sed(C)

sed -- invoke the stream editor

Syntax

sed [ -n ] [ script ] [ -f sfile ] [ file ... ]

sed [ -n ] [ -e script ] ... [ -f sfile ] ... [ file ... ]

Description

The sed command copies the named files (standard input default) to the standard output, edited according to a script of commands.

sed takes the following options:

-e script: Read the command script; usually quoted to protect it from the shell.
-f sfile: Take the script from the file sfile; these options accumulate. If there is just one -e option and no -f options, the flag -e may be omitted.
-n: Suppress the default output.

A script consists of editing commands, one per line, of the following form:

[ address [ , address ] ] function [ arguments ]

In normal operation, sed cyclically copies a line of input into a pattern space (unless there is something left after a D command), applies in sequence all commands whose addresses select that pattern space, and at the end of the script copies the pattern space to the standard output (except under -n) and deletes the pattern space.

A semicolon ``;'' can be used as a command delimiter.

Some of the commands use a hold space to save all or part of the pattern space for subsequent retrieval (see the ``Limitations'' section).

An address is either a decimal number that counts input lines cumulatively across files, a ``$'' that addresses the last line of input, or a context address, that is, a /regular expression/ as described in regexp(M), modified as follows:

In a context address, the construction \?regular expression?, where ``?'' is any character, is identical to /regular expression/. Note that in the context address \xabc\xdefx, the second x stands for itself, so that the standard expression is abcxdef.
The escape sequence \n matches a newline embedded in the pattern space.
A dot (.) matches any character except the terminal newline of the pattern space.
A command line with no addresses selects every pattern space.
A command line with one address selects each pattern space that matches the address.
A command line with two addresses separated by a comma selects the inclusive range from the first pattern space that matches the first address through the next pattern space 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.

Editing commands can be applied only to nonselected pattern spaces by use of the negation function ``!'' described in the next section.

Functions

In the following list of functions, the maximum number of permissible addresses for each function is indicated in parentheses.

The text argument consists of one or more lines, all but the last of which end with backslashes to hide the newlines. Backslashes in text are treated like backslashes in the replacement string of an s command, and may be used to protect initial blanks and tabs against the stripping that is done on every script line.

The rfile or wfile argument must terminate the command line and must be preceded by one blank. Each wfile is created before processing begins. There can be at most 10 distinct wfile arguments.

(1) a\
text

Appends text, placing it on the output before reading the next input line. Note that there must be a line break between the command and the text.

(2) b label

Branches to the : command bearing the label. If label is empty, branches to the end of the script.

(2) c\
text

Changes text by deleting the pattern space and then appending text. With 0 or 1 address or at the end of a 2-address range, places text on the output and starts the next cycle. Note that there must be a line break between the command and the text.

(2) d

Deletes the pattern space and starts the next cycle.

(2) D

Deletes the initial segment of the pattern space through the first newline and 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

Insert. Places text on the standard output. Note that there must be a line break between the command and the text.

(2) l

Lists the pattern space on the standard output in an unambiguous way. Nonprinting characters are displayed as a three digit octal number preceded by a backslash ``\''. The following characters are printed as escape sequences:

Character Output

backslash \\

alert (bell) \a

backspace \b

form feed \f

carriage return \r

horizontal tab \t

vertical tab \v

Any output lines that are longer than the output device width (determined by the environment variable COLUMNS) are folded into multiple lines. New lines, inserted when folding a long line, are escaped by a preceding backslash character. The ends of each line in the pattern space are denoted by a dollar character ``$''.

(2) n

Copies the pattern space to the standard output. 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. (The current line number changes.)

(2) p

Prints (copies) the pattern space on the standard output.

(2) P

Prints (copies) the initial segment of the pattern space through the first newline to the standard output.

(1) q

Character	Output
backslash	\\
alert (bell)	\a
backspace	\b
form feed	\f
carriage return	\r
horizontal tab	\t
vertical tab	\v

Quits sed by branching to the end of the script. No new cycle is started.

