Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
sed(1)				 User Commands				sed(1)

NAME
       sed - stream editor

SYNOPSIS
       /usr/bin/sed [-n] script	[file...]

       /usr/bin/sed [-n]  [-e script]...  [-f script_file]... [file...]

       /usr/xpg4/bin/sed [-n] script [file...]

       /usr/xpg4/bin/sed [-n]  [-e script]...  [-f script_file]... [file...]

DESCRIPTION
       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.  The script is obtained from ei-
       ther the	script operand string, or a combination	 of  the  option-argu-
       ments from the -e script	and -f script_file options.

       The  sed	utility	is a text editor. It cannot edit binary	files or files
       containing ASCII	NUL (\0) characters or very long lines.

OPTIONS
       The following options are supported:

       -e script
	     script is an edit command for sed.	See USAGE below	for  more  in-
	     formation on the format of	script.	If there is just one -e	option
	     and no -f options,	the flag -e may	be omitted.

       -f script_file
	     Take the script from script_file. script_file consists of editing
	     commands, one per line.

       -n    Suppress the default output.

       Multiple	 -e and	-f options may be specified. All commands are added to
       the script in the order specified, regardless of	their origin.

OPERANDS
       The following operands are supported:

       file  A path name of a file whose contents will be read and edited.  If
	     multiple  file  operands  are  specified, the named files will be
	     read in the order specified and the concatenation will be edited.
	     If	 no  file  operands  are specified, the	standard input will be
	     used.

       script
	     A string to be used as the	script of editing commands. The	appli-
	     cation  must  not present a script	that violates the restrictions
	     of	a text file except that	the final character need not be	a NEW-
	     LINE character.

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

	      [	address	[ , address ] ]	command	[ arguments ]

       Zero or more blank characters are accepted before the first address and
       before  command.	Any number of semicolons are accepted before the first
       address.

       In normal operation, sed	cyclically copies a line of  input  (less  its
       terminating  NEWLINE  character)	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 copies the resulting
       pattern space to	the standard output (except under -n) and deletes  the
       pattern space. Whenever the pattern space is written to standard	output
       or a named file,	sed will immediately follow it with a NEWLINE  charac-
       ter.

       Some  of	the commands use a hold	space  to save all or part of the pat-
       tern space  for subsequent retrieval. The pattern and hold spaces  will
       each be able to hold at least 8192 bytes.

   sed Addresses
       An  address  is	either empty, a	decimal	number that counts input lines
       cumulatively across files, a $ that addresses the last line  of	input,
       or  a  context address, which consists of a /regular expression/	as de-
       scribed on the regexp(5)	manual page.

       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 selects the inclusive	range from the
       first pattern space that	matches	the first  address  through  the  next
       pattern	space  that matches the	second address.	Thereafter the process
       is repeated, looking again for the first	address. (If  the  second  ad-
       dress is	a number less than or equal to the line	number selected	by the
       first address, only the line corresponding to the first address is  se-
       lected.)

       Typically,  address are separated from each other by a comma (,).  They
       may also	be separated by	a semicolon (;).

   sed Regular Expressions
       sed supports the	basic regular expressions described on	the  regexp(5)
       manual page, with the following additions:

       \cREc In	 a  context  address,  the  construction \cREc,	where c	is any
	     character other than a backslash or NEWLINE character, is identi-
	     cal to /RE/. 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 ad-
	     dress \xabc\xdefx,	the second x stands for	itself,	 so  that  the
	     regular expression	is abcxdef.

       \n    The  escape  sequence  \n matches a NEWLINE character embedded in
	     the pattern space.	 A literal NEWLINE character must not be  used
	     in	 the regular expression	of a context address or	in the substi-
	     tute command.

       Editing commands	can be applied only to non-selected pattern spaces  by
       use of the negation command ! (described	below).

   sed Editing Commands
       In  the	following  list	of functions the maximum number	of permissible
       addresses for each function is indicated.

       The r and w commands take an optional rfile (or wfile) parameter, sepa-
       rated from the command letter by	one or more blank characters.

       Multiple	 commands can be specified by separating them with a semicolon
       (;) on the same command line.

       The text	argument consists of one or more lines,	all but	 the  last  of
       which  end  with	\ to hide the NEWLINE. Each embedded NEWLINE character
       in the text must	be preceded by a backslash. Other backslashes in  text
       are  removed  and  the  following character is treated literally. Back-
       slashes 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
       exactly one blank.  The use of the wfile	parameter causes that file  to
       be  initially  created,	if it does not exist, or will replace the con-
       tents of	an existing file. There	can be at most 10 distinct wfile argu-
       ments.

       Regular	expressions  match  entire strings, not	just individual	lines,
       but a NEWLINE character is matched by \n	in a sed RE; a NEWLINE charac-
       ter is not allowed in an	RE.  Also note that \n cannot be used to match
       a NEWLINE character at the end of an input line;	NEWLINE	characters ap-
       pear in the pattern space as a result of	the N editing command.

       Two  of	the  commands take a command-list, which is a list of sed com-
       mands separated by NEWLINE characters, as follows:

       { command
       command
       }

       The { can be preceded with blank	characters and can  be	followed  with
       white  space.  The commands can be preceded by white space.  The	termi-
       nating }	must be	preceded by a NEWLINE character	and can	be preceded or
       followed	 by  <blank>s.	 The  braces  may  be  preceded	or followed by
       <blank>s.  The command may be preceded by <blank>s, but may not be fol-
       lowed by	<blank>s.

       The  following  table  lists  the functions, with the maximum number of
       permissible addresses.

       +------------+----------------+----------------------------------+
       |Max Address |	 Command     |		 Description		|
       +------------+----------------+----------------------------------+
       |     1	    | a\ text	     | Append by executing N command or	|
       |	    |		     | beginning  a  new  cycle.  Place	|
       |	    |		     | text on the output before  read-	|
       |	    |		     | ing the next input line.		|
       +------------+----------------+----------------------------------+
       |     2	    | b	label	     | Branch  to the :	command	bearing	|
       |	    |		     | the label .  If label is	 empty,	|
       |	    |		     | branch to the end of the	script.	|
       |	    |		     | Labels are recognized unique  up	|
       |	    |		     | to eight	characters.		|
       +------------+----------------+----------------------------------+
       |     2	    | c\ text	     | Change.	  Delete   the	pattern	|
       |	    |		     | space.  Place text on  the  out-	|
       |	    |		     | put. Start the next cycle.	|
       +------------+----------------+----------------------------------+
       |     2	    | d		     | Delete the pattern space.  Start	|
       |	    |		     | the next	cycle.			|
       +------------+----------------+----------------------------------+
       |     2	    | D		     | Delete the  initial  segment  of	|
       |	    |		     | the  pattern  space  through the	|
       |	    |		     | first new-line.	Start the  next	|
       |	    |		     | cycle.  (See  the  N command be-	|
       |	    |		     | low.)				|
       +------------+----------------+----------------------------------+
       |     2	    | g		     | Replace the contents of the pat-	|
       |	    |		     | tern  space  by	the contents of	|
       |	    |		     | the hold	space.			|
       +------------+----------------+----------------------------------+
       |     2	    | G		     | Append the contents of the  hold	|
       |	    |		     | space to	the pattern space.	|
       +------------+----------------+----------------------------------+
       |     2	    | h		     | Replace the contents of the hold	|
       |	    |		     | space by	 the  contents	of  the	|
       |	    |		     | pattern space.			|
       +------------+----------------+----------------------------------+
       |     2	    | H		     | Append  the contents of the pat-	|
       |	    |		     | tern space to the hold space.	|
       +------------+----------------+----------------------------------+
       |     1	    | i\ text	     | Insert.	Place text on the stan-	|
       |	    |		     | dard output.			|
       +------------+----------------+----------------------------------+
       |     2	    | l		     | /usr/bin/sed:   List the	pattern	|
       |	    |		     | space on	the standard output  in	|
       |	    |		     | an unambiguous form.  Non-print-	|
       |	    |		     | able characters are displayed in	|
       |	    |		     | octal  notation	and  long lines	|
       |	    |		     | are folded.			|
       +------------+----------------+----------------------------------+
       |	    |		     | /usr/xpg4/bin/sed:    List   the	|
       |	    |		     | pattern	space  on  the standard	|
       |	    |		     | output in an  unambiguous  form.	|
       |	    |		     | Non-printable   characters   are	|
       |	    |		     | displayed in octal notation  and	|
       |	    |		     | long lines are folded. The char-	|
       |	    |		     | acters (\\, \a, \b, \f, \r,  \t,	|
       |	    |		     | and  \v)	are written as the cor-	|
       |	    |		     | responding   escape   sequences.	|
       |	    |		     | Non-printable  characters not in	|
       |	    |		     | that table will	be  written  as	|
       |	    |		     | one   three-digit  octal	 number	|
       |	    |		     | (with  a	  preceding   backslash	|
       |	    |		     | character)  for each byte in the	|
       |	    |		     | character (most significant byte	|
       |	    |		     | first). If the size of a	byte on	|
       |	    |		     | the system is greater than  nine	|
       |	    |		     | bits,  the  format used for non-	|
       |	    |		     | printable characters  is	 imple-	|
       |	    |		     | mentation dependent.		|
       +------------+----------------+----------------------------------+
       |	    |		     | Long  lines are folded, with the	|
       |	    |		     | point of	 folding  indicated  by	|
       |	    |		     | writing	a backslash followed by	|
       |	    |		     | a NEWLINE; the length  at  which	|
       |	    |		     | folding	occurs	is unspecified,	|
       |	    |		     | but should  be  appropriate  for	|
       |	    |		     | the  output  device.  The end of	|
       |	    |		     | each line is marked with	a $.	|
       +------------+----------------+----------------------------------+
       |     2	    | n		     | Copy the	pattern	 space	to  the	|
       |	    |		     | standard	 output	if default out-	|
       |	    |		     | put is not suppressed.	Replace	|
       |	    |		     | the  pattern space with the next	|
       |	    |		     | line of input.			|
       +------------+----------------+----------------------------------+
       |     2	    | N		     | Append the next line of input to	|
       |	    |		     | the pattern space with an embed-	|
       |	    |		     | ded new-line.  (The current line	|
       |	    |		     | number  changes.)   If  no  next	|
       |	    |		     | line of input is	available,  the	|
       |	    |		     | N  command  verb	shall branch to	|
       |	    |		     | the end of the script  and  quit	|
       |	    |		     | without starting	a new cycle and	|
       |	    |		     | without	writing	  the	pattern	|
       |	    |		     | space.				|
       +------------+----------------+----------------------------------+
       |     2	    | p		     | Print.	Copy  the pattern space	|
       |	    |		     | to the standard output.		|
       +------------+----------------+----------------------------------+
       |     2	    | P		     | Copy the	initial	segment	of  the	|
       |	    |		     | pattern	space through the first	|
       |	    |		     | new-line	to the standard	output.	|
       +------------+----------------+----------------------------------+
       |     1	    | q		     | Quit.  Branch to	the end	of  the	|
       |	    |		     | script.	 Do not	start a	new cy-	|
       |	    |		     | cle.				|
       +------------+----------------+----------------------------------+
       |     2	    | r	rfile	     | Read  the  contents  of	 rfile.	|
       |	    |		     | Place  them on the output before	|
       |	    |		     | reading the next	input line.  If	|
       |	    |		     | rfile  does  not	exist or cannot	|
       |	    |		     | be read,	it is treated as if  it	|
       |	    |		     | were  an	 empty file, causing no	|
       |	    |		     | error condition.			|
       +------------+----------------+----------------------------------+
       |     2	    | t	label	     | Test.  Branch to	the  :	command	|
       |	    |		     | bearing the label if any	substi-	|
       |	    |		     | tutions have been made since the	|
       |	    |		     | most  recent reading of an input	|
       |	    |		     | line or execution of a t. If la-	|
       |	    |		     | bel  is empty, branch to	the end	|
       |	    |		     | of the script.			|
       +------------+----------------+----------------------------------+
       |     2	    | w	wfile	     | Write.  Append the pattern space	|
       |	    |		     | to  wfile.  The first occurrence	|
       |	    |		     | of w  will  cause  wfile	 to  be	|
       |	    |		     | cleared.	 Subsequent invocations	|
       |	    |		     | of w will append.  Each time the	|
       |	    |		     | sed  command  is	 used, wfile is	|
       |	    |		     | overwritten.			|
       +------------+----------------+----------------------------------+
       |     2	    | x		     | Exchange	 the  contents	of  the	|
       |	    |		     | pattern and hold	spaces.		|
       +------------+----------------+----------------------------------+
       |     2	    | !	command	     | Don't.	Apply  the  command (or	|
       |	    |		     | group, if command is {) only  to	|
       |	    |		     | lines  not  selected  by	the ad-	|
       |	    |		     | dress(es).			|
       +------------+----------------+----------------------------------+
       |     0	    | :	label	     | This command  does  nothing;  it	|
       |	    |		     | bears  a	 label for b and t com-	|
       |	    |		     | mands to	branch to.		|
       +------------+----------------+----------------------------------+
       |     1	    | =		     | Place the current line number on	|
       |	    |		     | the standard output as a	line.	|
       +------------+----------------+----------------------------------+
       |     2	    | {command-list} | Execute	command-list  only when	|
       |	    |		     | the pattern space is selected.	|
       +------------+----------------+----------------------------------+
       |     0	    |		     | An empty	command	is ignored.	|
       +------------+----------------+----------------------------------+
       |     0	    | #		     | If a  #	appears	 as  the  first	|
       |	    |		     | character  on a line of a script	|
       |	    |		     | file, then that entire  line  is	|
       |	    |		     | treated	as  a comment, with one	|
       |	    |		     | exception: if a # appears on the	|
       |	    |		     | first line and the character af-	|
       |	    |		     | ter the # is an n, then the  de-	|
       |	    |		     | fault output will be suppressed.	|
       |	    |		     | The rest	of the line after #n is	|
       |	    |		     | also  ignored.	A  script  file	|
       |	    |		     | must contain at least  one  non-	|
       |	    |		     | comment line.			|
       +------------+----------------+----------------------------------+

       +-----------+-----------------------------------------------+
       |Max Addr   |	Command	(Using strings)	and Description	   |
       +-----------+-----------------------------------------------+
       |    2	   |	s/regular expression/replacement/flags	   |
       +-----------+-----------------------------------------------+
       |	   |Substitute	the  replacement  string  for  in- |
       |	   |stances of the regular expression in the  pat- |
       |	   |tern  space.   Any	character other	than back- |
       |	   |slash or newline can  be  used  instead  of	 a |
       |	   |slash  to  delimit the RE and the replacement. |
       |	   |Within the RE and the replacement, the RE  de- |
       |	   |limiter  itself can	be used	as a literal char- |
       |	   |acter if it	is preceded by a backslash.	   |
       +-----------+-----------------------------------------------+
       |	   |An ampersand (&) appearing in the  replacement |
       |	   |will  be  replaced	by the string matching the |
       |	   |RE.	 The special meaning of	& in this  context |
       |	   |can	 be  suppressed	 by  preceding it by back- |
       |	   |slash.  The	characters \n, where n is a digit, |
       |	   |will  be  replaced	by the text matched by the |
       |	   |corresponding backreference	 expression.   For |
       |	   |each backslash (\) encountered in scanning re- |
       |	   |placement from beginning to	end, the following |
       |	   |character  loses its special meaning (if any). |
       |	   |It is  unspecified	what  special  meaning	is |
       |	   |given to any character other than &, \ or dig- |
       |	   |its.					   |
       +-----------+-----------------------------------------------+
       |	   |A line can be split	by substituting	a  NEWLINE |
       |	   |character  into  it.  The application must es- |
       |	   |cape the NEWLINE character in the  replacement |
       |	   |by	preceding  it with backslash.  A substitu- |
       |	   |tion is considered to have been performed even |
       |	   |if	the replacement	string is identical to the |
       |	   |string that	it replaces.			   |
       +-----------+-----------------------------------------------+
       |	   |	      flags is zero or more of:		   |
       +-----------+-----------------------------------------------+
       |	   |n n= 1 - 512.  Substitute for  just	 the   nth |
       |	   |occurrence of the regular expression.	   |
       +-----------+-----------------------------------------------+
       |	   |g  Global.	 Substitute for	all nonoverlapping |
       |	   |instances of  the  regular	expression  rather |
       |	   |than  just the first one.  If both g and n are |
       |	   |specified, the results are unspecified.	   |
       +-----------+-----------------------------------------------+
       |	   |p Print the	pattern	space if a replacement was |
       |	   |made.					   |
       +-----------+-----------------------------------------------+
       |	   |P  Copy  the  initial  segment  of the pattern |
       |	   |space through the first new-line to	the  stan- |
       |	   |dard output.				   |
       +-----------+-----------------------------------------------+
       |	   |w  wfile  Write.   Append the pattern space	to |
       |	   |wfile if a replacement was made. The first oc- |
       |	   |currence  of w will	cause wfile to be cleared. |
       |	   |Subsequent invocations of w	will append.  Each |
       |	   |time  the  sed command is used, wfile is over- |
       |	   |written.					   |
       +-----------+-----------------------------------------------+
       |    2	   |		     y/	string1	/		   |
       +-----------+-----------------------------------------------+
       |string2	/  |						   |
       +-----------+-----------------------------------------------+
       |	   |Transform.	Replace	all occurrences	of charac- |
       |	   |ters  in  string1 with the corresponding char- |
       |	   |acters in string2.	string1	and  string2  must |
       |	   |have  the same number of characters, or if any |
       |	   |of the characters in string1  appear more than |
       |	   |once,  the results are undefined.  Any charac- |
       |	   |ter	other than backslash  or  NEWLINE  can	be |
       |	   |used  instead of slash to delimit the strings. |
       |	   |Within string1 and string2,	the delimiter  it- |
       |	   |self  can be used as a literal character if	it |
       |	   |is	preceded  by  a	 backslash.  For  example, |
       |	   |y/abc/ABC/	replaces a with	A, b with B, and c |
       |	   |with C.					   |
       +-----------+-----------------------------------------------+

       See largefile(5)	for the	description of the behavior of	sed  when  en-
       countering files	greater	than or	equal to 2 Gbyte ( 2**31 bytes).

