source: kBuild/vendor/sed/current/doc/sed.info-2

This is ../../doc/sed.info, produced by makeinfo version 4.5 from
../../doc/sed.texi.

INFO-DIR-SECTION Text creation and manipulation
START-INFO-DIR-ENTRY
* sed: (sed).                   Stream EDitor.

END-INFO-DIR-ENTRY

This file documents version 4.1.5 of GNU `sed', a stream editor.

   Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004 Free Software
Foundation, Inc.

   This document is released under the terms of the GNU Free
Documentation License as published by the Free Software Foundation;
either version 1.1, or (at your option) any later version.

   You should have received a copy of the GNU Free Documentation
License along with GNU `sed'; see the file `COPYING.DOC'.  If not,
write to the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02110-1301, USA.

   There are no Cover Texts and no Invariant Sections; this text, along
with its equivalent in the printed manual, constitutes the Title Page.

File: sed.info,  Node: Print bash environment,  Next: Reverse chars of lines,  Prev: Rename files to lower case,  Up: Examples

Print `bash' Environment
========================

   This script strips the definition of the shell functions from the
output of the `set' Bourne-shell command.

     #!/bin/sh
     
     set | sed -n '
     :x
     
     # if no occurrence of "=()" print and load next line
     /=()/! { p; b; }
     / () $/! { p; b; }
     
     # possible start of functions section
     # save the line in case this is a var like FOO="() "
     h
     
     # if the next line has a brace, we quit because
     # nothing comes after functions
     n
     /^{/ q
     
     # print the old line
     x; p
     
     # work on the new line now
     x; bx
     '


File: sed.info,  Node: Reverse chars of lines,  Next: tac,  Prev: Print bash environment,  Up: Examples

Reverse Characters of Lines
===========================

   This script can be used to reverse the position of characters in
lines.  The technique moves two characters at a time, hence it is
faster than more intuitive implementations.

   Note the `tx' command before the definition of the label.  This is
often needed to reset the flag that is tested by the `t' command.

   Imaginative readers will find uses for this script.  An example is
reversing the output of `banner'.(1)

     #!/usr/bin/sed -f
     
     /../! b
     
     # Reverse a line.  Begin embedding the line between two newlines
     s/^.*$/\
     &\
     /
     
     # Move first character at the end.  The regexp matches until
     # there are zero or one characters between the markers
     tx
     :x
     s/\(\n.\)\(.*\)\(.\n\)/\3\2\1/
     tx
     
     # Remove the newline markers
     s/\n//g

   ---------- Footnotes ----------

   (1) This requires another script to pad the output of banner; for
example

     #! /bin/sh
     
     banner -w $1 $2 $3 $4 |
       sed -e :a -e '/^.\{0,'$1'\}$/ { s/$/ /; ba; }' |
       ~/sedscripts/reverseline.sed


File: sed.info,  Node: tac,  Next: cat -n,  Prev: Reverse chars of lines,  Up: Examples

Reverse Lines of Files
======================

   This one begins a series of totally useless (yet interesting)
scripts emulating various Unix commands.  This, in particular, is a
`tac' workalike.

   Note that on implementations other than GNU `sed' this script might
easily overflow internal buffers.

     #!/usr/bin/sed -nf
     
     # reverse all lines of input, i.e. first line became last, ...
     
     # from the second line, the buffer (which contains all previous lines)
     # is *appended* to current line, so, the order will be reversed
     1! G
     
     # on the last line we're done -- print everything
     $ p
     
     # store everything on the buffer again
     h


File: sed.info,  Node: cat -n,  Next: cat -b,  Prev: tac,  Up: Examples

Numbering Lines
===============

   This script replaces `cat -n'; in fact it formats its output exactly
like GNU `cat' does.

   Of course this is completely useless and for two reasons:  first,
because somebody else did it in C, second, because the following
Bourne-shell script could be used for the same purpose and would be
much faster:

     #! /bin/sh
     sed -e "=" $@ | sed -e '
       s/^/      /
       N
       s/^ *\(......\)\n/\1  /
     '

   It uses `sed' to print the line number, then groups lines two by two
using `N'.  Of course, this script does not teach as much as the one
presented below.

   The algorithm used for incrementing uses both buffers, so the line
is printed as soon as possible and then discarded.  The number is split
so that changing digits go in a buffer and unchanged ones go in the
other; the changed digits are modified in a single step (using a `y'
command).  The line number for the next line is then composed and
stored in the hold space, to be used in the next iteration.

     #!/usr/bin/sed -nf
     
     # Prime the pump on the first line
     x
     /^$/ s/^.*$/1/
     
     # Add the correct line number before the pattern
     G
     h
     
     # Format it and print it
     s/^/      /
     s/^ *\(......\)\n/\1  /p
     
     # Get the line number from hold space; add a zero
     # if we're going to add a digit on the next line
     g
     s/\n.*$//
     /^9*$/ s/^/0/
     
     # separate changing/unchanged digits with an x
     s/.9*$/x&/
     
     # keep changing digits in hold space
     h
     s/^.*x//
     y/0123456789/1234567890/
     x
     
     # keep unchanged digits in pattern space
     s/x.*$//
     
     # compose the new number, remove the newline implicitly added by G
     G
     s/\n//
     h


