 |
Index for
Section 1 |
|
 |
Alphabetical
listing for S |
|
 |
Bottom of
page |
|
sed(1)
NAME
sed - Stream editor
SYNOPSIS
sed [-n] script [file...]
sed [-n] [-e script]... [-f script_file...]... [file...]
The sed utility is a stream editor that reads one or more text files, makes
editing changes according to a script of editing commands and writes the
results to standard output.
STANDARDS
Interfaces documented on this reference page conform to industry standards
as follows:
sed: XCU5.0
Refer to the standards(5) reference page for more information about
industry standards and associated tags.
OPTIONS
-e script
Add the editing commands specified by the string script to the end of
the script of editing commands. If you are using just one -e option
and no -f option, you can omit the -e option and include the single
script on the command line as an argument to sed.
-f script_file
Uses script_file as the source of the edit script. The script_file is
a set of editing commands to be applied to file.
-n Suppresses all information normally written to standard output.
The order of presentation of the -e and -f options is significant.
OPERANDS
script
Use the string script as an editing script. See the description of the
-e option.
file
The path name of a file to be edited. If multiple file operands are
specified, all files are read and concatenated before editing begins.
If no file file operand is specified, standard input is read.
DESCRIPTION
The sed command includes many features for selecting lines to be modified
and making changes only to the selected lines.
The sed command uses two work spaces for holding the line being modified:
the pattern space, where the selected line is held, and the hold space,
where a line can be stored temporarily.
An edit script consists of individual subcommands, each one on a separate
line. The general form of sed subcommands is as follows:
[address_range] function [modifier ...]
The sed command processes each input file by reading an input line into a
pattern space, sequentially applying all sed subcommands in sequence whose
addresses select that line, and writing the pattern space to standard
output. It then clears the pattern space and repeats this process for each
line in the input file. Some of the subcommands use a hold space to save
all or part of the pattern space for subsequent retrieval.
[Tru64 UNIX] If you do not specify an argument to the sed command, the sed
usage string is displayed.
When a command includes an address, either a line number or a search
pattern, only the addressed line or lines are affected by the command.
Otherwise, the command is applied to all lines.
An address is either a decimal line number, a $, which addresses the last
line of input, or a context address. A context address is a basic regular
expression (BRE) as described for grep, except that you can select the
character delimiter for patterns. The general form of the expression is as
follows:
\?pattern?
The ? represents a character delimiter you select. The backslash (\) is
required when you select a delimiter other than the default slash (/)
character. This delimiter cannot be a 2-byte international character
support extended character.
The default form for the pattern is as follows:
/pattern/
· In a context address, the construction \cexpressionc, where c is any
character other than a backslash (\) or the newline character, is
identical to /expression/. If the character designated by c appears
following a \ (backslash), then it is considered to be that literal
character, which does not terminate the RE. For example, in the
context address \xabc\xdefx, the second x stands for itself, so that
the regular expression is abcxdef.
· The sequence \n matches a newline character in the pattern space,
except the terminating new line.
· A dot (.) matches any character except a terminating newline
character. That is, unlike grep, which cannot match a newline
character in the middle of a line, sed can match a newline character
in the pattern space.
Certain commands allow you to specify one line or a range of lines to which
the command applies. These commands are called addressed commands. The
following rules apply to addressed commands:
· A command line with no address selects every line.
· A command line with one address, expressed in context form, selects
each line that matches the address.
· A command line with two addresses separated by a comma (,) or
semicolon (;) selects the entire range from the first line that
matches the first address through the next line that matches the
second. (If the second address is a number less than or equal to the
line number first selected, only one line is selected.) Thereafter,
the process is repeated, looking again for the first address.
Subcommands
Backslashes in text are treated like backslashes in the replacement string
of an s command and can be used to protect initial spaces and tabs against
the stripping that is done on every script line.
The text argument accompanying the a\, c\, and i\ commands can continue
onto more than one line, provided all lines but the last end with a \
(backslash) to quote the newline character.
The read_file and write_file arguments must end the command line and must
be preceded by exactly one space. Each write_file is created before
processing begins.
[Tru64 UNIX] The sed command can process up to 999 commands in a file.
In the following list of subcommands, the maximum number of permissible
addresses for each subcommand is indicated in parentheses. The sed script
subcommands are as follows:
(2){subcommand ...
} Groups subcommands enclosed in { } (braces). The { (left brace) can be
preceded by spaces and can be followed by spaces or tabs. The list of
subcommands must be separated by newline characters. The subcommands
can also be preceded by spaces or tabs. The terminating } (right
brace) must be preceded by a newline character and then zero or more
spaces.
(1) a\
text
Places text on the output before reading the next input line.
The total number of a and/or r subcommands should not exceed 20.
()b[label]
Branches to the : command bearing the label. If label is empty, it
branches to the end of the script.
· The labels should not exceed 8 characters in length.
· Label names should not be duplicated.
· The maximum number of labels allowed in the sed script is 50.
(2)c\
text
Deletes the pattern space. With a 0 or 1 address or at the end of a
2-address range, places text on the output. Then it starts the next
cycle.
(2)d
Deletes the pattern space, then starts the next cycle.
(2)D
Deletes the initial segment of the pattern space through the first
newline character. Then it starts the next cycle.
(2)g
Replaces the contents of the pattern space with the contents of the
hold space.
(2)G
Appends the contents of the hold space to the pattern space.
(2)h
Replaces the contents of the hold space with the contents of the
pattern space.
(2)H
Appends the contents of the pattern space to the hold space.
(1)i\
text
Writes text to standard output before reading the next line into the
pattern space.
(2)l
Writes the pattern space to standard output, showing nonprinting
characters as 3-digit octal values. Long lines are folded, with the
point of folding indicated by <Backslash><Return>. The end of each
line is marked with a $.
Certain characters are shown as escape sequences as follows:
\\ Backslash
\a Alert
\b Backspace
\f Formfeed
\n Newline
\r Carriage-return
\t Tab
\v Vertical tab
(2)n
Writes the pattern space to standard output. It replaces the pattern
space with the next line of input.
(2)N
Appends the next line of input to the pattern space with an embedded
newline character. (The current line number changes.) You can use
this to search for patterns that are split onto two lines.
(2)p
Writes the pattern space to standard output.
(2)P
Writes the initial segment of the pattern space through the first
newline character to standard output.
(1)q
Branches to the end of the script. It does not start a new cycle.
(1)r read_file
Reads the contents of read_file. It places contents on the output
before reading the next input line.
The total number of a and/or r subcommands should not exceed 20.
(2)s/pattern/replacement/flags
Substitutes the replacement string for the first occurrence of the
pattern in the pattern space. Any character that is entered after the
s command can substitute for the / (slash) separator, except \
(backslash) and the newline character. Within the regular expression
and replacement string, the delimiter can appear as a literal if it is
preceded by a \ (backslash).
An & (ampersand) appearing in the replacement string is replaced by the
string matching the RE. The special meaning of & in this context can
be suppressed by preceding it with a \ (backslash). The characters \n,
where n is a digit, are replaced by the text matched by the
corresponding backreference expression.
A line can be split by substituting a newline character into it. You
must escape the newline character in the replacement string by
preceding it with a \ backslash. A substitution is considered to have
been performed even if the replacement string is identical to the
string that it replaces.
You can add zero or more of the following flags:
n Where n is 1-512, substitutes replacement for the nth occurrence of
pattern on each addressed line, rather than for the first
occurrence.
g Substitutes replacement for all nonoverlapping instances of pattern
on each addressed line, rather than for just the first one (or for
the one specified by n).
p Writes the pattern space to standard output if a replacement was
made.
[SVR4] If the environment variable CMD_ENV is set either to SVR4
or svr4, writes the substituted pattern space to standard output
only once at the end of the script, unless the -n option is
specified.
w write_file
Writes the pattern space to write_file if a replacement was made.
Appends the pattern space to write_file. If write_file was not
already created by a previous write by this sed script, sed creates
it. Each write_file is created before processing begins.
A maximum number of 10 files can be created by sed.
(2)t[label]
Branches to :label in the script file if any substitutions were made
since the most recent reading of an input line execution of a t
subcommand. If you do not specify label, control transfers to the end
of the script.
(2)w write_file
Appends the pattern space to write_file.
(2)x
Exchanges the contents of the pattern space and the hold space.
(2)y/pattern1/pattern2/
Replaces all occurrences of characters in pattern1 with the
corresponding characters from pattern2. The byte lengths of pattern1
and pattern2 must be equal.
(2)!sed_command
Applies the specified sed subcommand only to lines not selected by the
address or addresses.
(0):label
This script entry simply marks a branch point to be referenced by the b
and t commands. This label can be any sequence of eight or fewer
bytes.
(1)=
Writes the current line number to standard output as a line.
(2){subcommand ...
} Groups subcommands enclosed in { } (braces).
(0) Ignores an empty command.
(0)#
If a # (number sign) appears as the first character on the first line
of a script file, that entire line is treated as a comment, with one
exception. If the character after the # is an n, the default output is
suppressed. The rest of the line after the #n is ignored. A script
must contain at least one noncomment line.
RESTRICTIONS
[Tru64 UNIX] The h subcommand for sed does not work properly. When you
use the h subcommand to place text into the hold area, only the last line
of the specified text is saved. You can use the H subcommand to append
text to the hold area. The H subcommand and all others dealing with the
hold area work correctly.
EXIT STATUS
The following exit values are returned:
0 Successful completion.
>0 An error occurred.
EXAMPLES
1. To perform a global change, enter:
sed "s/happy/enchanted/g" chap1 >chap1.new
This replaces each occurrence of happy found in the file chap1 with
enchanted, and puts the edited version in a separate file named
chap1.new. The g at the end of the s subcommand tells sed to make as
many substitutions as possible on each line. Without the g, sed
replaces only the first happy on a line.
The sed stream editor operates as a filter. It reads text from
standard input or from the files named on the command line (chap1 in
this example), modifies this text, and writes it to standard output.
Unlike most editors, it does not replace the original file. This
makes sed a powerful command when used in pipelines.
2. To use sed as a filter in a pipeline (sh only), enter:
pr chap2 | sed "s/Page *[0-9]*$/(&)/" | print
This encloses the page numbers in parentheses before printing chap2.
The pr command puts a heading and page number at the top of each page,
then sed puts the page numbers in parentheses, and the print command
prints the edited listing.
The sed pattern /Page *[0-9]*$/ matches page numbers that appear at
the end of a line. The s subcommand changes this to (&), where the &
stands for the pattern that was matched (for example, Page 5).
3. To display selected lines of a file, enter:
sed -n "/food/p" chap3
This displays each line in chap3 that contains the word food.
Normally, sed copies every line to standard output after it is edited.
The -n option stops sed from doing this. You then use subcommands
like p to write specific parts of the text. Without the -n, this
example displays all the lines in chap3, and it shows each line
containing food twice.
4. To perform complex editing, enter:
sed -f script.sed chap4 >chap4.new
It is always a good idea to create a sed script file when you want to
do anything complex. You can then test and modify your script before
using it. You can also reuse your script to edit other files. Create
the script file with an interactive text editor.
5. A sample sed script follows:
:join
/\\$/{N
s/\\\n//
b join
}
This sed script joins each line that ends with a \ (backslash) to the
line that follows it. First, the pattern /\\$/ selects a line that
ends with a \ for the group of commands enclosed in { }. The N
subcommand then appends the next line, embedding a newline character.
The s/\\\n// deletes the \ (backslash) and embedded newline character.
Finally, b join branches back to the label :join to check for a \
(backslash) at the end of the newly joined line. Without the branch,
sed writes the joined line and reads the next one before checking for
a second \ character.
The N subcommand causes sed to stop immediately if there are no more
lines of input (that is, if N reads the End-of-File character). It
does not copy the pattern space to standard output before stopping.
This means that if the last line of the input ends with a \
(backslash) character, then it is not copied to the output.
ENVIRONMENT VARIABLES
The following environment variables affect the execution of sed:
LANG
Provides a default value for the internationalization variables that
are unset or null. If LANG is unset or null, the corresponding value
from the default locale is used. If any of the internationalization
variables contain an invalid setting, the utility behaves as if none of
the variables had been defined.
LC_ALL
If set to a non-empty string value, overrides the values of all the
other internationalization variables.
LC_CTYPE
Determines the locale for the interpretation of sequences of bytes of
text data as characters (for example, single-byte as opposed to
multibyte characters in arguments) and the behavior of character
classes within regular expressions.
LC_MESSAGES
Determines the locale for the format and contents of diagnostic
messages written to standard error.
NLSPATH
Determines the location of message catalogues for the processing of
LC_MESSAGES.
SEE ALSO
Commands: awk(1), ed(1), grep(1), vi(1)
Standards: standards(5)
Programming Support Tools
|
Index for
Section 1 |
|
|
Alphabetical
listing for S |
|
 |
Top of
page |
|