EXAMPLES
       Example 1: An example sed script

       This  sed  script  simulates  the  BSD cat -s command, squeezing	excess
       blank lines from	standard input.

       sed -n '
       # Write non-empty lines.
       /./     {
	       p
	       d
	       }
       # Write a single	empty line, then look for more empty lines.
       /^$/	   p
       # Get next line,	discard	the held <newline> (empty line),
       # and look for more empty lines.
       :Empty
       /^$/	   {
	       N
	       s/.//
	       b Empty
	       }
       # Write the non-empty line before going back to search
       # for the first in a set	of empty lines.
	       p
       '

ENVIRONMENT VARIABLES
       See environ(5) for descriptions of the following	environment  variables
       that  affect  the  execution of sed: LC_COLLATE,	LC_CTYPE, LC_MESSAGES,
       and NLSPATH.

EXIT STATUS
       The following exit values are returned:

       0     Successful	completion.

       >0    An	error occurred.

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

   /usr/bin/sed
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Not enabled		   |
       +-----------------------------+-----------------------------+

   /usr/xpg4/bin/sed
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWxcu4			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+

SEE ALSO
       awk(1), ed(1), grep(1), attributes(5), environ(5),  largefile(5),  reg-
       exp(5), XPG4(5)

SunOS 5.9			  23 Jul 1998				sed(1)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | OPERANDS | USAGE | EXAMPLES | ENVIRONMENT VARIABLES | EXIT STATUS | ATTRIBUTES | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=sed&sektion=1&manpath=SunOS+5.9>

home | help