(2) r rfile

Reads the contents of rfile and places them on the output before reading the next input line.

(2) s /regular expression/replacement/flags

Substitutes the replacement string for instances of the regular expression in the pattern space. Any character may be used instead of ``/''. For a more detailed description, see regexp(M).

Flags is zero or more of:

n: Substitute for just the nth occurrence of the regular expression. n must be an integer greater than zero.
g: Globally substitutes for all non-overlapping instances of the regular expression rather than just the first one.
p: Prints the pattern space if a replacement was made.
w wfile: Writes the pattern space to wfile if a replacement was made.

(2) t label

Branches to the colon (:) command bearing label if any substitutions have been made since the most recent reading of an input line or execution of a t command. If label is empty, t branches to the end of the script.

(2) w wfile

Writes the pattern space to wfile.

(2) x

Exchanges the contents of the pattern and hold spaces.

(2) y /string1/string2/

Replaces all occurrences of characters in string1 with the corresponding characters in string2. The lengths of string1 and string2 must be equal.

(2) ! function

Applies the function (or group, if function is ``{'') only to lines not selected by the address(es).

(0) : label

This command does nothing; it bears a label for b and t commands to branch to. Labels can be at most 8 characters long.

(1) =

Places the current line number on the standard output as a line.

(2) {

Executes the following commands through a matching ``}'' only when the pattern space is selected.

(2) !{

Executes the following commands through a matching ``}'' only when the pattern space is not selected.

(0)

An empty command is ignored.

(0) #

Ignore the remainder of the line if # is followed by any other character than ``n'' (treat the line as a comment); if the character ``n'' follows #, suppress the default output (equivalent to the command line option -n).

Environment variables

COLUMNS: The width of the standard output device in characters; used by the l command for folding long lines. If this variable is not set or it has an invalid value, sed uses the default value 72.

Exit values

sed continues to process all file arguments even if one or more of them produces an open error. If there is an open error, sed will exit with a value of 1 when it has finished processing the files. A value of 2 indicates a usage error.

Examples

The following examples assume the use of sh(C) or ksh(C).

A common use of sed is to edit a file from within a shell script. In this example, every occurrence of the string ``sysman'' in the file infile is replaced by ``System Manager''. A temporary file TMP is used to hold the intermediate result of the edit:

   TMP=/usr/tmp/tmpfile_$$
   sed -e 's/sysman/System Manager/g' < infile > $TMP
   mv $TMP infile

In this example, sed removes all blank lines (including those with just <Tab> and <Space> characters) from padded_file:

   sed '
   /^$/ d
   /^[<Tab><Space>]$/ d
   ´ padded_file

sed can be used to strip all lines from a file which do not contain a certain string. In this example, all lines in the file infile which start with a hash ``#'' are echoed to the screen:

sed -e '/^#/!d' < infile

If several editing commands must be carried out on a file, but the parameters for the edit are to be supplied by the user, then use echo to append command lines to a sed script. The following example removes all occurrences of the strings given as arguments to the script from the file infile. The name of the temporary file is held by the variable SCRIPT:

   SCRIPT=/usr/tmp/script_$$
   
   for name in $
   do
   	echo "s/${name}//g" >> $SCRIPT
   done
   

   TMPFILE=/usr/tmp/tmpfile_$$
   

   sed -f $SCRIPT < infile > $TMPFILE
   

   mv $TMPFILE infile
   

   rm $SCRIPT

Another use of sed is to process the output from other commands. Here the ps command is filtered using sed to report the status of all processes other than those owned by the super user:

ps -ef | sed -e '/^[<Space><Tab>]root/d'

Limitations

Both the hold space and pattern space can hold a maximum of 8192 bytes.

Standards conformance

sed is conformant with:

ISO/IEC DIS 99452:1992, Information technology Portable Operating System Interface (POSIX) Part 2: Shell and Utilities (IEEE Std 1003.21992);
AT&T SVID Issue 2;
X/Open CAE Specification, Commands and Utilities, Issue 4, 1992.