File: sed.info,  Node: cat -b,  Next: wc -c,  Prev: cat -n,  Up: Examples

Numbering Non-blank Lines
=========================

   Emulating `cat -b' is almost the same as `cat -n'--we only have to
select which lines are to be numbered and which are not.

   The part that is common to this script and the previous one is not
commented to show how important it is to comment `sed' scripts
properly...

     #!/usr/bin/sed -nf
     
     /^$/ {
       p
       b
     }
     
     # Same as cat -n from now
     x
     /^$/ s/^.*$/1/
     G
     h
     s/^/      /
     s/^ *\(......\)\n/\1  /p
     x
     s/\n.*$//
     /^9*$/ s/^/0/
     s/.9*$/x&/
     h
     s/^.*x//
     y/0123456789/1234567890/
     x
     s/x.*$//
     G
     s/\n//
     h


File: sed.info,  Node: wc -c,  Next: wc -w,  Prev: cat -b,  Up: Examples

Counting Characters
===================

   This script shows another way to do arithmetic with `sed'.  In this
case we have to add possibly large numbers, so implementing this by
successive increments would not be feasible (and possibly even more
complicated to contrive than this script).

   The approach is to map numbers to letters, kind of an abacus
implemented with `sed'.  `a's are units, `b's are tens and so on: we
simply add the number of characters on the current line as units, and
then propagate the carry to tens, hundreds, and so on.

   As usual, running totals are kept in hold space.

   On the last line, we convert the abacus form back to decimal.  For
the sake of variety, this is done with a loop rather than with some 80
`s' commands(1): first we convert units, removing `a's from the number;
then we rotate letters so that tens become `a's, and so on until no
more letters remain.

     #!/usr/bin/sed -nf
     
     # Add n+1 a's to hold space (+1 is for the newline)
     s/./a/g
     H
     x
     s/\n/a/
     
     # Do the carry.  The t's and b's are not necessary,
     # but they do speed up the thing
     t a
     : a;  s/aaaaaaaaaa/b/g; t b; b done
     : b;  s/bbbbbbbbbb/c/g; t c; b done
     : c;  s/cccccccccc/d/g; t d; b done
     : d;  s/dddddddddd/e/g; t e; b done
     : e;  s/eeeeeeeeee/f/g; t f; b done
     : f;  s/ffffffffff/g/g; t g; b done
     : g;  s/gggggggggg/h/g; t h; b done
     : h;  s/hhhhhhhhhh//g
     
     : done
     $! {
       h
       b
     }
     
     # On the last line, convert back to decimal
     
     : loop
     /a/! s/[b-h]*/&0/
     s/aaaaaaaaa/9/
     s/aaaaaaaa/8/
     s/aaaaaaa/7/
     s/aaaaaa/6/
     s/aaaaa/5/
     s/aaaa/4/
     s/aaa/3/
     s/aa/2/
     s/a/1/
     
     : next
     y/bcdefgh/abcdefg/
     /[a-h]/ b loop
     p

   ---------- Footnotes ----------

   (1) Some implementations have a limit of 199 commands per script


File: sed.info,  Node: wc -w,  Next: wc -l,  Prev: wc -c,  Up: Examples

Counting Words
==============

   This script is almost the same as the previous one, once each of the
words on the line is converted to a single `a' (in the previous script
each letter was changed to an `a').

   It is interesting that real `wc' programs have optimized loops for
