blob: e3cce433ed710667530d452625cf07d13f26bcf8 [file] [log] [blame]
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001/* vi: set sw=4 ts=4: */
Eric Andersen6b6b3f61999-10-28 16:06:25 +00002/*
Mark Whitley6315ce62000-07-10 22:55:51 +00003 * sed.c - very minimalist version of sed
Eric Andersen6b6b3f61999-10-28 16:06:25 +00004 *
Eric Andersenbdfd0d72001-10-24 05:00:29 +00005 * Copyright (C) 1999,2000,2001 by Lineo, inc. and Mark Whitley
6 * Copyright (C) 1999,2000,2001 by Mark Whitley <markw@codepoet.org>
Matt Kraai5ed78ad2002-01-03 21:12:34 +00007 * Copyright (C) 2002 Matt Kraai
Denis Vlasenko0beaff82007-09-21 13:16:32 +00008 * Copyright (C) 2003 by Glenn McGrath
Rob Landley25d82392004-04-01 09:23:30 +00009 * Copyright (C) 2003,2004 by Rob Landley <rob@landley.net>
Erik Andersen1266a131999-12-29 22:19:46 +000010 *
Rob Landley2b26fd52006-02-24 02:30:39 +000011 * MAINTAINER: Rob Landley <rob@landley.net>
Bernhard Reutner-Fischerb7f39732006-03-01 20:14:16 +000012 *
Denys Vlasenko0ef64bd2010-08-16 20:14:46 +020013 * Licensed under GPLv2, see file LICENSE in this source tree.
Eric Andersen6b6b3f61999-10-28 16:06:25 +000014 */
15
Glenn L McGrathaa5a6022003-10-01 03:06:16 +000016/* Code overview.
Denys Vlasenko52d83702011-05-03 00:51:43 +020017 *
18 * Files are laid out to avoid unnecessary function declarations. So for
19 * example, every function add_cmd calls occurs before add_cmd in this file.
20 *
21 * add_cmd() is called on each line of sed command text (from a file or from
22 * the command line). It calls get_address() and parse_cmd_args(). The
23 * resulting sed_cmd_t structures are appended to a linked list
24 * (G.sed_cmd_head/G.sed_cmd_tail).
25 *
26 * add_input_file() adds a FILE* to the list of input files. We need to
27 * know all input sources ahead of time to find the last line for the $ match.
28 *
Denys Vlasenkoa221bc52011-09-13 18:40:22 +020029 * process_files() does actual sedding, reading data lines from each input FILE*
Denys Vlasenko52d83702011-05-03 00:51:43 +020030 * (which could be stdin) and applying the sed command list (sed_cmd_head) to
31 * each of the resulting lines.
32 *
33 * sed_main() is where external code calls into this, with a command line.
34 */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +000035
Denys Vlasenko52d83702011-05-03 00:51:43 +020036/* Supported features and commands in this version of sed:
37 *
38 * - comments ('#')
39 * - address matching: num|/matchstr/[,num|/matchstr/|$]command
40 * - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
41 * - edit commands: (a)ppend, (i)nsert, (c)hange
42 * - file commands: (r)ead
43 * - backreferences in substitution expressions (\0, \1, \2...\9)
44 * - grouped commands: {cmd1;cmd2}
45 * - transliteration (y/source-chars/dest-chars/)
46 * - pattern space hold space storing / swapping (g, h, x)
47 * - labels / branching (: label, b, t, T)
48 *
49 * (Note: Specifying an address (range) to match is *optional*; commands
50 * default to the whole pattern space if no specific address match was
51 * requested.)
52 *
53 * Todo:
54 * - Create a wrapper around regex to make libc's regex conform with sed
55 *
Mimi Li37a79c02012-07-24 13:20:12 +020056 * Reference
57 * http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
58 * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html
Denys Vlasenko52d83702011-05-03 00:51:43 +020059 */
Mark Whitley6315ce62000-07-10 22:55:51 +000060
Pere Orga6a3e01d2011-04-01 22:56:30 +020061//usage:#define sed_trivial_usage
Denys Vlasenkoa221bc52011-09-13 18:40:22 +020062//usage: "[-inr] [-f FILE]... [-e CMD]... [FILE]...\n"
63//usage: "or: sed [-inr] CMD [FILE]..."
Pere Orga6a3e01d2011-04-01 22:56:30 +020064//usage:#define sed_full_usage "\n\n"
Denys Vlasenko66426762011-06-05 03:58:28 +020065//usage: " -e CMD Add CMD to sed commands to be executed"
Pere Orga6a3e01d2011-04-01 22:56:30 +020066//usage: "\n -f FILE Add FILE contents to sed commands to be executed"
Simon B8c343952012-05-06 13:59:15 +020067//usage: "\n -i[SFX] Edit files in-place (otherwise sends to stdout)"
Denys Vlasenko1d7ad7a2012-06-21 09:45:11 +020068//usage: "\n Optionally back files up, appending SFX"
Pere Orga6a3e01d2011-04-01 22:56:30 +020069//usage: "\n -n Suppress automatic printing of pattern space"
70//usage: "\n -r Use extended regex syntax"
71//usage: "\n"
72//usage: "\nIf no -e or -f, the first non-option argument is the sed command string."
73//usage: "\nRemaining arguments are input files (stdin if none)."
74//usage:
75//usage:#define sed_example_usage
76//usage: "$ echo \"foo\" | sed -e 's/f[a-zA-Z]o/bar/g'\n"
77//usage: "bar\n"
78
Denis Vlasenkob6adbf12007-05-26 19:00:18 +000079#include "libbb.h"
"Vladimir N. Oleynik"23f62fc2005-09-14 16:59:11 +000080#include "xregex.h"
Mark Whitley6315ce62000-07-10 22:55:51 +000081
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +020082#if 0
83# define dbg(...) bb_error_msg(__VA_ARGS__)
84#else
85# define dbg(...) ((void)0)
86#endif
87
88
Denys Vlasenko2e284a42010-08-01 04:14:46 +020089enum {
90 OPT_in_place = 1 << 0,
91};
92
Rob Landleye3f5a3f2006-05-09 03:53:55 +000093/* Each sed command turns into one of these structures. */
Glenn L McGrathe7a8bc92003-03-09 10:23:57 +000094typedef struct sed_cmd_s {
Denis Vlasenkod18a3a22006-10-25 12:46:03 +000095 /* Ordered by alignment requirements: currently 36 bytes on x86 */
Denis Vlasenko34c4e5f2007-01-30 22:25:16 +000096 struct sed_cmd_s *next; /* Next command (linked list, NULL terminated) */
Mark Whitley2dc192f2000-11-03 19:47:00 +000097
Denis Vlasenkod18a3a22006-10-25 12:46:03 +000098 /* address storage */
99 regex_t *beg_match; /* sed -e '/match/cmd' */
100 regex_t *end_match; /* sed -e '/match/,/end_match/cmd' */
101 regex_t *sub_match; /* For 's/sub_match/string/' */
102 int beg_line; /* 'sed 1p' 0 == apply commands to all lines */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200103 int beg_line_orig; /* copy of the above, needed for -i */
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000104 int end_line; /* 'sed 1,3p' 0 == one line only. -1 = last line ($) */
Bernhard Reutner-Fischerb7f39732006-03-01 20:14:16 +0000105
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000106 FILE *sw_file; /* File (sw) command writes to, -1 for none. */
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000107 char *string; /* Data string for (saicytb) commands. */
Glenn L McGrathfc4cb4d2003-04-12 16:10:42 +0000108
Denis Vlasenko284d0fa2008-02-16 13:18:17 +0000109 unsigned which_match; /* (s) Which match to replace (0 for all) */
Glenn L McGrathfc4cb4d2003-04-12 16:10:42 +0000110
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000111 /* Bitfields (gcc won't group them if we don't) */
Denis Vlasenko34c4e5f2007-01-30 22:25:16 +0000112 unsigned invert:1; /* the '!' after the address */
113 unsigned in_match:1; /* Next line also included in match? */
114 unsigned sub_p:1; /* (s) print option */
Denis Vlasenko1375bc72006-12-02 20:12:12 +0000115
Denis Vlasenko34c4e5f2007-01-30 22:25:16 +0000116 char sw_last_char; /* Last line written by (sw) had no '\n' */
Glenn L McGrathc18ce372003-09-13 06:57:39 +0000117
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000118 /* GENERAL FIELDS */
119 char cmd; /* The command char: abcdDgGhHilnNpPqrstwxy:={} */
Glenn L McGrathe7a8bc92003-03-09 10:23:57 +0000120} sed_cmd_t;
Mark Whitley6315ce62000-07-10 22:55:51 +0000121
Denis Vlasenko6ca409e2007-08-12 20:58:27 +0000122static const char semicolon_whitespace[] ALIGN1 = "; \n\r\t\v";
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000123
Denis Vlasenko17a15262007-03-26 20:48:46 +0000124struct globals {
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000125 /* options */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000126 int be_quiet, regex_type;
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000127 FILE *nonstdout;
128 char *outname, *hold_space;
Glenn L McGrathbd9b32b2003-04-09 01:43:54 +0000129
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000130 /* List of input files */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000131 int input_file_count, current_input_file;
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000132 FILE **input_file_list;
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000133
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000134 regmatch_t regmatch[10];
135 regex_t *previous_regex_ptr;
Denis Vlasenko9213a9e2006-09-17 16:28:10 +0000136
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000137 /* linked list of sed commands */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200138 sed_cmd_t *sed_cmd_head, **sed_cmd_tail;
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000139
140 /* Linked list of append lines */
141 llist_t *append_head;
142
143 char *add_cmd_line;
144
145 struct pipeline {
Denys Vlasenkofb132e42010-10-29 11:46:52 +0200146 char *buf; /* Space to hold string */
147 int idx; /* Space used */
148 int len; /* Space allocated */
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000149 } pipeline;
Denys Vlasenko98a4c7c2010-02-04 15:00:15 +0100150} FIX_ALIASING;
Denis Vlasenko17a15262007-03-26 20:48:46 +0000151#define G (*(struct globals*)&bb_common_bufsiz1)
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +0200152struct BUG_G_too_big {
Denys Vlasenkob7c9fb22011-02-03 00:05:48 +0100153 char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +0200154};
Denis Vlasenko74324c82007-06-04 10:16:52 +0000155#define INIT_G() do { \
Denis Vlasenko74324c82007-06-04 10:16:52 +0000156 G.sed_cmd_tail = &G.sed_cmd_head; \
157} while (0)
158
Glenn L McGrathbd9b32b2003-04-09 01:43:54 +0000159
Bernhard Reutner-Fischerb7f39732006-03-01 20:14:16 +0000160#if ENABLE_FEATURE_CLEAN_UP
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000161static void sed_free_and_close_stuff(void)
Mark Whitley6315ce62000-07-10 22:55:51 +0000162{
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200163 sed_cmd_t *sed_cmd = G.sed_cmd_head;
Mark Whitley6315ce62000-07-10 22:55:51 +0000164
Denis Vlasenko17a15262007-03-26 20:48:46 +0000165 llist_free(G.append_head, free);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000166
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000167 while (sed_cmd) {
Glenn L McGrathbd9b32b2003-04-09 01:43:54 +0000168 sed_cmd_t *sed_cmd_next = sed_cmd->next;
Mark Whitley6315ce62000-07-10 22:55:51 +0000169
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000170 if (sed_cmd->sw_file)
171 xprint_and_close_file(sed_cmd->sw_file);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000172
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000173 if (sed_cmd->beg_match) {
174 regfree(sed_cmd->beg_match);
175 free(sed_cmd->beg_match);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000176 }
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000177 if (sed_cmd->end_match) {
178 regfree(sed_cmd->end_match);
179 free(sed_cmd->end_match);
Mark Whitley6315ce62000-07-10 22:55:51 +0000180 }
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000181 if (sed_cmd->sub_match) {
182 regfree(sed_cmd->sub_match);
183 free(sed_cmd->sub_match);
Mark Whitley6315ce62000-07-10 22:55:51 +0000184 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000185 free(sed_cmd->string);
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000186 free(sed_cmd);
187 sed_cmd = sed_cmd_next;
Mark Whitley6315ce62000-07-10 22:55:51 +0000188 }
Rob Landleyce4f0e92004-10-30 06:54:19 +0000189
Denis Vlasenko60818682007-09-28 22:07:23 +0000190 free(G.hold_space);
Rob Landleydcc28662004-11-25 07:21:47 +0000191
Denis Vlasenko17a15262007-03-26 20:48:46 +0000192 while (G.current_input_file < G.input_file_count)
193 fclose(G.input_file_list[G.current_input_file++]);
Mark Whitley6315ce62000-07-10 22:55:51 +0000194}
Denis Vlasenko666da5e2006-12-26 18:17:42 +0000195#else
196void sed_free_and_close_stuff(void);
Mark Whitleyc41e8c82000-07-12 23:35:21 +0000197#endif
Mark Whitley6315ce62000-07-10 22:55:51 +0000198
Rob Landley53302f82004-02-18 09:54:15 +0000199/* If something bad happens during -i operation, delete temp file */
200
201static void cleanup_outname(void)
202{
Denis Vlasenko17a15262007-03-26 20:48:46 +0000203 if (G.outname) unlink(G.outname);
Rob Landley53302f82004-02-18 09:54:15 +0000204}
205
Denis Vlasenko40276642007-11-13 16:48:10 +0000206/* strcpy, replacing "\from" with 'to'. If to is NUL, replacing "\any" with 'any' */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000207
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000208static void parse_escapes(char *dest, const char *string, int len, char from, char to)
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000209{
Denis Vlasenko80778502006-10-25 12:46:46 +0000210 int i = 0;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000211
Denis Vlasenko80778502006-10-25 12:46:46 +0000212 while (i < len) {
213 if (string[i] == '\\') {
214 if (!to || string[i+1] == from) {
Denis Vlasenko4ebaf102007-01-19 21:33:19 +0000215 *dest++ = to ? to : string[i+1];
Denis Vlasenko80778502006-10-25 12:46:46 +0000216 i += 2;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000217 continue;
Denis Vlasenko4ebaf102007-01-19 21:33:19 +0000218 }
219 *dest++ = string[i++];
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000220 }
Denis Vlasenko40276642007-11-13 16:48:10 +0000221 /* TODO: is it safe wrt a string with trailing '\\' ? */
Denis Vlasenko4ebaf102007-01-19 21:33:19 +0000222 *dest++ = string[i++];
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000223 }
Denis Vlasenko40276642007-11-13 16:48:10 +0000224 *dest = '\0';
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000225}
226
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000227static char *copy_parsing_escapes(const char *string, int len)
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000228{
Pascal Bellardd3e4be32011-05-05 00:26:37 +0200229 const char *s;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000230 char *dest = xmalloc(len + 1);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000231
Pascal Bellardd3e4be32011-05-05 00:26:37 +0200232 /* sed recognizes \n */
Denys Vlasenko6a0abcc2011-05-03 00:52:22 +0200233 /* GNU sed also recognizes \t and \r */
Pascal Bellardd3e4be32011-05-05 00:26:37 +0200234 for (s = "\nn\tt\rr"; *s; s += 2) {
235 parse_escapes(dest, string, len, s[1], s[0]);
236 string = dest;
237 len = strlen(dest);
238 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000239 return dest;
240}
241
242
Mark Whitley6315ce62000-07-10 22:55:51 +0000243/*
Eric Andersen28b3c532001-01-02 11:01:31 +0000244 * index_of_next_unescaped_regexp_delim - walks left to right through a string
245 * beginning at a specified index and returns the index of the next regular
Denis Vlasenko40276642007-11-13 16:48:10 +0000246 * expression delimiter (typically a forward slash ('/')) not preceded by
Rob Landley4795e4e2006-07-26 17:25:08 +0000247 * a backslash ('\'). A negative delimiter disables square bracket checking.
Mark Whitley6315ce62000-07-10 22:55:51 +0000248 */
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000249static int index_of_next_unescaped_regexp_delim(int delimiter, const char *str)
Mark Whitley6315ce62000-07-10 22:55:51 +0000250{
Matt Kraaia0065d52001-08-24 14:45:50 +0000251 int bracket = -1;
252 int escaped = 0;
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000253 int idx = 0;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000254 char ch;
Matt Kraaia0065d52001-08-24 14:45:50 +0000255
Rob Landley4795e4e2006-07-26 17:25:08 +0000256 if (delimiter < 0) {
257 bracket--;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000258 delimiter = -delimiter;
Rob Landley4795e4e2006-07-26 17:25:08 +0000259 }
260
Denys Vlasenko52d83702011-05-03 00:51:43 +0200261 for (; (ch = str[idx]) != '\0'; idx++) {
Rob Landley4795e4e2006-07-26 17:25:08 +0000262 if (bracket >= 0) {
Denys Vlasenko52d83702011-05-03 00:51:43 +0200263 if (ch == ']'
264 && !(bracket == idx - 1 || (bracket == idx - 2 && str[idx - 1] == '^'))
265 ) {
Matt Kraaia0065d52001-08-24 14:45:50 +0000266 bracket = -1;
Denys Vlasenko52d83702011-05-03 00:51:43 +0200267 }
Matt Kraaia0065d52001-08-24 14:45:50 +0000268 } else if (escaped)
269 escaped = 0;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000270 else if (ch == '\\')
Matt Kraaia0065d52001-08-24 14:45:50 +0000271 escaped = 1;
Rob Landley4795e4e2006-07-26 17:25:08 +0000272 else if (bracket == -1 && ch == '[')
Matt Kraaia0065d52001-08-24 14:45:50 +0000273 bracket = idx;
Glenn L McGrath1fb44672003-03-09 08:44:49 +0000274 else if (ch == delimiter)
Mark Whitley97562bd2000-07-17 20:06:42 +0000275 return idx;
276 }
Mark Whitley6315ce62000-07-10 22:55:51 +0000277
Mark Whitley97562bd2000-07-17 20:06:42 +0000278 /* if we make it to here, we've hit the end of the string */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000279 bb_error_msg_and_die("unmatched '%c'", delimiter);
Mark Whitley6315ce62000-07-10 22:55:51 +0000280}
281
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000282/*
283 * Returns the index of the third delimiter
284 */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000285static int parse_regex_delim(const char *cmdstr, char **match, char **replace)
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000286{
Denis Vlasenko9356b502007-01-29 23:44:38 +0000287 const char *cmdstr_ptr = cmdstr;
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100288 unsigned char delimiter;
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000289 int idx = 0;
290
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000291 /* verify that the 's' or 'y' is followed by something. That something
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000292 * (typically a 'slash') is now our regexp delimiter... */
Rob Landley4795e4e2006-07-26 17:25:08 +0000293 if (*cmdstr == '\0')
294 bb_error_msg_and_die("bad format in substitution expression");
Denis Vlasenko80778502006-10-25 12:46:46 +0000295 delimiter = *cmdstr_ptr++;
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000296
297 /* save the match string */
298 idx = index_of_next_unescaped_regexp_delim(delimiter, cmdstr_ptr);
Rob Landleyfae1dc82005-11-20 07:44:35 +0000299 *match = copy_parsing_escapes(cmdstr_ptr, idx);
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000300
301 /* save the replacement string */
302 cmdstr_ptr += idx + 1;
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100303 idx = index_of_next_unescaped_regexp_delim(- (int)delimiter, cmdstr_ptr);
Rob Landleyfae1dc82005-11-20 07:44:35 +0000304 *replace = copy_parsing_escapes(cmdstr_ptr, idx);
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000305
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000306 return ((cmdstr_ptr - cmdstr) + idx);
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000307}
308
Mark Whitley6315ce62000-07-10 22:55:51 +0000309/*
310 * returns the index in the string just past where the address ends.
311 */
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000312static int get_address(const char *my_str, int *linenum, regex_t ** regex)
Mark Whitley6315ce62000-07-10 22:55:51 +0000313{
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000314 const char *pos = my_str;
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000315
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000316 if (isdigit(*my_str)) {
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000317 *linenum = strtol(my_str, (char**)&pos, 10);
Glenn L McGrath1fb44672003-03-09 08:44:49 +0000318 /* endstr shouldnt ever equal NULL */
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000319 } else if (*my_str == '$') {
Mark Whitley0915c4b2001-06-11 23:50:06 +0000320 *linenum = -1;
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000321 pos++;
322 } else if (*my_str == '/' || *my_str == '\\') {
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000323 int next;
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000324 char delimiter;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000325 char *temp;
Glenn L McGrath1fb44672003-03-09 08:44:49 +0000326
Denis Vlasenko80778502006-10-25 12:46:46 +0000327 delimiter = '/';
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100328 if (*my_str == '\\')
329 delimiter = *++pos;
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000330 next = index_of_next_unescaped_regexp_delim(delimiter, ++pos);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000331 temp = copy_parsing_escapes(pos, next);
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100332 *regex = xzalloc(sizeof(regex_t));
Denys Vlasenkob0e9b722013-07-21 22:09:44 +0200333 xregcomp(*regex, temp, G.regex_type);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000334 free(temp);
335 /* Move position to next character after last delimiter */
Rob Landley4795e4e2006-07-26 17:25:08 +0000336 pos += (next+1);
Mark Whitley6315ce62000-07-10 22:55:51 +0000337 }
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000338 return pos - my_str;
Mark Whitley6315ce62000-07-10 22:55:51 +0000339}
Erik Andersene49d5ec2000-02-08 19:58:47 +0000340
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000341/* Grab a filename. Whitespace at start is skipped, then goes to EOL. */
Denis Vlasenko68404f12008-03-17 09:00:54 +0000342static int parse_file_cmd(/*sed_cmd_t *sed_cmd,*/ const char *filecmdstr, char **retval)
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000343{
Denis Vlasenko80778502006-10-25 12:46:46 +0000344 int start = 0, idx, hack = 0;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000345
346 /* Skip whitespace, then grab filename to end of line */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000347 while (isspace(filecmdstr[start]))
348 start++;
Denis Vlasenko80778502006-10-25 12:46:46 +0000349 idx = start;
Denis Vlasenko9356b502007-01-29 23:44:38 +0000350 while (filecmdstr[idx] && filecmdstr[idx] != '\n')
351 idx++;
Denis Vlasenko80778502006-10-25 12:46:46 +0000352
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000353 /* If lines glued together, put backslash back. */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000354 if (filecmdstr[idx] == '\n')
355 hack = 1;
Denis Vlasenko80778502006-10-25 12:46:46 +0000356 if (idx == start)
357 bb_error_msg_and_die("empty filename");
Rob Landleyd921b2e2006-08-03 15:41:12 +0000358 *retval = xstrndup(filecmdstr+start, idx-start+hack+1);
Denis Vlasenko9356b502007-01-29 23:44:38 +0000359 if (hack)
360 (*retval)[idx] = '\\';
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000361
362 return idx;
363}
364
Denis Vlasenko9356b502007-01-29 23:44:38 +0000365static int parse_subst_cmd(sed_cmd_t *sed_cmd, const char *substr)
Mark Whitley06f35292000-07-13 19:58:04 +0000366{
Denis Vlasenko17a15262007-03-26 20:48:46 +0000367 int cflags = G.regex_type;
Mark Whitley06f35292000-07-13 19:58:04 +0000368 char *match;
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000369 int idx;
Mark Whitley06f35292000-07-13 19:58:04 +0000370
371 /*
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000372 * A substitution command should look something like this:
373 * s/match/replace/ #gIpw
Mark Whitley0e4cec02000-08-21 21:29:20 +0000374 * || | |||
Mark Whitley06f35292000-07-13 19:58:04 +0000375 * mandatory optional
Mark Whitley06f35292000-07-13 19:58:04 +0000376 */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000377 idx = parse_regex_delim(substr, &match, &sed_cmd->string);
Mark Whitley06f35292000-07-13 19:58:04 +0000378
Mark Whitley97562bd2000-07-17 20:06:42 +0000379 /* determine the number of back references in the match string */
380 /* Note: we compute this here rather than in the do_subst_command()
381 * function to save processor time, at the expense of a little more memory
382 * (4 bits) per sed_cmd */
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000383
Mark Whitley06f35292000-07-13 19:58:04 +0000384 /* process the flags */
Mark Whitley70705d72000-07-14 19:06:30 +0000385
Denis Vlasenko80778502006-10-25 12:46:46 +0000386 sed_cmd->which_match = 1;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000387 while (substr[++idx]) {
388 /* Parse match number */
Denis Vlasenko80778502006-10-25 12:46:46 +0000389 if (isdigit(substr[idx])) {
390 if (match[0] != '^') {
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000391 /* Match 0 treated as all, multiple matches we take the last one. */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000392 const char *pos = substr + idx;
393/* FIXME: error check? */
Denis Vlasenko284d0fa2008-02-16 13:18:17 +0000394 sed_cmd->which_match = (unsigned)strtol(substr+idx, (char**) &pos, 10);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000395 idx = pos - substr;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000396 }
397 continue;
398 }
Rob Landley40ec4ae2004-01-04 06:42:14 +0000399 /* Skip spaces */
Denys Vlasenko6935ec92009-10-22 19:42:26 +0200400 if (isspace(substr[idx]))
401 continue;
Rob Landley40ec4ae2004-01-04 06:42:14 +0000402
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000403 switch (substr[idx]) {
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000404 /* Replace all occurrences */
405 case 'g':
Denis Vlasenko284d0fa2008-02-16 13:18:17 +0000406 if (match[0] != '^')
407 sed_cmd->which_match = 0;
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000408 break;
409 /* Print pattern space */
410 case 'p':
411 sed_cmd->sub_p = 1;
412 break;
413 /* Write to file */
414 case 'w':
415 {
416 char *temp;
Denis Vlasenko68404f12008-03-17 09:00:54 +0000417 idx += parse_file_cmd(/*sed_cmd,*/ substr+idx, &temp);
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000418 break;
419 }
420 /* Ignore case (gnu exension) */
421 case 'I':
422 cflags |= REG_ICASE;
423 break;
424 /* Comment */
425 case '#':
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +0200426 // while (substr[++idx]) continue;
427 idx += strlen(substr + idx); // same
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000428 /* Fall through */
429 /* End of command */
430 case ';':
431 case '}':
432 goto out;
433 default:
434 bb_error_msg_and_die("bad option in substitution expression");
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000435 }
436 }
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +0200437 out:
Mark Whitley97562bd2000-07-17 20:06:42 +0000438 /* compile the match string into a regex */
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000439 if (*match != '\0') {
440 /* If match is empty, we use last regex used at runtime */
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100441 sed_cmd->sub_match = xzalloc(sizeof(regex_t));
442 dbg("xregcomp('%s',%x)", match, cflags);
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000443 xregcomp(sed_cmd->sub_match, match, cflags);
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100444 dbg("regcomp ok");
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000445 }
Mark Whitley06f35292000-07-13 19:58:04 +0000446 free(match);
Mark Whitley70705d72000-07-14 19:06:30 +0000447
448 return idx;
Mark Whitley06f35292000-07-13 19:58:04 +0000449}
450
Glenn L McGrath2971ef12003-03-18 01:19:23 +0000451/*
452 * Process the commands arguments
453 */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000454static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
Mark Whitley6315ce62000-07-10 22:55:51 +0000455{
Denys Vlasenko52d83702011-05-03 00:51:43 +0200456 static const char cmd_letters[] = "saicrw:btTydDgGhHlnNpPqx={}";
457 enum {
458 IDX_s = 0,
459 IDX_a,
460 IDX_i,
461 IDX_c,
462 IDX_r,
463 IDX_w,
464 IDX_colon,
465 IDX_b,
466 IDX_t,
467 IDX_T,
468 IDX_y,
469 IDX_d,
470 IDX_D,
471 IDX_g,
472 IDX_G,
473 IDX_h,
474 IDX_H,
475 IDX_l,
476 IDX_n,
477 IDX_N,
478 IDX_p,
479 IDX_P,
480 IDX_q,
481 IDX_x,
482 IDX_equal,
483 IDX_lbrace,
484 IDX_rbrace,
485 IDX_nul
486 };
487 struct chk { char chk[sizeof(cmd_letters)-1 == IDX_nul ? 1 : -1]; };
488
489 unsigned idx = strchrnul(cmd_letters, sed_cmd->cmd) - cmd_letters;
490
Glenn L McGrath2f8a4012003-03-09 02:44:49 +0000491 /* handle (s)ubstitution command */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200492 if (idx == IDX_s) {
Denis Vlasenko80778502006-10-25 12:46:46 +0000493 cmdstr += parse_subst_cmd(sed_cmd, cmdstr);
Denys Vlasenko52d83702011-05-03 00:51:43 +0200494 }
Glenn L McGrath2f8a4012003-03-09 02:44:49 +0000495 /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200496 else if (idx <= IDX_c) { /* a,i,c */
Mimi Li37a79c02012-07-24 13:20:12 +0200497 if (idx < IDX_c) { /* a,i */
498 if (sed_cmd->end_line || sed_cmd->end_match)
499 bb_error_msg_and_die("command '%c' uses only one address", sed_cmd->cmd);
500 }
Denis Vlasenko80778502006-10-25 12:46:46 +0000501 for (;;) {
502 if (*cmdstr == '\n' || *cmdstr == '\\') {
Rob Landley25d82392004-04-01 09:23:30 +0000503 cmdstr++;
504 break;
Denys Vlasenkoc0dab372009-10-22 22:28:08 +0200505 }
506 if (!isspace(*cmdstr))
Denis Vlasenko80778502006-10-25 12:46:46 +0000507 break;
Denys Vlasenkoc0dab372009-10-22 22:28:08 +0200508 cmdstr++;
Rob Landley25d82392004-04-01 09:23:30 +0000509 }
Rob Landleyd921b2e2006-08-03 15:41:12 +0000510 sed_cmd->string = xstrdup(cmdstr);
Denis Vlasenko40276642007-11-13 16:48:10 +0000511 /* "\anychar" -> "anychar" */
512 parse_escapes(sed_cmd->string, sed_cmd->string, strlen(cmdstr), '\0', '\0');
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000513 cmdstr += strlen(cmdstr);
Denys Vlasenko52d83702011-05-03 00:51:43 +0200514 }
Glenn L McGrath2f8a4012003-03-09 02:44:49 +0000515 /* handle file cmds: (r)ead */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200516 else if (idx <= IDX_w) { /* r,w */
Mimi Li37a79c02012-07-24 13:20:12 +0200517 if (idx < IDX_w) { /* r */
518 if (sed_cmd->end_line || sed_cmd->end_match)
519 bb_error_msg_and_die("command '%c' uses only one address", sed_cmd->cmd);
520 }
Denis Vlasenko68404f12008-03-17 09:00:54 +0000521 cmdstr += parse_file_cmd(/*sed_cmd,*/ cmdstr, &sed_cmd->string);
Denis Vlasenkoc562bb72007-01-29 17:08:51 +0000522 if (sed_cmd->cmd == 'w') {
Denis Vlasenko5415c852008-07-21 23:05:26 +0000523 sed_cmd->sw_file = xfopen_for_write(sed_cmd->string);
Denis Vlasenkoc562bb72007-01-29 17:08:51 +0000524 sed_cmd->sw_last_char = '\n';
525 }
Denys Vlasenko52d83702011-05-03 00:51:43 +0200526 }
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000527 /* handle branch commands */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200528 else if (idx <= IDX_T) { /* :,b,t,T */
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000529 int length;
530
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000531 cmdstr = skip_whitespace(cmdstr);
Glenn L McGrathf4523562003-09-14 06:01:14 +0000532 length = strcspn(cmdstr, semicolon_whitespace);
533 if (length) {
Rob Landleyd921b2e2006-08-03 15:41:12 +0000534 sed_cmd->string = xstrndup(cmdstr, length);
Glenn L McGrathf4523562003-09-14 06:01:14 +0000535 cmdstr += length;
536 }
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000537 }
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000538 /* translation command */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200539 else if (idx == IDX_y) {
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000540 char *match, *replace;
Denis Vlasenko80778502006-10-25 12:46:46 +0000541 int i = cmdstr[0];
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000542
Denis Vlasenko80778502006-10-25 12:46:46 +0000543 cmdstr += parse_regex_delim(cmdstr, &match, &replace)+1;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000544 /* \n already parsed, but \delimiter needs unescaping. */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000545 parse_escapes(match, match, strlen(match), i, i);
546 parse_escapes(replace, replace, strlen(replace), i, i);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000547
Rob Landley9ffd4232006-05-21 18:30:35 +0000548 sed_cmd->string = xzalloc((strlen(match) + 1) * 2);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000549 for (i = 0; match[i] && replace[i]; i++) {
Denis Vlasenko80778502006-10-25 12:46:46 +0000550 sed_cmd->string[i*2] = match[i];
551 sed_cmd->string[i*2+1] = replace[i];
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000552 }
553 free(match);
554 free(replace);
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000555 }
Glenn L McGrath2971ef12003-03-18 01:19:23 +0000556 /* if it wasnt a single-letter command that takes no arguments
557 * then it must be an invalid command.
558 */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200559 else if (idx >= IDX_nul) { /* not d,D,g,G,h,H,l,n,N,p,P,q,x,=,{,} */
Denis Vlasenko80778502006-10-25 12:46:46 +0000560 bb_error_msg_and_die("unsupported command %c", sed_cmd->cmd);
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000561 }
Mark Whitley70705d72000-07-14 19:06:30 +0000562
563 /* give back whatever's left over */
Denis Vlasenko80778502006-10-25 12:46:46 +0000564 return cmdstr;
Eric Andersen50d63601999-11-09 01:47:36 +0000565}
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000566
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000567
568/* Parse address+command sets, skipping comment lines. */
569
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000570static void add_cmd(const char *cmdstr)
Erik Andersen1266a131999-12-29 22:19:46 +0000571{
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000572 sed_cmd_t *sed_cmd;
Denys Vlasenkoa2215b92010-05-12 01:49:04 +0200573 unsigned len, n;
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000574
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000575 /* Append this line to any unfinished line from last time. */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000576 if (G.add_cmd_line) {
577 char *tp = xasprintf("%s\n%s", G.add_cmd_line, cmdstr);
578 free(G.add_cmd_line);
Denis Vlasenko945bd3d2007-04-12 21:20:25 +0000579 cmdstr = G.add_cmd_line = tp;
Rob Landley12d87552006-06-05 17:32:44 +0000580 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000581
Denys Vlasenkoa2215b92010-05-12 01:49:04 +0200582 /* If this line ends with unescaped backslash, request next line. */
583 n = len = strlen(cmdstr);
584 while (n && cmdstr[n-1] == '\\')
585 n--;
586 if ((len - n) & 1) { /* if odd number of trailing backslashes */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000587 if (!G.add_cmd_line)
588 G.add_cmd_line = xstrdup(cmdstr);
Denys Vlasenkoa2215b92010-05-12 01:49:04 +0200589 G.add_cmd_line[len-1] = '\0';
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000590 return;
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000591 }
Mark Whitley6315ce62000-07-10 22:55:51 +0000592
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000593 /* Loop parsing all commands in this line. */
Denis Vlasenko80778502006-10-25 12:46:46 +0000594 while (*cmdstr) {
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000595 /* Skip leading whitespace and semicolons */
596 cmdstr += strspn(cmdstr, semicolon_whitespace);
597
598 /* If no more commands, exit. */
Denis Vlasenko80778502006-10-25 12:46:46 +0000599 if (!*cmdstr) break;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000600
601 /* if this is a comment, jump past it and keep going */
602 if (*cmdstr == '#') {
603 /* "#n" is the same as using -n on the command line */
Denis Vlasenko80778502006-10-25 12:46:46 +0000604 if (cmdstr[1] == 'n')
Denis Vlasenko17a15262007-03-26 20:48:46 +0000605 G.be_quiet++;
Denis Vlasenko80778502006-10-25 12:46:46 +0000606 cmdstr = strpbrk(cmdstr, "\n\r");
607 if (!cmdstr) break;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000608 continue;
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000609 }
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000610
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000611 /* parse the command
612 * format is: [addr][,addr][!]cmd
613 * |----||-----||-|
614 * part1 part2 part3
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000615 */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000616
Rob Landley9ffd4232006-05-21 18:30:35 +0000617 sed_cmd = xzalloc(sizeof(sed_cmd_t));
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000618
619 /* first part (if present) is an address: either a '$', a number or a /regex/ */
620 cmdstr += get_address(cmdstr, &sed_cmd->beg_line, &sed_cmd->beg_match);
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200621 sed_cmd->beg_line_orig = sed_cmd->beg_line;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000622
623 /* second part (if present) will begin with a comma */
624 if (*cmdstr == ',') {
625 int idx;
626
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000627 cmdstr++;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000628 idx = get_address(cmdstr, &sed_cmd->end_line, &sed_cmd->end_match);
Denis Vlasenko80778502006-10-25 12:46:46 +0000629 if (!idx)
630 bb_error_msg_and_die("no address after comma");
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000631 cmdstr += idx;
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000632 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000633
634 /* skip whitespace before the command */
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000635 cmdstr = skip_whitespace(cmdstr);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000636
637 /* Check for inversion flag */
638 if (*cmdstr == '!') {
639 sed_cmd->invert = 1;
640 cmdstr++;
641
642 /* skip whitespace before the command */
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000643 cmdstr = skip_whitespace(cmdstr);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000644 }
645
646 /* last part (mandatory) will be a command */
Denis Vlasenko80778502006-10-25 12:46:46 +0000647 if (!*cmdstr)
648 bb_error_msg_and_die("missing command");
Denys Vlasenkoa2215b92010-05-12 01:49:04 +0200649 sed_cmd->cmd = *cmdstr++;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000650 cmdstr = parse_cmd_args(sed_cmd, cmdstr);
651
Denys Vlasenkoe93d1562013-07-08 01:43:40 +0200652 /* cmdstr now points past args.
653 * GNU sed requires a separator, if there are more commands,
654 * else it complains "char N: extra characters after command".
655 * Example: "sed 'p;d'". We also allow "sed 'pd'".
656 */
657
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000658 /* Add the command to the command array */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200659 *G.sed_cmd_tail = sed_cmd;
660 G.sed_cmd_tail = &sed_cmd->next;
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000661 }
662
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000663 /* If we glued multiple lines together, free the memory. */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000664 free(G.add_cmd_line);
665 G.add_cmd_line = NULL;
Mark Whitley6315ce62000-07-10 22:55:51 +0000666}
667
Rob Landleydcc28662004-11-25 07:21:47 +0000668/* Append to a string, reallocating memory as necessary. */
669
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000670#define PIPE_GROW 64
Eric Andersenc52a6b02001-11-10 10:49:42 +0000671
Eric Andersen14f5c8d2005-04-16 19:39:00 +0000672static void pipe_putc(char c)
Eric Andersenc52a6b02001-11-10 10:49:42 +0000673{
Denis Vlasenko17a15262007-03-26 20:48:46 +0000674 if (G.pipeline.idx == G.pipeline.len) {
675 G.pipeline.buf = xrealloc(G.pipeline.buf,
676 G.pipeline.len + PIPE_GROW);
677 G.pipeline.len += PIPE_GROW;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000678 }
Denis Vlasenko17a15262007-03-26 20:48:46 +0000679 G.pipeline.buf[G.pipeline.idx++] = c;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000680}
681
Rob Landley4795e4e2006-07-26 17:25:08 +0000682static void do_subst_w_backrefs(char *line, char *replace)
Mark Whitley97562bd2000-07-17 20:06:42 +0000683{
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200684 int i, j;
Mark Whitley97562bd2000-07-17 20:06:42 +0000685
686 /* go through the replacement string */
687 for (i = 0; replace[i]; i++) {
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200688 /* if we find a backreference (\1, \2, etc.) print the backref'ed text */
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000689 if (replace[i] == '\\') {
690 unsigned backref = replace[++i] - '0';
691 if (backref <= 9) {
Denis Vlasenko17a15262007-03-26 20:48:46 +0000692 /* print out the text held in G.regmatch[backref] */
693 if (G.regmatch[backref].rm_so != -1) {
694 j = G.regmatch[backref].rm_so;
695 while (j < G.regmatch[backref].rm_eo)
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000696 pipe_putc(line[j++]);
697 }
698 continue;
Denis Vlasenko80778502006-10-25 12:46:46 +0000699 }
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000700 /* I _think_ it is impossible to get '\' to be
701 * the last char in replace string. Thus we dont check
702 * for replace[i] == NUL. (counterexample anyone?) */
703 /* if we find a backslash escaped character, print the character */
704 pipe_putc(replace[i]);
705 continue;
Mark Whitley97562bd2000-07-17 20:06:42 +0000706 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000707 /* if we find an unescaped '&' print out the whole matched text. */
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000708 if (replace[i] == '&') {
Denis Vlasenko17a15262007-03-26 20:48:46 +0000709 j = G.regmatch[0].rm_so;
710 while (j < G.regmatch[0].rm_eo)
Denis Vlasenko80778502006-10-25 12:46:46 +0000711 pipe_putc(line[j++]);
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000712 continue;
Denis Vlasenko80778502006-10-25 12:46:46 +0000713 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000714 /* Otherwise just output the character. */
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000715 pipe_putc(replace[i]);
Mark Whitley97562bd2000-07-17 20:06:42 +0000716 }
717}
718
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200719static int do_subst_command(sed_cmd_t *sed_cmd, char **line_p)
Mark Whitley4f7fe772000-07-13 20:01:58 +0000720{
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200721 char *line = *line_p;
Denis Vlasenko77ad97f2008-05-13 02:27:31 +0000722 unsigned match_count = 0;
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200723 bool altered = 0;
724 bool prev_match_empty = 1;
725 bool tried_at_eol = 0;
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000726 regex_t *current_regex;
727
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200728 current_regex = sed_cmd->sub_match;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000729 /* Handle empty regex. */
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200730 if (!current_regex) {
Denis Vlasenko17a15262007-03-26 20:48:46 +0000731 current_regex = G.previous_regex_ptr;
Denis Vlasenko80778502006-10-25 12:46:46 +0000732 if (!current_regex)
Denis Vlasenkod3d004d2006-10-27 09:02:31 +0000733 bb_error_msg_and_die("no previous regexp");
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200734 }
735 G.previous_regex_ptr = current_regex;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000736
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000737 /* Find the first match */
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100738 dbg("matching '%s'", line);
739 if (REG_NOMATCH == regexec(current_regex, line, 10, G.regmatch, 0)) {
740 dbg("no match");
Mark Whitley2dc192f2000-11-03 19:47:00 +0000741 return 0;
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100742 }
743 dbg("match");
Mark Whitley2dc192f2000-11-03 19:47:00 +0000744
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000745 /* Initialize temporary output buffer. */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000746 G.pipeline.buf = xmalloc(PIPE_GROW);
747 G.pipeline.len = PIPE_GROW;
748 G.pipeline.idx = 0;
Mark Whitley2dc192f2000-11-03 19:47:00 +0000749
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000750 /* Now loop through, substituting for matches */
751 do {
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200752 int start = G.regmatch[0].rm_so;
753 int end = G.regmatch[0].rm_eo;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000754 int i;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000755
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000756 match_count++;
757
758 /* If we aren't interested in this match, output old line to
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200759 * end of match and continue */
Denis Vlasenko77ad97f2008-05-13 02:27:31 +0000760 if (sed_cmd->which_match
761 && (sed_cmd->which_match != match_count)
762 ) {
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200763 for (i = 0; i < end; i++)
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200764 pipe_putc(*line++);
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200765 /* Null match? Print one more char */
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200766 if (start == end && *line)
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200767 pipe_putc(*line++);
Denys Vlasenkob84dafb2012-04-24 19:27:34 +0200768 goto next;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000769 }
770
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200771 /* Print everything before the match */
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200772 for (i = 0; i < start; i++)
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200773 pipe_putc(line[i]);
Mark Whitley97562bd2000-07-17 20:06:42 +0000774
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200775 /* Then print the substitution string,
776 * unless we just matched empty string after non-empty one.
777 * Example: string "cccd", pattern "c*", repl "R":
778 * result is "RdR", not "RRdR": first match "ccc",
779 * second is "" before "d", third is "" after "d".
780 * Second match is NOT replaced!
781 */
Denys Vlasenko84406e42012-06-07 16:34:57 +0200782 if (prev_match_empty || start != 0 || start != end) {
Denys Vlasenko37ca36a2012-06-08 10:25:31 +0200783 //dbg("%d %d %d", prev_match_empty, start, end);
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200784 dbg("inserting replacement at %d in '%s'", start, line);
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200785 do_subst_w_backrefs(line, sed_cmd->string);
Denys Vlasenko37ca36a2012-06-08 10:25:31 +0200786 /* Flag that something has changed */
787 altered = 1;
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200788 } else {
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200789 dbg("NOT inserting replacement at %d in '%s'", start, line);
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200790 }
Mark Whitley97562bd2000-07-17 20:06:42 +0000791
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200792 /* If matched string is empty (f.e. "c*" pattern),
793 * copy verbatim one char after it before attempting more matches
794 */
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200795 prev_match_empty = (start == end);
Denys Vlasenko37ca36a2012-06-08 10:25:31 +0200796 if (prev_match_empty) {
797 if (!line[end]) {
798 tried_at_eol = 1;
799 } else {
800 pipe_putc(line[end]);
801 end++;
802 }
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200803 }
804
805 /* Advance past the match */
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200806 dbg("line += %d", end);
807 line += end;
Mark Whitley97562bd2000-07-17 20:06:42 +0000808
Mark Whitley2dc192f2000-11-03 19:47:00 +0000809 /* if we're not doing this globally, get out now */
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100810 if (sed_cmd->which_match != 0)
811 break;
Denys Vlasenkob84dafb2012-04-24 19:27:34 +0200812 next:
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200813 /* Exit if we are at EOL and already tried matching at it */
814 if (*line == '\0') {
815 if (tried_at_eol)
816 break;
817 tried_at_eol = 1;
818 }
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200819
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200820//maybe (end ? REG_NOTBOL : 0) instead of unconditional REG_NOTBOL?
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100821 } while (regexec(current_regex, line, 10, G.regmatch, REG_NOTBOL) != REG_NOMATCH);
Mark Whitley2dc192f2000-11-03 19:47:00 +0000822
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000823 /* Copy rest of string into output pipeline */
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200824 while (1) {
825 char c = *line++;
826 pipe_putc(c);
827 if (c == '\0')
828 break;
829 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000830
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200831 free(*line_p);
832 *line_p = G.pipeline.buf;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000833 return altered;
834}
Mark Whitley6315ce62000-07-10 22:55:51 +0000835
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000836/* Set command pointer to point to this label. (Does not handle null label.) */
Rob Landley4795e4e2006-07-26 17:25:08 +0000837static sed_cmd_t *branch_to(char *label)
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000838{
839 sed_cmd_t *sed_cmd;
Glenn L McGrathd4185b02003-04-11 17:10:23 +0000840
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200841 for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
Denis Vlasenko80778502006-10-25 12:46:46 +0000842 if (sed_cmd->cmd == ':' && sed_cmd->string && !strcmp(sed_cmd->string, label)) {
843 return sed_cmd;
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000844 }
845 }
Denis Vlasenko80778502006-10-25 12:46:46 +0000846 bb_error_msg_and_die("can't find label for jump to '%s'", label);
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000847}
Mark Whitley6315ce62000-07-10 22:55:51 +0000848
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000849static void append(char *s)
850{
Denys Vlasenko9d46a7a2013-10-30 10:22:47 +0100851 llist_add_to_end(&G.append_head, s);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000852}
853
854static void flush_append(void)
855{
Rob Landley0b656282006-05-08 22:17:23 +0000856 char *data;
857
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000858 /* Output appended lines. */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000859 while ((data = (char *)llist_pop(&G.append_head))) {
860 fprintf(G.nonstdout, "%s\n", data);
Rob Landley0b656282006-05-08 22:17:23 +0000861 free(data);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000862 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000863}
864
Eric Andersen14f5c8d2005-04-16 19:39:00 +0000865static void add_input_file(FILE *file)
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000866{
Denis Vlasenkodeeed592008-07-08 05:14:36 +0000867 G.input_file_list = xrealloc_vector(G.input_file_list, 2, G.input_file_count);
Denis Vlasenko17a15262007-03-26 20:48:46 +0000868 G.input_file_list[G.input_file_count++] = file;
Rob Landleydcc28662004-11-25 07:21:47 +0000869}
870
Denis Vlasenko17a15262007-03-26 20:48:46 +0000871/* Get next line of input from G.input_file_list, flushing append buffer and
Rob Landleydcc28662004-11-25 07:21:47 +0000872 * noting if we ran out of files without a newline on the last line we read.
873 */
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000874enum {
875 NO_EOL_CHAR = 1,
Denis Vlasenko86811802007-01-29 17:10:19 +0000876 LAST_IS_NUL = 2,
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000877};
878static char *get_next_line(char *gets_char)
Rob Landleydcc28662004-11-25 07:21:47 +0000879{
Denis Vlasenko80778502006-10-25 12:46:46 +0000880 char *temp = NULL;
Denis Vlasenkoc562bb72007-01-29 17:08:51 +0000881 int len;
882 char gc;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000883
884 flush_append();
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000885
886 /* will be returned if last line in the file
887 * doesn't end with either '\n' or '\0' */
888 gc = NO_EOL_CHAR;
Denis Vlasenko17a15262007-03-26 20:48:46 +0000889 while (G.current_input_file < G.input_file_count) {
890 FILE *fp = G.input_file_list[G.current_input_file];
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000891 /* Read line up to a newline or NUL byte, inclusive,
892 * return malloc'ed char[]. length of the chunk read
893 * is stored in len. NULL if EOF/error */
Denis Vlasenko86811802007-01-29 17:10:19 +0000894 temp = bb_get_chunk_from_file(fp, &len);
Rob Landley2b26fd52006-02-24 02:30:39 +0000895 if (temp) {
Denis Vlasenko8b22b072006-12-02 17:58:10 +0000896 /* len > 0 here, it's ok to do temp[len-1] */
897 char c = temp[len-1];
898 if (c == '\n' || c == '\0') {
899 temp[len-1] = '\0';
Denis Vlasenkoc562bb72007-01-29 17:08:51 +0000900 gc = c;
Denis Vlasenko86811802007-01-29 17:10:19 +0000901 if (c == '\0') {
902 int ch = fgetc(fp);
903 if (ch != EOF)
904 ungetc(ch, fp);
905 else
906 gc = LAST_IS_NUL;
907 }
Denis Vlasenko8b22b072006-12-02 17:58:10 +0000908 }
Denis Vlasenkoc562bb72007-01-29 17:08:51 +0000909 /* else we put NO_EOL_CHAR into *gets_char */
910 break;
911
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000912 /* NB: I had the idea of peeking next file(s) and returning
913 * NO_EOL_CHAR only if it is the *last* non-empty
914 * input file. But there is a case where this won't work:
915 * file1: "a woo\nb woo"
916 * file2: "c no\nd no"
917 * sed -ne 's/woo/bang/p' input1 input2 => "a bang\nb bang"
918 * (note: *no* newline after "b bang"!) */
Denis Vlasenko8b22b072006-12-02 17:58:10 +0000919 }
920 /* Close this file and advance to next one */
Denis Vlasenko86811802007-01-29 17:10:19 +0000921 fclose(fp);
Denis Vlasenko17a15262007-03-26 20:48:46 +0000922 G.current_input_file++;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000923 }
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000924 *gets_char = gc;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000925 return temp;
926}
927
Denis Vlasenko8b22b072006-12-02 17:58:10 +0000928/* Output line of text. */
929/* Note:
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000930 * The tricks with NO_EOL_CHAR and last_puts_char are there to emulate gnu sed.
Denis Vlasenko1375bc72006-12-02 20:12:12 +0000931 * Without them, we had this:
Denis Vlasenko8b22b072006-12-02 17:58:10 +0000932 * echo -n thingy >z1
933 * echo -n again >z2
934 * >znull
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000935 * sed "s/i/z/" z1 z2 znull | hexdump -vC
936 * output:
Denis Vlasenko8b22b072006-12-02 17:58:10 +0000937 * gnu sed 4.1.5:
938 * 00000000 74 68 7a 6e 67 79 0a 61 67 61 7a 6e |thzngy.agazn|
939 * bbox:
940 * 00000000 74 68 7a 6e 67 79 61 67 61 7a 6e |thzngyagazn|
Denis Vlasenko8b22b072006-12-02 17:58:10 +0000941 */
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000942static void puts_maybe_newline(char *s, FILE *file, char *last_puts_char, char last_gets_char)
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000943{
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000944 char lpc = *last_puts_char;
Denis Vlasenko1375bc72006-12-02 20:12:12 +0000945
Denis Vlasenko86811802007-01-29 17:10:19 +0000946 /* Need to insert a '\n' between two files because first file's
947 * last line wasn't terminated? */
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000948 if (lpc != '\n' && lpc != '\0') {
Denis Vlasenko1375bc72006-12-02 20:12:12 +0000949 fputc('\n', file);
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000950 lpc = '\n';
Denis Vlasenko1375bc72006-12-02 20:12:12 +0000951 }
Denis Vlasenko8b22b072006-12-02 17:58:10 +0000952 fputs(s, file);
Denis Vlasenko86811802007-01-29 17:10:19 +0000953
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000954 /* 'x' - just something which is not '\n', '\0' or NO_EOL_CHAR */
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000955 if (s[0])
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000956 lpc = 'x';
Denis Vlasenko86811802007-01-29 17:10:19 +0000957
958 /* had trailing '\0' and it was last char of file? */
959 if (last_gets_char == LAST_IS_NUL) {
960 fputc('\0', file);
961 lpc = 'x'; /* */
962 } else
963 /* had trailing '\n' or '\0'? */
964 if (last_gets_char != NO_EOL_CHAR) {
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000965 fputc(last_gets_char, file);
966 lpc = last_gets_char;
Denis Vlasenko1375bc72006-12-02 20:12:12 +0000967 }
Denis Vlasenko86811802007-01-29 17:10:19 +0000968
Denis Vlasenko80778502006-10-25 12:46:46 +0000969 if (ferror(file)) {
Denis Vlasenko40920822006-10-03 20:28:06 +0000970 xfunc_error_retval = 4; /* It's what gnu sed exits with... */
Bernhard Reutner-Fischera3d4bf32006-06-03 21:40:11 +0000971 bb_error_msg_and_die(bb_msg_write_error);
Rob Landley53302f82004-02-18 09:54:15 +0000972 }
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000973 *last_puts_char = lpc;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000974}
975
Denis Vlasenko17a15262007-03-26 20:48:46 +0000976#define sed_puts(s, n) (puts_maybe_newline(s, G.nonstdout, &last_puts_char, n))
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000977
Denis Vlasenko8274e062007-08-06 03:41:08 +0000978static int beg_match(sed_cmd_t *sed_cmd, const char *pattern_space)
979{
980 int retval = sed_cmd->beg_match && !regexec(sed_cmd->beg_match, pattern_space, 0, NULL, 0);
981 if (retval)
982 G.previous_regex_ptr = sed_cmd->beg_match;
983 return retval;
984}
985
Rob Landley2b26fd52006-02-24 02:30:39 +0000986/* Process all the lines in all the files */
987
Rob Landleydcc28662004-11-25 07:21:47 +0000988static void process_files(void)
Mark Whitley6315ce62000-07-10 22:55:51 +0000989{
Rob Landleyce4f0e92004-10-30 06:54:19 +0000990 char *pattern_space, *next_line;
Denis Vlasenko826c85f2007-01-28 23:26:15 +0000991 int linenum = 0;
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000992 char last_puts_char = '\n';
993 char last_gets_char, next_gets_char;
Denis Vlasenko2ea630f2006-12-10 02:52:19 +0000994 sed_cmd_t *sed_cmd;
995 int substituted;
Mark Whitley6315ce62000-07-10 22:55:51 +0000996
Rob Landley2b26fd52006-02-24 02:30:39 +0000997 /* Prime the pump */
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000998 next_line = get_next_line(&next_gets_char);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000999
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001000 /* Go through every line in each file */
Denis Vlasenkof39c7c02008-02-28 17:59:01 +00001001 again:
Denis Vlasenko2ea630f2006-12-10 02:52:19 +00001002 substituted = 0;
Glenn L McGrath505bd0f2003-03-08 05:21:02 +00001003
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001004 /* Advance to next line. Stop if out of lines. */
1005 pattern_space = next_line;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001006 if (!pattern_space)
1007 return;
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001008 last_gets_char = next_gets_char;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001009
1010 /* Read one line in advance so we can act on the last line,
1011 * the '$' address */
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001012 next_line = get_next_line(&next_gets_char);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001013 linenum++;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001014
1015 /* For every line, go through all the commands */
Denis Vlasenkof39c7c02008-02-28 17:59:01 +00001016 restart:
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001017 for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001018 int old_matched, matched;
Eric Andersen52a3c272003-12-23 08:53:51 +00001019
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001020 old_matched = sed_cmd->in_match;
Mark Whitley0915c4b2001-06-11 23:50:06 +00001021
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001022 /* Determine if this command matches this line: */
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001023
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001024 dbg("match1:%d", sed_cmd->in_match);
1025 dbg("match2:%d", (!sed_cmd->beg_line && !sed_cmd->end_line
1026 && !sed_cmd->beg_match && !sed_cmd->end_match));
1027 dbg("match3:%d", (sed_cmd->beg_line > 0
1028 && (sed_cmd->end_line || sed_cmd->end_match
1029 ? (sed_cmd->beg_line <= linenum)
1030 : (sed_cmd->beg_line == linenum)
1031 )
1032 ));
1033 dbg("match4:%d", (beg_match(sed_cmd, pattern_space)));
1034 dbg("match5:%d", (sed_cmd->beg_line == -1 && next_line == NULL));
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001035
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001036 /* Are we continuing a previous multi-line match? */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001037 sed_cmd->in_match = sed_cmd->in_match
1038 /* Or is no range necessary? */
1039 || (!sed_cmd->beg_line && !sed_cmd->end_line
1040 && !sed_cmd->beg_match && !sed_cmd->end_match)
1041 /* Or did we match the start of a numerical range? */
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001042 || (sed_cmd->beg_line > 0
1043 && (sed_cmd->end_line || sed_cmd->end_match
Denys Vlasenkoc4679242010-06-04 01:31:48 +02001044 /* note: even if end is numeric and is < linenum too,
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001045 * GNU sed matches! We match too, therefore we don't
1046 * check here that linenum <= end.
1047 * Example:
1048 * printf '1\n2\n3\n4\n' | sed -n '1{N;N;d};1p;2,3p;3p;4p'
1049 * first three input lines are deleted;
1050 * 4th line is matched and printed
1051 * by "2,3" (!) and by "4" ranges
1052 */
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001053 ? (sed_cmd->beg_line <= linenum) /* N,end */
1054 : (sed_cmd->beg_line == linenum) /* N */
1055 )
1056 )
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001057 /* Or does this line match our begin address regex? */
Denis Vlasenko8274e062007-08-06 03:41:08 +00001058 || (beg_match(sed_cmd, pattern_space))
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001059 /* Or did we match last line of input? */
1060 || (sed_cmd->beg_line == -1 && next_line == NULL);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001061
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001062 /* Snapshot the value */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001063 matched = sed_cmd->in_match;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001064
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001065 dbg("cmd:'%c' matched:%d beg_line:%d end_line:%d linenum:%d",
1066 sed_cmd->cmd, matched, sed_cmd->beg_line, sed_cmd->end_line, linenum);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001067
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001068 /* Is this line the end of the current match? */
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001069
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001070 if (matched) {
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001071 /* once matched, "n,xxx" range is dead, disabling it */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001072 if (sed_cmd->beg_line > 0) {
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001073 sed_cmd->beg_line = -2;
Denys Vlasenko2e284a42010-08-01 04:14:46 +02001074 }
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001075 sed_cmd->in_match = !(
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001076 /* has the ending line come, or is this a single address command? */
Denys Vlasenko52d83702011-05-03 00:51:43 +02001077 (sed_cmd->end_line
1078 ? sed_cmd->end_line == -1
1079 ? !next_line
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001080 : (sed_cmd->end_line <= linenum)
1081 : !sed_cmd->end_match
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001082 )
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001083 /* or does this line matches our last address regex */
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001084 || (sed_cmd->end_match && old_matched
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001085 && (regexec(sed_cmd->end_match,
Denys Vlasenko6830ade2013-01-15 13:58:01 +01001086 pattern_space, 0, NULL, 0) == 0)
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001087 )
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001088 );
Erik Andersene49d5ec2000-02-08 19:58:47 +00001089 }
Erik Andersen1266a131999-12-29 22:19:46 +00001090
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001091 /* Skip blocks of commands we didn't match */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001092 if (sed_cmd->cmd == '{') {
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001093 if (sed_cmd->invert ? matched : !matched) {
Denys Vlasenkof2c16ed2010-04-20 04:00:03 -04001094 unsigned nest_cnt = 0;
1095 while (1) {
1096 if (sed_cmd->cmd == '{')
1097 nest_cnt++;
1098 if (sed_cmd->cmd == '}') {
1099 nest_cnt--;
1100 if (nest_cnt == 0)
1101 break;
1102 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001103 sed_cmd = sed_cmd->next;
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001104 if (!sed_cmd)
1105 bb_error_msg_and_die("unterminated {");
1106 }
1107 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001108 continue;
1109 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001110
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001111 /* Okay, so did this line match? */
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001112 if (sed_cmd->invert ? matched : !matched)
1113 continue; /* no */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001114
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001115 /* Update last used regex in case a blank substitute BRE is found */
1116 if (sed_cmd->beg_match) {
1117 G.previous_regex_ptr = sed_cmd->beg_match;
1118 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001119
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001120 /* actual sedding */
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +01001121 dbg("pattern_space:'%s' next_line:'%s' cmd:%c",
1122 pattern_space, next_line, sed_cmd->cmd);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001123 switch (sed_cmd->cmd) {
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001124
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001125 /* Print line number */
1126 case '=':
1127 fprintf(G.nonstdout, "%d\n", linenum);
1128 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001129
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001130 /* Write the current pattern space up to the first newline */
1131 case 'P':
1132 {
1133 char *tmp = strchr(pattern_space, '\n');
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001134 if (tmp) {
1135 *tmp = '\0';
1136 /* TODO: explain why '\n' below */
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001137 sed_puts(pattern_space, '\n');
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001138 *tmp = '\n';
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001139 break;
1140 }
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001141 /* Fall Through */
1142 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001143
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001144 /* Write the current pattern space to output */
1145 case 'p':
1146 /* NB: we print this _before_ the last line
1147 * (of current file) is printed. Even if
1148 * that line is nonterminated, we print
1149 * '\n' here (gnu sed does the same) */
1150 sed_puts(pattern_space, '\n');
1151 break;
1152 /* Delete up through first newline */
1153 case 'D':
1154 {
1155 char *tmp = strchr(pattern_space, '\n');
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001156 if (tmp) {
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001157 overlapping_strcpy(pattern_space, tmp + 1);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001158 goto restart;
1159 }
1160 }
1161 /* discard this line. */
1162 case 'd':
1163 goto discard_line;
1164
1165 /* Substitute with regex */
1166 case 's':
1167 if (!do_subst_command(sed_cmd, &pattern_space))
1168 break;
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +02001169 dbg("do_subst_command succeeded:'%s'", pattern_space);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001170 substituted |= 1;
1171
1172 /* handle p option */
1173 if (sed_cmd->sub_p)
1174 sed_puts(pattern_space, last_gets_char);
1175 /* handle w option */
1176 if (sed_cmd->sw_file)
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001177 puts_maybe_newline(
1178 pattern_space, sed_cmd->sw_file,
1179 &sed_cmd->sw_last_char, last_gets_char);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001180 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001181
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001182 /* Append line to linked list to be printed later */
1183 case 'a':
Denys Vlasenko9d46a7a2013-10-30 10:22:47 +01001184 append(xstrdup(sed_cmd->string));
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001185 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001186
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001187 /* Insert text before this line */
1188 case 'i':
1189 sed_puts(sed_cmd->string, '\n');
1190 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001191
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001192 /* Cut and paste text (replace) */
1193 case 'c':
1194 /* Only triggers on last line of a matching range. */
1195 if (!sed_cmd->in_match)
Denys Vlasenko96a18332010-04-19 22:36:07 -04001196 sed_puts(sed_cmd->string, '\n');
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001197 goto discard_line;
1198
1199 /* Read file, append contents to output */
1200 case 'r':
1201 {
1202 FILE *rfile;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001203 rfile = fopen_for_read(sed_cmd->string);
1204 if (rfile) {
1205 char *line;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001206 while ((line = xmalloc_fgetline(rfile))
1207 != NULL)
1208 append(line);
Denys Vlasenko9d46a7a2013-10-30 10:22:47 +01001209 fclose(rfile);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001210 }
1211
1212 break;
1213 }
1214
1215 /* Write pattern space to file. */
1216 case 'w':
1217 puts_maybe_newline(
1218 pattern_space, sed_cmd->sw_file,
1219 &sed_cmd->sw_last_char, last_gets_char);
1220 break;
1221
1222 /* Read next line from input */
1223 case 'n':
1224 if (!G.be_quiet)
1225 sed_puts(pattern_space, last_gets_char);
1226 if (next_line) {
1227 free(pattern_space);
1228 pattern_space = next_line;
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001229 last_gets_char = next_gets_char;
1230 next_line = get_next_line(&next_gets_char);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001231 substituted = 0;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001232 linenum++;
1233 break;
1234 }
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001235 /* fall through */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001236
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001237 /* Quit. End of script, end of input. */
1238 case 'q':
1239 /* Exit the outer while loop */
1240 free(next_line);
1241 next_line = NULL;
1242 goto discard_commands;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001243
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001244 /* Append the next line to the current line */
1245 case 'N':
1246 {
1247 int len;
1248 /* If no next line, jump to end of script and exit. */
Denys Vlasenko0d555fc2010-08-16 16:26:33 +02001249 /* http://www.gnu.org/software/sed/manual/sed.html:
1250 * "Most versions of sed exit without printing anything
1251 * when the N command is issued on the last line of
1252 * a file. GNU sed prints pattern space before exiting
1253 * unless of course the -n command switch has been
1254 * specified. This choice is by design."
1255 */
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001256 if (next_line == NULL) {
Denys Vlasenko0d555fc2010-08-16 16:26:33 +02001257 //goto discard_line;
1258 goto discard_commands; /* GNU behavior */
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001259 }
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001260 /* Append next_line, read new next_line. */
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001261 len = strlen(pattern_space);
Denys Vlasenko90377872010-01-08 09:07:50 +01001262 pattern_space = xrealloc(pattern_space, len + strlen(next_line) + 2);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001263 pattern_space[len] = '\n';
1264 strcpy(pattern_space + len+1, next_line);
1265 last_gets_char = next_gets_char;
1266 next_line = get_next_line(&next_gets_char);
1267 linenum++;
1268 break;
1269 }
1270
1271 /* Test/branch if substitution occurred */
1272 case 't':
1273 if (!substituted) break;
1274 substituted = 0;
1275 /* Fall through */
1276 /* Test/branch if substitution didn't occur */
1277 case 'T':
1278 if (substituted) break;
1279 /* Fall through */
1280 /* Branch to label */
1281 case 'b':
1282 if (!sed_cmd->string) goto discard_commands;
1283 else sed_cmd = branch_to(sed_cmd->string);
1284 break;
1285 /* Transliterate characters */
1286 case 'y':
1287 {
1288 int i, j;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001289 for (i = 0; pattern_space[i]; i++) {
1290 for (j = 0; sed_cmd->string[j]; j += 2) {
1291 if (pattern_space[i] == sed_cmd->string[j]) {
1292 pattern_space[i] = sed_cmd->string[j + 1];
1293 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001294 }
1295 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001296 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001297
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001298 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001299 }
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001300 case 'g': /* Replace pattern space with hold space */
1301 free(pattern_space);
1302 pattern_space = xstrdup(G.hold_space ? G.hold_space : "");
1303 break;
1304 case 'G': /* Append newline and hold space to pattern space */
1305 {
1306 int pattern_space_size = 2;
1307 int hold_space_size = 0;
1308
1309 if (pattern_space)
1310 pattern_space_size += strlen(pattern_space);
1311 if (G.hold_space)
1312 hold_space_size = strlen(G.hold_space);
1313 pattern_space = xrealloc(pattern_space,
1314 pattern_space_size + hold_space_size);
1315 if (pattern_space_size == 2)
1316 pattern_space[0] = 0;
1317 strcat(pattern_space, "\n");
1318 if (G.hold_space)
1319 strcat(pattern_space, G.hold_space);
1320 last_gets_char = '\n';
1321
1322 break;
1323 }
1324 case 'h': /* Replace hold space with pattern space */
1325 free(G.hold_space);
1326 G.hold_space = xstrdup(pattern_space);
1327 break;
1328 case 'H': /* Append newline and pattern space to hold space */
1329 {
1330 int hold_space_size = 2;
1331 int pattern_space_size = 0;
1332
1333 if (G.hold_space)
1334 hold_space_size += strlen(G.hold_space);
1335 if (pattern_space)
1336 pattern_space_size = strlen(pattern_space);
1337 G.hold_space = xrealloc(G.hold_space,
1338 hold_space_size + pattern_space_size);
1339
1340 if (hold_space_size == 2)
1341 *G.hold_space = 0;
1342 strcat(G.hold_space, "\n");
1343 if (pattern_space)
1344 strcat(G.hold_space, pattern_space);
1345
1346 break;
1347 }
1348 case 'x': /* Exchange hold and pattern space */
1349 {
1350 char *tmp = pattern_space;
Denys Vlasenko90a99042009-09-06 02:36:23 +02001351 pattern_space = G.hold_space ? G.hold_space : xzalloc(1);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001352 last_gets_char = '\n';
1353 G.hold_space = tmp;
1354 break;
1355 }
1356 } /* switch */
1357 } /* for each cmd */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001358
1359 /*
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001360 * Exit point from sedding...
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001361 */
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001362 discard_commands:
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001363 /* we will print the line unless we were told to be quiet ('-n')
1364 or if the line was suppressed (ala 'd'elete) */
Denis Vlasenko17a15262007-03-26 20:48:46 +00001365 if (!G.be_quiet)
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001366 sed_puts(pattern_space, last_gets_char);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001367
1368 /* Delete and such jump here. */
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001369 discard_line:
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001370 flush_append();
1371 free(pattern_space);
1372
1373 goto again;
Erik Andersen1266a131999-12-29 22:19:46 +00001374}
1375
Glenn L McGrath42c25732003-10-04 05:27:56 +00001376/* It is possible to have a command line argument with embedded
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001377 * newlines. This counts as multiple command lines.
1378 * However, newline can be escaped: 's/e/z\<newline>z/'
Denys Vlasenko40ab27a2013-07-08 02:04:44 +02001379 * add_cmd() handles this.
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001380 */
Glenn L McGrath42c25732003-10-04 05:27:56 +00001381
1382static void add_cmd_block(char *cmdstr)
1383{
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001384 char *sv, *eol;
Glenn L McGrath42c25732003-10-04 05:27:56 +00001385
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001386 cmdstr = sv = xstrdup(cmdstr);
1387 do {
1388 eol = strchr(cmdstr, '\n');
Denys Vlasenko40ab27a2013-07-08 02:04:44 +02001389 if (eol)
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001390 *eol = '\0';
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001391 add_cmd(cmdstr);
1392 cmdstr = eol + 1;
1393 } while (eol);
1394 free(sv);
Glenn L McGrath42c25732003-10-04 05:27:56 +00001395}
1396
Denis Vlasenko9b49a5e2007-10-11 10:05:36 +00001397int sed_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
Denis Vlasenkoa60f84e2008-07-05 09:18:54 +00001398int sed_main(int argc UNUSED_PARAM, char **argv)
Eric Andersen6b6b3f61999-10-28 16:06:25 +00001399{
Denis Vlasenko67b23e62006-10-03 21:00:06 +00001400 unsigned opt;
Denis Vlasenkob97c9842006-10-01 21:05:12 +00001401 llist_t *opt_e, *opt_f;
Simon B8c343952012-05-06 13:59:15 +02001402 char *opt_i;
1403
1404#if ENABLE_LONG_OPTS
1405 static const char sed_longopts[] ALIGN1 =
1406 /* name has_arg short */
1407 "in-place\0" Optional_argument "i"
1408 "regexp-extended\0" No_argument "r"
1409 "quiet\0" No_argument "n"
1410 "silent\0" No_argument "n"
1411 "expression\0" Required_argument "e"
1412 "file\0" Required_argument "f";
1413#endif
1414
Denis Vlasenkob97c9842006-10-01 21:05:12 +00001415 int status = EXIT_SUCCESS;
Eric Andersen6b6b3f61999-10-28 16:06:25 +00001416
Denis Vlasenko74324c82007-06-04 10:16:52 +00001417 INIT_G();
Rob Landleye3f5a3f2006-05-09 03:53:55 +00001418
Mark Whitley858c1ad2000-07-11 21:38:47 +00001419 /* destroy command strings on exit */
Rob Landley0b656282006-05-08 22:17:23 +00001420 if (ENABLE_FEATURE_CLEAN_UP) atexit(sed_free_and_close_stuff);
Mark Whitley858c1ad2000-07-11 21:38:47 +00001421
Rob Landleyfae1dc82005-11-20 07:44:35 +00001422 /* Lie to autoconf when it starts asking stupid questions. */
Simon B8c343952012-05-06 13:59:15 +02001423 if (argv[1] && strcmp(argv[1], "--version") == 0) {
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001424 puts("This is not GNU sed version 4.0");
1425 return 0;
Eric Andersenc06f5682004-02-04 10:57:46 +00001426 }
Eric Andersenc06f5682004-02-04 10:57:46 +00001427
Mark Whitley6315ce62000-07-10 22:55:51 +00001428 /* do normal option parsing */
Denis Vlasenkob97c9842006-10-01 21:05:12 +00001429 opt_e = opt_f = NULL;
Simon B8c343952012-05-06 13:59:15 +02001430 opt_i = NULL;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001431 opt_complementary = "e::f::" /* can occur multiple times */
1432 "nn"; /* count -n */
Simon B8c343952012-05-06 13:59:15 +02001433
1434 IF_LONG_OPTS(applet_long_options = sed_longopts);
1435
Denys Vlasenko2e284a42010-08-01 04:14:46 +02001436 /* -i must be first, to match OPT_in_place definition */
David A. Wheeleraf0cdee2013-10-29 00:52:48 +01001437 /* -E is a synonym of -r:
1438 * GNU sed 4.2.1 mentions it in neither --help
1439 * nor manpage, but does recognize it.
1440 */
1441 opt = getopt32(argv, "i::rEne:f:", &opt_i, &opt_e, &opt_f,
Denis Vlasenko17a15262007-03-26 20:48:46 +00001442 &G.be_quiet); /* counter for -n */
Denis Vlasenko62a90cd2008-03-17 09:07:36 +00001443 //argc -= optind;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001444 argv += optind;
1445 if (opt & OPT_in_place) { // -i
Denis Vlasenko750fc6d2006-09-22 08:56:03 +00001446 atexit(cleanup_outname);
1447 }
David A. Wheeleraf0cdee2013-10-29 00:52:48 +01001448 if (opt & (2|4))
1449 G.regex_type |= REG_EXTENDED; // -r or -E
1450 //if (opt & 8)
1451 // G.be_quiet++; // -n (implemented with a counter instead)
Denis Vlasenko945bd3d2007-04-12 21:20:25 +00001452 while (opt_e) { // -e
Denis Vlasenkod50dda82008-06-15 05:40:56 +00001453 add_cmd_block(llist_pop(&opt_e));
Denis Vlasenko750fc6d2006-09-22 08:56:03 +00001454 }
Denis Vlasenko945bd3d2007-04-12 21:20:25 +00001455 while (opt_f) { // -f
1456 char *line;
1457 FILE *cmdfile;
Denis Vlasenko5415c852008-07-21 23:05:26 +00001458 cmdfile = xfopen_for_read(llist_pop(&opt_f));
Denis Vlasenko8ee649a2008-03-26 20:04:27 +00001459 while ((line = xmalloc_fgetline(cmdfile)) != NULL) {
Denis Vlasenko945bd3d2007-04-12 21:20:25 +00001460 add_cmd(line);
1461 free(line);
1462 }
1463 fclose(cmdfile);
Eric Andersen6b6b3f61999-10-28 16:06:25 +00001464 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001465 /* if we didn't get a pattern from -e or -f, use argv[0] */
David A. Wheeleraf0cdee2013-10-29 00:52:48 +01001466 if (!(opt & 0x30)) {
Denis Vlasenko62a90cd2008-03-17 09:07:36 +00001467 if (!*argv)
Manuel Novoa III cad53642003-03-19 09:13:01 +00001468 bb_show_usage();
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001469 add_cmd_block(*argv++);
Mark Whitley6315ce62000-07-10 22:55:51 +00001470 }
Glenn L McGrath42c25732003-10-04 05:27:56 +00001471 /* Flush any unfinished commands. */
1472 add_cmd("");
Mark Whitley6315ce62000-07-10 22:55:51 +00001473
Rob Landley53302f82004-02-18 09:54:15 +00001474 /* By default, we write to stdout */
Denis Vlasenko17a15262007-03-26 20:48:46 +00001475 G.nonstdout = stdout;
Rob Landley53302f82004-02-18 09:54:15 +00001476
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001477 /* argv[0..(argc-1)] should be names of file to process. If no
Mark Whitley6315ce62000-07-10 22:55:51 +00001478 * files were specified or '-' was specified, take input from stdin.
1479 * Otherwise, we process all the files specified. */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001480 if (argv[0] == NULL) {
1481 if (opt & OPT_in_place)
Denis Vlasenko80778502006-10-25 12:46:46 +00001482 bb_error_msg_and_die(bb_msg_requires_arg, "-i");
Rob Landleydcc28662004-11-25 07:21:47 +00001483 add_input_file(stdin);
Glenn L McGrath8d6395d2003-04-08 11:56:11 +00001484 } else {
Mark Whitley6315ce62000-07-10 22:55:51 +00001485 int i;
Glenn L McGrath8d6395d2003-04-08 11:56:11 +00001486
Denis Vlasenko62a90cd2008-03-17 09:07:36 +00001487 for (i = 0; argv[i]; i++) {
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001488 struct stat statbuf;
1489 int nonstdoutfd;
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001490 FILE *file;
1491 sed_cmd_t *sed_cmd;
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001492
Denis Vlasenko9f739442006-12-16 23:49:13 +00001493 if (LONE_DASH(argv[i]) && !(opt & OPT_in_place)) {
Rob Landleydcc28662004-11-25 07:21:47 +00001494 add_input_file(stdin);
1495 process_files();
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001496 continue;
Glenn L McGrath8aac05b2003-09-14 04:06:12 +00001497 }
Denis Vlasenkoddec5af2006-10-26 23:25:17 +00001498 file = fopen_or_warn(argv[i], "r");
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001499 if (!file) {
1500 status = EXIT_FAILURE;
1501 continue;
1502 }
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001503 add_input_file(file);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001504 if (!(opt & OPT_in_place)) {
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001505 continue;
1506 }
1507
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001508 /* -i: process each FILE separately: */
1509
Denis Vlasenko17a15262007-03-26 20:48:46 +00001510 G.outname = xasprintf("%sXXXXXX", argv[i]);
Alexander Shishkin67227372010-10-22 13:27:16 +02001511 nonstdoutfd = xmkstemp(G.outname);
Denys Vlasenkoa7ccdee2009-11-15 23:28:11 +01001512 G.nonstdout = xfdopen_for_write(nonstdoutfd);
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001513
Denys Vlasenko57992482009-11-13 09:09:07 +01001514 /* Set permissions/owner of output file */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001515 fstat(fileno(file), &statbuf);
Denys Vlasenko3b727cc2010-06-18 02:12:56 +02001516 /* chmod'ing AFTER chown would preserve suid/sgid bits,
1517 * but GNU sed 4.2.1 does not preserve them either */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001518 fchmod(nonstdoutfd, statbuf.st_mode);
Denys Vlasenko57992482009-11-13 09:09:07 +01001519 fchown(nonstdoutfd, statbuf.st_uid, statbuf.st_gid);
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001520
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001521 process_files();
Denis Vlasenko17a15262007-03-26 20:48:46 +00001522 fclose(G.nonstdout);
Denis Vlasenko17a15262007-03-26 20:48:46 +00001523 G.nonstdout = stdout;
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001524
Simon B8c343952012-05-06 13:59:15 +02001525 if (opt_i) {
1526 char *backupname = xasprintf("%s%s", argv[i], opt_i);
1527 xrename(argv[i], backupname);
1528 free(backupname);
1529 }
1530 /* else unlink(argv[i]); - rename below does this */
1531 xrename(G.outname, argv[i]); //TODO: rollback backup on error?
Denis Vlasenko17a15262007-03-26 20:48:46 +00001532 free(G.outname);
Denis Vlasenko40276642007-11-13 16:48:10 +00001533 G.outname = NULL;
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001534
1535 /* Re-enable disabled range matches */
1536 for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
1537 sed_cmd->beg_line = sed_cmd->beg_line_orig;
1538 }
Mark Whitley6315ce62000-07-10 22:55:51 +00001539 }
Denys Vlasenkoeb08b6e2010-06-19 17:51:06 +02001540 /* Here, to handle "sed 'cmds' nonexistent_file" case we did:
1541 * if (G.current_input_file >= G.input_file_count)
1542 * return status;
1543 * but it's not needed since process_files() works correctly
1544 * in this case too. */
Mark Whitley6315ce62000-07-10 22:55:51 +00001545 }
Denys Vlasenkoeb08b6e2010-06-19 17:51:06 +02001546 process_files();
Glenn L McGrath8d6395d2003-04-08 11:56:11 +00001547
Matt Kraaia5f09c62001-11-12 16:44:55 +00001548 return status;
Eric Andersen6b6b3f61999-10-28 16:06:25 +00001549}