sed man page on DigitalUNIX

Man page or keyword search:  
man Server   12896 pages
apropos Keyword Search (all sections)
Output format
DigitalUNIX logo
[printable version]

sed(1)									sed(1)

       sed - Stream editor

       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.

       Interfaces  documented on this reference page conform to industry stan‐
       dards as follows:

       sed:  XCU5.0

       Refer to the standards(5) reference page	 for  more  information	 about
       industry standards and associated tags.

       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.  Uses script_file  as
       the  source  of	the  edit script.  The script_file is a set of editing
       commands to be applied to file.	Suppresses  all	 information  normally
       written to standard output.

       The order of presentation of the -e and -f options is significant.

       Use  the string script as an editing script. See the description of the
       -e option.  The path name of a file to be edited.  If multiple file op‐
       erands  are specified, all files are read and concatenated before edit‐
       ing begins.

	      If no file file operand is specified, standard input is read.

       The sed command includes many features for selecting lines to be	 modi‐
       fied and making changes only to the selected lines.

       The  sed	 command uses two work spaces for holding the line being modi‐
       fied:  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 sepa‐
       rate 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

       [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 charac‐
       ter 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 iden‐
       tical  to  /expression/.	 If the character designated by c appears fol‐
       lowing a \ (backslash), then it is considered to be that literal	 char‐
       acter,  which  does  not terminate the RE.  For example, in the context
       address \xabc\xdefx, the second x stands for itself, so that the	 regu‐
       lar 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  com‐
       mands.  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.

       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: Groups subcommands enclosed in { }
       (braces).  The { (left brace) can be preceded by spaces and can be fol‐
       lowed  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.	 Places	 text  on  the	output
       before reading the next input line.

	      The total number of a and/or r subcommands should not exceed 20.
	      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 dupli‐
	      cated.   The  maximum number of labels allowed in the sed script
	      is 50.  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.   Deletes  the	 pattern  space,  then
	      starts  the next cycle.  Deletes the initial segment of the pat‐
	      tern space through the first newline character.  Then it	starts
	      the next cycle.  Replaces the contents of the pattern space with
	      the contents of the hold space.  Appends	the  contents  of  the
	      hold  space  to the pattern space.  Replaces the contents of the
	      hold space with the contents of the pattern space.  Appends  the
	      contents of the pattern space to the hold space.	Writes text to
	      standard output before reading the next line  into  the  pattern
	      space.   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	<Back‐
	      slash><Return>.  The end of each line is marked with a $.

	      Certain characters are shown as  escape  sequences  as  follows:
	      Backslash	 Alert	Backspace Formfeed Newline Carriage-return Tab
	      Vertical tab Writes the pattern space to	standard  output.   It
	      replaces the pattern space with the next line of input.  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.
	      Writes the pattern space to standard output.  Writes the initial
	      segment of the pattern space through the first newline character
	      to standard output.  Branches to the end of the script.  It does
	      not start a new cycle.  Reads the	 contents  of  read_file.   It
	      places  contents	on  the	 output	 before reading the next input

	      The total number of a and/or r subcommands should not exceed 20.
	      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 reg‐
	      ular 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  consid‐
	      ered  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:  Where	 n  is
	      1-512, substitutes replacement for the nth occurrence of pattern
	      on each addressed line, rather than for  the  first  occurrence.
	      Substitutes replacement for all nonoverlapping instances of pat‐
	      tern on each addressed line, rather than for just the first  one
	      (or  for	the  one specified by n).  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.   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.  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 sub‐
	      command.	If you do not specify label, control transfers to  the
	      end  of  the  script.   Appends the pattern space to write_file.
	      Exchanges the contents of the pattern space and the hold	space.
	      Replaces all occurrences of characters in pattern1 with the cor‐
	      responding characters from pattern2. The byte  lengths  of  pat‐
	      tern1  and  pattern2  must  be equal.  Applies the specified sed
	      subcommand  only	to  lines  not	selected  by  the  address  or
	      addresses.   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.  Writes the current line num‐
	      ber to standard output as a line.	 Groups	 subcommands  enclosed
	      in  {  }	(braces).   Ignores  an empty command.	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.

       [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 deal‐
       ing with the hold area work correctly.

       The following exit values  are  returned:  Successful  completion.   An
       error occurred.

       To  perform  a  global  change,	enter: sed "s/happy/enchanted/g" chap1

	      This replaces each occurrence of happy found in the  file	 chap1
	      with  enchanted,	and puts the edited version in a separate file
	      named	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.   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 exam‐
	      ple, Page	 5).  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.  To perform complex edit‐
	      ing, enter: sed -f script.sed chap4 >

	      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.  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 \ char‐

	      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 charac‐
	      ter).  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.

       The  following  environment variables affect the execution of sed: Pro‐
       vides 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	 vari‐
       ables contain an invalid setting, the utility behaves as if none of the
       variables had been defined.  If set to a non-empty string value,	 over‐
       rides  the  values  of  all  the	 other internationalization variables.
       Determines the locale for the interpretation of sequences of  bytes  of
       text  data as characters (for example, single-byte as opposed to multi‐
       byte characters in arguments) and the  behavior	of  character  classes
       within  regular	expressions.  Determines the locale for the format and
       contents of diagnostic messages written to standard error.   Determines
       the location of message catalogues for the processing of LC_MESSAGES.

       Commands:  awk(1), ed(1), grep(1), vi(1)

       Standards:  standards(5)

       Programming Support Tools


List of man pages available for DigitalUNIX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net