`wc -c', so they are much slower at counting words rather than
characters.  This script's bottleneck, instead, is arithmetic, and
hence the word-counting one is faster (it has to manage smaller
numbers).

   Again, the common parts are not commented to show the importance of
commenting `sed' scripts.

     #!/usr/bin/sed -nf
     
     # Convert words to a's
     s/[ tab][ tab]*/ /g
     s/^/ /
     s/ [^ ][^ ]*/a /g
     s/ //g
     
     # Append them to hold space
     H
     x
     s/\n//
     
     # From here on it is the same as in wc -c.
     /aaaaaaaaaa/! bx;   s/aaaaaaaaaa/b/g
     /bbbbbbbbbb/! bx;   s/bbbbbbbbbb/c/g
     /cccccccccc/! bx;   s/cccccccccc/d/g
     /dddddddddd/! bx;   s/dddddddddd/e/g
     /eeeeeeeeee/! bx;   s/eeeeeeeeee/f/g
     /ffffffffff/! bx;   s/ffffffffff/g/g
     /gggggggggg/! bx;   s/gggggggggg/h/g
     s/hhhhhhhhhh//g
     :x
     $! { h; b; }
     :y
     /a/! s/[b-h]*/&0/
     s/aaaaaaaaa/9/
     s/aaaaaaaa/8/
     s/aaaaaaa/7/
     s/aaaaaa/6/
     s/aaaaa/5/
     s/aaaa/4/
     s/aaa/3/
     s/aa/2/
     s/a/1/
     y/bcdefgh/abcdefg/
     /[a-h]/ by
     p


File: sed.info,  Node: wc -l,  Next: head,  Prev: wc -w,  Up: Examples

Counting Lines
==============

   No strange things are done now, because `sed' gives us `wc -l'
functionality for free!!! Look:

     #!/usr/bin/sed -nf
     $=


File: sed.info,  Node: head,  Next: tail,  Prev: wc -l,  Up: Examples

Printing the First Lines
========================

   This script is probably the simplest useful `sed' script.  It
displays the first 10 lines of input; the number of displayed lines is
right before the `q' command.

     #!/usr/bin/sed -f
     10q


File: sed.info,  Node: tail,  Next: uniq,  Prev: head,  Up: Examples

Printing the Last Lines
=======================

   Printing the last N lines rather than the first is more complex but
indeed possible.  N is encoded in the second line, before the bang
character.

   This script is similar to the `tac' script in that it keeps the
final output in the hold space and prints it at the end:

     #!/usr/bin/sed -nf
     
     1! {; H; g; }
     1,10 !s/[^\n]*\n//
     $p
     h

   Mainly, the scripts keeps a window of 10 lines and slides it by
adding a line and deleting the oldest (the substitution command on the
second line works like a `D' command but does not restart the loop).

   The "sliding window" technique is a very powerful way to write
efficient and complex `sed' scripts, because commands like `P' would
require a lot of work if implemented manually.

   To introduce the technique, which is fully demonstrated in the rest
of this chapter and is based on the `N', `P' and `D' commands, here is
an implementation of `tail' using a simple "sliding window."

   This looks complicated but in fact the working is the same as the
last script: after we have kicked in the appropriate number of lines,
however, we stop using the hold space to keep inter-line state, and
instead use `N' and `D' to slide pattern space by one line:

     #!/usr/bin/sed -f
     
     1h
     2,10 {; H; g; }
     $q
     1,9d
     N
     D

   Note how the first, second and fourth line are inactive after the
first ten lines of input.  After that, all the script does is: exiting
on the last line of input, appending the next input line to pattern
space, and removing the first line.


File: sed.info,  Node: uniq,  Next: uniq -d,  Prev: tail,  Up: Examples

Make Duplicate Lines Unique
===========================

   This is an example of the art of using the `N', `P' and `D'
commands, probably the most difficult to master.

     #!/usr/bin/sed -f
     h
     
     :b
     # On the last line, print and exit
     $b
     N
     /^\(.*\)\n\1$/ {
         # The two lines are identical.  Undo the effect of
         # the n command.
         g
         bb
     }
     
     # If the `N' command had added the last line, print and exit
     $b
     
     # The lines are different; print the first and go
     # back working on the second.
     P
     D

   As you can see, we mantain a 2-line window using `P' and `D'.  This
technique is often used in advanced `sed' scripts.


File: sed.info,  Node: uniq -d,  Next: uniq -u,  Prev: uniq,  Up: Examples

Print Duplicated Lines of Input
===============================

   This script prints only duplicated lines, like `uniq -d'.

     #!/usr/bin/sed -nf
     
     $b
     N
     /^\(.*\)\n\1$/ {
         # Print the first of the duplicated lines
         s/.*\n//
         p
     
         # Loop until we get a different line
         :b
         $b
         N
         /^\(.*\)\n\1$/ {
             s/.*\n//
             bb
         }
     }
     
     # The last line cannot be followed by duplicates
     $b
     
     # Found a different one.  Leave it alone in the pattern space
     # and go back to the top, hunting its duplicates
     D


