File:  [Local Repository] / gnujdoc / sed-4.1.2 / sed-ja.texi
Revision 1.1: download - view: text, annotated - select for diffs
Sat Oct 1 13:35:24 2005 UTC (15 years, 1 month ago) by futoshi
Branches: MAIN
CVS tags: HEAD
add sed-4.1.2.

\input texinfo  @c -*-texinfo-*-
@c Do not edit this file!! It is automatically generated from sed-in.texi.
@c -- Stuff that needs adding: ----------------------------------------------
@c (document the `;' command-separator)
@c --------------------------------------------------------------------------
@c Check for consistency: regexps in @code, text that they match in @samp.
@c Tips:
@c    @command for command
@c    @samp for command fragments: @samp{cat -s}
@c    @code for sed commands and flags
@c    Use ``quote'' not `quote' or "quote".
@c %**start of header
@settitle sed, a stream editor
@c %**end of header

@c @documentlanguage ja

@c @smallbook

@include sed-v.texi

@c Combine indices.
@syncodeindex ky cp
@syncodeindex pg cp
@syncodeindex tp cp

@defcodeindex op
@syncodeindex op fn

@include config-ja.texi

This file documents version @value{VERSION} of
@value{SSED}, a stream editor.

Copyright @copyright{} 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 @value{SSED}; see the file @file{COPYING.DOC}.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

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

@setchapternewpage off

@title @command{sed}, a stream editor
@subtitle version @value{VERSION}, @value{UPDATED}
@author by Ken Pizzini, Paolo Bonzini
@c 翻訳:西尾 太

@vskip 0pt plus 1filll
Copyright @copyright{} 1998, 1999 Free Software Foundation, Inc.


Published by the Free Software Foundation, @*
59 Temple Place - Suite 330 @*
Boston, MA 02111-1307, USA
@end titlepage

@node Top

@end ifnottex

* Introduction::               Introduction
* Invoking sed::               Invocation
* sed Programs::               @command{sed} programs
* Examples::                   Some sample scripts
* Limitations::                Limitations and (non-)limitations of @value{SSED}
* Other Resources::            Other resources for learning about @command{sed}
* Reporting Bugs::             Reporting bugs

* Extended regexps::           @command{egrep}-style regular expressions
@ifset PERL
* Perl regexps::               Perl-style regular expressions
@end ifset

* Concept Index::              A menu with all the topics in this manual.
* Command and Option Index::   A menu with all @command{sed} commands and
                               command-line options.

@c --- The detailed node listing ---
--- 詳細なノードリスト ---

@c sed Programs:
sed プログラム:
* Execution Cycle::                 How @command{sed} works
* Addresses::                       Selecting lines with @command{sed}
* Regular Expressions::             Overview of regular expression syntax
* Common Commands::                 Often used commands
* The "s" Command::                 @command{sed}'s Swiss Army Knife
* Other Commands::                  Less frequently used commands
* Programming Commands::            Commands for @command{sed} gurus
* Extended Commands::               Commands specific of @value{SSED}
* Escapes::                         Specifying special characters

@c Examples:
* Centering lines::
* Increment a number::
* Rename files to lower case::
* Print bash environment::
* Reverse chars of lines::
* tac::                             Reverse lines of files
* cat -n::                          Numbering lines
* cat -b::                          Numbering non-blank lines
* wc -c::                           Counting chars
* wc -w::                           Counting words
* wc -l::                           Counting lines
* head::                            Printing the first lines
* tail::                            Printing the last lines
* uniq::                            Make duplicate lines unique
* uniq -d::                         Print duplicated lines of input
* uniq -u::                         Remove all duplicated lines
* cat -s::                          Squeezing blank lines

@ifset PERL
@c Perl regexps::                      Perl-style regular expressions
Perlの正規表現::                    パール形式の正規表現
* Backslash::                       Introduces special sequences
* Circumflex/dollar sign/period::   Behave specially with regard to new lines
* Square brackets::                 Are a bit different in strange cases
* Options setting::                 Toggle modifiers in the middle of a regexp
* Non-capturing subpatterns::       Are not counted when backreferencing
* Repetition::                      Allows for non-greedy matching
* Backreferences::                  Allows for more than 10 back references
* Assertions::                      Allows for complex look ahead matches
* Non-backtracking subpatterns::    Often gives more performance
* Conditional subpatterns::         Allows if/then/else branches
* Recursive patterns::              For example to match parentheses
* Comments::                        Because things can get complex...
@end ifset

@end detailmenu
@end menu

@node Introduction
@c @chapter Introduction
@chapter はじめに

@cindex Stream editor
@c @command{sed} is a stream editor.
@c A stream editor is used to perform basic text
@c transformations on an input stream
@c (a file or input from a pipeline).
@c While in some ways similar to an editor which
@c permits scripted edits (such as @command{ed}),
@c @command{sed} works by making only one pass over the
@c input(s), and is consequently more efficient.
@c But it is @command{sed}'s ability to filter text in a pipeline
@c which particularly distinguishes it from other types of
@c editors.

@node Invoking sed
@c @chapter Invocation
@chapter 呼び出し

@c Normally @command{sed} is invoked like this:

@end example

@c The full format for invoking @command{sed} is:

@end example

@c If you do not specify @var{INPUTFILE}, or if @var{INPUTFILE} is @file{-},
@c @command{sed} filters the contents of the standard input.  The @var{script}
@c is actually the first non-option parameter, which @command{sed} specially
@c considers a script and not an input file if (and only if) none of the
@c other @var{options} specifies a script to be executed, that is if neither
@c of the @option{-e} and @option{-f} options is specified.

@c @command{sed} may be invoked with the following command-line options:

@table @code
@item --version
@opindex --version
@cindex Version, printing
@c Print out the version of @command{sed} that is being run and a copyright notice,
@c then exit.

@item --help
@opindex --help
@cindex Usage summary, printing
@c Print a usage message briefly summarizing these command-line options
@c and the bug-reporting address,
@c then exit.

@item -n
@itemx --quiet
@itemx --silent
@opindex -n
@opindex --quiet
@opindex --silent
@cindex Disabling autoprint, from command line
@c By default, @command{sed} prints out the pattern space
@c at the end of each cycle through the script.
@c These options disable this automatic printing,
@c and @command{sed} only produces output when explicitly told to
@c via the @code{p} command.

@item -i[@var{SUFFIX}]
@itemx --in-place[=@var{SUFFIX}]
@opindex -i
@opindex --in-place
@cindex In-place editing, activating
@cindex @value{SSEDEXT}, in-place editing
@c This option specifies that files are to be edited in-place.
@c @value{SSED} does this by creating a temporary file and
@c sending output to this file rather than to the standard
@c output.@footnote{This applies to commands such as @code{=},
@c @code{a}, @code{c}, @code{i}, @code{l}, @code{p}.  You can
@c still write to the standard output by using the @code{w}
@c @cindex @value{SSEDEXT}, @file{/dev/stdout} file
@c or @code{W} commands together with the @file{/dev/stdout}
@c special file}.
@cindex @value{SSEDEXT}, @file{/dev/stdout} file

@c This option implies @option{-s}.

@c When the end of the file is reached, the temporary file is
@c renamed to the output file's original name.  The extension,
@c if supplied, is used to modify the name of the old file
@c before renaming the temporary file, thereby making a backup
@c copy@footnote{Note that @value{SSED} creates the backup
@c     file whether or not any output is actually changed.}).

@cindex In-place editing, Perl-style backup file names
@c This rule is followed: if the extension doesn't contain a @code{*},
@c then it is appended to the end of the current filename as a
@c suffix; if the extension does contain one or more @code{*}
@c characters, then @emph{each} asterisk is replaced with the
@c current filename.  This allows you to add a prefix to the
@c backup file, instead of (or in addition to) a suffix, or
@c even to place backup copies of the original files into another
@c directory (provided the directory already exists).

@c If no extension is supplied, the original file is
@c overwritten without making a backup.

