1 /* vi: set sw=4 ts=4: */
3 * sed.c - very minimalist version of sed
5 * Copyright (C) 1999,2000,2001 by Lineo, inc. and Mark Whitley
6 * Copyright (C) 1999,2000,2001 by Mark Whitley <markw@codepoet.org>
7 * Copyright (C) 2002 Matt Kraai
8 * Copyright (C) 2003 by Glenn McGrath
9 * Copyright (C) 2003,2004 by Rob Landley <rob@landley.net>
11 * MAINTAINER: Rob Landley <rob@landley.net>
13 * Licensed under GPLv2, see file LICENSE in this source tree.
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.
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).
26 * process_files() does actual sedding, reading data lines from each input FILE*
27 * (which could be stdin) and applying the sed command list (sed_cmd_head) to
28 * each of the resulting lines.
30 * sed_main() is where external code calls into this, with a command line.
33 /* Supported features and commands in this version of sed:
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)
46 * (Note: Specifying an address (range) to match is *optional*; commands
47 * default to the whole pattern space if no specific address match was
51 * - Create a wrapper around regex to make libc's regex conform with sed
54 * http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
55 * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html
56 * http://sed.sourceforge.net/sedfaq3.html
63 //config: sed is used to perform text transformations on a file
64 //config: or input from a pipeline.
66 //kbuild:lib-$(CONFIG_SED) += sed.o
68 //applet:IF_SED(APPLET(sed, BB_DIR_BIN, BB_SUID_DROP))
70 //usage:#define sed_trivial_usage
71 //usage: "[-inrE] [-f FILE]... [-e CMD]... [FILE]...\n"
72 //usage: "or: sed [-inrE] CMD [FILE]..."
73 //usage:#define sed_full_usage "\n\n"
74 //usage: " -e CMD Add CMD to sed commands to be executed"
75 //usage: "\n -f FILE Add FILE contents to sed commands to be executed"
76 //usage: "\n -i[SFX] Edit files in-place (otherwise sends to stdout)"
77 //usage: "\n Optionally back files up, appending SFX"
78 //usage: "\n -n Suppress automatic printing of pattern space"
79 //usage: "\n -r,-E Use extended regex syntax"
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)."
84 //usage:#define sed_example_usage
85 //usage: "$ echo \"foo\" | sed -e 's/f[a-zA-Z]o/bar/g'\n"
89 #include "common_bufsiz.h"
93 # define dbg(...) bb_error_msg(__VA_ARGS__)
95 # define dbg(...) ((void)0)
100 OPT_in_place
= 1 << 0,
103 /* Each sed command turns into one of these structures. */
104 typedef struct sed_cmd_s
{
105 /* Ordered by alignment requirements: currently 36 bytes on x86 */
106 struct sed_cmd_s
*next
; /* Next command (linked list, NULL terminated) */
108 /* 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 */
113 int beg_line_orig
; /* copy of the above, needed for -i */
114 int end_line
; /* 'sed 1,3p' 0 == one line only. -1 = last line ($). -2-N = +N */
117 FILE *sw_file
; /* File (sw) command writes to, NULL for none. */
118 char *string
; /* Data string for (saicytb) commands. */
120 unsigned which_match
; /* (s) Which match to replace (0 for all) */
122 /* Bitfields (gcc won't group them if we don't) */
123 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 */
127 char sw_last_char
; /* Last line written by (sw) had no '\n' */
130 char cmd
; /* The command char: abcdDgGhHilnNpPqrstwxy:={} */
133 static const char semicolon_whitespace
[] ALIGN1
= "; \n\r\t\v";
137 int be_quiet
, regex_type
;
140 char *outname
, *hold_space
;
143 /* list of input files */
144 int current_input_file
, last_input_file
;
145 char **input_file_list
;
148 regmatch_t regmatch
[10];
149 regex_t
*previous_regex_ptr
;
151 /* linked list of sed commands */
152 sed_cmd_t
*sed_cmd_head
, **sed_cmd_tail
;
154 /* linked list of append lines */
155 llist_t
*append_head
;
160 char *buf
; /* Space to hold string */
161 int idx
; /* Space used */
162 int len
; /* Space allocated */
165 #define G (*(struct globals*)bb_common_bufsiz1)
166 #define INIT_G() do { \
167 setup_common_bufsiz(); \
168 BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
169 G.sed_cmd_tail = &G.sed_cmd_head; \
173 #if ENABLE_FEATURE_CLEAN_UP
174 static void sed_free_and_close_stuff(void)
176 sed_cmd_t
*sed_cmd
= G
.sed_cmd_head
;
178 llist_free(G
.append_head
, free
);
181 sed_cmd_t
*sed_cmd_next
= sed_cmd
->next
;
183 if (sed_cmd
->sw_file
)
184 fclose(sed_cmd
->sw_file
);
186 if (sed_cmd
->beg_match
) {
187 regfree(sed_cmd
->beg_match
);
188 free(sed_cmd
->beg_match
);
190 if (sed_cmd
->end_match
) {
191 regfree(sed_cmd
->end_match
);
192 free(sed_cmd
->end_match
);
194 if (sed_cmd
->sub_match
) {
195 regfree(sed_cmd
->sub_match
);
196 free(sed_cmd
->sub_match
);
198 free(sed_cmd
->string
);
200 sed_cmd
= sed_cmd_next
;
206 fclose(G
.current_fp
);
209 void sed_free_and_close_stuff(void);
212 /* If something bad happens during -i operation, delete temp file */
214 static void cleanup_outname(void)
216 if (G
.outname
) unlink(G
.outname
);
219 /* strcpy, replacing "\from" with 'to'. If to is NUL, replacing "\any" with 'any' */
221 static unsigned parse_escapes(char *dest
, const char *string
, int len
, char from
, char to
)
227 len
= strlen(string
);
230 if (string
[i
] == '\\') {
231 if (!to
|| string
[i
+1] == from
) {
232 if ((*d
= to
? to
: string
[i
+1]) == '\0')
238 i
++; /* skip backslash in string[] */
240 /* fall through: copy next char verbatim */
242 if ((*d
= string
[i
++]) == '\0')
250 static char *copy_parsing_escapes(const char *string
, int len
)
253 char *dest
= xmalloc(len
+ 1);
255 /* sed recognizes \n */
256 /* GNU sed also recognizes \t and \r */
257 for (s
= "\nn\tt\rr"; *s
; s
+= 2) {
258 len
= parse_escapes(dest
, string
, len
, s
[1], s
[0]);
266 * 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
268 * expression delimiter (typically a forward slash ('/')) not preceded by
269 * a backslash ('\'). A negative delimiter disables square bracket checking.
271 static int index_of_next_unescaped_regexp_delim(int delimiter
, const char *str
)
280 delimiter
= -delimiter
;
283 for (; (ch
= str
[idx
]) != '\0'; idx
++) {
286 && !(bracket
== idx
- 1 || (bracket
== idx
- 2 && str
[idx
- 1] == '^'))
294 else if (bracket
== -1 && ch
== '[')
296 else if (ch
== delimiter
)
300 /* if we make it to here, we've hit the end of the string */
301 bb_error_msg_and_die("unmatched '%c'", delimiter
);
305 * Returns the index of the third delimiter
307 static int parse_regex_delim(const char *cmdstr
, char **match
, char **replace
)
309 const char *cmdstr_ptr
= cmdstr
;
310 unsigned char delimiter
;
313 /* verify that the 's' or 'y' is followed by something. That something
314 * (typically a 'slash') is now our regexp delimiter... */
316 bb_error_msg_and_die("bad format in substitution expression");
317 delimiter
= *cmdstr_ptr
++;
319 /* save the match string */
320 idx
= index_of_next_unescaped_regexp_delim(delimiter
, cmdstr_ptr
);
321 *match
= copy_parsing_escapes(cmdstr_ptr
, idx
);
323 /* save the replacement string */
324 cmdstr_ptr
+= idx
+ 1;
325 idx
= index_of_next_unescaped_regexp_delim(- (int)delimiter
, cmdstr_ptr
);
326 *replace
= copy_parsing_escapes(cmdstr_ptr
, idx
);
328 return ((cmdstr_ptr
- cmdstr
) + idx
);
332 * returns the index in the string just past where the address ends.
334 static int get_address(const char *my_str
, int *linenum
, regex_t
** regex
)
336 const char *pos
= my_str
;
338 if (isdigit(*my_str
)) {
339 *linenum
= strtol(my_str
, (char**)&pos
, 10);
340 /* endstr shouldnt ever equal NULL */
341 } else if (*my_str
== '$') {
344 } else if (*my_str
== '/' || *my_str
== '\\') {
352 next
= index_of_next_unescaped_regexp_delim(delimiter
, ++pos
);
353 temp
= copy_parsing_escapes(pos
, next
);
354 *regex
= xzalloc(sizeof(regex_t
));
355 xregcomp(*regex
, temp
, G
.regex_type
);
357 /* Move position to next character after last delimiter */
363 /* Grab a filename. Whitespace at start is skipped, then goes to EOL. */
364 static int parse_file_cmd(/*sed_cmd_t *sed_cmd,*/ const char *filecmdstr
, char **retval
)
366 int start
= 0, idx
, hack
= 0;
368 /* Skip whitespace, then grab filename to end of line */
369 while (isspace(filecmdstr
[start
]))
372 while (filecmdstr
[idx
] && filecmdstr
[idx
] != '\n')
375 /* If lines glued together, put backslash back. */
376 if (filecmdstr
[idx
] == '\n')
379 bb_error_msg_and_die("empty filename");
380 *retval
= xstrndup(filecmdstr
+start
, idx
-start
+hack
+1);
382 (*retval
)[idx
] = '\\';
387 static int parse_subst_cmd(sed_cmd_t
*sed_cmd
, const char *substr
)
389 int cflags
= G
.regex_type
;
394 * A substitution command should look something like this:
395 * s/match/replace/ #giIpw
399 idx
= parse_regex_delim(substr
, &match
, &sed_cmd
->string
);
401 /* 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 */
406 /* process the flags */
408 sed_cmd
->which_match
= 1;
409 dbg("s flags:'%s'", substr
+ idx
+ 1);
410 while (substr
[++idx
]) {
411 dbg("s flag:'%c'", substr
[idx
]);
412 /* Parse match number */
413 if (isdigit(substr
[idx
])) {
414 if (match
[0] != '^') {
415 /* Match 0 treated as all, multiple matches we take the last one. */
416 const char *pos
= substr
+ idx
;
417 /* FIXME: error check? */
418 sed_cmd
->which_match
= (unsigned)strtol(substr
+idx
, (char**) &pos
, 10);
419 idx
= pos
- substr
- 1;
424 if (isspace(substr
[idx
]))
427 switch (substr
[idx
]) {
428 /* Replace all occurrences */
431 sed_cmd
->which_match
= 0;
433 /* Print pattern space */
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';
447 /* Ignore case (gnu exension) */
454 // while (substr[++idx]) continue;
455 idx
+= strlen(substr
+ idx
); // same
462 dbg("s bad flags:'%s'", substr
+ idx
);
463 bb_error_msg_and_die("bad option in substitution expression");
467 /* compile the match string into a regex */
468 if (*match
!= '\0') {
469 /* If match is empty, we use last regex used at runtime */
470 sed_cmd
->sub_match
= xzalloc(sizeof(regex_t
));
471 dbg("xregcomp('%s',%x)", match
, cflags
);
472 xregcomp(sed_cmd
->sub_match
, match
, cflags
);
481 * Process the commands arguments
483 static const char *parse_cmd_args(sed_cmd_t
*sed_cmd
, const char *cmdstr
)
485 static const char cmd_letters
[] ALIGN1
= "saicrw:btTydDgGhHlnNpPqx={}";
518 BUILD_BUG_ON(sizeof(cmd_letters
)-1 != IDX_nul
);
520 idx
= strchrnul(cmd_letters
, sed_cmd
->cmd
) - cmd_letters
;
522 /* handle (s)ubstitution command */
524 cmdstr
+= parse_subst_cmd(sed_cmd
, cmdstr
);
526 /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
527 else if (idx
<= IDX_c
) { /* a,i,c */
530 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
);
535 if (*cmdstr
== '\n' || *cmdstr
== '\\') {
539 if (!isspace(*cmdstr
))
543 len
= strlen(cmdstr
);
544 sed_cmd
->string
= copy_parsing_escapes(cmdstr
, len
);
546 /* "\anychar" -> "anychar" */
547 parse_escapes(sed_cmd
->string
, sed_cmd
->string
, -1, '\0', '\0');
549 /* handle file cmds: (r)ead */
550 else if (idx
<= IDX_w
) { /* r,w */
551 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
);
555 cmdstr
+= parse_file_cmd(/*sed_cmd,*/ cmdstr
, &sed_cmd
->string
);
556 if (sed_cmd
->cmd
== 'w') {
557 sed_cmd
->sw_file
= xfopen_for_write(sed_cmd
->string
);
558 sed_cmd
->sw_last_char
= '\n';
561 /* handle branch commands */
562 else if (idx
<= IDX_T
) { /* :,b,t,T */
565 cmdstr
= skip_whitespace(cmdstr
);
566 length
= strcspn(cmdstr
, semicolon_whitespace
);
568 sed_cmd
->string
= xstrndup(cmdstr
, length
);
572 /* translation command */
573 else if (idx
== IDX_y
) {
574 char *match
, *replace
;
577 cmdstr
+= parse_regex_delim(cmdstr
, &match
, &replace
)+1;
578 /* \n already parsed, but \delimiter needs unescaping. */
579 parse_escapes(match
, match
, -1, i
, i
);
580 parse_escapes(replace
, replace
, -1, i
, i
);
582 sed_cmd
->string
= xzalloc((strlen(match
) + 1) * 2);
583 for (i
= 0; match
[i
] && replace
[i
]; i
++) {
584 sed_cmd
->string
[i
*2] = match
[i
];
585 sed_cmd
->string
[i
*2+1] = replace
[i
];
590 /* if it wasnt a single-letter command that takes no arguments
591 * then it must be an invalid command.
593 else if (idx
>= IDX_nul
) { /* not d,D,g,G,h,H,l,n,N,p,P,q,x,=,{,} */
594 bb_error_msg_and_die("unsupported command %c", sed_cmd
->cmd
);
597 /* give back whatever's left over */
602 /* Parse address+command sets, skipping comment lines. */
604 static void add_cmd(const char *cmdstr
)
609 /* Append this line to any unfinished line from last time. */
610 if (G
.add_cmd_line
) {
611 char *tp
= xasprintf("%s\n%s", G
.add_cmd_line
, cmdstr
);
612 free(G
.add_cmd_line
);
613 cmdstr
= G
.add_cmd_line
= tp
;
616 /* If this line ends with unescaped backslash, request next line. */
617 n
= len
= strlen(cmdstr
);
618 while (n
&& cmdstr
[n
-1] == '\\')
620 if ((len
- n
) & 1) { /* if odd number of trailing backslashes */
622 G
.add_cmd_line
= xstrdup(cmdstr
);
623 G
.add_cmd_line
[len
-1] = '\0';
627 /* Loop parsing all commands in this line. */
629 /* Skip leading whitespace and semicolons */
630 cmdstr
+= strspn(cmdstr
, semicolon_whitespace
);
632 /* If no more commands, exit. */
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 */
638 if (cmdstr
[1] == 'n')
640 cmdstr
= strpbrk(cmdstr
, "\n\r");
646 * format is: [addr][,addr][!]cmd
651 sed_cmd
= xzalloc(sizeof(sed_cmd_t
));
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
);
655 sed_cmd
->beg_line_orig
= sed_cmd
->beg_line
;
657 /* second part (if present) will begin with a comma */
658 if (*cmdstr
== ',') {
662 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
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.
673 /* code is smaller compared to using &cmdstr here: */
674 idx
= strtol(cmdstr
+1, &end
, 10);
675 sed_cmd
->end_line
= -2 - idx
;
678 idx
= get_address(cmdstr
, &sed_cmd
->end_line
, &sed_cmd
->end_match
);
680 idx
--; /* if 0, trigger error check below */
683 bb_error_msg_and_die("no address after comma");
684 sed_cmd
->end_line_orig
= sed_cmd
->end_line
;
687 /* skip whitespace before the command */
688 cmdstr
= skip_whitespace(cmdstr
);
690 /* Check for inversion flag */
691 if (*cmdstr
== '!') {
695 /* skip whitespace before the command */
696 cmdstr
= skip_whitespace(cmdstr
);
699 /* last part (mandatory) will be a command */
701 bb_error_msg_and_die("missing command");
702 sed_cmd
->cmd
= *cmdstr
++;
703 cmdstr
= parse_cmd_args(sed_cmd
, cmdstr
);
705 /* 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'".
711 /* Add the command to the command array */
712 *G
.sed_cmd_tail
= sed_cmd
;
713 G
.sed_cmd_tail
= &sed_cmd
->next
;
716 /* If we glued multiple lines together, free the memory. */
717 free(G
.add_cmd_line
);
718 G
.add_cmd_line
= NULL
;
721 /* Append to a string, reallocating memory as necessary. */
725 static void pipe_putc(char c
)
727 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
;
732 G
.pipeline
.buf
[G
.pipeline
.idx
++] = c
;
735 static void do_subst_w_backrefs(char *line
, char *replace
)
739 /* go through the replacement string */
740 for (i
= 0; replace
[i
]; i
++) {
741 /* if we find a backreference (\1, \2, etc.) print the backref'ed text */
742 if (replace
[i
] == '\\') {
743 unsigned backref
= replace
[++i
] - '0';
745 /* 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
)
749 pipe_putc(line
[j
++]);
753 /* 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
]);
760 /* if we find an unescaped '&' print out the whole matched text. */
761 if (replace
[i
] == '&') {
762 j
= G
.regmatch
[0].rm_so
;
763 while (j
< G
.regmatch
[0].rm_eo
)
764 pipe_putc(line
[j
++]);
767 /* Otherwise just output the character. */
768 pipe_putc(replace
[i
]);
772 static int do_subst_command(sed_cmd_t
*sed_cmd
, char **line_p
)
774 char *line
= *line_p
;
775 unsigned match_count
= 0;
777 bool prev_match_empty
= 1;
778 bool tried_at_eol
= 0;
779 regex_t
*current_regex
;
781 current_regex
= sed_cmd
->sub_match
;
782 /* Handle empty regex. */
783 if (!current_regex
) {
784 current_regex
= G
.previous_regex_ptr
;
786 bb_error_msg_and_die("no previous regexp");
788 G
.previous_regex_ptr
= current_regex
;
790 /* Find the first match */
791 dbg("matching '%s'", line
);
792 if (REG_NOMATCH
== regexec(current_regex
, line
, 10, G
.regmatch
, 0)) {
798 /* Initialize temporary output buffer. */
799 G
.pipeline
.buf
= xmalloc(PIPE_GROW
);
800 G
.pipeline
.len
= PIPE_GROW
;
803 /* Now loop through, substituting for matches */
805 int start
= G
.regmatch
[0].rm_so
;
806 int end
= G
.regmatch
[0].rm_eo
;
811 /* If we aren't interested in this match, output old line to
812 * end of match and continue */
813 if (sed_cmd
->which_match
814 && (sed_cmd
->which_match
!= match_count
)
816 for (i
= 0; i
< end
; i
++)
818 /* Null match? Print one more char */
819 if (start
== end
&& *line
)
824 /* Print everything before the match */
825 for (i
= 0; i
< start
; i
++)
828 /* 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!
835 if (prev_match_empty
|| start
!= 0 || start
!= end
) {
836 //dbg("%d %d %d", prev_match_empty, start, end);
837 dbg("inserting replacement at %d in '%s'", start
, line
);
838 do_subst_w_backrefs(line
, sed_cmd
->string
);
839 /* Flag that something has changed */
842 dbg("NOT inserting replacement at %d in '%s'", start
, line
);
845 /* If matched string is empty (f.e. "c*" pattern),
846 * copy verbatim one char after it before attempting more matches
848 prev_match_empty
= (start
== end
);
849 if (prev_match_empty
) {
853 pipe_putc(line
[end
]);
858 /* Advance past the match */
859 dbg("line += %d", end
);
862 /* if we're not doing this globally, get out now */
863 if (sed_cmd
->which_match
!= 0)
866 /* Exit if we are at EOL and already tried matching at it */
873 //maybe (end ? REG_NOTBOL : 0) instead of unconditional REG_NOTBOL?
874 } while (regexec(current_regex
, line
, 10, G
.regmatch
, REG_NOTBOL
) != REG_NOMATCH
);
876 /* Copy rest of string into output pipeline */
885 *line_p
= G
.pipeline
.buf
;
889 /* Set command pointer to point to this label. (Does not handle null label.) */
890 static sed_cmd_t
*branch_to(char *label
)
894 for (sed_cmd
= G
.sed_cmd_head
; sed_cmd
; sed_cmd
= sed_cmd
->next
) {
895 if (sed_cmd
->cmd
== ':' && sed_cmd
->string
&& !strcmp(sed_cmd
->string
, label
)) {
899 bb_error_msg_and_die("can't find label for jump to '%s'", label
);
902 static void append(char *s
)
904 llist_add_to_end(&G
.append_head
, s
);
907 /* Output line of text. */
909 * The tricks with NO_EOL_CHAR and last_puts_char are there to emulate gnu sed.
910 * Without them, we had this:
914 * sed "s/i/z/" z1 z2 znull | hexdump -vC
917 * 00000000 74 68 7a 6e 67 79 0a 61 67 61 7a 6e |thzngy.agazn|
919 * 00000000 74 68 7a 6e 67 79 61 67 61 7a 6e |thzngyagazn|
925 static void puts_maybe_newline(char *s
, FILE *file
, char *last_puts_char
, char last_gets_char
)
927 char lpc
= *last_puts_char
;
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') {
937 /* 'x' - just something which is not '\n', '\0' or NO_EOL_CHAR */
941 /* had trailing '\0' and it was last char of file? */
942 if (last_gets_char
== LAST_IS_NUL
) {
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
;
953 xfunc_error_retval
= 4; /* It's what gnu sed exits with... */
954 bb_error_msg_and_die(bb_msg_write_error
);
956 *last_puts_char
= lpc
;
959 static void flush_append(char *last_puts_char
)
963 /* Output appended lines. */
964 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' -
970 * (both lines are terminated with \n)
971 * Therefore we do not propagate "last_gets_char" here,
974 puts_maybe_newline(data
, G
.nonstdout
, last_puts_char
, '\n');
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.
982 static char *get_next_line(char *gets_char
, char *last_puts_char
)
988 flush_append(last_puts_char
);
990 /* will be returned if last line in the file
991 * doesn't end with either '\n' or '\0' */
993 for (; G
.current_input_file
<= G
.last_input_file
; G
.current_input_file
++) {
994 FILE *fp
= G
.current_fp
;
996 const char *path
= G
.input_file_list
[G
.current_input_file
];
998 if (path
!= bb_msg_standard_input
) {
999 fp
= fopen_or_warn(path
, "r");
1001 G
.exitcode
= EXIT_FAILURE
;
1007 /* 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 */
1010 temp
= bb_get_chunk_from_file(fp
, &len
);
1012 /* len > 0 here, it's ok to do temp[len-1] */
1013 char c
= temp
[len
-1];
1014 if (c
== '\n' || c
== '\0') {
1025 /* else we put NO_EOL_CHAR into *gets_char */
1028 /* 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"!) */
1036 /* Close this file and advance to next one */
1037 fclose_if_not_stdin(fp
);
1038 G
.current_fp
= NULL
;
1044 #define sed_puts(s, n) (puts_maybe_newline(s, G.nonstdout, &last_puts_char, n))
1046 static int beg_match(sed_cmd_t
*sed_cmd
, const char *pattern_space
)
1048 int retval
= sed_cmd
->beg_match
&& !regexec(sed_cmd
->beg_match
, pattern_space
, 0, NULL
, 0);
1050 G
.previous_regex_ptr
= sed_cmd
->beg_match
;
1054 /* Process all the lines in all the files */
1056 static void process_files(void)
1058 char *pattern_space
, *next_line
;
1060 char last_puts_char
= '\n';
1061 char last_gets_char
, next_gets_char
;
1065 /* Prime the pump */
1066 next_line
= get_next_line(&next_gets_char
, &last_puts_char
);
1068 /* Go through every line in each file */
1072 /* Advance to next line. Stop if out of lines. */
1073 pattern_space
= next_line
;
1076 last_gets_char
= next_gets_char
;
1078 /* Read one line in advance so we can act on the last line,
1079 * the '$' address */
1080 next_line
= get_next_line(&next_gets_char
, &last_puts_char
);
1083 /* For every line, go through all the commands */
1085 for (sed_cmd
= G
.sed_cmd_head
; sed_cmd
; sed_cmd
= sed_cmd
->next
) {
1086 int old_matched
, matched
;
1088 old_matched
= sed_cmd
->in_match
;
1090 /* Determine if this command matches this line: */
1092 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
)
1101 dbg("match4:%d", (beg_match(sed_cmd
, pattern_space
)));
1102 dbg("match5:%d", (sed_cmd
->beg_line
== -1 && next_line
== NULL
));
1104 /* Are we continuing a previous multi-line match? */
1105 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? */
1110 || (sed_cmd
->beg_line
> 0
1111 && (sed_cmd
->end_line
|| sed_cmd
->end_match
1112 /* note: even if end is numeric and is < linenum too,
1113 * GNU sed matches! We match too, therefore we don't
1114 * check here that linenum <= end.
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
1121 ? (sed_cmd
->beg_line
<= linenum
) /* N,end */
1122 : (sed_cmd
->beg_line
== linenum
) /* N */
1125 /* Or does this line match our begin address regex? */
1126 || (beg_match(sed_cmd
, pattern_space
))
1127 /* Or did we match last line of input? */
1128 || (sed_cmd
->beg_line
== -1 && next_line
== NULL
);
1130 /* Snapshot the value */
1131 matched
= sed_cmd
->in_match
;
1133 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
);
1136 /* Is this line the end of the current match? */
1139 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);
1143 /* once matched, "n,xxx" range is dead, disabling it */
1144 if (sed_cmd
->beg_line
> 0) {
1145 sed_cmd
->beg_line
= -2;
1147 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));
1152 sed_cmd
->in_match
= !(
1153 /* has the ending line come, or is this a single address command? */
1155 ? sed_cmd
->end_line
== -1
1157 : (sed_cmd
->end_line
<= linenum
)
1158 : !sed_cmd
->end_match
1160 /* or does this line matches our last address regex */
1161 || (sed_cmd
->end_match
&& old_matched
1162 && (regexec(sed_cmd
->end_match
,
1163 pattern_space
, 0, NULL
, 0) == 0)
1168 /* Skip blocks of commands we didn't match */
1169 if (sed_cmd
->cmd
== '{') {
1170 if (sed_cmd
->invert
? matched
: !matched
) {
1171 unsigned nest_cnt
= 0;
1173 if (sed_cmd
->cmd
== '{')
1175 if (sed_cmd
->cmd
== '}') {
1180 sed_cmd
= sed_cmd
->next
;
1182 bb_error_msg_and_die("unterminated {");
1188 /* Okay, so did this line match? */
1189 if (sed_cmd
->invert
? matched
: !matched
)
1192 /* 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
;
1197 /* actual sedding */
1198 dbg("pattern_space:'%s' next_line:'%s' cmd:%c",
1199 pattern_space
, next_line
, sed_cmd
->cmd
);
1200 switch (sed_cmd
->cmd
) {
1202 /* Print line number */
1204 fprintf(G
.nonstdout
, "%d\n", linenum
);
1207 /* Write the current pattern space up to the first newline */
1210 char *tmp
= strchr(pattern_space
, '\n');
1213 /* TODO: explain why '\n' below */
1214 sed_puts(pattern_space
, '\n');
1221 /* Write the current pattern space to output */
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');
1229 /* Delete up through first newline */
1232 char *tmp
= strchr(pattern_space
, '\n');
1234 overlapping_strcpy(pattern_space
, tmp
+ 1);
1238 /* discard this line. */
1242 /* Substitute with regex */
1244 if (!do_subst_command(sed_cmd
, &pattern_space
))
1246 dbg("do_subst_command succeeded:'%s'", pattern_space
);
1249 /* handle p option */
1251 sed_puts(pattern_space
, last_gets_char
);
1252 /* handle w option */
1253 if (sed_cmd
->sw_file
)
1255 pattern_space
, sed_cmd
->sw_file
,
1256 &sed_cmd
->sw_last_char
, last_gets_char
);
1259 /* Append line to linked list to be printed later */
1261 append(xstrdup(sed_cmd
->string
));
1264 /* Insert text before this line */
1266 sed_puts(sed_cmd
->string
, '\n');
1269 /* Cut and paste text (replace) */
1271 /* Only triggers on last line of a matching range. */
1272 if (!sed_cmd
->in_match
)
1273 sed_puts(sed_cmd
->string
, '\n');
1276 /* Read file, append contents to output */
1280 rfile
= fopen_for_read(sed_cmd
->string
);
1283 while ((line
= xmalloc_fgetline(rfile
))
1292 /* Write pattern space to file. */
1295 pattern_space
, sed_cmd
->sw_file
,
1296 &sed_cmd
->sw_last_char
, last_gets_char
);
1299 /* Read next line from input */
1302 sed_puts(pattern_space
, last_gets_char
);
1304 free(pattern_space
);
1305 pattern_space
= next_line
;
1306 last_gets_char
= next_gets_char
;
1307 next_line
= get_next_line(&next_gets_char
, &last_puts_char
);
1314 /* Quit. End of script, end of input. */
1316 /* Exit the outer while loop */
1319 goto discard_commands
;
1321 /* Append the next line to the current line */
1325 /* If no next line, jump to end of script and exit. */
1326 /* 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."
1333 if (next_line
== NULL
) {
1334 //goto discard_line;
1335 goto discard_commands
; /* GNU behavior */
1337 /* Append next_line, read new next_line. */
1338 len
= strlen(pattern_space
);
1339 pattern_space
= xrealloc(pattern_space
, len
+ strlen(next_line
) + 2);
1340 pattern_space
[len
] = '\n';
1341 strcpy(pattern_space
+ len
+1, next_line
);
1342 last_gets_char
= next_gets_char
;
1343 next_line
= get_next_line(&next_gets_char
, &last_puts_char
);
1348 /* Test/branch if substitution occurred */
1350 if (!substituted
) break;
1353 /* Test/branch if substitution didn't occur */
1355 if (substituted
) break;
1357 /* Branch to label */
1359 if (!sed_cmd
->string
) goto discard_commands
;
1360 else sed_cmd
= branch_to(sed_cmd
->string
);
1362 /* Transliterate characters */
1366 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];
1377 case 'g': /* Replace pattern space with hold space */
1378 free(pattern_space
);
1379 pattern_space
= xstrdup(G
.hold_space
? G
.hold_space
: "");
1381 case 'G': /* Append newline and hold space to pattern space */
1383 int pattern_space_size
= 2;
1384 int hold_space_size
= 0;
1387 pattern_space_size
+= strlen(pattern_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");
1396 strcat(pattern_space
, G
.hold_space
);
1397 last_gets_char
= '\n';
1401 case 'h': /* Replace hold space with pattern space */
1403 G
.hold_space
= xstrdup(pattern_space
);
1405 case 'H': /* Append newline and pattern space to hold space */
1407 int hold_space_size
= 2;
1408 int pattern_space_size
= 0;
1411 hold_space_size
+= strlen(G
.hold_space
);
1413 pattern_space_size
= strlen(pattern_space
);
1414 G
.hold_space
= xrealloc(G
.hold_space
,
1415 hold_space_size
+ pattern_space_size
);
1417 if (hold_space_size
== 2)
1419 strcat(G
.hold_space
, "\n");
1421 strcat(G
.hold_space
, pattern_space
);
1425 case 'x': /* Exchange hold and pattern space */
1427 char *tmp
= pattern_space
;
1428 pattern_space
= G
.hold_space
? G
.hold_space
: xzalloc(1);
1429 last_gets_char
= '\n';
1434 } /* for each cmd */
1437 * Exit point from sedding...
1440 /* we will print the line unless we were told to be quiet ('-n')
1441 or if the line was suppressed (ala 'd'elete) */
1443 sed_puts(pattern_space
, last_gets_char
);
1445 /* Delete and such jump here. */
1447 flush_append(&last_puts_char
/*,last_gets_char*/);
1448 free(pattern_space
);
1453 /* It is possible to have a command line argument with embedded
1454 * newlines. This counts as multiple command lines.
1455 * However, newline can be escaped: 's/e/z\<newline>z/'
1456 * add_cmd() handles this.
1459 static void add_cmd_block(char *cmdstr
)
1463 cmdstr
= sv
= xstrdup(cmdstr
);
1465 eol
= strchr(cmdstr
, '\n');
1474 int sed_main(int argc
, char **argv
) MAIN_EXTERNALLY_VISIBLE
;
1475 int sed_main(int argc UNUSED_PARAM
, char **argv
)
1478 llist_t
*opt_e
, *opt_f
;
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";
1494 /* destroy command strings on exit */
1495 if (ENABLE_FEATURE_CLEAN_UP
) atexit(sed_free_and_close_stuff
);
1497 /* Lie to autoconf when it starts asking stupid questions. */
1498 if (argv
[1] && strcmp(argv
[1], "--version") == 0) {
1499 puts("This is not GNU sed version 4.0");
1503 /* do normal option parsing */
1504 opt_e
= opt_f
= NULL
;
1506 opt_complementary
= "e::f::" /* can occur multiple times */
1507 "nn"; /* count -n */
1509 IF_LONG_OPTS(applet_long_options
= sed_longopts
);
1511 /* -i must be first, to match OPT_in_place definition */
1512 /* -E is a synonym of -r:
1513 * GNU sed 4.2.1 mentions it in neither --help
1514 * nor manpage, but does recognize it.
1516 opt
= getopt32(argv
, "i::rEne:f:", &opt_i
, &opt_e
, &opt_f
,
1517 &G
.be_quiet
); /* counter for -n */
1520 if (opt
& OPT_in_place
) { // -i
1521 atexit(cleanup_outname
);
1524 G
.regex_type
|= REG_EXTENDED
; // -r or -E
1526 // G.be_quiet++; // -n (implemented with a counter instead)
1527 while (opt_e
) { // -e
1528 add_cmd_block(llist_pop(&opt_e
));
1530 while (opt_f
) { // -f
1533 cmdfile
= xfopen_stdin(llist_pop(&opt_f
));
1534 while ((line
= xmalloc_fgetline(cmdfile
)) != NULL
) {
1538 fclose_if_not_stdin(cmdfile
);
1540 /* if we didn't get a pattern from -e or -f, use argv[0] */
1541 if (!(opt
& 0x30)) {
1544 add_cmd_block(*argv
++);
1546 /* Flush any unfinished commands. */
1549 /* By default, we write to stdout */
1550 G
.nonstdout
= stdout
;
1552 /* argv[0..(argc-1)] should be names of file to process. If no
1553 * files were specified or '-' was specified, take input from stdin.
1554 * Otherwise, we process all the files specified. */
1555 G
.input_file_list
= argv
;
1557 if (opt
& OPT_in_place
)
1558 bb_error_msg_and_die(bb_msg_requires_arg
, "-i");
1559 argv
[0] = (char*)bb_msg_standard_input
;
1560 /* G.last_input_file = 0; - already is */
1564 for (; *argv
; argv
++) {
1565 struct stat statbuf
;
1569 G
.last_input_file
++;
1571 if (!(opt
& OPT_in_place
)) {
1572 if (LONE_DASH(*argv
)) {
1573 *argv
= (char*)bb_msg_standard_input
;
1579 /* -i: process each FILE separately: */
1581 if (stat(*argv
, &statbuf
) != 0) {
1582 bb_simple_perror_msg(*argv
);
1583 G
.exitcode
= EXIT_FAILURE
;
1584 G
.current_input_file
++;
1587 G
.outname
= xasprintf("%sXXXXXX", *argv
);
1588 nonstdoutfd
= xmkstemp(G
.outname
);
1589 G
.nonstdout
= xfdopen_for_write(nonstdoutfd
);
1590 /* Set permissions/owner of output file */
1591 /* chmod'ing AFTER chown would preserve suid/sgid bits,
1592 * but GNU sed 4.2.1 does not preserve them either */
1593 fchmod(nonstdoutfd
, statbuf
.st_mode
);
1594 fchown(nonstdoutfd
, statbuf
.st_uid
, statbuf
.st_gid
);
1597 fclose(G
.nonstdout
);
1598 G
.nonstdout
= stdout
;
1601 char *backupname
= xasprintf("%s%s", *argv
, opt_i
);
1602 xrename(*argv
, backupname
);
1605 /* else unlink(*argv); - rename below does this */
1606 xrename(G
.outname
, *argv
); //TODO: rollback backup on error?
1610 /* Fix disabled range matches and mangled ",+N" ranges */
1611 for (sed_cmd
= G
.sed_cmd_head
; sed_cmd
; sed_cmd
= sed_cmd
->next
) {
1612 sed_cmd
->beg_line
= sed_cmd
->beg_line_orig
;
1613 sed_cmd
->end_line
= sed_cmd
->end_line_orig
;
1616 /* Here, to handle "sed 'cmds' nonexistent_file" case we did:
1617 * if (G.current_input_file[G.current_input_file] == NULL)
1618 * return G.exitcode;
1619 * but it's not needed since process_files() works correctly
1620 * in this case too. */