File: sed.info,  Node: uniq -u,  Next: cat -s,  Prev: uniq -d,  Up: Examples

Remove All Duplicated Lines
===========================

   This script prints only unique lines, like `uniq -u'.

     #!/usr/bin/sed -f
     
     # Search for a duplicate line --- until that, print what you find.
     $b
     N
     /^\(.*\)\n\1$/ ! {
         P
         D
     }
     
     :c
     # Got two equal lines in pattern space.  At the
     # end of the file we simply exit
     $d
     
     # Else, we keep reading lines with `N' until we
     # find a different one
     s/.*\n//
     N
     /^\(.*\)\n\1$/ {
         bc
     }
     
     # Remove the last instance of the duplicate line
     # and go back to the top
     D


File: sed.info,  Node: cat -s,  Prev: uniq -u,  Up: Examples

Squeezing Blank Lines
=====================

   As a final example, here are three scripts, of increasing complexity
and speed, that implement the same function as `cat -s', that is
squeezing blank lines.

   The first leaves a blank line at the beginning and end if there are
some already.

     #!/usr/bin/sed -f
     
     # on empty lines, join with next
     # Note there is a star in the regexp
     :x
     /^\n*$/ {
     N
     bx
     }
     
     # now, squeeze all '\n', this can be also done by:
     # s/^\(\n\)*/\1/
     s/\n*/\
     /

   This one is a bit more complex and removes all empty lines at the
beginning.  It does leave a single blank line at end if one was there.

     #!/usr/bin/sed -f
     
     # delete all leading empty lines
     1,/^./{
     /./!d
     }
     
     # on an empty line we remove it and all the following
     # empty lines, but one
     :x
     /./!{
     N
     s/^\n$//
     tx
     }

   This removes leading and trailing blank lines.  It is also the
fastest.  Note that loops are completely done with `n' and `b', without
relying on `sed' to restart the the script automatically at the end of
a line.

     #!/usr/bin/sed -nf
     
     # delete all (leading) blanks
     /./!d
     
     # get here: so there is a non empty
     :x
     # print it
     p
     # get next
     n
     # got chars? print it again, etc...
     /./bx
     
     # no, don't have chars: got an empty line
     :z
     # get next, if last line we finish here so no trailing
     # empty lines are written
     n
     # also empty? then ignore it, and get next... this will
     # remove ALL empty lines
     /./!bz
     
     # all empty lines were deleted/ignored, but we have a non empty.  As
     # what we want to do is to squeeze, insert a blank line artificially
     i\
     
     bx


File: sed.info,  Node: Limitations,  Next: Other Resources,  Prev: Examples,  Up: Top

GNU `sed''s Limitations and Non-limitations
*******************************************

   For those who want to write portable `sed' scripts, be aware that
some implementations have been known to limit line lengths (for the
pattern and hold spaces) to be no more than 4000 bytes.  The POSIX
standard specifies that conforming `sed' implementations shall support
at least 8192 byte line lengths.  GNU `sed' has no built-in limit on
line length; as long as it can `malloc()' more (virtual) memory, you
can feed or construct lines as long as you like.

   However, recursion is used to handle subpatterns and indefinite
repetition.  This means that the available stack space may limit the
size of the buffer that can be processed by certain patterns.


File: sed.info,  Node: Other Resources,  Next: Reporting Bugs,  Prev: Limitations,  Up: Top

Other Resources for Learning About `sed'
****************************************

   In addition to several books that have been written about `sed'
(either specifically or as chapters in books which discuss shell
programming), one can find out more about `sed' (including suggestions
of a few books) from the FAQ for the `sed-users' mailing list,
available from any of:
      `http://www.student.northpark.edu/pemente/sed/sedfaq.html'
      `http://sed.sf.net/grabbag/tutorials/sedfaq.html'

   Also of interest are
`http://www.student.northpark.edu/pemente/sed/index.htm' and
`http://sed.sf.net/grabbag', which include `sed' tutorials and other
`sed'-related goodies.

   The `sed-users' mailing list itself maintained by Sven Guckes.  To
subscribe, visit `http://groups.yahoo.com' and search for the
`sed-users' mailing list.


File: sed.info,  Node: Reporting Bugs,  Next: Extended regexps,  Prev: Other Resources,  Up: Top

Reporting Bugs
**************

   Email bug reports to <bonzini@gnu.org>.  Be sure to include the word
