blob: c0d79cc7b9e24a951053cc1fe369ebea3b0b2218 [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 *
Denys Vlasenkoa221bc52011-09-13 18:40:22 +020026 * process_files() does actual sedding, reading data lines from each input FILE*
Denys Vlasenko52d83702011-05-03 00:51:43 +020027 * (which could be stdin) and applying the sed command list (sed_cmd_head) to
28 * each of the resulting lines.
29 *
30 * sed_main() is where external code calls into this, with a command line.
31 */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +000032
Denys Vlasenko52d83702011-05-03 00:51:43 +020033/* Supported features and commands in this version of sed:
34 *
35 * - comments ('#')
36 * - address matching: num|/matchstr/[,num|/matchstr/|$]command
37 * - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
38 * - edit commands: (a)ppend, (i)nsert, (c)hange
39 * - file commands: (r)ead
40 * - backreferences in substitution expressions (\0, \1, \2...\9)
41 * - grouped commands: {cmd1;cmd2}
42 * - transliteration (y/source-chars/dest-chars/)
43 * - pattern space hold space storing / swapping (g, h, x)
44 * - labels / branching (: label, b, t, T)
45 *
46 * (Note: Specifying an address (range) to match is *optional*; commands
47 * default to the whole pattern space if no specific address match was
48 * requested.)
49 *
50 * Todo:
51 * - Create a wrapper around regex to make libc's regex conform with sed
52 *
Mimi Li37a79c02012-07-24 13:20:12 +020053 * Reference
54 * http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
55 * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html
Denys Vlasenko63f4d322015-04-17 14:24:55 +020056 * http://sed.sourceforge.net/sedfaq3.html
Denys Vlasenko52d83702011-05-03 00:51:43 +020057 */
Mark Whitley6315ce62000-07-10 22:55:51 +000058
Denys Vlasenko73225b62013-11-13 12:45:33 +010059//config:config SED
60//config: bool "sed"
61//config: default y
62//config: help
63//config: sed is used to perform text transformations on a file
64//config: or input from a pipeline.
65
66//kbuild:lib-$(CONFIG_SED) += sed.o
67
68//applet:IF_SED(APPLET(sed, BB_DIR_BIN, BB_SUID_DROP))
69
Pere Orga6a3e01d2011-04-01 22:56:30 +020070//usage:#define sed_trivial_usage
Denys Vlasenkoa82e32d2013-10-30 13:00:00 +010071//usage: "[-inrE] [-f FILE]... [-e CMD]... [FILE]...\n"
72//usage: "or: sed [-inrE] CMD [FILE]..."
Pere Orga6a3e01d2011-04-01 22:56:30 +020073//usage:#define sed_full_usage "\n\n"
Denys Vlasenko66426762011-06-05 03:58:28 +020074//usage: " -e CMD Add CMD to sed commands to be executed"
Pere Orga6a3e01d2011-04-01 22:56:30 +020075//usage: "\n -f FILE Add FILE contents to sed commands to be executed"
Simon B8c343952012-05-06 13:59:15 +020076//usage: "\n -i[SFX] Edit files in-place (otherwise sends to stdout)"
Denys Vlasenko1d7ad7a2012-06-21 09:45:11 +020077//usage: "\n Optionally back files up, appending SFX"
Pere Orga6a3e01d2011-04-01 22:56:30 +020078//usage: "\n -n Suppress automatic printing of pattern space"
Denys Vlasenkoa82e32d2013-10-30 13:00:00 +010079//usage: "\n -r,-E Use extended regex syntax"
Pere Orga6a3e01d2011-04-01 22:56:30 +020080//usage: "\n"
81//usage: "\nIf no -e or -f, the first non-option argument is the sed command string."
82//usage: "\nRemaining arguments are input files (stdin if none)."
83//usage:
84//usage:#define sed_example_usage
85//usage: "$ echo \"foo\" | sed -e 's/f[a-zA-Z]o/bar/g'\n"
86//usage: "bar\n"
87
Denis Vlasenkob6adbf12007-05-26 19:00:18 +000088#include "libbb.h"
Denys Vlasenkoe6a2f4c2016-04-21 16:26:30 +020089#include "common_bufsiz.h"
"Vladimir N. Oleynik"23f62fc2005-09-14 16:59:11 +000090#include "xregex.h"
Mark Whitley6315ce62000-07-10 22:55:51 +000091
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +020092#if 0
93# define dbg(...) bb_error_msg(__VA_ARGS__)
94#else
95# define dbg(...) ((void)0)
96#endif
97
98
Denys Vlasenko2e284a42010-08-01 04:14:46 +020099enum {
100 OPT_in_place = 1 << 0,
101};
102
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000103/* Each sed command turns into one of these structures. */
Glenn L McGrathe7a8bc92003-03-09 10:23:57 +0000104typedef struct sed_cmd_s {
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000105 /* Ordered by alignment requirements: currently 36 bytes on x86 */
Denis Vlasenko34c4e5f2007-01-30 22:25:16 +0000106 struct sed_cmd_s *next; /* Next command (linked list, NULL terminated) */
Mark Whitley2dc192f2000-11-03 19:47:00 +0000107
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000108 /* address storage */
109 regex_t *beg_match; /* sed -e '/match/cmd' */
110 regex_t *end_match; /* sed -e '/match/,/end_match/cmd' */
111 regex_t *sub_match; /* For 's/sub_match/string/' */
112 int beg_line; /* 'sed 1p' 0 == apply commands to all lines */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200113 int beg_line_orig; /* copy of the above, needed for -i */
Denys Vlasenko63f4d322015-04-17 14:24:55 +0200114 int end_line; /* 'sed 1,3p' 0 == one line only. -1 = last line ($). -2-N = +N */
115 int end_line_orig;
Bernhard Reutner-Fischerb7f39732006-03-01 20:14:16 +0000116
Denys Vlasenko2a4bba32016-01-24 15:52:16 +0100117 FILE *sw_file; /* File (sw) command writes to, NULL for none. */
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000118 char *string; /* Data string for (saicytb) commands. */
Glenn L McGrathfc4cb4d2003-04-12 16:10:42 +0000119
Denis Vlasenko284d0fa2008-02-16 13:18:17 +0000120 unsigned which_match; /* (s) Which match to replace (0 for all) */
Glenn L McGrathfc4cb4d2003-04-12 16:10:42 +0000121
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000122 /* Bitfields (gcc won't group them if we don't) */
Denis Vlasenko34c4e5f2007-01-30 22:25:16 +0000123 unsigned invert:1; /* the '!' after the address */
124 unsigned in_match:1; /* Next line also included in match? */
125 unsigned sub_p:1; /* (s) print option */
Denis Vlasenko1375bc72006-12-02 20:12:12 +0000126
Denis Vlasenko34c4e5f2007-01-30 22:25:16 +0000127 char sw_last_char; /* Last line written by (sw) had no '\n' */
Glenn L McGrathc18ce372003-09-13 06:57:39 +0000128
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000129 /* GENERAL FIELDS */
130 char cmd; /* The command char: abcdDgGhHilnNpPqrstwxy:={} */
Glenn L McGrathe7a8bc92003-03-09 10:23:57 +0000131} sed_cmd_t;
Mark Whitley6315ce62000-07-10 22:55:51 +0000132
Denis Vlasenko6ca409e2007-08-12 20:58:27 +0000133static const char semicolon_whitespace[] ALIGN1 = "; \n\r\t\v";
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000134
Denis Vlasenko17a15262007-03-26 20:48:46 +0000135struct globals {
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000136 /* options */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000137 int be_quiet, regex_type;
Denys Vlasenko259b3c02013-11-28 03:14:16 +0100138
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000139 FILE *nonstdout;
140 char *outname, *hold_space;
Denys Vlasenko259b3c02013-11-28 03:14:16 +0100141 smallint exitcode;
Glenn L McGrathbd9b32b2003-04-09 01:43:54 +0000142
Denys Vlasenko259b3c02013-11-28 03:14:16 +0100143 /* list of input files */
Denys Vlasenkodeb07692013-11-28 12:08:51 +0100144 int current_input_file, last_input_file;
145 char **input_file_list;
Denys Vlasenko259b3c02013-11-28 03:14:16 +0100146 FILE *current_fp;
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000147
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000148 regmatch_t regmatch[10];
149 regex_t *previous_regex_ptr;
Denis Vlasenko9213a9e2006-09-17 16:28:10 +0000150
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000151 /* linked list of sed commands */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200152 sed_cmd_t *sed_cmd_head, **sed_cmd_tail;
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000153
Denys Vlasenko259b3c02013-11-28 03:14:16 +0100154 /* linked list of append lines */
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000155 llist_t *append_head;
156
157 char *add_cmd_line;
158
159 struct pipeline {
Denys Vlasenkofb132e42010-10-29 11:46:52 +0200160 char *buf; /* Space to hold string */
161 int idx; /* Space used */
162 int len; /* Space allocated */
Rob Landleye3f5a3f2006-05-09 03:53:55 +0000163 } pipeline;
Denys Vlasenko98a4c7c2010-02-04 15:00:15 +0100164} FIX_ALIASING;
Denys Vlasenkoe6a2f4c2016-04-21 16:26:30 +0200165#define G (*(struct globals*)bb_common_bufsiz1)
Denis Vlasenko74324c82007-06-04 10:16:52 +0000166#define INIT_G() do { \
Denys Vlasenko47cfbf32016-04-21 18:18:48 +0200167 setup_common_bufsiz(); \
Denys Vlasenko7b85ec32015-10-13 17:17:34 +0200168 BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
Denis Vlasenko74324c82007-06-04 10:16:52 +0000169 G.sed_cmd_tail = &G.sed_cmd_head; \
170} while (0)
171
Glenn L McGrathbd9b32b2003-04-09 01:43:54 +0000172
Bernhard Reutner-Fischerb7f39732006-03-01 20:14:16 +0000173#if ENABLE_FEATURE_CLEAN_UP
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000174static void sed_free_and_close_stuff(void)
Mark Whitley6315ce62000-07-10 22:55:51 +0000175{
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200176 sed_cmd_t *sed_cmd = G.sed_cmd_head;
Mark Whitley6315ce62000-07-10 22:55:51 +0000177
Denis Vlasenko17a15262007-03-26 20:48:46 +0000178 llist_free(G.append_head, free);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000179
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000180 while (sed_cmd) {
Glenn L McGrathbd9b32b2003-04-09 01:43:54 +0000181 sed_cmd_t *sed_cmd_next = sed_cmd->next;
Mark Whitley6315ce62000-07-10 22:55:51 +0000182
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000183 if (sed_cmd->sw_file)
Denys Vlasenko2a4bba32016-01-24 15:52:16 +0100184 fclose(sed_cmd->sw_file);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000185
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000186 if (sed_cmd->beg_match) {
187 regfree(sed_cmd->beg_match);
188 free(sed_cmd->beg_match);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000189 }
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000190 if (sed_cmd->end_match) {
191 regfree(sed_cmd->end_match);
192 free(sed_cmd->end_match);
Mark Whitley6315ce62000-07-10 22:55:51 +0000193 }
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000194 if (sed_cmd->sub_match) {
195 regfree(sed_cmd->sub_match);
196 free(sed_cmd->sub_match);
Mark Whitley6315ce62000-07-10 22:55:51 +0000197 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000198 free(sed_cmd->string);
Glenn L McGrath56c633c2003-03-28 04:23:23 +0000199 free(sed_cmd);
200 sed_cmd = sed_cmd_next;
Mark Whitley6315ce62000-07-10 22:55:51 +0000201 }
Rob Landleyce4f0e92004-10-30 06:54:19 +0000202
Denis Vlasenko60818682007-09-28 22:07:23 +0000203 free(G.hold_space);
Rob Landleydcc28662004-11-25 07:21:47 +0000204
Denys Vlasenko259b3c02013-11-28 03:14:16 +0100205 if (G.current_fp)
206 fclose(G.current_fp);
Mark Whitley6315ce62000-07-10 22:55:51 +0000207}
Denis Vlasenko666da5e2006-12-26 18:17:42 +0000208#else
209void sed_free_and_close_stuff(void);
Mark Whitleyc41e8c82000-07-12 23:35:21 +0000210#endif
Mark Whitley6315ce62000-07-10 22:55:51 +0000211
Rob Landley53302f82004-02-18 09:54:15 +0000212/* If something bad happens during -i operation, delete temp file */
213
214static void cleanup_outname(void)
215{
Denis Vlasenko17a15262007-03-26 20:48:46 +0000216 if (G.outname) unlink(G.outname);
Rob Landley53302f82004-02-18 09:54:15 +0000217}
218
Denis Vlasenko40276642007-11-13 16:48:10 +0000219/* strcpy, replacing "\from" with 'to'. If to is NUL, replacing "\any" with 'any' */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000220
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200221static unsigned parse_escapes(char *dest, const char *string, int len, char from, char to)
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000222{
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200223 char *d = dest;
Denis Vlasenko80778502006-10-25 12:46:46 +0000224 int i = 0;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000225
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200226 if (len == -1)
227 len = strlen(string);
228
Denis Vlasenko80778502006-10-25 12:46:46 +0000229 while (i < len) {
230 if (string[i] == '\\') {
231 if (!to || string[i+1] == from) {
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200232 if ((*d = to ? to : string[i+1]) == '\0')
233 return d - dest;
Denis Vlasenko80778502006-10-25 12:46:46 +0000234 i += 2;
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200235 d++;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000236 continue;
Denis Vlasenko4ebaf102007-01-19 21:33:19 +0000237 }
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200238 i++; /* skip backslash in string[] */
239 *d++ = '\\';
240 /* fall through: copy next char verbatim */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000241 }
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200242 if ((*d = string[i++]) == '\0')
243 return d - dest;
244 d++;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000245 }
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200246 *d = '\0';
247 return d - dest;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000248}
249
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000250static char *copy_parsing_escapes(const char *string, int len)
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000251{
Pascal Bellardd3e4be32011-05-05 00:26:37 +0200252 const char *s;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000253 char *dest = xmalloc(len + 1);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000254
Pascal Bellardd3e4be32011-05-05 00:26:37 +0200255 /* sed recognizes \n */
Denys Vlasenko6a0abcc2011-05-03 00:52:22 +0200256 /* GNU sed also recognizes \t and \r */
Pascal Bellardd3e4be32011-05-05 00:26:37 +0200257 for (s = "\nn\tt\rr"; *s; s += 2) {
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200258 len = parse_escapes(dest, string, len, s[1], s[0]);
Pascal Bellardd3e4be32011-05-05 00:26:37 +0200259 string = dest;
Pascal Bellardd3e4be32011-05-05 00:26:37 +0200260 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000261 return dest;
262}
263
264
Mark Whitley6315ce62000-07-10 22:55:51 +0000265/*
Eric Andersen28b3c532001-01-02 11:01:31 +0000266 * index_of_next_unescaped_regexp_delim - walks left to right through a string
267 * beginning at a specified index and returns the index of the next regular
Denis Vlasenko40276642007-11-13 16:48:10 +0000268 * expression delimiter (typically a forward slash ('/')) not preceded by
Rob Landley4795e4e2006-07-26 17:25:08 +0000269 * a backslash ('\'). A negative delimiter disables square bracket checking.
Mark Whitley6315ce62000-07-10 22:55:51 +0000270 */
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000271static int index_of_next_unescaped_regexp_delim(int delimiter, const char *str)
Mark Whitley6315ce62000-07-10 22:55:51 +0000272{
Matt Kraaia0065d52001-08-24 14:45:50 +0000273 int bracket = -1;
274 int escaped = 0;
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000275 int idx = 0;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000276 char ch;
Matt Kraaia0065d52001-08-24 14:45:50 +0000277
Rob Landley4795e4e2006-07-26 17:25:08 +0000278 if (delimiter < 0) {
279 bracket--;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000280 delimiter = -delimiter;
Rob Landley4795e4e2006-07-26 17:25:08 +0000281 }
282
Denys Vlasenko52d83702011-05-03 00:51:43 +0200283 for (; (ch = str[idx]) != '\0'; idx++) {
Rob Landley4795e4e2006-07-26 17:25:08 +0000284 if (bracket >= 0) {
Denys Vlasenko52d83702011-05-03 00:51:43 +0200285 if (ch == ']'
286 && !(bracket == idx - 1 || (bracket == idx - 2 && str[idx - 1] == '^'))
287 ) {
Matt Kraaia0065d52001-08-24 14:45:50 +0000288 bracket = -1;
Denys Vlasenko52d83702011-05-03 00:51:43 +0200289 }
Matt Kraaia0065d52001-08-24 14:45:50 +0000290 } else if (escaped)
291 escaped = 0;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000292 else if (ch == '\\')
Matt Kraaia0065d52001-08-24 14:45:50 +0000293 escaped = 1;
Rob Landley4795e4e2006-07-26 17:25:08 +0000294 else if (bracket == -1 && ch == '[')
Matt Kraaia0065d52001-08-24 14:45:50 +0000295 bracket = idx;
Glenn L McGrath1fb44672003-03-09 08:44:49 +0000296 else if (ch == delimiter)
Mark Whitley97562bd2000-07-17 20:06:42 +0000297 return idx;
298 }
Mark Whitley6315ce62000-07-10 22:55:51 +0000299
Mark Whitley97562bd2000-07-17 20:06:42 +0000300 /* if we make it to here, we've hit the end of the string */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000301 bb_error_msg_and_die("unmatched '%c'", delimiter);
Mark Whitley6315ce62000-07-10 22:55:51 +0000302}
303
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000304/*
305 * Returns the index of the third delimiter
306 */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000307static int parse_regex_delim(const char *cmdstr, char **match, char **replace)
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000308{
Denis Vlasenko9356b502007-01-29 23:44:38 +0000309 const char *cmdstr_ptr = cmdstr;
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100310 unsigned char delimiter;
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000311 int idx = 0;
312
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000313 /* verify that the 's' or 'y' is followed by something. That something
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000314 * (typically a 'slash') is now our regexp delimiter... */
Rob Landley4795e4e2006-07-26 17:25:08 +0000315 if (*cmdstr == '\0')
316 bb_error_msg_and_die("bad format in substitution expression");
Denis Vlasenko80778502006-10-25 12:46:46 +0000317 delimiter = *cmdstr_ptr++;
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000318
319 /* save the match string */
320 idx = index_of_next_unescaped_regexp_delim(delimiter, cmdstr_ptr);
Rob Landleyfae1dc82005-11-20 07:44:35 +0000321 *match = copy_parsing_escapes(cmdstr_ptr, idx);
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000322
323 /* save the replacement string */
324 cmdstr_ptr += idx + 1;
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100325 idx = index_of_next_unescaped_regexp_delim(- (int)delimiter, cmdstr_ptr);
Rob Landleyfae1dc82005-11-20 07:44:35 +0000326 *replace = copy_parsing_escapes(cmdstr_ptr, idx);
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000327
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000328 return ((cmdstr_ptr - cmdstr) + idx);
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000329}
330
Mark Whitley6315ce62000-07-10 22:55:51 +0000331/*
332 * returns the index in the string just past where the address ends.
333 */
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000334static int get_address(const char *my_str, int *linenum, regex_t ** regex)
Mark Whitley6315ce62000-07-10 22:55:51 +0000335{
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000336 const char *pos = my_str;
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000337
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000338 if (isdigit(*my_str)) {
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000339 *linenum = strtol(my_str, (char**)&pos, 10);
Glenn L McGrath1fb44672003-03-09 08:44:49 +0000340 /* endstr shouldnt ever equal NULL */
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000341 } else if (*my_str == '$') {
Mark Whitley0915c4b2001-06-11 23:50:06 +0000342 *linenum = -1;
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000343 pos++;
344 } else if (*my_str == '/' || *my_str == '\\') {
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000345 int next;
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000346 char delimiter;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000347 char *temp;
Glenn L McGrath1fb44672003-03-09 08:44:49 +0000348
Denis Vlasenko80778502006-10-25 12:46:46 +0000349 delimiter = '/';
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100350 if (*my_str == '\\')
351 delimiter = *++pos;
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000352 next = index_of_next_unescaped_regexp_delim(delimiter, ++pos);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +0000353 temp = copy_parsing_escapes(pos, next);
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100354 *regex = xzalloc(sizeof(regex_t));
Denys Vlasenkob0e9b722013-07-21 22:09:44 +0200355 xregcomp(*regex, temp, G.regex_type);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000356 free(temp);
357 /* Move position to next character after last delimiter */
Rob Landley4795e4e2006-07-26 17:25:08 +0000358 pos += (next+1);
Mark Whitley6315ce62000-07-10 22:55:51 +0000359 }
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000360 return pos - my_str;
Mark Whitley6315ce62000-07-10 22:55:51 +0000361}
Erik Andersene49d5ec2000-02-08 19:58:47 +0000362
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000363/* Grab a filename. Whitespace at start is skipped, then goes to EOL. */
Denis Vlasenko68404f12008-03-17 09:00:54 +0000364static int parse_file_cmd(/*sed_cmd_t *sed_cmd,*/ const char *filecmdstr, char **retval)
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000365{
Denis Vlasenko80778502006-10-25 12:46:46 +0000366 int start = 0, idx, hack = 0;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000367
368 /* Skip whitespace, then grab filename to end of line */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000369 while (isspace(filecmdstr[start]))
370 start++;
Denis Vlasenko80778502006-10-25 12:46:46 +0000371 idx = start;
Denis Vlasenko9356b502007-01-29 23:44:38 +0000372 while (filecmdstr[idx] && filecmdstr[idx] != '\n')
373 idx++;
Denis Vlasenko80778502006-10-25 12:46:46 +0000374
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000375 /* If lines glued together, put backslash back. */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000376 if (filecmdstr[idx] == '\n')
377 hack = 1;
Denis Vlasenko80778502006-10-25 12:46:46 +0000378 if (idx == start)
379 bb_error_msg_and_die("empty filename");
Rob Landleyd921b2e2006-08-03 15:41:12 +0000380 *retval = xstrndup(filecmdstr+start, idx-start+hack+1);
Denis Vlasenko9356b502007-01-29 23:44:38 +0000381 if (hack)
382 (*retval)[idx] = '\\';
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000383
384 return idx;
385}
386
Denis Vlasenko9356b502007-01-29 23:44:38 +0000387static int parse_subst_cmd(sed_cmd_t *sed_cmd, const char *substr)
Mark Whitley06f35292000-07-13 19:58:04 +0000388{
Denis Vlasenko17a15262007-03-26 20:48:46 +0000389 int cflags = G.regex_type;
Mark Whitley06f35292000-07-13 19:58:04 +0000390 char *match;
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000391 int idx;
Mark Whitley06f35292000-07-13 19:58:04 +0000392
393 /*
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000394 * A substitution command should look something like this:
David A. Wheeler80a068d2013-12-05 20:42:17 -0500395 * s/match/replace/ #giIpw
Mark Whitley0e4cec02000-08-21 21:29:20 +0000396 * || | |||
Mark Whitley06f35292000-07-13 19:58:04 +0000397 * mandatory optional
Mark Whitley06f35292000-07-13 19:58:04 +0000398 */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000399 idx = parse_regex_delim(substr, &match, &sed_cmd->string);
Mark Whitley06f35292000-07-13 19:58:04 +0000400
Mark Whitley97562bd2000-07-17 20:06:42 +0000401 /* determine the number of back references in the match string */
402 /* Note: we compute this here rather than in the do_subst_command()
403 * function to save processor time, at the expense of a little more memory
404 * (4 bits) per sed_cmd */
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000405
Mark Whitley06f35292000-07-13 19:58:04 +0000406 /* process the flags */
Mark Whitley70705d72000-07-14 19:06:30 +0000407
Denis Vlasenko80778502006-10-25 12:46:46 +0000408 sed_cmd->which_match = 1;
Denys Vlasenko9caea242014-09-16 01:11:13 +0200409 dbg("s flags:'%s'", substr + idx + 1);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000410 while (substr[++idx]) {
Denys Vlasenko9caea242014-09-16 01:11:13 +0200411 dbg("s flag:'%c'", substr[idx]);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000412 /* Parse match number */
Denis Vlasenko80778502006-10-25 12:46:46 +0000413 if (isdigit(substr[idx])) {
414 if (match[0] != '^') {
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000415 /* Match 0 treated as all, multiple matches we take the last one. */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000416 const char *pos = substr + idx;
417/* FIXME: error check? */
Denis Vlasenko284d0fa2008-02-16 13:18:17 +0000418 sed_cmd->which_match = (unsigned)strtol(substr+idx, (char**) &pos, 10);
Denys Vlasenko9caea242014-09-16 01:11:13 +0200419 idx = pos - substr - 1;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000420 }
421 continue;
422 }
Rob Landley40ec4ae2004-01-04 06:42:14 +0000423 /* Skip spaces */
Denys Vlasenko6935ec92009-10-22 19:42:26 +0200424 if (isspace(substr[idx]))
425 continue;
Rob Landley40ec4ae2004-01-04 06:42:14 +0000426
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000427 switch (substr[idx]) {
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000428 /* Replace all occurrences */
429 case 'g':
Denis Vlasenko284d0fa2008-02-16 13:18:17 +0000430 if (match[0] != '^')
431 sed_cmd->which_match = 0;
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000432 break;
433 /* Print pattern space */
434 case 'p':
435 sed_cmd->sub_p = 1;
436 break;
437 /* Write to file */
438 case 'w':
439 {
Denys Vlasenko2a4bba32016-01-24 15:52:16 +0100440 char *fname;
441 idx += parse_file_cmd(/*sed_cmd,*/ substr+idx+1, &fname);
442 sed_cmd->sw_file = xfopen_for_write(fname);
443 sed_cmd->sw_last_char = '\n';
444 free(fname);
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000445 break;
446 }
447 /* Ignore case (gnu exension) */
David A. Wheeler80a068d2013-12-05 20:42:17 -0500448 case 'i':
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000449 case 'I':
450 cflags |= REG_ICASE;
451 break;
452 /* Comment */
453 case '#':
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +0200454 // while (substr[++idx]) continue;
455 idx += strlen(substr + idx); // same
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000456 /* Fall through */
457 /* End of command */
458 case ';':
459 case '}':
460 goto out;
461 default:
Denys Vlasenko9caea242014-09-16 01:11:13 +0200462 dbg("s bad flags:'%s'", substr + idx);
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000463 bb_error_msg_and_die("bad option in substitution expression");
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000464 }
465 }
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +0200466 out:
Mark Whitley97562bd2000-07-17 20:06:42 +0000467 /* compile the match string into a regex */
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000468 if (*match != '\0') {
469 /* If match is empty, we use last regex used at runtime */
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100470 sed_cmd->sub_match = xzalloc(sizeof(regex_t));
471 dbg("xregcomp('%s',%x)", match, cflags);
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000472 xregcomp(sed_cmd->sub_match, match, cflags);
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100473 dbg("regcomp ok");
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000474 }
Mark Whitley06f35292000-07-13 19:58:04 +0000475 free(match);
Mark Whitley70705d72000-07-14 19:06:30 +0000476
477 return idx;
Mark Whitley06f35292000-07-13 19:58:04 +0000478}
479
Glenn L McGrath2971ef12003-03-18 01:19:23 +0000480/*
481 * Process the commands arguments
482 */
Denis Vlasenko9356b502007-01-29 23:44:38 +0000483static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
Mark Whitley6315ce62000-07-10 22:55:51 +0000484{
Denys Vlasenko3e134eb2016-04-22 18:09:21 +0200485 static const char cmd_letters[] ALIGN1 = "saicrw:btTydDgGhHlnNpPqx={}";
Denys Vlasenko52d83702011-05-03 00:51:43 +0200486 enum {
487 IDX_s = 0,
488 IDX_a,
489 IDX_i,
490 IDX_c,
491 IDX_r,
492 IDX_w,
493 IDX_colon,
494 IDX_b,
495 IDX_t,
496 IDX_T,
497 IDX_y,
498 IDX_d,
499 IDX_D,
500 IDX_g,
501 IDX_G,
502 IDX_h,
503 IDX_H,
504 IDX_l,
505 IDX_n,
506 IDX_N,
507 IDX_p,
508 IDX_P,
509 IDX_q,
510 IDX_x,
511 IDX_equal,
512 IDX_lbrace,
513 IDX_rbrace,
514 IDX_nul
515 };
Denys Vlasenko7b85ec32015-10-13 17:17:34 +0200516 unsigned idx;
Denys Vlasenko52d83702011-05-03 00:51:43 +0200517
Denys Vlasenko7b85ec32015-10-13 17:17:34 +0200518 BUILD_BUG_ON(sizeof(cmd_letters)-1 != IDX_nul);
519
520 idx = strchrnul(cmd_letters, sed_cmd->cmd) - cmd_letters;
Denys Vlasenko52d83702011-05-03 00:51:43 +0200521
Glenn L McGrath2f8a4012003-03-09 02:44:49 +0000522 /* handle (s)ubstitution command */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200523 if (idx == IDX_s) {
Denis Vlasenko80778502006-10-25 12:46:46 +0000524 cmdstr += parse_subst_cmd(sed_cmd, cmdstr);
Denys Vlasenko52d83702011-05-03 00:51:43 +0200525 }
Glenn L McGrath2f8a4012003-03-09 02:44:49 +0000526 /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200527 else if (idx <= IDX_c) { /* a,i,c */
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200528 unsigned len;
529
Mimi Li37a79c02012-07-24 13:20:12 +0200530 if (idx < IDX_c) { /* a,i */
531 if (sed_cmd->end_line || sed_cmd->end_match)
532 bb_error_msg_and_die("command '%c' uses only one address", sed_cmd->cmd);
533 }
Denis Vlasenko80778502006-10-25 12:46:46 +0000534 for (;;) {
535 if (*cmdstr == '\n' || *cmdstr == '\\') {
Rob Landley25d82392004-04-01 09:23:30 +0000536 cmdstr++;
537 break;
Denys Vlasenkoc0dab372009-10-22 22:28:08 +0200538 }
539 if (!isspace(*cmdstr))
Denis Vlasenko80778502006-10-25 12:46:46 +0000540 break;
Denys Vlasenkoc0dab372009-10-22 22:28:08 +0200541 cmdstr++;
Rob Landley25d82392004-04-01 09:23:30 +0000542 }
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200543 len = strlen(cmdstr);
544 sed_cmd->string = copy_parsing_escapes(cmdstr, len);
545 cmdstr += len;
Denis Vlasenko40276642007-11-13 16:48:10 +0000546 /* "\anychar" -> "anychar" */
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200547 parse_escapes(sed_cmd->string, sed_cmd->string, -1, '\0', '\0');
Denys Vlasenko52d83702011-05-03 00:51:43 +0200548 }
Glenn L McGrath2f8a4012003-03-09 02:44:49 +0000549 /* handle file cmds: (r)ead */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200550 else if (idx <= IDX_w) { /* r,w */
Mimi Li37a79c02012-07-24 13:20:12 +0200551 if (idx < IDX_w) { /* r */
552 if (sed_cmd->end_line || sed_cmd->end_match)
553 bb_error_msg_and_die("command '%c' uses only one address", sed_cmd->cmd);
554 }
Denis Vlasenko68404f12008-03-17 09:00:54 +0000555 cmdstr += parse_file_cmd(/*sed_cmd,*/ cmdstr, &sed_cmd->string);
Denis Vlasenkoc562bb72007-01-29 17:08:51 +0000556 if (sed_cmd->cmd == 'w') {
Denis Vlasenko5415c852008-07-21 23:05:26 +0000557 sed_cmd->sw_file = xfopen_for_write(sed_cmd->string);
Denis Vlasenkoc562bb72007-01-29 17:08:51 +0000558 sed_cmd->sw_last_char = '\n';
559 }
Denys Vlasenko52d83702011-05-03 00:51:43 +0200560 }
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000561 /* handle branch commands */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200562 else if (idx <= IDX_T) { /* :,b,t,T */
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000563 int length;
564
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000565 cmdstr = skip_whitespace(cmdstr);
Glenn L McGrathf4523562003-09-14 06:01:14 +0000566 length = strcspn(cmdstr, semicolon_whitespace);
567 if (length) {
Rob Landleyd921b2e2006-08-03 15:41:12 +0000568 sed_cmd->string = xstrndup(cmdstr, length);
Glenn L McGrathf4523562003-09-14 06:01:14 +0000569 cmdstr += length;
570 }
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000571 }
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000572 /* translation command */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200573 else if (idx == IDX_y) {
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000574 char *match, *replace;
Denis Vlasenko80778502006-10-25 12:46:46 +0000575 int i = cmdstr[0];
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000576
Denis Vlasenko80778502006-10-25 12:46:46 +0000577 cmdstr += parse_regex_delim(cmdstr, &match, &replace)+1;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000578 /* \n already parsed, but \delimiter needs unescaping. */
Denys Vlasenkocbdff152016-04-24 16:18:03 +0200579 parse_escapes(match, match, -1, i, i);
580 parse_escapes(replace, replace, -1, i, i);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000581
Rob Landley9ffd4232006-05-21 18:30:35 +0000582 sed_cmd->string = xzalloc((strlen(match) + 1) * 2);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000583 for (i = 0; match[i] && replace[i]; i++) {
Denis Vlasenko80778502006-10-25 12:46:46 +0000584 sed_cmd->string[i*2] = match[i];
585 sed_cmd->string[i*2+1] = replace[i];
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000586 }
587 free(match);
588 free(replace);
Glenn L McGrathf01b46d2003-03-30 08:02:18 +0000589 }
Glenn L McGrath2971ef12003-03-18 01:19:23 +0000590 /* if it wasnt a single-letter command that takes no arguments
591 * then it must be an invalid command.
592 */
Denys Vlasenko52d83702011-05-03 00:51:43 +0200593 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 +0000594 bb_error_msg_and_die("unsupported command %c", sed_cmd->cmd);
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000595 }
Mark Whitley70705d72000-07-14 19:06:30 +0000596
597 /* give back whatever's left over */
Denis Vlasenko80778502006-10-25 12:46:46 +0000598 return cmdstr;
Eric Andersen50d63601999-11-09 01:47:36 +0000599}
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000600
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000601
602/* Parse address+command sets, skipping comment lines. */
603
Denis Vlasenkob6aae0f2007-01-29 22:51:25 +0000604static void add_cmd(const char *cmdstr)
Erik Andersen1266a131999-12-29 22:19:46 +0000605{
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000606 sed_cmd_t *sed_cmd;
Denys Vlasenkoa2215b92010-05-12 01:49:04 +0200607 unsigned len, n;
Glenn L McGrath8aac05b2003-09-14 04:06:12 +0000608
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000609 /* Append this line to any unfinished line from last time. */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000610 if (G.add_cmd_line) {
611 char *tp = xasprintf("%s\n%s", G.add_cmd_line, cmdstr);
612 free(G.add_cmd_line);
Denis Vlasenko945bd3d2007-04-12 21:20:25 +0000613 cmdstr = G.add_cmd_line = tp;
Rob Landley12d87552006-06-05 17:32:44 +0000614 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000615
Denys Vlasenkoa2215b92010-05-12 01:49:04 +0200616 /* If this line ends with unescaped backslash, request next line. */
617 n = len = strlen(cmdstr);
618 while (n && cmdstr[n-1] == '\\')
619 n--;
620 if ((len - n) & 1) { /* if odd number of trailing backslashes */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000621 if (!G.add_cmd_line)
622 G.add_cmd_line = xstrdup(cmdstr);
Denys Vlasenkoa2215b92010-05-12 01:49:04 +0200623 G.add_cmd_line[len-1] = '\0';
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000624 return;
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000625 }
Mark Whitley6315ce62000-07-10 22:55:51 +0000626
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000627 /* Loop parsing all commands in this line. */
Denis Vlasenko80778502006-10-25 12:46:46 +0000628 while (*cmdstr) {
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000629 /* Skip leading whitespace and semicolons */
630 cmdstr += strspn(cmdstr, semicolon_whitespace);
631
632 /* If no more commands, exit. */
Denis Vlasenko80778502006-10-25 12:46:46 +0000633 if (!*cmdstr) break;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000634
635 /* if this is a comment, jump past it and keep going */
636 if (*cmdstr == '#') {
637 /* "#n" is the same as using -n on the command line */
Denis Vlasenko80778502006-10-25 12:46:46 +0000638 if (cmdstr[1] == 'n')
Denis Vlasenko17a15262007-03-26 20:48:46 +0000639 G.be_quiet++;
Denis Vlasenko80778502006-10-25 12:46:46 +0000640 cmdstr = strpbrk(cmdstr, "\n\r");
641 if (!cmdstr) break;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000642 continue;
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000643 }
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000644
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000645 /* parse the command
646 * format is: [addr][,addr][!]cmd
647 * |----||-----||-|
648 * part1 part2 part3
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000649 */
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000650
Rob Landley9ffd4232006-05-21 18:30:35 +0000651 sed_cmd = xzalloc(sizeof(sed_cmd_t));
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000652
653 /* first part (if present) is an address: either a '$', a number or a /regex/ */
654 cmdstr += get_address(cmdstr, &sed_cmd->beg_line, &sed_cmd->beg_match);
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200655 sed_cmd->beg_line_orig = sed_cmd->beg_line;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000656
657 /* second part (if present) will begin with a comma */
658 if (*cmdstr == ',') {
659 int idx;
660
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000661 cmdstr++;
Denys Vlasenko63f4d322015-04-17 14:24:55 +0200662 if (*cmdstr == '+' && isdigit(cmdstr[1])) {
663 /* http://sed.sourceforge.net/sedfaq3.html#s3.3
664 * Under GNU sed 3.02+, ssed, and sed15+, <address2>
665 * may also be a notation of the form +num,
666 * indicating the next num lines after <address1> is
667 * matched.
668 * GNU sed 4.2.1 accepts even "+" (meaning "+0").
669 * We don't (we check for isdigit, see above), think
670 * about the "+-3" case.
671 */
672 char *end;
673 /* code is smaller compared to using &cmdstr here: */
674 idx = strtol(cmdstr+1, &end, 10);
675 sed_cmd->end_line = -2 - idx;
676 cmdstr = end;
677 } else {
678 idx = get_address(cmdstr, &sed_cmd->end_line, &sed_cmd->end_match);
679 cmdstr += idx;
680 idx--; /* if 0, trigger error check below */
681 }
682 if (idx < 0)
Denis Vlasenko80778502006-10-25 12:46:46 +0000683 bb_error_msg_and_die("no address after comma");
Denys Vlasenko63f4d322015-04-17 14:24:55 +0200684 sed_cmd->end_line_orig = sed_cmd->end_line;
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000685 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000686
687 /* skip whitespace before the command */
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000688 cmdstr = skip_whitespace(cmdstr);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000689
690 /* Check for inversion flag */
691 if (*cmdstr == '!') {
692 sed_cmd->invert = 1;
693 cmdstr++;
694
695 /* skip whitespace before the command */
Denis Vlasenkod18a3a22006-10-25 12:46:03 +0000696 cmdstr = skip_whitespace(cmdstr);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000697 }
698
699 /* last part (mandatory) will be a command */
Denis Vlasenko80778502006-10-25 12:46:46 +0000700 if (!*cmdstr)
701 bb_error_msg_and_die("missing command");
Denys Vlasenkoa2215b92010-05-12 01:49:04 +0200702 sed_cmd->cmd = *cmdstr++;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000703 cmdstr = parse_cmd_args(sed_cmd, cmdstr);
704
Denys Vlasenkoe93d1562013-07-08 01:43:40 +0200705 /* cmdstr now points past args.
706 * GNU sed requires a separator, if there are more commands,
707 * else it complains "char N: extra characters after command".
708 * Example: "sed 'p;d'". We also allow "sed 'pd'".
709 */
710
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000711 /* Add the command to the command array */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200712 *G.sed_cmd_tail = sed_cmd;
713 G.sed_cmd_tail = &sed_cmd->next;
Glenn L McGrathf50ce312003-03-09 15:12:24 +0000714 }
715
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000716 /* If we glued multiple lines together, free the memory. */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000717 free(G.add_cmd_line);
718 G.add_cmd_line = NULL;
Mark Whitley6315ce62000-07-10 22:55:51 +0000719}
720
Rob Landleydcc28662004-11-25 07:21:47 +0000721/* Append to a string, reallocating memory as necessary. */
722
Glenn L McGrath8d6395d2003-04-08 11:56:11 +0000723#define PIPE_GROW 64
Eric Andersenc52a6b02001-11-10 10:49:42 +0000724
Eric Andersen14f5c8d2005-04-16 19:39:00 +0000725static void pipe_putc(char c)
Eric Andersenc52a6b02001-11-10 10:49:42 +0000726{
Denis Vlasenko17a15262007-03-26 20:48:46 +0000727 if (G.pipeline.idx == G.pipeline.len) {
728 G.pipeline.buf = xrealloc(G.pipeline.buf,
729 G.pipeline.len + PIPE_GROW);
730 G.pipeline.len += PIPE_GROW;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000731 }
Denis Vlasenko17a15262007-03-26 20:48:46 +0000732 G.pipeline.buf[G.pipeline.idx++] = c;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000733}
734
Rob Landley4795e4e2006-07-26 17:25:08 +0000735static void do_subst_w_backrefs(char *line, char *replace)
Mark Whitley97562bd2000-07-17 20:06:42 +0000736{
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200737 int i, j;
Mark Whitley97562bd2000-07-17 20:06:42 +0000738
739 /* go through the replacement string */
740 for (i = 0; replace[i]; i++) {
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200741 /* if we find a backreference (\1, \2, etc.) print the backref'ed text */
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000742 if (replace[i] == '\\') {
743 unsigned backref = replace[++i] - '0';
744 if (backref <= 9) {
Denis Vlasenko17a15262007-03-26 20:48:46 +0000745 /* print out the text held in G.regmatch[backref] */
746 if (G.regmatch[backref].rm_so != -1) {
747 j = G.regmatch[backref].rm_so;
748 while (j < G.regmatch[backref].rm_eo)
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000749 pipe_putc(line[j++]);
750 }
751 continue;
Denis Vlasenko80778502006-10-25 12:46:46 +0000752 }
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000753 /* I _think_ it is impossible to get '\' to be
754 * the last char in replace string. Thus we dont check
755 * for replace[i] == NUL. (counterexample anyone?) */
756 /* if we find a backslash escaped character, print the character */
757 pipe_putc(replace[i]);
758 continue;
Mark Whitley97562bd2000-07-17 20:06:42 +0000759 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000760 /* if we find an unescaped '&' print out the whole matched text. */
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000761 if (replace[i] == '&') {
Denis Vlasenko17a15262007-03-26 20:48:46 +0000762 j = G.regmatch[0].rm_so;
763 while (j < G.regmatch[0].rm_eo)
Denis Vlasenko80778502006-10-25 12:46:46 +0000764 pipe_putc(line[j++]);
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000765 continue;
Denis Vlasenko80778502006-10-25 12:46:46 +0000766 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000767 /* Otherwise just output the character. */
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +0000768 pipe_putc(replace[i]);
Mark Whitley97562bd2000-07-17 20:06:42 +0000769 }
770}
771
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200772static int do_subst_command(sed_cmd_t *sed_cmd, char **line_p)
Mark Whitley4f7fe772000-07-13 20:01:58 +0000773{
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200774 char *line = *line_p;
Denis Vlasenko77ad97f2008-05-13 02:27:31 +0000775 unsigned match_count = 0;
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200776 bool altered = 0;
777 bool prev_match_empty = 1;
778 bool tried_at_eol = 0;
Glenn L McGrathc1d95072003-04-08 06:42:45 +0000779 regex_t *current_regex;
780
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200781 current_regex = sed_cmd->sub_match;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000782 /* Handle empty regex. */
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200783 if (!current_regex) {
Denis Vlasenko17a15262007-03-26 20:48:46 +0000784 current_regex = G.previous_regex_ptr;
Denis Vlasenko80778502006-10-25 12:46:46 +0000785 if (!current_regex)
Denis Vlasenkod3d004d2006-10-27 09:02:31 +0000786 bb_error_msg_and_die("no previous regexp");
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200787 }
788 G.previous_regex_ptr = current_regex;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000789
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000790 /* Find the first match */
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100791 dbg("matching '%s'", line);
792 if (REG_NOMATCH == regexec(current_regex, line, 10, G.regmatch, 0)) {
793 dbg("no match");
Mark Whitley2dc192f2000-11-03 19:47:00 +0000794 return 0;
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100795 }
796 dbg("match");
Mark Whitley2dc192f2000-11-03 19:47:00 +0000797
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000798 /* Initialize temporary output buffer. */
Denis Vlasenko17a15262007-03-26 20:48:46 +0000799 G.pipeline.buf = xmalloc(PIPE_GROW);
800 G.pipeline.len = PIPE_GROW;
801 G.pipeline.idx = 0;
Mark Whitley2dc192f2000-11-03 19:47:00 +0000802
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000803 /* Now loop through, substituting for matches */
804 do {
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200805 int start = G.regmatch[0].rm_so;
806 int end = G.regmatch[0].rm_eo;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000807 int i;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000808
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000809 match_count++;
810
811 /* If we aren't interested in this match, output old line to
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200812 * end of match and continue */
Denis Vlasenko77ad97f2008-05-13 02:27:31 +0000813 if (sed_cmd->which_match
814 && (sed_cmd->which_match != match_count)
815 ) {
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200816 for (i = 0; i < end; i++)
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200817 pipe_putc(*line++);
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200818 /* Null match? Print one more char */
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200819 if (start == end && *line)
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200820 pipe_putc(*line++);
Denys Vlasenkob84dafb2012-04-24 19:27:34 +0200821 goto next;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000822 }
823
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200824 /* Print everything before the match */
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200825 for (i = 0; i < start; i++)
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200826 pipe_putc(line[i]);
Mark Whitley97562bd2000-07-17 20:06:42 +0000827
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200828 /* Then print the substitution string,
829 * unless we just matched empty string after non-empty one.
830 * Example: string "cccd", pattern "c*", repl "R":
831 * result is "RdR", not "RRdR": first match "ccc",
832 * second is "" before "d", third is "" after "d".
833 * Second match is NOT replaced!
834 */
Denys Vlasenko84406e42012-06-07 16:34:57 +0200835 if (prev_match_empty || start != 0 || start != end) {
Denys Vlasenko37ca36a2012-06-08 10:25:31 +0200836 //dbg("%d %d %d", prev_match_empty, start, end);
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200837 dbg("inserting replacement at %d in '%s'", start, line);
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200838 do_subst_w_backrefs(line, sed_cmd->string);
Denys Vlasenko37ca36a2012-06-08 10:25:31 +0200839 /* Flag that something has changed */
840 altered = 1;
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200841 } else {
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200842 dbg("NOT inserting replacement at %d in '%s'", start, line);
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200843 }
Mark Whitley97562bd2000-07-17 20:06:42 +0000844
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200845 /* If matched string is empty (f.e. "c*" pattern),
846 * copy verbatim one char after it before attempting more matches
847 */
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200848 prev_match_empty = (start == end);
Denys Vlasenko37ca36a2012-06-08 10:25:31 +0200849 if (prev_match_empty) {
850 if (!line[end]) {
851 tried_at_eol = 1;
852 } else {
853 pipe_putc(line[end]);
854 end++;
855 }
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200856 }
857
858 /* Advance past the match */
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200859 dbg("line += %d", end);
860 line += end;
Mark Whitley97562bd2000-07-17 20:06:42 +0000861
Mark Whitley2dc192f2000-11-03 19:47:00 +0000862 /* if we're not doing this globally, get out now */
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100863 if (sed_cmd->which_match != 0)
864 break;
Denys Vlasenkob84dafb2012-04-24 19:27:34 +0200865 next:
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +0200866 /* Exit if we are at EOL and already tried matching at it */
867 if (*line == '\0') {
868 if (tried_at_eol)
869 break;
870 tried_at_eol = 1;
871 }
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200872
Denys Vlasenkoc35545a2012-06-04 14:45:09 +0200873//maybe (end ? REG_NOTBOL : 0) instead of unconditional REG_NOTBOL?
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +0100874 } while (regexec(current_regex, line, 10, G.regmatch, REG_NOTBOL) != REG_NOMATCH);
Mark Whitley2dc192f2000-11-03 19:47:00 +0000875
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000876 /* Copy rest of string into output pipeline */
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200877 while (1) {
878 char c = *line++;
879 pipe_putc(c);
880 if (c == '\0')
881 break;
882 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000883
Denys Vlasenkof210cff2009-08-17 01:35:04 +0200884 free(*line_p);
885 *line_p = G.pipeline.buf;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000886 return altered;
887}
Mark Whitley6315ce62000-07-10 22:55:51 +0000888
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000889/* Set command pointer to point to this label. (Does not handle null label.) */
Rob Landley4795e4e2006-07-26 17:25:08 +0000890static sed_cmd_t *branch_to(char *label)
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000891{
892 sed_cmd_t *sed_cmd;
Glenn L McGrathd4185b02003-04-11 17:10:23 +0000893
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +0200894 for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
Denis Vlasenko80778502006-10-25 12:46:46 +0000895 if (sed_cmd->cmd == ':' && sed_cmd->string && !strcmp(sed_cmd->string, label)) {
896 return sed_cmd;
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000897 }
898 }
Denis Vlasenko80778502006-10-25 12:46:46 +0000899 bb_error_msg_and_die("can't find label for jump to '%s'", label);
Glenn L McGrath961c6c12003-03-28 04:43:39 +0000900}
Mark Whitley6315ce62000-07-10 22:55:51 +0000901
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000902static void append(char *s)
903{
Denys Vlasenko9d46a7a2013-10-30 10:22:47 +0100904 llist_add_to_end(&G.append_head, s);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000905}
906
Denys Vlasenkoc44539f2013-10-30 14:25:22 +0100907/* Output line of text. */
908/* Note:
909 * The tricks with NO_EOL_CHAR and last_puts_char are there to emulate gnu sed.
910 * Without them, we had this:
911 * echo -n thingy >z1
912 * echo -n again >z2
913 * >znull
914 * sed "s/i/z/" z1 z2 znull | hexdump -vC
915 * output:
916 * gnu sed 4.1.5:
917 * 00000000 74 68 7a 6e 67 79 0a 61 67 61 7a 6e |thzngy.agazn|
918 * bbox:
919 * 00000000 74 68 7a 6e 67 79 61 67 61 7a 6e |thzngyagazn|
Rob Landleydcc28662004-11-25 07:21:47 +0000920 */
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000921enum {
922 NO_EOL_CHAR = 1,
Denis Vlasenko86811802007-01-29 17:10:19 +0000923 LAST_IS_NUL = 2,
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000924};
Denys Vlasenkoc44539f2013-10-30 14:25:22 +0100925static void puts_maybe_newline(char *s, FILE *file, char *last_puts_char, char last_gets_char)
926{
927 char lpc = *last_puts_char;
928
929 /* Need to insert a '\n' between two files because first file's
930 * last line wasn't terminated? */
931 if (lpc != '\n' && lpc != '\0') {
932 fputc('\n', file);
933 lpc = '\n';
934 }
935 fputs(s, file);
936
937 /* 'x' - just something which is not '\n', '\0' or NO_EOL_CHAR */
938 if (s[0])
939 lpc = 'x';
940
941 /* had trailing '\0' and it was last char of file? */
942 if (last_gets_char == LAST_IS_NUL) {
943 fputc('\0', file);
944 lpc = 'x'; /* */
945 } else
946 /* had trailing '\n' or '\0'? */
947 if (last_gets_char != NO_EOL_CHAR) {
948 fputc(last_gets_char, file);
949 lpc = last_gets_char;
950 }
951
952 if (ferror(file)) {
953 xfunc_error_retval = 4; /* It's what gnu sed exits with... */
954 bb_error_msg_and_die(bb_msg_write_error);
955 }
956 *last_puts_char = lpc;
957}
958
Denys Vlasenkof2559e52016-05-06 18:25:56 +0200959static void flush_append(char *last_puts_char)
Denys Vlasenkoc44539f2013-10-30 14:25:22 +0100960{
961 char *data;
962
963 /* Output appended lines. */
Denys Vlasenkof2559e52016-05-06 18:25:56 +0200964 while ((data = (char *)llist_pop(&G.append_head)) != NULL) {
965 /* Append command does not respect "nonterminated-ness"
966 * of last line. Try this:
967 * $ echo -n "woot" | sed -e '/woot/a woo' -
968 * woot
969 * woo
970 * (both lines are terminated with \n)
971 * Therefore we do not propagate "last_gets_char" here,
972 * pass '\n' instead:
973 */
974 puts_maybe_newline(data, G.nonstdout, last_puts_char, '\n');
Denys Vlasenkoc44539f2013-10-30 14:25:22 +0100975 free(data);
976 }
977}
978
979/* Get next line of input from G.input_file_list, flushing append buffer and
980 * noting if we ran out of files without a newline on the last line we read.
981 */
Denys Vlasenkof2559e52016-05-06 18:25:56 +0200982static char *get_next_line(char *gets_char, char *last_puts_char)
Rob Landleydcc28662004-11-25 07:21:47 +0000983{
Denis Vlasenko80778502006-10-25 12:46:46 +0000984 char *temp = NULL;
Denis Vlasenkoc562bb72007-01-29 17:08:51 +0000985 int len;
986 char gc;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +0000987
Denys Vlasenkof2559e52016-05-06 18:25:56 +0200988 flush_append(last_puts_char);
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +0000989
990 /* will be returned if last line in the file
991 * doesn't end with either '\n' or '\0' */
992 gc = NO_EOL_CHAR;
Denys Vlasenkodeb07692013-11-28 12:08:51 +0100993 for (; G.current_input_file <= G.last_input_file; G.current_input_file++) {
Denys Vlasenko259b3c02013-11-28 03:14:16 +0100994 FILE *fp = G.current_fp;
995 if (!fp) {
996 const char *path = G.input_file_list[G.current_input_file];
997 fp = stdin;
998 if (path != bb_msg_standard_input) {
999 fp = fopen_or_warn(path, "r");
1000 if (!fp) {
1001 G.exitcode = EXIT_FAILURE;
1002 continue;
1003 }
1004 }
1005 G.current_fp = fp;
1006 }
Denis Vlasenkoef44d9d2007-01-17 23:16:16 +00001007 /* Read line up to a newline or NUL byte, inclusive,
1008 * return malloc'ed char[]. length of the chunk read
1009 * is stored in len. NULL if EOF/error */
Denis Vlasenko86811802007-01-29 17:10:19 +00001010 temp = bb_get_chunk_from_file(fp, &len);
Rob Landley2b26fd52006-02-24 02:30:39 +00001011 if (temp) {
Denis Vlasenko8b22b072006-12-02 17:58:10 +00001012 /* len > 0 here, it's ok to do temp[len-1] */
1013 char c = temp[len-1];
1014 if (c == '\n' || c == '\0') {
1015 temp[len-1] = '\0';
Denis Vlasenkoc562bb72007-01-29 17:08:51 +00001016 gc = c;
Denis Vlasenko86811802007-01-29 17:10:19 +00001017 if (c == '\0') {
1018 int ch = fgetc(fp);
1019 if (ch != EOF)
1020 ungetc(ch, fp);
1021 else
1022 gc = LAST_IS_NUL;
1023 }
Denis Vlasenko8b22b072006-12-02 17:58:10 +00001024 }
Denis Vlasenkoc562bb72007-01-29 17:08:51 +00001025 /* else we put NO_EOL_CHAR into *gets_char */
1026 break;
1027
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001028 /* NB: I had the idea of peeking next file(s) and returning
1029 * NO_EOL_CHAR only if it is the *last* non-empty
1030 * input file. But there is a case where this won't work:
1031 * file1: "a woo\nb woo"
1032 * file2: "c no\nd no"
1033 * sed -ne 's/woo/bang/p' input1 input2 => "a bang\nb bang"
1034 * (note: *no* newline after "b bang"!) */
Denis Vlasenko8b22b072006-12-02 17:58:10 +00001035 }
1036 /* Close this file and advance to next one */
Denys Vlasenko259b3c02013-11-28 03:14:16 +01001037 fclose_if_not_stdin(fp);
1038 G.current_fp = NULL;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001039 }
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001040 *gets_char = gc;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001041 return temp;
1042}
1043
Denis Vlasenko17a15262007-03-26 20:48:46 +00001044#define sed_puts(s, n) (puts_maybe_newline(s, G.nonstdout, &last_puts_char, n))
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001045
Denis Vlasenko8274e062007-08-06 03:41:08 +00001046static int beg_match(sed_cmd_t *sed_cmd, const char *pattern_space)
1047{
1048 int retval = sed_cmd->beg_match && !regexec(sed_cmd->beg_match, pattern_space, 0, NULL, 0);
1049 if (retval)
1050 G.previous_regex_ptr = sed_cmd->beg_match;
1051 return retval;
1052}
1053
Rob Landley2b26fd52006-02-24 02:30:39 +00001054/* Process all the lines in all the files */
1055
Rob Landleydcc28662004-11-25 07:21:47 +00001056static void process_files(void)
Mark Whitley6315ce62000-07-10 22:55:51 +00001057{
Rob Landleyce4f0e92004-10-30 06:54:19 +00001058 char *pattern_space, *next_line;
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001059 int linenum = 0;
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001060 char last_puts_char = '\n';
1061 char last_gets_char, next_gets_char;
Denis Vlasenko2ea630f2006-12-10 02:52:19 +00001062 sed_cmd_t *sed_cmd;
1063 int substituted;
Mark Whitley6315ce62000-07-10 22:55:51 +00001064
Rob Landley2b26fd52006-02-24 02:30:39 +00001065 /* Prime the pump */
Denys Vlasenkof2559e52016-05-06 18:25:56 +02001066 next_line = get_next_line(&next_gets_char, &last_puts_char);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001067
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001068 /* Go through every line in each file */
Denis Vlasenkof39c7c02008-02-28 17:59:01 +00001069 again:
Denis Vlasenko2ea630f2006-12-10 02:52:19 +00001070 substituted = 0;
Glenn L McGrath505bd0f2003-03-08 05:21:02 +00001071
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001072 /* Advance to next line. Stop if out of lines. */
1073 pattern_space = next_line;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001074 if (!pattern_space)
1075 return;
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001076 last_gets_char = next_gets_char;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001077
1078 /* Read one line in advance so we can act on the last line,
1079 * the '$' address */
Denys Vlasenkof2559e52016-05-06 18:25:56 +02001080 next_line = get_next_line(&next_gets_char, &last_puts_char);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001081 linenum++;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001082
1083 /* For every line, go through all the commands */
Denis Vlasenkof39c7c02008-02-28 17:59:01 +00001084 restart:
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001085 for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001086 int old_matched, matched;
Eric Andersen52a3c272003-12-23 08:53:51 +00001087
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001088 old_matched = sed_cmd->in_match;
Mark Whitley0915c4b2001-06-11 23:50:06 +00001089
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001090 /* Determine if this command matches this line: */
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001091
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001092 dbg("match1:%d", sed_cmd->in_match);
1093 dbg("match2:%d", (!sed_cmd->beg_line && !sed_cmd->end_line
1094 && !sed_cmd->beg_match && !sed_cmd->end_match));
1095 dbg("match3:%d", (sed_cmd->beg_line > 0
1096 && (sed_cmd->end_line || sed_cmd->end_match
1097 ? (sed_cmd->beg_line <= linenum)
1098 : (sed_cmd->beg_line == linenum)
1099 )
1100 ));
1101 dbg("match4:%d", (beg_match(sed_cmd, pattern_space)));
1102 dbg("match5:%d", (sed_cmd->beg_line == -1 && next_line == NULL));
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001103
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001104 /* Are we continuing a previous multi-line match? */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001105 sed_cmd->in_match = sed_cmd->in_match
1106 /* Or is no range necessary? */
1107 || (!sed_cmd->beg_line && !sed_cmd->end_line
1108 && !sed_cmd->beg_match && !sed_cmd->end_match)
1109 /* Or did we match the start of a numerical range? */
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001110 || (sed_cmd->beg_line > 0
1111 && (sed_cmd->end_line || sed_cmd->end_match
Denys Vlasenkoc4679242010-06-04 01:31:48 +02001112 /* note: even if end is numeric and is < linenum too,
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001113 * GNU sed matches! We match too, therefore we don't
1114 * check here that linenum <= end.
1115 * Example:
1116 * printf '1\n2\n3\n4\n' | sed -n '1{N;N;d};1p;2,3p;3p;4p'
1117 * first three input lines are deleted;
1118 * 4th line is matched and printed
1119 * by "2,3" (!) and by "4" ranges
1120 */
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001121 ? (sed_cmd->beg_line <= linenum) /* N,end */
1122 : (sed_cmd->beg_line == linenum) /* N */
1123 )
1124 )
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001125 /* Or does this line match our begin address regex? */
Denis Vlasenko8274e062007-08-06 03:41:08 +00001126 || (beg_match(sed_cmd, pattern_space))
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001127 /* Or did we match last line of input? */
1128 || (sed_cmd->beg_line == -1 && next_line == NULL);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001129
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001130 /* Snapshot the value */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001131 matched = sed_cmd->in_match;
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001132
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001133 dbg("cmd:'%c' matched:%d beg_line:%d end_line:%d linenum:%d",
1134 sed_cmd->cmd, matched, sed_cmd->beg_line, sed_cmd->end_line, linenum);
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001135
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001136 /* Is this line the end of the current match? */
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001137
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001138 if (matched) {
Denys Vlasenko63f4d322015-04-17 14:24:55 +02001139 if (sed_cmd->end_line <= -2) {
1140 /* address2 is +N, i.e. N lines from beg_line */
1141 sed_cmd->end_line = linenum + (-sed_cmd->end_line - 2);
1142 }
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001143 /* once matched, "n,xxx" range is dead, disabling it */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001144 if (sed_cmd->beg_line > 0) {
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001145 sed_cmd->beg_line = -2;
Denys Vlasenko2e284a42010-08-01 04:14:46 +02001146 }
Denys Vlasenko63f4d322015-04-17 14:24:55 +02001147 dbg("end1:%d", sed_cmd->end_line ? sed_cmd->end_line == -1
1148 ? !next_line : (sed_cmd->end_line <= linenum)
1149 : !sed_cmd->end_match);
1150 dbg("end2:%d", sed_cmd->end_match && old_matched
1151 && !regexec(sed_cmd->end_match,pattern_space, 0, NULL, 0));
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001152 sed_cmd->in_match = !(
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001153 /* has the ending line come, or is this a single address command? */
Denys Vlasenko52d83702011-05-03 00:51:43 +02001154 (sed_cmd->end_line
1155 ? sed_cmd->end_line == -1
1156 ? !next_line
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001157 : (sed_cmd->end_line <= linenum)
1158 : !sed_cmd->end_match
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001159 )
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001160 /* or does this line matches our last address regex */
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001161 || (sed_cmd->end_match && old_matched
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001162 && (regexec(sed_cmd->end_match,
Denys Vlasenko6830ade2013-01-15 13:58:01 +01001163 pattern_space, 0, NULL, 0) == 0)
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001164 )
Denys Vlasenko8e96b5b2009-07-14 01:02:57 +02001165 );
Erik Andersene49d5ec2000-02-08 19:58:47 +00001166 }
Erik Andersen1266a131999-12-29 22:19:46 +00001167
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001168 /* Skip blocks of commands we didn't match */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001169 if (sed_cmd->cmd == '{') {
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001170 if (sed_cmd->invert ? matched : !matched) {
Denys Vlasenkof2c16ed2010-04-20 04:00:03 -04001171 unsigned nest_cnt = 0;
1172 while (1) {
1173 if (sed_cmd->cmd == '{')
1174 nest_cnt++;
1175 if (sed_cmd->cmd == '}') {
1176 nest_cnt--;
1177 if (nest_cnt == 0)
1178 break;
1179 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001180 sed_cmd = sed_cmd->next;
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001181 if (!sed_cmd)
1182 bb_error_msg_and_die("unterminated {");
1183 }
1184 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001185 continue;
1186 }
Glenn L McGrathaa5a6022003-10-01 03:06:16 +00001187
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001188 /* Okay, so did this line match? */
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001189 if (sed_cmd->invert ? matched : !matched)
1190 continue; /* no */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001191
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001192 /* Update last used regex in case a blank substitute BRE is found */
1193 if (sed_cmd->beg_match) {
1194 G.previous_regex_ptr = sed_cmd->beg_match;
1195 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001196
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001197 /* actual sedding */
Denys Vlasenkod29ae7e2012-01-15 20:06:03 +01001198 dbg("pattern_space:'%s' next_line:'%s' cmd:%c",
1199 pattern_space, next_line, sed_cmd->cmd);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001200 switch (sed_cmd->cmd) {
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001201
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001202 /* Print line number */
1203 case '=':
1204 fprintf(G.nonstdout, "%d\n", linenum);
1205 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001206
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001207 /* Write the current pattern space up to the first newline */
1208 case 'P':
1209 {
1210 char *tmp = strchr(pattern_space, '\n');
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001211 if (tmp) {
1212 *tmp = '\0';
1213 /* TODO: explain why '\n' below */
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001214 sed_puts(pattern_space, '\n');
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001215 *tmp = '\n';
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001216 break;
1217 }
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001218 /* Fall Through */
1219 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001220
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001221 /* Write the current pattern space to output */
1222 case 'p':
1223 /* NB: we print this _before_ the last line
1224 * (of current file) is printed. Even if
1225 * that line is nonterminated, we print
1226 * '\n' here (gnu sed does the same) */
1227 sed_puts(pattern_space, '\n');
1228 break;
1229 /* Delete up through first newline */
1230 case 'D':
1231 {
1232 char *tmp = strchr(pattern_space, '\n');
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001233 if (tmp) {
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001234 overlapping_strcpy(pattern_space, tmp + 1);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001235 goto restart;
1236 }
1237 }
1238 /* discard this line. */
1239 case 'd':
1240 goto discard_line;
1241
1242 /* Substitute with regex */
1243 case 's':
1244 if (!do_subst_command(sed_cmd, &pattern_space))
1245 break;
Denys Vlasenko21f6fbf2012-06-04 14:44:47 +02001246 dbg("do_subst_command succeeded:'%s'", pattern_space);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001247 substituted |= 1;
1248
1249 /* handle p option */
1250 if (sed_cmd->sub_p)
1251 sed_puts(pattern_space, last_gets_char);
1252 /* handle w option */
1253 if (sed_cmd->sw_file)
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001254 puts_maybe_newline(
1255 pattern_space, sed_cmd->sw_file,
1256 &sed_cmd->sw_last_char, last_gets_char);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001257 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001258
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001259 /* Append line to linked list to be printed later */
1260 case 'a':
Denys Vlasenko9d46a7a2013-10-30 10:22:47 +01001261 append(xstrdup(sed_cmd->string));
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001262 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001263
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001264 /* Insert text before this line */
1265 case 'i':
1266 sed_puts(sed_cmd->string, '\n');
1267 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001268
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001269 /* Cut and paste text (replace) */
1270 case 'c':
1271 /* Only triggers on last line of a matching range. */
1272 if (!sed_cmd->in_match)
Denys Vlasenko96a18332010-04-19 22:36:07 -04001273 sed_puts(sed_cmd->string, '\n');
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001274 goto discard_line;
1275
1276 /* Read file, append contents to output */
1277 case 'r':
1278 {
1279 FILE *rfile;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001280 rfile = fopen_for_read(sed_cmd->string);
1281 if (rfile) {
1282 char *line;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001283 while ((line = xmalloc_fgetline(rfile))
1284 != NULL)
1285 append(line);
Denys Vlasenko9d46a7a2013-10-30 10:22:47 +01001286 fclose(rfile);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001287 }
1288
1289 break;
1290 }
1291
1292 /* Write pattern space to file. */
1293 case 'w':
1294 puts_maybe_newline(
1295 pattern_space, sed_cmd->sw_file,
1296 &sed_cmd->sw_last_char, last_gets_char);
1297 break;
1298
1299 /* Read next line from input */
1300 case 'n':
1301 if (!G.be_quiet)
1302 sed_puts(pattern_space, last_gets_char);
1303 if (next_line) {
1304 free(pattern_space);
1305 pattern_space = next_line;
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001306 last_gets_char = next_gets_char;
Denys Vlasenkof2559e52016-05-06 18:25:56 +02001307 next_line = get_next_line(&next_gets_char, &last_puts_char);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001308 substituted = 0;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001309 linenum++;
1310 break;
1311 }
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001312 /* fall through */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001313
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001314 /* Quit. End of script, end of input. */
1315 case 'q':
1316 /* Exit the outer while loop */
1317 free(next_line);
1318 next_line = NULL;
1319 goto discard_commands;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001320
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001321 /* Append the next line to the current line */
1322 case 'N':
1323 {
1324 int len;
1325 /* If no next line, jump to end of script and exit. */
Denys Vlasenko0d555fc2010-08-16 16:26:33 +02001326 /* http://www.gnu.org/software/sed/manual/sed.html:
1327 * "Most versions of sed exit without printing anything
1328 * when the N command is issued on the last line of
1329 * a file. GNU sed prints pattern space before exiting
1330 * unless of course the -n command switch has been
1331 * specified. This choice is by design."
1332 */
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001333 if (next_line == NULL) {
Denys Vlasenko0d555fc2010-08-16 16:26:33 +02001334 //goto discard_line;
1335 goto discard_commands; /* GNU behavior */
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001336 }
Denys Vlasenkobf5f99f2010-06-04 01:29:52 +02001337 /* Append next_line, read new next_line. */
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001338 len = strlen(pattern_space);
Denys Vlasenko90377872010-01-08 09:07:50 +01001339 pattern_space = xrealloc(pattern_space, len + strlen(next_line) + 2);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001340 pattern_space[len] = '\n';
1341 strcpy(pattern_space + len+1, next_line);
1342 last_gets_char = next_gets_char;
Denys Vlasenkof2559e52016-05-06 18:25:56 +02001343 next_line = get_next_line(&next_gets_char, &last_puts_char);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001344 linenum++;
1345 break;
1346 }
1347
1348 /* Test/branch if substitution occurred */
1349 case 't':
1350 if (!substituted) break;
1351 substituted = 0;
1352 /* Fall through */
1353 /* Test/branch if substitution didn't occur */
1354 case 'T':
1355 if (substituted) break;
1356 /* Fall through */
1357 /* Branch to label */
1358 case 'b':
1359 if (!sed_cmd->string) goto discard_commands;
1360 else sed_cmd = branch_to(sed_cmd->string);
1361 break;
1362 /* Transliterate characters */
1363 case 'y':
1364 {
1365 int i, j;
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001366 for (i = 0; pattern_space[i]; i++) {
1367 for (j = 0; sed_cmd->string[j]; j += 2) {
1368 if (pattern_space[i] == sed_cmd->string[j]) {
1369 pattern_space[i] = sed_cmd->string[j + 1];
1370 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001371 }
1372 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001373 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001374
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001375 break;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001376 }
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001377 case 'g': /* Replace pattern space with hold space */
1378 free(pattern_space);
1379 pattern_space = xstrdup(G.hold_space ? G.hold_space : "");
1380 break;
1381 case 'G': /* Append newline and hold space to pattern space */
1382 {
1383 int pattern_space_size = 2;
1384 int hold_space_size = 0;
1385
1386 if (pattern_space)
1387 pattern_space_size += strlen(pattern_space);
1388 if (G.hold_space)
1389 hold_space_size = strlen(G.hold_space);
1390 pattern_space = xrealloc(pattern_space,
1391 pattern_space_size + hold_space_size);
1392 if (pattern_space_size == 2)
1393 pattern_space[0] = 0;
1394 strcat(pattern_space, "\n");
1395 if (G.hold_space)
1396 strcat(pattern_space, G.hold_space);
1397 last_gets_char = '\n';
1398
1399 break;
1400 }
1401 case 'h': /* Replace hold space with pattern space */
1402 free(G.hold_space);
1403 G.hold_space = xstrdup(pattern_space);
1404 break;
1405 case 'H': /* Append newline and pattern space to hold space */
1406 {
1407 int hold_space_size = 2;
1408 int pattern_space_size = 0;
1409
1410 if (G.hold_space)
1411 hold_space_size += strlen(G.hold_space);
1412 if (pattern_space)
1413 pattern_space_size = strlen(pattern_space);
1414 G.hold_space = xrealloc(G.hold_space,
1415 hold_space_size + pattern_space_size);
1416
1417 if (hold_space_size == 2)
1418 *G.hold_space = 0;
1419 strcat(G.hold_space, "\n");
1420 if (pattern_space)
1421 strcat(G.hold_space, pattern_space);
1422
1423 break;
1424 }
1425 case 'x': /* Exchange hold and pattern space */
1426 {
1427 char *tmp = pattern_space;
Denys Vlasenko90a99042009-09-06 02:36:23 +02001428 pattern_space = G.hold_space ? G.hold_space : xzalloc(1);
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001429 last_gets_char = '\n';
1430 G.hold_space = tmp;
1431 break;
1432 }
1433 } /* switch */
1434 } /* for each cmd */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001435
1436 /*
Denys Vlasenko8bca3e22009-06-30 19:19:37 +02001437 * Exit point from sedding...
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001438 */
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001439 discard_commands:
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001440 /* we will print the line unless we were told to be quiet ('-n')
1441 or if the line was suppressed (ala 'd'elete) */
Denis Vlasenko17a15262007-03-26 20:48:46 +00001442 if (!G.be_quiet)
Denis Vlasenkofe7a9f12007-01-29 14:31:47 +00001443 sed_puts(pattern_space, last_gets_char);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001444
1445 /* Delete and such jump here. */
Denis Vlasenko826c85f2007-01-28 23:26:15 +00001446 discard_line:
Denys Vlasenkof2559e52016-05-06 18:25:56 +02001447 flush_append(&last_puts_char /*,last_gets_char*/);
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001448 free(pattern_space);
1449
1450 goto again;
Erik Andersen1266a131999-12-29 22:19:46 +00001451}
1452
Glenn L McGrath42c25732003-10-04 05:27:56 +00001453/* It is possible to have a command line argument with embedded
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001454 * newlines. This counts as multiple command lines.
1455 * However, newline can be escaped: 's/e/z\<newline>z/'
Denys Vlasenko40ab27a2013-07-08 02:04:44 +02001456 * add_cmd() handles this.
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001457 */
Glenn L McGrath42c25732003-10-04 05:27:56 +00001458
1459static void add_cmd_block(char *cmdstr)
1460{
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001461 char *sv, *eol;
Glenn L McGrath42c25732003-10-04 05:27:56 +00001462
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001463 cmdstr = sv = xstrdup(cmdstr);
1464 do {
1465 eol = strchr(cmdstr, '\n');
Denys Vlasenko40ab27a2013-07-08 02:04:44 +02001466 if (eol)
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001467 *eol = '\0';
Denis Vlasenko4b0bb9e2007-03-16 23:36:58 +00001468 add_cmd(cmdstr);
1469 cmdstr = eol + 1;
1470 } while (eol);
1471 free(sv);
Glenn L McGrath42c25732003-10-04 05:27:56 +00001472}
1473
Denis Vlasenko9b49a5e2007-10-11 10:05:36 +00001474int sed_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
Denis Vlasenkoa60f84e2008-07-05 09:18:54 +00001475int sed_main(int argc UNUSED_PARAM, char **argv)
Eric Andersen6b6b3f61999-10-28 16:06:25 +00001476{
Denis Vlasenko67b23e62006-10-03 21:00:06 +00001477 unsigned opt;
Denis Vlasenkob97c9842006-10-01 21:05:12 +00001478 llist_t *opt_e, *opt_f;
Simon B8c343952012-05-06 13:59:15 +02001479 char *opt_i;
1480
1481#if ENABLE_LONG_OPTS
1482 static const char sed_longopts[] ALIGN1 =
1483 /* name has_arg short */
1484 "in-place\0" Optional_argument "i"
1485 "regexp-extended\0" No_argument "r"
1486 "quiet\0" No_argument "n"
1487 "silent\0" No_argument "n"
1488 "expression\0" Required_argument "e"
1489 "file\0" Required_argument "f";
1490#endif
1491
Denis Vlasenko74324c82007-06-04 10:16:52 +00001492 INIT_G();
Rob Landleye3f5a3f2006-05-09 03:53:55 +00001493
Mark Whitley858c1ad2000-07-11 21:38:47 +00001494 /* destroy command strings on exit */
Rob Landley0b656282006-05-08 22:17:23 +00001495 if (ENABLE_FEATURE_CLEAN_UP) atexit(sed_free_and_close_stuff);
Mark Whitley858c1ad2000-07-11 21:38:47 +00001496
Rob Landleyfae1dc82005-11-20 07:44:35 +00001497 /* Lie to autoconf when it starts asking stupid questions. */
Simon B8c343952012-05-06 13:59:15 +02001498 if (argv[1] && strcmp(argv[1], "--version") == 0) {
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001499 puts("This is not GNU sed version 4.0");
1500 return 0;
Eric Andersenc06f5682004-02-04 10:57:46 +00001501 }
Eric Andersenc06f5682004-02-04 10:57:46 +00001502
Mark Whitley6315ce62000-07-10 22:55:51 +00001503 /* do normal option parsing */
Denis Vlasenkob97c9842006-10-01 21:05:12 +00001504 opt_e = opt_f = NULL;
Simon B8c343952012-05-06 13:59:15 +02001505 opt_i = NULL;
Denys Vlasenko237bedd2016-07-06 21:58:02 +02001506 opt_complementary = "nn"; /* count -n */
Simon B8c343952012-05-06 13:59:15 +02001507
1508 IF_LONG_OPTS(applet_long_options = sed_longopts);
1509
Denys Vlasenko2e284a42010-08-01 04:14:46 +02001510 /* -i must be first, to match OPT_in_place definition */
David A. Wheeleraf0cdee2013-10-29 00:52:48 +01001511 /* -E is a synonym of -r:
1512 * GNU sed 4.2.1 mentions it in neither --help
1513 * nor manpage, but does recognize it.
1514 */
Denys Vlasenko237bedd2016-07-06 21:58:02 +02001515 opt = getopt32(argv, "i::rEne:*f:*", &opt_i, &opt_e, &opt_f,
Denis Vlasenko17a15262007-03-26 20:48:46 +00001516 &G.be_quiet); /* counter for -n */
Denis Vlasenko62a90cd2008-03-17 09:07:36 +00001517 //argc -= optind;
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001518 argv += optind;
1519 if (opt & OPT_in_place) { // -i
Denis Vlasenko750fc6d2006-09-22 08:56:03 +00001520 atexit(cleanup_outname);
1521 }
David A. Wheeleraf0cdee2013-10-29 00:52:48 +01001522 if (opt & (2|4))
1523 G.regex_type |= REG_EXTENDED; // -r or -E
1524 //if (opt & 8)
1525 // G.be_quiet++; // -n (implemented with a counter instead)
Denis Vlasenko945bd3d2007-04-12 21:20:25 +00001526 while (opt_e) { // -e
Denis Vlasenkod50dda82008-06-15 05:40:56 +00001527 add_cmd_block(llist_pop(&opt_e));
Denis Vlasenko750fc6d2006-09-22 08:56:03 +00001528 }
Denis Vlasenko945bd3d2007-04-12 21:20:25 +00001529 while (opt_f) { // -f
1530 char *line;
1531 FILE *cmdfile;
Denys Vlasenkoe4d925b2016-04-08 00:20:36 +02001532 cmdfile = xfopen_stdin(llist_pop(&opt_f));
Denis Vlasenko8ee649a2008-03-26 20:04:27 +00001533 while ((line = xmalloc_fgetline(cmdfile)) != NULL) {
Denis Vlasenko945bd3d2007-04-12 21:20:25 +00001534 add_cmd(line);
1535 free(line);
1536 }
Denys Vlasenkoe4d925b2016-04-08 00:20:36 +02001537 fclose_if_not_stdin(cmdfile);
Eric Andersen6b6b3f61999-10-28 16:06:25 +00001538 }
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001539 /* if we didn't get a pattern from -e or -f, use argv[0] */
David A. Wheeleraf0cdee2013-10-29 00:52:48 +01001540 if (!(opt & 0x30)) {
Denis Vlasenko62a90cd2008-03-17 09:07:36 +00001541 if (!*argv)
Manuel Novoa III cad53642003-03-19 09:13:01 +00001542 bb_show_usage();
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001543 add_cmd_block(*argv++);
Mark Whitley6315ce62000-07-10 22:55:51 +00001544 }
Glenn L McGrath42c25732003-10-04 05:27:56 +00001545 /* Flush any unfinished commands. */
1546 add_cmd("");
Mark Whitley6315ce62000-07-10 22:55:51 +00001547
Rob Landley53302f82004-02-18 09:54:15 +00001548 /* By default, we write to stdout */
Denis Vlasenko17a15262007-03-26 20:48:46 +00001549 G.nonstdout = stdout;
Rob Landley53302f82004-02-18 09:54:15 +00001550
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001551 /* argv[0..(argc-1)] should be names of file to process. If no
Mark Whitley6315ce62000-07-10 22:55:51 +00001552 * files were specified or '-' was specified, take input from stdin.
1553 * Otherwise, we process all the files specified. */
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001554 G.input_file_list = argv;
1555 if (!argv[0]) {
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001556 if (opt & OPT_in_place)
Denis Vlasenko80778502006-10-25 12:46:46 +00001557 bb_error_msg_and_die(bb_msg_requires_arg, "-i");
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001558 argv[0] = (char*)bb_msg_standard_input;
1559 /* G.last_input_file = 0; - already is */
Glenn L McGrath8d6395d2003-04-08 11:56:11 +00001560 } else {
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001561 goto start;
Glenn L McGrath8d6395d2003-04-08 11:56:11 +00001562
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001563 for (; *argv; argv++) {
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001564 struct stat statbuf;
1565 int nonstdoutfd;
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001566 sed_cmd_t *sed_cmd;
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001567
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001568 G.last_input_file++;
1569 start:
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001570 if (!(opt & OPT_in_place)) {
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001571 if (LONE_DASH(*argv)) {
1572 *argv = (char*)bb_msg_standard_input;
1573 process_files();
1574 }
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001575 continue;
1576 }
1577
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001578 /* -i: process each FILE separately: */
1579
Denys Vlasenkocd738712014-10-05 02:44:34 +02001580 if (stat(*argv, &statbuf) != 0) {
1581 bb_simple_perror_msg(*argv);
1582 G.exitcode = EXIT_FAILURE;
1583 G.current_input_file++;
1584 continue;
1585 }
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001586 G.outname = xasprintf("%sXXXXXX", *argv);
Alexander Shishkin67227372010-10-22 13:27:16 +02001587 nonstdoutfd = xmkstemp(G.outname);
Denys Vlasenkoa7ccdee2009-11-15 23:28:11 +01001588 G.nonstdout = xfdopen_for_write(nonstdoutfd);
Denys Vlasenko57992482009-11-13 09:09:07 +01001589 /* Set permissions/owner of output file */
Denys Vlasenko3b727cc2010-06-18 02:12:56 +02001590 /* chmod'ing AFTER chown would preserve suid/sgid bits,
1591 * but GNU sed 4.2.1 does not preserve them either */
Denis Vlasenko2f8f71b2006-12-10 02:09:12 +00001592 fchmod(nonstdoutfd, statbuf.st_mode);
Denys Vlasenko57992482009-11-13 09:09:07 +01001593 fchown(nonstdoutfd, statbuf.st_uid, statbuf.st_gid);
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001594
Denis Vlasenkod18a3a22006-10-25 12:46:03 +00001595 process_files();
Denis Vlasenko17a15262007-03-26 20:48:46 +00001596 fclose(G.nonstdout);
Denis Vlasenko17a15262007-03-26 20:48:46 +00001597 G.nonstdout = stdout;
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001598
Simon B8c343952012-05-06 13:59:15 +02001599 if (opt_i) {
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001600 char *backupname = xasprintf("%s%s", *argv, opt_i);
1601 xrename(*argv, backupname);
Simon B8c343952012-05-06 13:59:15 +02001602 free(backupname);
1603 }
Denys Vlasenkodeb07692013-11-28 12:08:51 +01001604 /* else unlink(*argv); - rename below does this */
1605 xrename(G.outname, *argv); //TODO: rollback backup on error?
Denis Vlasenko17a15262007-03-26 20:48:46 +00001606 free(G.outname);
Denis Vlasenko40276642007-11-13 16:48:10 +00001607 G.outname = NULL;
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001608
Denys Vlasenko63f4d322015-04-17 14:24:55 +02001609 /* Fix disabled range matches and mangled ",+N" ranges */
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001610 for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
1611 sed_cmd->beg_line = sed_cmd->beg_line_orig;
Denys Vlasenko63f4d322015-04-17 14:24:55 +02001612 sed_cmd->end_line = sed_cmd->end_line_orig;
Denys Vlasenkoa7d6bb32011-08-16 13:29:34 +02001613 }
Mark Whitley6315ce62000-07-10 22:55:51 +00001614 }
Denys Vlasenkoeb08b6e2010-06-19 17:51:06 +02001615 /* Here, to handle "sed 'cmds' nonexistent_file" case we did:
Denys Vlasenko259b3c02013-11-28 03:14:16 +01001616 * if (G.current_input_file[G.current_input_file] == NULL)
1617 * return G.exitcode;
Denys Vlasenkoeb08b6e2010-06-19 17:51:06 +02001618 * but it's not needed since process_files() works correctly
1619 * in this case too. */
Mark Whitley6315ce62000-07-10 22:55:51 +00001620 }
Denys Vlasenko259b3c02013-11-28 03:14:16 +01001621
Denys Vlasenkoeb08b6e2010-06-19 17:51:06 +02001622 process_files();
Glenn L McGrath8d6395d2003-04-08 11:56:11 +00001623
Denys Vlasenko259b3c02013-11-28 03:14:16 +01001624 return G.exitcode;
Eric Andersen6b6b3f61999-10-28 16:06:25 +00001625}