@item -l @var{N}
@itemx --line-length=@var{N}
@opindex -l
@opindex --line-length
@cindex Line length, setting
@c Specify the default line-wrap length for the @code{l} command.
@c A length of 0 (zero) means to never wrap long lines.  If
@c not specified, it is taken to be 70.
@code{l}コマンドに対するデフォルトの行を丸める長さを指定します.0 (ゼ

@item --posix
@cindex @value{SSEDEXT}, disabling
@c @value{SSED} includes several extensions to @acronym{POSIX}
@c sed.  In order to simplify writing portable scripts, this
@c option disables all the extensions that this manual documents,
@c including additional commands.

@cindex @code{POSIXLY_CORRECT} behavior, enabling
@c Most of the extensions accept @command{sed} programs that
@c are outside the syntax mandated by @acronym{POSIX}, but some
@c of them (such as the behavior of the @command{N} command
@c described in @pxref{Reporting Bugs}) actually violate the
@c standard.  If you want to disable only the latter kind of
@c extension, you can set the @code{POSIXLY_CORRECT} variable
@c to a non-empty value.
ほとんどの拡張を受け入れるますが,(@pxref{Reporting Bugs}で記述されてい

@item -r
@itemx --regexp-extended
@opindex -r
@opindex --regexp-extended
@cindex Extended regular expressions, choosing
@cindex @acronym{GNU} extensions, extended regular expressions
@c Use extended regular expressions rather than basic
@c regular expressions.  Extended regexps are those that
@c @command{egrep} accepts; they can be clearer because they
@c usually have less backslashes, but are a @acronym{GNU} extension
@c and hence scripts that use them are not portable.
@c @xref{Extended regexps, , Extended regular expressions}.
使用しているスクリプトは移植性が無くなります.@xref{Extended regexps,
, Extended regular expressions}.

@ifset PERL
@item -R
@itemx --regexp-perl
@opindex -R
@opindex --regexp-perl
@cindex Perl-style regular expressions, choosing
@cindex @value{SSEDEXT}, Perl-style regular expressions
@c Use Perl-style regular expressions rather than basic
@c regular expressions.  Perl-style regexps are extremely
@c powerful but are a @value{SSED} extension and hence scripts that
@c use it are not portable.  @xref{Perl regexps, ,
@c Perl-style regular expressions}.
ているスクリプトは移植性が無くなります.@xref{Perl regexps, ,
Perl-style regular expressions}.
@end ifset

@item -s
@itemx --separate
@cindex Working on separate files
@c By default, @command{sed} will consider the files specified on the
@c command line as a single continuous long stream.  This @value{SSED}
@c extension allows the user to consider them as separate files:
@c range addresses (such as @samp{/abc/,/def/}) are not allowed
@c to span several files, line numbers are relative to the start
@c of each file, @code{$} refers to the last line of each file,
@c and files invoked from the @code{R} commands are rewound at the
@c start of each file.

@item -u
@itemx --unbuffered
@opindex -u
@opindex --unbuffered
@cindex Unbuffered I/O, choosing
@c Buffer both input and output as minimally as practical.
@c (This is particularly useful if the input is coming from
@c the likes of @samp{tail -f}, and you wish to see the transformed
@c output as soon as possible.)
@samp{tail -f}のようなものからのときと,できるだけ速く出力を変換して見

@item -e @var{script}
@itemx --expression=@var{script}
@opindex -e
@opindex --expression
@cindex Script, from command line
@c Add the commands in @var{script} to the set of commands to be
@c run while processing the input.

@item -f @var{script-file}
@itemx --file=@var{script-file}
@opindex -f
@opindex --file
@cindex Script, from a file
@c Add the commands contained in the file @var{script-file}
@c to the set of commands to be run while processing the input.
@end table

@c If no @option{-e}, @option{-f}, @option{--expression}, or @option{--file}
@c options are given on the command-line,
@c then the first non-option argument on the command line is
@c taken to be the @var{script} to be executed.

@cindex Files to be processed as input
@c If any command-line parameters remain after processing the above,
@c these parameters are interpreted as the names of input files to
@c be processed.

@cindex Standard input, processing as input
@c A file name of @samp{-} refers to the standard input stream.
@c The standard input will be processed if no file names are specified.

@node sed Programs
@c @chapter @command{sed} Programs
@chapter @sc{sed}プログラム

@cindex @command{sed} program structure
@cindex Script structure
@c A @command{sed} program consists of one or more @command{sed} commands,
@c passed in by one or more of the
@c @option{-e}, @option{-f}, @option{--expression}, and @option{--file}
@c options, or the first non-option argument if zero of these
@c options are used.
@c This document will refer to ``the'' @command{sed} script;
@c this is understood to mean the in-order catenation
@c of all of the @var{script}s and @var{script-file}s passed in.
は``その'' @command{sed}スクリプトを記述します.渡される@var{script}と

@c Each @command{sed} command consists of an optional address or
@c address range, followed by a one-character command name
@c and any additional command-specific code.

* Execution Cycle::          How @command{sed} works
* Addresses::                Selecting lines with @command{sed}
* Regular Expressions::      Overview of regular expression syntax
* Common Commands::          Often used commands
* The "s" Command::          @command{sed}'s Swiss Army Knife
* Other Commands::           Less frequently used commands
* Programming Commands::     Commands for @command{sed} gurus
* Extended Commands::        Commands specific of @value{SSED}
* Escapes::                  Specifying special characters
@end menu

@node Execution Cycle
@c @section How @command{sed} Works
@section @command{sed}が動作する様子

@cindex Buffer spaces, pattern and hold
@cindex Spaces, pattern and hold
@cindex Pattern space, definition
@cindex Hold space, definition
@c @command{sed} maintains two data buffers: the active @emph{pattern} space,
@c and the auxiliary @emph{hold} space. Both are initially empty.

@c @command{sed} operates by performing the following cycle on each
@c lines of input: first, @command{sed} reads one line from the input
@c stream, removes any trailing newline, and places it in the pattern space.
@c Then commands are executed; each command can have an address associated
@c to it: addresses are a kind of condition code, and a command is only
@c executed if the condition is verified before the command is to be
@c executed.

@c When the end of the script is reached, unless the @option{-n} option
@c is in use, the contents of pattern space are printed out to the output
@c stream, adding back the trailing newline if it was removed.@footnote{Actually,
@c   if @command{sed} prints a line without the terminating newline, it will
@c   nevertheless print the missing newline as soon as more text is sent to
@c   the same output stream, which gives the ``least expected surprise''
@c   even though it does not make commands like @samp{sed -n p} exactly
@c   identical to @command{cat}.} Then the next cycle starts for the next
@c input line.
に足りない改行を出力するので,@command{cat}とまったく同じ@samp{sed -n

@c Unless special commands (like @samp{D}) are used, the pattern space is
@c deleted between two cycles. The hold space, on the other hand, keeps
@c its data between cycles (see commands @samp{h}, @samp{H}, @samp{x},
@c @samp{g}, @samp{G} to move data between both buffers).

@node Addresses
@c @section Selecting lines with @command{sed}
@section @command{sed}で行を選択する
@cindex Addresses, in @command{sed} scripts
@cindex Line selection
@cindex Selecting lines to process

@c Addresses in a @command{sed} script can be in any of the following forms:

@table @code
@item @var{number}
@cindex Address, numeric
@cindex Line, selecting by number
@c Specifying a line number will match only that line in the input.
@c (Note that @command{sed} counts lines continuously across all input files
@c unless @option{-i} or @option{-s} options are specified.)

@item @var{first}~@var{step}
@cindex @acronym{GNU} extensions, @samp{@var{n}~@var{m}} addresses
@c This @acronym{GNU} extension matches every @var{step}th line
@c starting with line @var{first}.
@c In particular, lines will be selected when there exists
@c a non-negative @var{n} such that the current line-number equals
@c @var{first} + (@var{n} * @var{step}).
@c Thus, to select the odd-numbered lines,
@c one would use @samp{1~2};
@c to pick every third line starting with the second, @samp{2~3} would be used;
@c to pick every fifth line starting with the tenth, use @samp{10~5};
@c and @samp{50~0} is just an obscure way of saying @samp{50}.
@var{first} + (@var{n} * @var{step})になる行が選択されます.このため,

@item $
@cindex Address, last line
@cindex Last line, selecting
@cindex Line, selecting last
@c This address matches the last line of the last file of input, or
@c the last line of each file when the @option{-i} or @option{-s} options
@c are specified.

@item /@var{regexp}/
@cindex Address, as a regular expression
@cindex Line, selecting by regular expression match
@c This will select any line which matches the regular expression @var{regexp}.
@c If @var{regexp} itself includes any @code{/} characters,
@c each must be escaped by a backslash (@code{\}).

@cindex empty regular expression
@cindex @value{SSEDEXT}, modifiers and the empty regular expression
@c The empty regular expression @samp{//} repeats the last regular
@c expression match (the same holds if the empty regular expression is
@c passed to the @code{s} command).  Note that modifiers to regular expressions
@c are evaluated when the regular expression is compiled, thus it is invalid to
@c specify them together with the empty regular expression.

@item \%@var{regexp}%
@c (The @code{%} may be replaced by any other single character.)

@cindex Slash character, in regular expressions
@c This also matches the regular expression @var{regexp},
@c but allows one to use a different delimiter than @code{/}.
@c This is particularly useful if the @var{regexp} itself contains
@c a lot of slashes, since it avoids the tedious escaping of every @code{/}.
@c If @var{regexp} itself includes any delimiter characters,
@c each must be escaped by a backslash (@code{\}).

@item /@var{regexp}/I
@itemx \%@var{regexp}%I
@cindex @acronym{GNU} extensions, @code{I} modifier
@ifset PERL
@cindex Perl-style regular expressions, case-insensitive
@end ifset
@c The @code{I} modifier to regular-expression matching is a @acronym{GNU}
@c extension which causes the @var{regexp} to be matched in
@c a case-insensitive manner.

@item /@var{regexp}/M
@itemx \%@var{regexp}%M
@ifset PERL
@cindex @value{SSEDEXT}, @code{M} modifier
@end ifset
@cindex Perl-style regular expressions, multiline
@c The @code{M} modifier to regular-expression matching is a @value{SSED}
@c extension which causes @code{^} and @code{$} to match respectively
@c (in addition to the normal behavior) the empty string after a newline,
@c and the empty string before a newline.  There are special character
@c sequences

@ifset PERL
@c (@code{\A} and @code{\Z} in Perl mode, @code{\`} and @code{\'}
@c in basic or extended regular expression modes)

@end ifset
@ifclear PERL
@c (@code{\`} and @code{\'})
@end ifclear
@c which always match the beginning or the end of the buffer.
@c @code{M} stands for @cite{multi-line}.

@ifset PERL
@item /@var{regexp}/S
@itemx \%@var{regexp}%S
@cindex @value{SSEDEXT}, @code{S} modifier
@cindex Perl-style regular expressions, single line
@c The @code{S} modifier to regular-expression matching is only valid
@c in Perl mode and specifies that the dot character (@code{.}) will
@c match the newline character too.  @code{S} stands for @cite{single-line}.
@end ifset

@ifset PERL
@item /@var{regexp}/X
@itemx \%@var{regexp}%X
@cindex @value{SSEDEXT}, @code{X} modifier
@cindex Perl-style regular expressions, extended
@c The @code{X} modifier to regular-expression matching is also
@c valid in Perl mode only.  If it is used, whitespace in the
@c pattern (other than in a character class) and
@c characters between a @kbd{#} outside a character class and the
@c next newline character are ignored. An escaping backslash
@c can be used to include a whitespace or @kbd{#} character as part
@c of the pattern.
@end ifset
@end table

@c If no addresses are given, then all lines are matched;
@c if one address is given, then only lines matching that
@c address are matched.

@cindex Range of lines
@cindex Several lines, selecting
@c An address range can be specified by specifying two addresses
@c separated by a comma (@code{,}).  An address range matches lines
@c starting from where the first address matches, and continues
@c until the second address matches (inclusively).

@c If the second address is a @var{regexp}, then checking for the
@c ending match will start with the line @emph{following} the
@c line which matched the first address: a range will always
@c span at least two lines (except of course if the input stream
@c ends).

@c If the second address is a @var{number} less than (or equal to)
@c the line matching the first address, then only the one line is
@c matched.

@cindex Special addressing forms
@cindex Range with start address of zero
@cindex Zero, as range start address
@cindex @var{addr1},+N
@cindex @var{addr1},~N
@cindex @acronym{GNU} extensions, special two-address forms
@cindex @acronym{GNU} extensions, @code{0} address
@cindex @acronym{GNU} extensions, 0,@var{addr2} addressing
@cindex @acronym{GNU} extensions, @var{addr1},+@var{N} addressing
@cindex @acronym{GNU} extensions, @var{addr1},~@var{N} addressing
@c @value{SSED} also supports some special two-address forms; all these
@c are @acronym{GNU} extensions:
@table @code
@item 0,/@var{regexp}/
@c A line number of @code{0} can be used in an address specification like
@c @code{0,/@var{regexp}/} so that @command{sed} will try to match
@c @var{regexp} in the first input line too.  In other words,
@c @code{0,/@var{regexp}/} is similar to @code{1,/@var{regexp}/},
@c except that if @var{addr2} matches the very first line of input the
@c @code{0,/@var{regexp}/} form will consider it to end the range, whereas
@c the @code{1,/@var{regexp}/} form will match the beginning of its range and
@c hence make the range span up to the @emph{second} occurrence of the
@c regular expression.

@c Note that this is the only place where the @code{0} address makes
@c sense; there is no 0-th line and commands which are given the @code{0}
@c address in any other way will give an error.

@item @var{addr1},+@var{N}
@c Matches @var{addr1} and the @var{N} lines following @var{addr1}.

@item @var{addr1},~@var{N}
@c Matches @var{addr1} and the lines following @var{addr1}
@c until the next line whose input line number is a multiple of @var{N}.
@end table

@cindex Excluding lines
@cindex Selecting non-matching lines
@c Appending the @code{!} character to the end of an address
@c specification negates the sense of the match.
@c That is, if the @code{!} character follows an address range,
@c then only lines which do @emph{not} match the address range
@c will be selected.
@c This also works for singleton addresses,
@c and, perhaps perversely, for the null address.

@node Regular Expressions
@c @section Overview of Regular Expression Syntax
@section 正規表現の構文の概要

@c To know how to use @command{sed}, people should understand regular
@c expressions (@dfn{regexp} for short).  A regular expression
@c is a pattern that is matched against a
@c subject string from left to right.  Most characters are
@c @dfn{ordinary}: they stand for
@c themselves in a pattern, and match the corresponding characters
@c in the subject.  As a trivial example, the pattern

     The quick brown fox
@end example

@c matches a portion of a subject string that is identical to
@c itself.  The power of regular expressions comes from the
@c ability to include alternatives and repetitions in the pattern.
@c These are encoded in the pattern by the use of @dfn{special characters},
@c which do not stand for themselves but instead
@c are interpreted in some special way.  Here is a brief description
@c of regular expression syntax as used in @command{sed}.
@dfn{特殊文字(special characters)}を使用してパターン内にエンコードされ,

@table @code
@item @var{char}
@c A single ordinary character matches itself.

@item *
@cindex @acronym{GNU} extensions, to basic regular expressions
@c Matches a sequence of zero or more instances of matches for the
@c preceding regular expression, which must be an ordinary character, a
@c special character preceded by @code{\}, a @code{.}, a grouped regexp
@c (see below), or a bracket expression.  As a @acronym{GNU} extension, a
@c postfixed regular expression can also be followed by @code{*}; for
@c example, @code{a**} is equivalent to @code{a*}.  @acronym{POSIX}
@c 1003.1-2001 says that @code{*} stands for itself when it appears at
@c the start of a regular expression or subexpression, but many
@c non@acronym{GNU} implementations do not support this and portable
@c scripts should instead use @code{\*} in these contexts.
価です.@acronym{POSIX} 1003.1-2001では,@code{*}が正規表現やサブ正規表

@item \+
@cindex @acronym{GNU} extensions, to basic regular expressions
@c As @code{*}, but matches one or more.  It is a @acronym{GNU} extension.

@item \?
@cindex @acronym{GNU} extensions, to basic regular expressions
@c As @code{*}, but only matches zero or one.  It is a @acronym{GNU} extension.

@item \@{@var{i}\@}
@c As @code{*}, but matches exactly @var{i} sequences (@var{i} is a
@c decimal integer; for portability, keep it between 0 and 255
@c inclusive).

@item \@{@var{i},@var{j}\@}
@c Matches between @var{i} and @var{j}, inclusive, sequences.

@item \@{@var{i},\@}
@c Matches more than or equal to @var{i} sequences.

@item \(@var{regexp}\)
@c Groups the inner @var{regexp} as a whole, this is used to: 

@itemize @bullet
@cindex @acronym{GNU} extensions, to basic regular expressions
@c Apply postfix operators, like @code{\(abcd\)*}:
@c this will search for zero or more whole sequences 
@c of @samp{abcd}, while @code{abcd*} would search
@c for @samp{abc} followed by zero or more occurrences
@c of @samp{d}.  Note that support for @code{\(abcd\)*} is
@c required by @acronym{POSIX} 1003.1-2001, but many non-@acronym{GNU}
@c implementations do not support it and hence it is not universally
@c portable.
@acronym{POSIX} 1003.1-2001で要求されているためサポートされていますが,

@c Use back references (see below).
@end itemize

@item .
@c Matches any character, including newline.

@item ^
@c Matches the null string at beginning of line, i.e. what
@c appears after the circumflex must appear at the 
@c beginning of line. @code{^#include} will match only 
@c lines where @samp{#include} is the first thing on line---if
@c there are spaces before, for example, the match fails.
@c @code{^} acts as a special character only at the beginning
@c of the regular expression or subexpression (that is,
@c after @code{\(} or @code{\|}).  Portable scripts should avoid
@c @code{^} at the beginning of a subexpression, though, as
@c @acronym{POSIX} allows implementations that treat @code{^} as
@c an ordinary character in that context.
にあるところだけにマッチします --- その前に一つか二つのスペースがある場

@item $
@c It is the same as @code{^}, but refers to end of line.
@c @code{$} also acts as a special character only at the end
@c of the regular expression or subexpression (that is, before @code{\)}
@c or @code{\|}), and its use at the end of a subexpression is not
@c portable.

@item [@var{list}]
@itemx [^@var{list}]
@c Matches any single character in @var{list}: for example,
@c @code{[aeiou]} matches all vowels.  A list may include
@c sequences like @code{@var{char1}-@var{char2}}, which
@c matches any character between (inclusive) @var{char1}
@c and @var{char2}.

@c A leading @code{^} reverses the meaning of @var{list}, so that
@c it matches any single character @emph{not} in @var{list}.  To include
@c @code{]} in the list, make it the first character (after
@c the @code{^} if needed), to include @code{-} in the list,
@c make it the first or last; to include @code{^} put
@c it after the first character.

@cindex @code{POSIXLY_CORRECT} behavior, bracket expressions
@c The characters @code{$}, @code{*}, @code{.}, @code{[}, and @code{\}
@c are normally not special within @var{list}.  For example, @code{[\*]}
@c matches either @samp{\} or @samp{*}, because the @code{\} is not
@c special here.  However, strings like @code{[.ch.]}, @code{[=a=]}, and
@c @code{[:space:]} are special within @var{list} and represent collating
@c symbols, equivalence classes, and character classes, respectively, and
@c @code{[} is therefore special within @var{list} when it is followed by
@c @code{.}, @code{=}, or @code{:}.  Also, when not in
@c @env{POSIXLY_CORRECT} mode, special escapes like @code{\n} and
@c @code{\t} are recognized within @var{list}.  @xref{Escapes}.

@item @var{regexp1}\|@var{regexp2}
@cindex @acronym{GNU} extensions, to basic regular expressions
@c Matches either @var{regexp1} or @var{regexp2}.  Use
@c parentheses to use complex alternative regular expressions.
@c The matching process tries each alternative in turn, from
@c left to right, and the first one that succeeds is used.
@c It is a @acronym{GNU} extension.

@item @var{regexp1}@var{regexp2}
@c Matches the concatenation of @var{regexp1} and @var{regexp2}.
@c Concatenation binds more tightly than @code{\|}, @code{^}, and
@c @code{$}, but less tightly than the other regular expression
@c operators.

@item \@var{digit}
@c Matches the @var{digit}-th @code{\(@dots{}\)} parenthesized
@c subexpression in the regular expression.  This is called a @dfn{back
@c reference}.  Subexpressions are implicity numbered by counting
@c occurrences of @code{\(} left-to-right.
チします.これは,@dfn{後方参照(back reference)}と呼ばれています.部分

@item \n
@c Matches the newline character.

@item \@var{char}
@c Matches @var{char}, where @var{char} is one of @code{$},
@c @code{*}, @code{.}, @code{[}, @code{\}, or @code{^}.
@c Note that the only C-like
@c backslash sequences that you can portably assume to be
@c interpreted are @code{\n} and @code{\\}; in particular
@c @code{\t} is not portable, and matches a @samp{t} under most
@c implementations of @command{sed}, rather than a tab character.

@end table

@cindex Greedy regular expression matching
@c Note that the regular expression matcher is greedy, i.e., matches
@c are attempted from left to right and, if two or more matches are
@c possible starting at the same character, it selects the longest.

@c Examples:
@table @samp
@item abcdef
@c Matches @samp{abcdef}.

@item a*b
@c Matches zero or more @samp{a}s followed by a single
@c @samp{b}.  For example, @samp{b} or @samp{aaaaab}. 

@item a\?b
@c Matches @samp{b} or @samp{ab}.

@item a\+b\+
@c Matches one or more @samp{a}s followed by one or more
@c @samp{b}s: @samp{ab} is the shortest possible match, but
@c other examples are @samp{aaaab} or @samp{abbbbb} or
@c @samp{aaaaaabbbbbbb}.

@item .*
@itemx .\+
@c These two both match all the characters in a string;
@c however, the first matches every string (including the empty
@c string), while the second matches only strings containing
@c at least one character.

@item ^main.*(.*)
@c This matches a string starting with @samp{main},
@c followed by an opening and closing
@c parenthesis.  The @samp{n}, @samp{(} and @samp{)} need not
@c be adjacent.

@item ^#
@c This matches a string beginning with @samp{#}.

@item \\$
@c This matches a string ending with a single backslash.  The
@c regexp contains two backslashes for escaping.

@item \$
@c Instead, this matches a string consisting of a single dollar sign,
@c because it is escaped.

@item [a-zA-Z0-9]
@c In the C locale, this matches any @acronym{ASCII} letters or digits.

@item [^ @kbd{tab}]\+
@c (Here @kbd{tab} stands for a single tab character.)
@c This matches a string of one or more
@c characters, none of which is a space or a tab.
@c Usually this means a word.
(ここでの@kbd{tab}は単一のタブ文字を意味します.) これは,スペースとタ

@item ^\(.*\)\n\1$
@c This matches a string consisting of two equal substrings separated by
@c a newline.

@item .\@{9\@}A$
@c This matches nine characters followed by an @samp{A}.

@item ^.\@{15\@}A
@c This matches the start of a string that contains 16 characters,
@c the last of which is an @samp{A}.

@end table

@node Common Commands
@c @section Often-Used Commands
@section よく使用されるコマンド

@c If you use @command{sed} at all, you will quite likely want to know
@c these commands.

@table @code
@item #
@c [No addresses allowed.]

@findex # (comments)
@cindex Comments, in scripts
@c The @code{#} character begins a comment;
@c the comment continues until the next newline.

@cindex Portability, comments
@c If you are concerned about portability, be aware that
@c some implementations of @command{sed} (which are not @sc{posix}
@c conformant) may only support a single one-line comment,
@c and then only when the very first character of the script is a @code{#}.
移植性を心配している場合,@command{sed} (@sc{posix}に準拠していないも

@findex -n, forcing from within a script
@cindex Caveat --- #n on first line
@c Warning: if the first two characters of the @command{sed} script
@c are @code{#n}, then the @option{-n} (no-autoprint) option is forced.
@c If you want to put a comment in the first line of your script
@c and that comment begins with the letter @samp{n}
@c and you do not want this behavior,
@c then be sure to either use a capital @samp{N},
@c or place at least one space before the @samp{n}.
@option{-n} (自動的に出力しない)オプションが強制的に使用されます.スク

@item q [@var{exit-code}]
@c This command only accepts a single address.

@findex q (quit) command
@cindex @value{SSEDEXT}, returning an exit code
@cindex Quitting
@c Exit @command{sed} without processing any more commands or input.
@c Note that the current pattern space is printed if auto-print is
@c not disabled with the @option{-n} options.  The ability to return
@c an exit code from the @command{sed} script is a @value{SSED} extension.

@item d
@findex d (delete) command
@cindex Text, deleting
@c Delete the pattern space;
@c immediately start next cycle.

@item p
@findex p (print) command
@cindex Text, printing
@c Print out the pattern space (to the standard output).
@c This command is usually only used in conjunction with the @option{-n}
@c command-line option.

@item n
@findex n (next-line) command
@cindex Next input line, replace pattern space with
@cindex Read next input line
@c If auto-print is not disabled, print the pattern space,
@c then, regardless, replace the pattern space with the next line of input.
@c If there is no more input then @command{sed} exits without processing
@c any more commands.

@item @{ @var{commands} @}
@findex @{@} command grouping
@cindex Grouping commands
@cindex Command groups
@c A group of commands may be enclosed between
@c @code{@{} and @code{@}} characters.
@c This is particularly useful when you want a group of commands
@c to be triggered by a single address (or address-range) match.

@end table

@node The "s" Command
@c @section The @code{s} Command
@section @code{s}コマンド

@c The syntax of the @code{s} (as in substitute) command is
@c @samp{s/@var{regexp}/@var{replacement}/@var{flags}}.  The @code{/}
@c characters may be uniformly replaced by any other single
@c character within any given @code{s} command.  The @code{/}
@c character (or whatever other character is used in its stead)
@c can appear in the @var{regexp} or @var{replacement}
@c only if it is preceded by a @code{\} character.

@c The @code{s} command is probably the most important in @command{sed}
@c and has a lot of different options.  Its basic concept is simple:
@c the @code{s} command attempts to match the pattern
@c space against the supplied @var{regexp}; if the match is
@c successful, then that portion of the pattern
@c space which was matched is replaced with @var{replacement}.

@cindex Backreferences, in regular expressions
@cindex Parenthesized substrings
@c The @var{replacement} can contain @code{\@var{n}} (@var{n} being
@c a number from 1 to 9, inclusive) references, which refer to
@c the portion of the match which is contained between the @var{n}th
@c @code{\(} and its matching @code{\)}.
@c Also, the @var{replacement} can contain unescaped @code{&}
@c characters which reference the whole matched portion
@c of the pattern space.

@cindex @value{SSEDEXT}, case modifiers in @code{s} commands
@c Finally, as a @value{SSED} extension, you can include a
@c special sequence made of a backslash and one of the letters
@c @code{L}, @code{l}, @code{U}, @code{u}, or @code{E}.
@c The meaning is as follows:

@table @code
@item \L
@c Turn the replacement
@c to lowercase until a @code{\U} or @code{\E} is found,

@item \l
@c Turn the
@c next character to lowercase,

@item \U
@c Turn the replacement to uppercase
@c until a @code{\L} or @code{\E} is found,

@item \u
@c Turn the next character
@c to uppercase,

@item \E
@c Stop case conversion started by @code{\L} or @code{\U}.
@end table

@c To include a literal @code{\}, @code{&}, or newline in the final
@c replacement, be sure to precede the desired @code{\}, @code{&},
@c or newline in the @var{replacement} with a @code{\}.

@findex s command, option flags
@cindex Substitution of text, options
@c The @code{s} command can be followed by zero or more of the
@c following @var{flags}:

@table @code
@item g
@cindex Global substitution
@cindex Replacing all text matching regexp in a line
@c Apply the replacement to @emph{all} matches to the @var{regexp},
@c not just the first.

@item @var{number}
@cindex Replacing only @var{n}th match of regexp in a line
@c Only replace the @var{number}th match of the @var{regexp}.

@cindex @acronym{GNU} extensions, @code{g} and @var{number} modifier interaction in @code{s} command
@cindex Mixing @code{g} and @var{number} modifiers in the @code{s} command
@c Note: the @sc{posix} standard does not specify what should happen
@c when you mix the @code{g} and @var{number} modifiers,
@c and currently there is no widely agreed upon meaning
@c across @command{sed} implementations.
@c For @value{SSED}, the interaction is defined to be:
@c ignore matches before the @var{number}th,
@c and then match and replace all matches from
@c the @var{number}th on.

@item p
@cindex Text, printing after substitution
@c If the substitution was made, then print the new pattern space.

@c Note: when both the @code{p} and @code{e} options are specified,
@c the relative ordering of the two produces very different results.
@c In general, @code{ep} (evaluate then print) is what you want,
@c but operating the other way round can be useful for debugging.
@c For this reason, the current version of @value{SSED} interprets
@c specially the presence of @code{p} options both before and after
@c @code{e}, printing the pattern space before and after evaluation,
@c while in general flags for the @code{s} command show their
@c effect just once.  This behavior, although documented, might
@c change in future versions.

@item w @var{file-name}
@cindex Text, writing to a file after substitution
@cindex @value{SSEDEXT}, @file{/dev/stdout} file
@cindex @value{SSEDEXT}, @file{/dev/stderr} file
@c If the substitution was made, then write out the result to the named file.
@c As a @value{SSED} extension, two special values of @var{file-name} are
@c supported: @file{/dev/stderr}, which writes the result to the standard
@c error, and @file{/dev/stdout}, which writes to the standard
@c output.@footnote{This is equivalent to @code{p} unless the @option{-i}
@c option is being used.}

@item e
@cindex Evaluate Bourne-shell commands, after substitution
@cindex Subprocesses
@cindex @value{SSEDEXT}, evaluating Bourne-shell commands
@cindex @value{SSEDEXT}, subprocesses
@c This command allows one to pipe input from a shell command
@c into pattern space.  If a substitution was made, the command
@c that is found in pattern space is executed and pattern space
@c is replaced with its output.  A trailing newline is suppressed;
@c results are undefined if the command to be executed contains
@c a @sc{nul} character.  This is a @value{SSED} extension.

@item I
@itemx i
@cindex @acronym{GNU} extensions, @code{I} modifier
@cindex Case-insensitive matching
@ifset PERL
@cindex Perl-style regular expressions, case-insensitive
@end ifset
@c The @code{I} modifier to regular-expression matching is a @acronym{GNU}
@c extension which makes @command{sed} match @var{regexp} in a
@c case-insensitive manner.

@item M
@itemx m
@cindex @value{SSEDEXT}, @code{M} modifier
@ifset PERL
@cindex Perl-style regular expressions, multiline
@end ifset
@c The @code{M} modifier to regular-expression matching is a @value{SSED}
@c extension which causes @code{^} and @code{$} to match respectively
@c (in addition to the normal behavior) the empty string after a newline,
@c and the empty string before a newline.  There are special character
@c sequences

@ifset PERL
@c (@code{\A} and @code{\Z} in Perl mode, @code{\`} and @code{\'}
@c in basic or extended regular expression modes)
@end ifset
@ifclear PERL
@c (@code{\`} and @code{\'})
@end ifclear
@c which always match the beginning or the end of the buffer.
@c @code{M} stands for @cite{multi-line}.

@ifset PERL
@item S
@itemx s
@cindex @value{SSEDEXT}, @code{S} modifier
@cindex Perl-style regular expressions, single line
@c The @code{S} modifier to regular-expression matching is only valid
@c in Perl mode and specifies that the dot character (@code{.}) will
@c match the newline character too.  @code{S} stands for @cite{single-line}.
@end ifset

@ifset PERL
@item X
@itemx x
@cindex @value{SSEDEXT}, @code{X} modifier
@cindex Perl-style regular expressions, extended
@c The @code{X} modifier to regular-expression matching is also
@c valid in Perl mode only.  If it is used, whitespace in the
@c pattern (other than in a character class) and
@c characters between a @kbd{#} outside a character class and the
@c next newline character are ignored. An escaping backslash
@c can be used to include a whitespace or @kbd{#} character as part
@c of the pattern.
@end ifset
@end table

@node Other Commands
@c @section Less Frequently-Used Commands
@section あまり使用されないコマンド

@c Though perhaps less frequently used than those in the previous
@c section, some very small yet useful @command{sed} scripts can be built with
@c these commands.

@table @code
@item y/@var{source-chars}/@var{dest-chars}/
@c (The @code{/} characters may be uniformly replaced by
@c any other single character within any given @code{y} command.)

@findex y (transliterate) command
@cindex Transliteration
@c Transliterate any characters in the pattern space which match
@c any of the @var{source-chars} with the corresponding character
@c in @var{dest-chars}.

@c Instances of the @code{/} (or whatever other character is used in its stead),
@c @code{\}, or newlines can appear in the @var{source-chars} or @var{dest-chars}
@c lists, provide that each instance is escaped by a @code{\}.
@c The @var{source-chars} and @var{dest-chars} lists @emph{must}
@c contain the same number of characters (after de-escaping).

@item a\
@itemx @var{text}
@cindex @value{SSEDEXT}, two addresses supported by most commands
@c As a @acronym{GNU} extension, this command accepts two addresses.

@findex a (append text lines) command
@cindex Appending text after a line
@cindex Text, appending
@c Queue the lines of text which follow this command
@c (each but the last ending with a @code{\},
@c which are removed from the output)
@c to be output at the end of the current cycle,
@c or when the next input line is read.

@c Escape sequences in @var{text} are processed, so you should
@c use @code{\\} in @var{text} to print a single backslash.

@c As a @acronym{GNU} extension, if between the @code{a} and the newline there is
@c other than a whitespace-@code{\} sequence, then the text of this line,
@c starting at the first non-whitespace character after the @code{a},
@c is taken as the first line of the @var{text} block.
@c (This enables a simplification in scripting a one-line add.)
@c This extension also works with the @code{i} and @code{c} commands.

@item i\
@itemx @var{text}
@cindex @value{SSEDEXT}, two addresses supported by most commands
@c As a @acronym{GNU} extension, this command accepts two addresses.

@findex i (insert text lines) command
@cindex Inserting text before a line
@cindex Text, insertion
@c Immediately output the lines of text which follow this command
@c (each but the last ending with a @code{\},
@c which are removed from the output).

@item c\
@itemx @var{text}
@findex c (change to text lines) command
@cindex Replacing selected lines with other text
@c Delete the lines matching the address or address-range,
@c and output the lines of text which follow this command
@c (each but the last ending with a @code{\},
@c which are removed from the output)
@c in place of the last line
@c (or in place of each line, if no addresses were specified).
@c A new cycle is started after this command is done,
@c since the pattern space will have been deleted.

@item =
@cindex @value{SSEDEXT}, two addresses supported by most commands
@c As a @acronym{GNU} extension, this command accepts two addresses.

@findex = (print line number) command
@cindex Printing line number
@cindex Line number, printing
@c Print out the current input line number (with a trailing newline).

@item l @var{n}
@findex l (list unambiguously) command
@cindex List pattern space
@cindex Printing text unambiguously
@cindex Line length, setting
@cindex @value{SSEDEXT}, setting line length
@c Print the pattern space in an unambiguous form:
@c non-printable characters (and the @code{\} character)
@c are printed in C-style escaped form; long lines are split,
@c with a trailing @code{\} character to indicate the split;
@c the end of each line is marked with a @code{$}.

@c @var{n} specifies the desired line-wrap length;
@c a length of 0 (zero) means to never wrap long lines.  If omitted,
@c the default as specified on the command line is used.  The @var{n}
@c parameter is a @value{SSED} extension.

@item r @var{filename}
@cindex @value{SSEDEXT}, two addresses supported by most commands
@c As a @acronym{GNU} extension, this command accepts two addresses.

@findex r (read file) command
@cindex Read text from a file
@cindex @value{SSEDEXT}, @file{/dev/stdin} file
@c Queue the contents of @var{filename} to be read and
@c inserted into the output stream at the end of the current cycle,
@c or when the next input line is read.
@c Note that if @var{filename} cannot be read, it is treated as
@c if it were an empty file, without any error indication.

@c As a @value{SSED} extension, the special value @file{/dev/stdin}
@c is supported for the file name, which reads the contents of the
@c standard input.

@item w @var{filename}
@findex w (write file) command
@cindex Write to a file
@cindex @value{SSEDEXT}, @file{/dev/stdout} file
@cindex @value{SSEDEXT}, @file{/dev/stderr} file
@c Write the pattern space to @var{filename}.
@c As a @value{SSED} extension, two special values of @var{file-name} are
@c supported: @file{/dev/stderr}, which writes the result to the standard
@c error, and @file{/dev/stdout}, which writes to the standard
@c output.@footnote{This is equivalent to @code{p} unless the @option{-i}
@c option is being used.}

@c The file will be created (or truncated) before the
@c first input line is read; all @code{w} commands
@c (including instances of @code{w} flag on successful @code{s} commands)
@c which refer to the same @var{filename} are output without
@c closing and reopening the file.

@item D
@findex D (delete first line) command
@cindex Delete first line from pattern space
@c Delete text in the pattern space up to the first newline.
@c If any text is left, restart cycle with the resultant
@c pattern space (without reading a new line of input),
@c otherwise start a normal new cycle.

@item N
@findex N (append Next line) command
@cindex Next input line, append to pattern space
@cindex Append next input line to pattern space
@c Add a newline to the pattern space,
@c then append the next line of input to the pattern space.
@c If there is no more input then @command{sed} exits without processing
@c any more commands.

@item P
@findex P (print first line) command
@cindex Print first line from pattern space
@c Print out the portion of the pattern space up to the first newline.

@item h
@findex h (hold) command
@cindex Copy pattern space into hold space
@cindex Replace hold space with copy of pattern space
@cindex Hold space, copying pattern space into
@c Replace the contents of the hold space with the contents of the pattern space.

@item H
@findex H (append Hold) command
@cindex Append pattern space to hold space
@cindex Hold space, appending from pattern space
@c Append a newline to the contents of the hold space,
@c and then append the contents of the pattern space to that of the hold space.

@item g
@findex g (get) command
@cindex Copy hold space into pattern space
@cindex Replace pattern space with copy of hold space
@cindex Hold space, copy into pattern space
@c Replace the contents of the pattern space with the contents of the hold space.

@item G
@findex G (appending Get) command
@cindex Append hold space to pattern space
@cindex Hold space, appending to pattern space
@c Append a newline to the contents of the pattern space,
@c and then append the contents of the hold space to that of the pattern space.

@item x
@findex x (eXchange) command
@cindex Exchange hold space with pattern space
@cindex Hold space, exchange with pattern space
@c Exchange the contents of the hold and pattern spaces.

@end table

@node Programming Commands
@c @section Commands for @command{sed} gurus
@section @command{sed}のベテランプログラマのためのコマンド

@c In most cases, use of these commands indicates that you are
@c probably better off programming in something like @command{awk}
@c or Perl.  But occasionally one is committed to sticking
@c with @command{sed}, and these commands can enable one to write
@c quite convoluted scripts.

@cindex Flow of control in scripts
@table @code
@item : @var{label}
@c [No addresses allowed.]

@findex : (label) command
@cindex Labels, in scripts
@c Specify the location of @var{label} for branch commands.
@c In all other respects, a no-op.

@item b @var{label}
@findex b (branch) command
@cindex Branch to a label, unconditionally
@cindex Goto, in scripts
@c Unconditionally branch to @var{label}.
@c The @var{label} may be omitted, in which case the next cycle is started.

@item t @var{label}
@findex t (test and branch if successful) command
@cindex Branch to a label, if @code{s///} succeeded
@cindex Conditional branch
@c Branch to @var{label} only if there has been a successful @code{s}ubstitution
@c since the last input line was read or conditional branch was taken.
@c The @var{label} may be omitted, in which case the next cycle is started.

@end table

@node Extended Commands
@c @section Commands Specific to @value{SSED}
@section @value{SSED}特有のコマンド

@c These commands are specific to @value{SSED}, so you
@c must use them with care and only when you are sure that
@c hindering portability is not evil.  They allow you to check
@c for @value{SSED} extensions or to do tasks that are required
@c quite often, yet are unsupported by standard @command{sed}s.

@table @code
@item e [@var{command}]
@findex e (evaluate) command
@cindex Evaluate Bourne-shell commands
@cindex Subprocesses
@cindex @value{SSEDEXT}, evaluating Bourne-shell commands
@cindex @value{SSEDEXT}, subprocesses
@c This command allows one to pipe input from a shell command
@c into pattern space.  Without parameters, the @code{e} command
@c executes the command that is found in pattern space and
@c replaces the pattern space with the output; a trailing newline
@c is suppressed.

@c If a parameter is specified, instead, the @code{e} command
@c interprets it as a command and sends its output to the output stream
@c (like @code{r} does).  The command can run across multiple
@c lines, all but the last ending with a back-slash.

@c In both cases, the results are undefined if the command to be
@c executed contains a @sc{nul} character.

@item L @var{n}
@findex L (fLow paragraphs) command
@cindex Reformat pattern space
@cindex Reformatting paragraphs
@cindex @value{SSEDEXT}, reformatting paragraphs
@cindex @value{SSEDEXT}, @code{L} command
@c This @value{SSED} extension fills and joins lines in pattern space
@c to produce output lines of (at most) @var{n} characters, like
@c @code{fmt} does; if @var{n} is omitted, the default as specified
@c on the command line is used.  This command is considered a failed
@c experiment and unless there is enough request (which seems unlikely)
@c will be removed in future versions.

Blank lines, spaces between words, and indentation are
preserved in the output; successive input lines with different
indentation are not joined; tabs are expanded to 8 columns.

If the pattern space contains multiple lines, they are joined, but
since the pattern space usually contains a single line, the behavior
of a simple @code{L;d} script is the same as @samp{fmt -s} (i.e.,
it does not join short lines to form longer ones).

@var{n} specifies the desired line-wrap length; if omitted,
the default as specified on the command line is used.
@end ignore

@item Q [@var{exit-code}]
@c This command only accepts a single address.

@findex Q (silent Quit) command
@cindex @value{SSEDEXT}, quitting silently
@cindex @value{SSEDEXT}, returning an exit code
@cindex Quitting
@c This command is the same as @code{q}, but will not print the
@c contents of pattern space.  Like @code{q}, it provides the
@c ability to return an exit code to the caller.

@c This command can be useful because the only alternative ways
@c to accomplish this apparently trivial function are to use
@c the @option{-n} option (which can unnecessarily complicate
@c your script) or resorting to the following snippet, which
@c wastes time by reading the whole file without any visible effect:

$d       @i{Quit silently on the last line}
N        @i{Read another line, silently}
g        @i{Overwrite pattern space each time to save memory}
b eat
@end example

@item R @var{filename}
@findex R (read line) command
@cindex Read text from a file
@cindex @value{SSEDEXT}, reading a file a line at a time
@cindex @value{SSEDEXT}, @code{R} command
@cindex @value{SSEDEXT}, @file{/dev/stdin} file
@c Queue a line of @var{filename} to be read and
@c inserted into the output stream at the end of the current cycle,
@c or when the next input line is read.
@c Note that if @var{filename} cannot be read, or if its end is
@c reached, no line is appended, without any error indication.

@c As with the @code{r} command, the special value @file{/dev/stdin}
@c is supported for the file name, which reads a line from the
@c standard input.

@item T @var{label}
@findex T (test and branch if failed) command
@cindex @value{SSEDEXT}, branch if @code{s///} failed
@cindex Branch to a label, if @code{s///} failed
@cindex Conditional branch
@c Branch to @var{label} only if there have been no successful
@c @code{s}ubstitutions since the last input line was read or
@c conditional branch was taken. The @var{label} may be omitted,
@c in which case the next cycle is started.

@item v @var{version}
@findex v (version) command
@cindex @value{SSEDEXT}, checking for their presence
@cindex Requiring @value{SSED}
@c This command does nothing, but makes @command{sed} fail if
@c @value{SSED} extensions are not supported, simply because other
@c versions of @command{sed} do not implement it.  In addition, you
@c can specify the version of @command{sed} that your script
@c requires, such as @code{4.0.5}.  The default is @code{4.0}
@c because that is the first version that implemented this command.

@c This command enables all @value{SSEDEXT} even if
@c @env{POSIXLY_CORRECT} is set in the environment.

@item W @var{filename}
@findex W (write first line) command
@cindex Write first line to a file
@cindex @value{SSEDEXT}, writing first line to a file
@c Write to the given filename the portion of the pattern space up to
@c the first newline.  Everything said under the @code{w} command about
@c file handling holds here too.
@end table

@node Escapes
@c @section @acronym{GNU} Extensions for Escapes in Regular Expressions
@section 正規表現でのエスケープに関する@acronym{GNU}の拡張

@cindex @acronym{GNU} extensions, special escapes
@c Until this chapter, we have only encountered escapes of the form
@c @samp{\^}, which tell @command{sed} not to interpret the circumflex
@c as a special character, but rather to take it literally.  For
@c example, @samp{\*} matches a single asterisk rather than zero
@c or more backslashes.
@samp{\*} はゼロ以上のバックスラッシュでは無く単一のアスタリスクにマッ

@cindex @code{POSIXLY_CORRECT} behavior, escapes
@c This chapter introduces another kind of escape@footnote{All
@c the escapes introduced here are @acronym{GNU}
@c extensions, with the exception of @code{\n}.  In basic regular
@c expression mode, setting @code{POSIXLY_CORRECT} disables them inside
@c bracket expressions.}---that
@c is, escapes that are applied to a character or sequence of characters
@c that ordinarily are taken literally, and that @command{sed} replaces
@c with a special character.  This provides a way
@c of encoding non-printable characters in patterns in a visible manner.
@c There is no restriction on the appearance of non-printing characters
@c in a @command{sed} script but when a script is being prepared in the
@c shell or by text editing, it is usually easier to use one of
@c the following escape sequences than the binary character it
@c represents:
ことができなくなります.} --- すなわち,通常の文字や文字の連続に適用さ

@c The list of these escapes is:

@table @code
@item \a
@c Produces or matches a @sc{bel} character, that is an ``alert'' (@sc{ascii} 7).

@item \f
@c Produces or matches a form feed (@sc{ascii} 12).
フォームフィードを生成またはそれにマッチします(@sc{ascii} 12).

@item \n
@c Produces or matches a newline (@sc{ascii} 10).
改行を生成またはそれにマッチします(@sc{ascii} 10).

@item \r
@c Produces or matches a carriage return (@sc{ascii} 13).
キャリッジリターンを生成またはそれにマッチします(@sc{ascii} 13).

@item \t
@c Produces or matches a horizontal tab (@sc{ascii} 9).
水平タブを生成またはそれにマッチします(@sc{ascii} 9).

@item \v
@c Produces or matches a so called ``vertical tab'' (@sc{ascii} 11).

@item \c@var{x}
@c Produces or matches @kbd{@sc{Control}-@var{x}}, where @var{x} is
@c any character.  The precise effect of @samp{\c@var{x}} is as follows:
@c if @var{x} is a lower case letter, it is converted to upper case.
@c Then bit 6 of the character (hex 40) is inverted.  Thus @samp{\cz} becomes
@c hex 1A, but @samp{\c@{} becomes hex 3B, while @samp{\c;} becomes hex 7B.

@item \d@var{xxx}
@c Produces or matches a character whose decimal @sc{ascii} value is @var{xxx}.

@item \o@var{xxx}
@ifset PERL
@item \@var{xxx}
@end ifset
@c Produces or matches a character whose octal @sc{ascii} value is @var{xxx}.

@ifset PERL
@c The syntax without the @code{o} is active in Perl mode, while the one
@c with the @code{o} is active in the normal or extended @sc{posix} regular
@c expression modes.
@end ifset

@item \x@var{xx}
@c Produces or matches a character whose hexadecimal @sc{ascii} value is @var{xx}.
@end table

@c @samp{\b} (backspace) was omitted because of the conflict with
@c the existing ``word boundary'' meaning.

@c Other escapes match a particular character class and are valid only in
@c regular expressions:

@table @code
@item \w
@c Matches any ``word'' character.  A ``word'' character is any
@c letter or digit or the underscore character.

@item \W
@c Matches any ``non-word'' character.

@item \b
@c Matches a word boundary; that is it matches if the character
@c to the left is a ``word'' character and the character to the
@c right is a ``non-word'' character, or vice-versa.

@item \B
@c Matches everywhere but on a word boundary; that is it matches
@c if the character to the left and the character to the right
@c are either both ``word'' characters or both ``non-word''
@c characters.

@item \`
@c Matches only at the start of pattern space.  This is different
@c from @code{^} in multi-line mode.

@item \'
@c Matches only at the end of pattern space.  This is different
@c from @code{$} in multi-line mode.

@ifset PERL
@item \G
@c Match only at the start of pattern space or, when doing a global
@c substitution using the @code{s///g} command and option, at
@c the end-of-match position of the prior match.  For example,
@c @samp{s/\Ga/Z/g} will change an initial run of @code{a}s to
@c a run of @code{Z}s
@end ifset
@end table

@node Examples
@c @chapter Some Sample Scripts
@chapter いくつかの見本スクリプト

@c Here are some @command{sed} scripts to guide you in the art of mastering
@c @command{sed}.

Some exotic examples:
* Centering lines::
* Increment a number::
* Rename files to lower case::
* Print bash environment::
* Reverse chars of lines::

Emulating standard utilities:
* tac::                             Reverse lines of files
* cat -n::                          Numbering lines
* cat -b::                          Numbering non-blank lines
* wc -c::                           Counting chars
* wc -w::                           Counting words
* wc -l::                           Counting lines
* head::                            Printing the first lines
* tail::                            Printing the last lines
* uniq::                            Make duplicate lines unique
* uniq -d::                         Print duplicated lines of input
* uniq -u::                         Remove all duplicated lines
* cat -s::                          Squeezing blank lines
@end menu

@node Centering lines
@c @section Centering Lines
@section 行の中央揃え

@c This script centers all lines of a file on a 80 columns width.
@c To change that width, the number in @code{\@{@dots{}\@}} must be
@c replaced, and the number of added spaces also must be changed.

@c Note how the buffer commands are used to separate parts in
@c the regular expressions to be matched---this is a common
@c technique.
いる方法に注意してください --- これは一般的なテクニックです.

@c start-------------------------------------------
#!/usr/bin/sed -f

# Put 80 spaces in the buffer
1 @{
  s/^$/          /
@end group

# del leading and trailing spaces
y/@kbd{tab}/ /
s/^ *//
s/ *$//
@end group

# add a newline and 80 spaces to end of line
@end group

# keep first 81 chars (80 + a newline)
@end group

# \2 matches half of the spaces, which are moved to the beginning
@end group
@end example
@c end---------------------------------------------

@node Increment a number
@c @section Increment a Number
@section 数字を増加させる

@c This script is one of a few that demonstrate how to do arithmetic
@c in @command{sed}.  This is indeed possible,@footnote{@command{sed} guru Greg
@c Ubben wrote an implementation of the @command{dc} @sc{rpn} calculator!
@c It is distributed together with sed.} but must be done manually.
Ubbenは,@code{dc} @sc{rpn}の計算機の実装を書いています!それはsedとと

@c To increment one number you just add 1 to last digit, replacing
@c it by the following digit.  There is one exception: when the digit
@c is a nine the previous digits must be also incremented until you
@c don't have a nine.

@c This solution by Bruno Haible is very clever and smart because
@c it uses a single buffer; if you don't have this limitation, the
@c algorithm used in @ref{cat -n, Numbering lines}, is faster.
@c It works by replacing trailing nines with an underscore, then
@c using multiple @code{s} commands to increment the last digit,
@c and then again substituting underscores with zeros.
このBruno Haibleによる解決方法は,単一のバッファを使用しているので非常
に賢く知的です.この制限がない場合,@ref{cat -n, Numbering lines}で使用

@c start-------------------------------------------
#!/usr/bin/sed -f

/[^0-9]/ d

# replace all leading 9s by _ (any other character except digits, could
# be used)
@end group

# incr last digit only.  The first line adds a most-significant
# digit of 1 if we have to add a digit.
# The @code{tn} commands are not necessary, but make the thing
# faster
@end group

s/^\(_*\)$/1\1/; tn
s/8\(_*\)$/9\1/; tn
s/7\(_*\)$/8\1/; tn
s/6\(_*\)$/7\1/; tn
s/5\(_*\)$/6\1/; tn
s/4\(_*\)$/5\1/; tn
s/3\(_*\)$/4\1/; tn
s/2\(_*\)$/3\1/; tn
s/1\(_*\)$/2\1/; tn
s/0\(_*\)$/1\1/; tn
@end group

@end group
@end example
@c end---------------------------------------------

@node Rename files to lower case
@c @section Rename Files to Lower Case
@section ファイル名を小文字に変更する

@c This is a pretty strange use of @command{sed}.  We transform text, and
@c transform it to be shell commands, then just feed them to shell.
@c Don't worry, even worse hacks are done when using @command{sed}; I have
@c seen a script converting the output of @command{date} into a @command{bc}
@c program!
@c The main body of this is the @command{sed} script, which remaps the name
@c from lower to upper (or vice-versa) and even checks out 
@c if the remapped name is the same as the original name.
@c Note how the script is parameterized using shell
@c variables and proper quoting.

@c start-------------------------------------------
#! /bin/sh
# rename files to lower/upper case... 
# usage: 
#    move-to-lower * 
#    move-to-upper * 
# or
#    move-to-lower -R .
#    move-to-upper -R .
@end group

	cat << eof
Usage: $0 [-n] [-r] [-h] files...
@end group

-n      do nothing, only see what would be done
-R      recursive (use find)
-h      this message
files   files to remap to lower case
@end group

       $0 -n *        (see if everything is ok, then...)
       $0 *
@end group

       $0 -R .

@end group

finder='echo "$@@" | tr " " "\n"'
@end group

while :
    case "$1" in 
        -n) apply_cmd='cat' ;;
        -R) finder='find "$@@" -type f';;
        -h) help ; exit 1 ;;
        *) break ;;
@end group

if [ -z "$1" ]; then
        echo Usage: $0 [-h] [-n] [-r] files...
        exit 1
@end group

@end group

case `basename $0` in
        *upper*) TO=$UPPER; FROM=$LOWER ;;
        *)       FROM=$UPPER; TO=$LOWER ;;
@end group
eval $finder | sed -n '

# remove all trailing slashes
@end group

# add ./ if there is no path, only a filename
/\//! s/^/.\//
@end group

# save path+filename
@end group

# remove path
@end group

# do conversion only on filename
@end group

# now line contains original path+file, while
# hold space contains the new filename
@end group

# add converted file name to line, which now contains
# path/file-name\nconverted-file-name
@end group

# check if converted file name is equal to original file name,
# if it is, do not print nothing
@end group

# now, transform path/fromfile\n, into
# mv path/fromfile path/tofile and print it
s/^\(.*\/\)\(.*\)\n\(.*\)$/mv \1\2 \1\3/p
@end group

' | $apply_cmd
@end example
@c end---------------------------------------------

@node Print bash environment
@c @section Print @command{bash} Environment
@section @command{bash}の環境変数の出力

@c This script strips the definition of the shell functions
@c from the output of the @command{set} Bourne-shell command.
以下のスクリプトは,@code{set} Bourneシェルコマンドの出力から,シェル関

@c start-------------------------------------------

set | sed -n '
@end group

# if no occurrence of "=()" print and load next line
@end ifinfo
# if no occurrence of @samp{=()} print and load next line
@end ifnotinfo
/=()/! @{ p; b; @}
/ () $/! @{ p; b; @}
@end group

# possible start of functions section
# save the line in case this is a var like FOO="() "
@end group

# if the next line has a brace, we quit because
# nothing comes after functions
/^@{/ q
@end group

# print the old line
x; p
@end group

# work on the new line now
x; bx
@end group
@end example
@c end---------------------------------------------

@node Reverse chars of lines
@c @section Reverse Characters of Lines
@section 行の文字を反転する

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

@c Note the @code{tx} command before the definition of the label.
@c This is often needed to reset the flag that is tested by
@c the @code{t} command.

@c Imaginative readers will find uses for this script.  An example
@c is reversing the output of @command{banner}.@footnote{This requires
@c 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; @}' |
@end example

@c start-------------------------------------------
#!/usr/bin/sed -f

/../! b

# Reverse a line.  Begin embedding the line between two newlines
@end group

# Move first character at the end.  The regexp matches until
# there are zero or one characters between the markers
@end group

# Remove the newline markers
@end group
@end example
@c end---------------------------------------------

@node tac
@c @section Reverse Lines of Files
@section ファイルの行を反転する

@c This one begins a series of totally useless (yet interesting)
@c scripts emulating various Unix commands.  This, in particular,
@c is a @command{tac} workalike.

@c Note that on implementations other than @acronym{GNU} @command{sed}
@acronym{GNU} @command{sed}と@value{SSED}以外の実装では,
@ifset PERL
@c and @value{SSED}
@end ifset
@c this script might easily overflow internal buffers.

@c start-------------------------------------------
#!/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
@end group

# on the last line we're done -- print everything
$ p
@end group

# store everything on the buffer again
@end group
@end example
@c end---------------------------------------------

@node cat -n
@c @section Numbering Lines
@section 行の番号付け

@c This script replaces @samp{cat -n}; in fact it formats its output
@c exactly like @acronym{GNU} @command{cat} does.
以下のスクリプトは@code{cat -n}の置換えです.実際それは,出力を
@acronym{GNU} @code{cat}のように正確に書式化します.

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

@c start-------------------------------------------
#! /bin/sh
sed -e "=" $@@ | sed -e '
  s/^/      /
  s/^ *\(......\)\n/\1  /
@end group
@end example
@c end---------------------------------------------

@c It uses @command{sed} to print the line number, then groups lines two
@c by two using @code{N}.  Of course, this script does not teach as much as
@c the one presented below.

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

@c start-------------------------------------------
#!/usr/bin/sed -nf

# Prime the pump on the first line
/^$/ s/^.*$/1/
@end group

# Add the correct line number before the pattern
@end group

# Format it and print it
s/^/      /
s/^ *\(......\)\n/\1  /p
@end group

# Get the line number from hold space; add a zero
# if we're going to add a digit on the next line
/^9*$/ s/^/0/
@end group

# separate changing/unchanged digits with an x
@end group

# keep changing digits in hold space
@end group

# keep unchanged digits in pattern space
@end group

# compose the new number, remove the newline implicitly added by G
@end group
@end example
@c end---------------------------------------------

@node cat -b
@c @section Numbering Non-blank Lines
@section 空白行以外に番号を付ける

@c Emulating @samp{cat -b} is almost the same as @samp{cat -n}---we only
@c have to select which lines are to be numbered and which are not.
@code{cat -b}のエミュレートは,ほとんど@code{cat -n}と同じです --- 我々

@c The part that is common to this script and the previous one is
@c not commented to show how important it is to comment @command{sed}
@c scripts properly...

@c start-------------------------------------------
#!/usr/bin/sed -nf

/^$/ @{
@end group

# Same as cat -n from now
/^$/ s/^.*$/1/
s/^/      /
s/^ *\(......\)\n/\1  /p
/^9*$/ s/^/0/
@end group
@end example
@c end---------------------------------------------

@node wc -c
@c @section Counting Characters
@section 文字を数える

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

@c The approach is to map numbers to letters, kind of an abacus
@c implemented with @command{sed}.  @samp{a}s are units, @samp{b}s are
@c tenths and so on: we simply add the number of characters
@c on the current line as units, and then propagate the carry
@c to tenths, hundredths, and so on.

@c As usual, running totals are kept in hold space.

@c On the last line, we convert the abacus form back to decimal.
@c For the sake of variety, this is done with a loop rather than
@c with some 80 @code{s} commands@footnote{Some implementations
@c have a limit of 199 commands per script}: first we
@c convert units, removing @samp{a}s from the number; then we
@c rotate letters so that tenths become @samp{a}s, and so on
@c until no more letters remain.

@c start-------------------------------------------
#!/usr/bin/sed -nf

# Add n+1 a's to hold space (+1 is for the newline)
@end group

# 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
@end group

: done
$! @{
@end group

# On the last line, convert back to decimal

: loop
/a/! s/[b-h]*/&0/
@end group

: next
/[a-h]/ b loop
@end group
@end example
@c end---------------------------------------------

@node wc -w
@c @section Counting Words
@section 単語を数える

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

@c It is interesting that real @command{wc} programs have optimized
@c loops for @samp{wc -c}, so they are much slower at counting
@c words rather than characters.  This script's bottleneck,
@c instead, is arithmetic, and hence the word-counting one
@c is faster (it has to manage smaller numbers).
本物の@code{wc}プログラムは@code{wc -c}に対しループが最適化されているの

@c Again, the common parts are not commented to show the importance
@c of commenting @command{sed} scripts.

@c start-------------------------------------------
#!/usr/bin/sed -nf

# Convert words to a's
s/[ @kbd{tab}][ @kbd{tab}]*/ /g
s/^/ /
s/ [^ ][^ ]*/a /g
s/ //g
@end group

# Append them to hold space
@end group

# 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
$! @{ h; b; @}
/a/! s/[b-h]*/&0/
/[a-h]/ by
@end group
@end example
@c end---------------------------------------------

@node wc -l
@c @section Counting Lines
@section 行を数える

@c No strange things are done now, because @command{sed} gives us
@c @samp{wc -l} functionality for free!!! Look:
@command{sed}はに@code{wc -l}の機能があるので,今回はおかしなことを何も
しません!!! まあ見てください.

@c start-------------------------------------------
#!/usr/bin/sed -nf
@end group
@end example
@c end---------------------------------------------

@node head
@c @section Printing the First Lines
@section 最初の行を出力する

@c This script is probably the simplest useful @command{sed} script.
@c It displays the first 10 lines of input; the number of displayed
@c lines is right before the @code{q} command.

@c start-------------------------------------------
#!/usr/bin/sed -f
@end group
@end example
@c end---------------------------------------------

@node tail
@c @section Printing the Last Lines
@section 最後の行を出力する

@c Printing the last @var{n} lines rather than the first is more complex
@c but indeed possible.  @var{n} is encoded in the second line, before
@c the bang character.

@c This script is similar to the @command{tac} script in that it keeps the
@c final output in the hold space and prints it at the end:

@c start-------------------------------------------
#!/usr/bin/sed -nf

1! @{; H; g; @}
1,10 !s/[^\n]*\n//
@end group
@end example
@c end---------------------------------------------

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

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

@c To introduce the technique, which is fully demonstrated in the
@c rest of this chapter and is based on the @code{N}, @code{P}
@c and @code{D} commands, here is an implementation of @command{tail}
@c using a simple ``sliding window.''
ウ' を使用している@code{tail}の実装を以下に上げます.

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

@c start-------------------------------------------
#!/usr/bin/sed -f

2,10 @{; H; g; @}
@end group
@end example
@c end---------------------------------------------

@node uniq
@c @section Make Duplicate Lines Unique
@section 重複した行を一行にする

@c This is an example of the art of using the @code{N}, @code{P}
@c and @code{D} commands, probably the most difficult to master.

@c start-------------------------------------------
#!/usr/bin/sed -f
@end group

# On the last line, print and exit
/^\(.*\)\n\1$/ @{
    # The two lines are identical.  Undo the effect of
    # the n command.
@end group

# If the @code{N} command had added the last line, print and exit
@end group

# The lines are different; print the first and go
# back working on the second.
@end group
@end example
@c end---------------------------------------------

@c As you can see, we mantain a 2-line window using @code{P} and @code{D}.
@c This technique is often used in advanced @command{sed} scripts.

@node uniq -d
@c @section Print Duplicated Lines of Input
@section 入力の重複している行を出力する.

@c This script prints only duplicated lines, like @samp{uniq -d}.
以下のスクリプトは,@code{uniq -d}のように重複している行だけを出力しま

@c start-------------------------------------------
#!/usr/bin/sed -nf

/^\(.*\)\n\1$/ @{
    # Print the first of the duplicated lines
@end group

    # Loop until we get a different line
    /^\(.*\)\n\1$/ @{
@end group

# The last line cannot be followed by duplicates
@end group

# Found a different one.  Leave it alone in the pattern space
# and go back to the top, hunting its duplicates
@end group
@end example
@c end---------------------------------------------

@node uniq -u
@c @section Remove All Duplicated Lines
@section すべての重複行を削除する

@c This script prints only unique lines, like @samp{uniq -u}.
以下のスクリプトは,@code{uniq -u}のようにユニークな行だけを出力します.

@c start-------------------------------------------
#!/usr/bin/sed -f

# Search for a duplicate line --- until that, print what you find.
/^\(.*\)\n\1$/ ! @{
@end group

# Got two equal lines in pattern space.  At the
# end of the file we simply exit
@end group

# Else, we keep reading lines with @code{N} until we
# find a different one
/^\(.*\)\n\1$/ @{
@end group

# Remove the last instance of the duplicate line
# and go back to the top
@end group
@end example
@c end---------------------------------------------

@node cat -s
@c @section Squeezing Blank Lines
@section 空白行をまとめる

@c As a final example, here are three scripts, of increasing complexity
@c and speed, that implement the same function as @samp{cat -s}, that is
@c squeezing blank lines.
最後の例として,空白行をまとめる@code{cat -s}と同じ機能を実装している,

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

@c start-------------------------------------------
#!/usr/bin/sed -f

# on empty lines, join with next
# Note there is a star in the regexp
/^\n*$/ @{
@end group

# now, squeeze all '\n', this can be also done by:
# s/^\(\n\)*/\1/
@end group
@end example
@c end---------------------------------------------

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

@c start-------------------------------------------
#!/usr/bin/sed -f

# delete all leading empty lines
@end group

# on an empty line we remove it and all the following
# empty lines, but one
@end group
@end example
@c end---------------------------------------------

@c This removes leading and trailing blank lines.  It is also the
@c fastest.  Note that loops are completely done with @code{n} and
@c @code{b}, without exploting the fact that @command{sed} cycles back
@c to the top of the script automatically at the end of a line.

@c start-------------------------------------------
#!/usr/bin/sed -nf

# delete all (leading) blanks
@end group

# get here: so there is a non empty
# print it
# get next
# got chars? print it again, etc... 
@end group

# no, don't have chars: got an empty line
# get next, if last line we finish here so no trailing
# empty lines are written
# also empty? then ignore it, and get next... this will
# remove ALL empty lines
@end group

# 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
@end group

@end example
@c end---------------------------------------------

@node Limitations
@c @chapter @value{SSED}'s Limitations and Non-limitations
@chapter @value{SSED}の制限と制限されていないこと

@cindex @acronym{GNU} extensions, unlimited line length
@cindex Portability, line length limitations
@c For those who want to write portable @command{sed} scripts,
@c be aware that some implementations have been known to
@c limit line lengths (for the pattern and hold spaces)
@c to be no more than 4000 bytes.
@c The @sc{posix} standard specifies that conforming @command{sed}
@c implementations shall support at least 8192 byte line lengths.
@c @value{SSED} has no built-in limit on line length;
@c as long as it can @code{malloc()} more (virtual) memory,
@c you can feed or construct lines as long as you like.

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

@ifset PERL
There are some size limitations in the regular expression
matcher but it is hoped that they will never in practice
be relevant.  The maximum length of a compiled pattern
is 65539 (sic) bytes.  All values in repeating quantifiers
must be less than 65536.  The maximum nesting depth of
all parenthesized subpatterns, including capturing and
non-capturing subpatterns@footnote{The
distinction is meaningful when referring to Perl-style
regular expressions.}, assertions, and other types of
subpattern, is 200.

Also, @value{SSED} recognizes the @sc{posix} syntax
@code{[.@var{ch}.]} and @code{[=@var{ch}=]}
where @var{ch} is a ``collating element'', but these
are not supported, and an error is given if they are

Here are a few distinctions between the real Perl-style
regular expressions and those that @option{-R} recognizes.

Lookahead assertions do not allow repeat quantifiers after them
Perl permits them, but they do not mean what you
might think. For example, @samp{(?!a)@{3@}} does not assert that the
next three characters are not @samp{a}. It just asserts three times that the
next character is not @samp{a} --- a waste of time and nothing else.

Capturing subpatterns that occur inside  negative  lookahead
head  assertions  are  counted,  but  their  entries are counted
as empty in the second half of an @code{s} command.
Perl sets its numerical variables from any such patterns
that are matched before the assertion fails to match
something (thereby succeeding), but only if the negative
lookahead assertion contains just one branch.

The following Perl escape sequences are not supported:
@samp{\l}, @samp{\u}, @samp{\L}, @samp{\U}, @samp{\E},
@samp{\Q}. In fact these are implemented by Perl's general
string-handling and are not part of its pattern matching engine.

The Perl @samp{\G} assertion is not supported as it is not
relevant to single pattern matches.

Fairly obviously, @value{SSED} does not support the @samp{(?@{code@})}
and @samp{(?p@{code@})} constructions. However, there is some experimental
support for recursive patterns using the non-Perl item @samp{(?R)}.

There are at the time of writing some oddities in Perl
5.005_02 concerned with the settings of captured strings
when part of a pattern is repeated. For example, matching
@samp{aba} against the pattern @samp{/^(a(b)?)+$/} sets
@samp{$2}@footnote{@samp{$2} would be @samp{\2} in @value{SSED}.}
to the value @samp{b}, but matching @samp{aabbaa}
against @samp{/^(aa(bb)?)+$/} leaves @samp{$2}
unset.  However, if the pattern is changed to
@samp{/^(aa(b(b))?)+$/} then @samp{$2} (and @samp{$3}) are set.
In Perl 5.004 @samp{$2} is set in both cases, and that is also
true of @value{SSED}.

Another as yet unresolved discrepancy is that in Perl
5.005_02 the pattern @samp{/^(a)?(?(1)a|b)+$/} matches
the string @samp{a}, whereas in @value{SSED} it does not.
However, in both Perl and @value{SSED} @samp{/^(a)?a/} matched
against @samp{a} leaves $1 unset.
@end enumerate
@end ifset

@node Other Resources
@c @chapter Other Resources for Learning About @command{sed}
@chapter @command{sed}を学ぶ際のその他の情報源

@cindex Additional reading about @command{sed}
@c In addition to several books that have been written about @command{sed}
@c (either specifically or as chapters in books which discuss
@c shell programming), one can find out more about @command{sed}
@c (including suggestions of a few books) from the FAQ
@c for the @code{sed-users} mailing list, available from any of:

@end display

@c Also of interest are
@c @uref{}
@c and @uref{},
@c which include @command{sed} tutorials and other @command{sed}-related goodies.

@c The @code{sed-users} mailing list itself maintained by Sven Guckes.
@c To subscribe, visit @uref{} and search
@c for the @code{sed-users} mailing list.
Sven Guckesが管理している非公式の``sed-users''のメーリングリストがあり

@node Reporting Bugs
@c @chapter Reporting Bugs
@chapter バグの報告

@cindex Bugs, reporting
@c Email bug reports to @email{}.
@c Be sure to include the word ``sed'' somewhere in the @code{Subject:} field.
@c Also, please include the output of @samp{sed --version} in the body
@c of your report if at all possible.
可能であれば,報告の内容に@code{sed --version}の出力も含めてください.

@c Please do not send a bug report like this:

@i{while building frobme-1.3.4}
$ configure 
@error{} sed: file sedscr line 1: Unknown option to 's'
@end example

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

@c A stand-alone test case includes all the data necessary to perform the
@c test, and the specific invocation of @command{sed} that causes the problem.
@c The smaller a stand-alone test case is, the better.  A test case should
@c not involve something as far removed from @command{sed} as ``try to configure
@c frobme-1.3.4''.  Yes, that is in principle enough information to look
@c for the bug, but that is not a very practical prospect.
@command{sed} からかけ離れているものを必要とすべきではありません.そう

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

@table @asis
@c @item @code{N} command on the last line
@item 最後の行の@code{N}コマンド
@cindex Portability, @code{N} command on the last line
@cindex Non-bugs, @code{N} command on the last line

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

@c For example, the behavior of
sed N foo bar
@end example
@c would depend on whether foo has an even or an odd number of
@c lines@footnote{which is the actual ``bug'' that prompted the
@c change in behavior}.  Or, when writing a script to read the
@c next few lines following a pattern match, traditional
@c implementations of @command{sed} would force you to write
@c something like

/foo/@{ $!N; $!N; $!N; $!N; $!N; $!N; $!N; $!N; $!N @}
@end example
@c instead of just
/foo/@{ N;N;N;N;N;N;N;N;N; @}
@end example
@cindex @code{POSIXLY_CORRECT} behavior, @code{N} command
@c In any case, the simplest workaround is to use @code{$d;N} in
@c scripts that rely on the traditional behavior, or to set
@c the @code{POSIXLY_CORRECT} variable to a non-empty value.

@c @item Regex syntax clashes
@item 正規表現の構文の破壊
@cindex @acronym{GNU} extensions, to basic regular expressions
@cindex Non-bugs, regex syntax clashes
@c @command{sed} uses the @sc{posix} basic regular expression syntax.  According to
@c the standard, the meaning of some escape sequences is undefined in
@c this syntax;  notable in the case of @command{sed} are @code{\|},
@c @code{\+}, @code{\?}, @code{\`}, @code{\'}, @code{\<},
@c @code{\>}, @code{\b}, @code{\B}, @code{\w}, and @code{\W}.

@c As in all GNU programs that use @sc{posix} basic regular expressions, @command{sed}
@c interprets these escape sequences as special characters.  So, @code{x\+}
@c matches one or more occurrences of @samp{x}.  @code{abc\|def} matches
@c either @samp{abc} or @samp{def}.

@c This syntax may cause problems when running scripts written for other
@c @command{sed}s.  Some @command{sed} programs have been written with the
@c assumption that @code{\|} and @code{\+} match the literal characters
@c @code{|} and @code{+}.  Such scripts must be modified by removing the
@c spurious backslashes if they are to be used with modern implementations
@c of @command{sed}, like
@ifset PERL
@c @value{SSED} or
@end ifset
@c @acronym{GNU} @command{sed}.
@acronym{GNU} @command{sed}のような近代的な@command{sed}を実装している

@cindex @acronym{GNU} extensions, special escapes
@c In addition, this version of @command{sed} supports several escape characters
@c (some of which are multi-character) to insert non-printable characters
@c in scripts (@code{\a}, @code{\c}, @code{\d}, @code{\o}, @code{\r},
@c @code{\t}, @code{\v}, @code{\x}).  These can cause similar problems
@c with scripts written for other @command{sed}s.

@c @item @option{-i} clobbers read-only files
@item @code{-i}で読み込み専用のファイルを破壊する
@cindex In-place editing
@cindex @value{SSEDEXT}, in-place editing
@cindex Non-bugs, in-place editing

@c In short, @samp{sed -i} will let you delete the contents of
@c a read-only file, and in general the @option{-i} option
@c (@pxref{Invoking sed, , Invocation}) lets you clobber
@c protected files.  This is not a bug, but rather a consequence
@c of how the Unix filesystem works.
手短に言うと,@code{sed d -i}では読み取り専用のファイルの内容を削除し,
一般的に@code{-i}オプション((@pxref{Invoking sed, , Invocation})では保

@c The permissions on a file say what can happen to the data
@c in that file, while the permissions on a directory say what can
@c happen to the list of files in that directory.  @samp{sed -i}
@c will not ever open for writing  a file that is already on disk.
@c Rather, it will work on a temporary file that is finally renamed
@c to the original name: if you rename or delete files, you're actually
@c modifying the contents of the directory, so the operation depends on
@c the permissions of the directory, not of the file.  For this same
@c reason, @command{sed} does not let you use @option{-i} on a writeable file
@c in a read-only directory (but unbelievably nobody reports that as a
@c bug@dots{}).
があることを告げています.@code{sed -i}は書き込み属性でディスクに存在し

@c @item @code{0a} does not work (gives an error)
@item @code{0a}は動作しません(エラーになります)
@c There is no line 0.  0 is a special address that is only used to treat
@c addresses like @samp{0,/@var{RE}/} as active when the script starts: if
@c you write @samp{1,/abc/d} and the first line includes the word @samp{abc},
@c then that match would be ignored because address ranges must span at least
@c two lines (barring the end of the file); but what you probably wanted is
@c to delete every line up to the first one including @samp{abc}, and this
@c is obtained with @samp{0,/abc/d}.
@samp{1,/abc/d} と書き,最初の行に単語@samp{abc}が含まれている場合,ア
@end table

@node Extended regexps
@c @appendix Extended regular expressions
@appendix 拡張正規表現
@cindex Extended regular expressions, syntax

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

@c Examples:
@table @code
@item abc?
@c becomes @samp{abc\?} when using extended regular expressions.  It matches
@c the literal string @samp{abc?}.

@item c\+
@c becomes @samp{c+} when using extended regular expressions.  It matches
@c one or more @samp{c}s.

@item a\@{3,\@}
@c becomes @samp{a@{3,@}} when using extended regular expressions.  It matches
@c three or more @samp{a}s.

@item \(abc\)\@{2,3\@}
@c becomes @samp{(abc)@{2,3@}} when using extended regular expressions.  It
@c matches either @samp{abcabc} or @samp{abcabcabc}.

@item \(abc*\)\1
@c becomes @samp{(abc*)\1} when using extended regular expressions.
@c Backreferences must still be escaped when using extended regular
@c expressions.
@end table

@ifset PERL
@node Perl regexps
@c @appendix Perl-style regular expressions
@appendix Perl形式の正規表現
@cindex Perl-style regular expressions, syntax

@emph{This part is taken from the @file{pcre.txt} file distributed together
with the free @sc{pcre} regular expression matcher; it was written by Philip Hazel.}

Perl introduced several extensions to regular expressions, some
of them incompatible with the syntax of regular expressions
accepted by Emacs and other @acronym{GNU} tools (whose matcher was
based on the Emacs matcher).  @value{SSED} implements
both kinds of extensions.

Summarizing, we have:

@itemize @bullet
A backslash can introduce several special sequences

The circumflex, dollar sign, and period characters behave specially 
with regard to new lines

Strange uses of square brackets are parsed differently

You can toggle modifiers in the middle of a regular expression

You can specify that a subpattern does not count when numbering backreferences

@cindex Greedy regular expression matching
You can specify greedy or non-greedy matching

You can have more than ten back references

You can do complex look aheads and look behinds (in the spirit of
@code{\b}, but with subpatterns).

You can often improve performance by avoiding that @command{sed} wastes
time with backtracking

You can have if/then/else branches

You can do recursive matches, for example to look for unbalanced parentheses

You can have comments and non-significant whitespace, because things can
get complex...
@end itemize

Most of these extensions are introduced by the special @code{(?}
sequence, which gives special meanings to parenthesized groups.
@end iftex
Other extensions can be roughly subdivided in two categories
On one hand Perl introduces several more escaped sequences
(that is, sequences introduced by a backslash).  On the other
hand, it specifies that if a question mark follows an open
parentheses it should give a special meaning to the parenthesized

* Backslash::                       Introduces special sequences
* Circumflex/dollar sign/period::   Behave specially with regard to new lines
* Square brackets::                 Are a bit different in strange cases
* Options setting::                 Toggle modifiers in the middle of a regexp
* Non-capturing subpatterns::       Are not counted when backreferencing
* Repetition::                      Allows for non-greedy matching
* Backreferences::                  Allows for more than 10 back references
* Assertions::                      Allows for complex look ahead matches
* Non-backtracking subpatterns::    Often gives more performance
* Conditional subpatterns::         Allows if/then/else branches
* Recursive patterns::              For example to match parentheses
* Comments::                        Because things can get complex...
@end menu

@node Backslash
@c @appendixsec Backslash
@appendixsec バックスラッシュ
@cindex Perl-style regular expressions, escaped sequences

There are a few difference in the handling of backslashed 
sequences in Perl mode.

First of all, there are no @code{\o} and @code{\d} sequences.
@sc{ascii} values for characters can be specified in octal
with a @code{\@var{xxx}} sequence, where @var{xxx} is a
sequence of up to three octal digits.  If the first digit
is a zero, the treatment of the sequence is straightforward;
just note that if the character that follows the escaped digit
is itself an octal digit, you have to supply three octal digits
for @var{xxx}.  For example @code{\07} is a @sc{bel} character
rather than a @sc{nul} and a literal @code{7} (this sequence is
instead represented by @code{\0007}).

@cindex Perl-style regular expressions, backreferences
The handling of a backslash followed by a digit other than 0
is complicated.  Outside a character class, @command{sed} reads it
and any following digits as a decimal number. If the number
is less than 10, or if there have been at least that many
previous capturing left parentheses in the expression, the
entire sequence is taken as a back reference. A description
of how this works is given later, following the discussion
of parenthesized subpatterns.

Inside a character class, or if the decimal number is
greater than 9 and there have not been that many capturing
subpatterns, @command{sed} re-reads up to three octal digits following
the backslash, and generates a single byte from the
least significant 8 bits of the value. Any subsequent digits
stand for themselves.  For example:

     \040  @i{is another way of writing a space}
     \40   @i{is the same, provided there are fewer than 40}
           @i{previous capturing subpatterns}
     \7    @i{is always a back reference}
     \011  @i{is always a tab}
     \11   @i{might be a back reference, or another way of}
           @i{writing a tab}
     \0113 @i{is a tab followed by the character @samp{3}}
     \113  @i{is the character with octal code 113 (since there}
           @i{can be no more than 99 back references)}
     \377  @i{is a byte consisting entirely of 1 bits (@sc{ascii} 255)}
     \81   @i{is either a back reference, or a binary zero}
           @i{followed by the two characters @samp{81}}
@end example

Note that octal values of 100 or greater must not be introduced
duced by a leading zero, because no more than three octal
digits are ever read.

All the sequences that define a single byte value can be
used both inside and outside character classes. In addition,
inside a character class, the sequence @code{\b} is interpreted
as the backspace character (hex 08). Outside a character
class it has a different meaning (see below).

In addition, there are four additional escapes specifying
generic character classes (like @code{\w} and @code{\W} do):

@cindex Perl-style regular expressions, character classes
@table @samp
@item \d
Matches any decimal digit

@item \D
Matches any character that is not a decimal digit
@end table

In Perl mode, these character type sequences can appear both inside and
outside character classes. Instead, in @sc{posix} mode these sequences
(as well as @code{\w} and @code{\W}) are treated as two literal characters
(a backslash and a letter) inside square brackets.

Escaped sequences specifying assertions are also different in
Perl mode.  An assertion specifies a condition that has to be met
at a particular point in a match, without consuming any
characters from the subject string. The use of subpatterns
for more complicated assertions is described below.  The
backslashed assertions are

@cindex Perl-style regular expressions, assertions
@table @samp
@item \b
Asserts that the point is at a word boundary.
A word boundary is a position in the subject string where
the current character and the previous character do not both
match @code{\w} or @code{\W} (i.e. one matches @code{\w} and
the other matches @code{\W}), or the start or end of the string
if the first or last character matches @code{\w}, respectively.

@item \B
Asserts that the point is not at a word boundary.

@item \A
Asserts the matcher is at the start of pattern space (independent
of multiline mode).

@item \Z
Asserts the matcher is at the end of pattern space,
or at a newline before the end of pattern space (independent of
multiline mode)

@item \z
Asserts the matcher is at the end of pattern space (independent
of multiline mode)
@end table

These assertions may not appear in character classes (but
note that @code{\b} has a different meaning, namely the
backspace character, inside a character class).
Note that Perl mode does not support directly assertions
for the beginning and the end of word; the @acronym{GNU} extensions
@code{\<} and @code{\>} achieve this purpose in @sc{posix} mode

The @code{\A}, @code{\Z}, and @code{\z} assertions differ
from the traditional circumflex and dollar sign (described below)
in that they only ever match at the very start and end of the
subject string, whatever options are set; in particular @code{\A}
and @code{\z} are the same as the @acronym{GNU} extensions
@code{\`} and @code{\'} that are active in @sc{posix} mode.

@node Circumflex/dollar sign/period
@appendixsec Circumflex, dollar sign, period
@cindex Perl-style regular expressions, newlines

Outside a character class, in the default matching mode, the
circumflex character is an assertion which is true only if
the current matching point is at the start of the subject
string.  Inside a character class, the circumflex has an entirely
different meaning (see below).

The circumflex need not be the first character of the pattern if
a number of alternatives are involved, but it should be the
first thing in each alternative in which it appears if the
pattern is ever to match that branch. If all possible alternatives,
start with a circumflex, that is, if the pattern is
constrained to match only at the start of the subject, it is
said to be an @dfn{anchored} pattern. (There are also other constructs
structs that can cause a pattern to be anchored.)

A dollar sign is an assertion which is true only if the
current matching point is at the end of the subject string,
or immediately before a newline character that is the last
character in the string (by default).  A dollar sign need not be the
last character of the pattern if a number of alternatives
are involved, but it should be the last item in any branch
in which it appears.  A dollar sign has no special meaning in a
character class.

@cindex Perl-style regular expressions, multiline
The meanings of the circumflex and dollar sign characters are
changed if the @code{M} modifier option is used. When this is
the case, they match immediately after and immediately
before an internal @code{\n} character, respectively, in addition
to matching at the start and end of the subject string.  For
example, the pattern @code{/^abc$/} matches the subject string
@samp{def\nabc} in multiline mode, but not otherwise.  Consequently,
patterns that are anchored in single line mode
because all branches start with @code{^} are not anchored in
multiline mode.

@cindex Perl-style regular expressions, multiline
Note that the sequences @code{\A}, @code{\Z}, and @code{\z}
can be used to match the start and end of the subject in both
modes, and if all branches of a pattern start with @code{\A}
is it always anchored, whether the @code{M} modifier is set or not.

@cindex Perl-style regular expressions, single line
Outside a character class, a dot in the pattern matches any
one character in the subject, including a non-printing character,
but not (by default) newline.  If the @code{S} modifier is used,
dots match newlines as well.  Actually, the handling of
dot is entirely independent of the handling of circumflex
and dollar sign, the only relationship being that they both
involve newline characters. Dot has no special meaning in a
character class.

@node Square brackets
@appendixsec Square brackets
@cindex Perl-style regular expressions, character classes

An opening square bracket introduces a character class, terminated
by a closing square bracket.  A closing square bracket on its own
is not special.  If a closing square bracket is required as a
member of the class, it should be the first data character in
the class (after an initial circumflex, if present) or escaped with a backslash.

A character class matches a single character in the subject;
the character must be in the set of characters defined by
the class, unless the first character in the class is a circumflex,
in which case the subject character must not be in
the set defined by the class. If a circumflex is actually
required as a member of the class, ensure it is not the
first character, or escape it with a backslash.

For example, the character class [aeiou] matches any lower
case vowel, while [^aeiou] matches any character that is not
a lower case vowel. Note that a circumflex is just a convenient
venient notation for specifying the characters which are in
the class by enumerating those that are not. It is not an
assertion: it still consumes a character from the subject
string, and fails if the current pointer is at the end of
the string.

@cindex Perl-style regular expressions, case-insensitive
When caseless matching is set, any letters in a class
represent both their upper case and lower case versions, so
for example, a caseless @code{[aeiou]} matches uppercase
and lowercase @samp{A}s, and a caseless @code{[^aeiou]}
does not match @samp{A}, whereas a case-sensitive version would.

@cindex Perl-style regular expressions, single line
@cindex Perl-style regular expressions, multiline
The newline character is never treated in any special way in
character classes, whatever the setting of the @code{S} and
@code{M} options (modifiers) is.  A class such as @code{[^a]} will
always match a newline.

The minus (hyphen) character can be used to specify a range
of characters in a character class.  For example, @code{[d-m]}
matches any letter between d and m, inclusive.  If a minus
character is required in a class, it must be escaped with a
backslash or appear in a position where it cannot be interpreted
as indicating a range, typically as the first or last
character in the class.

It is not possible to have the literal character @code{]} as the
end character of a range.  A pattern such as @code{[W-]46]} is
interpreted as a class of two characters (@code{W} and @code{-})
followed by a literal string @code{46]}, so it would match
@samp{W46]} or @samp{-46]}. However, if the @code{]} is escaped
with a backslash it is interpreted as the end of range, so
@code{[W-\]46]} is interpreted as a single class containing a
range followed by two separate characters. The octal or
hexadecimal representation of @code{]} can also be used to end a range.

Ranges operate in @sc{ascii} collating sequence. They can also be
used for characters specified numerically, for example
@code{[\000-\037]}. If a range that includes letters is used when
caseless matching is set, it matches the letters in either
case. For example, a caseless @code{[W-c]} is equivalent to
@code{[][\^_`wxyzabc]}, matched caselessly, and if character
tables for the French locale are in use, @code{[\xc8-\xcb]}
matches accented E characters in both cases.

Unlike in @sc{posix} mode, the character types @code{\d},
@code{\D}, @code{\s}, @code{\S}, @code{\w}, and @code{\W}
may also appear in a character class, and add the characters
that they match to the class. For example, @code{[\dABCDEF]} matches any
hexadecimal digit.  A circumflex can conveniently be used
with the upper case character types to specify a more restricted
set of characters than the matching lower case type.
For example, the class @code{[^\W_]} matches any letter or digit,
but not underscore.

All non-alphameric characters other than @code{\}, @code{-},
@code{^} (at the start) and the terminating @code{]}
are non-special in character classes, but it does no harm
if they are escaped.

Perl 5.6 supports the @sc{posix} notation for character classes, which
uses names enclosed by @code{[:} and @code{:]} within the enclosing
square brackets, and @value{SSED} supports this notation as well.
For example,

@end example

matches @samp{0}, @samp{1}, any alphabetic character, or @samp{%}.
The supported class names are

@table @code
@item alnum
Matches letters and digits

@item alpha
Matches letters

@item ascii
Matches character codes 0 - 127

@item cntrl
Matches control characters

@item digit
Matches decimal digits (same as \d)

@item graph
Matches printing characters, excluding space

@item lower
Matches lower case letters

@item print
Matches printing characters, including space

@item punct
Matches printing characters, excluding letters and digits

@item space
Matches white space (same as \s)

@item upper
Matches upper case letters

@item word
Matches ``word'' characters (same as \w)

@item xdigit
Matches hexadecimal digits
@end table

The names @code{ascii} and @code{word} are extensions valid only in
Perl mode.  Another Perl extension is negation, which is
indicated by a circumflex character after the colon. For example,

@end example

matches @samp{1}, @samp{2}, or any non-digit.

@node Options setting
@appendixsec Options setting
@cindex Perl-style regular expressions, toggling options
@cindex Perl-style regular expressions, case-insensitive
@cindex Perl-style regular expressions, multiline
@cindex Perl-style regular expressions, single line
@cindex Perl-style regular expressions, extended

The settings of the @code{I}, @code{M}, @code{S}, @code{X}
modifiers can be changed from within the pattern by
a sequence of Perl option letters enclosed between @code{(?}
and @code{)}. The option letters must be lowercase.

For example, @code{(?im)} sets caseless, multiline matching. It is
also possible to unset these options by preceding the letter
with a hyphen; you can also have combined settings and unsettings:
@code{(?im-sx)} sets caseless and multiline matching,
while unsets single line matching (for dots) and extended
whitespace interpretation.  If a letter appears both before
and after the hyphen, the option is unset.

The scope of these option changes depends on where in the
pattern the setting occurs. For settings that are outside
any subpattern (defined below), the effect is the same as if
the options were set or unset at the start of matching. The
following patterns all behave in exactly the same way:

@end example

which in turn is the same as specifying the pattern abc with
the @code{I} modifier.  In other words, ``top level'' settings
apply to the whole pattern (unless there are other
changes inside subpatterns). If there is more than one setting
of the same option at top level, the rightmost setting
is used.

If an option change occurs inside a subpattern, the effect
is different.  This is a change of behaviour in Perl 5.005.
An option change inside a subpattern affects only that part
of the subpattern @emph{that follows} it, so

@end example

matches abc and aBc and no other  strings  (assuming
case-sensitive matching is used).  By this means, options can
be made to have different settings in different parts of the
pattern.  Any changes made in one alternative do carry on
into subsequent branches within the same subpattern.  For

@end example

matches @samp{ab}, @samp{aB}, @samp{c}, and @samp{C},
even though when matching @samp{C} the first branch is
abandoned before the option setting.
This is because the effects of option settings happen at
compile time. There would be some very weird behaviour otherwise.

There are two PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA
that can be changed in the same way as the Perl-compatible options by
using the characters U and X respectively.  The (?X) flag
setting is special in that it must always occur earlier in
the pattern than any of the additional features it turns on,
even when it is at top level. It is best put at the start.
@end ignore

@node Non-capturing subpatterns
@appendixsec Non-capturing subpatterns
@cindex Perl-style regular expressions, non-capturing subpatterns

Marking part of a pattern as a subpattern does two things.
On one hand, it localizes a set of alternatives; on the other
hand, it sets up the subpattern as a capturing subpattern (as
defined above).  The subpattern can be backreferenced and
referenced in the right side of @code{s} commands.

For example, if the string @samp{the red king} is matched against
the pattern

     the ((red|white) (king|queen))
@end example

the captured substrings are @samp{red king}, @samp{red},
and @samp{king}, and are numbered 1, 2, and 3.

The fact that plain parentheses fulfil two functions is not
always helpful.  There are often times when a grouping
subpattern is required without a capturing requirement.  If an
opening parenthesis is followed by @code{?:}, the subpattern does
not do any capturing, and is not counted when computing the
number of any subsequent capturing subpatterns. For example,
if the string @samp{the white queen} is matched against the pattern

     the ((?:red|white) (king|queen))
@end example

the captured substrings are @samp{white queen} and @samp{queen},
and are numbered 1 and 2. The maximum number of captured
substrings is 99, while the maximum number of all subpatterns,
both capturing and non-capturing, is 200.

As a convenient shorthand, if any option settings are
equired at the start of a non-capturing subpattern, the
option letters may appear between the @code{?} and the
@code{:}.  Thus the two patterns

@end example

match exactly the same set of strings.  Because alternative
branches are tried from left to right, and options are not
reset until the end of the subpattern is reached, an option
setting in one branch does affect subsequent branches, so
the above patterns match @samp{SUNDAY} as well as @samp{Saturday}.

@node Repetition
@appendixsec Repetition
@cindex Perl-style regular expressions, repetitions

Repetition is specified by quantifiers, which can follow any
of the following items:

@itemize @bullet
a single character, possibly escaped

the @code{.} special character

a character class

a back reference (see next section)

a parenthesized subpattern (unless it is an assertion; @pxref{Assertions})
@end itemize

The general repetition quantifier specifies a minimum and
maximum number of permitted matches, by giving the two
numbers in curly brackets (braces), separated by a comma.
The numbers must be less than 65536, and the first must be
less than or equal to the second. For example:

@end example

matches @samp{zz}, @samp{zzz}, or @samp{zzzz}. A closing brace on its own
is not a special character. If the second number is omitted,
but the comma is present, there is no upper limit; if the
second number and the comma are both omitted, the quantifier
specifies an exact number of required matches. Thus

@end example

matches at least 3 successive vowels, but may match many
more, while

@end example

matches exactly 8 digits.  An opening curly bracket that
appears in a position where a quantifier is not allowed, or
one that does not match the syntax of a quantifier, is taken
as a literal character. For example, @{,6@} is not a quantifier,
but a literal string of four characters.@footnote{It
raises an error if @option{-R} is not used.}

The quantifier @samp{@{0@}} is permitted, causing the expression to
behave as if the previous item and the quantifier were not

For convenience (and historical compatibility) the three
most common quantifiers have single-character abbreviations:

@table @code
@item *
is equivalent to @{0,@}

@item +
is equivalent to @{1,@}

@item ?
is equivalent to @{0,1@}
@end table

It is possible to construct infinite loops by following a
subpattern that can match no characters with a quantifier
that has no upper limit, for example:

@end example

Earlier versions of Perl used to give an error at
compile time for such patterns. However, because there are
cases where this can be useful, such patterns are now
accepted, but if any repetition of the subpattern does in
fact match no characters, the loop is forcibly broken.

@cindex Greedy regular expression matching
@cindex Perl-style regular expressions, stingy repetitions
By default, the quantifiers are @dfn{greedy} like in @sc{posix}
mode, that is, they match as much as possible (up to the maximum
number of permitted times), without causing the rest of the
pattern to fail. The classic example of where this gives problems
is in trying to match comments in C programs. These appear between
the sequences @code{/*} and @code{*/} and within the sequence, individual
@code{*} and @code{/} characters may appear. An attempt to match C
comments by applying the pattern

@end example

to the string

     /* first command */ not comment /* second comment */
@end example


fails, because it matches the entire string owing to the
greediness of the @code{.*} item.

However, if a quantifier is followed by a question mark, it
ceases to be greedy, and instead matches the minimum number
of times possible, so the pattern @code{/\*.*?\*/}
does the right thing with the C comments. The meaning of the
various quantifiers is not otherwise changed, just the preferred
number of matches.  Do not confuse this use of question
mark with its use as a quantifier in its own right.
Because it has two uses, it can sometimes appear doubled, as in

@end example

which matches one digit by preference, but can match two if
that is the only way the rest of the pattern matches.

Note that greediness does not matter when specifying addresses,
but can be nevertheless used to improve performance.

   If the PCRE_UNGREEDY option is set (an option which is not
   available in Perl), the quantifiers are not greedy by
   default, but individual ones can be made greedy by following
   them with a question mark. In other words, it inverts the
   default behaviour.
@end ignore

When a parenthesized subpattern is quantified with a minimum
repeat count that is greater than 1 or with a limited maximum,
more store is required for the compiled pattern, in
proportion to the size of the minimum or maximum.

@cindex Perl-style regular expressions, single line
If a pattern starts with @code{.*} or @code{.@{0,@}} and the
@code{S} modifier is used, the pattern is implicitly anchored,
because whatever follows will be tried against every character
position in the subject string, so there is no point in
retrying the overall match at any position after the first.
PCRE treats such a pattern as though it were preceded by \A.

When a capturing subpattern is repeated, the value captured
is the substring that matched the final iteration. For example,

@end example

has matched @samp{tweedledum tweedledee} the value of the
captured substring is @samp{tweedledee}.  However, if there are
nested capturing subpatterns, the corresponding captured
values may have been set in previous iterations. For example,

@end example

matches @samp{aba}, the value of the second captured substring is

@node Backreferences
@appendixsec Backreferences
@cindex Perl-style regular expressions, backreferences

Outside a character class, a backslash followed by a digit
greater than 0 (and possibly further digits) is a back
reference to a capturing subpattern earlier (i.e.  to its
left) in the pattern, provided there have been that many
previous capturing left parentheses.

However, if the decimal number following the backslash is
less than 10, it is always taken as a back reference, and
causes an error only if there are not that many capturing
left parentheses in the entire pattern. In other words, the
parentheses that are referenced need not be to the left of
the reference for numbers less than 10. @ref{Backslash}
for further details of the handling of digits following a backslash.

A back reference matches whatever actually matched the capturing
subpattern in the current subject string, rather than
anything matching the subpattern itself. So the pattern

     (sens|respons)e and \1ibility
@end example

matches @samp{sense and sensibility} and @samp{response and responsibility},
but not @samp{sense and responsibility}. If caseful
matching is in force at the time of the back reference, the
case of letters is relevant. For example,

@end example

matches @samp{blah blah} and @samp{Blah Blah}, but not
@samp{BLAH blah}, even though the original capturing
subpattern is matched caselessly.

There may be more than one back reference to the same subpattern.
Also, if a subpattern has not actually been used in a
particular match, any back references to it always fail. For
example, the pattern

@end example

always fails if it starts to match @samp{a} rather than
@samp{bc}.  Because there may be up to 99 back references, all
digits following the backslash are taken as part of a potential
back reference number; this is different from what happens
in @sc{posix} mode. If the pattern continues with a digit
character, some delimiter must be used to terminate the back
reference.  If the @code{X} modifier option is set, this can be
whitespace.  Otherwise an empty comment can be used, or the
following character can be expressed in hexadecimal or octal.

A back reference that occurs inside the parentheses to which
it refers fails when the subpattern is first used, so, for
example, @code{(a\1)} never matches.  However, such references
can be useful inside repeated subpatterns. For example, the

@end example

matches any number of @samp{a}s and also @samp{aba}, @samp{ababbaa},
etc. At each iteration of the subpattern, the back reference matches
the character string corresponding to the previous iteration.  In
order for this to work, the pattern must be such that the first
iteration does not need to match the back reference.  This can be
done using alternation, as in the example above, or by a
quantifier with a minimum of zero.

@node Assertions
@appendixsec Assertions
@cindex Perl-style regular expressions, assertions
@cindex Perl-style regular expressions, asserting subpatterns

An assertion is a test on the characters following or
preceding the current matching point that does not actually
consume any characters. The simple assertions coded as @code{\b},
@code{\B}, @code{\A}, @code{\Z}, @code{\z}, @code{^} and @code{$}
are described above. More complicated assertions are coded as
subpatterns.  There are two kinds: those that look ahead of the
current position in the subject string, and those that look behind it.

@cindex Perl-style regular expressions, lookahead subpatterns
An assertion subpattern is matched in the normal way, except
that it does not cause the current matching position to be
changed. Lookahead assertions start with @code{(?=} for positive
assertions and @code{(?!} for negative assertions. For example,

@end example

matches a word followed by a semicolon, but does not include
the semicolon in the match, and

@end example

matches any occurrence of @samp{foo} that is not followed by

Note that the apparently similar pattern

@end example

@cindex Perl-style regular expressions, lookbehind subpatterns
finds any occurrence of @samp{bar} even if it is preceded by
@samp{foo}, because the assertion @code{(?!foo)} is always true
when the next three characters are @samp{bar}. A lookbehind
assertion is needed to achieve this effect.
Lookbehind assertions start with @code{(?<=} for positive
assertions and @code{(?<!} for negative assertions. So,

@end example

achieves the required effect of finding an occurrence of
@samp{bar} that is not preceded by @samp{foo}. The contents of a
lookbehind assertion are restricted
such that all the strings it matches must have a fixed
length.  However, if there are several alternatives, they do
not all have to have the same fixed length.  This is an extension
compared with Perl 5.005, which requires all branches to match
the same length of string. Thus

@end example

is permitted, but the apparently equivalent regular expression

@end example

causes an error at compile time. Branches that match different
length strings are permitted only at the top level of
a lookbehind assertion: an assertion such as

@end example

is not permitted, because its single top-level branch can
match two different lengths, but it is acceptable if rewritten
to use two top-level branches:

@end example

All this is required because lookbehind assertions simply
move the current position back by the alternative's fixed
width and then try to match.  If there are
insufficient characters before the current position, the
match is deemed to fail.  Lookbehinds, in conjunction with
non-backtracking subpatterns can be particularly useful for
matching at the ends of strings; an example is given at the end
of the section on non-backtracking subpatterns.

Several assertions (of any sort) may occur in succession.
For example,

@end example

matches @samp{foo} preceded by three digits that are not @samp{999}.
Notice that each of the assertions is applied independently
at the same point in the subject string. First there is a
check that the previous three characters are all digits, and
then there is a check that the same three characters are not
@samp{999}.  This pattern does not match @samp{foo} preceded by six
characters, the first of which are digits and the last three
of which are not @samp{999}.  For example, it doesn't match
@samp{123abcfoo}. A pattern to do that is

@end example

This time the first assertion looks at the preceding six
characters, checking that the first three are digits, and
then the second assertion checks that the preceding three
characters are not @samp{999}.  Actually, assertions can be
nested in any combination, so one can write this as 

@end example


@end example

both of which might be considered more readable.

Assertion subpatterns are not capturing subpatterns, and may
not be repeated, because it makes no sense to assert the
same thing several times. If any kind of assertion contains
capturing subpatterns within it, these are counted for the
purposes of numbering the capturing subpatterns in the whole
pattern.  However, substring capturing is carried out only
for positive assertions, because it does not make sense for
negative assertions.

Assertions count towards the maximum of 200 parenthesized

@node Non-backtracking subpatterns
@appendixsec Non-backtracking subpatterns
@cindex Perl-style regular expressions, non-backtracking subpatterns

With both maximizing and minimizing repetition, failure of
what follows normally causes the repeated item to be evaluated
again to see if a different number of repeats allows the
rest of the pattern to match. Sometimes it is useful to
prevent this, either to change the nature of the match, or
to cause it fail earlier than it otherwise might, when the
author of the pattern knows there is no point in carrying

Consider, for example, the pattern @code{\d+foo} when applied to
the subject line

@end example

After matching all 6 digits and then failing to match @samp{foo},
the normal action of the matcher is to try again with only 5
digits matching the @code{\d+} item, and then with 4, and so on,
before ultimately failing. Non-backtracking subpatterns
provide the means for specifying that once a portion of the
pattern has matched, it is not to be re-evaluated in this way,
so the matcher would give up immediately on failing to match
@samp{foo} the first time.  The notation is another kind of special
parenthesis, starting with @code{(?>} as in this example:

@end example

This kind of parenthesis ``locks up'' the part of the pattern
it contains once it has matched, and a failure further into
the pattern is prevented from backtracking into it.
Backtracking past it to previous items, however, works as

Non-backtracking subpatterns are not capturing subpatterns.  Simple
cases such as the above example can be thought of as a maximizing
repeat that must swallow everything it can.  So,
while both @code{\d+} and @code{\d+?} are prepared to adjust the number of
digits they match in order to make the rest of the pattern
match, @code{(?>\d+)} can only match an entire sequence of digits.

This construction can of course contain arbitrarily complicated
subpatterns, and it can be nested.

@cindex Perl-style regular expressions, lookbehind subpatterns
Non-backtracking subpatterns can be used in conjunction with look-behind
assertions to specify efficient matching at the end
of the subject string. Consider a simple pattern such as

@end example

when applied to a long string which does not match.  Because
matching proceeds from left to right, @command{sed} will look for
each @samp{a} in the subject and then see if what follows matches
the rest of the pattern. If the pattern is specified as

@end example

the initial @code{.*} matches the entire string at first, but when
this fails (because there is no following @samp{a}), it backtracks
to match all but the last character, then all but the
last two characters, and so on. Once again the search for
@samp{a} covers the entire string, from right to left, so we are
no better off. However, if the pattern is written as

@end example

there can be no backtracking for the .* item; it can match
only the entire string. The subsequent lookbehind assertion
does a single test on the last four characters. If it fails,
the match fails immediately. For long strings, this approach
makes a significant difference to the processing time.

When a pattern contains an unlimited repeat inside a subpattern
that can itself be repeated an unlimited number of
times, the use of a once-only subpattern is the only way to
avoid some failing matches taking a very long time
indeed.@footnote{Actually, the matcher embedded in @value{SSED}
    tries to do something for this in the simplest cases,
    like @code{([^b]*b)*}.  These cases are actually quite
    common: they happen for example in a regular expression
    like @code{\/\*([^*]*\*)*\/} which matches C comments.}

The pattern

@end example


matches an unlimited number of substrings that either consist
of non-digits, or digits enclosed in angular brackets, followed by
an exclamation or question mark. When it matches, it runs quickly.
However, if it is applied to

@end example

it takes a long time before reporting failure.  This is
because the string can be divided between the two repeats in
a large number of ways, and all have to be tried.@footnote{The
example used @code{[!?]} rather than a single character at the end,
because both @value{SSED} and Perl have an optimization that allows
for fast failure when a single character is used. They
remember the last single character that is required for a
match, and fail early if it is not present in the string.}

If the pattern is changed to

@end example

sequences of non-digits cannot be broken, and failure happens

@node Conditional subpatterns
@appendixsec Conditional subpatterns
@cindex Perl-style regular expressions, conditional subpatterns

It is possible to cause the matching process to obey a subpattern
conditionally or to choose between two alternative
subpatterns, depending on the result of an assertion, or
whether a previous capturing subpattern matched or not. The
two possible forms of conditional subpattern are

@end example

If the condition is satisfied, the yes-pattern is used; otherwise
the no-pattern (if present) is used. If there are more than two
alternatives in the subpattern, a compile-time error occurs.

There are two kinds of condition. If the text between the
parentheses consists of a sequence of digits, the condition
is satisfied if the capturing subpattern of that number has
previously matched.  The number must be greater than zero.
Consider the following pattern, which contains non-significant
white space to make it more readable (assume the @code{X} modifier)
and to divide it into three parts for ease of discussion:

     ( \( )?   [^()]+   (?(1) \) )
@end example

The first part matches an optional opening parenthesis, and
if that character is present, sets it as the first captured
substring. The second part matches one or more characters
that are not parentheses. The third part is a conditional
subpattern that tests whether the first set of parentheses
matched or not.  If they did, that is, if subject started
with an opening parenthesis, the condition is true, and so
the yes-pattern is executed and a closing parenthesis is
required. Otherwise, since no-pattern is not present, the
subpattern matches nothing.  In other words, this pattern
matches a sequence of non-parentheses, optionally enclosed
in parentheses.

@cindex Perl-style regular expressions, lookahead subpatterns
If the condition is not a sequence of digits, it must be an
assertion.  This may be a positive or negative lookahead or
lookbehind assertion. Consider this pattern, again containing
non-significant white space, and with the two alternatives
on the second line:

        \d\d-[a-z]@{3@}-\d\d |
        \d\d-\d\d-\d\d )
@end example

The condition is a positive lookahead assertion that matches
a letter that is three characters away from the current point.
If a letter is found, the subject is matched against the first
alternative @samp{@var{dd}-@var{aaa}-@var{dd}} (where @var{aaa} are
letters and @var{dd} are digits); otherwise it is matched against 
the second alternative, @samp{@var{dd}-@var{dd}-@var{dd}}.

@node Recursive patterns
@appendixsec Recursive patterns
@cindex Perl-style regular expressions, recursive patterns
@cindex Perl-style regular expressions, recursion

Consider the problem of matching a string in parentheses,
allowing for unlimited nested parentheses. Without the use
of recursion, the best that can be done is to use a pattern
that matches up to some fixed depth of nesting. It is not
possible to handle an arbitrary nesting depth. Perl 5.6 has
provided an experimental facility that allows regular
expressions to recurse (amongst other things). It does this
by interpolating Perl code in the expression at run time,
and the code can refer to the expression itself. A Perl pattern
tern to solve the parentheses problem can be created like

     $re = qr@{\( (?: (?>[^()]+) | (?p@{$re@}) )* \)@}x;
@end example

The @code{(?p@{...@})} item interpolates Perl code at run time,
and in this case refers recursively to the pattern in which it
appears. Obviously, @command{sed} cannot support the interpolation of
Perl code.  Instead, the special item @code{(?R)} is provided for
the specific case of recursion. This pattern solves the
parentheses problem (assume the @code{X} modifier option is used
so that white space is ignored):

     \( ( (?>[^()]+) | (?R) )* \)
@end example

First it matches an opening parenthesis. Then it matches any
number of substrings which can either be a sequence of
non-parentheses, or a recursive match of the pattern itself
(i.e. a correctly parenthesized substring). Finally there is
a closing parenthesis.

This particular example pattern contains nested unlimited
repeats, and so the use of a non-backtracking subpattern for
matching strings of non-parentheses is important when applying
the pattern to strings that do not match. For example, when
it is applied to

@end example

it yields a ``no match'' response quickly. However, if a
standard backtracking subpattern is not used, the match runs
for a very long time indeed because there are so many different
ways the @code{+} and @code{*} repeats can carve up the subject,
and all have to be tested before failure can be reported.

The values set for any capturing subpatterns are those from
the outermost level of the recursion at which the subpattern
value is set. If the pattern above is matched against

@end example

the value for the capturing parentheses is @samp{ef}, which is
the last value taken on at the top level.

@node Comments
@appendixsec Comments
@cindex Perl-style regular expressions, comments

The sequence (?# marks the start of a comment which continues
ues up to the next closing parenthesis. Nested parentheses
are not permitted. The characters that make up a comment
play no part in the pattern matching at all.

@cindex Perl-style regular expressions, extended
If the @code{X} modifier option is used, an unescaped @code{#} character
outside a character class introduces a comment that continues
up to the next newline character in the pattern.
@end ifset

@node Concept Index
@c @unnumbered Concept Index
@unnumbered 概念の索引

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

@printindex cp

@node Command and Option Index
@c @unnumbered Command and Option Index
@unnumbered コマンドとオプションの索引

@c This is an alphabetical list of all @command{sed} commands and command-line
@c options.

@printindex fn


@c XXX FIXME: the term "cycle" is never defined...

FreeBSD-CVSweb <>