"sed" somewhere in the `Subject:' field.  Also, please include the
output of `sed --version' in the body of your report if at all possible.

   Please do not send a bug report like this:

     while building frobme-1.3.4
     $ configure
     error--> sed: file sedscr line 1: Unknown option to 's'

   If GNU `sed' doesn't configure your favorite package, take a few
extra minutes to identify the specific problem and make a stand-alone
test case.  Unlike other programs such as C compilers, making such test
cases for `sed' is quite simple.

   A stand-alone test case includes all the data necessary to perform
the test, and the specific invocation of `sed' that causes the problem.
The smaller a stand-alone test case is, the better.  A test case should
not involve something as far removed from `sed' as "try to configure
frobme-1.3.4".  Yes, that is in principle enough information to look
for the bug, but that is not a very practical prospect.

   Here are a few commonly reported bugs that are not bugs.

`N' command on the last line
     Most versions of `sed' exit without printing anything when the `N'
     command is issued on the last line of a file.  GNU `sed' prints
     pattern space before exiting unless of course the `-n' command
     switch has been specified.  This choice is by design.

     For example, the behavior of
          sed N foo bar

     would depend on whether foo has an even or an odd number of
     lines(1).  Or, when writing a script to read the next few lines
     following a pattern match, traditional implementations of `sed'
     would force you to write something like
          /foo/{ $!N; $!N; $!N; $!N; $!N; $!N; $!N; $!N; $!N }

     instead of just
          /foo/{ N;N;N;N;N;N;N;N;N; }

     In any case, the simplest workaround is to use `$d;N' in scripts
     that rely on the traditional behavior, or to set the
     `POSIXLY_CORRECT' variable to a non-empty value.

Regex syntax clashes (problems with backslashes)
     `sed' uses the POSIX basic regular expression syntax.  According to
     the standard, the meaning of some escape sequences is undefined in
     this syntax;  notable in the case of `sed' are `\|', `\+', `\?',
     `\`', `\'', `\<', `\>', `\b', `\B', `\w', and `\W'.

     As in all GNU programs that use POSIX basic regular expressions,
     `sed' interprets these escape sequences as special characters.
     So, `x\+' matches one or more occurrences of `x'.  `abc\|def'
     matches either `abc' or `def'.

     This syntax may cause problems when running scripts written for
     other `sed's.  Some `sed' programs have been written with the
     assumption that `\|' and `\+' match the literal characters `|' and
     `+'.  Such scripts must be modified by removing the spurious
     backslashes if they are to be used with modern implementations of
     `sed', like GNU `sed'.

     On the other hand, some scripts use s|abc\|def||g to remove
     occurrences of _either_ `abc' or `def'.  While this worked until
     `sed' 4.0.x, newer versions interpret this as removing the string
     `abc|def'.  This is again undefined behavior according to POSIX,
     and this interpretation is arguably more robust: older `sed's, for
     example, required that the regex matcher parsed `\/' as `/' in the
     common case of escaping a slash, which is again undefined
     behavior; the new behavior avoids this, and this is good because
     the regex matcher is only partially under our control.

     In addition, this version of `sed' supports several escape
     characters (some of which are multi-character) to insert
     non-printable characters in scripts (`\a', `\c', `\d', `\o', `\r',
     `\t', `\v', `\x').  These can cause similar problems with scripts
     written for other `sed's.

`-i' clobbers read-only files
     In short, `sed -i' will let you delete the contents of a read-only
     file, and in general the `-i' option (*note Invocation: Invoking
     sed.) lets you clobber protected files.  This is not a bug, but
     rather a consequence of how the Unix filesystem works.

     The permissions on a file say what can happen to the data in that
     file, while the permissions on a directory say what can happen to
     the list of files in that directory.  `sed -i' will not ever open
     for writing  a file that is already on disk.  Rather, it will work
     on a temporary file that is finally renamed to the original name:
     if you rename or delete files, you're actually modifying the
     contents of the directory, so the operation depends on the
     permissions of the directory, not of the file.  For this same
     reason, `sed' does not let you use `-i' on a writeable file in a
     read-only directory (but unbelievably nobody reports that as a
     bug...).

`0a' does not work (gives an error)
     There is no line 0.  0 is a special address that is only used to
     treat addresses like `0,/RE/' as active when the script starts: if
     you write `1,/abc/d' and the first line includes the word `abc',
     then that match would be ignored because address ranges must span
     at least two lines (barring the end of the file); but what you
     probably wanted is to delete every line up to the first one
     including `abc', and this is obtained with `0,/abc/d'.

