This file documents version 4.4 of GNU sed, a stream editor.
Copyright © 1998-2017 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled “GNU Free Documentation License”.
sed is a stream editor. A stream editor is used to perform basic text transformations on an input stream (a file or input from a pipeline). While in some ways similar to an editor which permits scripted edits (such as ed), sed works by making only one pass over the input(s), and is consequently more efficient. But it is sed's ability to filter text in a pipeline which particularly distinguishes it from other types of editors.
This chapter covers how to run sed. Details of sed scripts and individual sed commands are discussed in the next chapter.
Normally sed is invoked like this:
sed SCRIPT INPUTFILE...
For example, to replace all occurrences of ‘hello’ to ‘world’ in the file input.txt:
sed 's/hello/world/' input.txt > output.txt
If you do not specify INPUTFILE, or if INPUTFILE is -, sed filters the contents of the standard input. The following commands are equivalent:
sed 's/hello/world/' input.txt > output.txt
sed 's/hello/world/' < input.txt > output.txt
cat input.txt | sed 's/hello/world/' - > output.txt
sed writes output to standard output. Use -i to edit
files in-place instead of printing to standard output.
See also the W and s///w commands for writing output to
other files. The following command modifies file.txt and
does not produce any output:
sed -i 's/hello/world' file.txt
By default sed prints all processed input (except input
that has been modified/deleted by commands such as d).
Use -n to suppress output, and the p command
to print specific lines. The following command prints only line 45
of the input file:
sed -n '45p' file.txt
sed treats multiple input files as one long stream. The following example prints the first line of the first file (one.txt) and the last line of the last file (three.txt). Use -s to reverse this behavior.
sed -n '1p ; $p' one.txt two.txt three.txt
Without -e or -f options, sed uses the first non-option parameter as the script, and the following non-option parameters as input files. If -e or -f options are used to specify a script, all non-option parameters are taken as input files. Options -e and -f can be combined, and can appear multiple times (in which case the final effective script will be concatenation of all the individual scripts).
The following examples are equivalent:
sed 's/hello/world/' input.txt > output.txt
sed -e 's/hello/world/' input.txt > output.txt
sed --expression='s/hello/world/' input.txt > output.txt
echo 's/hello/world/' > myscript.sed
sed -f myscript.sed input.txt > output.txt
sed --file=myscript.sed input.txt > output.txt
The full format for invoking sed is:
sed OPTIONS... [SCRIPT] [INPUTFILE...]
sed may be invoked with the following command-line options:
--version--help-n--quiet--silentsed works).
These options disable this automatic printing,
and sed only produces output when explicitly told to
via the p command.
-e script--expression=script-f script-file--file=script-file-i[SUFFIX]--in-place[=SUFFIX]This option implies -s.
When the end of the file is reached, the temporary file is renamed to the output file's original name. The extension, if supplied, is used to modify the name of the old file before renaming the temporary file, thereby making a backup copy2).
This rule is followed: if the extension doesn't contain a *,
then it is appended to the end of the current filename as a
suffix; if the extension does contain one or more *
characters, then each asterisk is replaced with the
current filename. This allows you to add a prefix to the
backup file, instead of (or in addition to) a suffix, or
even to place backup copies of the original files into another
directory (provided the directory already exists).
If no extension is supplied, the original file is
overwritten without making a backup.
-l N--line-length=Nl command.
A length of 0 (zero) means to never wrap long lines. If
not specified, it is taken to be 70.
--posixPOSIXLY_CORRECT variable
to a non-empty value.
-b--binary--follow-symlinks-E-r--regexp-extended-s--separate$ refers to the last line of each file,
and files invoked from the R commands are rewound at the
start of each file.
--sandboxe/w/r commands are rejected - programs containing
them will be aborted without being run. Sandbox mode ensures sed
operates only on the input files designated on the command line, and
cannot run external programs.
-u--unbuffered-z--null-data--zero-terminatedIf no -e, -f, --expression, or --file options are given on the command-line, then the first non-option argument on the command line is taken to be the script to be executed.
If any command-line parameters remain after processing the above, these parameters are interpreted as the names of input files to be processed. A file name of ‘-’ refers to the standard input stream. The standard input will be processed if no file names are specified.
An exit status of zero indicates success, and a nonzero value indicates failure. GNU sed returns the following exit status error values:
Additionally, the commands q and Q can be used to terminate
sed with a custom exit code value (this is a GNU sed extension):
$ echo | sed 'Q42' ; echo $?
42
A sed program consists of one or more sed commands, passed in by one or more of the -e, -f, --expression, and --file options, or the first non-option argument if zero of these options are used. This document will refer to “the” sed script; this is understood to mean the in-order concatenation of all of the scripts and script-files passed in. See Overview.
sed commands follow this syntax:
[addr]X[options]
X is a single-letter sed command.
[addr] is an optional line address. If [addr] is specified,
the command X will be executed only on the matched lines.
[addr] can be a single line number, a regular expression,
or a range of lines (see sed addresses).
Additional [options] are used for some sed commands.
The following example deletes lines 30 to 35 in the input.
30,35 is an address range. d is the delete command:
sed '30,35d' input.txt > output.txt
The following example prints all input until a line
starting with the word ‘foo’ is found. If such line is found,
sed will terminate with exit status 42.
If such line was not found (and no other error occurred), sed
will exit with status 0.
/^foo/ is a regular-expression address.
q is the quit command. 42 is the command option.
sed '/^foo/q42' input.txt > output.txt
Commands within a script or script-file can be
separated by semicolons (;) or newlines (ASCII 10).
Multiple scripts can be specified with -e or -f
options.
The following examples are all equivalent. They perform two sed
operations: deleting any lines matching the regular expression /^foo/,
and replacing all occurrences of the string ‘hello’ with ‘world’:
sed '/^foo/d ; s/hello/world/' input.txt > output.txt
sed -e '/^foo/d' -e 's/hello/world/' input.txt > output.txt
echo '/^foo/d' > script.sed
echo 's/hello/world/' >> script.sed
sed -f script.sed input.txt > output.txt
echo 's/hello/world/' > script2.sed
sed -e '/^foo/d' -f script2.sed input.txt > output.txt
Commands a, c, i, due to their syntax, cannot be followed by semicolons working as command separators and thus should be terminated with newlines or be placed at the end of a script or script-file. Commands can also be preceded with optional non-significant whitespace characters. See Multiple commands syntax.
The following commands are supported in GNU sed. Some are standard POSIX commands, while other are GNU extensions. Details and examples for each command are in the following sections. (Mnemonics) are shown in parentheses.
a\a textb labelc\c textdDIf pattern space contains no newline, start a normal new cycle as if
the d command was issued.
ee commandFgGhHi\i textlnNpPq[exit-code]Q[exit-code]q, but will not print the
contents of pattern space. Like q, it provides the
ability to return an exit code to the caller.
r filenameR filenames/regexp/replacement/[flags]t labelsubstitution since the last input line was read or conditional
branch was taken. The label may be omitted, in which case the
next cycle is started.
T labelsubstitutions since the last input line was read or
conditional branch was taken. The label may be omitted,
in which case the next cycle is started.
v [version]w filenameW filenamexy/src/dst/z#{ cmd ; cmd ... }=: labelb,
t, T).
s CommandThe s command (as in substitute) is probably the most important
in sed and has a lot of different options. The syntax of
the s command is
‘s/regexp/replacement/flags’.
Its basic concept is simple: the s command attempts to match
the pattern space against the supplied regular expression regexp;
if the match is successful, then that portion of the
pattern space which was matched is replaced with replacement.
For details about regexp syntax see Regular Expression Addresses.
The replacement can contain \n (n being
a number from 1 to 9, inclusive) references, which refer to
the portion of the match which is contained between the nth
\( and its matching \).
Also, the replacement can contain unescaped &
characters which reference the whole matched portion
of the pattern space.
The /
characters may be uniformly replaced by any other single
character within any given s command. The /
character (or whatever other character is used in its stead)
can appear in the regexp or replacement
only if it is preceded by a \ character.
Finally, as a GNU sed extension, you can include a
special sequence made of a backslash and one of the letters
L, l, U, u, or E.
The meaning is as follows:
\L\U or \E is found,
\l\U\L or \E is found,
\u\E\L or \U.
When the g flag is being used, case conversion does not
propagate from one occurrence of the regular expression to
another. For example, when the following command is executed
with ‘a-b-’ in pattern space:
s/\(b\?\)-/x\u\1/g
the output is ‘axxB’. When replacing the first ‘-’,
the ‘\u’ sequence only affects the empty replacement of
‘\1’. It does not affect the x character that is
added to pattern space when replacing b- with xB.
On the other hand, \l and \u do affect the remainder
of the replacement text if they are followed by an empty substitution.
With ‘a-b-’ in pattern space, the following command:
s/\(b\?\)-/\u\1x/g
will replace ‘-’ with ‘X’ (uppercase) and ‘b-’ with ‘Bx’. If this behavior is undesirable, you can prevent it by adding a ‘\E’ sequence—after ‘\1’ in this case.
To include a literal \, &, or newline in the final
replacement, be sure to precede the desired \, &,
or newline in the replacement with a \.
The s command can be followed by zero or more of the
following flags:
ginteraction in s command
Note: the posix standard does not specify what should happen
when you mix the g and number modifiers,
and currently there is no widely agreed upon meaning
across sed implementations.
For GNU sed, the interaction is defined to be:
ignore matches before the numberth,
and then match and replace all matches from
the numberth on.
pNote: when both the p and e options are specified,
the relative ordering of the two produces very different results.
In general, ep (evaluate then print) is what you want,
but operating the other way round can be useful for debugging.
For this reason, the current version of GNU sed interprets
specially the presence of p options both before and after
e, printing the pattern space before and after evaluation,
while in general flags for the s command show their
effect just once. This behavior, although documented, might
change in future versions.
w filenameeIiI modifier to regular-expression matching is a GNU
extension which makes sed match regexp in a
case-insensitive manner.
MmM modifier to regular-expression matching is a GNU sed
extension which directs GNU sed to match the regular expression
in multi-line mode. The modifier causes ^ and $ to
match respectively (in addition to the normal behavior) the empty string
after a newline, and the empty string before a newline. There are
special character sequences
(\` and \')
which always match the beginning or the end of the buffer.
In addition,
the period character does not match a new-line character in
multi-line mode.
If you use sed at all, you will quite likely want to know these commands.
#The # character begins a comment;
the comment continues until the next newline.
If you are concerned about portability, be aware that
some implementations of sed (which are not posix
conforming) may only support a single one-line comment,
and then only when the very first character of the script is a #.
Warning: if the first two characters of the sed script
are #n, then the -n (no-autoprint) option is forced.
If you want to put a comment in the first line of your script
and that comment begins with the letter ‘n’
and you do not want this behavior,
then be sure to either use a capital ‘N’,
or place at least one space before the ‘n’.
q [exit-code]Example: stop after printing the second line:
$ seq 3 | sed 2q
1
2
This command only accepts a single address. Note that the current pattern space is printed if auto-print is not disabled with the -n options. The ability to return an exit code from the sed script is a GNU sed extension.
See also the GNU sed extension Q command which quits silently
without printing the current pattern space.
dExample: delete the second input line:
$ seq 3 | sed 2d
1
3
pExample: print only the second input line:
$ seq 3 | sed -n 2p
2
nThis command is useful to skip lines (e.g. process every Nth line).
Example: perform substitution on every 3rd line (i.e. two n commands
skip two lines):
on
on
$ seq 6 | sed 'n;n;s/./x/'
1
2
x
4
5
x
GNU sed provides an extension address syntax of first~step to achieve the same result:
$ seq 6 | sed '0~3s/./x/'
1
2
x
4
5
x
off
off
{ commands }{ and } characters.
This is particularly useful when you want a group of commands
to be triggered by a single address (or address-range) match.
Example: perform substitution then print the second input line: on on
$ seq 3 | sed -n '2{s/2/X/ ; p}'
X
off off
Though perhaps less frequently used than those in the previous section, some very small yet useful sed scripts can be built with these commands.
y/source-chars/dest-chars/Example: transliterate ‘a-j’ into ‘0-9’: on on
$ echo hello world | sed 'y/abcdefghij/0123456789/'
74llo worl3
off off
(The / characters may be uniformly replaced by
any other single character within any given y command.)
Instances of the / (or whatever other character is used in its stead),
\, or newlines can appear in the source-chars or dest-chars
lists, provide that each instance is escaped by a \.
The source-chars and dest-chars lists must
contain the same number of characters (after de-escaping).
See the tr command from GNU coreutils for similar functionality.
a texta command - see below for details.
Example: Add the word ‘hello’ after the second line: on on
$ seq 3 | sed '2a hello'
1
2
hello
3
off off
Leading whitespace after the a command is ignored.
The text to add is read until the end of the line.
a\Example: Add ‘hello’ after the second line (-| indicates printed output lines): on on
$ seq 3 | sed '2a\
hello'
-|1
-|2
-|hello
-|3
off off
The a command queues the lines of text which follow this command
(each but the last ending with a \,
which are removed from the output)
to be output at the end of the current cycle,
or when the next input line is read.
As a GNU extension, this command accepts two addresses.
Escape sequences in text are processed, so you should
use \\ in text to print a single backslash.
The commands resume after the last line without a backslash (\) -
‘world’ in the following example:
on
on
$ seq 3 | sed '2a\
hello\
world
3s/./X/'
-|1
-|2
-|hello
-|world
-|X
off off
As a GNU extension, the a command and text can be
separated into two -e parameters, enabling easier scripting:
on
on
$ seq 3 | sed -e '2a\' -e hello
1
2
hello
3
$ sed -e '2a\' -e "$VAR"
off
off
i texti command - see below for details.
Example: Insert the word ‘hello’ before the second line: on on
$ seq 3 | sed '2i hello'
1
hello
2
3
off off
Leading whitespace after the i command is ignored.
The text to add is read until the end of the line.
i\Example: Insert ‘hello’ before the second line (-| indicates printed output lines): on on
$ seq 3 | sed '2i\
hello'
-|1
-|hello
-|2
-|3
off off
As a GNU extension, this command accepts two addresses.
Escape sequences in text are processed, so you should
use \\ in text to print a single backslash.
The commands resume after the last line without a backslash (\) -
‘world’ in the following example:
on
on
$ seq 3 | sed '2i\
hello\
world
s/./X/'
-|X
-|hello
-|world
-|X
-|X
off off
As a GNU extension, the i command and text can be
separated into two -e parameters, enabling easier scripting:
on
on
$ seq 3 | sed -e '2i\' -e hello
1
hello
2
3
$ sed -e '2i\' -e "$VAR"
off
off
c textc command - see below for details.
Example: Replace the 2nd to 9th lines with the word ‘hello’: on on
$ seq 10 | sed '2,9c hello'
1
hello
10
off off
Leading whitespace after the c command is ignored.
The text to add is read until the end of the line.
c\Example: Replace 2nd to 4th lines with the words ‘hello’ and ‘world’ (-| indicates printed output lines): on on
$ seq 5 | sed '2,4c\
hello\
world'
-|1
-|hello
-|world
-|5
off off
If no addresses are given, each line is replaced.
A new cycle is started after this command is done,
since the pattern space will have been deleted.
In the following example, the c starts a
new cycle and the substitution command is not performed
on the replaced text:
on on
$ seq 3 | sed '2c\
hello
s/./X/'
-|X
-|hello
-|X
off off
As a GNU extension, the c command and text can be
separated into two -e parameters, enabling easier scripting:
on
on
$ seq 3 | sed -e '2c\' -e hello
1
hello
3
$ sed -e '2c\' -e "$VAR"
off
off
=on on
$ printf '%s\n' aaa bbb ccc | sed =
1
aaa
2
bbb
3
ccc
off off
l n\ character)
are printed in C-style escaped form; long lines are split,
with a trailing \ character to indicate the split;
the end of each line is marked with a $.
n specifies the desired line-wrap length;
a length of 0 (zero) means to never wrap long lines. If omitted,
the default as specified on the command line is used. The n
parameter is a GNU sed extension.
r filenameon on
$ seq 3 | sed '2r/etc/hostname'
1
2
fencepost.gnu.org
3
off off
Queue the contents of filename to be read and inserted into the output stream at the end of the current cycle, or when the next input line is read. Note that if filename cannot be read, it is treated as if it were an empty file, without any error indication.
As a GNU sed extension, the special value /dev/stdin is supported for the file name, which reads the contents of the standard input.
As a GNU extension, this command accepts two addresses. The
file will then be reread and inserted on each of the addressed lines.
w filenameThe file will be created (or truncated) before the first input line is
read; all w commands (including instances of the w flag
on successful s commands) which refer to the same filename
are output without closing and reopening the file.
Dd command was issued. Otherwise, delete text in the pattern
space up to the first newline, and restart cycle with the resultant
pattern space, without reading a new line of input.
NWhen -z is used, a zero byte (the ascii ‘NUL’ character) is added between the lines (instead of a new line).
By default sed does not terminate if there is no 'next' input line.
This is a GNU extension which can be disabled with --posix.
See N command on the last line.
PhHgGxIn most cases, use of these commands indicates that you are probably better off programming in something like awk or Perl. But occasionally one is committed to sticking with sed, and these commands can enable one to write quite convoluted scripts.
: labelSpecify the location of label for branch commands.
In all other respects, a no-op.
b labelt labelsubstitution
since the last input line was read or conditional branch was taken.
The label may be omitted, in which case the next cycle is started.
These commands are specific to GNU sed, so you must use them with care and only when you are sure that hindering portability is not evil. They allow you to check for GNU sed extensions or to do tasks that are required quite often, yet are unsupported by standard seds.
e [command]e command
executes the command that is found in pattern space and
replaces the pattern space with the output; a trailing newline
is suppressed.
If a parameter is specified, instead, the e command
interprets it as a command and sends its output to the output stream.
The command can run across multiple lines, all but the last ending with
a back-slash.
In both cases, the results are undefined if the command to be executed contains a nul character.
Note that, unlike the r command, the output of the command will
be printed immediately; the r command instead delays the output
to the end of the current cycle.
FQ [exit-code]This command is the same as q, but will not print the
contents of pattern space. Like q, it provides the
ability to return an exit code to the caller.
This command can be useful because the only alternative ways to accomplish this apparently trivial function are to use the -n option (which can unnecessarily complicate your script) or resorting to the following snippet, which wastes time by reading the whole file without any visible effect:
:eat
$d Quit silently on the last line
N Read another line, silently
g Overwrite pattern space each time to save memory
b eat
R filenameAs with the r command, the special value /dev/stdin
is supported for the file name, which reads a line from the
standard input.
T labelsubstitutions since the last input line was read or
conditional branch was taken. The label may be omitted,
in which case the next cycle is started.
v version4.0.5. The default is 4.0
because that is the first version that implemented this command.
This command enables all GNU extensions even if
POSIXLY_CORRECT is set in the environment.
W filenamew command about
file handling holds here too.
zThere are several methods to specify multiple commands in a sed program.
Using newlines is most natural when running a sed script from a file (using the -f option).
On the command line, all sed commands may be separated by newlines. Alternatively, you may specify each command as an argument to an -e option:
on on
$ seq 6 | sed '1d
3d
5d'
2
4
6
$ seq 6 | sed -e 1d -e 3d -e 5d
2
4
6
off off
A semicolon (‘;’) may be used to separate most simple commands:
on on
$ seq 6 | sed '1d;3d;5d'
2
4
6
off off
The {,},b,t,T,: commands can
be separated with a semicolon (this is a non-portable GNU sed extension).
on on
$ seq 4 | sed '{1d;3d}'
2
4
$ seq 6 | sed '{1d;3d};5d'
2
4
6
off off
Labels used in b,t,T,: commands are read
until a semicolon. Leading and trailing whitespace is ignored. In
the examples below the label is ‘x’. The first example works
with GNU sed. The second is a portable equivalent. For more
information about branching and labels see Branching and flow control.
on on
$ seq 3 | sed '/1/b x ; s/^/=/ ; :x ; 3d'
1
=2
$ seq 3 | sed -e '/1/bx' -e 's/^/=/' -e ':x' -e '3d'
1
=2
off off
The following commands cannot be separated by a semicolon and require a newline:
a,c,i (append/change/insert)a,c,i commands are taken
as the text to append/change/insert. Using a semicolon leads to
undesirable results:
on on
$ seq 2 | sed '1aHello ; 2d'
1
Hello ; 2d
2
off off
Separate the commands using -e or a newline:
on on
$ seq 2 | sed -e 1aHello -e 2d
1
Hello
$ seq 2 | sed '1aHello
2d'
1
Hello
off off
Note that specifying the text to add (‘Hello’) immediately
after a,c,i is itself a GNU sed extension.
A portable, POSIX-compliant alternative is:
on on
$ seq 2 | sed '1a\
Hello
2d'
1
Hello
off
off
# (comment)on on
$ seq 3 | sed '# this is a comment ; 2d'
1
2
3
$ seq 3 | sed '# this is a comment
2d'
1
3
off
off
r,R,w,W (reading and writing files)r,R,w,W commands parse the filename
until end of the line. If whitespace, comments or semicolons are found,
they will be included in the filename, leading to unexpected results:
on on
$ seq 2 | sed '1w hello.txt ; 2d'
1
2
$ ls -log
total 4
-rw-rw-r-- 1 2 Jan 23 23:03 hello.txt ; 2d
$ cat 'hello.txt ; 2d'
1
off off
Note that sed silently ignores read/write errors in
r,R,w,W commands (such as missing files).
In the following example, sed tries to read a file named
‘hello.txt ; N’. The file is missing, and the error is silently
ignored:
on on
$ echo x | sed '1rhello.txt ; N'
x
off
off
e (command execution)e command until the end of the line
will be sent to the shell. If whitespace, comments or semicolons are found,
they will be included in the shell command, leading to unexpected results:
on on
$ echo a | sed '1e touch foo#bar'
a
$ ls -1
foo#bar
$ echo a | sed '1e touch foo ; s/a/b/'
sh: 1: s/a/b/: not found
a
off
off
s///[we] (substitute with e or w flags)w flag writes the substitution
result to a file, and the e flag executes the subsitution result
as a shell command. As with the r/R/w/W/e commands, these
must be terminated with a newline. If whitespace, comments or semicolons
are found, they will be included in the shell command or filename, leading to
unexpected results:
on on
$ echo a | sed 's/a/b/w1.txt#foo'
b
$ ls -1
1.txt#foo
off off
Addresses determine on which line(s) the sed command will be executed. The following command replaces the word ‘hello’ with ‘world’ only on line 144:
on on
sed '144s/hello/world/' input.txt > output.txt
off off
If no addresses are given, the command is performed on all lines. The following command replaces the word ‘hello’ with ‘world’ on all lines in the input file:
on on
sed 's/hello/world/' input.txt > output.txt
off off
Addresses can contain regular expressions to match lines based on content instead of line numbers. The following command replaces the word ‘hello’ with ‘world’ only in lines containing the word ‘apple’:
on on
sed '/apple/s/hello/world/' input.txt > output.txt
off off
An address range is specified with two addresses separated by a comma
(,). Addresses can be numeric, regular expressions, or a mix of
both.
The following command replaces the word ‘hello’ with ‘world’
only in lines 4 to 17 (inclusive):
on on
sed '4,17s/hello/world/' input.txt > output.txt
off off
Appending the ! character to the end of an address
specification (before the command letter) negates the sense of the
match. That is, if the ! character follows an address or an
address range, then only lines which do not match the addresses
will be selected. The following command replaces the word ‘hello’
with ‘world’ only in lines not containing the word
‘apple’:
sed '/apple/!s/hello/world/' input.txt > output.txt
The following command replaces the word ‘hello’ with ‘world’ only in lines 1 to 3 and 18 till the last line of the input file (i.e. excluding lines 4 to 17):
sed '4,17!s/hello/world/' input.txt > output.txt
Addresses in a sed script can be in any of the following forms:
$~step1~2 to select the odd-numbered lines and
0~2 for even-numbered lines;
to pick every third line starting with the second, ‘2~3’ would be used;
to pick every fifth line starting with the tenth, use ‘10~5’;
and ‘50~0’ is just an obscure way of saying 50.
The following commands demonstrate the step address usage:
$ seq 10 | sed -n '0~4p'
4
8
$ seq 10 | sed -n '1~3p'
1
4
7
10
GNU sed supports the following regular expression addresses. The default regular expression is Basic Regular Expression (BRE). If -E or -r options are used, The regular expression should be in Extended Regular Expression (ERE) syntax. See BRE vs ERE.
/regexp// characters,
each must be escaped by a backslash (\).
The following command prints lines in /etc/passwd which end with ‘bash’5:
sed -n '/bash$/p' /etc/passwd
The empty regular expression ‘//’ repeats the last regular
expression match (the same holds if the empty regular expression is
passed to the s command). Note that modifiers to regular expressions
are evaluated when the regular expression is compiled, thus it is invalid to
specify them together with the empty regular expression.
\%regexp%% may be replaced by any other single character.)
This also matches the regular expression regexp,
but allows one to use a different delimiter than /.
This is particularly useful if the regexp itself contains
a lot of slashes, since it avoids the tedious escaping of every /.
If regexp itself includes any delimiter characters,
each must be escaped by a backslash (\).
The following two commands are equivalent. They print lines which start with ‘/home/alice/documents/’:
sed -n '/^\/home\/alice\/documents\//p'
sed -n '\%^/home/alice/documents/%p'
sed -n '\;^/home/alice/documents/;p'
/regexp/I\%regexp%II modifier to regular-expression matching is a GNU
extension which causes the regexp to be matched in
a case-insensitive manner.
In many other programming languages, a lower case i is used
for case-insensitive regular expression matching. However, in sed
the i is used for the insert command (TODO: add pxref).
Observe the difference between the following examples.
In this example, /b/I is the address: regular expression with I
modifier. d is the delete command:
$ printf "%s\n" a b c | sed '/b/Id'
a
c
Here, /b/ is the address: a regular expression.
i is the insert command.
d is the value to insert.
A line with ‘d’ is then inserted above the matched line:
$ printf "%s\n" a b c | sed '/b/id'
a
d
b
c
/regexp/M\%regexp%MM modifier to regular-expression matching is a GNU sed
extension which directs GNU sed to match the regular expression
in multi-line mode. The modifier causes ^ and $ to
match respectively (in addition to the normal behavior) the empty string
after a newline, and the empty string before a newline. There are
special character sequences
(\` and \')
which always match the beginning or the end of the buffer.
In addition,
the period character does not match a new-line character in
multi-line mode.
An address range can be specified by specifying two addresses
separated by a comma (,). An address range matches lines
starting from where the first address matches, and continues
until the second address matches (inclusively):
$ seq 10 | sed -n '4,6p'
4
5
6
If the second address is a regexp, then checking for the ending match will start with the line following the line which matched the first address: a range will always span at least two lines (except of course if the input stream ends).
$ seq 10 | sed -n '4,/[0-9]/p'
4
5
If the second address is a number less than (or equal to) the line matching the first address, then only the one line is matched:
$ seq 10 | sed -n '4,1p'
4
GNU sed also supports some special two-address forms; all these are GNU extensions:
0,/regexp/0 can be used in an address specification like
0,/regexp/ so that sed will try to match
regexp in the first input line too. In other words,
0,/regexp/ is similar to 1,/regexp/,
except that if addr2 matches the very first line of input the
0,/regexp/ form will consider it to end the range, whereas
the 1,/regexp/ form will match the beginning of its range and
hence make the range span up to the second occurrence of the
regular expression.
Note that this is the only place where the 0 address makes
sense; there is no 0-th line and commands which are given the 0
address in any other way will give an error.
The following examples demonstrate the difference between starting with address 1 and 0:
$ seq 10 | sed -n '1,/[0-9]/p'
1
2
$ seq 10 | sed -n '0,/[0-9]/p'
1
,+N $ seq 10 | sed -n '6,+2p'
6
7
8
addr1 can be a line number or a regular expression.
,~N $ seq 10 | sed -n '6,~4p'
6
7
8
addr1 can be a line number or a regular expression.
To know how to use sed, people should understand regular expressions (regexp for short). A regular expression is a pattern that is matched against a subject string from left to right. Most characters are ordinary: they stand for themselves in a pattern, and match the corresponding characters. Regular expressions in sed are specified between two slashes.
The following command prints lines containing the word ‘hello’:
sed -n '/hello/p'
The above example is equivalent to this grep command:
grep 'hello'
The power of regular expressions comes from the ability to include alternatives and repetitions in the pattern. These are encoded in the pattern by the use of special characters, which do not stand for themselves but instead are interpreted in some special way.
The character ^ (caret) in a regular expression matches the
beginning of the line. The character . (dot) matches any single
character. The following sed command matches and prints
lines which start with the letter ‘b’, followed by any single character,
followed by the letter ‘d’:
$ printf "%s\n" abode bad bed bit bid byte body | sed -n '/^b.d/p'
bad
bed
bid
body
The following sections explain the meaning and usage of special characters in regular expressions.
Basic and extended regular expressions are two variations on the syntax of the specified pattern. Basic Regular Expression (BRE) is the default in sed (and similarly in grep). Extended Regular Expression syntax (ERE) is activated by using the -r or -E options (and similarly, grep -E).
In GNU sed the only difference between basic and extended regular expressions is in the behavior of a few special characters: ‘?’, ‘+’, parentheses, braces (‘{}’), and ‘|’.
With basic (BRE) syntax, these characters do not have special meaning unless prefixed backslash (‘\’); While with extended (ERE) syntax it is reversed: these characters are special unless they are prefixed with backslash (‘\’).
| Desired pattern | Basic (BRE) Syntax | Extended (ERE) Syntax
|
|---|---|---|
| literal ‘+’ (plus sign) |
$ echo "a+b=c" | sed -n '/a+b/p'
a+b=c
|
$ echo "a+b=c" | sed -E -n '/a\+b/p'
a+b=c
|
| One or more ‘a’ characters followed by ‘b’ (plus sign as special meta-character) |
$ echo "aab" | sed -n '/a\+b/p'
aab
|
$ echo "aab" | sed -E -n '/a+b/p'
aab
|
Here is a brief description of regular expression syntax as used in sed.
*\, a ., a grouped regexp
(see below), or a bracket expression. As a GNU extension, a
postfixed regular expression can also be followed by *; for
example, a** is equivalent to a*. POSIX
1003.1-2001 says that * stands for itself when it appears at
the start of a regular expression or subexpression, but many
nonGNU implementations do not support this and portable
scripts should instead use \* in these contexts.
.^In most scripts, pattern space is initialized to the content of each
line (see How sed works). So, it is a
useful simplification to think of ^#include as matching only
lines where ‘#include’ is the first thing on line—if there are
spaces before, for example, the match fails. This simplification is
valid as long as the original content of pattern space is not modified,
for example with an s command.
^ acts as a special character only at the beginning of the
regular expression or subexpression (that is, after \( or
\|). Portable scripts should avoid ^ at the beginning of
a subexpression, though, as POSIX allows implementations that
treat ^ as an ordinary character in that context.
$^, but refers to end of pattern space.
$ also acts as a special character only at the end
of the regular expression or subexpression (that is, before \)
or \|), and its use at the end of a subexpression is not
portable.
[list][^list][aeiou] matches all vowels. A list may include
sequences like char1-char2, which
matches any character between (inclusive) char1
and char2.
See Character Classes and Bracket Expressions.
\+*, but matches one or more. It is a GNU extension.
\?*, but only matches zero or one. It is a GNU extension.
\{i\}*, but matches exactly i sequences (i is a
decimal integer; for portability, keep it between 0 and 255
inclusive).
\{i,j\}\{i,\}\(regexp\)\(abcd\)*:
this will search for zero or more whole sequences
of ‘abcd’, while abcd* would search
for ‘abc’ followed by zero or more occurrences
of ‘d’. Note that support for \(abcd\)* is
required by POSIX 1003.1-2001, but many non-GNU
implementations do not support it and hence it is not universally
portable.
\|regexp2\|, ^, and
$, but less tightly than the other regular expression
operators.
\digit\(...\) parenthesized
subexpression in the regular expression. This is called a back
reference. Subexpressions are implicitly numbered by counting
occurrences of \( left-to-right.
\n\char$,
*, ., [, \, or ^.
Note that the only C-like
backslash sequences that you can portably assume to be
interpreted are \n and \\; in particular
\t is not portable, and matches a ‘t’ under most
implementations of sed, rather than a tab character.
Note that the regular expression matcher is greedy, i.e., matches are attempted from left to right and, if two or more matches are possible starting at the same character, it selects the longest.
Examples:
The only difference between basic and extended regular expressions is in the behavior of a few characters: ‘?’, ‘+’, parentheses, braces (‘{}’), and ‘|’. While basic regular expressions require these to be escaped if you want them to behave as special characters, when using extended regular expressions you must escape them if you want them to match a literal character. ‘|’ is special here because ‘\|’ is a GNU extension – standard basic regular expressions do not provide its functionality.
Examples:
abc?c\+a\{3,\}\(abc\)\{2,3\}\(abc*\)\1a\|bA bracket expression is a list of characters enclosed by ‘[’ and ‘]’. It matches any single character in that list; if the first character of the list is the caret ‘^’, then it matches any character not in the list. For example, the following command replaces the words ‘gray’ or ‘grey’ with ‘blue’:
sed 's/gr[ae]y/blue/'
Bracket expressions can be used in both basic and extended regular expressions (that is, with or without the -E/-r options).
Within a bracket expression, a range expression consists of two characters separated by a hyphen. It matches any single character that sorts between the two characters, inclusive. In the default C locale, the sorting sequence is the native character order; for example, ‘[a-d]’ is equivalent to ‘[abcd]’.
Finally, certain named classes of characters are predefined within bracket expressions, as follows.
These named classes must be used inside brackets themselves. Correct usage:
$ echo 1 | sed 's/[[:digit:]]/X/'
X
Incorrect usage is rejected by newer sed versions. Older versions accepted it but treated it as a single bracket expression (which is equivalent to ‘[dgit:]’, that is, only the characters d/g/i/t/:):
# current GNU sed versions - incorrect usage rejected
$ echo 1 | sed 's/[:digit:]/X/'
sed: character class syntax is [[:space:]], not [:space:]
# older GNU sed versions
$ echo 1 | sed 's/[:digit:]/X/'
1
0 1 2 3 4 5 6 7 8 9.
a b c d e f g h i j k l m n o p q r s t u v w x y z.
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~.
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z.
0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f.
Most meta-characters lose their special meaning inside bracket expressions:
TODO: incorporate this paragraph (copied verbatim from BRE section).
The characters $, *, ., [, and \
are normally not special within list. For example, [\*]
matches either ‘\’ or ‘*’, because the \ is not
special here. However, strings like [.ch.], [=a=], and
[:space:] are special within list and represent collating
symbols, equivalence classes, and character classes, respectively, and
[ is therefore special within list when it is followed by
., =, or :. Also, when not in
POSIXLY_CORRECT mode, special escapes like \n and
\t are recognized within list. See Escapes.
The following sequences have special meaning inside regular expressions
(used in addresses and the s command).
These can be used in both basic and extended regular expressions (that is, with or without the -E/-r options).
\w $ echo "abc %-= def." | sed 's/\w/X/g'
XXX %-= XXX.
\W $ echo "abc %-= def." | sed 's/\W/X/g'
abcXXXXXdefX
\b $ echo "abc %-= def." | sed 's/\b/X/g'
XabcX %-= XdefX.
\B $ echo "abc %-= def." | sed 's/\w/X/g'
aXbXc X%X-X=X dXeXf.X
\s $ echo "abc %-= def." | sed 's/\s/X/g'
abcX%-=Xdef.
\S $ echo "abc %-= def." | sed 's/\w/X/g'
XXX XXX XXXX
\< $ echo "abc %-= def." | sed 's/\</X/g'
Xabc %-= Xdef.
\> $ echo "abc %-= def." | sed 's/\>/X/g'
abcX %-= defX.
\`^ in multi-line mode.
Compare the following two examples:
$ printf "a\nb\nc\n" | sed 'N;N;s/^/X/gm'
Xa
Xb
Xc
$ printf "a\nb\nc\n" | sed 'N;N;s/\`/X/gm'
Xa
b
c
\'$ in multi-line mode.
back-references are regular expression commands which refer to a previous part of the matched regular expression. Back-references are specified with backslash and a single digit (e.g. ‘\1’). The part of the regular expression they refer to is called a subexpression, and is designated with parentheses.
Back-references and subexpressions are used in two cases: in the regular expression search pattern, and in the replacement part of the s command (see Regular Expression Addresses and The "s" Command).
In a regular expression pattern, back-references are used to match the same content as a previously matched subexpression. In the following example, the subexpression is ‘.’ - any single character (being surrounded by parentheses makes it a subexpression). The back-reference ‘\1’ asks to match the same content (same character) as the sub-expression.
The command below matches words starting with any character, followed by the letter ‘o’, followed by the same character as the first.
$ sed -E -n '/^(.)o\1$/p' /usr/share/dict/words
bob
mom
non
pop
sos
tot
wow
Multiple subexpressions are automatically numbered from left-to-right. This command searches for 6-letter palindromes (the first three letters are 3 subexpressions, followed by 3 back-references in reverse order):
$ sed -E -n '/^(.)(.)(.)\3\2\1$/p' /usr/share/dict/words
redder
In the s command, back-references can be used in the replacement part to refer back to subexpressions in the regexp part.
The following example uses two subexpressions in the regular expression to match two space-separated words. The back-references in the replacement part prints the words in a different order:
$ echo "James Bond" | sed -E 's/(.*) (.*)/The name is \2, \1 \2./'
The name is Bond, James Bond.
When used with alternation, if the group does not participate in the match then the back-reference makes the whole match fail. For example, ‘a(.)|b\1’ will not match ‘ba’. When multiple regular expressions are given with -e or from a file (‘-f file’), back-references are local to each expression.
Until this chapter, we have only encountered escapes of the form ‘\^’, which tell sed not to interpret the circumflex as a special character, but rather to take it literally. For example, ‘\*’ matches a single asterisk rather than zero or more backslashes.
This chapter introduces another kind of escape6—that is, escapes that are applied to a character or sequence of characters that ordinarily are taken literally, and that sed replaces with a special character. This provides a way of encoding non-printable characters in patterns in a visible manner. There is no restriction on the appearance of non-printing characters in a sed script but when a script is being prepared in the shell or by text editing, it is usually easier to use one of the following escape sequences than the binary character it represents:
The list of these escapes is:
\a\f\n\r\t\v\cx\dxxx\oxxx\xxx‘\b’ (backspace) was omitted because of the conflict with the existing “word boundary” meaning.
TODO: fix following paragraphs (copied verbatim from 'bracket expression' section).
TODO: mention locale support is heavily dependent on the OS/libc, not on sed.
The current locale affects the characters matched by sed's regular expressions.
In other locales, the sorting sequence is not specified, and ‘[a-d]’ might be equivalent to ‘[abcd]’ or to ‘[aBbCcDd]’, or it might fail to match any character, or the set of characters that it matches might even be erratic. To obtain the traditional interpretation of bracket expressions, you can use the ‘C’ locale by setting the LC_ALL environment variable to the value ‘C’.
# TODO: is there any real-world system/locale where 'A'
# is replaced by '-' ?
$ echo A | sed 's/[a-z]/-/'
A
Their interpretation depends on the LC_CTYPE locale; for example, ‘[[:alnum:]]’ means the character class of numbers and letters in the current locale.
TODO: show example of collation
# TODO: this works on glibc systems, not on musl-libc/freebsd/macosx.
$ printf 'cliché\n' | LC_ALL=fr_FR.utf8 sed 's/[[=e=]]/X/g'
clichX
sed maintains two data buffers: the active pattern space, and the auxiliary hold space. Both are initially empty.
sed operates by performing the following cycle on each line of input: first, sed reads one line from the input stream, removes any trailing newline, and places it in the pattern space. Then commands are executed; each command can have an address associated to it: addresses are a kind of condition code, and a command is only executed if the condition is verified before the command is to be executed.
When the end of the script is reached, unless the -n option is in use, the contents of pattern space are printed out to the output stream, adding back the trailing newline if it was removed.7 Then the next cycle starts for the next input line.
Unless special commands (like ‘D’) are used, the pattern space is deleted between two cycles. The hold space, on the other hand, keeps its data between cycles (see commands ‘h’, ‘H’, ‘x’, ‘g’, ‘G’ to move data between both buffers).
TODO
Multiple lines can be processed as one buffer using the
D,G,H,N,P. They are similar to
their lowercase counterparts (d,g,
h,n,p), except that these commands append or
subtract data while respecting embedded newlines - allowing adding and
removing lines from the pattern and hold spaces.
They operate as follows:
DGHNPThe following example illustrates the operation of N and
D commands:
on on
$ seq 6 | sed -n 'N;l;D'
1\n2$
2\n3$
3\n4$
4\n5$
5\n6$
off off
N
command appends a newline and the next line to the pattern space
(i.e. ‘1’, ‘\n’, ‘2’ in the first cycle).
l command prints the content of the pattern space
unambiguously.
D command then removes the content of pattern
space up to the first newline (leaving ‘2’ at the end of
the first cycle).
N command appends a
newline and the next input line to the pattern space
(e.g. ‘2’, ‘\n’, ‘3’).
A common technique to process blocks of text such as paragraphs (instead of line-by-line) is using the following construct:
on on
sed '/./{H;$!d} ; x ; s/REGEXP/REPLACEMENT/'
off off
/./{H;$!d} operates on all non-empty lines,
and adds the current line (in the pattern space) to the hold space.
On all lines except the last, the pattern space is deleted and the cycle is
restarted.
x and s are executed only on empty
lines (i.e. paragraph separators). The x command fetches the
accumulated lines from the hold space back to the pattern space. The
s/// command then operates on all the text in the paragraph
(including the embedded newlines).
The following example demonstrates this technique: on on
$ cat input.txt
a a a aa aaa
aaaa aaaa aa
aaaa aaa aaa
bbbb bbb bbb
bb bb bbb bb
bbbbbbbb bbb
ccc ccc cccc
cccc ccccc c
cc cc cc cc
$ sed '/./{H;$!d} ; x ; s/^/\nSTART-->/ ; s/$/\n<--END/' input.txt
START-->
a a a aa aaa
aaaa aaaa aa
aaaa aaa aaa
<--END
START-->
bbbb bbb bbb
bb bb bbb bb
bbbbbbbb bbb
<--END
START-->
ccc ccc cccc
cccc ccccc c
cc cc cc cc
<--END
off off
For more annotated examples, see Text search across multiple lines and Line length adjustment.
The branching commands b, t, and T enable
changing the flow of sed programs.
By default, sed reads an input line into the pattern buffer, then continues to processes all commands in order. Commands without addresses affect all lines. Commands with addresses affect only matching lines. See Execution Cycle and Addresses overview.
sed does not support a typical if/then construct.
Instead, some commands can be used as conditionals or to change the
default flow control:
dD[addr]X[addr]{ X ; X ; X }/regexp/X/regexp/{ X ; X ; X }if/then
conditional: If [addr] matches the current pattern space,
execute the command(s).
For example: The command /^#/d means:
if the current pattern matches the regular expression ^# (a line
starting with a hash), then execute the d command:
delete the line without printing it, and restart the program cycle
immediately.
bts/// command has succeeded since the last input line was read
or another conditional branch was taken.
Tt command: branch only if
there has been no successful substitutions since the last
input line was read.
The following two sed programs are equivalent. The first
(contrived) example uses the b command to skip the s///
command on lines containing ‘1’. The second example uses an
address with negation (‘!’) to perform substitution only on
desired lines. The y/// command is still executed on all
lines:
on on
$ printf '%s\n' a1 a2 a3 | sed -E '/1/bx ; s/a/z/ ; :x ; y/123/456/'
a4
z5
z6
$ printf '%s\n' a1 a2 a3 | sed -E '/1/!s/a/z/ ; y/123/456/'
a4
z5
z6
off off
The b,t and T commands can be followed by a label
(typically a single letter). Labels are defined with a colon followed by
one or more letters (e.g. ‘:x’). If the label is omitted the
branch commands restart the cycle. Note the difference between
branching to a label and restarting the cycle: when a cycle is
restarted, sed first prints the current content of the
pattern space, then reads the next input line into the pattern space;
Jumping to a label (even if it is at the beginning of the program)
does not print the pattern space and does not read the next input line.
The following program is a no-op. The b command (the only command
in the program) does not have a label, and thus simply restarts the cycle.
On each cycle, the pattern space is printed and the next input line is read:
$ seq 3 | sed b
1
2
3
The following example is an infinite-loop - it doesn't terminate and
doesn't print anything. The b command jumps to the ‘x’
label, and a new cycle is never started:
on on
$ seq 3 | sed ':x ; bx'
# The above command requires gnu sed (which supports additional
# commands following a label, without a newline). A portable equivalent:
# sed -e ':x' -e bx
off off
Branching is often complemented with the n or N commands:
both commands read the next input line into the pattern space without waiting
for the cycle to restart. Before reading the next input line, n
prints the current pattern space then empties it, while N
appends a newline and the next input line to the pattern space.
Consider the following two examples:
on on
$ seq 3 | sed ':x ; n ; bx'
1
2
3
$ seq 3 | sed ':x ; N ; bx'
1
2
3
off off
n commands first prints the content
of the pattern space, empties the pattern space then reads the next
input line.
N commands appends the next input
line to the pattern space (with a newline). Lines are accumulated in
the pattern space until there are no more input lines to read, then
the N command terminates the sed program. When the
program terminates, the end-of-cycle actions are performed, and the
entire pattern space is printed.
N.
See the “N command on the last line” paragraph
in Reporting Bugs.
printf '%s\n' aa bb cc dd | sed ':x ; n ; = ; bx'
printf '%s\n' aa bb cc dd | sed ':x ; N ; = ; bx'
printf '%s\n' aa bb cc dd | sed ':x ; n ; s/\n/***/ ; bx'
printf '%s\n' aa bb cc dd | sed ':x ; N ; s/\n/***/ ; bx'
off off
As a real-world example of using branching, consider the case of quoted-printable files, typically used to encode email messages. In these files long lines are split and marked with a soft line break consisting of a single ‘=’ character at the end of the line:
$ cat jaques.txt
All the wor=
ld's a stag=
e,
And all the=
men and wo=
men merely =
players:
They have t=
heir exits =
and their e=
ntrances;
And one man=
in his tim=
e plays man=
y parts.
The following program uses an address match ‘/=$/’ as a
conditional: If the current pattern space ends with a ‘=’, it
reads the next input line using N, replaces all ‘=’
characters which are followed by a newline, and unconditionally
branches (b) to the beginning of the program without restarting
a new cycle. If the pattern space does not ends with ‘=’, the
default action is performed: the pattern space is printed and a new
cycle is started:
on on
$ sed ':x ; /=$/ { N ; s/=\n//g ; bx }' jaques.txt
All the world's a stage,
And all the men and women merely players:
They have their exits and their entrances;
And one man in his time plays many parts.
off off
Here's an alternative program with a slightly different approach: On
all lines except the last, N appends the line to the pattern
space. A substitution command then removes soft line breaks
(‘=’ at the end of a line, i.e. followed by a newline) by replacing
them with an empty string.
if the substitution was successful (meaning the pattern space contained
a line which should be joined), The conditional branch command t jumps
to the beginning of the program without completing or restarting the cycle.
If the substitution failed (meaning there were no soft line breaks),
The t command will not branch. Then, P will
print the pattern space content until the first newline, and D
will delete the pattern space content until the first new line.
(To learn more about N, P and D commands
see Multiline techniques).
on on
$ sed ':x ; $!N ; s/=\n// ; tx ; P ; D' jaques.txt
All the world's a stage,
And all the men and women merely players:
They have their exits and their entrances;
And one man in his time plays many parts.
off off
For more line-joining examples see Joining lines.
Here are some sed scripts to guide you in the art of mastering sed.
Useful one-liners:
Some exotic examples:
Emulating standard utilities:
This section uses N, D and P commands to process
multiple lines, and the b and t commands for branching.
See Multiline techniques and Branching and flow control.
Join specific lines (e.g. if lines 2 and 3 need to be joined):
on on
$ cat lines.txt
hello
hel
lo
hello
$ sed '2{N;s/\n//;}' lines.txt
hello
hello
hello
off off
Join backslash-continued lines:
on on
$ cat 1.txt
this \
is \
a \
long \
line
and another \
line
$ sed -e ':x /\\$/ { N; s/\\\n//g ; bx }' 1.txt
this is a long line
and another line
#TODO: The above requires gnu sed.
# non-gnu seds need newlines after ':' and 'b'
off off
Join lines that start with whitespace (e.g SMTP headers):
on on
$ cat 2.txt
Subject: Hello
World
Content-Type: multipart/alternative;
boundary=94eb2c190cc6370f06054535da6a
Date: Tue, 3 Jan 2017 19:41:16 +0000 (GMT)
Authentication-Results: mx.gnu.org;
dkim=pass header.i=@gnu.org;
spf=pass
Message-ID: <abcdef@gnu.org>
From: John Doe <jdoe@gnu.org>
To: Jane Smith <jsmith@gnu.org>
$ sed -E ':a ; $!N ; s/\n\s+/ / ; ta ; P ; D' 2.txt
Subject: Hello World
Content-Type: multipart/alternative; boundary=94eb2c190cc6370f06054535da6a
Date: Tue, 3 Jan 2017 19:41:16 +0000 (GMT)
Authentication-Results: mx.gnu.org; dkim=pass header.i=@gnu.org; spf=pass
Message-ID: <abcdef@gnu.org>
From: John Doe <jdoe@gnu.org>
To: Jane Smith <jsmith@gnu.org>
# A portable (non-gnu) variation:
# sed -e :a -e '$!N;s/\n */ /;ta' -e 'P;D'
off off
This script centers all lines of a file on a 80 columns width.
To change that width, the number in \{...\} must be
replaced, and the number of added spaces also must be changed.
Note how the buffer commands are used to separate parts in the regular expressions to be matched—this is a common technique.
#!/usr/bin/sed -f
# Put 80 spaces in the buffer
1 {
x
s/^$/ /
s/^.*$/&&&&&&&&/
x
}
# delete leading and trailing spaces
y/tab/ /
s/^ *//
s/ *$//
# add a newline and 80 spaces to end of line
G
# keep first 81 chars (80 + a newline)
s/^\(.\{81\}\).*$/\1/
# \2 matches half of the spaces, which are moved to the beginning
s/^\(.*\)\n\(.*\)\2/\2\1/
This script is one of a few that demonstrate how to do arithmetic in sed. This is indeed possible,8 but must be done manually.
To increment one number you just add 1 to last digit, replacing it by the following digit. There is one exception: when the digit is a nine the previous digits must be also incremented until you don't have a nine.
This solution by Bruno Haible is very clever and smart because
it uses a single buffer; if you don't have this limitation, the
algorithm used in Numbering lines, is faster.
It works by replacing trailing nines with an underscore, then
using multiple s commands to increment the last digit,
and then again substituting underscores with zeros.
#!/usr/bin/sed -f
/[^0-9]/ d
# replace all trailing 9s by _ (any other character except digits, could
# be used)
:d
s/9\(_*\)$/_\1/
td
# incr last digit only. The first line adds a most-significant
# digit of 1 if we have to add a digit.
s/^\(_*\)$/1\1/; tn
s/8\(_*\)$/9\1/; tn
s/7\(_*\)$/8\1/; tn
s/6\(_*\)$/7\1/; tn
s/5\(_*\)$/6\1/; tn
s/4\(_*\)$/5\1/; tn
s/3\(_*\)$/4\1/; tn
s/2\(_*\)$/3\1/; tn
s/1\(_*\)$/2\1/; tn
s/0\(_*\)$/1\1/; tn
:n
y/_/0/
This is a pretty strange use of sed. We transform text, and transform it to be shell commands, then just feed them to shell. Don't worry, even worse hacks are done when using sed; I have seen a script converting the output of date into a bc program!
The main body of this is the sed script, which remaps the name from lower to upper (or vice-versa) and even checks out if the remapped name is the same as the original name. Note how the script is parameterized using shell variables and proper quoting.
#! /bin/sh
# rename files to lower/upper case...
#
# usage:
# move-to-lower *
# move-to-upper *
# or
# move-to-lower -R .
# move-to-upper -R .
#
help()
{
cat << eof
Usage: $0 [-n] [-r] [-h] files...
-n do nothing, only see what would be done
-R recursive (use find)
-h this message
files files to remap to lower case
Examples:
$0 -n * (see if everything is ok, then...)
$0 *
$0 -R .
eof
}
apply_cmd='sh'
finder='echo "$@" | tr " " "\n"'
files_only=
while :
do
case "$1" in
-n) apply_cmd='cat' ;;
-R) finder='find "$@" -type f';;
-h) help ; exit 1 ;;
*) break ;;
esac
shift
done
if [ -z "$1" ]; then
echo Usage: $0 [-h] [-n] [-r] files...
exit 1
fi
LOWER='abcdefghijklmnopqrstuvwxyz'
UPPER='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
case `basename $0` in
*upper*) TO=$UPPER; FROM=$LOWER ;;
*) FROM=$UPPER; TO=$LOWER ;;
esac
eval $finder | sed -n '
# remove all trailing slashes
s/\/*$//
# add ./ if there is no path, only a filename
/\//! s/^/.\//
# save path+filename
h
# remove path
s/.*\///
# do conversion only on filename
y/'$FROM'/'$TO'/
# now line contains original path+file, while
# hold space contains the new filename
x
# add converted file name to line, which now contains
# path/file-name\nconverted-file-name
G
# check if converted file name is equal to original file name,
# if it is, do not print anything
/^.*\/\(.*\)\n\1/b
# escape special characters for the shell
s/["$`\\]/\\&/g
# now, transform path/fromfile\n, into
# mv path/fromfile path/tofile and print it
s/^\(.*\/\)\(.*\)\n\(.*\)$/mv "\1\2" "\1\3"/p
' | $apply_cmd
This script strips the definition of the shell functions from the output of the set Bourne-shell command.
#!/bin/sh
set | sed -n '
:x
# if no occurrence of ‘=()’ print and load next line
/=()/! { p; b; }
/ () $/! { p; b; }
# possible start of functions section
# save the line in case this is a var like FOO="() "
h
# if the next line has a brace, we quit because
# nothing comes after functions
n
/^{/ q
# print the old line
x; p
# work on the new line now
x; bx
'
This script can be used to reverse the position of characters in lines. The technique moves two characters at a time, hence it is faster than more intuitive implementations.
Note the tx command before the definition of the label.
This is often needed to reset the flag that is tested by
the t command.
Imaginative readers will find uses for this script. An example is reversing the output of banner.9
#!/usr/bin/sed -f
/../! b
# Reverse a line. Begin embedding the line between two newlines
s/^.*$/\
&\
/
# Move first character at the end. The regexp matches until
# there are zero or one characters between the markers
tx
:x
s/\(\n.\)\(.*\)\(.\n\)/\3\2\1/
tx
# Remove the newline markers
s/\n//g
This section uses N and D commands to search for
consecutive words spanning multiple lines. See Multiline techniques.
These examples deal with finding doubled occurrences of words in a document.
Finding doubled words in a single line is easy using GNU grep and similarly with GNU sed:
on on
$ cat two-cities-dup1.txt
It was the best of times,
it was the worst of times,
it was the the age of wisdom,
it was the age of foolishness,
$ grep -E '\b(\w+)\s+\1\b' two-cities-dup1.txt
it was the the age of wisdom,
$ grep -n -E '\b(\w+)\s+\1\b' two-cities-dup1.txt
3:it was the the age of wisdom,
$ sed -En '/\b(\w+)\s+\1\b/p' two-cities-dup1.txt
it was the the age of wisdom,
$ sed -En '/\b(\w+)\s+\1\b/{=;p}' two-cities-dup1.txt
3
it was the the age of wisdom,
off off
When the doubled word span two lines the above regular expression will not find them as grep and sed operate line-by-line.
By using N and D commands, sed can apply regular expressions on multiple lines (that is, multiple lines are stored in the pattern space, and the regular expression works on it):
on on
$ cat two-cities-dup2.txt
It was the best of times, it was the
worst of times, it was the
the age of wisdom,
it was the age of foolishness,
$ sed -En '{N; /\b(\w+)\s+\1\b/{=;p} ; D}' two-cities-dup2.txt
3
worst of times, it was the
the age of wisdom,
off off
See the GNU coreutils manual for an alternative solution using tr -s and uniq at https://gnu.org/s/coreutils/manual/html_node/Squeezing-and-deleting.html.
This section uses N and D commands to search for
consecutive words spanning multiple lines, and the b command for
branching.
See Multiline techniques and Branching and flow control.
These (somewhat contrived) examples deal with formatting and wrapping lines of text of the following input file:
$ cat two-cities-mix.txt
It was the best of times, it was
the worst of times, it
was the age of
wisdom,
it
was
the age
of foolishness,
The following command will wrap lines at 40 characters: on on
$ sed -E ':x {N ; s/\n/ /g ; s/(.{40,40})/\1\n/ ; /\n/!bx ; P ; D}' \
two-cities-mix.txt
It was the best of times, it was the wor
st of times, it was the age of wisdom, i
t was the age of foolishness,
off off
The following command will split lines by comma character: on on
$ sed -E ':x {N ; s/\n/ /g ; s/,/,\n/ ; /\n/!bx ; s/^ *// ; P ; D}' \
two-cities-mix.txt
It was the best of times,
it was the worst of times,
it was the age of wisdom,
it was the age of foolishness,
off off
Both examples use similar construct:
This one begins a series of totally useless (yet interesting) scripts emulating various Unix commands. This, in particular, is a tac workalike.
Note that on implementations other than GNU sed this script might easily overflow internal buffers.
#!/usr/bin/sed -nf
# reverse all lines of input, i.e. first line became last, ...
# from the second line, the buffer (which contains all previous lines)
# is *appended* to current line, so, the order will be reversed
1! G
# on the last line we're done -- print everything
$ p
# store everything on the buffer again
h
This script replaces ‘cat -n’; in fact it formats its output exactly like GNU cat does.
Of course this is completely useless and for two reasons: first, because somebody else did it in C, second, because the following Bourne-shell script could be used for the same purpose and would be much faster:
#! /bin/sh
sed -e "=" $@ | sed -e '
s/^/ /
N
s/^ *\(......\)\n/\1 /
'
It uses sed to print the line number, then groups lines two
by two using N. Of course, this script does not teach as much as
the one presented below.
The algorithm used for incrementing uses both buffers, so the line
is printed as soon as possible and then discarded. The number
is split so that changing digits go in a buffer and unchanged ones go
in the other; the changed digits are modified in a single step
(using a y command). The line number for the next line
is then composed and stored in the hold space, to be used in the
next iteration.
#!/usr/bin/sed -nf
# Prime the pump on the first line
x
/^$/ s/^.*$/1/
# Add the correct line number before the pattern
G
h
# Format it and print it
s/^/ /
s/^ *\(......\)\n/\1 /p
# Get the line number from hold space; add a zero
# if we're going to add a digit on the next line
g
s/\n.*$//
/^9*$/ s/^/0/
# separate changing/unchanged digits with an x
s/.9*$/x&/
# keep changing digits in hold space
h
s/^.*x//
y/0123456789/1234567890/
x
# keep unchanged digits in pattern space
s/x.*$//
# compose the new number, remove the newline implicitly added by G
G
s/\n//
h
Emulating ‘cat -b’ is almost the same as ‘cat -n’—we only have to select which lines are to be numbered and which are not.
The part that is common to this script and the previous one is not commented to show how important it is to comment sed scripts properly...
#!/usr/bin/sed -nf
/^$/ {
p
b
}
# Same as cat -n from now
x
/^$/ s/^.*$/1/
G
h
s/^/ /
s/^ *\(......\)\n/\1 /p
x
s/\n.*$//
/^9*$/ s/^/0/
s/.9*$/x&/
h
s/^.*x//
y/0123456789/1234567890/
x
s/x.*$//
G
s/\n//
h
This script shows another way to do arithmetic with sed. In this case we have to add possibly large numbers, so implementing this by successive increments would not be feasible (and possibly even more complicated to contrive than this script).
The approach is to map numbers to letters, kind of an abacus implemented with sed. ‘a’s are units, ‘b’s are tens and so on: we simply add the number of characters on the current line as units, and then propagate the carry to tens, hundreds, and so on.
As usual, running totals are kept in hold space.
On the last line, we convert the abacus form back to decimal.
For the sake of variety, this is done with a loop rather than
with some 80 s commands10: first we
convert units, removing ‘a’s from the number; then we
rotate letters so that tens become ‘a’s, and so on
until no more letters remain.
#!/usr/bin/sed -nf
# Add n+1 a's to hold space (+1 is for the newline)
s/./a/g
H
x
s/\n/a/
# Do the carry. The t's and b's are not necessary,
# but they do speed up the thing
t a
: a; s/aaaaaaaaaa/b/g; t b; b done
: b; s/bbbbbbbbbb/c/g; t c; b done
: c; s/cccccccccc/d/g; t d; b done
: d; s/dddddddddd/e/g; t e; b done
: e; s/eeeeeeeeee/f/g; t f; b done
: f; s/ffffffffff/g/g; t g; b done
: g; s/gggggggggg/h/g; t h; b done
: h; s/hhhhhhhhhh//g
: done
$! {
h
b
}
# On the last line, convert back to decimal
: loop
/a/! s/[b-h]*/&0/
s/aaaaaaaaa/9/
s/aaaaaaaa/8/
s/aaaaaaa/7/
s/aaaaaa/6/
s/aaaaa/5/
s/aaaa/4/
s/aaa/3/
s/aa/2/
s/a/1/
: next
y/bcdefgh/abcdefg/
/[a-h]/ b loop
p
This script is almost the same as the previous one, once each of the words on the line is converted to a single ‘a’ (in the previous script each letter was changed to an ‘a’).
It is interesting that real wc programs have optimized loops for ‘wc -c’, so they are much slower at counting words rather than characters. This script's bottleneck, instead, is arithmetic, and hence the word-counting one is faster (it has to manage smaller numbers).
Again, the common parts are not commented to show the importance of commenting sed scripts.
#!/usr/bin/sed -nf
# Convert words to a's
s/[ tab][ tab]*/ /g
s/^/ /
s/ [^ ][^ ]*/a /g
s/ //g
# Append them to hold space
H
x
s/\n//
# From here on it is the same as in wc -c.
/aaaaaaaaaa/! bx; s/aaaaaaaaaa/b/g
/bbbbbbbbbb/! bx; s/bbbbbbbbbb/c/g
/cccccccccc/! bx; s/cccccccccc/d/g
/dddddddddd/! bx; s/dddddddddd/e/g
/eeeeeeeeee/! bx; s/eeeeeeeeee/f/g
/ffffffffff/! bx; s/ffffffffff/g/g
/gggggggggg/! bx; s/gggggggggg/h/g
s/hhhhhhhhhh//g
:x
$! { h; b; }
:y
/a/! s/[b-h]*/&0/
s/aaaaaaaaa/9/
s/aaaaaaaa/8/
s/aaaaaaa/7/
s/aaaaaa/6/
s/aaaaa/5/
s/aaaa/4/
s/aaa/3/
s/aa/2/
s/a/1/
y/bcdefgh/abcdefg/
/[a-h]/ by
p
No strange things are done now, because sed gives us ‘wc -l’ functionality for free!!! Look:
#!/usr/bin/sed -nf
$=
This script is probably the simplest useful sed script.
It displays the first 10 lines of input; the number of displayed
lines is right before the q command.
#!/usr/bin/sed -f
10q
Printing the last n lines rather than the first is more complex but indeed possible. n is encoded in the second line, before the bang character.
This script is similar to the tac script in that it keeps the final output in the hold space and prints it at the end:
#!/usr/bin/sed -nf
1! {; H; g; }
1,10 !s/[^\n]*\n//
$p
h
Mainly, the scripts keeps a window of 10 lines and slides it
by adding a line and deleting the oldest (the substitution command
on the second line works like a D command but does not
restart the loop).
The “sliding window” technique is a very powerful way to write
efficient and complex sed scripts, because commands like
P would require a lot of work if implemented manually.
To introduce the technique, which is fully demonstrated in the
rest of this chapter and is based on the N, P
and D commands, here is an implementation of tail
using a simple “sliding window.”
This looks complicated but in fact the working is the same as
the last script: after we have kicked in the appropriate number
of lines, however, we stop using the hold space to keep inter-line
state, and instead use N and D to slide pattern
space by one line:
#!/usr/bin/sed -f
1h
2,10 {; H; g; }
$q
1,9d
N
D
Note how the first, second and fourth line are inactive after the first ten lines of input. After that, all the script does is: exiting on the last line of input, appending the next input line to pattern space, and removing the first line.
This is an example of the art of using the N, P
and D commands, probably the most difficult to master.
#!/usr/bin/sed -f
h
:b
# On the last line, print and exit
$b
N
/^\(.*\)\n\1$/ {
# The two lines are identical. Undo the effect of
# the n command.
g
bb
}
# If the N command had added the last line, print and exit
$b
# The lines are different; print the first and go
# back working on the second.
P
D
As you can see, we maintain a 2-line window using P and D.
This technique is often used in advanced sed scripts.
This script prints only duplicated lines, like ‘uniq -d’.
#!/usr/bin/sed -nf
$b
N
/^\(.*\)\n\1$/ {
# Print the first of the duplicated lines
s/.*\n//
p
# Loop until we get a different line
:b
$b
N
/^\(.*\)\n\1$/ {
s/.*\n//
bb
}
}
# The last line cannot be followed by duplicates
$b
# Found a different one. Leave it alone in the pattern space
# and go back to the top, hunting its duplicates
D
This script prints only unique lines, like ‘uniq -u’.
#!/usr/bin/sed -f
# Search for a duplicate line --- until that, print what you find.
$b
N
/^\(.*\)\n\1$/ ! {
P
D
}
:c
# Got two equal lines in pattern space. At the
# end of the file we simply exit
$d
# Else, we keep reading lines with N until we
# find a different one
s/.*\n//
N
/^\(.*\)\n\1$/ {
bc
}
# Remove the last instance of the duplicate line
# and go back to the top
D
As a final example, here are three scripts, of increasing complexity and speed, that implement the same function as ‘cat -s’, that is squeezing blank lines.
The first leaves a blank line at the beginning and end if there are some already.
#!/usr/bin/sed -f
# on empty lines, join with next
# Note there is a star in the regexp
:x
/^\n*$/ {
N
bx
}
# now, squeeze all '\n', this can be also done by:
# s/^\(\n\)*/\1/
s/\n*/\
/
This one is a bit more complex and removes all empty lines at the beginning. It does leave a single blank line at end if one was there.
#!/usr/bin/sed -f
# delete all leading empty lines
1,/^./{
/./!d
}
# on an empty line we remove it and all the following
# empty lines, but one
:x
/./!{
N
s/^\n$//
tx
}
This removes leading and trailing blank lines. It is also the
fastest. Note that loops are completely done with n and
b, without relying on sed to restart the
script automatically at the end of a line.
#!/usr/bin/sed -nf
# delete all (leading) blanks
/./!d
# get here: so there is a non empty
:x
# print it
p
# get next
n
# got chars? print it again, etc...
/./bx
# no, don't have chars: got an empty line
:z
# get next, if last line we finish here so no trailing
# empty lines are written
n
# also empty? then ignore it, and get next... this will
# remove ALL empty lines
/./!bz
# all empty lines were deleted/ignored, but we have a non empty. As
# what we want to do is to squeeze, insert a blank line artificially
i\
bx
For those who want to write portable sed scripts,
be aware that some implementations have been known to
limit line lengths (for the pattern and hold spaces)
to be no more than 4000 bytes.
The posix standard specifies that conforming sed
implementations shall support at least 8192 byte line lengths.
GNU sed has no built-in limit on line length;
as long as it can malloc() more (virtual) memory,
you can feed or construct lines as long as you like.
However, recursion is used to handle subpatterns and indefinite repetition. This means that the available stack space may limit the size of the buffer that can be processed by certain patterns.
For up to date information about GNU sed please visit https://www.gnu.org/software/sed/.
Send general questions and suggestions to sed-devel@gnu.org. Visit the mailing list archives for past discussions at https://lists.gnu.org/archive/html/sed-devel/.
The following resources provide information about sed (both GNU sed and other variations). Note these not maintained by GNU sed developers.
$HOME: http://sed.sf.net
sed-users mailing list maintained by Sven Guckes:
http://groups.yahoo.com/group/sed-users/
(note this is not the GNU sed mailing list).
Email bug reports to bug-sed@gnu.org. Also, please include the output of ‘sed --version’ in the body of your report if at all possible.
Please do not send a bug report like this:
while building frobme-1.3.4
$ configure
error--> sed: file sedscr line 1: Unknown option to 's'
If GNU sed doesn't configure your favorite package, take a few extra minutes to identify the specific problem and make a stand-alone test case. Unlike other programs such as C compilers, making such test cases for sed is quite simple.
A stand-alone test case includes all the data necessary to perform the test, and the specific invocation of sed that causes the problem. The smaller a stand-alone test case is, the better. A test case should not involve something as far removed from sed as “try to configure frobme-1.3.4”. Yes, that is in principle enough information to look for the bug, but that is not a very practical prospect.
Here are a few commonly reported bugs that are not bugs.
N command on the last lineDefault behavior (gnu extension, non-POSIX conforming):
$ seq 3 | sed N
1
2
3
To force POSIX-conforming behavior:
$ seq 3 | sed --posix N
1
2
For example, the behavior of
sed N foo bar
would depend on whether foo has an even or an odd number of
lines11. Or, when writing a script to read the
next few lines following a pattern match, traditional
implementations of sed would force you to write
something like
/foo/{ $!N; $!N; $!N; $!N; $!N; $!N; $!N; $!N; $!N }
instead of just
/foo/{ N;N;N;N;N;N;N;N;N; }
In any case, the simplest workaround is to use $d;N in
scripts that rely on the traditional behavior, or to set
the POSIXLY_CORRECT variable to a non-empty value.
\|,
\+, \?, \`, \', \<,
\>, \b, \B, \w, and \W.
As in all GNU programs that use posix basic regular
expressions, sed interprets these escape sequences as special
characters. So, x\+ matches one or more occurrences of ‘x’.
abc\|def matches either ‘abc’ or ‘def’.
This syntax may cause problems when running scripts written for other
seds. Some sed programs have been written with the
assumption that \| and \+ match the literal characters
| and +. Such scripts must be modified by removing the
spurious backslashes if they are to be used with modern implementations
of sed, like
GNU sed.
On the other hand, some scripts use s|abc\|def||g to remove occurrences
of either abc or def. While this worked until
sed 4.0.x, newer versions interpret this as removing the
string abc|def. This is again undefined behavior according to
POSIX, and this interpretation is arguably more robust: older
seds, for example, required that the regex matcher parsed
\/ as / in the common case of escaping a slash, which is
again undefined behavior; the new behavior avoids this, and this is good
because the regex matcher is only partially under our control.
In addition, this version of sed supports several escape characters
(some of which are multi-character) to insert non-printable characters
in scripts (\a, \c, \d, \o, \r,
\t, \v, \x). These can cause similar problems
with scripts written for other seds.
The permissions on a file say what can happen to the data
in that file, while the permissions on a directory say what can
happen to the list of files in that directory. ‘sed -i’
will not ever open for writing a file that is already on disk.
Rather, it will work on a temporary file that is finally renamed
to the original name: if you rename or delete files, you're actually
modifying the contents of the directory, so the operation depends on
the permissions of the directory, not of the file. For this same
reason, sed does not let you use -i on a writable file
in a read-only directory, and will break hard or symbolic links when
-i is used on such a file.
0a does not work (gives an error)0,/RE/ as active when the script starts: if
you write 1,/abc/d and the first line includes the word ‘abc’,
then that match would be ignored because address ranges must span at least
two lines (barring the end of the file); but what you probably wanted is
to delete every line up to the first one including ‘abc’, and this
is obtained with 0,/abc/d.
[a-z] is case insensitive[a-z]
uses the current locale's collation order – in C parlance, that means using
strcoll(3) instead of strcmp(3). Some locales have a
case-insensitive collation order, others don't.
Another problem is that [a-z] tries to use collation symbols.
This only happens if you are on the GNU system, using
GNU libc's regular expression matcher instead of compiling the
one supplied with GNU sed. In a Danish locale, for example,
the regular expression ^[a-z]$ matches the string ‘aa’,
because this is a single collating symbol that comes after ‘a’
and before ‘b’; ‘ll’ behaves similarly in Spanish
locales, or ‘ij’ in Dutch locales.
To work around these problems, which may cause bugs in shell scripts, set
the LC_COLLATE and LC_CTYPE environment variables to ‘C’.
s/.*// does not clear pattern spaceTo work around these problems, which may cause bugs in shell scripts, set the LC_COLLATE and LC_CTYPE environment variables to ‘C’.
Copyright © 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
http://fsf.org/
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
The purpose of this License is to make a manual, textbook, or other functional and useful document free in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.
This License is a kind of “copyleft”, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.
This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The “Document”, below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as “you”. You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.
A “Modified Version” of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.
A “Secondary Section” is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
The “Invariant Sections” are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.
The “Cover Texts” are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.
A “Transparent” copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not “Transparent” is called “Opaque”.
Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.
The “Title Page” means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, “Title Page” means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.
The “publisher” means any person or entity that distributes copies of the Document to the public.
A section “Entitled XYZ” means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as “Acknowledgements”, “Dedications”, “Endorsements”, or “History”.) To “Preserve the Title” of such a section when you modify the Document means that it remains a section “Entitled XYZ” according to this definition.
The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.
You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you may publicly display copies.
If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.
You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:
If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.
You may add a section Entitled “Endorsements”, provided it contains nothing but endorsements of your Modified Version by various parties—for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.
You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.
The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections Entitled “History” in the various original documents, forming one section Entitled “History”; likewise combine any sections Entitled “Acknowledgements”, and any sections Entitled “Dedications”. You must delete all sections Entitled “Endorsements.”
You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.
A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an “aggregate” if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.
Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.
If a section in the Document is Entitled “Acknowledgements”, “Dedications”, or “History”, the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.
You may not copy, modify, sublicense, or distribute the Document except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.
However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.
Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, receipt of a copy of some or all of the same material does not give you any rights to use it.
The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License “or any later version” applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. If the Document specifies that a proxy can decide which future versions of this License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Document.
“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any World Wide Web server that publishes copyrightable works and also provides prominent facilities for anybody to edit those works. A public wiki that anybody can edit is an example of such a server. A “Massive Multiauthor Collaboration” (or “MMC”) contained in the site means any set of copyrightable works thus published on the MMC site.
“CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0 license published by Creative Commons Corporation, a not-for-profit corporation with a principal place of business in San Francisco, California, as well as future copyleft versions of that license published by that same organization.
“Incorporate” means to publish or republish a Document, in whole or in part, as part of another Document.
An MMC is “eligible for relicensing” if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008.
The operator of an MMC Site may republish an MMC contained in the site under CC-BY-SA on the same site at any time before August 1, 2009, provided the MMC is eligible for relicensing.
To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:
Copyright (C) year your name.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3
or any later version published by the Free Software Foundation;
with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
Texts. A copy of the license is included in the section entitled ``GNU
Free Documentation License''.
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the “with...Texts.” line with this:
with the Invariant Sections being list their titles, with
the Front-Cover Texts being list, and with the Back-Cover Texts
being list.
If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.
If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.
This is a general index of all issues discussed in this manual, with the exception of the sed commands and command-line options.
0 address: Reporting Bugss/// failed: Extended Commandss/// succeeded: Programming Commands0 address: Reporting Bugs0 address: Range Addressess/// failed: Extended Commandss commands: The "s" Commandg and number modifier: The "s" CommandI modifier: Regexp AddressesI modifier: The "s" CommandM modifier: Regexp AddressesM modifier: The "s" CommandR command: Extended Commandsg and number modifiers in the s command: The "s" Command0 address: Reporting BugsN command on the last line: Reporting BugsN command on the last line: Reporting BugsPOSIXLY_CORRECT behavior, bracket expressions: Character Classes and Bracket ExpressionsPOSIXLY_CORRECT behavior, enabling: Command-Line OptionsPOSIXLY_CORRECT behavior, escapes: EscapesPOSIXLY_CORRECT behavior, N command: Reporting BugsThis is an alphabetical list of all sed commands and command-line options.
# (comments): Common Commands--binary: Command-Line Options--expression: Command-Line Options--file: Command-Line Options--follow-symlinks: Command-Line Options--help: Command-Line Options--in-place: Command-Line Options--line-length: Command-Line Options--null-data: Command-Line Options--posix: Command-Line Options--quiet: Command-Line Options--regexp-extended: Command-Line Options--sandbox: Command-Line Options--separate: Command-Line Options--silent: Command-Line Options--unbuffered: Command-Line Options--version: Command-Line Options--zero-terminated: Command-Line Options-b: Command-Line Options-E: Command-Line Options-e: Command-Line Options-f: Command-Line Options-i: Command-Line Options-l: Command-Line Options-n: Command-Line Options-n, forcing from within a script: Common Commands-r: Command-Line Options-s: Command-Line Options-u: Command-Line Options-z: Command-Line Options: (label) command: Programming Commands= (print line number) command: Other Commandsa (append text lines) command: Other Commandsalnum character class: Character Classes and Bracket Expressionsalpha character class: Character Classes and Bracket Expressionsb (branch) command: Programming Commandsblank character class: Character Classes and Bracket Expressionsc (change to text lines) command: Other Commandscntrl character class: Character Classes and Bracket ExpressionsD (delete first line) command: Other Commandsd (delete) command: Common Commandsdigit character class: Character Classes and Bracket Expressionse (evaluate) command: Extended CommandsF (File name) command: Extended CommandsG (appending Get) command: Other Commandsg (get) command: Other Commandsgraph character class: Character Classes and Bracket ExpressionsH (append Hold) command: Other Commandsh (hold) command: Other Commandsi (insert text lines) command: Other Commandsl (list unambiguously) command: Other Commandslower character class: Character Classes and Bracket ExpressionsN (append Next line) command: Other Commandsn (next-line) command: Common CommandsP (print first line) command: Other Commandsp (print) command: Common Commandsprint character class: Character Classes and Bracket Expressionspunct character class: Character Classes and Bracket Expressionsq (quit) command: Common CommandsQ (silent Quit) command: Extended Commandsr (read file) command: Other CommandsR (read line) command: Extended Commandss command, option flags: The "s" Commandspace character class: Character Classes and Bracket ExpressionsT (test and branch if failed) command: Extended Commandst (test and branch if successful) command: Programming Commandsupper character class: Character Classes and Bracket Expressionsv (version) command: Extended Commandsw (write file) command: Other CommandsW (write first line) command: Extended Commandsx (eXchange) command: Other Commandsxdigit character class: Character Classes and Bracket Expressionsy (transliterate) command: Other Commandsz (Zap) command: Extended Commands{} command grouping: Common Commands[1] This applies to commands such as =,
a, c, i, l, p. You can
still write to the standard output by using the w
or W commands together with the /dev/stdout
special file
[2] Note that GNU sed creates the backup file whether or not any output is actually changed.
[3] This is equivalent to p unless the -i
option is being used.
[4] This is equivalent to p unless the -i
option is being used.
[5] There are of course many other ways to do the same, e.g.
grep 'bash$' /etc/passwd
awk -F: '$7 == "/bin/bash"' /etc/passwd
[6] All
the escapes introduced here are GNU
extensions, with the exception of \n. In basic regular
expression mode, setting POSIXLY_CORRECT disables them inside
bracket expressions.
[7] Actually, if sed prints a line without the terminating newline, it will nevertheless print the missing newline as soon as more text is sent to the same output stream, which gives the “least expected surprise” even though it does not make commands like ‘sed -n p’ exactly identical to cat.
[8] sed guru Greg Ubben wrote an implementation of the dc rpn calculator! It is distributed together with sed.
[9] This requires another script to pad the output of banner; for example
#! /bin/sh
banner -w $1 $2 $3 $4 |
sed -e :a -e '/^.\{0,'$1'\}$/ { s/$/ /; ba; }' |
~/sedscripts/reverseline.sed
[10] Some implementations have a limit of 199 commands per script
[11] which is the actual “bug” that prompted the change in behavior