unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (OSF1-V5.1-alpha)
Page:
Section:
Apropos / Subsearch:
optional field



sed(1)								       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 indus-
  try 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	out-
  put.	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 pat-
  tern,	only the addressed line	or lines are affected by the command.  Other-
  wise,	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 (/)	char-
  acter.  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	con-
       text 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 charac-
       ter.  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 pro-
  cessing 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 new-
      line 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 pat-
      tern 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 char-
      acters as	3-digit	octal values.  Long lines are folded, with the point
      of folding indicated by <&lt;Backslash>&gt;<&lt;Return>&gt;.  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	new-
      line 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 pat-
      tern 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 &&amp; (ampersand) appearing in the	replacement string is replaced by the
      string matching the RE.  The special meaning of &&amp;	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 correspond-
      ing 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 preced-
      ing 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 speci-
	  fied.

      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 subcom-
      mand.  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 correspond-
      ing 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.

  >&gt;0  An error occurred.

EXAMPLES

   1.  To perform a global change, enter:
	    sed	"s/happy/enchanted/g" chap1 >&gt;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 stan-
       dard 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]*$/(&&amp;)/" | 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 (&&amp;), where the &&amp;
       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.  Nor-
       mally, 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 con-
       taining food twice.

   4.  To perform complex editing, enter:
	    sed	-f script.sed chap4 >&gt;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 sub-
       command 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 mes-
      sages 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