`[a-z]' is case insensitive
     You are encountering problems with locales.  POSIX mandates that
     `[a-z]' uses the current locale's collation order - in C parlance,
     that means using `strcoll(3)' instead of `strcmp(3)'.  Some
     locales have a case-insensitive collation order, others don't: one
     of those that have problems is Estonian.

     Another problem is that `[a-z]' tries to use collation symbols.
     This only happens if you are on the GNU system, using GNU libc's
     regular expression matcher instead of compiling the one supplied
     with GNU sed.  In a Danish locale, for example, the regular
     expression `^[a-z]$' matches the string `aa', because this is a
     single collating symbol that comes after `a' and before `b'; `ll'
     behaves similarly in Spanish locales, or `ij' in Dutch locales.

     To work around these problems, which may cause bugs in shell
     scripts, set the `LC_COLLATE' and `LC_CTYPE' environment variables
     to `C'.

   ---------- Footnotes ----------

   (1) which is the actual "bug" that prompted the change in behavior


File: sed.info,  Node: Extended regexps,  Next: Concept Index,  Prev: Reporting Bugs,  Up: Top

Extended regular expressions
****************************

   The only difference between basic and extended regular expressions
is in the behavior of a few characters: `?', `+', parentheses, and
braces (`{}').  While basic regular expressions require these to be
escaped if you want them to behave as special characters, when using
extended regular expressions you must escape them if you want them _to
match a literal character_.

Examples:
`abc?'
     becomes `abc\?' when using extended regular expressions.  It
     matches the literal string `abc?'.

`c\+'
     becomes `c+' when using extended regular expressions.  It matches
     one or more `c's.

`a\{3,\}'
     becomes `a{3,}' when using extended regular expressions.  It
     matches three or more `a's.

`\(abc\)\{2,3\}'
     becomes `(abc){2,3}' when using extended regular expressions.  It
     matches either `abcabc' or `abcabcabc'.

`\(abc*\)\1'
     becomes `(abc*)\1' when using extended regular expressions.
     Backreferences must still be escaped when using extended regular
     expressions.


File: sed.info,  Node: Concept Index,  Next: Command and Option Index,  Prev: Extended regexps,  Up: Top

Concept Index
*************

   This is a general index of all issues discussed in this manual, with
the exception of the `sed' commands and command-line options.

* Menu:

* Additional reading about sed:          Other Resources.
* ADDR1,+N:                              Addresses.
* ADDR1,~N:                              Addresses.
* Address, as a regular expression:      Addresses.
* Address, last line:                    Addresses.
* Address, numeric:                      Addresses.
* Addresses, in sed scripts:             Addresses.
* Append hold space to pattern space:    Other Commands.
* Append next input line to pattern space: Other Commands.
* Append pattern space to hold space:    Other Commands.
* Appending text after a line:           Other Commands.
* Backreferences, in regular expressions: The "s" Command.
* Branch to a label, if s/// failed:     Extended Commands.
* Branch to a label, if s/// succeeded:  Programming Commands.
* Branch to a label, unconditionally:    Programming Commands.
* Buffer spaces, pattern and hold:       Execution Cycle.
* Bugs, reporting:                       Reporting Bugs.
* Case-insensitive matching:             The "s" Command.
* Caveat -- #n on first line:            Common Commands.
* Command groups:                        Common Commands.
* Comments, in scripts:                  Common Commands.
* Conditional branch <1>:                Extended Commands.
* Conditional branch:                    Programming Commands.
* Copy hold space into pattern space:    Other Commands.
* Copy pattern space into hold space:    Other Commands.
* Delete first line from pattern space:  Other Commands.
* Disabling autoprint, from command line: Invoking sed.
* empty regular expression:              Addresses.
* Evaluate Bourne-shell commands:        Extended Commands.
* Evaluate Bourne-shell commands, after substitution: The "s" Command.
* Exchange hold space with pattern space: Other Commands.
* Excluding lines:                       Addresses.
* Extended regular expressions, choosing: Invoking sed.
* Extended regular expressions, syntax:  Extended regexps.
* Files to be processed as input:        Invoking sed.
* Flow of control in scripts:            Programming Commands.
* Global substitution:                   The "s" Command.
* GNU extensions, /dev/stderr file <1>:  The "s" Command.
* GNU extensions, /dev/stderr file:      Other Commands.
* GNU extensions, /dev/stdin file <1>:   Other Commands.
* GNU extensions, /dev/stdin file:       Extended Commands.
* GNU extensions, /dev/stdout file <1>:  Invoking sed.
* GNU extensions, /dev/stdout file <2>:  The "s" Command.
* GNU extensions, /dev/stdout file:      Other Commands.
* GNU extensions, 0 address:             Addresses.
* GNU extensions, 0,ADDR2 addressing:    Addresses.
* GNU extensions, ADDR1,+N addressing:   Addresses.
* GNU extensions, ADDR1,~N addressing:   Addresses.
* GNU extensions, branch if s/// failed: Extended Commands.
* GNU extensions, case modifiers in s commands: The "s" Command.
* GNU extensions, checking for their presence: Extended Commands.
* GNU extensions, disabling:             Invoking sed.
* GNU extensions, evaluating Bourne-shell commands <1>: Extended Commands.
* GNU extensions, evaluating Bourne-shell commands: The "s" Command.
* GNU extensions, extended regular expressions: Invoking sed.
* GNU extensions, g and NUMBER modifier interaction in s command: The "s" Command.
* GNU extensions, I modifier <1>:        Addresses.
* GNU extensions, I modifier:            The "s" Command.
* GNU extensions, in-place editing <1>:  Reporting Bugs.
* GNU extensions, in-place editing:      Invoking sed.
* GNU extensions, L command:             Extended Commands.
* GNU extensions, M modifier:            The "s" Command.
* GNU extensions, modifiers and the empty regular expression: Addresses.
* GNU extensions, N~M addresses:         Addresses.
* GNU extensions, quitting silently:     Extended Commands.
* GNU extensions, R command:             Extended Commands.
* GNU extensions, reading a file a line at a time: Extended Commands.
* GNU extensions, reformatting paragraphs: Extended Commands.
* GNU extensions, returning an exit code <1>: Common Commands.
* GNU extensions, returning an exit code: Extended Commands.
* GNU extensions, setting line length:   Other Commands.
* GNU extensions, special escapes <1>:   Reporting Bugs.
* GNU extensions, special escapes:       Escapes.
* GNU extensions, special two-address forms: Addresses.
* GNU extensions, subprocesses <1>:      The "s" Command.
* GNU extensions, subprocesses:          Extended Commands.
* GNU extensions, to basic regular expressions <1>: Reporting Bugs.
* GNU extensions, to basic regular expressions: Regular Expressions.
* GNU extensions, two addresses supported by most commands: Other Commands.
* GNU extensions, unlimited line length: Limitations.
* GNU extensions, writing first line to a file: Extended Commands.
* Goto, in scripts:                      Programming Commands.
* Greedy regular expression matching:    Regular Expressions.
* Grouping commands:                     Common Commands.
* Hold space, appending from pattern space: Other Commands.
* Hold space, appending to pattern space: Other Commands.
* Hold space, copy into pattern space:   Other Commands.
* Hold space, copying pattern space into: Other Commands.
* Hold space, definition:                Execution Cycle.
* Hold space, exchange with pattern space: Other Commands.
* In-place editing:                      Reporting Bugs.
* In-place editing, activating:          Invoking sed.
* In-place editing, Perl-style backup file names: Invoking sed.
* Inserting text before a line:          Other Commands.
* Labels, in scripts:                    Programming Commands.
* Last line, selecting:                  Addresses.
* Line length, setting <1>:              Invoking sed.
* Line length, setting:                  Other Commands.
* Line number, printing:                 Other Commands.
* Line selection:                        Addresses.
* Line, selecting by number:             Addresses.
* Line, selecting by regular expression match: Addresses.
* Line, selecting last:                  Addresses.
* List pattern space:                    Other Commands.
* Mixing g and NUMBER modifiers in the s command: The "s" Command.
* Next input line, append to pattern space: Other Commands.
* Next input line, replace pattern space with: Common Commands.
* Non-bugs, in-place editing:            Reporting Bugs.
* Non-bugs, N command on the last line:  Reporting Bugs.
* Non-bugs, regex syntax clashes:        Reporting Bugs.
* Parenthesized substrings:              The "s" Command.
* Pattern space, definition:             Execution Cycle.
* Perl-style regular expressions, multiline: Addresses.
* Portability, comments:                 Common Commands.
* Portability, line length limitations:  Limitations.
* Portability, N command on the last line: Reporting Bugs.
* POSIXLY_CORRECT behavior, bracket expressions: Regular Expressions.
* POSIXLY_CORRECT behavior, enabling:    Invoking sed.
* POSIXLY_CORRECT behavior, escapes:     Escapes.
* POSIXLY_CORRECT behavior, N command:   Reporting Bugs.
* Print first line from pattern space:   Other Commands.
* Printing line number:                  Other Commands.
* Printing text unambiguously:           Other Commands.
* Quitting <1>:                          Extended Commands.
* Quitting:                              Common Commands.
* Range of lines:                        Addresses.
* Range with start address of zero:      Addresses.
* Read next input line:                  Common Commands.
* Read text from a file <1>:             Extended Commands.
* Read text from a file:                 Other Commands.
* Reformat pattern space:                Extended Commands.
* Reformatting paragraphs:               Extended Commands.
* Replace hold space with copy of pattern space: Other Commands.
* Replace pattern space with copy of hold space: Other Commands.
* Replacing all text matching regexp in a line: The "s" Command.
* Replacing only Nth match of regexp in a line: The "s" Command.
* Replacing selected lines with other text: Other Commands.
* Requiring GNU sed:                     Extended Commands.
* Script structure:                      sed Programs.
* Script, from a file:                   Invoking sed.
* Script, from command line:             Invoking sed.
* sed program structure:                 sed Programs.
* Selecting lines to process:            Addresses.
* Selecting non-matching lines:          Addresses.
* Several lines, selecting:              Addresses.
* Slash character, in regular expressions: Addresses.
* Spaces, pattern and hold:              Execution Cycle.
* Special addressing forms:              Addresses.
* Standard input, processing as input:   Invoking sed.
* Stream editor:                         Introduction.
* Subprocesses <1>:                      Extended Commands.
* Subprocesses:                          The "s" Command.
* Substitution of text, options:         The "s" Command.
* Text, appending:                       Other Commands.
* Text, deleting:                        Common Commands.
* Text, insertion:                       Other Commands.
* Text, printing:                        Common Commands.
* Text, printing after substitution:     The "s" Command.
* Text, writing to a file after substitution: The "s" Command.
* Transliteration:                       Other Commands.
* Unbuffered I/O, choosing:              Invoking sed.
* Usage summary, printing:               Invoking sed.
* Version, printing:                     Invoking sed.
* Working on separate files:             Invoking sed.
* Write first line to a file:            Extended Commands.
* Write to a file:                       Other Commands.
* Zero, as range start address:          Addresses.


File: sed.info,  Node: Command and Option Index,  Prev: Concept Index,  Up: Top

Command and Option Index
************************

   This is an alphabetical list of all `sed' commands and command-line
options.

* Menu:

* # (comments):                          Common Commands.
* --expression:                          Invoking sed.
* --file:                                Invoking sed.
* --help:                                Invoking sed.
* --in-place:                            Invoking sed.
* --line-length:                         Invoking sed.
* --quiet:                               Invoking sed.
* --regexp-extended:                     Invoking sed.
* --silent:                              Invoking sed.
* --unbuffered:                          Invoking sed.
* --version:                             Invoking sed.
* -e:                                    Invoking sed.
* -f:                                    Invoking sed.
* -i:                                    Invoking sed.
* -l:                                    Invoking sed.
* -n:                                    Invoking sed.
* -n, forcing from within a script:      Common Commands.
* -r:                                    Invoking sed.
* -u:                                    Invoking sed.
* : (label) command:                     Programming Commands.
* = (print line number) command:         Other Commands.
* a (append text lines) command:         Other Commands.
* b (branch) command:                    Programming Commands.
* c (change to text lines) command:      Other Commands.
* D (delete first line) command:         Other Commands.
* d (delete) command:                    Common Commands.
* e (evaluate) command:                  Extended Commands.
* G (appending Get) command:             Other Commands.
* g (get) command:                       Other Commands.
* H (append Hold) command:               Other Commands.
* h (hold) command:                      Other Commands.
* i (insert text lines) command:         Other Commands.
* L (fLow paragraphs) command:           Extended Commands.
* l (list unambiguously) command:        Other Commands.
* N (append Next line) command:          Other Commands.
* n (next-line) command:                 Common Commands.
* P (print first line) command:          Other Commands.
* p (print) command:                     Common Commands.
* q (quit) command:                      Common Commands.
* Q (silent Quit) command:               Extended Commands.
* r (read file) command:                 Other Commands.
* R (read line) command:                 Extended Commands.
* s command, option flags:               The "s" Command.
* T (test and branch if failed) command: Extended Commands.
* t (test and branch if successful) command: Programming Commands.
* v (version) command:                   Extended Commands.
* w (write file) command:                Other Commands.
* W (write first line) command:          Extended Commands.
* x (eXchange) command:                  Other Commands.
* y (transliterate) command:             Other Commands.
* {} command grouping:                   Common Commands.