Reguläre Ausdrücke für VB - komplette Beschreibung

     regexp$ consists of editing commands, one	per line, of the following
     form:

	  [ address [ ,	address	] ] function [ arguments ]

     Zero or more blank	characters are accepted	before the first address and
     before command.

     In	normal operation, sed cyclically copies	a line of input	into a pattern
     space (unless there is something left after a D command), applies in
     sequence all commands whose addresses select that pattern space, and at
     the end of	the script copies the pattern space to the standard output
     (except when -n is	specified) and deletes the pattern space.  Whenever
     the pattern space is written to standard output or	a named	file, sed will
     immediately follow	it with	a newline character.

     Some of the commands use a	hold space to save all or part of the pattern
     space for subsequent retrieval.  The hold and pattern spaces each hold at
     least 8192	bytes.

     An	address	is either a decimal number that	counts input lines
     cumulatively across files,	a $ that addresses the last line of input, or
     a context address,	i.e., a	/regular expression/ 
     modified thus:

	  In a context address,	the construction \?regular expression?,	where
	       ?  is any character, is identical to /regular expression/.
	       Note that in the	context	address	\xabc\xdefx, the second	x
	       stands for itself, so that the regular expression is abcxdef.
	  The escape sequence \n matches a new-line embedded in	the pattern
	       space.
	  A period . matches any character except the terminal new-line	of the
	       pattern space.
	  A command line with no addresses selects every pattern space.
	  A command line with one address selects each pattern space that
	       matches the address.
	  A command line with two addresses selects the	inclusive range	from
	       the first pattern space that matches the	first address through
	       the next	pattern	space that matches the second.	(If the	second
	       address is a number less	than or	equal to the line number first
	       selected, only one line is selected.)  Thereafter the process
	       is repeated, looking again for the first	address.
	  \< and \> are	not currently supported.

     Editing commands can be applied only to non-selected pattern spaces by
     use of the	negation function ! (below).

     In	the following list of functions	the maximum number of permissible
     addresses for each	function is indicated in parentheses.

     The text argument consists	of one or more lines, all but the last of
     which end with \ to hide the new-line.  Backslashes in text are treated
     like backslashes in the replacement string	of an s	command, and may be
     used to protect initial blanks and	tabs against the stripping that	is
     done on every script line.	 The rfile or wfile argument must terminate
     the command line and must be preceded by exactly one blank.  Each wfile
     is	created	before processing begins.  There can be	at most	10 distinct
     wfile arguments.

     (1)a\
     text      Append.	Place text on the output before	reading	the next input
	       line.
     (2)b label
	       Branch to the : command bearing the label.  If label is empty,
	       branch to the end of the	script.
     (2)c\
     text      Change.	Delete the pattern space.  With	0 or 1 address or at
	       the end of a 2-address range, place text	on the output.	Start
	       the next	cycle.
     (2)d      Delete the pattern space.  Start	the next cycle.
     (2)D      Delete the initial segment of the pattern space through the
	       first new-line.	Start the next cycle.
     (2)g      Replace the contents of the pattern space by the	contents of
	       the hold	space.
     (2)G      Append the contents of the hold space to	the pattern space.
     (2)h      Replace the contents of the hold	space by the contents of the
	       pattern space.
     (2)H      Append the contents of the pattern space	to the hold space.
     (1)i\
     text      Insert.	Place text on the standard output.
     (2)l      List the	pattern	space on the standard output in	an unambiguous
	       form.  Non-printable characters are displayed in	octal notation
	       and long	lines are folded.
     (2)n      Copy the	pattern	space to the standard output.  Replace the
	       pattern space with the next line	of input.
     (2)N      Append the next line of input to	the pattern space with an
	       embedded	new-line.  (The	current	line number changes.)
     (2)p      Print.  Copy the	pattern	space to the standard output.
     (2)P      Copy the	initial	segment	of the pattern space through the first
	       new-line	to the standard	output.
     (1)q      Quit.  Branch to	the end	of the script.	Do not start a new
	       cycle.
     (2)r rfile
	       Read the	contents of rfile.  Place them on the output before
	       reading the next	input line.
     (2)s/regular expression/replacement/flags
	       Substitute the replacement string for instances of the regular
	       expression in the pattern space.	 Any character may be used
	       instead of /.
               For a fuller description see regular expressions.
               Flags is zero or more of:
	       n	 n= 1 -	512.  Substitute for just the n	th occurrence
			 of the	regular	expression.
	       g	 Global.  Substitute for all nonoverlapping instances
			 of the	regular	expression rather than just the	first
			 one.
	       p	 Print the pattern space if a replacement was made.
	       w wfile	 Write.	 Append	the pattern space to wfile if a
			 replacement was made.
     (2)t label
	       Test.  Branch to	the : command bearing the label	if any
	       substitutions have been made since the most recent reading of
	       an input	line or	execution of a t.  If label is empty, branch
	       to the end of the script.
     (2)w wfile
	       Write.  Append the pattern space	to wfile.
     (2)x      Exchange	the contents of	the pattern and	hold spaces.
     (2)y/string1/string2/
	       Transform.  Replace all occurrences of characters in string1
	       with the	corresponding character	in string2.  The lengths of
	       string1 and string2 must	be equal.
     (2)! function
	       Don't.  Apply the function (or group, if	function is {) only to
	       lines not selected by the address(es).
     (0): label
	       This command does nothing; it bears a label for b and t
	       commands	to branch to.
     (1)=      Place the current line number on	the standard output as a line.
     (2){      Execute the following commands through a	matching } only	when
	       the pattern space is selected.
     (0)       An empty	command	is ignored.
     (0)#      If a # appears as the first character on	a line of a script
	       file, then that entire line is treated as a comment, with one
	       exception.  If the character after the #	is an 'n', then	the
	       default output will be suppressed.  The rest of the line	after
	       #n is also ignored.  A script file must contain at least	one
	       non-comment line.

   REGULAR EXPRESSIONS
     Regular expressions are patterns used in selecting	text.

     In	addition to a specifying string	literals, regular expressions can
     represent classes of strings.  Strings thus represented are said to be
     matched by	the corresponding regular expression.  If it is	possible for a
     regular expression	to match several strings in a line, then the left-most
     longest match is the one selected.

     The following symbols are used in constructing regular expressions:

     c	     Any character c not listed	below, including `{', '}', `(',	`)',
	     `<' and `>', matches itself.

     \c	     A backslash-escaped character c other than	`{', '}', `(', `)',
	     `<', `>', `b', 'B', `w', `W', `+',	and `?'	 matches itself.

     Matches any single	character.

     [char-class]
	     Matches any single	character in char-class.  To include a	`]' in
	     char-class, it must be the	first character.  A range of
	     characters	may be specified by separating the end characters of
	     the range with a `-', e.g., `a-z' specifies the lower case
	     characters.  The following	literal	expressions can	also be	used
	     in	char-class to specify sets of characters:

	       [:alnum:]  [:cntrl:]  [:lower:]	[:space:]
	       [:alpha:]  [:digit:]  [:print:]	[:upper:]
	       [:blank:]  [:graph:]  [:punct:]	[:xdigit:]

	     If	`-' appears as the first or last character of char-class, then
	     it	matches	itself.	 All other characters in char-class match
	     themselves.

	     Patterns in char-class of the form:

	       [.col-elm.] or,	 [=col-elm=]

	     where col-elm is a	collating element are interpreted according to
	     locale(5) (not currently supported).  See regcomp(7) for an
	     explanation of these constructs.

     [^char-class]
	     Matches any single	character, other than newline, not in char-
	     class.  char-class	is defined as above.

     ^	     If	`^' is the first character of a	regular	expression, then it
	     anchors the regular expression to the beginning of	a line.
	     Otherwise,	it matches itself.

     $	     If	`$' is the last	character of a regular expression, it anchors
	     the regular expression to the end of a line.  Otherwise, it
	     matches itself.

     (re)    Defines a (possibly null) subexpression re.  Subexpressions may
	     be	nested.	 A subsequent backreference of the form	`\n', where n
	     is	a number in the	range [1,9], expands to	the text matched by
	     the nth subexpression.  For example, the regular expression
	     `(a.c)\1' matches the string `abcabc', but not `abcadc'.
	     Subexpressions are	ordered	relative to their left delimiter.

     *	     Matches the single	character regular expression or	subexpression
	     immediately preceding it zero or more times.  If '*' is the first
	     character of a regular expression or subexpression, then it
	     matches itself.  The `*' operator sometimes yields	unexpected
	     results.  For example, the	regular	expression `b*'	matches	the
	     beginning of the string `abbb', as	opposed	to the substring
	     `bbb', since a null match is the only left-most match.

     \{n,m\}
     \{n,\}
     \{n\}   Matches the single	character regular expression or	subexpression
	     immediately preceding it at least n and at	most m times.  If m is
	     omitted, then it matches at least n times.	 If the	comma is also
	     omitted, then it matches exactly n	times.	If  any	of these forms
	     occurs first in a regular expression or subexpression, then it is
	     interpreted literally (i.e., the regular expression `\{2\}'
	     matches the string	`{2}', and so on).

     \<
     \>	     Anchors the single	character regular expression or	subexpression
	     immediately following it to the beginning (\<) or ending (\>) of
	     a word, i.e., in ASCII, a maximal string of alphanumeric
	     characters, including the underscore (_).

     The following extended operators are preceded by a	backslash (\) to
     distinguish them from traditional ed syntax.

     \`
     \'	     Unconditionally matches the beginning (\`)	or ending (\') of a
	     line.

     \?	     Optionally	matches	the single character regular expression	or
	     subexpression immediately preceding it.  For example, the regular
	     expression	`a[bd]\?c' matches the strings `abc', `adc' and	`ac'.
	     If	\? occurs at the beginning of a	regular	expressions or
	     subexpression, then it matches a literal `?'.

     \+	     Matches the single	character regular expression or	subexpression
	     immediately preceding it one or more times.  So the regular
	     expression	`a+' is	shorthand for `aa*'.  If \+ occurs at the
	     beginning of a regular expression or subexpression, then it
	     matches a literal `+'.

     \b	     Matches the beginning or ending (null string) of a	word.  Thus
	     the regular expression `\bhello\b'	is equivalent to `\<hello\>'.
	     However, `\b\b' is	a valid	regular	expression whereas `\<\>' is
	     not.

     \B	     Matches (a	null string) inside a word.

     \w	     Matches any character in a	word.

     \W	     Matches any character not in a word.