unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (SunOS-5.10)
Page:
Section:
Apropos / Subsearch:
optional field

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
       either 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  information  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  Takes the script from script_file. script_file consists
                       of editing commands, one per line.



       -n              Suppresses 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 application must not present a script that violates
                       the  restrictions  of a text file except that the final
                       character need not be a NEWLINE 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
       described 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
       address 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
       selected.)

       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
                identical to /RE/. If the character designated  by  c  appears
                following  a  backslash, then it is considered to be that lit-
                eral 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.



       \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
                substitute 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 notice that  \n  cannot  be  used  to
       match  a NEWLINE character at the end of an input line; NEWLINE charac-
       ters appear 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 terminat-
       ing  }  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.


       tab()     allbox;     cw(0.916667i)|    cw(1.375000i)|    cw(3.208333i)
       cw(0.916667i)|  lw(1.375000i)|  lw(3.208333i).   Max  AddressCommandDe-
       scription  1a\  textT{ Append by executing N command or beginning a new
       cycle. Place text on the output before reading the next input line.  T}
       2b  labelT{  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.   T}  2c\ textT{ Change.  Delete the pattern
       space.  Place text on the output. Start the next cycle.  T} 2dT{ Delete
       the  pattern  space.  Start the next cycle.  T} 2DT{ Delete the initial
       segment of the pattern space through the  first  new-line.   Start  the
       next cycle. (See the N command below.)  T} 2gT{ Replace the contents of
       the pattern space by the contents of the hold space.   T}  2GT{  Append
       the  contents  of the hold space to the pattern space.  T} 2hT{ Replace
       the contents of the hold space by the contents of  the  pattern  space.
       T} 2HT{ Append the contents of the pattern space to the hold space.  T}
       1i\ textT{ Insert.   Place  text  on  the  standard  output.   T}  2lT{
       /usr/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.  T} T{ /usr/xpg4/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. The characters (\\, \a, \b, \f, \r, \t, and \v) are written  as
       the  corresponding  escape  sequences.  Non-printable characters not in
       that table will be written as one three-digit octal number (with a pre-
       ceding  backslash  character) for each byte in the character (most sig-
       nificant 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.  T} T{ 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  appropri-
       ate  for  the  output device.  The end of each line is marked with a $.
       T} 2nT{ Copy the pattern space to the standard output if default output
       is  not  suppressed.   Replace  the pattern space with the next line of
       input.  T} 2NT{ Append the next line of input to the pattern space with
       an  embedded  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.  T} 2pT{ Print.  Copy the pattern space to the stan-
       dard  output.   T}  2PT{  Copy the initial segment of the pattern space
       through the first new-line to  the  standard  output.   T}  1qT{  Quit.
       Branch  to  the  end  of  the script.  Do not start a new cycle.  T} 2r
       rfileT{ 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  con-
       dition.  T} 2t labelT{ Test.  Branch to the : command bearing the label
       if any substitutions have been made since the most recent reading of an
       input line or execution of a t. If label is empty, branch to the end of
       the script.  T} 2w wfileT{ 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.  T} 2xT{ Exchange the contents of the pattern and hold
       spaces.  T} 2! commandT{ Don't.  Apply the command (or group,  if  com-
       mand  is  {)  only  to  lines  not  selected by the address(es).  T} 0:
       labelT{ This command does nothing; it bears a label for b  and  t  com-
       mands to branch to.  T} 1=T{ Place the current line number on the stan-
       dard output as a line.  T} 2{command-list}T{ Execute command-list  only
       when  the  pattern space is selected.  T} 0An empty command is ignored.
       0#T{ 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 after the # is an n, then
       the  default  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.  T}



       tab()  allbox; cw(0.916667i)| cw(4.583333i).  Max AddrT{ Command (Using
       strings) and Description T} 2T{ s/regular  expression/replacement/flags
       T}  T{  Substitute  the replacement string for instances of the regular
       expression in the pattern space.  Any character other than backslash or
       newline  can  be  used  instead  of  a  slash to delimit the RE and the
       replacement.  Within the RE  and  the  replacement,  the  RE  delimiter
       itself  can be used as a literal character if it is preceded by a back-
       slash.  T} T{ An ampersand (&&amp;) appearing in  the  replacement  will  be
       replaced  by  the  string matching the RE.  The special meaning of &&amp; in
       this context can be suppressed by preceding it by backslash.  The char-
       acters  \n, where n is a digit, will be replaced by the text matched by
       the corresponding backreference expression.   For  each  backslash  (\)
       encountered  in scanning replacement from beginning to end, the follow-
       ing character loses its special meaning (if any).   It  is  unspecified
       what  special meaning is given to any character other than &, \ or dig-
       its.  T} T{ A line can be split by  substituting  a  NEWLINE  character
       into  it.   The  application  must  escape the NEWLINE character in the
       replacement by preceding it with backslash.  A substitution is  consid-
       ered to have been performed even if the replacement string is identical
       to the string that it replaces.  T} flags is zero or more of: T{ n n= 1
       -  512.  Substitute for just the  nth occurrence of the regular expres-
       sion.  T} T{ 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.  T} T{ p Print the  pattern
       space  if  a replacement was made.  T} T{ P Copy the initial segment of
       the pattern space through the first new-line to  the  standard  output.
       T}  T{  w wfile Write.  Append the pattern space to wfile if a replace-
       ment was made. 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.  T} 2y/ string1 / string2  /  T{
       Transform.   Replace all occurrences of characters in  string1 with the
       corresponding characters 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 character  other
       than  backslash  or NEWLINE can be used instead of slash to delimit the
       strings.  Within string1 and string2, the delimiter itself 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.  T}


       See largefile(5) for the  description  of  the  behavior  of  sed  when
       encountering 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: LANG, LC_ALL, LC_COLLATE, LC_CTYPE,
       LC_MESSAGES, and NLSPATH.

EXIT STATUS
       The following exit values are returned:

       0        Successful completion.



       >&gt;0       An error occurred.



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

   /usr/bin/sed
       tab()    allbox;    cw(2.750000i)|     cw(2.750000i)     lw(2.750000i)|
       lw(2.750000i).    ATTRIBUTE   TYPEATTRIBUTE  VALUE  AvailabilitySUNWcsu
       CSINot enabled


   /usr/xpg4/bin/sed
       tab()    allbox;    cw(2.750000i)|     cw(2.750000i)     lw(2.750000i)|
       lw(2.750000i).    ATTRIBUTE  TYPEATTRIBUTE  VALUE  AvailabilitySUNWxcu4
       CSIEnabled Interface StabilityStandard


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



SunOS 5.10                        23 Jul 1998                           sed(1)