mirror of
https://github.com/boostorg/regex.git
synced 2025-07-29 12:07:28 +02:00
Added support for \g \K and \R.
[SVN r52592]
This commit is contained in:
John Maddock
@ -12,7 +12,7 @@
|
||||
|
||||
The Perl regular expression syntax is based on that used by the
|
||||
programming language Perl . Perl regular expressions are the
|
||||
default behavior in Boost.Regex or you can pass the flag `perl` to the
|
||||
default behavior in Boost.Regex or you can pass the flag =perl= to the
|
||||
[basic_regex] constructor, for example:
|
||||
|
||||
// e1 is a case sensitive Perl regular expression:
|
||||
@ -34,9 +34,9 @@ The single character '.' when used outside of a character set will match
|
||||
any single character except:
|
||||
|
||||
* The NULL character when the [link boost_regex.ref.match_flag_type flag
|
||||
`match_not_dot_null`] is passed to the matching algorithms.
|
||||
=match_not_dot_null=] is passed to the matching algorithms.
|
||||
* The newline character when the [link boost_regex.ref.match_flag_type
|
||||
flag `match_not_dot_newline`] is passed to
|
||||
flag =match_not_dot_newline=] is passed to
|
||||
the matching algorithms.
|
||||
|
||||
[h4 Anchors]
|
||||
@ -47,7 +47,7 @@ A '$' character shall match the end of a line.
|
||||
|
||||
[h4 Marked sub-expressions]
|
||||
|
||||
A section beginning `(` and ending `)` acts as a marked sub-expression.
|
||||
A section beginning =(= and ending =)= acts as a marked sub-expression.
|
||||
Whatever matched the sub-expression is split out in a separate field by
|
||||
the matching algorithms. Marked sub-expressions can also repeated, or
|
||||
referred to by a back-reference.
|
||||
@ -58,23 +58,23 @@ A marked sub-expression is useful to lexically group part of a regular
|
||||
expression, but has the side-effect of spitting out an extra field in
|
||||
the result. As an alternative you can lexically group part of a
|
||||
regular expression, without generating a marked sub-expression by using
|
||||
`(?:` and `)` , for example `(?:ab)+` will repeat `ab` without splitting
|
||||
=(?:= and =)= , for example =(?:ab)+= will repeat =ab= without splitting
|
||||
out any separate sub-expressions.
|
||||
|
||||
[h4 Repeats]
|
||||
|
||||
Any atom (a single character, a marked sub-expression, or a character class)
|
||||
can be repeated with the `*`, `+`, `?`, and `{}` operators.
|
||||
can be repeated with the =*=, =+=, =?=, and ={}= operators.
|
||||
|
||||
The `*` operator will match the preceding atom zero or more times,
|
||||
for example the expression `a*b` will match any of the following:
|
||||
The =*= operator will match the preceding atom zero or more times,
|
||||
for example the expression =a*b= will match any of the following:
|
||||
|
||||
b
|
||||
ab
|
||||
aaaaaaaab
|
||||
|
||||
The `+` operator will match the preceding atom one or more times, for
|
||||
example the expression `a+b` will match any of the following:
|
||||
The =+= operator will match the preceding atom one or more times, for
|
||||
example the expression =a+b= will match any of the following:
|
||||
|
||||
ab
|
||||
aaaaaaaab
|
||||
@ -83,7 +83,7 @@ But will not match:
|
||||
|
||||
b
|
||||
|
||||
The `?` operator will match the preceding atom zero or one times, for
|
||||
The =?= operator will match the preceding atom zero or one times, for
|
||||
example the expression ca?b will match any of the following:
|
||||
|
||||
cb
|
||||
@ -95,11 +95,11 @@ But will not match:
|
||||
|
||||
An atom can also be repeated with a bounded repeat:
|
||||
|
||||
`a{n}` Matches 'a' repeated exactly n times.
|
||||
=a{n}= Matches 'a' repeated exactly n times.
|
||||
|
||||
`a{n,}` Matches 'a' repeated n or more times.
|
||||
=a{n,}= Matches 'a' repeated n or more times.
|
||||
|
||||
`a{n, m}` Matches 'a' repeated between n and m times inclusive.
|
||||
=a{n, m}= Matches 'a' repeated between n and m times inclusive.
|
||||
|
||||
For example:
|
||||
|
||||
@ -120,7 +120,7 @@ be repeated, for example:
|
||||
|
||||
a(*)
|
||||
|
||||
Will raise an error, as there is nothing for the `*` operator to be applied to.
|
||||
Will raise an error, as there is nothing for the =*= operator to be applied to.
|
||||
|
||||
[h4 Non greedy repeats]
|
||||
|
||||
@ -128,19 +128,19 @@ The normal repeat operators are "greedy", that is to say they will consume as
|
||||
much input as possible. There are non-greedy versions available that will
|
||||
consume as little input as possible while still producing a match.
|
||||
|
||||
`*?` Matches the previous atom zero or more times, while consuming as little
|
||||
=*?= Matches the previous atom zero or more times, while consuming as little
|
||||
input as possible.
|
||||
|
||||
`+?` Matches the previous atom one or more times, while consuming as
|
||||
=+?= Matches the previous atom one or more times, while consuming as
|
||||
little input as possible.
|
||||
|
||||
`??` Matches the previous atom zero or one times, while consuming
|
||||
=??= Matches the previous atom zero or one times, while consuming
|
||||
as little input as possible.
|
||||
|
||||
`{n,}?` Matches the previous atom n or more times, while consuming as
|
||||
={n,}?= Matches the previous atom n or more times, while consuming as
|
||||
little input as possible.
|
||||
|
||||
`{n,m}?` Matches the previous atom between n and m times, while
|
||||
={n,m}?= Matches the previous atom between n and m times, while
|
||||
consuming as little input as possible.
|
||||
|
||||
[h4 Pocessive repeats]
|
||||
@ -150,15 +150,15 @@ a match is found. However, this behaviour can sometime be undesireable so there
|
||||
also "pocessive" repeats: these match as much as possible and do not then allow
|
||||
backtracking if the rest of the expression fails to match.
|
||||
|
||||
`*+` Matches the previous atom zero or more times, while giving nothing back.
|
||||
=*+= Matches the previous atom zero or more times, while giving nothing back.
|
||||
|
||||
`++` Matches the previous atom one or more times, while giving nothing back.
|
||||
=++= Matches the previous atom one or more times, while giving nothing back.
|
||||
|
||||
`?+` Matches the previous atom zero or one times, while giving nothing back.
|
||||
=?+= Matches the previous atom zero or one times, while giving nothing back.
|
||||
|
||||
`{n,}+` Matches the previous atom n or more times, while giving nothing back.
|
||||
={n,}+= Matches the previous atom n or more times, while giving nothing back.
|
||||
|
||||
`{n,m}+` Matches the previous atom between n and m times, while giving nothing back.
|
||||
={n,m}+= Matches the previous atom between n and m times, while giving nothing back.
|
||||
|
||||
[h4 Back references]
|
||||
|
||||
@ -175,27 +175,38 @@ Will match the string:
|
||||
But not the string:
|
||||
|
||||
aaabba
|
||||
|
||||
You can also use the \g escape for the same function, for example:
|
||||
|
||||
[table
|
||||
[[Escape][Meaning]]
|
||||
[[=\g1=][Match whatever matched sub-expression 1]]
|
||||
[[=\g{1}=][Match whatever matched sub-expression 1: this form allows for safer
|
||||
parsing of the expression in cases like =\g{1}2= or for indexes higher than 9 as in =\g{1234}=]]
|
||||
[[=\g-1=][Match whatever matched the last opened sub-expression]]
|
||||
[[=\g{-2}=][Match whatever matched the last but one opened sub-expression]]
|
||||
]
|
||||
|
||||
[h4 Alternation]
|
||||
|
||||
The `|` operator will match either of its arguments, so for example:
|
||||
`abc|def` will match either "abc" or "def".
|
||||
The =|= operator will match either of its arguments, so for example:
|
||||
=abc|def= will match either "abc" or "def".
|
||||
|
||||
Parenthesis can be used to group alternations, for example: `ab(d|ef)`
|
||||
Parenthesis can be used to group alternations, for example: =ab(d|ef)=
|
||||
will match either of "abd" or "abef".
|
||||
|
||||
Empty alternatives are not allowed (these are almost always a mistake), but
|
||||
if you really want an empty alternative use `(?:)` as a placeholder, for example:
|
||||
if you really want an empty alternative use =(?:)= as a placeholder, for example:
|
||||
|
||||
`|abc` is not a valid expression, but
|
||||
=|abc= is not a valid expression, but
|
||||
|
||||
`(?:)|abc` is and is equivalent, also the expression:
|
||||
=(?:)|abc= is and is equivalent, also the expression:
|
||||
|
||||
`(?:abc)??` has exactly the same effect.
|
||||
=(?:abc)??= has exactly the same effect.
|
||||
|
||||
[h4 Character sets]
|
||||
|
||||
A character set is a bracket-expression starting with `[` and ending with `]`,
|
||||
A character set is a bracket-expression starting with =[= and ending with =]=,
|
||||
it defines a set of characters, and matches any single character that is a
|
||||
member of that set.
|
||||
|
||||
@ -203,35 +214,35 @@ A bracket expression may contain any combination of the following:
|
||||
|
||||
[h5 Single characters]
|
||||
|
||||
For example `[abc]`, will match any of the characters 'a', 'b', or 'c'.
|
||||
For example =[abc]=, will match any of the characters 'a', 'b', or 'c'.
|
||||
|
||||
[h5 Character ranges]
|
||||
|
||||
For example `[a-c]` will match any single character in the range 'a' to 'c'.
|
||||
For example =[a-c]= will match any single character in the range 'a' to 'c'.
|
||||
By default, for Perl regular expressions, a character x is within the
|
||||
range y to z, if the code point of the character lies within the codepoints of
|
||||
the endpoints of the range. Alternatively, if you set the
|
||||
[link boost_regex.ref.syntax_option_type.syntax_option_type_perl `collate` flag]
|
||||
[link boost_regex.ref.syntax_option_type.syntax_option_type_perl =collate= flag]
|
||||
when constructing the regular expression, then ranges are locale sensitive.
|
||||
|
||||
[h5 Negation]
|
||||
|
||||
If the bracket-expression begins with the ^ character, then it matches the
|
||||
complement of the characters it contains, for example `[^a-c]` matches
|
||||
any character that is not in the range `a-c`.
|
||||
complement of the characters it contains, for example =[^a-c]= matches
|
||||
any character that is not in the range =a-c=.
|
||||
|
||||
[h5 Character classes]
|
||||
|
||||
An expression of the form `[[:name:]]` matches the named character class
|
||||
"name", for example `[[:lower:]]` matches any lower case character.
|
||||
An expression of the form [^\[\[:name:\]\]] matches the named character class
|
||||
"name", for example [^\[\[:lower:\]\]] matches any lower case character.
|
||||
See [link boost_regex.syntax.character_classes character class names].
|
||||
|
||||
[h5 Collating Elements]
|
||||
|
||||
An expression of the form `[[.col.]` matches the collating element /col/.
|
||||
An expression of the form [^\[\[.col.\]\]] matches the collating element /col/.
|
||||
A collating element is any single character, or any sequence of characters
|
||||
that collates as a single unit. Collating elements may also be used
|
||||
as the end point of a range, for example: `[[.ae.]-c]` matches the
|
||||
as the end point of a range, for example: [^\[\[.ae.\]-c\]] matches the
|
||||
character sequence "ae", plus any single character in the range "ae"-c,
|
||||
assuming that "ae" is treated as a single collating element in the current locale.
|
||||
|
||||
@ -240,11 +251,11 @@ As an extension, a collating element may also be specified via it's
|
||||
|
||||
[[.NUL.]]
|
||||
|
||||
matches a `\0` character.
|
||||
matches a =\0= character.
|
||||
|
||||
[h5 Equivalence classes]
|
||||
|
||||
An expression of the form `[[=col=]]`, matches any character or collating element
|
||||
An expression of the form [^\[\[\=col\=\]\]], matches any character or collating element
|
||||
whose primary sort key is the same as that for collating element /col/, as with
|
||||
collating elements the name /col/ may be a
|
||||
[link boost_regex.syntax.collating_names symbolic name]. A primary sort key is
|
||||
@ -267,7 +278,7 @@ that is either a "digit", /or/ is /not/ a "word" character.
|
||||
[h5 Combinations]
|
||||
|
||||
All of the above can be combined in one character set declaration, for example:
|
||||
`[[:digit:]a-c[.NUL.]]`.
|
||||
[^\[\[:digit:\]a-c\[.NUL.\]\]].
|
||||
|
||||
[h4 Escapes]
|
||||
|
||||
@ -277,24 +288,24 @@ The following escape sequences are all synonyms for single characters:
|
||||
|
||||
[table
|
||||
[[Escape][Character]]
|
||||
[[`\a`][`\a`]]
|
||||
[[`\e`][`0x1B`]]
|
||||
[[`\f`][`\f`]]
|
||||
[[`\n`][`\n`]]
|
||||
[[`\r`][`\r`]]
|
||||
[[`\t`][`\t`]]
|
||||
[[`\v `][`\v`]]
|
||||
[[`\b`][`\b` (but only inside a character class declaration).]]
|
||||
[[`\cX`][An ASCII escape sequence - the character whose code point is X % 32]]
|
||||
[[`\xdd`][A hexadecimal escape sequence - matches the single character whose
|
||||
[[=\a=][=\a=]]
|
||||
[[=\e=][=0x1B=]]
|
||||
[[=\f=][=\f=]]
|
||||
[[=\n=][=\n=]]
|
||||
[[=\r=][=\r=]]
|
||||
[[=\t=][=\t=]]
|
||||
[[=\v=][=\v=]]
|
||||
[[=\b=][=\b= (but only inside a character class declaration).]]
|
||||
[[=\cX=][An ASCII escape sequence - the character whose code point is X % 32]]
|
||||
[[=\xdd=][A hexadecimal escape sequence - matches the single character whose
|
||||
code point is 0xdd.]]
|
||||
[[`\x{dddd}`][A hexadecimal escape sequence - matches the single character whose
|
||||
[[=\x{dddd}=][A hexadecimal escape sequence - matches the single character whose
|
||||
code point is 0xdddd.]]
|
||||
[[`\0ddd`][An octal escape sequence - matches the single character whose
|
||||
[[=\0ddd=][An octal escape sequence - matches the single character whose
|
||||
code point is 0ddd.]]
|
||||
[[`\N{name}`][Matches the single character which has the
|
||||
[[=\N{name}=][Matches the single character which has the
|
||||
[link boost_regex.syntax.collating_names symbolic name] /name/.
|
||||
For example `\N{newline}` matches the single character \\n.]]
|
||||
For example =\N{newline}= matches the single character \\n.]]
|
||||
]
|
||||
|
||||
[h5 "Single character" character classes:]
|
||||
@ -337,19 +348,19 @@ to the [link boost_regex.syntax.character_classes names used in character classe
|
||||
[[`\P{Name}`][Matches any character that does not have the property Name.][`[^[:Name:]]`]]
|
||||
]
|
||||
|
||||
For example `\pd` matches any "digit" character, as does `\p{digit}`.
|
||||
For example =\pd= matches any "digit" character, as does =\p{digit}=.
|
||||
|
||||
[h5 Word Boundaries]
|
||||
|
||||
The following escape sequences match the boundaries of words:
|
||||
|
||||
`\<` Matches the start of a word.
|
||||
=\<= Matches the start of a word.
|
||||
|
||||
`\>` Matches the end of a word.
|
||||
=\>= Matches the end of a word.
|
||||
|
||||
`\b` Matches a word boundary (the start or end of a word).
|
||||
=\b= Matches a word boundary (the start or end of a word).
|
||||
|
||||
`\B` Matches only when not at a word boundary.
|
||||
=\B= Matches only when not at a word boundary.
|
||||
|
||||
[h5 Buffer boundaries]
|
||||
|
||||
@ -366,30 +377,44 @@ context is the whole of the input text that is being matched against
|
||||
\\z Matches at the end of a buffer only (the same as \\').
|
||||
|
||||
\\Z Matches an optional sequence of newlines at the end of a buffer:
|
||||
equivalent to the regular expression `\n*\z`
|
||||
equivalent to the regular expression =\n*\z=
|
||||
|
||||
[h5 Continuation Escape]
|
||||
|
||||
The sequence `\G` matches only at the end of the last match found, or at
|
||||
The sequence =\G= matches only at the end of the last match found, or at
|
||||
the start of the text being matched if no previous match was found.
|
||||
This escape useful if you're iterating over the matches contained within a
|
||||
text, and you want each subsequence match to start where the last one ended.
|
||||
|
||||
[h5 Quoting escape]
|
||||
|
||||
The escape sequence `\Q` begins a "quoted sequence": all the subsequent characters
|
||||
The escape sequence =\Q= begins a "quoted sequence": all the subsequent characters
|
||||
are treated as literals, until either the end of the regular expression or \\E
|
||||
is found. For example the expression: `\Q\*+\Ea+` would match either of:
|
||||
is found. For example the expression: =\Q\*+\Ea+= would match either of:
|
||||
|
||||
\*+a
|
||||
\*+aaa
|
||||
|
||||
[h5 Unicode escapes]
|
||||
|
||||
`\C` Matches a single code point: in Boost regex this has exactly the
|
||||
=\C= Matches a single code point: in Boost regex this has exactly the
|
||||
same effect as a "." operator.
|
||||
`\X` Matches a combining character sequence: that is any non-combining
|
||||
=\X= Matches a combining character sequence: that is any non-combining
|
||||
character followed by a sequence of zero or more combining characters.
|
||||
|
||||
[h5 Matching Line Endings]
|
||||
|
||||
The escape sequence =\R= matches any line ending character sequence, specifically it is identical to
|
||||
the expression [^(?>\x0D\x0A?|\[\x0A-\x0C\x85\x{2028}\x{2029}\])].
|
||||
|
||||
[h5 Keeping back some text]
|
||||
|
||||
=\K= Resets the start location of $0 to the current text position: in other words everything to the
|
||||
left of \K is "kept back" and does not form part of the regular expression match. $` is updated
|
||||
accordingly.
|
||||
|
||||
For example =foo\Kbar= matched against the text "foobar" would return the match "bar" for $0 and "foo"
|
||||
for $`. This can be used to simulate variable width lookbehind assertions.
|
||||
|
||||
[h5 Any other escape]
|
||||
|
||||
@ -398,31 +423,31 @@ Any other escape sequence matches the character that is escaped, for example
|
||||
|
||||
[h4 Perl Extended Patterns]
|
||||
|
||||
Perl-specific extensions to the regular expression syntax all start with `(?`.
|
||||
Perl-specific extensions to the regular expression syntax all start with =(?=.
|
||||
|
||||
[h5 Comments]
|
||||
|
||||
`(?# ... )` is treated as a comment, it's contents are ignored.
|
||||
=(?# ... )= is treated as a comment, it's contents are ignored.
|
||||
|
||||
[h5 Modifiers]
|
||||
|
||||
`(?imsx-imsx ... )` alters which of the perl modifiers are in effect within
|
||||
=(?imsx-imsx ... )= alters which of the perl modifiers are in effect within
|
||||
the pattern, changes take effect from the point that the block is first seen
|
||||
and extend to any enclosing `)`. Letters before a '-' turn that perl
|
||||
and extend to any enclosing =)=. Letters before a '-' turn that perl
|
||||
modifier on, letters afterward, turn it off.
|
||||
|
||||
`(?imsx-imsx:pattern)` applies the specified modifiers to pattern only.
|
||||
=(?imsx-imsx:pattern)= applies the specified modifiers to pattern only.
|
||||
|
||||
[h5 Non-marking groups]
|
||||
|
||||
`(?:pattern)` lexically groups pattern, without generating an additional
|
||||
=(?:pattern)= lexically groups pattern, without generating an additional
|
||||
sub-expression.
|
||||
|
||||
[h5 Lookahead]
|
||||
|
||||
`(?=pattern)` consumes zero characters, only if pattern matches.
|
||||
[^(?=pattern)] consumes zero characters, only if pattern matches.
|
||||
|
||||
`(?!pattern)` consumes zero characters, only if pattern does not match.
|
||||
=(?!pattern)= consumes zero characters, only if pattern does not match.
|
||||
|
||||
Lookahead is typically used to create the logical AND of two regular
|
||||
expressions, for example if a password must contain a lower case letter,
|
||||
@ -435,17 +460,17 @@ could be used to validate the password.
|
||||
|
||||
[h5 Lookbehind]
|
||||
|
||||
`(?<=pattern)` consumes zero characters, only if pattern could be matched
|
||||
[^(?<=pattern)] consumes zero characters, only if pattern could be matched
|
||||
against the characters preceding the current position (pattern must be
|
||||
of fixed length).
|
||||
|
||||
`(?<!pattern)` consumes zero characters, only if pattern could not be
|
||||
=(?<!pattern)= consumes zero characters, only if pattern could not be
|
||||
matched against the characters preceding the current position (pattern must
|
||||
be of fixed length).
|
||||
|
||||
[h5 Independent sub-expressions]
|
||||
|
||||
`(?>pattern)` /pattern/ is matched independently of the surrounding patterns,
|
||||
=(?>pattern)= /pattern/ is matched independently of the surrounding patterns,
|
||||
the expression will never backtrack into /pattern/. Independent sub-expressions
|
||||
are typically used to improve performance; only the best possible match
|
||||
for pattern will be considered, if this doesn't allow the expression as a
|
||||
@ -453,10 +478,10 @@ whole to match then no match is found at all.
|
||||
|
||||
[h5 Conditional Expressions]
|
||||
|
||||
`(?(condition)yes-pattern|no-pattern)` attempts to match /yes-pattern/ if
|
||||
=(?(condition)yes-pattern|no-pattern)= attempts to match /yes-pattern/ if
|
||||
the /condition/ is true, otherwise attempts to match /no-pattern/.
|
||||
|
||||
`(?(condition)yes-pattern)` attempts to match /yes-pattern/ if the /condition/
|
||||
=(?(condition)yes-pattern)= attempts to match /yes-pattern/ if the /condition/
|
||||
is true, otherwise fails.
|
||||
|
||||
/condition/ may be either a forward lookahead assert, or the index of
|
||||
@ -468,10 +493,10 @@ has been matched).
|
||||
The order of precedence for of operators is as follows:
|
||||
|
||||
# Collation-related bracket symbols `[==] [::] [..]`
|
||||
# Escaped characters `\`
|
||||
# Escaped characters =\=
|
||||
# Character set (bracket expression) `[]`
|
||||
# Grouping `()`
|
||||
# Single-character-ERE duplication `* + ? {m,n}`
|
||||
# Grouping =()=
|
||||
# Single-character-ERE duplication =* + ? {m,n}=
|
||||
# Concatenation
|
||||
# Anchoring ^$
|
||||
# Alternation |
|
||||
@ -490,42 +515,42 @@ with individual elements matched as follows;
|
||||
|
||||
[table
|
||||
[[Construct][What gets matched]]
|
||||
[[`AtomA AtomB`][Locates the best match for /AtomA/ that has a following match for /AtomB/.]]
|
||||
[[`Expression1 | Expression2`][If /Expresion1/ can be matched then returns that match,
|
||||
[[=AtomA AtomB=][Locates the best match for /AtomA/ that has a following match for /AtomB/.]]
|
||||
[[=Expression1 | Expression2=][If /Expresion1/ can be matched then returns that match,
|
||||
otherwise attempts to match /Expression2/.]]
|
||||
[[`S{N}`][Matches /S/ repeated exactly N times.]]
|
||||
[[`S{N,M}`][Matches S repeated between N and M times, and as many times as possible.]]
|
||||
[[`S{N,M}?`][Matches S repeated between N and M times, and as few times as possible.]]
|
||||
[[`S?, S*, S+`][The same as `S{0,1}`, `S{0,UINT_MAX}`, `S{1,UINT_MAX}` respectively.]]
|
||||
[[`S??, S*?, S+?`][The same as `S{0,1}?`, `S{0,UINT_MAX}?`, `S{1,UINT_MAX}?` respectively.]]
|
||||
[[`(?>S)`][Matches the best match for /S/, and only that.]]
|
||||
[[`(?=S), (?<=S)`][Matches only the best match for /S/ (this is only
|
||||
[[=S{N}=][Matches /S/ repeated exactly N times.]]
|
||||
[[=S{N,M}=][Matches S repeated between N and M times, and as many times as possible.]]
|
||||
[[=S{N,M}?=][Matches S repeated between N and M times, and as few times as possible.]]
|
||||
[[=S?, S*, S+=][The same as =S{0,1}=, =S{0,UINT_MAX}=, =S{1,UINT_MAX}= respectively.]]
|
||||
[[=S??, S*?, S+?=][The same as =S{0,1}?=, =S{0,UINT_MAX}?=, =S{1,UINT_MAX}?= respectively.]]
|
||||
[[=(?>S)=][Matches the best match for /S/, and only that.]]
|
||||
[[[^(?=S), (?<=S)]][Matches only the best match for /S/ (this is only
|
||||
visible if there are capturing parenthesis within /S/).]]
|
||||
[[`(?!S), (?<!S)`][Considers only whether a match for S exists or not.]]
|
||||
[[`(?(condition)yes-pattern | no-pattern)`][If condition is true, then
|
||||
[[=(?!S), (?<!S)=][Considers only whether a match for S exists or not.]]
|
||||
[[=(?(condition)yes-pattern | no-pattern)=][If condition is true, then
|
||||
only yes-pattern is considered, otherwise only no-pattern is considered.]]
|
||||
]
|
||||
|
||||
[h3 Variations]
|
||||
|
||||
The [link boost_regex.ref.syntax_option_type.syntax_option_type_perl options `normal`,
|
||||
`ECMAScript`, `JavaScript` and `JScript`] are all synonyms for
|
||||
`perl`.
|
||||
The [link boost_regex.ref.syntax_option_type.syntax_option_type_perl options =normal=,
|
||||
=ECMAScript=, =JavaScript= and =JScript=] are all synonyms for
|
||||
=perl=.
|
||||
|
||||
[h3 Options]
|
||||
|
||||
There are a [link boost_regex.ref.syntax_option_type.syntax_option_type_perl
|
||||
variety of flags] that may be combined with the `perl` option when
|
||||
variety of flags] that may be combined with the =perl= option when
|
||||
constructing the regular expression, in particular note that the
|
||||
`newline_alt` option alters the syntax, while the `collate`, `nosubs` and
|
||||
`icase` options modify how the case and locale sensitivity are to be applied.
|
||||
=newline_alt= option alters the syntax, while the =collate=, =nosubs= and
|
||||
=icase= options modify how the case and locale sensitivity are to be applied.
|
||||
|
||||
[h3 Pattern Modifiers]
|
||||
|
||||
The perl `smix` modifiers can either be applied using a `(?smix-smix)`
|
||||
The perl =smix= modifiers can either be applied using a =(?smix-smix)=
|
||||
prefix to the regular expression, or with one of the
|
||||
[link boost_regex.ref.syntax_option_type.syntax_option_type_perl regex-compile time
|
||||
flags `no_mod_m`, `mod_x`, `mod_s`, and `no_mod_s`].
|
||||
flags =no_mod_m=, =mod_x=, =mod_s=, and =no_mod_s=].
|
||||
|
||||
[h3 References]
|
||||
|
||||
|
||||
Reference in New Issue
Block a user