From 8a9cfdb118cd246da29c9ee82292947f70f02e70 Mon Sep 17 00:00:00 2001 From: ph10 Date: Sun, 19 Oct 2014 15:30:48 +0000 Subject: [PATCH] More documentation. --- Makefile.am | 4 +- doc/html/README.txt | 6 +- doc/html/pcre2api.html | 65 +- doc/html/pcre2pattern.html | 3202 +++++++++++++++++++++++++++++++++++ doc/html/pcre2test.html | 6 +- doc/pcre2.txt | 1937 ++++++++++++++++++++- doc/pcre2api.3 | 1 + doc/pcre2pattern.3 | 3241 ++++++++++++++++++++++++++++++++++++ doc/pcre2test.txt | 6 +- 9 files changed, 8403 insertions(+), 65 deletions(-) create mode 100644 doc/html/pcre2pattern.html create mode 100644 doc/pcre2pattern.3 diff --git a/Makefile.am b/Makefile.am index b56d6b4..57ab2fc 100644 --- a/Makefile.am +++ b/Makefile.am @@ -35,6 +35,7 @@ dist_html_DATA = \ doc/html/pcre2limits.html \ doc/html/pcre2matching.html \ doc/html/pcre2partial.html \ + doc/html/pcre2pattern.html \ doc/html/pcre2test.html \ doc/html/pcre2unicode.html @@ -65,7 +66,6 @@ dist_html_DATA = \ # doc/html/pcre2_utf16_to_host_byte_order.html \ # doc/html/pcre2_utf32_to_host_byte_order.html \ # doc/html/pcre2_version.html \ -# doc/html/pcre2pattern.html \ # doc/html/pcre2perform.html \ # doc/html/pcre2posix.html \ # doc/html/pcre2precompile.html \ @@ -87,6 +87,7 @@ dist_man_MANS = \ doc/pcre2limits.3 \ doc/pcre2matching.3 \ doc/pcre2partial.3 \ + doc/pcre2pattern.3 \ doc/pcre2test.1 \ doc/pcre2unicode.3 @@ -119,7 +120,6 @@ dist_man_MANS = \ # doc/pcre2_utf16_to_host_byte_order.3 \ # doc/pcre2_utf32_to_host_byte_order.3 \ # doc/pcre2_version.3 \ -# doc/pcre2pattern.3 \ # doc/pcre2perform.3 \ # doc/pcre2posix.3 \ # doc/pcre2precompile.3 \ diff --git a/doc/html/README.txt b/doc/html/README.txt index 95c8747..f6bb0b6 100644 --- a/doc/html/README.txt +++ b/doc/html/README.txt @@ -164,10 +164,10 @@ library. They are also documented in the pcre2build man page. (See also "Shared libraries on Unix-like systems" below.) -. By default, only the 8-bit library is built. If you add --enable-pcre16 to +. By default, only the 8-bit library is built. If you add --enable-pcre2-16 to the "configure" command, the 16-bit library is also built. If you add - --enable-pcre32 to the "configure" command, the 32-bit library is also built. - If you want only the 16-bit or 32-bit library, use --disable-pcre8 to disable + --enable-pcre2-32 to the "configure" command, the 32-bit library is also built. + If you want only the 16-bit or 32-bit library, use --disable-pcre2-8 to disable building the 8-bit library. . If you want to include support for just-in-time compiling, which can give diff --git a/doc/html/pcre2api.html b/doc/html/pcre2api.html index 9c5d9cd..66a164f 100644 --- a/doc/html/pcre2api.html +++ b/doc/html/pcre2api.html @@ -258,7 +258,7 @@ document for an overview of all the PCRE2 documentation. int pcre2_pattern_info(const pcre2 *code, uint32_t what, void *where);

-int pcre2_config(uint32_t what, void *where, PCRE2_SIZE length); +int pcre2_config(uint32_t what, void *where);


PCRE2 8-BIT, 16-BIT, AND 32-BIT LIBRARIES

@@ -771,7 +771,7 @@ supplied, otherwise the system functions.


CHECKING BUILD-TIME OPTIONS

-int pcre2_config(uint32_t what, void *where, PCRE2_SIZE length); +int pcre2_config(uint32_t what, void *where);

The function pcre2_config() makes it possible for a PCRE2 client to @@ -782,15 +782,17 @@ documentation has more details about these optional features.

The first argument for pcre2_config() specifies which information is required. The second argument is a pointer to memory into which the information -is placed, with the final argument giving the length of this memory in bytes. -For calls that return numerical values, where should point to -appropriately aligned memory, with length set to at least the "sizeof" -the data type. +is placed. If NULL is passed, the function returns the amount of memory that is +needed for the requested information. For calls that return numerical values, +the value is in bytes; when requesting these values, where should point +to appropriately aligned memory. For calls that return strings, the required +length is given in code units, not counting the terminating zero.

-The returned value from pcre2_config() is zero on success, or the -negative error code PCRE2_ERROR_BADOPTION if the value in the first argument is -not recognized. The following information is available: +When requesting information, the returned value from pcre2_config() is +non-negative on success, or the negative error code PCRE2_ERROR_BADOPTION if +the value in the first argument is not recognized. The following information is +available: 

   PCRE2_CONFIG_BSR
@@ -806,10 +808,13 @@ compiling is available; otherwise it is set to zero. 
   PCRE2_CONFIG_JITTARGET
-FIXME: this needs sorting out once JIT is implemented. -If JIT support is available, the string contains the name of the architecture -for which the JIT compiler is configured, for example "x86 32bit (little endian -+ unaligned)". If JIT support is not available, FIXME. +The where argument should point to a buffer that is at least 48 code +units long. (The exact length needed can be found by calling +pcre2_config() with where set to NULL.) The buffer is filled with a +string that contains the name of the architecture for which the JIT compiler is +configured, for example "x86 32bit (little endian + unaligned)". If JIT support +is not available, PCRE2_ERROR_BADOPTION is returned, otherwise the length of +the string, in code units, is returned. 
   PCRE2_CONFIG_LINKSIZE
@@ -873,9 +878,12 @@ heap instead of recursive function calls. PCRE2_CONFIG_UNICODE_VERSION The where argument should point to a buffer that is at least 24 code -units long. If PCRE2 has been compiled without Unicode support, this is filled -with the text "Unicode not supported". Otherwise, the Unicode version string -(for example, "7.0.0") is returnd. The string is zero-terminated. +units long. (The exact length needed can be found by calling +pcre2_config() with where set to NULL.) If PCRE2 has been compiled +without Unicode support, the buffer is filled with the text "Unicode not +supported". Otherwise, the Unicode version string (for example, "7.0.0") is +inserted. The string is zero-terminated. The function returns the length of the +string in code units. 
   PCRE2_CONFIG_UNICODE
@@ -884,9 +892,12 @@ otherwise it is set to zero. Unicode support implies UTF support. 
   PCRE2_CONFIG_VERSION
-The where argument should point to a buffer that is at least 12 code -units long. It is filled with the PCRE2 version string, zero-terminated. -

+The where argument should point to a buffer that is at least 12 code +units long. (The exact length needed can be found by calling +pcre2_config() with where set to NULL.) The buffer is filled with +the PCRE2 version string, zero-terminated. The length of the string (in code +units) is returned. +


COMPILING A PATTERN

pcre2_code *pcre2_compile(PCRE2_SPTR pattern, PCRE2_SIZE length, @@ -1354,20 +1365,20 @@ can be processed in different locales. The pcre2_pattern_info() function returns information about a compiled pattern. The first argument is a pointer to the compiled pattern. The second argument specifies which piece of information is required, and the third -argument is a pointer to a variable to receive the data. The yield of the -function is zero for success, or one of the following negative numbers: +argument is a pointer to a variable to receive the data. If the third argument +is NULL, the first argument is ignored, and the function returns the size in +bytes of the variable that is required for the information requested. +Otherwise, The yield of the function is zero for success, or one of the +following negative numbers: 

   PCRE2_ERROR_NULL           the argument code was NULL
-                             the argument where was NULL
   PCRE2_ERROR_BADMAGIC       the "magic number" was not found
   PCRE2_ERROR_BADOPTION      the value of what was invalid
   PCRE2_ERROR_UNSET          the requested field is not set
The "magic number" is placed at the start of each compiled pattern as an simple -check against passing an arbitrary memory pointer. -Here is -a typical call of pcre2_pattern_info(), to obtain the length of the compiled -pattern: +check against passing an arbitrary memory pointer. Here is a typical call of +pcre2_pattern_info(), to obtain the length of the compiled pattern: 
   int rc;
   size_t length;
@@ -2570,7 +2581,7 @@ Cambridge CB2 3QH, England.
 

 
REVISION

 

-Last updated: 14 October 2014
+Last updated: 16 October 2014
 

 Copyright © 1997-2014 University of Cambridge.
 

diff --git a/doc/html/pcre2pattern.html b/doc/html/pcre2pattern.html
new file mode 100644
index 0000000..4c8168b
--- /dev/null
+++ b/doc/html/pcre2pattern.html
@@ -0,0 +1,3202 @@
+
+
+pcre2pattern specification
+
+
+
pcre2pattern man page

+

+Return to the PCRE2 index page.
+

+

+This page is part of the PCRE2 HTML documentation. It was generated
+automatically from the original man page. If there is any nonsense in it,
+please consult the man page, in case the conversion went wrong.
+

+

+
PCRE2 REGULAR EXPRESSION DETAILS

+

+The syntax and semantics of the regular expressions that are supported by PCRE2
+are described in detail below. There is a quick-reference syntax summary in the
+pcre2syntax
+page. PCRE2 tries to match Perl syntax and semantics as closely as it can.
+PCRE2 also supports some alternative regular expression syntax (which does not
+conflict with the Perl syntax) in order to provide some compatibility with
+regular expressions in Python, .NET, and Oniguruma.
+

+

+Perl's regular expressions are described in its own documentation, and regular
+expressions in general are covered in a number of books, some of which have
+copious examples. Jeffrey Friedl's "Mastering Regular Expressions", published
+by O'Reilly, covers regular expressions in great detail. This description of
+PCRE2's regular expressions is intended as reference material.
+

+

+This document discusses the patterns that are supported by PCRE2 when its main
+matching function, pcre2_match(), is used. PCRE2 also has an alternative
+matching function, pcre2_dfa_match(), which matches using a different
+algorithm that is not Perl-compatible. Some of the features discussed below are
+not available when DFA matching is used. The advantages and disadvantages of
+the alternative function, and how it differs from the normal function, are
+discussed in the
+pcre2matching
+page.
+

+
SPECIAL START-OF-PATTERN ITEMS

+

+A number of options that can be passed to pcre2_compile() can also be set
+by special items at the start of a pattern. These are not Perl-compatible, but
+are provided to make these options accessible to pattern writers who are not
+able to change the program that processes the pattern. Any number of these
+items may appear, but they must all be together right at the start of the
+pattern string, and the letters must be in upper case.
+

+

+UTF support
+

+

+In the 8-bit and 16-bit PCRE2 libraries, characters may be coded either as
+single code units, or as multiple UTF-8 or UTF-16 code units. UTF-32 can be
+specified for the 32-bit library, in which case it constrains the character
+values to valid Unicode code points. To process UTF strings, PCRE2 must be
+built to include Unicode support. When using UTF strings you must either call
+the compiling function with the PCRE2_UTF option, or the pattern must start
+with the special sequence (*UTF), which is equivalent to setting the relevant
+option. How setting a UTF mode affects pattern matching is mentioned in several
+places below. There is also a summary of features in the
+pcre2unicode
+page.
+

+

+Some applications that allow their users to supply patterns may wish to
+restrict them to non-UTF data for security reasons. If the PCRE2_NEVER_UTF
+option is set at compile time, (*UTF) is not allowed, and its appearance causes
+an error.
+

+

+Unicode property support
+

+

+Another special sequence that may appear at the start of a pattern is (*UCP).
+This has the same effect as setting the PCRE2_UCP option: it causes sequences
+such as \d and \w to use Unicode properties to determine character types,
+instead of recognizing only characters with codes less than 128 via a lookup
+table.
+

+

+Disabling auto-possessification
+

+

+If a pattern starts with (*NO_AUTO_POSSESS), it has the same effect as setting
+the PCRE2_NO_AUTO_POSSESS option. This stops PCRE2 from making quantifiers
+possessive when what follows cannot match the repeated item. For example, by
+default a+b is treated as a++b. For more details, see the
+pcre2api
+documentation.
+

+

+Disabling start-up optimizations
+

+

+If a pattern starts with (*NO_START_OPT), it has the same effect as setting the
+PCRE2_NO_START_OPTIMIZE option. This disables several optimizations for quickly
+reaching "no match" results. For more details, see the
+pcre2api
+documentation.
+

+

+Newline conventions
+

+

+PCRE2 supports five different conventions for indicating line breaks in
+strings: a single CR (carriage return) character, a single LF (linefeed)
+character, the two-character sequence CRLF, any of the three preceding, or any
+Unicode newline sequence. The
+pcre2api
+page has
+further discussion
+about newlines, and shows how to set the newline convention when calling 
+pcre2_compile().
+

+

+It is also possible to specify a newline convention by starting a pattern
+string with one of the following five sequences:
+
+  (*CR)        carriage return
+  (*LF)        linefeed
+  (*CRLF)      carriage return, followed by linefeed
+  (*ANYCRLF)   any of the three above
+  (*ANY)       all Unicode newline sequences
+

+These override the default and the options given to the compiling function. For
+example, on a Unix system where LF is the default newline sequence, the pattern
+
+  (*CR)a.b
+

+changes the convention to CR. That pattern matches "a\nb" because LF is no
+longer a newline. If more than one of these settings is present, the last one
+is used.
+

+

+The newline convention affects where the circumflex and dollar assertions are
+true. It also affects the interpretation of the dot metacharacter when
+PCRE2_DOTALL is not set, and the behaviour of \N. However, it does not affect
+what the \R escape sequence matches. By default, this is any Unicode newline
+sequence, for Perl compatibility. However, this can be changed; see the
+description of \R in the section entitled
+"Newline sequences"
+below. A change of \R setting can be combined with a change of newline
+convention.
+

+

+Setting match and recursion limits
+

+

+The caller of pcre2_match() can set a limit on the number of times the
+internal match() function is called and on the maximum depth of
+recursive calls. These facilities are provided to catch runaway matches that
+are provoked by patterns with huge matching trees (a typical example is a
+pattern with nested unlimited repeats) and to avoid running out of system stack
+by too much recursion. When one of these limits is reached, pcre2_match()
+gives an error return. The limits can also be set by items at the start of the
+pattern of the form
+
+  (*LIMIT_MATCH=d)
+  (*LIMIT_RECURSION=d)
+

+where d is any number of decimal digits. However, the value of the setting must
+be less than the value set (or defaulted) by the caller of pcre2_match()
+for it to have any effect. In other words, the pattern writer can lower the
+limits set by the programmer, but not raise them. If there is more than one
+setting of one of these limits, the lower value is used.
+

+
EBCDIC CHARACTER CODES

+

+PCRE2 can be compiled to run in an environment that uses EBCDIC as its
+character code rather than ASCII or Unicode (typically a mainframe system). In
+the sections below, character code values are ASCII or Unicode; in an EBCDIC
+environment these characters may have different code values, and there are no
+code points greater than 255.
+

+
CHARACTERS AND METACHARACTERS

+

+A regular expression is a pattern that is matched against a subject string from
+left to right. Most characters stand for themselves in a pattern, and match the
+corresponding characters in the subject. As a trivial example, the pattern
+
+  The quick brown fox
+

+matches a portion of a subject string that is identical to itself. When
+caseless matching is specified (the PCRE2_CASELESS option), letters are matched
+independently of case. 
+

+

+The power of regular expressions comes from the ability to include alternatives
+and repetitions in the pattern. These are encoded in the pattern by the use of
+metacharacters, which do not stand for themselves but instead are
+interpreted in some special way.
+

+

+There are two different sets of metacharacters: those that are recognized
+anywhere in the pattern except within square brackets, and those that are
+recognized within square brackets. Outside square brackets, the metacharacters
+are as follows:
+
+  \      general escape character with several uses
+  ^      assert start of string (or line, in multiline mode)
+  $      assert end of string (or line, in multiline mode)
+  .      match any character except newline (by default)
+  [      start character class definition
+  |      start of alternative branch
+  (      start subpattern
+  )      end subpattern
+  ?      extends the meaning of (
+         also 0 or 1 quantifier
+         also quantifier minimizer
+  *      0 or more quantifier
+  +      1 or more quantifier
+         also "possessive quantifier"
+  {      start min/max quantifier
+

+Part of a pattern that is in square brackets is called a "character class". In
+a character class the only metacharacters are:
+
+  \      general escape character
+  ^      negate the class, but only if the first character
+  -      indicates character range
+  [      POSIX character class (only if followed by POSIX syntax)
+  ]      terminates the character class
+

+The following sections describe the use of each of the metacharacters.
+

+
BACKSLASH

+

+The backslash character has several uses. Firstly, if it is followed by a
+character that is not a number or a letter, it takes away any special meaning
+that character may have. This use of backslash as an escape character applies
+both inside and outside character classes.
+

+

+For example, if you want to match a * character, you write \* in the pattern.
+This escaping action applies whether or not the following character would
+otherwise be interpreted as a metacharacter, so it is always safe to precede a
+non-alphanumeric with backslash to specify that it stands for itself. In
+particular, if you want to match a backslash, you write \\.
+

+

+In a UTF mode, only ASCII numbers and letters have any special meaning after a
+backslash. All other characters (in particular, those whose codepoints are
+greater than 127) are treated as literals.
+

+

+If a pattern is compiled with the PCRE2_EXTENDED option, most white space in
+the pattern (other than in a character class), and characters between a #
+outside a character class and the next newline, inclusive, are ignored. An
+escaping backslash can be used to include a white space or # character as part
+of the pattern.
+

+

+If you want to remove the special meaning from a sequence of characters, you
+can do so by putting them between \Q and \E. This is different from Perl in
+that $ and @ are handled as literals in \Q...\E sequences in PCRE2, whereas
+in Perl, $ and @ cause variable interpolation. Note the following examples:
+
+  Pattern            PCRE2 matches   Perl matches
+
+  \Qabc$xyz\E        abc$xyz        abc followed by the contents of $xyz
+  \Qabc\$xyz\E       abc\$xyz       abc\$xyz
+  \Qabc\E\$\Qxyz\E   abc$xyz        abc$xyz
+

+The \Q...\E sequence is recognized both inside and outside character classes.
+An isolated \E that is not preceded by \Q is ignored. If \Q is not followed
+by \E later in the pattern, the literal interpretation continues to the end of
+the pattern (that is, \E is assumed at the end). If the isolated \Q is inside
+a character class, this causes an error, because the character class is not
+terminated.
+

+

+Non-printing characters
+

+

+A second use of backslash provides a way of encoding non-printing characters
+in patterns in a visible manner. There is no restriction on the appearance of
+non-printing characters in a pattern, but when a pattern is being prepared by
+text editing, it is often easier to use one of the following escape sequences
+than the binary character it represents:
+
+  \a        alarm, that is, the BEL character (hex 07)
+  \cx       "control-x", where x is any ASCII character
+  \e        escape (hex 1B)
+  \f        form feed (hex 0C)
+  \n        linefeed (hex 0A)
+  \r        carriage return (hex 0D)
+  \t        tab (hex 09)
+  \0dd      character with octal code 0dd
+  \ddd      character with octal code ddd, or back reference
+  \o{ddd..} character with octal code ddd..
+  \xhh      character with hex code hh
+  \x{hhh..} character with hex code hhh.. (default mode)
+  \uhhhh    character with hex code hhhh (when PCRE2_ALT_BSUX is set)
+

+The precise effect of \cx on ASCII characters is as follows: if x is a lower
+case letter, it is converted to upper case. Then bit 6 of the character (hex
+40) is inverted. Thus \cA to \cZ become hex 01 to hex 1A (A is 41, Z is 5A),
+but \c{ becomes hex 3B ({ is 7B), and \c; becomes hex 7B (; is 3B). If the
+code unit following \c has a value greater than 127, a compile-time error
+occurs. This locks out non-ASCII characters in all modes.
+

+

+The \c facility was designed for use with ASCII characters, but with the
+extension to Unicode it is even less useful than it once was. It is, however,
+recognized when PCRE2 is compiled in EBCDIC mode, where data items are always
+bytes. In this mode, all values are valid after \c. If the next character is a
+lower case letter, it is converted to upper case. Then the 0xc0 bits of the
+byte are inverted. Thus \cA becomes hex 01, as in ASCII (A is C1), but because
+the EBCDIC letters are disjoint, \cZ becomes hex 29 (Z is E9), and other
+characters also generate different values.
+

+

+After \0 up to two further octal digits are read. If there are fewer than two
+digits, just those that are present are used. Thus the sequence \0\x\07
+specifies two binary zeros followed by a BEL character (code value 7). Make
+sure you supply two digits after the initial zero if the pattern character that
+follows is itself an octal digit.
+

+

+The escape \o must be followed by a sequence of octal digits, enclosed in
+braces. An error occurs if this is not the case. This escape is a recent
+addition to Perl; it provides way of specifying character code points as octal
+numbers greater than 0777, and it also allows octal numbers and back references
+to be unambiguously specified.
+

+

+For greater clarity and unambiguity, it is best to avoid following \ by a
+digit greater than zero. Instead, use \o{} or \x{} to specify character
+numbers, and \g{} to specify back references. The following paragraphs
+describe the old, ambiguous syntax.
+

+

+The handling of a backslash followed by a digit other than 0 is complicated,
+and Perl has changed in recent releases, causing PCRE2 also to change. Outside
+a character class, PCRE2 reads the digit and any following digits as a decimal
+number. If the number is less than 8, 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 following \ is greater than
+7 and there have not been that many capturing subpatterns, PCRE2 handles \8
+and \9 as the literal characters "8" and "9", and otherwise re-reads up to
+three octal digits following the backslash, using them to generate a data
+character. Any subsequent digits stand for themselves. For example:
+
+  \040   is another way of writing an ASCII space
+  \40    is the same, provided there are fewer than 40 previous capturing subpatterns
+  \7     is always a back reference
+  \11    might be a back reference, or another way of writing a tab
+  \011   is always a tab
+  \0113  is a tab followed by the character "3"
+  \113   might be a back reference, otherwise the character with octal code 113
+  \377   might be a back reference, otherwise the value 255 (decimal)
+  \81    is either a back reference, or the two characters "8" and "1"
+

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

+

+By default, after \x that is not followed by {, from zero to two hexadecimal
+digits are read (letters can be in upper or lower case). Any number of
+hexadecimal digits may appear between \x{ and }. If a character other than
+a hexadecimal digit appears between \x{ and }, or if there is no terminating
+}, an error occurs.
+

+

+If the PCRE2_ALT_BSUX option is set, the interpretation of \x is as just
+described only when it is followed by two hexadecimal digits. Otherwise, it
+matches a literal "x" character. In this mode mode, support for code points
+greater than 256 is provided by \u, which must be followed by four hexadecimal
+digits; otherwise it matches a literal "u" character.
+

+

+Characters whose value is less than 256 can be defined by either of the two
+syntaxes for \x (or by \u in PCRE2_ALT_BSUX mode). There is no difference in
+the way they are handled. For example, \xdc is exactly the same as \x{dc} (or
+\u00dc in PCRE2_ALT_BSUX mode).
+

+

+Constraints on character values
+

+

+Characters that are specified using octal or hexadecimal numbers are
+limited to certain values, as follows:
+
+  8-bit non-UTF mode    less than 0x100
+  8-bit UTF-8 mode      less than 0x10ffff and a valid codepoint
+  16-bit non-UTF mode   less than 0x10000
+  16-bit UTF-16 mode    less than 0x10ffff and a valid codepoint
+  32-bit non-UTF mode   less than 0x100000000
+  32-bit UTF-32 mode    less than 0x10ffff and a valid codepoint
+

+Invalid Unicode codepoints are the range 0xd800 to 0xdfff (the so-called
+"surrogate" codepoints), and 0xffef.
+

+

+Escape sequences in character classes
+

+

+All the sequences that define a single character value can be used both inside
+and outside character classes. In addition, inside a character class, \b is
+interpreted as the backspace character (hex 08).
+

+

+\N is not allowed in a character class. \B, \R, and \X are not special
+inside a character class. Like other unrecognized alphabetic escape sequences,
+they cause an error. Outside a character class, these sequences have different
+meanings.
+

+

+Unsupported escape sequences
+

+

+In Perl, the sequences \l, \L, \u, and \U are recognized by its string
+handler and used to modify the case of following characters. By default, PCRE2
+does not support these escape sequences. However, if the PCRE2_ALT_BSUX option
+is set, \U matches a "U" character, and \u can be used to define a character
+by code point, as described in the previous section.
+

+

+Absolute and relative back references
+

+

+The sequence \g followed by an unsigned or a negative number, optionally
+enclosed in braces, is an absolute or relative back reference. A named back
+reference can be coded as \g{name}. Back references are discussed
+later,
+following the discussion of
+parenthesized subpatterns.
+

+

+Absolute and relative subroutine calls
+

+

+For compatibility with Oniguruma, the non-Perl syntax \g followed by a name or
+a number enclosed either in angle brackets or single quotes, is an alternative
+syntax for referencing a subpattern as a "subroutine". Details are discussed
+later.
+Note that \g{...} (Perl syntax) and \g<...> (Oniguruma syntax) are not
+synonymous. The former is a back reference; the latter is a
+subroutine
+call.
+

+

+Generic character types
+

+

+Another use of backslash is for specifying generic character types:
+
+  \d     any decimal digit
+  \D     any character that is not a decimal digit
+  \h     any horizontal white space character
+  \H     any character that is not a horizontal white space character
+  \s     any white space character
+  \S     any character that is not a white space character
+  \v     any vertical white space character
+  \V     any character that is not a vertical white space character
+  \w     any "word" character
+  \W     any "non-word" character
+

+There is also the single sequence \N, which matches a non-newline character.
+This is the same as
+the "." metacharacter
+when PCRE2_DOTALL is not set. Perl also uses \N to match characters by name;
+PCRE2 does not support this.
+

+

+Each pair of lower and upper case escape sequences partitions the complete set
+of characters into two disjoint sets. Any given character matches one, and only
+one, of each pair. The sequences can appear both inside and outside character
+classes. They each match one character of the appropriate type. If the current
+matching point is at the end of the subject string, all of them fail, because
+there is no character to match.
+

+

+The default \s characters are HT (9), LF (10), VT (11), FF (12), CR (13), and
+space (32), which are defined as white space in the "C" locale. This list may
+vary if locale-specific matching is taking place. For example, in some locales
+the "non-breaking space" character (\xA0) is recognized as white space, and in
+others the VT character is not.
+

+

+A "word" character is an underscore or any character that is a letter or digit.
+By default, the definition of letters and digits is controlled by PCRE2's
+low-valued character tables, and may vary if locale-specific matching is taking
+place (see
+"Locale support"
+in the
+pcre2api
+page). For example, in a French locale such as "fr_FR" in Unix-like systems,
+or "french" in Windows, some character codes greater than 127 are used for
+accented letters, and these are then matched by \w. The use of locales with
+Unicode is discouraged.
+

+

+By default, characters whose code points are greater than 127 never match \d,
+\s, or \w, and always match \D, \S, and \W, although this may vary for
+characters in the range 128-255 when locale-specific matching is happening.
+These escape sequences retain their original meanings from before Unicode
+support was available, mainly for efficiency reasons. If PCRE2 is compiled with
+Unicode support, and the PCRE2_UCP option is set, the behaviour is changed so
+that Unicode properties are used to determine character types, as follows:
+
+  \d  any character that matches \p{Nd} (decimal digit)
+  \s  any character that matches \p{Z} or \h or \v
+  \w  any character that matches \p{L} or \p{N}, plus underscore
+

+The upper case escapes match the inverse sets of characters. Note that \d
+matches only decimal digits, whereas \w matches any Unicode digit, as well as
+any Unicode letter, and underscore. Note also that PCRE2_UCP affects \b, and
+\B because they are defined in terms of \w and \W. Matching these sequences
+is noticeably slower when PCRE2_UCP is set.
+

+

+The sequences \h, \H, \v, and \V, in contrast to the other sequences, which
+match only ASCII characters by default, always match a specific list of code
+points, whether or not PCRE2_UCP is set. The horizontal space characters are:
+
+  U+0009     Horizontal tab (HT)
+  U+0020     Space
+  U+00A0     Non-break space
+  U+1680     Ogham space mark
+  U+180E     Mongolian vowel separator
+  U+2000     En quad
+  U+2001     Em quad
+  U+2002     En space
+  U+2003     Em space
+  U+2004     Three-per-em space
+  U+2005     Four-per-em space
+  U+2006     Six-per-em space
+  U+2007     Figure space
+  U+2008     Punctuation space
+  U+2009     Thin space
+  U+200A     Hair space
+  U+202F     Narrow no-break space
+  U+205F     Medium mathematical space
+  U+3000     Ideographic space
+

+The vertical space characters are:
+
+  U+000A     Linefeed (LF)
+  U+000B     Vertical tab (VT)
+  U+000C     Form feed (FF)
+  U+000D     Carriage return (CR)
+  U+0085     Next line (NEL)
+  U+2028     Line separator
+  U+2029     Paragraph separator
+

+In 8-bit, non-UTF-8 mode, only the characters with code points less than 256
+are relevant.
+

+

+Newline sequences
+

+

+Outside a character class, by default, the escape sequence \R matches any
+Unicode newline sequence. In 8-bit non-UTF-8 mode \R is equivalent to the
+following:
+
+  (?>\r\n|\n|\x0b|\f|\r|\x85)
+

+This is an example of an "atomic group", details of which are given
+below.
+This particular group matches either the two-character sequence CR followed by
+LF, or one of the single characters LF (linefeed, U+000A), VT (vertical tab,
+U+000B), FF (form feed, U+000C), CR (carriage return, U+000D), or NEL (next
+line, U+0085). The two-character sequence is treated as a single unit that
+cannot be split.
+

+

+In other modes, two additional characters whose codepoints are greater than 255
+are added: LS (line separator, U+2028) and PS (paragraph separator, U+2029).
+Unicode support is not needed for these characters to be recognized.
+

+

+It is possible to restrict \R to match only CR, LF, or CRLF (instead of the
+complete set of Unicode line endings) by setting the option PCRE2_BSR_ANYCRLF
+at compile time. (BSR is an abbrevation for "backslash R".) This can be made
+the default when PCRE2 is built; if this is the case, the other behaviour can
+be requested via the PCRE2_BSR_UNICODE option. It is also possible to specify
+these settings by starting a pattern string with one of the following
+sequences:
+
+  (*BSR_ANYCRLF)   CR, LF, or CRLF only
+  (*BSR_UNICODE)   any Unicode newline sequence
+

+These override the default and the options given to the compiling function.
+Note that these special settings, which are not Perl-compatible, are recognized
+only at the very start of a pattern, and that they must be in upper case. If
+more than one of them is present, the last one is used. They can be combined
+with a change of newline convention; for example, a pattern can start with:
+
+  (*ANY)(*BSR_ANYCRLF)
+

+They can also be combined with the (*UTF) or (*UCP) special sequences. Inside a
+character class, \R is treated as an unrecognized escape sequence, and causes
+an error.
+

+

+Unicode character properties
+

+

+When PCRE2 is built with Unicode support, three additional escape sequences
+that match characters with specific properties are available. In 8-bit
+non-UTF-8 mode, these sequences are of course limited to testing characters
+whose codepoints are less than 256, but they do work in this mode. The extra
+escape sequences are:
+
+  \p{xx}   a character with the xx property
+  \P{xx}   a character without the xx property
+  \X       a Unicode extended grapheme cluster
+

+The property names represented by xx above are limited to the Unicode
+script names, the general category properties, "Any", which matches any
+character (including newline), and some special PCRE2 properties (described
+in the
+next section).
+Other Perl properties such as "InMusicalSymbols" are not supported by PCRE2.
+Note that \P{Any} does not match any characters, so always causes a match
+failure.
+

+

+Sets of Unicode characters are defined as belonging to certain scripts. A
+character from one of these sets can be matched using a script name. For
+example:
+
+  \p{Greek}
+  \P{Han}
+

+Those that are not part of an identified script are lumped together as
+"Common". The current list of scripts is:
+

+

+Arabic,
+Armenian,
+Avestan,
+Balinese,
+Bamum,
+Bassa_Vah,
+Batak,
+Bengali,
+Bopomofo,
+Brahmi,
+Braille,
+Buginese,
+Buhid,
+Canadian_Aboriginal,
+Carian,
+Caucasian_Albanian,
+Chakma,
+Cham,
+Cherokee,
+Common,
+Coptic,
+Cuneiform,
+Cypriot,
+Cyrillic,
+Deseret,
+Devanagari,
+Duployan,
+Egyptian_Hieroglyphs,
+Elbasan,
+Ethiopic,
+Georgian,
+Glagolitic,
+Gothic,
+Grantha,
+Greek,
+Gujarati,
+Gurmukhi,
+Han,
+Hangul,
+Hanunoo,
+Hebrew,
+Hiragana,
+Imperial_Aramaic,
+Inherited,
+Inscriptional_Pahlavi,
+Inscriptional_Parthian,
+Javanese,
+Kaithi,
+Kannada,
+Katakana,
+Kayah_Li,
+Kharoshthi,
+Khmer,
+Khojki,
+Khudawadi,
+Lao,
+Latin,
+Lepcha,
+Limbu,
+Linear_A,
+Linear_B,
+Lisu,
+Lycian,
+Lydian,
+Mahajani,
+Malayalam,
+Mandaic,
+Manichaean,
+Meetei_Mayek,
+Mende_Kikakui,
+Meroitic_Cursive,
+Meroitic_Hieroglyphs,
+Miao,
+Modi,
+Mongolian,
+Mro,
+Myanmar,
+Nabataean,
+New_Tai_Lue,
+Nko,
+Ogham,
+Ol_Chiki,
+Old_Italic,
+Old_North_Arabian,
+Old_Permic,
+Old_Persian,
+Old_South_Arabian,
+Old_Turkic,
+Oriya,
+Osmanya,
+Pahawh_Hmong,
+Palmyrene,
+Pau_Cin_Hau,
+Phags_Pa,
+Phoenician,
+Psalter_Pahlavi,
+Rejang,
+Runic,
+Samaritan,
+Saurashtra,
+Sharada,
+Shavian,
+Siddham,
+Sinhala,
+Sora_Sompeng,
+Sundanese,
+Syloti_Nagri,
+Syriac,
+Tagalog,
+Tagbanwa,
+Tai_Le,
+Tai_Tham,
+Tai_Viet,
+Takri,
+Tamil,
+Telugu,
+Thaana,
+Thai,
+Tibetan,
+Tifinagh,
+Tirhuta,
+Ugaritic,
+Vai,
+Warang_Citi,
+Yi.
+

+

+Each character has exactly one Unicode general category property, specified by
+a two-letter abbreviation. For compatibility with Perl, negation can be
+specified by including a circumflex between the opening brace and the property
+name. For example, \p{^Lu} is the same as \P{Lu}.
+

+

+If only one letter is specified with \p or \P, it includes all the general
+category properties that start with that letter. In this case, in the absence
+of negation, the curly brackets in the escape sequence are optional; these two
+examples have the same effect:
+
+  \p{L}
+  \pL
+

+The following general category property codes are supported:
+
+  C     Other
+  Cc    Control
+  Cf    Format
+  Cn    Unassigned
+  Co    Private use
+  Cs    Surrogate
+
+  L     Letter
+  Ll    Lower case letter
+  Lm    Modifier letter
+  Lo    Other letter
+  Lt    Title case letter
+  Lu    Upper case letter
+
+  M     Mark
+  Mc    Spacing mark
+  Me    Enclosing mark
+  Mn    Non-spacing mark
+
+  N     Number
+  Nd    Decimal number
+  Nl    Letter number
+  No    Other number
+
+  P     Punctuation
+  Pc    Connector punctuation
+  Pd    Dash punctuation
+  Pe    Close punctuation
+  Pf    Final punctuation
+  Pi    Initial punctuation
+  Po    Other punctuation
+  Ps    Open punctuation
+
+  S     Symbol
+  Sc    Currency symbol
+  Sk    Modifier symbol
+  Sm    Mathematical symbol
+  So    Other symbol
+
+  Z     Separator
+  Zl    Line separator
+  Zp    Paragraph separator
+  Zs    Space separator
+

+The special property L& is also supported: it matches a character that has
+the Lu, Ll, or Lt property, in other words, a letter that is not classified as
+a modifier or "other".
+

+

+The Cs (Surrogate) property applies only to characters in the range U+D800 to
+U+DFFF. Such characters are not valid in Unicode strings and so
+cannot be tested by PCRE2, unless UTF validity checking has been turned off
+(see the discussion of PCRE2_NO_UTF_CHECK in the
+pcre2api
+page). Perl does not support the Cs property.
+

+

+The long synonyms for property names that Perl supports (such as \p{Letter})
+are not supported by PCRE2, nor is it permitted to prefix any of these
+properties with "Is".
+

+

+No character that is in the Unicode table has the Cn (unassigned) property.
+Instead, this property is assumed for any code point that is not in the
+Unicode table.
+

+

+Specifying caseless matching does not affect these escape sequences. For
+example, \p{Lu} always matches only upper case letters. This is different from
+the behaviour of current versions of Perl.
+

+

+Matching characters by Unicode property is not fast, because PCRE2 has to do a
+multistage table lookup in order to find a character's property. That is why
+the traditional escape sequences such as \d and \w do not use Unicode
+properties in PCRE2 by default, though you can make them do so by setting the
+PCRE2_UCP option or by starting the pattern with (*UCP).
+

+

+Extended grapheme clusters
+

+

+The \X escape matches any number of Unicode characters that form an "extended
+grapheme cluster", and treats the sequence as an atomic group
+(see below).
+Unicode supports various kinds of composite character by giving each character
+a grapheme breaking property, and having rules that use these properties to
+define the boundaries of extended grapheme clusters. \X always matches at
+least one character. Then it decides whether to add additional characters
+according to the following rules for ending a cluster:
+

+

+1. End at the end of the subject string.
+

+

+2. Do not end between CR and LF; otherwise end after any control character.
+

+

+3. Do not break Hangul (a Korean script) syllable sequences. Hangul characters
+are of five types: L, V, T, LV, and LVT. An L character may be followed by an
+L, V, LV, or LVT character; an LV or V character may be followed by a V or T
+character; an LVT or T character may be follwed only by a T character.
+

+

+4. Do not end before extending characters or spacing marks. Characters with
+the "mark" property always have the "extend" grapheme breaking property.
+

+

+5. Do not end after prepend characters.
+

+

+6. Otherwise, end the cluster.
+

+

+PCRE2's additional properties
+

+

+As well as the standard Unicode properties described above, PCRE2 supports four
+more that make it possible to convert traditional escape sequences such as \w
+and \s to use Unicode properties. PCRE2 uses these non-standard, non-Perl
+properties internally when PCRE2_UCP is set. However, they may also be used
+explicitly. These properties are:
+
+  Xan   Any alphanumeric character
+  Xps   Any POSIX space character
+  Xsp   Any Perl space character
+  Xwd   Any Perl "word" character
+

+Xan matches characters that have either the L (letter) or the N (number)
+property. Xps matches the characters tab, linefeed, vertical tab, form feed, or
+carriage return, and any other character that has the Z (separator) property.
+Xsp is the same as Xps; in PCRE1 it used to exclude vertical tab, for Perl
+compatibility, but Perl changed. Xwd matches the same characters as Xan, plus
+underscore.
+

+

+There is another non-standard property, Xuc, which matches any character that
+can be represented by a Universal Character Name in C++ and other programming
+languages. These are the characters $, @, ` (grave accent), and all characters
+with Unicode code points greater than or equal to U+00A0, except for the
+surrogates U+D800 to U+DFFF. Note that most base (ASCII) characters are
+excluded. (Universal Character Names are of the form \uHHHH or \UHHHHHHHH
+where H is a hexadecimal digit. Note that the Xuc property does not match these
+sequences but the characters that they represent.)
+

+

+Resetting the match start
+

+

+The escape sequence \K causes any previously matched characters not to be
+included in the final matched sequence. For example, the pattern:
+
+  foo\Kbar
+

+matches "foobar", but reports that it has matched "bar". This feature is
+similar to a lookbehind assertion
+(described below).
+However, in this case, the part of the subject before the real match does not
+have to be of fixed length, as lookbehind assertions do. The use of \K does
+not interfere with the setting of
+captured substrings.
+For example, when the pattern
+
+  (foo)\Kbar
+

+matches "foobar", the first substring is still set to "foo".
+

+

+Perl documents that the use of \K within assertions is "not well defined". In
+PCRE2, \K is acted upon when it occurs inside positive assertions, but is
+ignored in negative assertions. Note that when a pattern such as (?=ab\K)
+matches, the reported start of the match can be greater than the end of the
+match.
+

+

+Simple assertions
+

+

+The final use of backslash is for certain simple assertions. 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:
+
+  \b     matches at a word boundary
+  \B     matches when not at a word boundary
+  \A     matches at the start of the subject
+  \Z     matches at the end of the subject
+          also matches before a newline at the end of the subject
+  \z     matches only at the end of the subject
+  \G     matches at the first matching position in the subject
+

+Inside a character class, \b has a different meaning; it matches the backspace
+character. If any other of these assertions appears in a character class, an
+"invalid escape sequence" error is generated.
+

+

+A word boundary is a position in the subject string where the current character
+and the previous character do not both match \w or \W (i.e. one matches
+\w and the other matches \W), or the start or end of the string if the
+first or last character matches \w, respectively. In a UTF mode, the meanings
+of \w and \W can be changed by setting the PCRE2_UCP option. When this is
+done, it also affects \b and \B. Neither PCRE2 nor Perl has a separate "start
+of word" or "end of word" metasequence. However, whatever follows \b normally
+determines which it is. For example, the fragment \ba matches "a" at the start
+of a word.
+

+

+The \A, \Z, and \z assertions differ from the traditional circumflex and
+dollar (described in the next section) in that they only ever match at the very
+start and end of the subject string, whatever options are set. Thus, they are
+independent of multiline mode. These three assertions are not affected by the
+PCRE2_NOTBOL or PCRE2_NOTEOL options, which affect only the behaviour of the
+circumflex and dollar metacharacters. However, if the startoffset
+argument of pcre2_match() is non-zero, indicating that matching is to
+start at a point other than the beginning of the subject, \A can never match.
+The difference between \Z and \z is that \Z matches before a newline at the
+end of the string as well as at the very end, whereas \z matches only at the
+end.
+

+

+The \G assertion is true only when the current matching position is at the
+start point of the match, as specified by the startoffset argument of
+pcre2_match(). It differs from \A when the value of startoffset is
+non-zero. By calling pcre2_match() multiple times with appropriate
+arguments, you can mimic Perl's /g option, and it is in this kind of
+implementation where \G can be useful.
+

+

+Note, however, that PCRE2's interpretation of \G, as the start of the current
+match, is subtly different from Perl's, which defines it as the end of the
+previous match. In Perl, these can be different when the previously matched
+string was empty. Because PCRE2 does just one match at a time, it cannot
+reproduce this behaviour.
+

+

+If all the alternatives of a pattern begin with \G, the expression is anchored
+to the starting match position, and the "anchored" flag is set in the compiled
+regular expression.
+

+
CIRCUMFLEX AND DOLLAR

+

+The circumflex and dollar metacharacters are zero-width assertions. That is,
+they test for a particular condition being true without consuming any
+characters from the subject string.
+

+

+Outside a character class, in the default matching mode, the circumflex
+character is an assertion that is true only if the current matching point is at
+the start of the subject string. If the startoffset argument of
+pcre2_match() is non-zero, circumflex can never match if the
+PCRE2_MULTILINE option is unset. Inside a character class, circumflex has an
+entirely different meaning
+(see below).
+

+

+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
+"anchored" pattern. (There are also other constructs that can cause a pattern
+to be anchored.)
+

+

+The dollar character is an assertion that is true only if the current matching
+point is at the end of the subject string, or immediately before a newline at
+the end of the string (by default). Note, however, that it does not actually
+match the newline. Dollar 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. Dollar has no special meaning in a character class.
+

+

+The meaning of dollar can be changed so that it matches only at the very end of
+the string, by setting the PCRE2_DOLLAR_ENDONLY option at compile time. This
+does not affect the \Z assertion.
+

+

+The meanings of the circumflex and dollar characters are changed if the
+PCRE2_MULTILINE option is set. When this is the case, a circumflex matches
+immediately after internal newlines as well as at the start of the subject
+string. It does not match after a newline that ends the string. A dollar
+matches before any newlines in the string, as well as at the very end, when
+PCRE2_MULTILINE is set. When newline is specified as the two-character
+sequence CRLF, isolated CR and LF characters do not indicate newlines.
+

+

+For example, the pattern /^abc$/ matches the subject string "def\nabc" (where
+\n represents a newline) in multiline mode, but not otherwise. Consequently,
+patterns that are anchored in single line mode because all branches start with
+^ are not anchored in multiline mode, and a match for circumflex is possible
+when the startoffset argument of pcre2_match() is non-zero. The
+PCRE2_DOLLAR_ENDONLY option is ignored if PCRE2_MULTILINE is set.
+

+

+Note that the sequences \A, \Z, and \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
+\A it is always anchored, whether or not PCRE2_MULTILINE is set.
+

+
FULL STOP (PERIOD, DOT) AND \N

+

+Outside a character class, a dot in the pattern matches any one character in
+the subject string except (by default) a character that signifies the end of a
+line.
+

+

+When a line ending is defined as a single character, dot never matches that
+character; when the two-character sequence CRLF is used, dot does not match CR
+if it is immediately followed by LF, but otherwise it matches all characters
+(including isolated CRs and LFs). When any Unicode line endings are being
+recognized, dot does not match CR or LF or any of the other line ending
+characters.
+

+

+The behaviour of dot with regard to newlines can be changed. If the
+PCRE2_DOTALL option is set, a dot matches any one character, without exception.
+If the two-character sequence CRLF is present in the subject string, it takes
+two dots to match it.
+

+

+The handling of dot is entirely independent of the handling of circumflex and
+dollar, the only relationship being that they both involve newlines. Dot has no
+special meaning in a character class.
+

+

+The escape sequence \N behaves like a dot, except that it is not affected by
+the PCRE2_DOTALL option. In other words, it matches any character except one
+that signifies the end of a line. Perl also uses \N to match characters by
+name; PCRE2 does not support this.
+

+
MATCHING A SINGLE CODE UNIT

+

+Outside a character class, the escape sequence \C matches any one code unit,
+whether or not a UTF mode is set. In the 8-bit library, one code unit is one
+byte; in the 16-bit library it is a 16-bit unit; in the 32-bit library it is a
+32-bit unit. Unlike a dot, \C always matches line-ending characters. The
+feature is provided in Perl in order to match individual bytes in UTF-8 mode,
+but it is unclear how it can usefully be used. Because \C breaks up characters
+into individual code units, matching one unit with \C in a UTF mode means that
+the rest of the string may start with a malformed UTF character. This has
+undefined results, because PCRE2 assumes that it is dealing with valid UTF
+strings (and by default it checks this at the start of processing unless the
+PCRE2_NO_UTF_CHECK option is used).
+

+

+PCRE2 does not allow \C to appear in lookbehind assertions
+(described below)
+in a UTF mode, because this would make it impossible to calculate the length of
+the lookbehind.
+

+

+In general, the \C escape sequence is best avoided. However, one way of using
+it that avoids the problem of malformed UTF characters is to use a lookahead to
+check the length of the next character, as in this pattern, which could be used
+with a UTF-8 string (ignore white space and line breaks):
+
+  (?| (?=[\x00-\x7f])(\C) |
+      (?=[\x80-\x{7ff}])(\C)(\C) |
+      (?=[\x{800}-\x{ffff}])(\C)(\C)(\C) |
+      (?=[\x{10000}-\x{1fffff}])(\C)(\C)(\C)(\C))
+

+In this example, a group that starts with (?| resets the capturing parentheses
+numbers in each alternative (see
+"Duplicate Subpattern Numbers"
+below). The assertions at the start of each branch check the next UTF-8
+character for values whose encoding uses 1, 2, 3, or 4 bytes, respectively. The
+character's individual bytes are then captured by the appropriate number of
+\C groups.
+

+
SQUARE BRACKETS AND 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 by default.
+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. This means that, by default, an empty class cannot 
+be defined. However, if the PCRE2_ALLOW_EMPTY_CLASS option is set, a closing 
+square bracket at the start does end the (empty) class.
+

+

+A character class matches a single character in the subject. A matched
+character must be in the set of characters defined by the class, unless the
+first character in the class definition 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 notation for specifying the characters that
+are in the class by enumerating those that are not. A class that starts with a
+circumflex is not an assertion; it still consumes a character from the subject
+string, and therefore it fails if the current pointer is at the end of the
+string.
+

+

+When caseless matching is set, any letters in a class represent both their
+upper case and lower case versions, so for example, a caseless [aeiou] matches
+"A" as well as "a", and a caseless [^aeiou] does not match "A", whereas a
+caseful version would. 
+

+

+Characters that might indicate line breaks are never treated in any special way
+when matching character classes, whatever line-ending sequence is in use, and
+whatever setting of the PCRE2_DOTALL and PCRE2_MULTILINE options is used. A
+class such as [^a] always matches one of these characters.
+

+

+The minus (hyphen) character can be used to specify a range of characters in a
+character class. For example, [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, or
+immediately after a range. For example, [b-d-z] matches letters in the range b
+to d, a hyphen character, or z.
+

+

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

+

+An error is generated if a POSIX character class (see below) or an escape
+sequence other than one that defines a single character appears at a point
+where a range ending character is expected. For example, [z-\xff] is valid,
+but [A-\d] and [A-[:digit:]] are not.
+

+

+Ranges operate in the collating sequence of character values. They can also be
+used for characters specified numerically, for example [\000-\037]. Ranges
+can include any characters that are valid for the current mode.
+

+

+If a range that includes letters is used when caseless matching is set, it
+matches the letters in either case. For example, [W-c] is equivalent to
+[][\\^_`wxyzabc], matched caselessly, and in a non-UTF mode, if character
+tables for a French locale are in use, [\xc8-\xcb] matches accented E
+characters in both cases.
+

+

+The character escape sequences \d, \D, \h, \H, \p, \P, \s, \S, \v,
+\V, \w, and \W may appear in a character class, and add the characters that
+they match to the class. For example, [\dABCDEF] matches any hexadecimal
+digit. In UTF modes, the PCRE2_UCP option affects the meanings of \d, \s, \w
+and their upper case partners, just as it does when they appear outside a
+character class, as described in the section entitled
+"Generic character types"
+above. The escape sequence \b has a different meaning inside a character
+class; it matches the backspace character. The sequences \B, \N, \R, and \X
+are not special inside a character class. Like any other unrecognized escape
+sequences, they cause an error.
+

+

+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 [^\W_] matches any letter or digit, but not underscore,
+whereas [\w] includes underscore. A positive character class should be read as
+"something OR something OR ..." and a negative class as "NOT something AND NOT
+something AND NOT ...".
+

+

+The only metacharacters that are recognized in character classes are backslash,
+hyphen (only where it can be interpreted as specifying a range), circumflex
+(only at the start), opening square bracket (only when it can be interpreted as
+introducing a POSIX class name, or for a special compatibility feature - see
+the next two sections), and the terminating closing square bracket. However,
+escaping other non-alphanumeric characters does no harm.
+

+
POSIX CHARACTER CLASSES

+

+Perl supports the POSIX notation for character classes. This uses names
+enclosed by [: and :] within the enclosing square brackets. PCRE2 also supports
+this notation. For example,
+
+  [01[:alpha:]%]
+

+matches "0", "1", any alphabetic character, or "%". The supported class names
+are:
+
+  alnum    letters and digits
+  alpha    letters
+  ascii    character codes 0 - 127
+  blank    space or tab only
+  cntrl    control characters
+  digit    decimal digits (same as \d)
+  graph    printing characters, excluding space
+  lower    lower case letters
+  print    printing characters, including space
+  punct    printing characters, excluding letters and digits and space
+  space    white space (the same as \s from PCRE2 8.34)
+  upper    upper case letters
+  word     "word" characters (same as \w)
+  xdigit   hexadecimal digits
+

+The default "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13),
+and space (32). If locale-specific matching is taking place, the list of space
+characters may be different; there may be fewer or more of them. "Space" and
+\s match the same set of characters.
+

+

+The name "word" is a Perl extension, and "blank" is a GNU extension from Perl
+5.8. Another Perl extension is negation, which is indicated by a ^ character
+after the colon. For example,
+
+  [12[:^digit:]]
+

+matches "1", "2", or any non-digit. PCRE2 (and Perl) also recognize the POSIX
+syntax [.ch.] and [=ch=] where "ch" is a "collating element", but these are not
+supported, and an error is given if they are encountered.
+

+

+By default, characters with values greater than 128 do not match any of the
+POSIX character classes. However, if the PCRE2_UCP option is passed to
+pcre2_compile(), some of the classes are changed so that Unicode
+character properties are used. This is achieved by replacing certain POSIX
+classes by other sequences, as follows:
+
+  [:alnum:]  becomes  \p{Xan}
+  [:alpha:]  becomes  \p{L}
+  [:blank:]  becomes  \h
+  [:cntrl:]  becomes  \p{Cc} 
+  [:digit:]  becomes  \p{Nd}
+  [:lower:]  becomes  \p{Ll}
+  [:space:]  becomes  \p{Xps}
+  [:upper:]  becomes  \p{Lu}
+  [:word:]   becomes  \p{Xwd}
+

+Negated versions, such as [:^alpha:] use \P instead of \p. Three other POSIX
+classes are handled specially in UCP mode:
+

+

+[:graph:]
+This matches characters that have glyphs that mark the page when printed. In
+Unicode property terms, it matches all characters with the L, M, N, P, S, or Cf
+properties, except for:
+
+  U+061C           Arabic Letter Mark
+  U+180E           Mongolian Vowel Separator
+  U+2066 - U+2069  Various "isolate"s
+
+

+

+

+[:print:]
+This matches the same characters as [:graph:] plus space characters that are
+not controls, that is, characters with the Zs property.
+

+

+[:punct:]
+This matches all characters that have the Unicode P (punctuation) property,
+plus those characters with code points less than 128 that have the S (Symbol)
+property.
+

+

+The other POSIX classes are unchanged, and match only characters with code
+points less than 128.
+

+
COMPATIBILITY FEATURE FOR WORD BOUNDARIES

+

+In the POSIX.2 compliant library that was included in 4.4BSD Unix, the ugly
+syntax [[:<:]] and [[:>:]] is used for matching "start of word" and "end of
+word". PCRE2 treats these items as follows:
+
+  [[:<:]]  is converted to  \b(?=\w)
+  [[:>:]]  is converted to  \b(?<=\w)
+

+Only these exact character sequences are recognized. A sequence such as
+[a[:<:]b] provokes error for an unrecognized POSIX class name. This support is
+not compatible with Perl. It is provided to help migrations from other
+environments, and is best not used in any new patterns. Note that \b matches
+at the start and the end of a word (see
+"Simple assertions"
+above), and in a Perl-style pattern the preceding or following character
+normally shows which is wanted, without the need for the assertions that are
+used above in order to give exactly the POSIX behaviour.
+

+
VERTICAL BAR

+

+Vertical bar characters are used to separate alternative patterns. For example,
+the pattern
+
+  gilbert|sullivan
+

+matches either "gilbert" or "sullivan". Any number of alternatives may appear,
+and an empty alternative is permitted (matching the empty string). The matching
+process tries each alternative in turn, from left to right, and the first one
+that succeeds is used. If the alternatives are within a subpattern
+(defined below),
+"succeeds" means matching the rest of the main pattern as well as the
+alternative in the subpattern.
+

+
INTERNAL OPTION SETTING

+

+The settings of the PCRE2_CASELESS, PCRE2_MULTILINE, PCRE2_DOTALL, and
+PCRE2_EXTENDED options (which are Perl-compatible) can be changed from within
+the pattern by a sequence of Perl option letters enclosed between "(?" and ")".
+The option letters are
+
+  i  for PCRE2_CASELESS
+  m  for PCRE2_MULTILINE
+  s  for PCRE2_DOTALL
+  x  for PCRE2_EXTENDED
+

+For example, (?im) sets caseless, multiline matching. It is also possible to
+unset these options by preceding the letter with a hyphen, and a combined
+setting and unsetting such as (?im-sx), which sets PCRE2_CASELESS and
+PCRE2_MULTILINE while unsetting PCRE2_DOTALL and PCRE2_EXTENDED, is also
+permitted. If a letter appears both before and after the hyphen, the option is
+unset.
+

+

+The PCRE2-specific options PCRE2_DUPNAMES and PCRE2_UNGREEDY can be changed in
+the same way as the Perl-compatible options by using the characters J and U
+respectively.
+

+

+When one of these option changes occurs at top level (that is, not inside
+subpattern parentheses), the change applies to the remainder of the pattern
+that follows. If the change is placed right at the start of a pattern, PCRE2
+extracts it into the global options (and it will therefore show up in data
+extracted by the pcre2_pattern_info() function).
+

+

+An option change within a subpattern (see below for a description of
+subpatterns) affects only that part of the subpattern that follows it, so
+
+  (a(?i)b)c
+

+matches abc and aBc and no other strings (assuming PCRE2_CASELESS is not 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 example,
+
+  (a(?i)b|c)
+

+matches "ab", "aB", "c", and "C", even though when matching "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.
+

+

+Note: There are other PCRE2-specific options that can be set by the
+application when the compiling function is called.
+The pattern can contain special leading sequences such as (*CRLF) to override
+what the application has set or what has been defaulted. Details are given in
+the section entitled
+"Newline sequences"
+above. There are also the (*UTF) and (*UCP) leading sequences that can be used
+to set UTF and Unicode property modes; they are equivalent to setting the
+PCRE2_UTF and PCRE2_UCP options, respectively. However, the application can set
+the PCRE2_NEVER_UTF and PCRE2_NEVER_UCP options, which lock out the use of the
+(*UTF) and (*UCP) sequences.
+

+
SUBPATTERNS

+

+Subpatterns are delimited by parentheses (round brackets), which can be nested.
+Turning part of a pattern into a subpattern does two things:
+

+

+1. It localizes a set of alternatives. For example, the pattern
+
+  cat(aract|erpillar|)
+

+matches "cataract", "caterpillar", or "cat". Without the parentheses, it would
+match "cataract", "erpillar" or an empty string.
+

+

+2. It sets up the subpattern as a capturing subpattern. This means that, when
+the whole pattern matches, the portion of the subject string that matched the
+subpattern is passed back to the caller, separately from the portion that 
+matched the whole pattern. (This applies only to the traditional matching
+function; the DFA matching function does not support capturing.)
+

+

+Opening parentheses are counted from left to right (starting from 1) to obtain
+numbers for the capturing subpatterns. For example, if the string "the red
+king" is matched against the pattern
+
+  the ((red|white) (king|queen))
+

+the captured substrings are "red king", "red", and "king", and are numbered 1,
+2, and 3, respectively.
+

+

+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 a question mark
+and a colon, 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 "the white queen" is matched against the pattern
+
+  the ((?:red|white) (king|queen))
+

+the captured substrings are "white queen" and "queen", and are numbered 1 and
+2. The maximum number of capturing subpatterns is 65535.
+

+

+As a convenient shorthand, if any option settings are required at the start of
+a non-capturing subpattern, the option letters may appear between the "?" and
+the ":". Thus the two patterns
+
+  (?i:saturday|sunday)
+  (?:(?i)saturday|sunday)
+

+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 "SUNDAY" as well as "Saturday".
+

+
DUPLICATE SUBPATTERN NUMBERS

+

+Perl 5.10 introduced a feature whereby each alternative in a subpattern uses
+the same numbers for its capturing parentheses. Such a subpattern starts with
+(?| and is itself a non-capturing subpattern. For example, consider this
+pattern:
+
+  (?|(Sat)ur|(Sun))day
+

+Because the two alternatives are inside a (?| group, both sets of capturing
+parentheses are numbered one. Thus, when the pattern matches, you can look
+at captured substring number one, whichever alternative matched. This construct
+is useful when you want to capture part, but not all, of one of a number of
+alternatives. Inside a (?| group, parentheses are numbered as usual, but the
+number is reset at the start of each branch. The numbers of any capturing
+parentheses that follow the subpattern start after the highest number used in
+any branch. The following example is taken from the Perl documentation. The
+numbers underneath show in which buffer the captured content will be stored.
+
+  # before  ---------------branch-reset----------- after
+  / ( a )  (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
+  # 1            2         2  3        2     3     4
+

+A back reference to a numbered subpattern uses the most recent value that is
+set for that number by any subpattern. The following pattern matches "abcabc"
+or "defdef":
+
+  /(?|(abc)|(def))\1/
+

+In contrast, a subroutine call to a numbered subpattern always refers to the
+first one in the pattern with the given number. The following pattern matches
+"abcabc" or "defabc":
+
+  /(?|(abc)|(def))(?1)/
+

+If a
+condition test
+for a subpattern's having matched refers to a non-unique number, the test is
+true if any of the subpatterns of that number have matched.
+

+

+An alternative approach to using this "branch reset" feature is to use
+duplicate named subpatterns, as described in the next section.
+

+
NAMED SUBPATTERNS

+

+Identifying capturing parentheses by number is simple, but it can be very hard
+to keep track of the numbers in complicated regular expressions. Furthermore,
+if an expression is modified, the numbers may change. To help with this
+difficulty, PCRE2 supports the naming of subpatterns. This feature was not
+added to Perl until release 5.10. Python had the feature earlier, and PCRE1
+introduced it at release 4.0, using the Python syntax. PCRE2 supports both the
+Perl and the Python syntax. Perl allows identically numbered subpatterns to
+have different names, but PCRE2 does not.
+

+

+In PCRE2, a subpattern can be named in one of three ways: (?<name>...) or
+(?'name'...) as in Perl, or (?P<name>...) as in Python. References to capturing
+parentheses from other parts of the pattern, such as
+back references,
+recursion,
+and
+conditions,
+can be made by name as well as by number.
+

+

+Names consist of up to 32 alphanumeric characters and underscores, but must
+start with a non-digit. Named capturing parentheses are still allocated numbers
+as well as names, exactly as if the names were not present. The PCRE2 API
+provides function calls for extracting the name-to-number translation table
+from a compiled pattern. There are also convenience functions for extracting a
+captured substring by name.
+

+

+By default, a name must be unique within a pattern, but it is possible to relax
+this constraint by setting the PCRE2_DUPNAMES option at compile time.
+(Duplicate names are also always permitted for subpatterns with the same
+number, set up as described in the previous section.) Duplicate names can be
+useful for patterns where only one instance of the named parentheses can match.
+Suppose you want to match the name of a weekday, either as a 3-letter
+abbreviation or as the full name, and in both cases you want to extract the
+abbreviation. This pattern (ignoring the line breaks) does the job:
+
+  (?<DN>Mon|Fri|Sun)(?:day)?|
+  (?<DN>Tue)(?:sday)?|
+  (?<DN>Wed)(?:nesday)?|
+  (?<DN>Thu)(?:rsday)?|
+  (?<DN>Sat)(?:urday)?
+

+There are five capturing substrings, but only one is ever set after a match.
+(An alternative way of solving this problem is to use a "branch reset"
+subpattern, as described in the previous section.)
+

+

+The convenience functions for extracting the data by name returns the substring
+for the first (and in this example, the only) subpattern of that name that
+matched. This saves searching to find which numbered subpattern it was.
+

+

+If you make a back reference to a non-unique named subpattern from elsewhere in
+the pattern, the subpatterns to which the name refers are checked in the order
+in which they appear in the overall pattern. The first one that is set is used
+for the reference. For example, this pattern matches both "foofoo" and
+"barbar" but not "foobar" or "barfoo":
+
+  (?:(?<n>foo)|(?<n>bar))\k<n>
+
+

+

+

+If you make a subroutine call to a non-unique named subpattern, the one that
+corresponds to the first occurrence of the name is used. In the absence of
+duplicate numbers (see the previous section) this is the one with the lowest
+number.
+

+

+If you use a named reference in a condition
+test (see the
+section about conditions
+below), either to check whether a subpattern has matched, or to check for
+recursion, all subpatterns with the same name are tested. If the condition is
+true for any one of them, the overall condition is true. This is the same
+behaviour as testing by number. For further details of the interfaces for
+handling named subpatterns, see the
+pcre2api
+documentation.
+

+

+Warning: You cannot use different names to distinguish between two
+subpatterns with the same number because PCRE2 uses only the numbers when
+matching. For this reason, an error is given at compile time if different names
+are given to subpatterns with the same number. However, you can always give the
+same name to subpatterns with the same number, even when PCRE2_DUPNAMES is not
+set.
+

+
REPETITION

+

+Repetition is specified by quantifiers, which can follow any of the following
+items:
+
+  a literal data character
+  the dot metacharacter
+  the \C escape sequence
+  the \X escape sequence
+  the \R escape sequence
+  an escape such as \d or \pL that matches a single character
+  a character class
+  a back reference (see next section)
+  a parenthesized subpattern (including assertions)
+  a subroutine call to a subpattern (recursive or otherwise)
+

+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:
+
+  z{2,4}
+

+matches "zz", "zzz", or "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
+
+  [aeiou]{3,}
+

+matches at least 3 successive vowels, but may match many more, whereas
+
+  \d{8}
+

+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.
+

+

+In UTF modes, quantifiers apply to characters rather than to individual code
+units. Thus, for example, \x{100}{2} matches two characters, each of
+which is represented by a two-byte sequence in a UTF-8 string. Similarly,
+\X{3} matches three Unicode extended grapheme clusters, each of which may be
+several code units long (and they may be of different lengths).
+

+

+The quantifier {0} is permitted, causing the expression to behave as if the
+previous item and the quantifier were not present. This may be useful for
+subpatterns that are referenced as
+subroutines
+from elsewhere in the pattern (but see also the section entitled
+"Defining subpatterns for use by reference only"
+below). Items other than subpatterns that have a {0} quantifier are omitted
+from the compiled pattern.
+

+

+For convenience, the three most common quantifiers have single-character
+abbreviations:
+
+  *    is equivalent to {0,}
+  +    is equivalent to {1,}
+  ?    is equivalent to {0,1}
+

+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:
+
+  (a?)*
+

+Earlier versions of Perl and PCRE1 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.
+

+

+By default, the quantifiers are "greedy", 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 /* and */
+and within the comment, individual * and / characters may appear. An attempt to
+match C comments by applying the pattern
+
+  /\*.*\*/
+

+to the string
+
+  /* first comment */  not comment  /* second comment */
+

+fails, because it matches the entire string owing to the greediness of the .*
+item.
+

+

+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
+
+  /\*.*?\*/
+

+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
+
+  \d??\d
+

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

+

+If the PCRE2_UNGREEDY option is set (an option that 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.
+

+

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

+

+If a pattern starts with .* or .{0,} and the PCRE2_DOTALL option (equivalent
+to Perl's /s) is set, thus allowing the dot to match newlines, 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. PCRE2 normally treats such a
+pattern as though it were preceded by \A.
+

+

+In cases where it is known that the subject string contains no newlines, it is
+worth setting PCRE2_DOTALL in order to obtain this optimization, or
+alternatively, using ^ to indicate anchoring explicitly.
+

+

+However, there are some cases where the optimization cannot be used. When .*
+is inside capturing parentheses that are the subject of a back reference
+elsewhere in the pattern, a match at the start may fail where a later one
+succeeds. Consider, for example:
+
+  (.*)abc\1
+

+If the subject is "xyz123abc123" the match point is the fourth character. For
+this reason, such a pattern is not implicitly anchored.
+

+

+Another case where implicit anchoring is not applied is when the leading .* is
+inside an atomic group. Once again, a match at the start may fail where a later
+one succeeds. Consider this pattern:
+
+  (?>.*?a)b
+

+It matches "ab" in the subject "aab". The use of the backtracking control verbs
+(*PRUNE) and (*SKIP) also disable this optimization.
+

+

+When a capturing subpattern is repeated, the value captured is the substring
+that matched the final iteration. For example, after
+
+  (tweedle[dume]{3}\s*)+
+

+has matched "tweedledum tweedledee" the value of the captured substring is
+"tweedledee". However, if there are nested capturing subpatterns, the
+corresponding captured values may have been set in previous iterations. For
+example, after
+
+  (a|(b))+
+

+matches "aba" the value of the second captured substring is "b".
+

+
ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS

+

+With both maximizing ("greedy") and minimizing ("ungreedy" or "lazy")
+repetition, failure of what follows normally causes the repeated item to be
+re-evaluated 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 on.
+

+

+Consider, for example, the pattern \d+foo when applied to the subject line
+
+  123456bar
+

+After matching all 6 digits and then failing to match "foo", the normal
+action of the matcher is to try again with only 5 digits matching the \d+
+item, and then with 4, and so on, before ultimately failing. "Atomic grouping"
+(a term taken from Jeffrey Friedl's book) provides the means for specifying
+that once a subpattern has matched, it is not to be re-evaluated in this way.
+

+

+If we use atomic grouping for the previous example, the matcher gives up
+immediately on failing to match "foo" the first time. The notation is a kind of
+special parenthesis, starting with (?> as in this example:
+
+  (?>\d+)foo
+

+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
+normal.
+

+

+An alternative description is that a subpattern of this type matches exactly
+the string of characters that an identical standalone pattern would match, if
+anchored at the current point in the subject string.
+

+

+Atomic grouping 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 \d+ and \d+? are prepared to adjust the
+number of digits they match in order to make the rest of the pattern match,
+(?>\d+) can only match an entire sequence of digits.
+

+

+Atomic groups in general can of course contain arbitrarily complicated
+subpatterns, and can be nested. However, when the subpattern for an atomic
+group is just a single repeated item, as in the example above, a simpler
+notation, called a "possessive quantifier" can be used. This consists of an
+additional + character following a quantifier. Using this notation, the
+previous example can be rewritten as
+
+  \d++foo
+

+Note that a possessive quantifier can be used with an entire group, for
+example:
+
+  (abc|xyz){2,3}+
+

+Possessive quantifiers are always greedy; the setting of the PCRE2_UNGREEDY
+option is ignored. They are a convenient notation for the simpler forms of
+atomic group. However, there is no difference in the meaning of a possessive
+quantifier and the equivalent atomic group, though there may be a performance
+difference; possessive quantifiers should be slightly faster.
+

+

+The possessive quantifier syntax is an extension to the Perl 5.8 syntax.
+Jeffrey Friedl originated the idea (and the name) in the first edition of his
+book. Mike McCloskey liked it, so implemented it when he built Sun's Java
+package, and PCRE1 copied it from there. It ultimately found its way into Perl
+at release 5.10.
+

+

+PCRE2 has an optimization that automatically "possessifies" certain simple
+pattern constructs. For example, the sequence A+B is treated as A++B because
+there is no point in backtracking into a sequence of A's when B must follow.
+This feature can be disabled by the PCRE2_NO_AUTOPOSSESS option, or starting 
+the pattern with (*NO_AUTO_POSSESS).
+

+

+When a pattern contains an unlimited repeat inside a subpattern that can itself
+be repeated an unlimited number of times, the use of an atomic group is the
+only way to avoid some failing matches taking a very long time indeed. The
+pattern
+
+  (\D+|<\d+>)*[!?]
+

+matches an unlimited number of substrings that either consist of non-digits, or
+digits enclosed in <>, followed by either ! or ?. When it matches, it runs
+quickly. However, if it is applied to
+
+  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+

+it takes a long time before reporting failure. This is because the string can
+be divided between the internal \D+ repeat and the external * repeat in a
+large number of ways, and all have to be tried. (The example uses [!?] rather
+than a single character at the end, because both PCRE2 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 so that it uses
+an atomic group, like this:
+
+  ((?>\D+)|<\d+>)*[!?]
+

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

+
BACK REFERENCES

+

+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
+(that is, 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 8, 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 8. A "forward back reference" of this type can make sense
+when a repetition is involved and the subpattern to the right has participated
+in an earlier iteration.
+

+

+It is not possible to have a numerical "forward back reference" to a subpattern
+whose number is 8 or more using this syntax because a sequence such as \50 is
+interpreted as a character defined in octal. See the subsection entitled
+"Non-printing characters"
+above
+for further details of the handling of digits following a backslash. There is
+no such problem when named parentheses are used. A back reference to any
+subpattern is possible using named parentheses (see below).
+

+

+Another way of avoiding the ambiguity inherent in the use of digits following a
+backslash is to use the \g escape sequence. This escape must be followed by an
+unsigned number or a negative number, optionally enclosed in braces. These
+examples are all identical:
+
+  (ring), \1
+  (ring), \g1
+  (ring), \g{1}
+

+An unsigned number specifies an absolute reference without the ambiguity that
+is present in the older syntax. It is also useful when literal digits follow
+the reference. A negative number is a relative reference. Consider this
+example:
+
+  (abc(def)ghi)\g{-1}
+

+The sequence \g{-1} is a reference to the most recently started capturing
+subpattern before \g, that is, is it equivalent to \2 in this example.
+Similarly, \g{-2} would be equivalent to \1. The use of relative references
+can be helpful in long patterns, and also in patterns that are created by
+joining together fragments that contain references within themselves.
+

+

+A back reference matches whatever actually matched the capturing subpattern in
+the current subject string, rather than anything matching the subpattern
+itself (see
+"Subpatterns as subroutines"
+below for a way of doing that). So the pattern
+
+  (sens|respons)e and \1ibility
+

+matches "sense and sensibility" and "response and responsibility", but not
+"sense and responsibility". If caseful matching is in force at the time of the
+back reference, the case of letters is relevant. For example,
+
+  ((?i)rah)\s+\1
+

+matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original
+capturing subpattern is matched caselessly.
+

+

+There are several different ways of writing back references to named
+subpatterns. The .NET syntax \k{name} and the Perl syntax \k<name> or
+\k'name' are supported, as is the Python syntax (?P=name). Perl 5.10's unified
+back reference syntax, in which \g can be used for both numeric and named
+references, is also supported. We could rewrite the above example in any of
+the following ways:
+
+  (?<p1>(?i)rah)\s+\k<p1>
+  (?'p1'(?i)rah)\s+\k{p1}
+  (?P<p1>(?i)rah)\s+(?P=p1)
+  (?<p1>(?i)rah)\s+\g{p1}
+

+A subpattern that is referenced by name may appear in the pattern before or
+after the reference.
+

+

+There may be more than one back reference to the same subpattern. If a
+subpattern has not actually been used in a particular match, any back
+references to it always fail by default. For example, the pattern
+
+  (a|(bc))\2
+

+always fails if it starts to match "a" rather than "bc". However, if the
+PCRE2_MATCH_UNSET_BACKREF option is set at compile time, a back reference to an
+unset value matches an empty string.
+

+

+Because there may be many capturing parentheses in a pattern, all digits
+following a backslash are taken as part of a potential back reference number.
+If the pattern continues with a digit character, some delimiter must be used to
+terminate the back reference. If the PCRE2_EXTENDED option is set, this can be
+white space. Otherwise, the \g{ syntax or an empty comment (see
+"Comments"
+below) can be used.
+

+

+Recursive back references
+

+

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

+matches any number of "a"s and also "aba", "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.
+

+

+Back references of this type cause the group that they reference to be treated
+as an
+atomic group.
+Once the whole group has been matched, a subsequent matching failure cannot
+cause backtracking into the middle of the group.
+

+
ASSERTIONS

+

+An assertion is a test on the characters following or preceding the current
+matching point that does not consume any characters. The simple assertions
+coded as \b, \B, \A, \G, \Z, \z, ^ and $ 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. An assertion subpattern is matched in the normal way,
+except that it does not cause the current matching position to be changed.
+

+

+Assertion subpatterns are not capturing subpatterns. If such an 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. (Perl sometimes, but not
+always, does do capturing in negative assertions.)
+

+

+For compatibility with Perl, assertion subpatterns may be repeated; though
+it makes no sense to assert the same thing several times, the side effect of
+capturing parentheses may occasionally be useful. In practice, there only three
+cases:
+

+

+(1) If the quantifier is {0}, the assertion is never obeyed during matching.
+However, it may contain internal capturing parenthesized groups that are called
+from elsewhere via the
+subroutine mechanism.
+

+

+(2) If quantifier is {0,n} where n is greater than zero, it is treated as if it
+were {0,1}. At run time, the rest of the pattern match is tried with and
+without the assertion, the order depending on the greediness of the quantifier.
+

+

+(3) If the minimum repetition is greater than zero, the quantifier is ignored.
+The assertion is obeyed just once when encountered during matching.
+

+

+Lookahead assertions
+

+

+Lookahead assertions start with (?= for positive assertions and (?! for
+negative assertions. For example,
+
+  \w+(?=;)
+

+matches a word followed by a semicolon, but does not include the semicolon in
+the match, and
+
+  foo(?!bar)
+

+matches any occurrence of "foo" that is not followed by "bar". Note that the
+apparently similar pattern
+
+  (?!foo)bar
+

+does not find an occurrence of "bar" that is preceded by something other than
+"foo"; it finds any occurrence of "bar" whatsoever, because the assertion
+(?!foo) is always true when the next three characters are "bar". A
+lookbehind assertion is needed to achieve the other effect.
+

+

+If you want to force a matching failure at some point in a pattern, the most
+convenient way to do it is with (?!) because an empty string always matches, so
+an assertion that requires there not to be an empty string must always fail.
+The backtracking control verb (*FAIL) or (*F) is a synonym for (?!).
+

+

+Lookbehind assertions
+

+

+Lookbehind assertions start with (?<= for positive assertions and (?<! for
+negative assertions. For example,
+
+  (?<!foo)bar
+

+does find an occurrence of "bar" that is not preceded by "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 top-level alternatives, they
+do not all have to have the same fixed length. Thus
+
+  (?<=bullock|donkey)
+

+is permitted, but
+
+  (?<!dogs?|cats?)
+

+causes an error at compile time. Branches that match different length strings
+are permitted only at the top level of a lookbehind assertion. This is an
+extension compared with Perl, which requires all branches to match the same
+length of string. An assertion such as
+
+  (?<=ab(c|de))
+

+is not permitted, because its single top-level branch can match two different
+lengths, but it is acceptable to PCRE2 if rewritten to use two top-level
+branches:
+
+  (?<=abc|abde)
+

+In some cases, the escape sequence \K
+(see above)
+can be used instead of a lookbehind assertion to get round the fixed-length
+restriction.
+

+

+The implementation of lookbehind assertions is, for each alternative, to
+temporarily move the current position back by the fixed length and then try to
+match. If there are insufficient characters before the current position, the
+assertion fails.
+

+

+In a UTF mode, PCRE2 does not allow the \C escape (which matches a single code
+unit even in a UTF mode) to appear in lookbehind assertions, because it makes
+it impossible to calculate the length of the lookbehind. The \X and \R
+escapes, which can match different numbers of code units, are also not
+permitted.
+

+

+"Subroutine"
+calls (see below) such as (?2) or (?&X) are permitted in lookbehinds, as long
+as the subpattern matches a fixed-length string.
+Recursion,
+however, is not supported.
+

+

+Possessive quantifiers can be used in conjunction with lookbehind assertions to
+specify efficient matching of fixed-length strings at the end of subject
+strings. Consider a simple pattern such as
+
+  abcd$
+

+when applied to a long string that does not match. Because matching proceeds
+from left to right, PCRE2 will look for each "a" in the subject and then see if
+what follows matches the rest of the pattern. If the pattern is specified as
+
+  ^.*abcd$
+

+the initial .* matches the entire string at first, but when this fails (because
+there is no following "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 "a"
+covers the entire string, from right to left, so we are no better off. However,
+if the pattern is written as
+
+  ^.*+(?<=abcd)
+

+there can be no backtracking for the .*+ item because of the possessive 
+quantifier; 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.
+

+

+Using multiple assertions
+

+

+Several assertions (of any sort) may occur in succession. For example,
+
+  (?<=\d{3})(?<!999)foo
+

+matches "foo" preceded by three digits that are not "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 "999".
+This pattern does not match "foo" preceded by six characters, the first
+of which are digits and the last three of which are not "999". For example, it
+doesn't match "123abcfoo". A pattern to do that is
+
+  (?<=\d{3}...)(?<!999)foo
+

+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 "999".
+

+

+Assertions can be nested in any combination. For example,
+
+  (?<=(?<!foo)bar)baz
+

+matches an occurrence of "baz" that is preceded by "bar" which in turn is not
+preceded by "foo", while
+
+  (?<=\d{3}(?!999)...)foo
+

+is another pattern that matches "foo" preceded by three digits and any three
+characters that are not "999".
+

+
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 specific capturing subpattern has
+already been matched. The two possible forms of conditional subpattern are:
+
+  (?(condition)yes-pattern)
+  (?(condition)yes-pattern|no-pattern)
+

+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. Each of the two alternatives may
+itself contain nested subpatterns of any form, including conditional
+subpatterns; the restriction to two alternatives applies only at the level of
+the condition. This pattern fragment is an example where the alternatives are
+complex:
+
+  (?(1) (A|B|C) | (D | (?(2)E|F) | E) )
+
+

+

+

+There are four kinds of condition: references to subpatterns, references to
+recursion, a pseudo-condition called DEFINE, and assertions.
+

+

+Checking for a used subpattern by number
+

+

+If the text between the parentheses consists of a sequence of digits, the
+condition is true if a capturing subpattern of that number has previously
+matched. If there is more than one capturing subpattern with the same number
+(see the earlier
+section about duplicate subpattern numbers),
+the condition is true if any of them have matched. An alternative notation is
+to precede the digits with a plus or minus sign. In this case, the subpattern
+number is relative rather than absolute. The most recently opened parentheses
+can be referenced by (?(-1), the next most recent by (?(-2), and so on. Inside
+loops it can also make sense to refer to subsequent groups. The next
+parentheses to be opened can be referenced as (?(+1), and so on. (The value
+zero in any of these forms is not used; it provokes a compile-time error.)
+

+

+Consider the following pattern, which contains non-significant white space to
+make it more readable (assume the PCRE2_EXTENDED option) and to divide it into
+three parts for ease of discussion:
+
+  ( \( )?    [^()]+    (?(1) \) )
+

+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 or not the first set of parentheses
+matched. 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.
+

+

+If you were embedding this pattern in a larger one, you could use a relative
+reference:
+
+  ...other stuff... ( \( )?    [^()]+    (?(-1) \) ) ...
+

+This makes the fragment independent of the parentheses in the larger pattern.
+

+

+Checking for a used subpattern by name
+

+

+Perl uses the syntax (?(<name>)...) or (?('name')...) to test for a used
+subpattern by name. For compatibility with earlier versions of PCRE1, which had
+this facility before Perl, the syntax (?(name)...) is also recognized.
+

+

+Rewriting the above example to use a named subpattern gives this:
+
+  (?<OPEN> \( )?    [^()]+    (?(<OPEN>) \) )
+

+If the name used in a condition of this kind is a duplicate, the test is
+applied to all subpatterns of the same name, and is true if any one of them has
+matched.
+

+

+Checking for pattern recursion
+

+

+If the condition is the string (R), and there is no subpattern with the name R,
+the condition is true if a recursive call to the whole pattern or any
+subpattern has been made. If digits or a name preceded by ampersand follow the
+letter R, for example:
+
+  (?(R3)...) or (?(R&name)...)
+

+the condition is true if the most recent recursion is into a subpattern whose
+number or name is given. This condition does not check the entire recursion
+stack. If the name used in a condition of this kind is a duplicate, the test is
+applied to all subpatterns of the same name, and is true if any one of them is
+the most recent recursion.
+

+

+At "top level", all these recursion test conditions are false.
+The syntax for recursive patterns
+is described below.
+

+

+Defining subpatterns for use by reference only
+

+

+If the condition is the string (DEFINE), and there is no subpattern with the
+name DEFINE, the condition is always false. In this case, there may be only one
+alternative in the subpattern. It is always skipped if control reaches this
+point in the pattern; the idea of DEFINE is that it can be used to define
+subroutines that can be referenced from elsewhere. (The use of
+subroutines
+is described below.) For example, a pattern to match an IPv4 address such as
+"192.168.23.245" could be written like this (ignore white space and line
+breaks):
+
+  (?(DEFINE) (?<byte> 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )
+  \b (?&byte) (\.(?&byte)){3} \b
+

+The first part of the pattern is a DEFINE group inside which a another group
+named "byte" is defined. This matches an individual component of an IPv4
+address (a number less than 256). When matching takes place, this part of the
+pattern is skipped because DEFINE acts like a false condition. The rest of the
+pattern uses references to the named group to match the four dot-separated
+components of an IPv4 address, insisting on a word boundary at each end.
+

+

+Assertion conditions
+

+

+If the condition is not in any of the above formats, 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:
+
+  (?(?=[^a-z]*[a-z])
+  \d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} )
+

+The condition is a positive lookahead assertion that matches an optional
+sequence of non-letters followed by a letter. In other words, it tests for the
+presence of at least one letter in the subject. If a letter is found, the
+subject is matched against the first alternative; otherwise it is matched
+against the second. This pattern matches strings in one of the two forms
+dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.
+

+
COMMENTS

+

+There are two ways of including comments in patterns that are processed by
+PCRE2. In both cases, the start of the comment must not be in a character
+class, nor in the middle of any other sequence of related characters such as
+(?: or a subpattern name or number. The characters that make up a comment play
+no part in the pattern matching.
+

+

+The sequence (?# marks the start of a comment that continues up to the next
+closing parenthesis. Nested parentheses are not permitted. If the
+PCRE2_EXTENDED option is set, an unescaped # character also introduces a
+comment, which in this case continues to immediately after the next newline
+character or character sequence in the pattern. Which characters are
+interpreted as newlines is controlled by an option passed to the compiling
+function or by a special sequence at the start of the pattern, as described in
+the section entitled
+"Newline conventions"
+above. Note that the end of this type of comment is a literal newline sequence
+in the pattern; escape sequences that happen to represent a newline do not
+count. For example, consider this pattern when PCRE2_EXTENDED is set, and the
+default newline convention (a single linefeed character) is in force:
+
+  abc #comment \n still comment
+

+On encountering the # character, pcre2_compile() skips along, looking for
+a newline in the pattern. The sequence \n is still literal at this stage, so
+it does not terminate the comment. Only an actual character with the code value
+0x0a (the default newline) does so.
+

+
RECURSIVE PATTERNS

+

+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.
+

+

+For some time, Perl has provided a 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 using code interpolation to solve the parentheses problem can be
+created like this:
+
+  $re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
+

+The (?p{...}) item interpolates Perl code at run time, and in this case refers
+recursively to the pattern in which it appears.
+

+

+Obviously, PCRE2 cannot support the interpolation of Perl code. Instead, it
+supports special syntax for recursion of the entire pattern, and also for
+individual subpattern recursion. After its introduction in PCRE1 and Python,
+this kind of recursion was subsequently introduced into Perl at release 5.10.
+

+

+A special item that consists of (? followed by a number greater than zero and a
+closing parenthesis is a recursive subroutine call of the subpattern of the
+given number, provided that it occurs inside that subpattern. (If not, it is a
+non-recursive subroutine
+call, which is described in the next section.) The special item (?R) or (?0) is
+a recursive call of the entire regular expression.
+

+

+This PCRE2 pattern solves the nested parentheses problem (assume the
+PCRE2_EXTENDED option is set so that white space is ignored):
+
+  \( ( [^()]++ | (?R) )* \)
+

+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 (that is, a correctly parenthesized substring).
+Finally there is a closing parenthesis. Note the use of a possessive quantifier
+to avoid backtracking into sequences of non-parentheses.
+

+

+If this were part of a larger pattern, you would not want to recurse the entire
+pattern, so instead you could use this:
+
+  ( \( ( [^()]++ | (?1) )* \) )
+

+We have put the pattern into parentheses, and caused the recursion to refer to
+them instead of the whole pattern.
+

+

+In a larger pattern, keeping track of parenthesis numbers can be tricky. This
+is made easier by the use of relative references. Instead of (?1) in the
+pattern above you can write (?-2) to refer to the second most recently opened
+parentheses preceding the recursion. In other words, a negative number counts
+capturing parentheses leftwards from the point at which it is encountered.
+

+

+It is also possible to refer to subsequently opened parentheses, by writing
+references such as (?+2). However, these cannot be recursive because the
+reference is not inside the parentheses that are referenced. They are always
+non-recursive subroutine
+calls, as described in the next section.
+

+

+An alternative approach is to use named parentheses. The Perl syntax for this
+is (?&name); PCRE1's earlier syntax (?P>name) is also supported. We could
+rewrite the above example as follows:
+
+  (?<pn> \( ( [^()]++ | (?&pn) )* \) )
+

+If there is more than one subpattern with the same name, the earliest one is
+used.
+

+

+The example pattern that we have been looking at contains nested unlimited
+repeats, and so the use of a possessive quantifier for matching strings of
+non-parentheses is important when applying the pattern to strings that do not
+match. For example, when this pattern is applied to
+
+  (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
+

+it yields "no match" quickly. However, if a possessive quantifier is not used,
+the match runs for a very long time indeed because there are so many different
+ways the + and * repeats can carve up the subject, and all have to be tested
+before failure can be reported.
+

+

+At the end of a match, the values of capturing parentheses are those from
+the outermost level. If you want to obtain intermediate values, a callout
+function can be used (see below and the
+pcre2callout
+documentation). If the pattern above is matched against
+
+  (ab(cd)ef)
+

+the value for the inner capturing parentheses (numbered 2) is "ef", which is
+the last value taken on at the top level. If a capturing subpattern is not
+matched at the top level, its final captured value is unset, even if it was
+(temporarily) set at a deeper level during the matching process.
+

+

+If there are more than 15 capturing parentheses in a pattern, PCRE2 has to
+obtain extra memory from the heap to store data during a recursion. If no
+memory can be obtained, the match fails with the PCRE2_ERROR_NOMEMORY error.
+

+

+Do not confuse the (?R) item with the condition (R), which tests for recursion.
+Consider this pattern, which matches text in angle brackets, allowing for
+arbitrary nesting. Only digits are allowed in nested brackets (that is, when
+recursing), whereas any characters are permitted at the outer level.
+
+  < (?: (?(R) \d++  | [^<>]*+) | (?R)) * >
+

+In this pattern, (?(R) is the start of a conditional subpattern, with two
+different alternatives for the recursive and non-recursive cases. The (?R) item
+is the actual recursive call.
+

+

+Differences in recursion processing between PCRE2 and Perl
+

+

+Recursion processing in PCRE2 differs from Perl in two important ways. In PCRE2
+(like Python, but unlike Perl), a recursive subpattern call is always treated
+as an atomic group. That is, once it has matched some of the subject string, it
+is never re-entered, even if it contains untried alternatives and there is a
+subsequent matching failure. This can be illustrated by the following pattern,
+which purports to match a palindromic string that contains an odd number of
+characters (for example, "a", "aba", "abcba", "abcdcba"):
+
+  ^(.|(.)(?1)\2)$
+

+The idea is that it either matches a single character, or two identical
+characters surrounding a sub-palindrome. In Perl, this pattern works; in PCRE2
+it does not if the pattern is longer than three characters. Consider the
+subject string "abcba":
+

+

+At the top level, the first character is matched, but as it is not at the end
+of the string, the first alternative fails; the second alternative is taken
+and the recursion kicks in. The recursive call to subpattern 1 successfully
+matches the next character ("b"). (Note that the beginning and end of line
+tests are not part of the recursion).
+

+

+Back at the top level, the next character ("c") is compared with what
+subpattern 2 matched, which was "a". This fails. Because the recursion is
+treated as an atomic group, there are now no backtracking points, and so the
+entire match fails. (Perl is able, at this point, to re-enter the recursion and
+try the second alternative.) However, if the pattern is written with the
+alternatives in the other order, things are different:
+
+  ^((.)(?1)\2|.)$
+

+This time, the recursing alternative is tried first, and continues to recurse
+until it runs out of characters, at which point the recursion fails. But this
+time we do have another alternative to try at the higher level. That is the big
+difference: in the previous case the remaining alternative is at a deeper
+recursion level, which PCRE2 cannot use.
+

+

+To change the pattern so that it matches all palindromic strings, not just
+those with an odd number of characters, it is tempting to change the pattern to
+this:
+
+  ^((.)(?1)\2|.?)$
+

+Again, this works in Perl, but not in PCRE2, and for the same reason. When a
+deeper recursion has matched a single character, it cannot be entered again in
+order to match an empty string. The solution is to separate the two cases, and
+write out the odd and even cases as alternatives at the higher level:
+
+  ^(?:((.)(?1)\2|)|((.)(?3)\4|.))
+

+If you want to match typical palindromic phrases, the pattern has to ignore all
+non-word characters, which can be done like this:
+
+  ^\W*+(?:((.)\W*+(?1)\W*+\2|)|((.)\W*+(?3)\W*+\4|\W*+.\W*+))\W*+$
+

+If run with the PCRE2_CASELESS option, this pattern matches phrases such as "A
+man, a plan, a canal: Panama!" and it works in both PCRE2 and Perl. Note the
+use of the possessive quantifier *+ to avoid backtracking into sequences of
+non-word characters. Without this, PCRE2 takes a great deal longer (ten times
+or more) to match typical phrases, and Perl takes so long that you think it has
+gone into a loop.
+

+

+WARNING: The palindrome-matching patterns above work only if the subject
+string does not start with a palindrome that is shorter than the entire string.
+For example, although "abcba" is correctly matched, if the subject is "ababa",
+PCRE2 finds the palindrome "aba" at the start, then fails at top level because
+the end of the string does not follow. Once again, it cannot jump back into the
+recursion to try other alternatives, so the entire match fails.
+

+

+The second way in which PCRE2 and Perl differ in their recursion processing is
+in the handling of captured values. In Perl, when a subpattern is called
+recursively or as a subpattern (see the next section), it has no access to any
+values that were captured outside the recursion, whereas in PCRE2 these values
+can be referenced. Consider this pattern:
+
+  ^(.)(\1|a(?2))
+

+In PCRE2, this pattern matches "bab". The first capturing parentheses match "b",
+then in the second group, when the back reference \1 fails to match "b", the
+second alternative matches "a" and then recurses. In the recursion, \1 does
+now match "b" and so the whole match succeeds. In Perl, the pattern fails to
+match because inside the recursive call \1 cannot access the externally set
+value.
+

+
SUBPATTERNS AS SUBROUTINES

+

+If the syntax for a recursive subpattern call (either by number or by
+name) is used outside the parentheses to which it refers, it operates like a
+subroutine in a programming language. The called subpattern may be defined
+before or after the reference. A numbered reference can be absolute or
+relative, as in these examples:
+
+  (...(absolute)...)...(?2)...
+  (...(relative)...)...(?-1)...
+  (...(?+1)...(relative)...
+

+An earlier example pointed out that the pattern
+
+  (sens|respons)e and \1ibility
+

+matches "sense and sensibility" and "response and responsibility", but not
+"sense and responsibility". If instead the pattern
+
+  (sens|respons)e and (?1)ibility
+

+is used, it does match "sense and responsibility" as well as the other two
+strings. Another example is given in the discussion of DEFINE above.
+

+

+All subroutine calls, whether recursive or not, are always treated as atomic
+groups. That is, once a subroutine has matched some of the subject string, it
+is never re-entered, even if it contains untried alternatives and there is a
+subsequent matching failure. Any capturing parentheses that are set during the
+subroutine call revert to their previous values afterwards.
+

+

+Processing options such as case-independence are fixed when a subpattern is
+defined, so if it is used as a subroutine, such options cannot be changed for
+different calls. For example, consider this pattern:
+
+  (abc)(?i:(?-1))
+

+It matches "abcabc". It does not match "abcABC" because the change of
+processing option does not affect the called subpattern.
+

+
ONIGURUMA SUBROUTINE SYNTAX

+

+For compatibility with Oniguruma, the non-Perl syntax \g followed by a name or
+a number enclosed either in angle brackets or single quotes, is an alternative
+syntax for referencing a subpattern as a subroutine, possibly recursively. Here
+are two of the examples used above, rewritten using this syntax:
+
+  (?<pn> \( ( (?>[^()]+) | \g<pn> )* \) )
+  (sens|respons)e and \g'1'ibility
+

+PCRE2 supports an extension to Oniguruma: if a number is preceded by a
+plus or a minus sign it is taken as a relative reference. For example:
+
+  (abc)(?i:\g<-1>)
+

+Note that \g{...} (Perl syntax) and \g<...> (Oniguruma syntax) are not
+synonymous. The former is a back reference; the latter is a subroutine call.
+

+
CALLOUTS

+

+Perl has a feature whereby using the sequence (?{...}) causes arbitrary Perl
+code to be obeyed in the middle of matching a regular expression. This makes it
+possible, amongst other things, to extract different substrings that match the
+same pair of parentheses when there is a repetition.
+

+

+PCRE2 provides a similar feature, but of course it cannot obey arbitrary Perl
+code. The feature is called "callout". The caller of PCRE2 provides an external
+function by putting its entry point in a match context using the function 
+pcre2_set_callout() and passing the context to pcre2_match() or 
+pcre2_dfa_match(). If no match context is passed, or if the callout entry
+point is set to NULL, callouts are disabled.
+

+

+Within a regular expression, (?C) indicates the points at which the external
+function is to be called. If you want to identify different callout points, you
+can put a number less than 256 after the letter C. The default value is zero.
+For example, this pattern has two callout points:
+
+  (?C1)abc(?C2)def
+

+If the PCRE2_AUTO_CALLOUT flag is passed to pcre2_compile(), callouts are
+automatically installed before each item in the pattern. They are all numbered
+255. If there is a conditional group in the pattern whose condition is an
+assertion, an additional callout is inserted just before the condition. An
+explicit callout may also be set at this position, as in this example:
+
+  (?(?C9)(?=a)abc|def)
+

+Note that this applies only to assertion conditions, not to other types of
+condition.
+

+

+During matching, when PCRE2 reaches a callout point, the external function is
+called. It is provided with the number of the callout, the position in the
+pattern, and one item of data that is also set in the match block. The callout
+function may cause matching to proceed, to backtrack, or to fail.
+

+

+By default, PCRE2 implements a number of optimizations at matching time, and
+one side-effect is that sometimes callouts are skipped. If you need all
+possible callouts to happen, you need to set options that disable the relevant
+optimizations. More details, and a complete description of the interface to the
+callout function, are given in the
+pcre2callout
+documentation.
+

+
BACKTRACKING CONTROL

+

+Perl 5.10 introduced a number of "Special Backtracking Control Verbs", which
+are still described in the Perl documentation as "experimental and subject to
+change or removal in a future version of Perl". It goes on to say: "Their usage
+in production code should be noted to avoid problems during upgrades." The same
+remarks apply to the PCRE2 features described in this section.
+

+

+The new verbs make use of what was previously invalid syntax: an opening
+parenthesis followed by an asterisk. They are generally of the form
+(*VERB) or (*VERB:NAME). Some may take either form, possibly behaving
+differently depending on whether or not a name is present. A name is any
+sequence of characters that does not include a closing parenthesis. The maximum
+length of name is 255 in the 8-bit library and 65535 in the 16-bit and 32-bit
+libraries. If the name is empty, that is, if the closing parenthesis
+immediately follows the colon, the effect is as if the colon were not there.
+Any number of these verbs may occur in a pattern.
+

+

+Since these verbs are specifically related to backtracking, most of them can be
+used only when the pattern is to be matched using the traditional matching
+function, because these use a backtracking algorithm. With the exception of
+(*FAIL), which behaves like a failing negative assertion, the backtracking
+control verbs cause an error if encountered by the DFA matching function.
+

+

+The behaviour of these verbs in
+repeated groups,
+assertions,
+and in
+subpatterns called as subroutines
+(whether or not recursively) is documented below.
+

+

+Optimizations that affect backtracking verbs
+

+

+PCRE2 contains some optimizations that are used to speed up matching by running
+some checks at the start of each match attempt. For example, it may know the
+minimum length of matching subject, or that a particular character must be
+present. When one of these optimizations bypasses the running of a match, any
+included backtracking verbs will not, of course, be processed. You can suppress
+the start-of-match optimizations by setting the PCRE2_NO_START_OPTIMIZE option
+when calling pcre2_compile(), or by starting the pattern with
+(*NO_START_OPT). There is more discussion of this option in the section
+entitled
+"Compiling a pattern"
+in the
+pcre2api
+documentation.
+

+

+Experiments with Perl suggest that it too has similar optimizations, sometimes
+leading to anomalous results.
+

+

+Verbs that act immediately
+

+

+The following verbs act as soon as they are encountered. They may not be
+followed by a name.
+
+   (*ACCEPT)
+

+This verb causes the match to end successfully, skipping the remainder of the
+pattern. However, when it is inside a subpattern that is called as a
+subroutine, only that subpattern is ended successfully. Matching then continues
+at the outer level. If (*ACCEPT) in triggered in a positive assertion, the
+assertion succeeds; in a negative assertion, the assertion fails.
+

+

+If (*ACCEPT) is inside capturing parentheses, the data so far is captured. For
+example:
+
+  A((?:A|B(*ACCEPT)|C)D)
+

+This matches "AB", "AAD", or "ACD"; when it matches "AB", "B" is captured by
+the outer parentheses.
+
+  (*FAIL) or (*F)
+

+This verb causes a matching failure, forcing backtracking to occur. It is
+equivalent to (?!) but easier to read. The Perl documentation notes that it is
+probably useful only when combined with (?{}) or (??{}). Those are, of course,
+Perl features that are not present in PCRE2. The nearest equivalent is the
+callout feature, as for example in this pattern:
+
+  a+(?C)(*FAIL)
+

+A match with the string "aaaa" always fails, but the callout is taken before
+each backtrack happens (in this example, 10 times).
+

+

+Recording which path was taken
+

+

+There is one verb whose main purpose is to track how a match was arrived at,
+though it also has a secondary use in conjunction with advancing the match
+starting point (see (*SKIP) below).
+
+  (*MARK:NAME) or (*:NAME)
+

+A name is always required with this verb. There may be as many instances of
+(*MARK) as you like in a pattern, and their names do not have to be unique.
+

+

+When a match succeeds, the name of the last-encountered (*MARK:NAME),
+(*PRUNE:NAME), or (*THEN:NAME) on the matching path is passed back to the
+caller as described in the section entitled
+"Other information about the match"
+in the
+pcre2api
+documentation. Here is an example of pcre2test output, where the "mark"
+modifier requests the retrieval and outputting of (*MARK) data:
+
+    re> /X(*MARK:A)Y|X(*MARK:B)Z/mark
+  data> XY
+   0: XY
+  MK: A
+  XZ
+   0: XZ
+  MK: B
+

+The (*MARK) name is tagged with "MK:" in this output, and in this example it
+indicates which of the two alternatives matched. This is a more efficient way
+of obtaining this information than putting each alternative in its own
+capturing parentheses.
+

+

+If a verb with a name is encountered in a positive assertion that is true, the
+name is recorded and passed back if it is the last-encountered. This does not
+happen for negative assertions or failing positive assertions.
+

+

+After a partial match or a failed match, the last encountered name in the
+entire match process is returned. For example:
+
+    re> /X(*MARK:A)Y|X(*MARK:B)Z/mark
+  data> XP
+  No match, mark = B
+

+Note that in this unanchored example the mark is retained from the match
+attempt that started at the letter "X" in the subject. Subsequent match
+attempts starting at "P" and then with an empty string do not get as far as the
+(*MARK) item, but nevertheless do not reset it.
+

+

+If you are interested in (*MARK) values after failed matches, you should
+probably set the PCRE2_NO_START_OPTIMIZE option
+(see above)
+to ensure that the match is always attempted.
+

+

+Verbs that act after backtracking
+

+

+The following verbs do nothing when they are encountered. Matching continues
+with what follows, but if there is no subsequent match, causing a backtrack to
+the verb, a failure is forced. That is, backtracking cannot pass to the left of
+the verb. However, when one of these verbs appears inside an atomic group
+(which includes any group that is called as a subroutine) or in an assertion
+that is true, its effect is confined to that group, because once the group has
+been matched, there is never any backtracking into it. In this situation,
+backtracking has to jump to the left of the entire atomic group or assertion.
+

+

+These verbs differ in exactly what kind of failure occurs when backtracking
+reaches them. The behaviour described below is what happens when the verb is
+not in a subroutine or an assertion. Subsequent sections cover these special
+cases.
+
+  (*COMMIT)
+

+This verb, which may not be followed by a name, causes the whole match to fail
+outright if there is a later matching failure that causes backtracking to reach
+it. Even if the pattern is unanchored, no further attempts to find a match by
+advancing the starting point take place. If (*COMMIT) is the only backtracking
+verb that is encountered, once it has been passed pcre2_match() is
+committed to finding a match at the current starting point, or not at all. For
+example:
+
+  a+(*COMMIT)b
+

+This matches "xxaab" but not "aacaab". It can be thought of as a kind of
+dynamic anchor, or "I've started, so I must finish." The name of the most
+recently passed (*MARK) in the path is passed back when (*COMMIT) forces a
+match failure.
+

+

+If there is more than one backtracking verb in a pattern, a different one that
+follows (*COMMIT) may be triggered first, so merely passing (*COMMIT) during a
+match does not always guarantee that a match must be at this starting point.
+

+

+Note that (*COMMIT) at the start of a pattern is not the same as an anchor,
+unless PCRE2's start-of-match optimizations are turned off, as shown in this
+output from pcre2test:
+
+    re> /(*COMMIT)abc/
+  data> xyzabc
+   0: abc
+  data>  
+  re> /(*COMMIT)abc/no_start_optimize
+  data> xyzabc
+  No match
+

+For the first pattern, PCRE2 knows that any match must start with "a", so the
+optimization skips along the subject to "a" before applying the pattern to the
+first set of data. The match attempt then succeeds. The second pattern disables
+the optimization that skips along to the first character. The pattern is now
+applied starting at "x", and so the (*COMMIT) causes the match to fail without
+trying any other starting points.
+
+  (*PRUNE) or (*PRUNE:NAME)
+

+This verb causes the match to fail at the current starting position in the
+subject if there is a later matching failure that causes backtracking to reach
+it. If the pattern is unanchored, the normal "bumpalong" advance to the next
+starting character then happens. Backtracking can occur as usual to the left of
+(*PRUNE), before it is reached, or when matching to the right of (*PRUNE), but
+if there is no match to the right, backtracking cannot cross (*PRUNE). In
+simple cases, the use of (*PRUNE) is just an alternative to an atomic group or
+possessive quantifier, but there are some uses of (*PRUNE) that cannot be
+expressed in any other way. In an anchored pattern (*PRUNE) has the same effect
+as (*COMMIT).
+

+

+The behaviour of (*PRUNE:NAME) is the not the same as (*MARK:NAME)(*PRUNE).
+It is like (*MARK:NAME) in that the name is remembered for passing back to the
+caller. However, (*SKIP:NAME) searches only for names set with (*MARK), 
+ignoring those set by (*PRUNE) or (*THEN).
+
+  (*SKIP)
+

+This verb, when given without a name, is like (*PRUNE), except that if the
+pattern is unanchored, the "bumpalong" advance is not to the next character,
+but to the position in the subject where (*SKIP) was encountered. (*SKIP)
+signifies that whatever text was matched leading up to it cannot be part of a
+successful match. Consider:
+
+  a+(*SKIP)b
+

+If the subject is "aaaac...", after the first match attempt fails (starting at
+the first character in the string), the starting point skips on to start the
+next attempt at "c". Note that a possessive quantifer does not have the same
+effect as this example; although it would suppress backtracking during the
+first match attempt, the second attempt would start at the second character
+instead of skipping on to "c".
+
+  (*SKIP:NAME)
+

+When (*SKIP) has an associated name, its behaviour is modified. When it is
+triggered, the previous path through the pattern is searched for the most
+recent (*MARK) that has the same name. If one is found, the "bumpalong" advance
+is to the subject position that corresponds to that (*MARK) instead of to where
+(*SKIP) was encountered. If no (*MARK) with a matching name is found, the
+(*SKIP) is ignored.
+

+

+Note that (*SKIP:NAME) searches only for names set by (*MARK:NAME). It ignores
+names that are set by (*PRUNE:NAME) or (*THEN:NAME).
+
+  (*THEN) or (*THEN:NAME)
+

+This verb causes a skip to the next innermost alternative when backtracking
+reaches it. That is, it cancels any further backtracking within the current
+alternative. Its name comes from the observation that it can be used for a
+pattern-based if-then-else block:
+
+  ( COND1 (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ ) ...
+

+If the COND1 pattern matches, FOO is tried (and possibly further items after
+the end of the group if FOO succeeds); on failure, the matcher skips to the
+second alternative and tries COND2, without backtracking into COND1. If that
+succeeds and BAR fails, COND3 is tried. If subsequently BAZ fails, there are no
+more alternatives, so there is a backtrack to whatever came before the entire
+group. If (*THEN) is not inside an alternation, it acts like (*PRUNE).
+

+

+The behaviour of (*THEN:NAME) is the not the same as (*MARK:NAME)(*THEN).
+It is like (*MARK:NAME) in that the name is remembered for passing back to the
+caller. However, (*SKIP:NAME) searches only for names set with (*MARK), 
+ignoring those set by (*PRUNE) and (*THEN).
+

+

+A subpattern that does not contain a | character is just a part of the
+enclosing alternative; it is not a nested alternation with only one
+alternative. The effect of (*THEN) extends beyond such a subpattern to the
+enclosing alternative. Consider this pattern, where A, B, etc. are complex
+pattern fragments that do not contain any | characters at this level:
+
+  A (B(*THEN)C) | D
+

+If A and B are matched, but there is a failure in C, matching does not
+backtrack into A; instead it moves to the next alternative, that is, D.
+However, if the subpattern containing (*THEN) is given an alternative, it
+behaves differently:
+
+  A (B(*THEN)C | (*FAIL)) | D
+

+The effect of (*THEN) is now confined to the inner subpattern. After a failure
+in C, matching moves to (*FAIL), which causes the whole subpattern to fail
+because there are no more alternatives to try. In this case, matching does now
+backtrack into A.
+

+

+Note that a conditional subpattern is not considered as having two
+alternatives, because only one is ever used. In other words, the | character in
+a conditional subpattern has a different meaning. Ignoring white space,
+consider:
+
+  ^.*? (?(?=a) a | b(*THEN)c )
+

+If the subject is "ba", this pattern does not match. Because .*? is ungreedy,
+it initially matches zero characters. The condition (?=a) then fails, the
+character "b" is matched, but "c" is not. At this point, matching does not
+backtrack to .*? as might perhaps be expected from the presence of the |
+character. The conditional subpattern is part of the single alternative that
+comprises the whole pattern, and so the match fails. (If there was a backtrack
+into .*?, allowing it to match "b", the match would succeed.)
+

+

+The verbs just described provide four different "strengths" of control when
+subsequent matching fails. (*THEN) is the weakest, carrying on the match at the
+next alternative. (*PRUNE) comes next, failing the match at the current
+starting position, but allowing an advance to the next character (for an
+unanchored pattern). (*SKIP) is similar, except that the advance may be more
+than one character. (*COMMIT) is the strongest, causing the entire match to
+fail.
+

+

+More than one backtracking verb
+

+

+If more than one backtracking verb is present in a pattern, the one that is
+backtracked onto first acts. For example, consider this pattern, where A, B,
+etc. are complex pattern fragments:
+
+  (A(*COMMIT)B(*THEN)C|ABD)
+

+If A matches but B fails, the backtrack to (*COMMIT) causes the entire match to
+fail. However, if A and B match, but C fails, the backtrack to (*THEN) causes
+the next alternative (ABD) to be tried. This behaviour is consistent, but is
+not always the same as Perl's. It means that if two or more backtracking verbs
+appear in succession, all the the last of them has no effect. Consider this
+example:
+
+  ...(*COMMIT)(*PRUNE)...
+

+If there is a matching failure to the right, backtracking onto (*PRUNE) causes
+it to be triggered, and its action is taken. There can never be a backtrack
+onto (*COMMIT).
+

+

+Backtracking verbs in repeated groups
+

+

+PCRE2 differs from Perl in its handling of backtracking verbs in repeated
+groups. For example, consider:
+
+  /(a(*COMMIT)b)+ac/
+

+If the subject is "abac", Perl matches, but PCRE2 fails because the (*COMMIT)
+in the second repeat of the group acts.
+

+

+Backtracking verbs in assertions
+

+

+(*FAIL) in an assertion has its normal effect: it forces an immediate
+backtrack.
+

+

+(*ACCEPT) in a positive assertion causes the assertion to succeed without any
+further processing. In a negative assertion, (*ACCEPT) causes the assertion to
+fail without any further processing.
+

+

+The other backtracking verbs are not treated specially if they appear in a
+positive assertion. In particular, (*THEN) skips to the next alternative in the
+innermost enclosing group that has alternations, whether or not this is within
+the assertion.
+

+

+Negative assertions are, however, different, in order to ensure that changing a
+positive assertion into a negative assertion changes its result. Backtracking
+into (*COMMIT), (*SKIP), or (*PRUNE) causes a negative assertion to be true,
+without considering any further alternative branches in the assertion.
+Backtracking into (*THEN) causes it to skip to the next enclosing alternative
+within the assertion (the normal behaviour), but if the assertion does not have
+such an alternative, (*THEN) behaves like (*PRUNE).
+

+

+Backtracking verbs in subroutines
+

+

+These behaviours occur whether or not the subpattern is called recursively.
+Perl's treatment of subroutines is different in some cases.
+

+

+(*FAIL) in a subpattern called as a subroutine has its normal effect: it forces
+an immediate backtrack.
+

+

+(*ACCEPT) in a subpattern called as a subroutine causes the subroutine match to
+succeed without any further processing. Matching then continues after the
+subroutine call.
+

+

+(*COMMIT), (*SKIP), and (*PRUNE) in a subpattern called as a subroutine cause
+the subroutine match to fail.
+

+

+(*THEN) skips to the next alternative in the innermost enclosing group within
+the subpattern that has alternatives. If there is no such group within the
+subpattern, (*THEN) causes the subroutine match to fail.
+

+
SEE ALSO

+

+pcre2api(3), pcre2callout(3), pcre2matching(3),
+pcre2syntax(3), pcre2(3), pcre216(3), pcre232(3).
+

+
AUTHOR

+

+Philip Hazel
+

+University Computing Service
+

+Cambridge CB2 3QH, England.
+

+

+
REVISION

+

+Last updated: 19 October 2014
+

+Copyright © 1997-2014 University of Cambridge.
+

+

+Return to the PCRE2 index page.
+

diff --git a/doc/html/pcre2test.html b/doc/html/pcre2test.html
index 617c582..592d9e0 100644
--- a/doc/html/pcre2test.html
+++ b/doc/html/pcre2test.html
@@ -148,9 +148,9 @@ to the same value:
 
   ebcdic     compiled for an EBCDIC environment
   jit        just-in-time support is available
-  pcre16     the 16-bit library was built
-  pcre32     the 32-bit library was built
-  pcre8      the 8-bit library was built
+  pcre2-16   the 16-bit library was built
+  pcre2-32   the 32-bit library was built
+  pcre2-8    the 8-bit library was built
   unicode    Unicode support is available
 

 If an unknown option is given, an error message is output; the exit code is 0.
diff --git a/doc/pcre2.txt b/doc/pcre2.txt
index 18e5cc1..2301c8a 100644
--- a/doc/pcre2.txt
+++ b/doc/pcre2.txt
@@ -8,6 +8,158 @@ pcre2test commands.
 -----------------------------------------------------------------------------
 
 
+PCRE2(3)                   Library Functions Manual                   PCRE2(3)
+
+
+
+NAME
+       PCRE2 - Perl-compatible regular expressions (revised API)
+
+INTRODUCTION
+
+       PCRE2 is the name used for a revised API for the PCRE library, which is
+       a set of functions, written in C,  that  implement  regular  expression
+       pattern matching using the same syntax and semantics as Perl, with just
+       a few differences. Some features that appeared in Python and the origi-
+       nal  PCRE  before  they  appeared  in Perl are also available using the
+       Python syntax, there is some support for one or two .NET and  Oniguruma
+       syntax  items,  and there are options for requesting some minor changes
+       that give better ECMAScript (aka JavaScript) compatibility.
+
+       The source code for PCRE2 can be compiled to support 8-bit, 16-bit,  or
+       32-bit  code units, which means that up to three separate libraries may
+       be installed.  The original work to extend PCRE to  16-bit  and  32-bit
+       code  units  was  done  by Zoltan Herczeg and Christian Persch, respec-
+       tively. In all three cases, strings can be interpreted  either  as  one
+       character  per  code  unit, or as UTF-encoded Unicode, with support for
+       Unicode general category properties. Unicode is optional at build time,
+       and  must  be enabled explicitly at run time. The version of Unicode in
+       use can be discovered by running
+
+         pcre2test -C
+
+       The three libraries contain identical sets  of  functions,  with  names
+       ending  in  _8,  _16,  or  _32,  respectively  (for example, pcre2_com-
+       pile_8()). However, by defining PCRE2_CODE_UNIT_WIDTH to be 8,  16,  or
+       32,  a  program that uses just one code unit width can be written using
+       generic names such as pcre2_compile(), and the documentation is written
+       assuming that this is the case.
+
+       In addition to the Perl-compatible matching function, PCRE2 contains an
+       alternative function that matches the same compiled patterns in a  dif-
+       ferent way. In certain circumstances, the alternative function has some
+       advantages.  For a discussion of the two matching algorithms,  see  the
+       pcre2matching page.
+
+       Details  of  exactly which Perl regular expression features are and are
+       not supported by  PCRE2  are  given  in  separate  documents.  See  the
+       pcre2pattern  and  pcre2compat  pages. There is a syntax summary in the
+       pcre2syntax page.
+
+       Some features of PCRE2 can be included, excluded, or changed  when  the
+       library  is  built. The pcre2_config() function makes it possible for a
+       client to discover which features are  available.  The  features  them-
+       selves are described in the pcre2build page. Documentation about build-
+       ing PCRE2 for various operating systems can be found in the README  and
+       NON-AUTOTOOLS_BUILD files in the source distribution.
+
+       The  libraries contains a number of undocumented internal functions and
+       data tables that are used by more than one  of  the  exported  external
+       functions,  but  which  are  not  intended for use by external callers.
+       Their names all begin with "_pcre2", which hopefully will  not  provoke
+       any name clashes. In some environments, it is possible to control which
+       external symbols are exported when a shared library is  built,  and  in
+       these cases the undocumented symbols are not exported.
+
+
+SECURITY CONSIDERATIONS
+
+       If  you  are using PCRE2 in a non-UTF application that permits users to
+       supply arbitrary patterns for compilation, you should  be  aware  of  a
+       feature that allows users to turn on UTF support from within a pattern,
+       provided that PCRE2 was built with Unicode  support.  For  example,  an
+       8-bit  pattern  that  begins  with  "(*UTF)" turns on UTF-8 mode, which
+       interprets patterns and subjects as strings of UTF-8 code units instead
+       of  individual  8-bit  characters. This causes both the pattern and any
+       data against which it is matched to be checked for UTF-8  validity.  If
+       the  data string is very long, such a check might use sufficiently many
+       resources as to cause your application to lose performance.
+
+       One way of guarding against this possibility is to use  the  pcre2_pat-
+       tern_info()  function  to check the compiled pattern's options for UTF.
+       Alternatively, you can set the PCRE2_NEVER_UTF option at compile  time.
+       This  causes  an compile time error if a pattern contains a UTF-setting
+       sequence.
+
+       If your application is one that supports UTF, be  aware  that  validity
+       checking  can  take time. If the same data string is to be matched many
+       times, you can use the PCRE2_NO_UTF_CHECK option  for  the  second  and
+       subsequent matches to avoid running redundant checks.
+
+       Another  way  that  performance can be hit is by running a pattern that
+       has a very large search tree against a string that  will  never  match.
+       Nested  unlimited repeats in a pattern are a common example. PCRE2 pro-
+       vides some protection against  this:  see  the  pcre2_set_match_limit()
+       function in the pcre2api page.
+
+
+USER DOCUMENTATION
+
+       The  user  documentation for PCRE2 comprises a number of different sec-
+       tions. In the "man" format, each of these is a separate "man page".  In
+       the  HTML  format, each is a separate page, linked from the index page.
+       In the plain  text  format,  the  descriptions  of  the  pcre2grep  and
+       pcre2test programs are in files called pcre2grep.txt and pcre2test.txt,
+       respectively. The remaining sections, except for the pcre2demo  section
+       (which  is a program listing), and the short pages for individual func-
+       tions, are concatenated in pcre2.txt, for ease of searching.  The  sec-
+       tions are as follows:
+
+         pcre2              this document FIXME CHECK THIS LIST
+         pcre2-config       show PCRE2 installation configuration information
+         pcre2api           details of PCRE2's native C API
+         pcre2build         building PCRE2
+         pcre2callout       details of the callout feature
+         pcre2compat        discussion of Perl compatibility
+         pcre2demo          a demonstration C program that uses PCRE2
+         pcre2grep          description of the pcre2grep command (8-bit only)
+         pcre2jit            discussion  of the just-in-time optimization sup-
+       port
+         pcre2limits        details of size and other limits
+         pcre2matching      discussion of the two matching algorithms
+         pcre2partial       details of the partial matching facility
+         pcre2pattern       syntax and semantics of supported
+                             regular expressions
+         pcre2perform       discussion of performance issues
+         pcre2posix         the POSIX-compatible C API for the 8-bit library
+         pcre2sample        discussion of the pcre2demo program
+         pcre2stack         discussion of stack usage
+         pcre2syntax        quick syntax reference
+         pcre2test          description of the pcre2test testing command
+         pcre2unicode       discussion of Unicode and UTF support
+
+       In the "man" and HTML formats, there is also a short page  for  each  C
+       library function, listing its arguments and results.
+
+
+AUTHOR
+
+       Philip Hazel
+       University Computing Service
+       Cambridge CB2 3QH, England.
+
+       Putting  an  actual email address here is a spam magnet. If you want to
+       email me, use my two initials, followed by the two digits  10,  at  the
+       domain cam.ac.uk.
+
+
+REVISION
+
+       Last updated: 28 September 2014
+       Copyright (c) 1997-2014 University of Cambridge.
+------------------------------------------------------------------------------
+ 
+ 
 PCRE2API(3)                Library Functions Manual                PCRE2API(3)
 
 
@@ -190,7 +342,7 @@ PCRE2 NATIVE API AUXILIARY FUNCTIONS
 
        int pcre2_pattern_info(const pcre2 *code, uint32_t what, void *where);
 
-       int pcre2_config(uint32_t what, void *where, PCRE2_SIZE length);
+       int pcre2_config(uint32_t what, void *where);
 
 
 PCRE2 8-BIT, 16-BIT, AND 32-BIT LIBRARIES
@@ -670,7 +822,7 @@ PCRE2 CONTEXTS
 
 CHECKING BUILD-TIME OPTIONS
 
-       int pcre2_config(uint32_t what, void *where, PCRE2_SIZE length);
+       int pcre2_config(uint32_t what, void *where);
 
        The  function  pcre2_config()  makes  it possible for a PCRE2 client to
        discover which optional features have  been  compiled  into  the  PCRE2
@@ -679,20 +831,23 @@ CHECKING BUILD-TIME OPTIONS
 
        The first argument for pcre2_config() specifies  which  information  is
        required.  The  second  argument  is a pointer to memory into which the
-       information is placed, with the final argument  giving  the  length  of
-       this  memory  in  bytes.  For calls that return numerical values, where
-       should point to appropriately aligned memory, with  length  set  to  at
-       least the "sizeof" the data type.
+       information is placed. If NULL is  passed,  the  function  returns  the
+       amount  of  memory  that  is  needed for the requested information. For
+       calls that return  numerical  values,  the  value  is  in  bytes;  when
+       requesting  these  values,  where should point to appropriately aligned
+       memory. For calls that return strings, the required length is given  in
+       code units, not counting the terminating zero.
 
-       The returned value from pcre2_config() is zero on success, or the nega-
-       tive error code PCRE2_ERROR_BADOPTION if the value in the  first  argu-
-       ment is not recognized. The following information is available:
+       When  requesting information, the returned value from pcre2_config() is
+       non-negative on success, or the negative error code  PCRE2_ERROR_BADOP-
+       TION  if the value in the first argument is not recognized. The follow-
+       ing information is available:
 
          PCRE2_CONFIG_BSR
 
        The output is an integer whose value indicates what character sequences
-       the \R escape sequence matches by default. A value of 0 means  that  \R
-       matches  any  Unicode  line ending sequence; a value of 1 means that \R
+       the  \R  escape sequence matches by default. A value of 0 means that \R
+       matches any Unicode line ending sequence; a value of 1  means  that  \R
        matches only CR, LF, or CRLF. The default can be overridden when a pat-
        tern is compiled or matched.
 
@@ -703,10 +858,13 @@ CHECKING BUILD-TIME OPTIONS
 
          PCRE2_CONFIG_JITTARGET
 
-       FIXME: this needs sorting out once JIT is implemented.  If JIT  support
-       is  available,  the  string  contains  the name of the architecture for
-       which the JIT compiler is configured, for example  "x86  32bit  (little
-       endian + unaligned)". If JIT support is not available, FIXME.
+       The  where  argument  should point to a buffer that is at least 48 code
+       units long. (The exact length needed can be found by calling pcre2_con-
+       fig()  with where set to NULL.) The buffer is filled with a string that
+       contains the name of the architecture for which  the  JIT  compiler  is
+       configured, for example "x86 32bit (little endian + unaligned)". If JIT
+       support is not available, PCRE2_ERROR_BADOPTION is returned,  otherwise
+       the length of the string, in code units, is returned.
 
          PCRE2_CONFIG_LINKSIZE
 
@@ -772,10 +930,12 @@ CHECKING BUILD-TIME OPTIONS
          PCRE2_CONFIG_UNICODE_VERSION
 
        The where argument should point to a buffer that is at  least  24  code
-       units long. If PCRE2 has been compiled without Unicode support, this is
-       filled with the text "Unicode not supported".  Otherwise,  the  Unicode
-       version  string  (for example, "7.0.0") is returnd. The string is zero-
-       terminated.
+       units long. (The exact length needed can be found by calling pcre2_con-
+       fig() with where set to NULL.) If PCRE2 has been compiled without  Uni-
+       code  support,  the  buffer  is  filled with the text "Unicode not sup-
+       ported". Otherwise, the Unicode version string (for  example,  "7.0.0")
+       is  inserted.  The  string is zero-terminated. The function returns the
+       length of the string in code units.
 
          PCRE2_CONFIG_UNICODE
 
@@ -786,8 +946,10 @@ CHECKING BUILD-TIME OPTIONS
          PCRE2_CONFIG_VERSION
 
        The where argument should point to a buffer that is at  least  12  code
-       units  long.  It  is  filled with the PCRE2 version string, zero-termi-
-       nated.
+       units long. (The exact length needed can be found by calling pcre2_con-
+       fig() with where set to NULL.) The buffer is filled with the PCRE2 ver-
+       sion  string, zero-terminated. The length of the string (in code units)
+       is returned.
 
 
 COMPILING A PATTERN
@@ -1227,18 +1389,19 @@ INFORMATION ABOUT A COMPILED PATTERN
        The pcre2_pattern_info() function returns information about a  compiled
        pattern.  The  first argument is a pointer to the compiled pattern. The
        second argument specifies which piece of information is  required,  and
-       the  third argument is a pointer to a variable to receive the data. The
-       yield of the function is zero for success, or one of the following neg-
-       ative numbers:
+       the  third  argument is a pointer to a variable to receive the data. If
+       the third argument is NULL, the first  argument  is  ignored,  and  the
+       function returns the size in bytes of the variable that is required for
+       the information requested.  Otherwise, The yield  of  the  function  is
+       zero for success, or one of the following negative numbers:
 
          PCRE2_ERROR_NULL           the argument code was NULL
-                                    the argument where was NULL
          PCRE2_ERROR_BADMAGIC       the "magic number" was not found
          PCRE2_ERROR_BADOPTION      the value of what was invalid
          PCRE2_ERROR_UNSET          the requested field is not set
 
        The  "magic  number" is placed at the start of each compiled pattern as
-       an simple check against passing an arbitrary memory pointer.  Here is a
+       an simple check against passing an arbitrary memory pointer. Here is  a
        typical  call of pcre2_pattern_info(), to obtain the length of the com-
        piled pattern:
 
@@ -2363,7 +2526,459 @@ AUTHOR
 
 REVISION
 
-       Last updated: 14 October 2014
+       Last updated: 16 October 2014
+       Copyright (c) 1997-2014 University of Cambridge.
+------------------------------------------------------------------------------
+ 
+ 
+PCRE2BUILD(3)              Library Functions Manual              PCRE2BUILD(3)
+
+
+
+NAME
+       PCRE2 - Perl-compatible regular expressions (revised API)
+
+BUILDING PCRE2
+
+       PCRE2  is distributed with a configure script that can be used to build
+       the library in Unix-like environments using the applications  known  as
+       Autotools. Also in the distribution are files to support building using
+       CMake instead of configure.  The  text  file  README  contains  general
+       information  about  building  with Autotools (some of which is repeated
+       below), and also has some comments about building on various  operating
+       systems.  There  is a lot more information about building PCRE2 without
+       using Autotools (including information about using CMake  and  building
+       "by  hand")  in  the  text file called NON-AUTOTOOLS-BUILD.  You should
+       consult this file as well as the README file if you are building  in  a
+       non-Unix-like environment.
+
+
+PCRE2 BUILD-TIME OPTIONS
+
+       The rest of this document describes the optional features of PCRE2 that
+       can be selected when the library is compiled. It  assumes  use  of  the
+       configure  script,  where  the  optional features are selected or dese-
+       lected by providing options to configure before running the  make  com-
+       mand.  However,  the same options can be selected in both Unix-like and
+       non-Unix-like environments if you are using CMake instead of  configure
+       to build PCRE2.
+
+       If  you  are not using Autotools or CMake, option selection can be done
+       by editing the config.h file, or by passing parameter settings  to  the
+       compiler, as described in NON-AUTOTOOLS-BUILD.
+
+       The complete list of options for configure (which includes the standard
+       ones such as the  selection  of  the  installation  directory)  can  be
+       obtained by running
+
+         ./configure --help
+
+       The  following  sections  include  descriptions  of options whose names
+       begin with --enable or --disable. These settings specify changes to the
+       defaults  for  the configure command. Because of the way that configure
+       works, --enable and --disable always come in pairs, so  the  complemen-
+       tary  option always exists as well, but as it specifies the default, it
+       is not described.
+
+
+BUILDING 8-BIT, 16-BIT AND 32-BIT LIBRARIES
+
+       By default, a library called libpcre2-8 is built, containing  functions
+       that  take  string arguments contained in vectors of bytes, interpreted
+       either as single-byte characters, or UTF-8 strings. You can also  build
+       two  other libraries, called libpcre2-16 and libpcre2-32, which process
+       strings that are contained in vectors of 16-bit and 32-bit code  units,
+       respectively. These can be interpreted either as single-unit characters
+       or UTF-16/UTF-32 strings. To build these additional libraries, add  one
+       or both of the following to the configure command:
+
+         --enable-pcre16
+         --enable-pcre32
+
+       If you do not want the 8-bit library, add
+
+         --disable-pcre8
+
+       as  well.  At least one of the three libraries must be built. Note that
+       the POSIX wrapper is for the 8-bit library only, and that pcre2grep  is
+       an  8-bit  program.  Neither  of these are built if you select only the
+       16-bit or 32-bit libraries.
+
+
+BUILDING SHARED AND STATIC LIBRARIES
+
+       The Autotools PCRE2 building process uses libtool to build both  shared
+       and  static  libraries  by  default.  You  can suppress one of these by
+       adding one of
+
+         --disable-shared
+         --disable-static
+
+       to the configure command, as required.
+
+
+Unicode and UTF SUPPORT
+
+       To build PCRE2 with support for Unicode and UTF character strings, add
+
+         --enable-unicode
+
+       to the configure command. This setting applies to all three  libraries,
+       adding  support  for  UTF-8 to the 8-bit library, support for UTF-16 to
+       the 16-bit library, and  support  for  UTF-32  to  the  to  the  32-bit
+       library.   It is not possible to build one library with UTF support and
+       another without in the same configuration.
+
+       Of itself, this setting does not make PCRE2  treat  strings  as  UTF-8,
+       UTF-16 or UTF-32. As well as compiling PCRE2 with this option, you also
+       have have to set the PCRE2_UTF option when you call pcre2_compile()  to
+       compile a pattern.
+
+       If  you  set  --enable-unicode when compiling in an EBCDIC environment,
+       PCRE2 expects its input to be either ASCII or UTF-8 (depending  on  the
+       run-time  option).  It is not possible to support both EBCDIC and UTF-8
+       codes in the same version of the library.  Consequently,  --enable-uni-
+       code and --enable-ebcdic are mutually exclusive.
+
+       UTF  support allows the libraries to process character codepoints up to
+       0x10ffff in the strings that they handle. It also provides support  for
+       accessing the properties of such characters, using pattern escapes such
+       as \P, \p, and \X.  Only the general category properties such as Lu and
+       Nd are supported. Details are given in the pcre2pattern documentation.
+
+
+JUST-IN-TIME COMPILER SUPPORT
+
+       Just-in-time compiler support is included in the build by specifying
+
+         --enable-jit
+
+       This  support  is available only for certain hardware architectures. If
+       this option is set for an  unsupported  architecture,  a  compile  time
+       error  occurs.   See the pcre2jit documentation for a discussion of JIT
+       usage. When JIT support is enabled, pcre2grep automatically  makes  use
+       of it, unless you add
+
+         --disable-pcre2grep-jit
+
+       to the "configure" command.
+
+
+CODE VALUE OF NEWLINE
+
+       By  default, PCRE2 interprets the linefeed (LF) character as indicating
+       the end of a line. This is the normal newline  character  on  Unix-like
+       systems.  You can compile PCRE2 to use carriage return (CR) instead, by
+       adding
+
+         --enable-newline-is-cr
+
+       to the  configure  command.  There  is  also  a  --enable-newline-is-lf
+       option, which explicitly specifies linefeed as the newline character.
+
+       Alternatively, you can specify that line endings are to be indicated by
+       the two character sequence CRLF. If you want this, add
+
+         --enable-newline-is-crlf
+
+       to the configure command. There is a fourth option, specified by
+
+         --enable-newline-is-anycrlf
+
+       which causes PCRE2 to recognize any of the three sequences CR,  LF,  or
+       CRLF as indicating a line ending. Finally, a fifth option, specified by
+
+         --enable-newline-is-any
+
+       causes PCRE2 to recognize any Unicode newline sequence.
+
+       Whatever  line ending convention is selected when PCRE2 is built can be
+       overridden when the library functions are called. At build time  it  is
+       conventional to use the standard for your operating system.
+
+
+WHAT \R MATCHES
+
+       By  default,  the  sequence \R in a pattern matches any Unicode newline
+       sequence, whatever has been selected as the line  ending  sequence.  If
+       you specify
+
+         --enable-bsr-anycrlf
+
+       the  default  is changed so that \R matches only CR, LF, or CRLF. What-
+       ever is selected when PCRE2 is built can be overridden when the library
+       functions are called.
+
+
+HANDLING VERY LARGE PATTERNS
+
+       Within  a  compiled  pattern,  offset values are used to point from one
+       part to another (for example, from an opening parenthesis to an  alter-
+       nation  metacharacter).  By default, in the 8-bit and 16-bit libraries,
+       two-byte values are used for these offsets, leading to a  maximum  size
+       for  a compiled pattern of around 64K. This is sufficient to handle all
+       but the most gigantic patterns.  Nevertheless, some people do  want  to
+       process  truly enormous patterns, so it is possible to compile PCRE2 to
+       use three-byte or four-byte offsets by adding a setting such as
+
+         --with-link-size=3
+
+       to the configure command. The value given must be 2, 3, or 4.  For  the
+       16-bit  library,  a  value of 3 is rounded up to 4. In these libraries,
+       using longer offsets slows down the operation of PCRE2 because  it  has
+       to  load additional data when handling them. For the 32-bit library the
+       value is always 4 and cannot be overridden; the value  of  --with-link-
+       size is ignored.
+
+
+AVOIDING EXCESSIVE STACK USAGE
+
+       When  matching  with the pcre2_match() function, PCRE2 implements back-
+       tracking by making recursive  calls  to  an  internal  function  called
+       match().  In  environments where the size of the stack is limited, this
+       can severely limit PCRE2's operation. (The Unix  environment  does  not
+       usually  suffer from this problem, but it may sometimes be necessary to
+       increase  the  maximum  stack  size.  There  is  a  discussion  in  the
+       pcre2stack  documentation.)  An  alternative approach to recursion that
+       uses memory from the heap to remember data, instead of using  recursive
+       function  calls, has been implemented to work round the problem of lim-
+       ited stack size. If you want to build a version  of  PCRE2  that  works
+       this way, add
+
+         --disable-stack-for-recursion
+
+       to the configure command. By default, the system functions malloc() and
+       free() are called to manage the heap memory that is required, but  cus-
+       tom  memory  management  functions  can  be  called instead. PCRE2 runs
+       noticeably more slowly when built in this way. This option affects only
+       the pcre2_match() function; it is not relevant for pcre2_dfa_match().
+
+
+LIMITING PCRE2 RESOURCE USAGE
+
+       Internally, PCRE2 has a function called match(), which it calls repeat-
+       edly  (sometimes  recursively)  when  matching  a  pattern   with   the
+       pcre2_match() function. By controlling the maximum number of times this
+       function may be called during a single matching operation, a limit  can
+       be  placed on the resources used by a single call to pcre2_match(). The
+       limit can be changed at run time, as described in the pcre2api documen-
+       tation.  The default is 10 million, but this can be changed by adding a
+       setting such as
+
+         --with-match-limit=500000
+
+       to  the  configure  command.  This  setting  has  no  effect   on   the
+       pcre2_dfa_match() matching function.
+
+       In  some  environments  it is desirable to limit the depth of recursive
+       calls of match() more strictly than the total number of calls, in order
+       to  restrict  the maximum amount of stack (or heap, if --disable-stack-
+       for-recursion is specified) that is used. A second limit controls this;
+       it  defaults  to  the  value  that is set for --with-match-limit, which
+       imposes no additional constraints. However, you can set a  lower  limit
+       by adding, for example,
+
+         --with-match-limit-recursion=10000
+
+       to  the  configure  command.  This  value can also be overridden at run
+       time.
+
+
+CREATING CHARACTER TABLES AT BUILD TIME
+
+       PCRE2 uses fixed tables for processing characters whose code points are
+       less than 256. By default, PCRE2 is built with a set of tables that are
+       distributed in the file src/pcre2_chartables.c.dist. These  tables  are
+       for ASCII codes only. If you add
+
+         --enable-rebuild-chartables
+
+       to  the  configure  command, the distributed tables are no longer used.
+       Instead, a program called dftables is compiled and  run.  This  outputs
+       the source for new set of tables, created in the default locale of your
+       C run-time system. (This method of replacing the tables does  not  work
+       if  you are cross compiling, because dftables is run on the local host.
+       If you need to create alternative tables when cross compiling, you will
+       have to do so "by hand".)
+
+
+USING EBCDIC CODE
+
+       PCRE2  assumes  by default that it will run in an environment where the
+       character code is ASCII (or Unicode, which is  a  superset  of  ASCII).
+       This  is  the case for most computer operating systems. PCRE2 can, how-
+       ever, be compiled to run in an EBCDIC environment by adding
+
+         --enable-ebcdic
+
+       to the configure command. This setting implies --enable-rebuild-charta-
+       bles.  You  should  only  use  it if you know that you are in an EBCDIC
+       environment (for example,  an  IBM  mainframe  operating  system).  The
+       --enable-ebcdic option is incompatible with --enable-unicode.
+
+       The EBCDIC character that corresponds to an ASCII LF is assumed to have
+       the value 0x15 by default. However, in some EBCDIC  environments,  0x25
+       is used. In such an environment you should use
+
+         --enable-ebcdic-nl25
+
+       as well as, or instead of, --enable-ebcdic. The EBCDIC character for CR
+       has the same value as in ASCII, namely, 0x0d.  Whichever  of  0x15  and
+       0x25 is not chosen as LF is made to correspond to the Unicode NEL char-
+       acter (which, in Unicode, is 0x85).
+
+       The options that select newline behaviour, such as --enable-newline-is-
+       cr, and equivalent run-time options, refer to these character values in
+       an EBCDIC environment.
+
+
+PCRE2GREP OPTIONS FOR COMPRESSED FILE SUPPORT
+
+       By default, pcre2grep reads all files as plain text. You can  build  it
+       so  that  it recognizes files whose names end in .gz or .bz2, and reads
+       them with libz or libbz2, respectively, by adding one or both of
+
+         --enable-pcre2grep-libz
+         --enable-pcre2grep-libbz2
+
+       to the configure command. These options naturally require that the rel-
+       evant  libraries  are installed on your system. Configuration will fail
+       if they are not.
+
+
+PCRE2GREP BUFFER SIZE
+
+       pcre2grep uses an internal buffer to hold a "window" on the file it  is
+       scanning, in order to be able to output "before" and "after" lines when
+       it finds a match. The size of the buffer is controlled by  a  parameter
+       whose default value is 20K. The buffer itself is three times this size,
+       but because of the way it is used for holding "before" lines, the long-
+       est  line  that  is guaranteed to be processable is the parameter size.
+       You can change the default parameter value by adding, for example,
+
+         --with-pcre2grep-bufsize=50K
+
+       to the configure command. The caller of pcre2grep can,  however,  over-
+       ride this value by specifying a run-time option.
+
+
+PCRE2TEST OPTION FOR LIBREADLINE SUPPORT
+
+       If you add one of
+
+         --enable-pcre2test-libreadline
+         --enable-pcre2test-libedit
+
+       to  the  configure  command,  pcre2test  is linked with the libreadline
+       orlibedit library, respectively, and when its input is from a terminal,
+       it  reads  it using the readline() function. This provides line-editing
+       and history facilities. Note that libreadline is  GPL-licensed,  so  if
+       you  distribute  a binary of pcre2test linked in this way, there may be
+       licensing issues. These can be avoided by linking with  libedit  (which
+       has a BSD licence) instead.
+
+       Setting  this  option  causes  the -lreadline option to be added to the
+       pcre2test build. In many operating environments with a  sytem-installed
+       readline  library  this  is  sufficient.  However, in some environments
+       (e.g. if an unmodified distribution version of  readline  is  in  use),
+       some  extra  configuration  may  be  necessary.  The  INSTALL  file for
+       libreadline says this:
+
+         "Readline uses the termcap functions, but does not link with
+         the termcap or curses library itself, allowing applications
+         which link with readline the to choose an appropriate library."
+
+       If your environment has not been set up so that an appropriate  library
+       is automatically included, you may need to add something like
+
+         LIBS="-ncurses"
+
+       immediately before the configure command.
+
+
+DEBUGGING WITH VALGRIND SUPPORT
+
+       By adding the
+
+         --enable-valgrind
+
+       option to to the configure command, PCRE2 will use valgrind annotations
+       to mark certain memory regions as  unaddressable.  This  allows  it  to
+       detect  invalid  memory  accesses,  and  is mostly useful for debugging
+       PCRE2 itself.
+
+
+CODE COVERAGE REPORTING
+
+       If your C compiler is gcc, you can build a version of  PCRE2  that  can
+       generate a code coverage report for its test suite. To enable this, you
+       must install lcov version 1.6 or above. Then specify
+
+         --enable-coverage
+
+       to the configure command and build PCRE2 in the usual way.
+
+       Note that using ccache (a caching C compiler) is incompatible with code
+       coverage  reporting. If you have configured ccache to run automatically
+       on your system, you must set the environment variable
+
+         CCACHE_DISABLE=1
+
+       before running make to build PCRE2, so that ccache is not used.
+
+       When --enable-coverage is used,  the  following  addition  targets  are
+       added to the Makefile:
+
+         make coverage
+
+       This  creates  a  fresh coverage report for the PCRE2 test suite. It is
+       equivalent to running "make coverage-reset", "make  coverage-baseline",
+       "make check", and then "make coverage-report".
+
+         make coverage-reset
+
+       This zeroes the coverage counters, but does nothing else.
+
+         make coverage-baseline
+
+       This captures baseline coverage information.
+
+         make coverage-report
+
+       This creates the coverage report.
+
+         make coverage-clean-report
+
+       This  removes the generated coverage report without cleaning the cover-
+       age data itself.
+
+         make coverage-clean-data
+
+       This removes the captured coverage data without removing  the  coverage
+       files created at compile time (*.gcno).
+
+         make coverage-clean
+
+       This  cleans all coverage data including the generated coverage report.
+       For more information about code coverage, see the gcov and  lcov  docu-
+       mentation.
+
+
+SEE ALSO
+
+       pcre2api(3), pcre2_config(3).
+
+
+AUTHOR
+
+       Philip Hazel
+       University Computing Service
+       Cambridge CB2 3QH, England.
+
+
+REVISION
+
+       Last updated: 28 September 2014
        Copyright (c) 1997-2014 University of Cambridge.
 ------------------------------------------------------------------------------
  
@@ -2604,6 +3219,1274 @@ REVISION
 ------------------------------------------------------------------------------
  
  
+PCRE2COMPAT(3)             Library Functions Manual             PCRE2COMPAT(3)
+
+
+
+NAME
+       PCRE2 - Perl-compatible regular expressions (revised API)
+
+DIFFERENCES BETWEEN PCRE2 AND PERL
+
+       This document describes the differences in the ways that PCRE2 and Perl
+       handle regular expressions. The differences  described  here  are  with
+       respect to Perl versions 5.10 and above.
+
+       1.  PCRE2  has only a subset of Perl's Unicode support. Details of what
+       it does have are given in the pcre2unicode page.
+
+       2. PCRE2 allows repeat quantifiers only  on  parenthesized  assertions,
+       but  they  do not mean what you might think. For example, (?!a){3} does
+       not assert that the next three characters are not "a". It just  asserts
+       that  the  next  character  is not "a" three times (in principle: PCRE2
+       optimizes this to run the assertion  just  once).  Perl  allows  repeat
+       quantifiers  on  other  assertions such as \b, but these do not seem to
+       have any use.
+
+       3. Capturing subpatterns that occur inside  negative  lookahead  asser-
+       tions  are  counted,  but their entries in the offsets vector are never
+       set. Perl sometimes (but not always) sets its numerical variables  from
+       inside negative assertions.
+
+       4.  The  following Perl escape sequences are not supported: \l, \u, \L,
+       \U, and \N when followed by a character name or Unicode value.  (\N  on
+       its own, matching a non-newline character, is supported.) In fact these
+       are implemented by Perl's general string-handling and are not  part  of
+       its  pattern matching engine. If any of these are encountered by PCRE2,
+       an error is generated by default. However, if the PCRE2_ALT_BSUX option
+       is set, \U and \u are interpreted as ECMAScript interprets them.
+
+       5. The Perl escape sequences \p, \P, and \X are supported only if PCRE2
+       is built with Unicode support. The properties that can be  tested  with
+       \p and \P are limited to the general category properties such as Lu and
+       Nd, script names such as Greek or Han, and the derived  properties  Any
+       and L&. PCRE2 does support the Cs (surrogate) property, which Perl does
+       not; the Perl documentation says "Because Perl hides the need  for  the
+       user  to  understand the internal representation of Unicode characters,
+       there is no need to implement the  somewhat  messy  concept  of  surro-
+       gates."
+
+       6.  PCRE2 does support the \Q...\E escape for quoting substrings. Char-
+       acters in between are treated as literals. This is  slightly  different
+       from  Perl  in  that  $  and  @ are also handled as literals inside the
+       quotes. In Perl, they cause variable interpolation (but of course PCRE2
+       does not have variables).  Note the following examples:
+
+           Pattern            PCRE2 matches      Perl matches
+
+           \Qabc$xyz\E        abc$xyz           abc followed by the
+                                                  contents of $xyz
+           \Qabc\$xyz\E       abc\$xyz          abc\$xyz
+           \Qabc\E\$\Qxyz\E   abc$xyz           abc$xyz
+
+       The  \Q...\E  sequence  is recognized both inside and outside character
+       classes.
+
+       7.  Fairly  obviously,  PCRE2  does  not  support  the  (?{code})   and
+       (??{code})  constructions. However, there is support for recursive pat-
+       terns. This is not available in Perl 5.8, but it is in Perl 5.10. Also,
+       the  PCRE2  "callout"  feature allows an external function to be called
+       during  pattern  matching.  See  the  pcre2callout  documentation   for
+       details.
+
+       8.  Subpatterns  that  are called as subroutines (whether or not recur-
+       sively) are always treated as atomic groups  in  PCRE2.  This  is  like
+       Python,  but  unlike Perl.  Captured values that are set outside a sub-
+       routine call can be reference from inside in PCRE2, but  not  in  Perl.
+       There is a discussion that explains these differences in more detail in
+       the section on recursion differences  from  Perl  in  the  pcre2pattern
+       page.
+
+       9.  If  any  of the backtracking control verbs are used in a subpattern
+       that is called as a subroutine  (whether  or  not  recursively),  their
+       effect  is  confined to that subpattern; it does not extend to the sur-
+       rounding pattern. This is not always the case in Perl.  In  particular,
+       if  (*THEN)  is  present in a group that is called as a subroutine, its
+       action is limited to that group, even if the group does not contain any
+       |  characters.  Note that such subpatterns are processed as anchored at
+       the point where they are tested.
+
+       10. If a pattern contains more than one backtracking control verb,  the
+       first  one  that  is backtracked onto acts. For example, in the pattern
+       A(*COMMIT)B(*PRUNE)C a failure in B triggers (*COMMIT), but  a  failure
+       in C triggers (*PRUNE). Perl's behaviour is more complex; in many cases
+       it is the same as PCRE2, but there are examples where it differs.
+
+       11. Most backtracking verbs in assertions have  their  normal  actions.
+       They are not confined to the assertion.
+
+       12.  There are some differences that are concerned with the settings of
+       captured strings when part of  a  pattern  is  repeated.  For  example,
+       matching  "aba"  against  the  pattern  /^(a(b)?)+$/  in Perl leaves $2
+       unset, but in PCRE2 it is set to "b".
+
+       13. PCRE2's handling of duplicate subpattern numbers and duplicate sub-
+       pattern names is not as general as Perl's. This is a consequence of the
+       fact the PCRE2 works internally just with numbers,  using  an  external
+       table  to translate between numbers and names. In particular, a pattern
+       such as (?|(?A)|(?
+
+       is matched against the string
+
+           
+
+       there are three possible answers. The standard algorithm finds only one
+       of them, whereas the alternative algorithm finds all three.
+
+
+REGULAR EXPRESSIONS AS TREES
+
+       The set of strings that are matched by a regular expression can be rep-
+       resented  as  a  tree structure. An unlimited repetition in the pattern
+       makes the tree of infinite size, but it is still a tree.  Matching  the
+       pattern  to a given subject string (from a given starting point) can be
+       thought of as a search of the tree.  There are two  ways  to  search  a
+       tree:  depth-first  and  breadth-first, and these correspond to the two
+       matching algorithms provided by PCRE2.
+
+
+THE STANDARD MATCHING ALGORITHM
+
+       In the terminology of Jeffrey Friedl's book "Mastering Regular  Expres-
+       sions",  the  standard  algorithm  is an "NFA algorithm". It conducts a
+       depth-first search of the pattern tree. That is, it  proceeds  along  a
+       single path through the tree, checking that the subject matches what is
+       required. When there is a mismatch, the algorithm  tries  any  alterna-
+       tives  at  the  current point, and if they all fail, it backs up to the
+       previous branch point in the  tree,  and  tries  the  next  alternative
+       branch  at  that  level.  This often involves backing up (moving to the
+       left) in the subject string as well.  The  order  in  which  repetition
+       branches  are  tried  is controlled by the greedy or ungreedy nature of
+       the quantifier.
+
+       If a leaf node is reached, a matching string has  been  found,  and  at
+       that  point the algorithm stops. Thus, if there is more than one possi-
+       ble match, this algorithm returns the first one that it finds.  Whether
+       this  is the shortest, the longest, or some intermediate length depends
+       on the way the greedy and ungreedy repetition quantifiers are specified
+       in the pattern.
+
+       Because  it  ends  up  with a single path through the tree, it is rela-
+       tively straightforward for this algorithm to keep  track  of  the  sub-
+       strings  that  are  matched  by portions of the pattern in parentheses.
+       This provides support for capturing parentheses and back references.
+
+
+THE ALTERNATIVE MATCHING ALGORITHM
+
+       This algorithm conducts a breadth-first search of  the  tree.  Starting
+       from  the  first  matching  point  in the subject, it scans the subject
+       string from left to right, once, character by character, and as it does
+       this,  it remembers all the paths through the tree that represent valid
+       matches. In Friedl's terminology, this is a kind  of  "DFA  algorithm",
+       though  it is not implemented as a traditional finite state machine (it
+       keeps multiple states active simultaneously).
+
+       Although the general principle of this matching algorithm  is  that  it
+       scans  the subject string only once, without backtracking, there is one
+       exception: when a lookaround assertion is encountered,  the  characters
+       following  or  preceding  the  current  point  have to be independently
+       inspected.
+
+       The scan continues until either the end of the subject is  reached,  or
+       there  are  no more unterminated paths. At this point, terminated paths
+       represent the different matching possibilities (if there are none,  the
+       match  has  failed).   Thus,  if there is more than one possible match,
+       this algorithm finds all of them, and in particular, it finds the long-
+       est.  The  matches are returned in decreasing order of length. There is
+       an option to stop the algorithm after the first match (which is  neces-
+       sarily the shortest) is found.
+
+       Note that all the matches that are found start at the same point in the
+       subject. If the pattern
+
+         cat(er(pillar)?)?
+
+       is matched against the string "the caterpillar catchment",  the  result
+       is  the  three  strings "caterpillar", "cater", and "cat" that start at
+       the fifth character of the subject. The algorithm  does  not  automati-
+       cally move on to find matches that start at later positions.
+
+       PCRE2's "auto-possessification" optimization usually applies to charac-
+       ter repeats at the end of a pattern (as well as internally). For  exam-
+       ple, the pattern "a\d+" is compiled as if it were "a\d++" because there
+       is no point even considering the possibility of backtracking  into  the
+       repeated  digits.  For  DFA matching, this means that only one possible
+       match is found. If you really do want multiple matches in  such  cases,
+       either  use  an ungreedy repeat ("a\d+?") or set the PCRE2_NO_AUTO_POS-
+       SESS option when compiling.
+
+       There are a number of features of PCRE2 regular  expressions  that  are
+       not  supported  by the alternative matching algorithm. They are as fol-
+       lows:
+
+       1. Because the algorithm finds all  possible  matches,  the  greedy  or
+       ungreedy  nature  of  repetition quantifiers is not relevant (though it
+       may affect auto-possessification, as just described). During  matching,
+       greedy  and  ungreedy  quantifiers are treated in exactly the same way.
+       However, possessive quantifiers can make a difference when what follows
+       could  also  match  what  is  quantified, for example in a pattern like
+       this:
+
+         ^a++\w!
+
+       This pattern matches "aaab!" but not "aaa!", which would be matched  by
+       a  non-possessive quantifier. Similarly, if an atomic group is present,
+       it is matched as if it were a standalone pattern at the current  point,
+       and  the  longest match is then "locked in" for the rest of the overall
+       pattern.
+
+       2. When dealing with multiple paths through the tree simultaneously, it
+       is  not  straightforward  to  keep track of captured substrings for the
+       different matching possibilities, and PCRE2's  implementation  of  this
+       algorithm does not attempt to do this. This means that no captured sub-
+       strings are available.
+
+       3. Because no substrings are captured, back references within the  pat-
+       tern are not supported, and cause errors if encountered.
+
+       4.  For  the same reason, conditional expressions that use a backrefer-
+       ence as the condition or test for a specific group  recursion  are  not
+       supported.
+
+       5.  Because  many  paths  through the tree may be active, the \K escape
+       sequence, which resets the start of the match when encountered (but may
+       be  on  some  paths  and not on others), is not supported. It causes an
+       error if encountered.
+
+       6. Callouts are supported, but the value of the  capture_top  field  is
+       always 1, and the value of the capture_last field is always 0.
+
+       7.  The  \C  escape  sequence, which (in the standard algorithm) always
+       matches a single code unit, even in a UTF mode,  is  not  supported  in
+       these  modes,  because the alternative algorithm moves through the sub-
+       ject string one character (not code unit) at a  time,  for  all  active
+       paths through the tree.
+
+       8.  Except for (*FAIL), the backtracking control verbs such as (*PRUNE)
+       are not supported. (*FAIL) is supported, and  behaves  like  a  failing
+       negative assertion.
+
+
+ADVANTAGES OF THE ALTERNATIVE ALGORITHM
+
+       Using  the alternative matching algorithm provides the following advan-
+       tages:
+
+       1. All possible matches (at a single point in the subject) are automat-
+       ically  found,  and  in particular, the longest match is found. To find
+       more than one match using the standard algorithm, you have to do kludgy
+       things with callouts.
+
+       2.  Because  the  alternative  algorithm  scans the subject string just
+       once, and never needs to backtrack (except for lookbehinds), it is pos-
+       sible  to  pass  very  long subject strings to the matching function in
+       several pieces, checking for partial matching each time. Although it is
+       also  possible  to  do  multi-segment matching using the standard algo-
+       rithm, by retaining partially matched substrings, it  is  more  compli-
+       cated. The pcre2partial documentation gives details of partial matching
+       and discusses multi-segment matching.
+
+
+DISADVANTAGES OF THE ALTERNATIVE ALGORITHM
+
+       The alternative algorithm suffers from a number of disadvantages:
+
+       1. It is substantially slower than  the  standard  algorithm.  This  is
+       partly  because  it has to search for all possible matches, but is also
+       because it is less susceptible to optimization.
+
+       2. Capturing parentheses and back references are not supported.
+
+       3. Although atomic groups are supported, their use does not provide the
+       performance advantage that it does for the standard algorithm.
+
+
+AUTHOR
+
+       Philip Hazel
+       University Computing Service
+       Cambridge CB2 3QH, England.
+
+
+REVISION
+
+       Last updated: 29 September 2014
+       Copyright (c) 1997-2014 University of Cambridge.
+------------------------------------------------------------------------------
+ 
+ 
+PCRE2PARTIAL(3)            Library Functions Manual            PCRE2PARTIAL(3)
+
+
+
+NAME
+       PCRE2 - Perl-compatible regular expressions
+
+PARTIAL MATCHING IN PCRE2
+
+       In  normal  use  of  PCRE2,  if  the subject string that is passed to a
+       matching function matches as far as it goes, but is too short to  match
+       the  entire pattern, PCRE2_ERROR_NOMATCH is returned. There are circum-
+       stances where it might be helpful to distinguish this case  from  other
+       cases in which there is no match.
+
+       Consider, for example, an application where a human is required to type
+       in data for a field with specific formatting requirements.  An  example
+       might be a date in the form ddmmmyy, defined by this pattern:
+
+         ^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$
+
+       If the application sees the user's keystrokes one by one, and can check
+       that what has been typed so far is potentially valid,  it  is  able  to
+       raise  an  error  as  soon  as  a  mistake  is made, by beeping and not
+       reflecting the character that has been typed, for example. This immedi-
+       ate  feedback is likely to be a better user interface than a check that
+       is delayed until the entire string has been entered.  Partial  matching
+       can  also be useful when the subject string is very long and is not all
+       available at once.
+
+       PCRE2 supports partial matching by means of the PCRE2_PARTIAL_SOFT  and
+       PCRE2_PARTIAL_HARD  options,  which  can be set when calling a matching
+       function.  The difference between the two options is whether or  not  a
+       partial match is preferred to an alternative complete match, though the
+       details differ between the two types  of  matching  function.  If  both
+       options are set, PCRE2_PARTIAL_HARD takes precedence.
+
+       If  you  want to use partial matching with just-in-time optimized code,
+       you must call pcre2_jit_compile() with one or both of these options:
+
+         PCRE2_JIT_PARTIAL_SOFT
+         PCRE2_JIT_PARTIAL_HARD
+
+       PCRE2_JIT_COMPLETE should also be set if you are going to run  non-par-
+       tial  matches  on the same pattern. If the appropriate JIT mode has not
+       been compiled, interpretive matching code is used.
+
+       Setting a partial matching option  disables  two  of  PCRE2's  standard
+       optimizations. PCRE2 remembers the last literal code unit in a pattern,
+       and abandons matching immediately if it is not present in  the  subject
+       string.  This  optimization  cannot  be  used for a subject string that
+       might match only partially. PCRE2 also knows the minimum  length  of  a
+       matching  string,  and  does not bother to run the matching function on
+       shorter strings. This optimization is also disabled for partial  match-
+       ing.
+
+
+PARTIAL MATCHING USING pcre2_match()
+
+       A  partial  match occurs during a call to pcre2_match() when the end of
+       the subject string is reached successfully, but  matching  cannot  con-
+       tinue because more characters are needed. However, at least one charac-
+       ter in the subject must have been inspected. This  character  need  not
+       form part of the final matched string; lookbehind assertions and the \K
+       escape sequence provide ways of inspecting characters before the  start
+       of  a matched string. The requirement for inspecting at least one char-
+       acter exists because an empty string can  always  be  matched;  without
+       such  a  restriction  there would always be a partial match of an empty
+       string at the end of the subject.
+
+       When a partial match is returned, the first two elements in the ovector
+       point to the portion of the subject that was matched. The appearance of
+       \K in the pattern has no effect for a partial match. Consider this pat-
+       tern:
+
+         /abc\K123/
+
+       If it is matched against "456abc123xyz" the result is a complete match,
+       and the ovector defines the matched string as "123", because \K  resets
+       the  "start  of  match" point. However, if a partial match is requested
+       and the subject string is "456abc12", a partial match is found for  the
+       string  "abc12",  because  all these characters are needed for a subse-
+       quent re-match with additional characters.
+
+       What happens when a partial match is identified depends on which of the
+       two partial matching options are set.
+
+   PCRE2_PARTIAL_SOFT WITH pcre2_match()
+
+       If  PCRE2_PARTIAL_SOFT  is  set when pcre2_match() identifies a partial
+       match, the partial match is remembered, but matching continues as  nor-
+       mal,  and  other  alternatives in the pattern are tried. If no complete
+       match  can  be  found,  PCRE2_ERROR_PARTIAL  is  returned  instead   of
+       PCRE2_ERROR_NOMATCH.
+
+       This  option  is "soft" because it prefers a complete match over a par-
+       tial match.  All the various matching items in a pattern behave  as  if
+       the  subject string is potentially complete. For example, \z, \Z, and $
+       match at the end of the subject, as normal, and for \b and \B  the  end
+       of the subject is treated as a non-alphanumeric.
+
+       If  there  is more than one partial match, the first one that was found
+       provides the data that is returned. Consider this pattern:
+
+         /123\w+X|dogY/
+
+       If this is matched against the subject string "abc123dog", both  alter-
+       natives  fail  to  match,  but the end of the subject is reached during
+       matching, so PCRE2_ERROR_PARTIAL is returned. The offsets are set to  3
+       and  9, identifying "123dog" as the first partial match that was found.
+       (In this example, there are two partial matches, because "dog"  on  its
+       own partially matches the second alternative.)
+
+   PCRE2_PARTIAL_HARD WITH pcre2_match()
+
+       If  PCRE2_PARTIAL_HARD is set for pcre2_match(), PCRE2_ERROR_PARTIAL is
+       returned as soon as a partial match is  found,  without  continuing  to
+       search  for possible complete matches. This option is "hard" because it
+       prefers an earlier partial match over a later complete match. For  this
+       reason,  the  assumption  is  made that the end of the supplied subject
+       string may not be the true end of the available data, and  so,  if  \z,
+       \Z,  \b, \B, or $ are encountered at the end of the subject, the result
+       is PCRE2_ERROR_PARTIAL, provided that at least  one  character  in  the
+       subject has been inspected.
+
+   Comparing hard and soft partial matching
+
+       The  difference  between the two partial matching options can be illus-
+       trated by a pattern such as:
+
+         /dog(sbody)?/
+
+       This matches either "dog" or "dogsbody", greedily (that is, it  prefers
+       the  longer  string  if  possible). If it is matched against the string
+       "dog" with PCRE2_PARTIAL_SOFT, it yields a complete  match  for  "dog".
+       However,  if  PCRE2_PARTIAL_HARD is set, the result is PCRE2_ERROR_PAR-
+       TIAL. On the other hand, if the pattern is made ungreedy the result  is
+       different:
+
+         /dog(sbody)??/
+
+       In  this  case  the  result  is always a complete match because that is
+       found first, and matching never  continues  after  finding  a  complete
+       match. It might be easier to follow this explanation by thinking of the
+       two patterns like this:
+
+         /dog(sbody)?/    is the same as  /dogsbody|dog/
+         /dog(sbody)??/   is the same as  /dog|dogsbody/
+
+       The second pattern will never match "dogsbody", because it will  always
+       find the shorter match first.
+
+
+PARTIAL MATCHING USING pcre2_dfa_match()
+
+       The DFA functions move along the subject string character by character,
+       without backtracking, searching for  all  possible  matches  simultane-
+       ously.  If the end of the subject is reached before the end of the pat-
+       tern, there is the possibility of a partial match, again provided  that
+       at least one character has been inspected.
+
+       When PCRE2_PARTIAL_SOFT is set, PCRE2_ERROR_PARTIAL is returned only if
+       there have been no complete matches. Otherwise,  the  complete  matches
+       are  returned.   However, if PCRE2_PARTIAL_HARD is set, a partial match
+       takes precedence over any complete matches. The portion of  the  string
+       that was matched when the longest partial match was found is set as the
+       first matching string.
+
+       Because the DFA functions always search for all possible  matches,  and
+       there  is  no  difference between greedy and ungreedy repetition, their
+       behaviour is different from  the  standard  functions  when  PCRE2_PAR-
+       TIAL_HARD  is  set.  Consider  the  string  "dog"  matched  against the
+       ungreedy pattern shown above:
+
+         /dog(sbody)??/
+
+       Whereas the standard functions stop as soon as they find  the  complete
+       match  for  "dog",  the  DFA  functions also find the partial match for
+       "dogsbody", and so return that when PCRE2_PARTIAL_HARD is set.
+
+
+PARTIAL MATCHING AND WORD BOUNDARIES
+
+       If a pattern ends with one of sequences \b or \B, which test  for  word
+       boundaries,  partial matching with PCRE2_PARTIAL_SOFT can give counter-
+       intuitive results. Consider this pattern:
+
+         /\bcat\b/
+
+       This matches "cat", provided there is a word boundary at either end. If
+       the subject string is "the cat", the comparison of the final "t" with a
+       following character cannot take place, so a  partial  match  is  found.
+       However,  normal  matching carries on, and \b matches at the end of the
+       subject when the last character is a letter, so  a  complete  match  is
+       found.   The  result,  therefore,  is  not  PCRE2_ERROR_PARTIAL.  Using
+       PCRE2_PARTIAL_HARD in this case does yield PCRE2_ERROR_PARTIAL, because
+       then the partial match takes precedence.
+
+
+EXAMPLE OF PARTIAL MATCHING USING PCRE2TEST
+
+       If  the  partial_soft  (or  ps) modifier is present on a pcre2test data
+       line, the PCRE2_PARTIAL_SOFT option is used for the match.  Here  is  a
+       run of pcre2test that uses the date example quoted above:
+
+           re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
+         data> 25jun04\=ps
+          0: 25jun04
+          1: jun
+         data> 25dec3\=ps
+         Partial match: 23dec3
+         data> 3ju\=ps
+         Partial match: 3ju
+         data> 3juj\=ps
+         No match
+         data> j\=ps
+         No match
+
+       The  first  data  string  is matched completely, so pcre2test shows the
+       matched substrings. The remaining four strings do not  match  the  com-
+       plete pattern, but the first two are partial matches. Similar output is
+       obtained if DFA matching is used.
+
+       If the partial_hard (or ph) modifier is present  on  a  pcre2test  data
+       line, the PCRE2_PARTIAL_HARD option is set for the match.
+
+
+MULTI-SEGMENT MATCHING WITH pcre2_dfa_match()
+
+       When  a  partial match has been found using a DFA matching function, it
+       is possible to continue the match by providing additional subject  data
+       and  calling  the function again with the same compiled regular expres-
+       sion, this time setting the PCRE2_DFA_RESTART option. You must pass the
+       same working space as before, because this is where details of the pre-
+       vious partial match are stored. Here is an example using pcre2test:
+
+           re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
+         data> 23ja\=dfa,ps
+         Partial match: 23ja
+         data> n05\=dfa,dfa_restart
+          0: n05
+
+       The first call has "23ja" as the subject, and requests  partial  match-
+       ing;  the  second  call  has  "n05"  as  the  subject for the continued
+       (restarted) match.  Notice that when the match is  complete,  only  the
+       last  part  is  shown;  PCRE2 does not retain the previously partially-
+       matched string. It is up to the calling program to do that if it  needs
+       to.
+
+       That means that, for an unanchored pattern, if a continued match fails,
+       it is not possible to try again at  a  new  starting  point.  All  this
+       facility  is  capable  of  doing  is continuing with the previous match
+       attempt. In the previous example, if the second set of data  is  "ug23"
+       the  result is no match, even though there would be a match for "aug23"
+       if the entire string were given at once. Depending on the  application,
+       this may or may not be what you want.  The only way to allow for start-
+       ing again at the next character is to retain the matched  part  of  the
+       subject and try a new complete match.
+
+       You  can  set the PCRE2_PARTIAL_SOFT or PCRE2_PARTIAL_HARD options with
+       PCRE2_DFA_RESTART to continue partial matching over multiple  segments.
+       This  facility can be used to pass very long subject strings to the DFA
+       matching functions.
+
+
+MULTI-SEGMENT MATCHING WITH pcre2_match()
+
+       Unlike the DFA function, it is not possible  to  restart  the  previous
+       match with a new segment of data when using pcre2_match(). Instead, new
+       data must be added to the previous subject string, and the entire match
+       re-run,  starting from the point where the partial match occurred. Ear-
+       lier data can be discarded.
+
+       It is best to use PCRE2_PARTIAL_HARD in this situation, because it does
+       not  treat the end of a segment as the end of the subject when matching
+       \z, \Z, \b, \B, and $. Consider  an  unanchored  pattern  that  matches
+       dates:
+
+           re> /\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d/
+         data> The date is 23ja\=ph
+         Partial match: 23ja
+
+       At  this stage, an application could discard the text preceding "23ja",
+       add on text from the next  segment,  and  call  the  matching  function
+       again.  Unlike  the  DFA  matching function, the entire matching string
+       must always be available, and the complete matching process occurs  for
+       each call, so more memory and more processing time is needed.
+
+
+ISSUES WITH MULTI-SEGMENT MATCHING
+
+       Certain types of pattern may give problems with multi-segment matching,
+       whichever matching function is used.
+
+       1. If the pattern contains a test for the beginning of a line, you need
+       to  pass  the  PCRE2_NOTBOL option when the subject string for any call
+       does start at the beginning of a line. There  is  also  a  PCRE2_NOTEOL
+       option, but in practice when doing multi-segment matching you should be
+       using PCRE2_PARTIAL_HARD, which includes the effect of PCRE2_NOTEOL.
+
+       2. If a pattern contains a lookbehind assertion, characters  that  pre-
+       cede  the start of the partial match may have been inspected during the
+       matching process.  When using pcre2_match(), sufficient characters must
+       be  retained  for  the  next  match attempt. You can ensure that enough
+       characters are retained by doing the following:
+
+       Before doing any matching, find the length of the longest lookbehind in
+       the     pattern    by    calling    pcre2_pattern_info()    with    the
+       PCRE2_INFO_MAXLOOKBEHIND option. Note that the resulting  count  is  in
+       characters, not code units. After a partial match, moving back from the
+       ovector[0] offset in the subject by the number of characters given  for
+       the  maximum lookbehind gets you to the earliest character that must be
+       retained. In a non-UTF or a 32-bit situation, moving  back  is  just  a
+       subtraction,  but in UTF-8 or UTF-16 you have to count characters while
+       moving back through the code units.
+
+       Characters before the point you have now reached can be discarded,  and
+       after  the  next segment has been added to what is retained, you should
+       run the next match with the startoffset argument set so that the  match
+       begins at the same point as before.
+
+       For  example, if the pattern "(?<=123)abc" is partially matched against
+       the string "xx123ab", the ovector offsets are 5 and 7 ("ab"). The maxi-
+       mum  lookbehind  count  is  3, so all characters before offset 2 can be
+       discarded. The value of startoffset for the next  match  should  be  3.
+       When  pcre2test  displays  a partial match, it indicates the lookbehind
+       characters with '<' characters:
+
+           re> "(?<=123)abc"
+         data> xx123ab\=ph
+         Partial match: 123ab
+                        <<<
+
+       3. Because a partial match must always contain at least one  character,
+       what  might  be  considered a partial match of an empty string actually
+       gives a "no match" result. For example:
+
+           re> /c(?<=abc)x/
+         data> ab\=ps
+         No match
+
+       If the next segment begins "cx", a match should be found, but this will
+       only  happen  if characters from the previous segment are retained. For
+       this reason, a "no match" result  should  be  interpreted  as  "partial
+       match of an empty string" when the pattern contains lookbehinds.
+
+       4.  Matching  a subject string that is split into multiple segments may
+       not always produce exactly the same result as matching over one  single
+       long  string,  especially  when PCRE2_PARTIAL_SOFT is used. The section
+       "Partial Matching and Word Boundaries" above describes  an  issue  that
+       arises  if  the  pattern ends with \b or \B. Another kind of difference
+       may occur when there are multiple matching possibilities, because  (for
+       PCRE2_PARTIAL_SOFT) a partial match result is given only when there are
+       no completed matches. This means that as soon as the shortest match has
+       been  found,  continuation to a new subject segment is no longer possi-
+       ble. Consider this pcre2test example:
+
+           re> /dog(sbody)?/
+         data> dogsb\=ps
+          0: dog
+         data> do\=ps,dfa
+         Partial match: do
+         data> gsb\=ps,dfa,dfa_restart
+          0: g
+         data> dogsbody\=dfa
+          0: dogsbody
+          1: dog
+
+       The first data line passes the string "dogsb" to  a  standard  matching
+       function, setting the PCRE2_PARTIAL_SOFT option. Although the string is
+       a partial match for "dogsbody", the result is not  PCRE2_ERROR_PARTIAL,
+       because  the  shorter string "dog" is a complete match. Similarly, when
+       the subject is presented to a DFA matching function  in  several  parts
+       ("do"  and  "gsb"  being  the first two) the match stops when "dog" has
+       been found, and it is not possible to continue.  On the other hand,  if
+       "dogsbody"  is  presented  as  a single string, a DFA matching function
+       finds both matches.
+
+       Because of these problems, it is best to  use  PCRE2_PARTIAL_HARD  when
+       matching  multi-segment  data.  The  example above then behaves differ-
+       ently:
+
+           re> /dog(sbody)?/
+         data> dogsb\=ph
+         Partial match: dogsb
+         data> do\=ps,dfa
+         Partial match: do
+         data> gsb\=ph,dfa,dfa_restart
+         Partial match: gsb
+
+       5. Patterns that contain alternatives at the top level which do not all
+       start  with  the  same  pattern  item  may  not  work  as expected when
+       PCRE2_DFA_RESTART is used. For example, consider this pattern:
+
+         1234|3789
+
+       If the first part of the subject is "ABC123", a partial  match  of  the
+       first  alternative  is found at offset 3. There is no partial match for
+       the second alternative, because such a match does not start at the same
+       point  in  the  subject  string. Attempting to continue with the string
+       "7890" does not yield a match  because  only  those  alternatives  that
+       match  at  one  point in the subject are remembered. The problem arises
+       because the start of the second alternative matches  within  the  first
+       alternative.  There  is  no  problem with anchored patterns or patterns
+       such as:
+
+         1234|ABCD
+
+       where no string can be a partial match for both alternatives.  This  is
+       not  a  problem  if  a  standard matching function is used, because the
+       entire match has to be rerun each time:
+
+           re> /1234|3789/
+         data> ABC123\=ph
+         Partial match: 123
+         data> 1237890
+          0: 3789
+
+       Of course, instead of using PCRE2_DFA_RESTART, the  same  technique  of
+       re-running  the  entire  match  can  also be used with the DFA matching
+       function. Another possibility is to work with two buffers. If a partial
+       match  at  offset  n in the first buffer is followed by "no match" when
+       PCRE2_DFA_RESTART is used on the second buffer, you can then try a  new
+       match starting at offset n+1 in the first buffer.
+
+
+AUTHOR
+
+       Philip Hazel
+       University Computing Service
+       Cambridge CB2 3QH, England.
+
+
+REVISION
+
+       Last updated: 14 October 2014
+       Copyright (c) 1997-2014 University of Cambridge.
+------------------------------------------------------------------------------
+ 
+ 
 PCRE2UNICODE(3)            Library Functions Manual            PCRE2UNICODE(3)
 
 
diff --git a/doc/pcre2api.3 b/doc/pcre2api.3
index f766417..47351cd 100644
--- a/doc/pcre2api.3
+++ b/doc/pcre2api.3
@@ -872,6 +872,7 @@ the PCRE2 version string, zero-terminated. The length of the string (in code
 units) is returned.
 .
 .
+.\" HTML 
 .SH "COMPILING A PATTERN"
 .rs
 .sp
diff --git a/doc/pcre2pattern.3 b/doc/pcre2pattern.3
new file mode 100644
index 0000000..8e10337
--- /dev/null
+++ b/doc/pcre2pattern.3
@@ -0,0 +1,3241 @@
+.TH PCRE2PATTERN 3 "19 October 2014" "PCRE2 10.00"
+.SH NAME
+PCRE2 - Perl-compatible regular expressions (revised API)
+.SH "PCRE2 REGULAR EXPRESSION DETAILS"
+.rs
+.sp
+The syntax and semantics of the regular expressions that are supported by PCRE2
+are described in detail below. There is a quick-reference syntax summary in the
+.\" HREF
+\fBpcre2syntax\fP
+.\"
+page. PCRE2 tries to match Perl syntax and semantics as closely as it can.
+PCRE2 also supports some alternative regular expression syntax (which does not
+conflict with the Perl syntax) in order to provide some compatibility with
+regular expressions in Python, .NET, and Oniguruma.
+.P
+Perl's regular expressions are described in its own documentation, and regular
+expressions in general are covered in a number of books, some of which have
+copious examples. Jeffrey Friedl's "Mastering Regular Expressions", published
+by O'Reilly, covers regular expressions in great detail. This description of
+PCRE2's regular expressions is intended as reference material.
+.P
+This document discusses the patterns that are supported by PCRE2 when its main
+matching function, \fBpcre2_match()\fP, is used. PCRE2 also has an alternative
+matching function, \fBpcre2_dfa_match()\fP, which matches using a different
+algorithm that is not Perl-compatible. Some of the features discussed below are
+not available when DFA matching is used. The advantages and disadvantages of
+the alternative function, and how it differs from the normal function, are
+discussed in the
+.\" HREF
+\fBpcre2matching\fP
+.\"
+page.
+.
+.
+.SH "SPECIAL START-OF-PATTERN ITEMS"
+.rs
+.sp
+A number of options that can be passed to \fBpcre2_compile()\fP can also be set
+by special items at the start of a pattern. These are not Perl-compatible, but
+are provided to make these options accessible to pattern writers who are not
+able to change the program that processes the pattern. Any number of these
+items may appear, but they must all be together right at the start of the
+pattern string, and the letters must be in upper case.
+.
+.
+.SS "UTF support"
+.rs
+.sp
+In the 8-bit and 16-bit PCRE2 libraries, characters may be coded either as
+single code units, or as multiple UTF-8 or UTF-16 code units. UTF-32 can be
+specified for the 32-bit library, in which case it constrains the character
+values to valid Unicode code points. To process UTF strings, PCRE2 must be
+built to include Unicode support. When using UTF strings you must either call
+the compiling function with the PCRE2_UTF option, or the pattern must start
+with the special sequence (*UTF), which is equivalent to setting the relevant
+option. How setting a UTF mode affects pattern matching is mentioned in several
+places below. There is also a summary of features in the
+.\" HREF
+\fBpcre2unicode\fP
+.\"
+page.
+.P
+Some applications that allow their users to supply patterns may wish to
+restrict them to non-UTF data for security reasons. If the PCRE2_NEVER_UTF
+option is set at compile time, (*UTF) is not allowed, and its appearance causes
+an error.
+.
+.
+.SS "Unicode property support"
+.rs
+.sp
+Another special sequence that may appear at the start of a pattern is (*UCP).
+This has the same effect as setting the PCRE2_UCP option: it causes sequences
+such as \ed and \ew to use Unicode properties to determine character types,
+instead of recognizing only characters with codes less than 128 via a lookup
+table.
+.
+.
+.SS "Disabling auto-possessification"
+.rs
+.sp
+If a pattern starts with (*NO_AUTO_POSSESS), it has the same effect as setting
+the PCRE2_NO_AUTO_POSSESS option. This stops PCRE2 from making quantifiers
+possessive when what follows cannot match the repeated item. For example, by
+default a+b is treated as a++b. For more details, see the
+.\" HREF
+\fBpcre2api\fP
+.\"
+documentation.
+.
+.
+.SS "Disabling start-up optimizations"
+.rs
+.sp
+If a pattern starts with (*NO_START_OPT), it has the same effect as setting the
+PCRE2_NO_START_OPTIMIZE option. This disables several optimizations for quickly
+reaching "no match" results. For more details, see the
+.\" HREF
+\fBpcre2api\fP
+.\"
+documentation.
+.
+.
+.\" HTML 
+.SS "Newline conventions"
+.rs
+.sp
+PCRE2 supports five different conventions for indicating line breaks in
+strings: a single CR (carriage return) character, a single LF (linefeed)
+character, the two-character sequence CRLF, any of the three preceding, or any
+Unicode newline sequence. The
+.\" HREF
+\fBpcre2api\fP
+.\"
+page has
+.\" HTML 
+.\" 
+further discussion
+.\"
+about newlines, and shows how to set the newline convention when calling 
+\fBpcre2_compile()\fP.
+.P
+It is also possible to specify a newline convention by starting a pattern
+string with one of the following five sequences:
+.sp
+  (*CR)        carriage return
+  (*LF)        linefeed
+  (*CRLF)      carriage return, followed by linefeed
+  (*ANYCRLF)   any of the three above
+  (*ANY)       all Unicode newline sequences
+.sp
+These override the default and the options given to the compiling function. For
+example, on a Unix system where LF is the default newline sequence, the pattern
+.sp
+  (*CR)a.b
+.sp
+changes the convention to CR. That pattern matches "a\enb" because LF is no
+longer a newline. If more than one of these settings is present, the last one
+is used.
+.P
+The newline convention affects where the circumflex and dollar assertions are
+true. It also affects the interpretation of the dot metacharacter when
+PCRE2_DOTALL is not set, and the behaviour of \eN. However, it does not affect
+what the \eR escape sequence matches. By default, this is any Unicode newline
+sequence, for Perl compatibility. However, this can be changed; see the
+description of \eR in the section entitled
+.\" HTML 
+.\" 
+"Newline sequences"
+.\"
+below. A change of \eR setting can be combined with a change of newline
+convention.
+.
+.
+.SS "Setting match and recursion limits"
+.rs
+.sp
+The caller of \fBpcre2_match()\fP can set a limit on the number of times the
+internal \fBmatch()\fP function is called and on the maximum depth of
+recursive calls. These facilities are provided to catch runaway matches that
+are provoked by patterns with huge matching trees (a typical example is a
+pattern with nested unlimited repeats) and to avoid running out of system stack
+by too much recursion. When one of these limits is reached, \fBpcre2_match()\fP
+gives an error return. The limits can also be set by items at the start of the
+pattern of the form
+.sp
+  (*LIMIT_MATCH=d)
+  (*LIMIT_RECURSION=d)
+.sp
+where d is any number of decimal digits. However, the value of the setting must
+be less than the value set (or defaulted) by the caller of \fBpcre2_match()\fP
+for it to have any effect. In other words, the pattern writer can lower the
+limits set by the programmer, but not raise them. If there is more than one
+setting of one of these limits, the lower value is used.
+.
+.
+.SH "EBCDIC CHARACTER CODES"
+.rs
+.sp
+PCRE2 can be compiled to run in an environment that uses EBCDIC as its
+character code rather than ASCII or Unicode (typically a mainframe system). In
+the sections below, character code values are ASCII or Unicode; in an EBCDIC
+environment these characters may have different code values, and there are no
+code points greater than 255.
+.
+.
+.SH "CHARACTERS AND METACHARACTERS"
+.rs
+.sp
+A regular expression is a pattern that is matched against a subject string from
+left to right. Most characters stand for themselves in a pattern, and match the
+corresponding characters in the subject. As a trivial example, the pattern
+.sp
+  The quick brown fox
+.sp
+matches a portion of a subject string that is identical to itself. When
+caseless matching is specified (the PCRE2_CASELESS option), letters are matched
+independently of case. 
+.P
+The power of regular expressions comes from the ability to include alternatives
+and repetitions in the pattern. These are encoded in the pattern by the use of
+\fImetacharacters\fP, which do not stand for themselves but instead are
+interpreted in some special way.
+.P
+There are two different sets of metacharacters: those that are recognized
+anywhere in the pattern except within square brackets, and those that are
+recognized within square brackets. Outside square brackets, the metacharacters
+are as follows:
+.sp
+  \e      general escape character with several uses
+  ^      assert start of string (or line, in multiline mode)
+  $      assert end of string (or line, in multiline mode)
+  .      match any character except newline (by default)
+  [      start character class definition
+  |      start of alternative branch
+  (      start subpattern
+  )      end subpattern
+  ?      extends the meaning of (
+         also 0 or 1 quantifier
+         also quantifier minimizer
+  *      0 or more quantifier
+  +      1 or more quantifier
+         also "possessive quantifier"
+  {      start min/max quantifier
+.sp
+Part of a pattern that is in square brackets is called a "character class". In
+a character class the only metacharacters are:
+.sp
+  \e      general escape character
+  ^      negate the class, but only if the first character
+  -      indicates character range
+.\" JOIN
+  [      POSIX character class (only if followed by POSIX
+           syntax)
+  ]      terminates the character class
+.sp
+The following sections describe the use of each of the metacharacters.
+.
+.
+.SH BACKSLASH
+.rs
+.sp
+The backslash character has several uses. Firstly, if it is followed by a
+character that is not a number or a letter, it takes away any special meaning
+that character may have. This use of backslash as an escape character applies
+both inside and outside character classes.
+.P
+For example, if you want to match a * character, you write \e* in the pattern.
+This escaping action applies whether or not the following character would
+otherwise be interpreted as a metacharacter, so it is always safe to precede a
+non-alphanumeric with backslash to specify that it stands for itself. In
+particular, if you want to match a backslash, you write \e\e.
+.P
+In a UTF mode, only ASCII numbers and letters have any special meaning after a
+backslash. All other characters (in particular, those whose codepoints are
+greater than 127) are treated as literals.
+.P
+If a pattern is compiled with the PCRE2_EXTENDED option, most white space in
+the pattern (other than in a character class), and characters between a #
+outside a character class and the next newline, inclusive, are ignored. An
+escaping backslash can be used to include a white space or # character as part
+of the pattern.
+.P
+If you want to remove the special meaning from a sequence of characters, you
+can do so by putting them between \eQ and \eE. This is different from Perl in
+that $ and @ are handled as literals in \eQ...\eE sequences in PCRE2, whereas
+in Perl, $ and @ cause variable interpolation. Note the following examples:
+.sp
+  Pattern            PCRE2 matches   Perl matches
+.sp
+.\" JOIN
+  \eQabc$xyz\eE        abc$xyz        abc followed by the
+                                      contents of $xyz
+  \eQabc\e$xyz\eE       abc\e$xyz       abc\e$xyz
+  \eQabc\eE\e$\eQxyz\eE   abc$xyz        abc$xyz
+.sp
+The \eQ...\eE sequence is recognized both inside and outside character classes.
+An isolated \eE that is not preceded by \eQ is ignored. If \eQ is not followed
+by \eE later in the pattern, the literal interpretation continues to the end of
+the pattern (that is, \eE is assumed at the end). If the isolated \eQ is inside
+a character class, this causes an error, because the character class is not
+terminated.
+.
+.
+.\" HTML 
+.SS "Non-printing characters"
+.rs
+.sp
+A second use of backslash provides a way of encoding non-printing characters
+in patterns in a visible manner. There is no restriction on the appearance of
+non-printing characters in a pattern, but when a pattern is being prepared by
+text editing, it is often easier to use one of the following escape sequences
+than the binary character it represents:
+.sp
+  \ea        alarm, that is, the BEL character (hex 07)
+  \ecx       "control-x", where x is any ASCII character
+  \ee        escape (hex 1B)
+  \ef        form feed (hex 0C)
+  \en        linefeed (hex 0A)
+  \er        carriage return (hex 0D)
+  \et        tab (hex 09)
+  \e0dd      character with octal code 0dd
+  \eddd      character with octal code ddd, or back reference
+  \eo{ddd..} character with octal code ddd..
+  \exhh      character with hex code hh
+  \ex{hhh..} character with hex code hhh.. (default mode)
+  \euhhhh    character with hex code hhhh (when PCRE2_ALT_BSUX is set)
+.sp
+The precise effect of \ecx on ASCII characters is as follows: if x is a lower
+case letter, it is converted to upper case. Then bit 6 of the character (hex
+40) is inverted. Thus \ecA to \ecZ become hex 01 to hex 1A (A is 41, Z is 5A),
+but \ec{ becomes hex 3B ({ is 7B), and \ec; becomes hex 7B (; is 3B). If the
+code unit following \ec has a value greater than 127, a compile-time error
+occurs. This locks out non-ASCII characters in all modes.
+.P
+The \ec facility was designed for use with ASCII characters, but with the
+extension to Unicode it is even less useful than it once was. It is, however,
+recognized when PCRE2 is compiled in EBCDIC mode, where data items are always
+bytes. In this mode, all values are valid after \ec. If the next character is a
+lower case letter, it is converted to upper case. Then the 0xc0 bits of the
+byte are inverted. Thus \ecA becomes hex 01, as in ASCII (A is C1), but because
+the EBCDIC letters are disjoint, \ecZ becomes hex 29 (Z is E9), and other
+characters also generate different values.
+.P
+After \e0 up to two further octal digits are read. If there are fewer than two
+digits, just those that are present are used. Thus the sequence \e0\ex\e07
+specifies two binary zeros followed by a BEL character (code value 7). Make
+sure you supply two digits after the initial zero if the pattern character that
+follows is itself an octal digit.
+.P
+The escape \eo must be followed by a sequence of octal digits, enclosed in
+braces. An error occurs if this is not the case. This escape is a recent
+addition to Perl; it provides way of specifying character code points as octal
+numbers greater than 0777, and it also allows octal numbers and back references
+to be unambiguously specified.
+.P
+For greater clarity and unambiguity, it is best to avoid following \e by a
+digit greater than zero. Instead, use \eo{} or \ex{} to specify character
+numbers, and \eg{} to specify back references. The following paragraphs
+describe the old, ambiguous syntax.
+.P
+The handling of a backslash followed by a digit other than 0 is complicated,
+and Perl has changed in recent releases, causing PCRE2 also to change. Outside
+a character class, PCRE2 reads the digit and any following digits as a decimal
+number. If the number is less than 8, or if there have been at least that many
+previous capturing left parentheses in the expression, the entire sequence is
+taken as a \fIback reference\fP. A description of how this works is given
+.\" HTML 
+.\" 
+later,
+.\"
+following the discussion of
+.\" HTML 
+.\" 
+parenthesized subpatterns.
+.\"
+.P
+Inside a character class, or if the decimal number following \e is greater than
+7 and there have not been that many capturing subpatterns, PCRE2 handles \e8
+and \e9 as the literal characters "8" and "9", and otherwise re-reads up to
+three octal digits following the backslash, using them to generate a data
+character. Any subsequent digits stand for themselves. For example:
+.sp
+  \e040   is another way of writing an ASCII space
+.\" JOIN
+  \e40    is the same, provided there are fewer than 40
+            previous capturing subpatterns
+  \e7     is always a back reference
+.\" JOIN
+  \e11    might be a back reference, or another way of
+            writing a tab
+  \e011   is always a tab
+  \e0113  is a tab followed by the character "3"
+.\" JOIN
+  \e113   might be a back reference, otherwise the
+            character with octal code 113
+.\" JOIN
+  \e377   might be a back reference, otherwise
+            the value 255 (decimal)
+.\" JOIN
+  \e81    is either a back reference, or the two
+            characters "8" and "1"
+.sp
+Note that octal values of 100 or greater that are specified using this syntax
+must not be introduced by a leading zero, because no more than three octal
+digits are ever read.
+.P
+By default, after \ex that is not followed by {, from zero to two hexadecimal
+digits are read (letters can be in upper or lower case). Any number of
+hexadecimal digits may appear between \ex{ and }. If a character other than
+a hexadecimal digit appears between \ex{ and }, or if there is no terminating
+}, an error occurs.
+.P
+If the PCRE2_ALT_BSUX option is set, the interpretation of \ex is as just
+described only when it is followed by two hexadecimal digits. Otherwise, it
+matches a literal "x" character. In this mode mode, support for code points
+greater than 256 is provided by \eu, which must be followed by four hexadecimal
+digits; otherwise it matches a literal "u" character.
+.P
+Characters whose value is less than 256 can be defined by either of the two
+syntaxes for \ex (or by \eu in PCRE2_ALT_BSUX mode). There is no difference in
+the way they are handled. For example, \exdc is exactly the same as \ex{dc} (or
+\eu00dc in PCRE2_ALT_BSUX mode).
+.
+.
+.SS "Constraints on character values"
+.rs
+.sp
+Characters that are specified using octal or hexadecimal numbers are
+limited to certain values, as follows:
+.sp
+  8-bit non-UTF mode    less than 0x100
+  8-bit UTF-8 mode      less than 0x10ffff and a valid codepoint
+  16-bit non-UTF mode   less than 0x10000
+  16-bit UTF-16 mode    less than 0x10ffff and a valid codepoint
+  32-bit non-UTF mode   less than 0x100000000
+  32-bit UTF-32 mode    less than 0x10ffff and a valid codepoint
+.sp
+Invalid Unicode codepoints are the range 0xd800 to 0xdfff (the so-called
+"surrogate" codepoints), and 0xffef.
+.
+.
+.SS "Escape sequences in character classes"
+.rs
+.sp
+All the sequences that define a single character value can be used both inside
+and outside character classes. In addition, inside a character class, \eb is
+interpreted as the backspace character (hex 08).
+.P
+\eN is not allowed in a character class. \eB, \eR, and \eX are not special
+inside a character class. Like other unrecognized alphabetic escape sequences,
+they cause an error. Outside a character class, these sequences have different
+meanings.
+.
+.
+.SS "Unsupported escape sequences"
+.rs
+.sp
+In Perl, the sequences \el, \eL, \eu, and \eU are recognized by its string
+handler and used to modify the case of following characters. By default, PCRE2
+does not support these escape sequences. However, if the PCRE2_ALT_BSUX option
+is set, \eU matches a "U" character, and \eu can be used to define a character
+by code point, as described in the previous section.
+.
+.
+.SS "Absolute and relative back references"
+.rs
+.sp
+The sequence \eg followed by an unsigned or a negative number, optionally
+enclosed in braces, is an absolute or relative back reference. A named back
+reference can be coded as \eg{name}. Back references are discussed
+.\" HTML 
+.\" 
+later,
+.\"
+following the discussion of
+.\" HTML 
+.\" 
+parenthesized subpatterns.
+.\"
+.
+.
+.SS "Absolute and relative subroutine calls"
+.rs
+.sp
+For compatibility with Oniguruma, the non-Perl syntax \eg followed by a name or
+a number enclosed either in angle brackets or single quotes, is an alternative
+syntax for referencing a subpattern as a "subroutine". Details are discussed
+.\" HTML 
+.\" 
+later.
+.\"
+Note that \eg{...} (Perl syntax) and \eg<...> (Oniguruma syntax) are \fInot\fP
+synonymous. The former is a back reference; the latter is a
+.\" HTML 
+.\" 
+subroutine
+.\"
+call.
+.
+.
+.\" HTML 
+.SS "Generic character types"
+.rs
+.sp
+Another use of backslash is for specifying generic character types:
+.sp
+  \ed     any decimal digit
+  \eD     any character that is not a decimal digit
+  \eh     any horizontal white space character
+  \eH     any character that is not a horizontal white space character
+  \es     any white space character
+  \eS     any character that is not a white space character
+  \ev     any vertical white space character
+  \eV     any character that is not a vertical white space character
+  \ew     any "word" character
+  \eW     any "non-word" character
+.sp
+There is also the single sequence \eN, which matches a non-newline character.
+This is the same as
+.\" HTML 
+.\" 
+the "." metacharacter
+.\"
+when PCRE2_DOTALL is not set. Perl also uses \eN to match characters by name;
+PCRE2 does not support this.
+.P
+Each pair of lower and upper case escape sequences partitions the complete set
+of characters into two disjoint sets. Any given character matches one, and only
+one, of each pair. The sequences can appear both inside and outside character
+classes. They each match one character of the appropriate type. If the current
+matching point is at the end of the subject string, all of them fail, because
+there is no character to match.
+.P
+The default \es characters are HT (9), LF (10), VT (11), FF (12), CR (13), and
+space (32), which are defined as white space in the "C" locale. This list may
+vary if locale-specific matching is taking place. For example, in some locales
+the "non-breaking space" character (\exA0) is recognized as white space, and in
+others the VT character is not.
+.P
+A "word" character is an underscore or any character that is a letter or digit.
+By default, the definition of letters and digits is controlled by PCRE2's
+low-valued character tables, and may vary if locale-specific matching is taking
+place (see
+.\" HTML 
+.\" 
+"Locale support"
+.\"
+in the
+.\" HREF
+\fBpcre2api\fP
+.\"
+page). For example, in a French locale such as "fr_FR" in Unix-like systems,
+or "french" in Windows, some character codes greater than 127 are used for
+accented letters, and these are then matched by \ew. The use of locales with
+Unicode is discouraged.
+.P
+By default, characters whose code points are greater than 127 never match \ed,
+\es, or \ew, and always match \eD, \eS, and \eW, although this may vary for
+characters in the range 128-255 when locale-specific matching is happening.
+These escape sequences retain their original meanings from before Unicode
+support was available, mainly for efficiency reasons. If PCRE2 is compiled with
+Unicode support, and the PCRE2_UCP option is set, the behaviour is changed so
+that Unicode properties are used to determine character types, as follows:
+.sp
+  \ed  any character that matches \ep{Nd} (decimal digit)
+  \es  any character that matches \ep{Z} or \eh or \ev
+  \ew  any character that matches \ep{L} or \ep{N}, plus underscore
+.sp
+The upper case escapes match the inverse sets of characters. Note that \ed
+matches only decimal digits, whereas \ew matches any Unicode digit, as well as
+any Unicode letter, and underscore. Note also that PCRE2_UCP affects \eb, and
+\eB because they are defined in terms of \ew and \eW. Matching these sequences
+is noticeably slower when PCRE2_UCP is set.
+.P
+The sequences \eh, \eH, \ev, and \eV, in contrast to the other sequences, which
+match only ASCII characters by default, always match a specific list of code
+points, whether or not PCRE2_UCP is set. The horizontal space characters are:
+.sp
+  U+0009     Horizontal tab (HT)
+  U+0020     Space
+  U+00A0     Non-break space
+  U+1680     Ogham space mark
+  U+180E     Mongolian vowel separator
+  U+2000     En quad
+  U+2001     Em quad
+  U+2002     En space
+  U+2003     Em space
+  U+2004     Three-per-em space
+  U+2005     Four-per-em space
+  U+2006     Six-per-em space
+  U+2007     Figure space
+  U+2008     Punctuation space
+  U+2009     Thin space
+  U+200A     Hair space
+  U+202F     Narrow no-break space
+  U+205F     Medium mathematical space
+  U+3000     Ideographic space
+.sp
+The vertical space characters are:
+.sp
+  U+000A     Linefeed (LF)
+  U+000B     Vertical tab (VT)
+  U+000C     Form feed (FF)
+  U+000D     Carriage return (CR)
+  U+0085     Next line (NEL)
+  U+2028     Line separator
+  U+2029     Paragraph separator
+.sp
+In 8-bit, non-UTF-8 mode, only the characters with code points less than 256
+are relevant.
+.
+.
+.\" HTML 
+.SS "Newline sequences"
+.rs
+.sp
+Outside a character class, by default, the escape sequence \eR matches any
+Unicode newline sequence. In 8-bit non-UTF-8 mode \eR is equivalent to the
+following:
+.sp
+  (?>\er\en|\en|\ex0b|\ef|\er|\ex85)
+.sp
+This is an example of an "atomic group", details of which are given
+.\" HTML 
+.\" 
+below.
+.\"
+This particular group matches either the two-character sequence CR followed by
+LF, or one of the single characters LF (linefeed, U+000A), VT (vertical tab,
+U+000B), FF (form feed, U+000C), CR (carriage return, U+000D), or NEL (next
+line, U+0085). The two-character sequence is treated as a single unit that
+cannot be split.
+.P
+In other modes, two additional characters whose codepoints are greater than 255
+are added: LS (line separator, U+2028) and PS (paragraph separator, U+2029).
+Unicode support is not needed for these characters to be recognized.
+.P
+It is possible to restrict \eR to match only CR, LF, or CRLF (instead of the
+complete set of Unicode line endings) by setting the option PCRE2_BSR_ANYCRLF
+at compile time. (BSR is an abbrevation for "backslash R".) This can be made
+the default when PCRE2 is built; if this is the case, the other behaviour can
+be requested via the PCRE2_BSR_UNICODE option. It is also possible to specify
+these settings by starting a pattern string with one of the following
+sequences:
+.sp
+  (*BSR_ANYCRLF)   CR, LF, or CRLF only
+  (*BSR_UNICODE)   any Unicode newline sequence
+.sp
+These override the default and the options given to the compiling function.
+Note that these special settings, which are not Perl-compatible, are recognized
+only at the very start of a pattern, and that they must be in upper case. If
+more than one of them is present, the last one is used. They can be combined
+with a change of newline convention; for example, a pattern can start with:
+.sp
+  (*ANY)(*BSR_ANYCRLF)
+.sp
+They can also be combined with the (*UTF) or (*UCP) special sequences. Inside a
+character class, \eR is treated as an unrecognized escape sequence, and causes
+an error.
+.
+.
+.\" HTML 
+.SS Unicode character properties
+.rs
+.sp
+When PCRE2 is built with Unicode support, three additional escape sequences
+that match characters with specific properties are available. In 8-bit
+non-UTF-8 mode, these sequences are of course limited to testing characters
+whose codepoints are less than 256, but they do work in this mode. The extra
+escape sequences are:
+.sp
+  \ep{\fIxx\fP}   a character with the \fIxx\fP property
+  \eP{\fIxx\fP}   a character without the \fIxx\fP property
+  \eX       a Unicode extended grapheme cluster
+.sp
+The property names represented by \fIxx\fP above are limited to the Unicode
+script names, the general category properties, "Any", which matches any
+character (including newline), and some special PCRE2 properties (described
+in the
+.\" HTML 
+.\" 
+next section).
+.\"
+Other Perl properties such as "InMusicalSymbols" are not supported by PCRE2.
+Note that \eP{Any} does not match any characters, so always causes a match
+failure.
+.P
+Sets of Unicode characters are defined as belonging to certain scripts. A
+character from one of these sets can be matched using a script name. For
+example:
+.sp
+  \ep{Greek}
+  \eP{Han}
+.sp
+Those that are not part of an identified script are lumped together as
+"Common". The current list of scripts is:
+.P
+Arabic,
+Armenian,
+Avestan,
+Balinese,
+Bamum,
+Bassa_Vah,
+Batak,
+Bengali,
+Bopomofo,
+Brahmi,
+Braille,
+Buginese,
+Buhid,
+Canadian_Aboriginal,
+Carian,
+Caucasian_Albanian,
+Chakma,
+Cham,
+Cherokee,
+Common,
+Coptic,
+Cuneiform,
+Cypriot,
+Cyrillic,
+Deseret,
+Devanagari,
+Duployan,
+Egyptian_Hieroglyphs,
+Elbasan,
+Ethiopic,
+Georgian,
+Glagolitic,
+Gothic,
+Grantha,
+Greek,
+Gujarati,
+Gurmukhi,
+Han,
+Hangul,
+Hanunoo,
+Hebrew,
+Hiragana,
+Imperial_Aramaic,
+Inherited,
+Inscriptional_Pahlavi,
+Inscriptional_Parthian,
+Javanese,
+Kaithi,
+Kannada,
+Katakana,
+Kayah_Li,
+Kharoshthi,
+Khmer,
+Khojki,
+Khudawadi,
+Lao,
+Latin,
+Lepcha,
+Limbu,
+Linear_A,
+Linear_B,
+Lisu,
+Lycian,
+Lydian,
+Mahajani,
+Malayalam,
+Mandaic,
+Manichaean,
+Meetei_Mayek,
+Mende_Kikakui,
+Meroitic_Cursive,
+Meroitic_Hieroglyphs,
+Miao,
+Modi,
+Mongolian,
+Mro,
+Myanmar,
+Nabataean,
+New_Tai_Lue,
+Nko,
+Ogham,
+Ol_Chiki,
+Old_Italic,
+Old_North_Arabian,
+Old_Permic,
+Old_Persian,
+Old_South_Arabian,
+Old_Turkic,
+Oriya,
+Osmanya,
+Pahawh_Hmong,
+Palmyrene,
+Pau_Cin_Hau,
+Phags_Pa,
+Phoenician,
+Psalter_Pahlavi,
+Rejang,
+Runic,
+Samaritan,
+Saurashtra,
+Sharada,
+Shavian,
+Siddham,
+Sinhala,
+Sora_Sompeng,
+Sundanese,
+Syloti_Nagri,
+Syriac,
+Tagalog,
+Tagbanwa,
+Tai_Le,
+Tai_Tham,
+Tai_Viet,
+Takri,
+Tamil,
+Telugu,
+Thaana,
+Thai,
+Tibetan,
+Tifinagh,
+Tirhuta,
+Ugaritic,
+Vai,
+Warang_Citi,
+Yi.
+.P
+Each character has exactly one Unicode general category property, specified by
+a two-letter abbreviation. For compatibility with Perl, negation can be
+specified by including a circumflex between the opening brace and the property
+name. For example, \ep{^Lu} is the same as \eP{Lu}.
+.P
+If only one letter is specified with \ep or \eP, it includes all the general
+category properties that start with that letter. In this case, in the absence
+of negation, the curly brackets in the escape sequence are optional; these two
+examples have the same effect:
+.sp
+  \ep{L}
+  \epL
+.sp
+The following general category property codes are supported:
+.sp
+  C     Other
+  Cc    Control
+  Cf    Format
+  Cn    Unassigned
+  Co    Private use
+  Cs    Surrogate
+.sp
+  L     Letter
+  Ll    Lower case letter
+  Lm    Modifier letter
+  Lo    Other letter
+  Lt    Title case letter
+  Lu    Upper case letter
+.sp
+  M     Mark
+  Mc    Spacing mark
+  Me    Enclosing mark
+  Mn    Non-spacing mark
+.sp
+  N     Number
+  Nd    Decimal number
+  Nl    Letter number
+  No    Other number
+.sp
+  P     Punctuation
+  Pc    Connector punctuation
+  Pd    Dash punctuation
+  Pe    Close punctuation
+  Pf    Final punctuation
+  Pi    Initial punctuation
+  Po    Other punctuation
+  Ps    Open punctuation
+.sp
+  S     Symbol
+  Sc    Currency symbol
+  Sk    Modifier symbol
+  Sm    Mathematical symbol
+  So    Other symbol
+.sp
+  Z     Separator
+  Zl    Line separator
+  Zp    Paragraph separator
+  Zs    Space separator
+.sp
+The special property L& is also supported: it matches a character that has
+the Lu, Ll, or Lt property, in other words, a letter that is not classified as
+a modifier or "other".
+.P
+The Cs (Surrogate) property applies only to characters in the range U+D800 to
+U+DFFF. Such characters are not valid in Unicode strings and so
+cannot be tested by PCRE2, unless UTF validity checking has been turned off
+(see the discussion of PCRE2_NO_UTF_CHECK in the
+.\" HREF
+\fBpcre2api\fP
+.\"
+page). Perl does not support the Cs property.
+.P
+The long synonyms for property names that Perl supports (such as \ep{Letter})
+are not supported by PCRE2, nor is it permitted to prefix any of these
+properties with "Is".
+.P
+No character that is in the Unicode table has the Cn (unassigned) property.
+Instead, this property is assumed for any code point that is not in the
+Unicode table.
+.P
+Specifying caseless matching does not affect these escape sequences. For
+example, \ep{Lu} always matches only upper case letters. This is different from
+the behaviour of current versions of Perl.
+.P
+Matching characters by Unicode property is not fast, because PCRE2 has to do a
+multistage table lookup in order to find a character's property. That is why
+the traditional escape sequences such as \ed and \ew do not use Unicode
+properties in PCRE2 by default, though you can make them do so by setting the
+PCRE2_UCP option or by starting the pattern with (*UCP).
+.
+.
+.SS Extended grapheme clusters
+.rs
+.sp
+The \eX escape matches any number of Unicode characters that form an "extended
+grapheme cluster", and treats the sequence as an atomic group
+.\" HTML 
+.\" 
+(see below).
+.\"
+Unicode supports various kinds of composite character by giving each character
+a grapheme breaking property, and having rules that use these properties to
+define the boundaries of extended grapheme clusters. \eX always matches at
+least one character. Then it decides whether to add additional characters
+according to the following rules for ending a cluster:
+.P
+1. End at the end of the subject string.
+.P
+2. Do not end between CR and LF; otherwise end after any control character.
+.P
+3. Do not break Hangul (a Korean script) syllable sequences. Hangul characters
+are of five types: L, V, T, LV, and LVT. An L character may be followed by an
+L, V, LV, or LVT character; an LV or V character may be followed by a V or T
+character; an LVT or T character may be follwed only by a T character.
+.P
+4. Do not end before extending characters or spacing marks. Characters with
+the "mark" property always have the "extend" grapheme breaking property.
+.P
+5. Do not end after prepend characters.
+.P
+6. Otherwise, end the cluster.
+.
+.
+.\" HTML 
+.SS PCRE2's additional properties
+.rs
+.sp
+As well as the standard Unicode properties described above, PCRE2 supports four
+more that make it possible to convert traditional escape sequences such as \ew
+and \es to use Unicode properties. PCRE2 uses these non-standard, non-Perl
+properties internally when PCRE2_UCP is set. However, they may also be used
+explicitly. These properties are:
+.sp
+  Xan   Any alphanumeric character
+  Xps   Any POSIX space character
+  Xsp   Any Perl space character
+  Xwd   Any Perl "word" character
+.sp
+Xan matches characters that have either the L (letter) or the N (number)
+property. Xps matches the characters tab, linefeed, vertical tab, form feed, or
+carriage return, and any other character that has the Z (separator) property.
+Xsp is the same as Xps; in PCRE1 it used to exclude vertical tab, for Perl
+compatibility, but Perl changed. Xwd matches the same characters as Xan, plus
+underscore.
+.P
+There is another non-standard property, Xuc, which matches any character that
+can be represented by a Universal Character Name in C++ and other programming
+languages. These are the characters $, @, ` (grave accent), and all characters
+with Unicode code points greater than or equal to U+00A0, except for the
+surrogates U+D800 to U+DFFF. Note that most base (ASCII) characters are
+excluded. (Universal Character Names are of the form \euHHHH or \eUHHHHHHHH
+where H is a hexadecimal digit. Note that the Xuc property does not match these
+sequences but the characters that they represent.)
+.
+.
+.\" HTML 
+.SS "Resetting the match start"
+.rs
+.sp
+The escape sequence \eK causes any previously matched characters not to be
+included in the final matched sequence. For example, the pattern:
+.sp
+  foo\eKbar
+.sp
+matches "foobar", but reports that it has matched "bar". This feature is
+similar to a lookbehind assertion
+.\" HTML 
+.\" 
+(described below).
+.\"
+However, in this case, the part of the subject before the real match does not
+have to be of fixed length, as lookbehind assertions do. The use of \eK does
+not interfere with the setting of
+.\" HTML 
+.\" 
+captured substrings.
+.\"
+For example, when the pattern
+.sp
+  (foo)\eKbar
+.sp
+matches "foobar", the first substring is still set to "foo".
+.P
+Perl documents that the use of \eK within assertions is "not well defined". In
+PCRE2, \eK is acted upon when it occurs inside positive assertions, but is
+ignored in negative assertions. Note that when a pattern such as (?=ab\eK)
+matches, the reported start of the match can be greater than the end of the
+match.
+.
+.
+.\" HTML 
+.SS "Simple assertions"
+.rs
+.sp
+The final use of backslash is for certain simple assertions. 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
+.\" HTML 
+.\" 
+below.
+.\"
+The backslashed assertions are:
+.sp
+  \eb     matches at a word boundary
+  \eB     matches when not at a word boundary
+  \eA     matches at the start of the subject
+  \eZ     matches at the end of the subject
+          also matches before a newline at the end of the subject
+  \ez     matches only at the end of the subject
+  \eG     matches at the first matching position in the subject
+.sp
+Inside a character class, \eb has a different meaning; it matches the backspace
+character. If any other of these assertions appears in a character class, an
+"invalid escape sequence" error is generated.
+.P
+A word boundary is a position in the subject string where the current character
+and the previous character do not both match \ew or \eW (i.e. one matches
+\ew and the other matches \eW), or the start or end of the string if the
+first or last character matches \ew, respectively. In a UTF mode, the meanings
+of \ew and \eW can be changed by setting the PCRE2_UCP option. When this is
+done, it also affects \eb and \eB. Neither PCRE2 nor Perl has a separate "start
+of word" or "end of word" metasequence. However, whatever follows \eb normally
+determines which it is. For example, the fragment \eba matches "a" at the start
+of a word.
+.P
+The \eA, \eZ, and \ez assertions differ from the traditional circumflex and
+dollar (described in the next section) in that they only ever match at the very
+start and end of the subject string, whatever options are set. Thus, they are
+independent of multiline mode. These three assertions are not affected by the
+PCRE2_NOTBOL or PCRE2_NOTEOL options, which affect only the behaviour of the
+circumflex and dollar metacharacters. However, if the \fIstartoffset\fP
+argument of \fBpcre2_match()\fP is non-zero, indicating that matching is to
+start at a point other than the beginning of the subject, \eA can never match.
+The difference between \eZ and \ez is that \eZ matches before a newline at the
+end of the string as well as at the very end, whereas \ez matches only at the
+end.
+.P
+The \eG assertion is true only when the current matching position is at the
+start point of the match, as specified by the \fIstartoffset\fP argument of
+\fBpcre2_match()\fP. It differs from \eA when the value of \fIstartoffset\fP is
+non-zero. By calling \fBpcre2_match()\fP multiple times with appropriate
+arguments, you can mimic Perl's /g option, and it is in this kind of
+implementation where \eG can be useful.
+.P
+Note, however, that PCRE2's interpretation of \eG, as the start of the current
+match, is subtly different from Perl's, which defines it as the end of the
+previous match. In Perl, these can be different when the previously matched
+string was empty. Because PCRE2 does just one match at a time, it cannot
+reproduce this behaviour.
+.P
+If all the alternatives of a pattern begin with \eG, the expression is anchored
+to the starting match position, and the "anchored" flag is set in the compiled
+regular expression.
+.
+.
+.SH "CIRCUMFLEX AND DOLLAR"
+.rs
+.sp
+The circumflex and dollar metacharacters are zero-width assertions. That is,
+they test for a particular condition being true without consuming any
+characters from the subject string.
+.P
+Outside a character class, in the default matching mode, the circumflex
+character is an assertion that is true only if the current matching point is at
+the start of the subject string. If the \fIstartoffset\fP argument of
+\fBpcre2_match()\fP is non-zero, circumflex can never match if the
+PCRE2_MULTILINE option is unset. Inside a character class, circumflex has an
+entirely different meaning
+.\" HTML 
+.\" 
+(see below).
+.\"
+.P
+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
+"anchored" pattern. (There are also other constructs that can cause a pattern
+to be anchored.)
+.P
+The dollar character is an assertion that is true only if the current matching
+point is at the end of the subject string, or immediately before a newline at
+the end of the string (by default). Note, however, that it does not actually
+match the newline. Dollar 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. Dollar has no special meaning in a character class.
+.P
+The meaning of dollar can be changed so that it matches only at the very end of
+the string, by setting the PCRE2_DOLLAR_ENDONLY option at compile time. This
+does not affect the \eZ assertion.
+.P
+The meanings of the circumflex and dollar characters are changed if the
+PCRE2_MULTILINE option is set. When this is the case, a circumflex matches
+immediately after internal newlines as well as at the start of the subject
+string. It does not match after a newline that ends the string. A dollar
+matches before any newlines in the string, as well as at the very end, when
+PCRE2_MULTILINE is set. When newline is specified as the two-character
+sequence CRLF, isolated CR and LF characters do not indicate newlines.
+.P
+For example, the pattern /^abc$/ matches the subject string "def\enabc" (where
+\en represents a newline) in multiline mode, but not otherwise. Consequently,
+patterns that are anchored in single line mode because all branches start with
+^ are not anchored in multiline mode, and a match for circumflex is possible
+when the \fIstartoffset\fP argument of \fBpcre2_match()\fP is non-zero. The
+PCRE2_DOLLAR_ENDONLY option is ignored if PCRE2_MULTILINE is set.
+.P
+Note that the sequences \eA, \eZ, and \ez can be used to match the start and
+end of the subject in both modes, and if all branches of a pattern start with
+\eA it is always anchored, whether or not PCRE2_MULTILINE is set.
+.
+.
+.\" HTML 
+.SH "FULL STOP (PERIOD, DOT) AND \eN"
+.rs
+.sp
+Outside a character class, a dot in the pattern matches any one character in
+the subject string except (by default) a character that signifies the end of a
+line.
+.P
+When a line ending is defined as a single character, dot never matches that
+character; when the two-character sequence CRLF is used, dot does not match CR
+if it is immediately followed by LF, but otherwise it matches all characters
+(including isolated CRs and LFs). When any Unicode line endings are being
+recognized, dot does not match CR or LF or any of the other line ending
+characters.
+.P
+The behaviour of dot with regard to newlines can be changed. If the
+PCRE2_DOTALL option is set, a dot matches any one character, without exception.
+If the two-character sequence CRLF is present in the subject string, it takes
+two dots to match it.
+.P
+The handling of dot is entirely independent of the handling of circumflex and
+dollar, the only relationship being that they both involve newlines. Dot has no
+special meaning in a character class.
+.P
+The escape sequence \eN behaves like a dot, except that it is not affected by
+the PCRE2_DOTALL option. In other words, it matches any character except one
+that signifies the end of a line. Perl also uses \eN to match characters by
+name; PCRE2 does not support this.
+.
+.
+.SH "MATCHING A SINGLE CODE UNIT"
+.rs
+.sp
+Outside a character class, the escape sequence \eC matches any one code unit,
+whether or not a UTF mode is set. In the 8-bit library, one code unit is one
+byte; in the 16-bit library it is a 16-bit unit; in the 32-bit library it is a
+32-bit unit. Unlike a dot, \eC always matches line-ending characters. The
+feature is provided in Perl in order to match individual bytes in UTF-8 mode,
+but it is unclear how it can usefully be used. Because \eC breaks up characters
+into individual code units, matching one unit with \eC in a UTF mode means that
+the rest of the string may start with a malformed UTF character. This has
+undefined results, because PCRE2 assumes that it is dealing with valid UTF
+strings (and by default it checks this at the start of processing unless the
+PCRE2_NO_UTF_CHECK option is used).
+.P
+PCRE2 does not allow \eC to appear in lookbehind assertions
+.\" HTML 
+.\" 
+(described below)
+.\"
+in a UTF mode, because this would make it impossible to calculate the length of
+the lookbehind.
+.P
+In general, the \eC escape sequence is best avoided. However, one way of using
+it that avoids the problem of malformed UTF characters is to use a lookahead to
+check the length of the next character, as in this pattern, which could be used
+with a UTF-8 string (ignore white space and line breaks):
+.sp
+  (?| (?=[\ex00-\ex7f])(\eC) |
+      (?=[\ex80-\ex{7ff}])(\eC)(\eC) |
+      (?=[\ex{800}-\ex{ffff}])(\eC)(\eC)(\eC) |
+      (?=[\ex{10000}-\ex{1fffff}])(\eC)(\eC)(\eC)(\eC))
+.sp
+In this example, a group that starts with (?| resets the capturing parentheses
+numbers in each alternative (see
+.\" HTML 
+.\" 
+"Duplicate Subpattern Numbers"
+.\"
+below). The assertions at the start of each branch check the next UTF-8
+character for values whose encoding uses 1, 2, 3, or 4 bytes, respectively. The
+character's individual bytes are then captured by the appropriate number of
+\eC groups.
+.
+.
+.\" HTML 
+.SH "SQUARE BRACKETS AND CHARACTER CLASSES"
+.rs
+.sp
+An opening square bracket introduces a character class, terminated by a closing
+square bracket. A closing square bracket on its own is not special by default.
+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. This means that, by default, an empty class cannot 
+be defined. However, if the PCRE2_ALLOW_EMPTY_CLASS option is set, a closing 
+square bracket at the start does end the (empty) class.
+.P
+A character class matches a single character in the subject. A matched
+character must be in the set of characters defined by the class, unless the
+first character in the class definition 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.
+.P
+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 notation for specifying the characters that
+are in the class by enumerating those that are not. A class that starts with a
+circumflex is not an assertion; it still consumes a character from the subject
+string, and therefore it fails if the current pointer is at the end of the
+string.
+.P
+When caseless matching is set, any letters in a class represent both their
+upper case and lower case versions, so for example, a caseless [aeiou] matches
+"A" as well as "a", and a caseless [^aeiou] does not match "A", whereas a
+caseful version would. 
+.P
+Characters that might indicate line breaks are never treated in any special way
+when matching character classes, whatever line-ending sequence is in use, and
+whatever setting of the PCRE2_DOTALL and PCRE2_MULTILINE options is used. A
+class such as [^a] always matches one of these characters.
+.P
+The minus (hyphen) character can be used to specify a range of characters in a
+character class. For example, [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, or
+immediately after a range. For example, [b-d-z] matches letters in the range b
+to d, a hyphen character, or z.
+.P
+It is not possible to have the literal character "]" as the end character of a
+range. A pattern such as [W-]46] is interpreted as a class of two characters
+("W" and "-") followed by a literal string "46]", so it would match "W46]" or
+"-46]". However, if the "]" is escaped with a backslash it is interpreted as
+the end of range, so [W-\e]46] is interpreted as a class containing a range
+followed by two other characters. The octal or hexadecimal representation of
+"]" can also be used to end a range.
+.P
+An error is generated if a POSIX character class (see below) or an escape
+sequence other than one that defines a single character appears at a point
+where a range ending character is expected. For example, [z-\exff] is valid,
+but [A-\ed] and [A-[:digit:]] are not.
+.P
+Ranges operate in the collating sequence of character values. They can also be
+used for characters specified numerically, for example [\e000-\e037]. Ranges
+can include any characters that are valid for the current mode.
+.P
+If a range that includes letters is used when caseless matching is set, it
+matches the letters in either case. For example, [W-c] is equivalent to
+[][\e\e^_`wxyzabc], matched caselessly, and in a non-UTF mode, if character
+tables for a French locale are in use, [\exc8-\excb] matches accented E
+characters in both cases.
+.P
+The character escape sequences \ed, \eD, \eh, \eH, \ep, \eP, \es, \eS, \ev,
+\eV, \ew, and \eW may appear in a character class, and add the characters that
+they match to the class. For example, [\edABCDEF] matches any hexadecimal
+digit. In UTF modes, the PCRE2_UCP option affects the meanings of \ed, \es, \ew
+and their upper case partners, just as it does when they appear outside a
+character class, as described in the section entitled
+.\" HTML 
+.\" 
+"Generic character types"
+.\"
+above. The escape sequence \eb has a different meaning inside a character
+class; it matches the backspace character. The sequences \eB, \eN, \eR, and \eX
+are not special inside a character class. Like any other unrecognized escape
+sequences, they cause an error.
+.P
+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 [^\eW_] matches any letter or digit, but not underscore,
+whereas [\ew] includes underscore. A positive character class should be read as
+"something OR something OR ..." and a negative class as "NOT something AND NOT
+something AND NOT ...".
+.P
+The only metacharacters that are recognized in character classes are backslash,
+hyphen (only where it can be interpreted as specifying a range), circumflex
+(only at the start), opening square bracket (only when it can be interpreted as
+introducing a POSIX class name, or for a special compatibility feature - see
+the next two sections), and the terminating closing square bracket. However,
+escaping other non-alphanumeric characters does no harm.
+.
+.
+.SH "POSIX CHARACTER CLASSES"
+.rs
+.sp
+Perl supports the POSIX notation for character classes. This uses names
+enclosed by [: and :] within the enclosing square brackets. PCRE2 also supports
+this notation. For example,
+.sp
+  [01[:alpha:]%]
+.sp
+matches "0", "1", any alphabetic character, or "%". The supported class names
+are:
+.sp
+  alnum    letters and digits
+  alpha    letters
+  ascii    character codes 0 - 127
+  blank    space or tab only
+  cntrl    control characters
+  digit    decimal digits (same as \ed)
+  graph    printing characters, excluding space
+  lower    lower case letters
+  print    printing characters, including space
+  punct    printing characters, excluding letters and digits and space
+  space    white space (the same as \es from PCRE2 8.34)
+  upper    upper case letters
+  word     "word" characters (same as \ew)
+  xdigit   hexadecimal digits
+.sp
+The default "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13),
+and space (32). If locale-specific matching is taking place, the list of space
+characters may be different; there may be fewer or more of them. "Space" and
+\es match the same set of characters.
+.P
+The name "word" is a Perl extension, and "blank" is a GNU extension from Perl
+5.8. Another Perl extension is negation, which is indicated by a ^ character
+after the colon. For example,
+.sp
+  [12[:^digit:]]
+.sp
+matches "1", "2", or any non-digit. PCRE2 (and Perl) also recognize the POSIX
+syntax [.ch.] and [=ch=] where "ch" is a "collating element", but these are not
+supported, and an error is given if they are encountered.
+.P
+By default, characters with values greater than 128 do not match any of the
+POSIX character classes. However, if the PCRE2_UCP option is passed to
+\fBpcre2_compile()\fP, some of the classes are changed so that Unicode
+character properties are used. This is achieved by replacing certain POSIX
+classes by other sequences, as follows:
+.sp
+  [:alnum:]  becomes  \ep{Xan}
+  [:alpha:]  becomes  \ep{L}
+  [:blank:]  becomes  \eh
+  [:cntrl:]  becomes  \ep{Cc} 
+  [:digit:]  becomes  \ep{Nd}
+  [:lower:]  becomes  \ep{Ll}
+  [:space:]  becomes  \ep{Xps}
+  [:upper:]  becomes  \ep{Lu}
+  [:word:]   becomes  \ep{Xwd}
+.sp
+Negated versions, such as [:^alpha:] use \eP instead of \ep. Three other POSIX
+classes are handled specially in UCP mode:
+.TP 10
+[:graph:]
+This matches characters that have glyphs that mark the page when printed. In
+Unicode property terms, it matches all characters with the L, M, N, P, S, or Cf
+properties, except for:
+.sp
+  U+061C           Arabic Letter Mark
+  U+180E           Mongolian Vowel Separator
+  U+2066 - U+2069  Various "isolate"s
+.sp
+.TP 10
+[:print:]
+This matches the same characters as [:graph:] plus space characters that are
+not controls, that is, characters with the Zs property.
+.TP 10
+[:punct:]
+This matches all characters that have the Unicode P (punctuation) property,
+plus those characters with code points less than 128 that have the S (Symbol)
+property.
+.P
+The other POSIX classes are unchanged, and match only characters with code
+points less than 128.
+.
+.
+.SH "COMPATIBILITY FEATURE FOR WORD BOUNDARIES"
+.rs
+.sp
+In the POSIX.2 compliant library that was included in 4.4BSD Unix, the ugly
+syntax [[:<:]] and [[:>:]] is used for matching "start of word" and "end of
+word". PCRE2 treats these items as follows:
+.sp
+  [[:<:]]  is converted to  \eb(?=\ew)
+  [[:>:]]  is converted to  \eb(?<=\ew)
+.sp
+Only these exact character sequences are recognized. A sequence such as
+[a[:<:]b] provokes error for an unrecognized POSIX class name. This support is
+not compatible with Perl. It is provided to help migrations from other
+environments, and is best not used in any new patterns. Note that \eb matches
+at the start and the end of a word (see
+.\" HTML 
+.\" 
+"Simple assertions"
+.\"
+above), and in a Perl-style pattern the preceding or following character
+normally shows which is wanted, without the need for the assertions that are
+used above in order to give exactly the POSIX behaviour.
+.
+.
+.SH "VERTICAL BAR"
+.rs
+.sp
+Vertical bar characters are used to separate alternative patterns. For example,
+the pattern
+.sp
+  gilbert|sullivan
+.sp
+matches either "gilbert" or "sullivan". Any number of alternatives may appear,
+and an empty alternative is permitted (matching the empty string). The matching
+process tries each alternative in turn, from left to right, and the first one
+that succeeds is used. If the alternatives are within a subpattern
+.\" HTML 
+.\" 
+(defined below),
+.\"
+"succeeds" means matching the rest of the main pattern as well as the
+alternative in the subpattern.
+.
+.
+.SH "INTERNAL OPTION SETTING"
+.rs
+.sp
+The settings of the PCRE2_CASELESS, PCRE2_MULTILINE, PCRE2_DOTALL, and
+PCRE2_EXTENDED options (which are Perl-compatible) can be changed from within
+the pattern by a sequence of Perl option letters enclosed between "(?" and ")".
+The option letters are
+.sp
+  i  for PCRE2_CASELESS
+  m  for PCRE2_MULTILINE
+  s  for PCRE2_DOTALL
+  x  for PCRE2_EXTENDED
+.sp
+For example, (?im) sets caseless, multiline matching. It is also possible to
+unset these options by preceding the letter with a hyphen, and a combined
+setting and unsetting such as (?im-sx), which sets PCRE2_CASELESS and
+PCRE2_MULTILINE while unsetting PCRE2_DOTALL and PCRE2_EXTENDED, is also
+permitted. If a letter appears both before and after the hyphen, the option is
+unset.
+.P
+The PCRE2-specific options PCRE2_DUPNAMES and PCRE2_UNGREEDY can be changed in
+the same way as the Perl-compatible options by using the characters J and U
+respectively.
+.P
+When one of these option changes occurs at top level (that is, not inside
+subpattern parentheses), the change applies to the remainder of the pattern
+that follows. If the change is placed right at the start of a pattern, PCRE2
+extracts it into the global options (and it will therefore show up in data
+extracted by the \fBpcre2_pattern_info()\fP function).
+.P
+An option change within a subpattern (see below for a description of
+subpatterns) affects only that part of the subpattern that follows it, so
+.sp
+  (a(?i)b)c
+.sp
+matches abc and aBc and no other strings (assuming PCRE2_CASELESS is not 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 example,
+.sp
+  (a(?i)b|c)
+.sp
+matches "ab", "aB", "c", and "C", even though when matching "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.
+.P
+\fBNote:\fP There are other PCRE2-specific options that can be set by the
+application when the compiling function is called.
+The pattern can contain special leading sequences such as (*CRLF) to override
+what the application has set or what has been defaulted. Details are given in
+the section entitled
+.\" HTML 
+.\" 
+"Newline sequences"
+.\"
+above. There are also the (*UTF) and (*UCP) leading sequences that can be used
+to set UTF and Unicode property modes; they are equivalent to setting the
+PCRE2_UTF and PCRE2_UCP options, respectively. However, the application can set
+the PCRE2_NEVER_UTF and PCRE2_NEVER_UCP options, which lock out the use of the
+(*UTF) and (*UCP) sequences.
+.
+.
+.\" HTML 
+.SH SUBPATTERNS
+.rs
+.sp
+Subpatterns are delimited by parentheses (round brackets), which can be nested.
+Turning part of a pattern into a subpattern does two things:
+.sp
+1. It localizes a set of alternatives. For example, the pattern
+.sp
+  cat(aract|erpillar|)
+.sp
+matches "cataract", "caterpillar", or "cat". Without the parentheses, it would
+match "cataract", "erpillar" or an empty string.
+.sp
+2. It sets up the subpattern as a capturing subpattern. This means that, when
+the whole pattern matches, the portion of the subject string that matched the
+subpattern is passed back to the caller, separately from the portion that 
+matched the whole pattern. (This applies only to the traditional matching
+function; the DFA matching function does not support capturing.)
+.P
+Opening parentheses are counted from left to right (starting from 1) to obtain
+numbers for the capturing subpatterns. For example, if the string "the red
+king" is matched against the pattern
+.sp
+  the ((red|white) (king|queen))
+.sp
+the captured substrings are "red king", "red", and "king", and are numbered 1,
+2, and 3, respectively.
+.P
+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 a question mark
+and a colon, 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 "the white queen" is matched against the pattern
+.sp
+  the ((?:red|white) (king|queen))
+.sp
+the captured substrings are "white queen" and "queen", and are numbered 1 and
+2. The maximum number of capturing subpatterns is 65535.
+.P
+As a convenient shorthand, if any option settings are required at the start of
+a non-capturing subpattern, the option letters may appear between the "?" and
+the ":". Thus the two patterns
+.sp
+  (?i:saturday|sunday)
+  (?:(?i)saturday|sunday)
+.sp
+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 "SUNDAY" as well as "Saturday".
+.
+.
+.\" HTML 
+.SH "DUPLICATE SUBPATTERN NUMBERS"
+.rs
+.sp
+Perl 5.10 introduced a feature whereby each alternative in a subpattern uses
+the same numbers for its capturing parentheses. Such a subpattern starts with
+(?| and is itself a non-capturing subpattern. For example, consider this
+pattern:
+.sp
+  (?|(Sat)ur|(Sun))day
+.sp
+Because the two alternatives are inside a (?| group, both sets of capturing
+parentheses are numbered one. Thus, when the pattern matches, you can look
+at captured substring number one, whichever alternative matched. This construct
+is useful when you want to capture part, but not all, of one of a number of
+alternatives. Inside a (?| group, parentheses are numbered as usual, but the
+number is reset at the start of each branch. The numbers of any capturing
+parentheses that follow the subpattern start after the highest number used in
+any branch. The following example is taken from the Perl documentation. The
+numbers underneath show in which buffer the captured content will be stored.
+.sp
+  # before  ---------------branch-reset----------- after
+  / ( a )  (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
+  # 1            2         2  3        2     3     4
+.sp
+A back reference to a numbered subpattern uses the most recent value that is
+set for that number by any subpattern. The following pattern matches "abcabc"
+or "defdef":
+.sp
+  /(?|(abc)|(def))\e1/
+.sp
+In contrast, a subroutine call to a numbered subpattern always refers to the
+first one in the pattern with the given number. The following pattern matches
+"abcabc" or "defabc":
+.sp
+  /(?|(abc)|(def))(?1)/
+.sp
+If a
+.\" HTML 
+.\" 
+condition test
+.\"
+for a subpattern's having matched refers to a non-unique number, the test is
+true if any of the subpatterns of that number have matched.
+.P
+An alternative approach to using this "branch reset" feature is to use
+duplicate named subpatterns, as described in the next section.
+.
+.
+.SH "NAMED SUBPATTERNS"
+.rs
+.sp
+Identifying capturing parentheses by number is simple, but it can be very hard
+to keep track of the numbers in complicated regular expressions. Furthermore,
+if an expression is modified, the numbers may change. To help with this
+difficulty, PCRE2 supports the naming of subpatterns. This feature was not
+added to Perl until release 5.10. Python had the feature earlier, and PCRE1
+introduced it at release 4.0, using the Python syntax. PCRE2 supports both the
+Perl and the Python syntax. Perl allows identically numbered subpatterns to
+have different names, but PCRE2 does not.
+.P
+In PCRE2, a subpattern can be named in one of three ways: (?...) or
+(?'name'...) as in Perl, or (?P...) as in Python. References to capturing
+parentheses from other parts of the pattern, such as
+.\" HTML 
+.\" 
+back references,
+.\"
+.\" HTML 
+.\" 
+recursion,
+.\"
+and
+.\" HTML 
+.\" 
+conditions,
+.\"
+can be made by name as well as by number.
+.P
+Names consist of up to 32 alphanumeric characters and underscores, but must
+start with a non-digit. Named capturing parentheses are still allocated numbers
+as well as names, exactly as if the names were not present. The PCRE2 API
+provides function calls for extracting the name-to-number translation table
+from a compiled pattern. There are also convenience functions for extracting a
+captured substring by name.
+.P
+By default, a name must be unique within a pattern, but it is possible to relax
+this constraint by setting the PCRE2_DUPNAMES option at compile time.
+(Duplicate names are also always permitted for subpatterns with the same
+number, set up as described in the previous section.) Duplicate names can be
+useful for patterns where only one instance of the named parentheses can match.
+Suppose you want to match the name of a weekday, either as a 3-letter
+abbreviation or as the full name, and in both cases you want to extract the
+abbreviation. This pattern (ignoring the line breaks) does the job:
+.sp
+  (?Mon|Fri|Sun)(?:day)?|
+  (?Tue)(?:sday)?|
+  (?Wed)(?:nesday)?|
+  (?Thu)(?:rsday)?|
+  (?Sat)(?:urday)?
+.sp
+There are five capturing substrings, but only one is ever set after a match.
+(An alternative way of solving this problem is to use a "branch reset"
+subpattern, as described in the previous section.)
+.P
+The convenience functions for extracting the data by name returns the substring
+for the first (and in this example, the only) subpattern of that name that
+matched. This saves searching to find which numbered subpattern it was.
+.P
+If you make a back reference to a non-unique named subpattern from elsewhere in
+the pattern, the subpatterns to which the name refers are checked in the order
+in which they appear in the overall pattern. The first one that is set is used
+for the reference. For example, this pattern matches both "foofoo" and
+"barbar" but not "foobar" or "barfoo":
+.sp
+  (?:(?foo)|(?bar))\ek
+.sp
+.P
+If you make a subroutine call to a non-unique named subpattern, the one that
+corresponds to the first occurrence of the name is used. In the absence of
+duplicate numbers (see the previous section) this is the one with the lowest
+number.
+.P
+If you use a named reference in a condition
+test (see the
+.\"
+.\" HTML 
+.\" 
+section about conditions
+.\"
+below), either to check whether a subpattern has matched, or to check for
+recursion, all subpatterns with the same name are tested. If the condition is
+true for any one of them, the overall condition is true. This is the same
+behaviour as testing by number. For further details of the interfaces for
+handling named subpatterns, see the
+.\" HREF
+\fBpcre2api\fP
+.\"
+documentation.
+.P
+\fBWarning:\fP You cannot use different names to distinguish between two
+subpatterns with the same number because PCRE2 uses only the numbers when
+matching. For this reason, an error is given at compile time if different names
+are given to subpatterns with the same number. However, you can always give the
+same name to subpatterns with the same number, even when PCRE2_DUPNAMES is not
+set.
+.
+.
+.SH REPETITION
+.rs
+.sp
+Repetition is specified by quantifiers, which can follow any of the following
+items:
+.sp
+  a literal data character
+  the dot metacharacter
+  the \eC escape sequence
+  the \eX escape sequence
+  the \eR escape sequence
+  an escape such as \ed or \epL that matches a single character
+  a character class
+  a back reference (see next section)
+  a parenthesized subpattern (including assertions)
+  a subroutine call to a subpattern (recursive or otherwise)
+.sp
+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:
+.sp
+  z{2,4}
+.sp
+matches "zz", "zzz", or "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
+.sp
+  [aeiou]{3,}
+.sp
+matches at least 3 successive vowels, but may match many more, whereas
+.sp
+  \ed{8}
+.sp
+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.
+.P
+In UTF modes, quantifiers apply to characters rather than to individual code
+units. Thus, for example, \ex{100}{2} matches two characters, each of
+which is represented by a two-byte sequence in a UTF-8 string. Similarly,
+\eX{3} matches three Unicode extended grapheme clusters, each of which may be
+several code units long (and they may be of different lengths).
+.P
+The quantifier {0} is permitted, causing the expression to behave as if the
+previous item and the quantifier were not present. This may be useful for
+subpatterns that are referenced as
+.\" HTML 
+.\" 
+subroutines
+.\"
+from elsewhere in the pattern (but see also the section entitled
+.\" HTML 
+.\" 
+"Defining subpatterns for use by reference only"
+.\"
+below). Items other than subpatterns that have a {0} quantifier are omitted
+from the compiled pattern.
+.P
+For convenience, the three most common quantifiers have single-character
+abbreviations:
+.sp
+  *    is equivalent to {0,}
+  +    is equivalent to {1,}
+  ?    is equivalent to {0,1}
+.sp
+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:
+.sp
+  (a?)*
+.sp
+Earlier versions of Perl and PCRE1 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.
+.P
+By default, the quantifiers are "greedy", 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 /* and */
+and within the comment, individual * and / characters may appear. An attempt to
+match C comments by applying the pattern
+.sp
+  /\e*.*\e*/
+.sp
+to the string
+.sp
+  /* first comment */  not comment  /* second comment */
+.sp
+fails, because it matches the entire string owing to the greediness of the .*
+item.
+.P
+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
+.sp
+  /\e*.*?\e*/
+.sp
+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
+.sp
+  \ed??\ed
+.sp
+which matches one digit by preference, but can match two if that is the only
+way the rest of the pattern matches.
+.P
+If the PCRE2_UNGREEDY option is set (an option that 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.
+.P
+When a parenthesized subpattern is quantified with a minimum repeat count that
+is greater than 1 or with a limited maximum, more memory is required for the
+compiled pattern, in proportion to the size of the minimum or maximum.
+.P
+If a pattern starts with .* or .{0,} and the PCRE2_DOTALL option (equivalent
+to Perl's /s) is set, thus allowing the dot to match newlines, 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. PCRE2 normally treats such a
+pattern as though it were preceded by \eA.
+.P
+In cases where it is known that the subject string contains no newlines, it is
+worth setting PCRE2_DOTALL in order to obtain this optimization, or
+alternatively, using ^ to indicate anchoring explicitly.
+.P
+However, there are some cases where the optimization cannot be used. When .*
+is inside capturing parentheses that are the subject of a back reference
+elsewhere in the pattern, a match at the start may fail where a later one
+succeeds. Consider, for example:
+.sp
+  (.*)abc\e1
+.sp
+If the subject is "xyz123abc123" the match point is the fourth character. For
+this reason, such a pattern is not implicitly anchored.
+.P
+Another case where implicit anchoring is not applied is when the leading .* is
+inside an atomic group. Once again, a match at the start may fail where a later
+one succeeds. Consider this pattern:
+.sp
+  (?>.*?a)b
+.sp
+It matches "ab" in the subject "aab". The use of the backtracking control verbs
+(*PRUNE) and (*SKIP) also disable this optimization.
+.P
+When a capturing subpattern is repeated, the value captured is the substring
+that matched the final iteration. For example, after
+.sp
+  (tweedle[dume]{3}\es*)+
+.sp
+has matched "tweedledum tweedledee" the value of the captured substring is
+"tweedledee". However, if there are nested capturing subpatterns, the
+corresponding captured values may have been set in previous iterations. For
+example, after
+.sp
+  (a|(b))+
+.sp
+matches "aba" the value of the second captured substring is "b".
+.
+.
+.\" HTML 
+.SH "ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS"
+.rs
+.sp
+With both maximizing ("greedy") and minimizing ("ungreedy" or "lazy")
+repetition, failure of what follows normally causes the repeated item to be
+re-evaluated 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 on.
+.P
+Consider, for example, the pattern \ed+foo when applied to the subject line
+.sp
+  123456bar
+.sp
+After matching all 6 digits and then failing to match "foo", the normal
+action of the matcher is to try again with only 5 digits matching the \ed+
+item, and then with 4, and so on, before ultimately failing. "Atomic grouping"
+(a term taken from Jeffrey Friedl's book) provides the means for specifying
+that once a subpattern has matched, it is not to be re-evaluated in this way.
+.P
+If we use atomic grouping for the previous example, the matcher gives up
+immediately on failing to match "foo" the first time. The notation is a kind of
+special parenthesis, starting with (?> as in this example:
+.sp
+  (?>\ed+)foo
+.sp
+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
+normal.
+.P
+An alternative description is that a subpattern of this type matches exactly
+the string of characters that an identical standalone pattern would match, if
+anchored at the current point in the subject string.
+.P
+Atomic grouping 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 \ed+ and \ed+? are prepared to adjust the
+number of digits they match in order to make the rest of the pattern match,
+(?>\ed+) can only match an entire sequence of digits.
+.P
+Atomic groups in general can of course contain arbitrarily complicated
+subpatterns, and can be nested. However, when the subpattern for an atomic
+group is just a single repeated item, as in the example above, a simpler
+notation, called a "possessive quantifier" can be used. This consists of an
+additional + character following a quantifier. Using this notation, the
+previous example can be rewritten as
+.sp
+  \ed++foo
+.sp
+Note that a possessive quantifier can be used with an entire group, for
+example:
+.sp
+  (abc|xyz){2,3}+
+.sp
+Possessive quantifiers are always greedy; the setting of the PCRE2_UNGREEDY
+option is ignored. They are a convenient notation for the simpler forms of
+atomic group. However, there is no difference in the meaning of a possessive
+quantifier and the equivalent atomic group, though there may be a performance
+difference; possessive quantifiers should be slightly faster.
+.P
+The possessive quantifier syntax is an extension to the Perl 5.8 syntax.
+Jeffrey Friedl originated the idea (and the name) in the first edition of his
+book. Mike McCloskey liked it, so implemented it when he built Sun's Java
+package, and PCRE1 copied it from there. It ultimately found its way into Perl
+at release 5.10.
+.P
+PCRE2 has an optimization that automatically "possessifies" certain simple
+pattern constructs. For example, the sequence A+B is treated as A++B because
+there is no point in backtracking into a sequence of A's when B must follow.
+This feature can be disabled by the PCRE2_NO_AUTOPOSSESS option, or starting 
+the pattern with (*NO_AUTO_POSSESS).
+.P
+When a pattern contains an unlimited repeat inside a subpattern that can itself
+be repeated an unlimited number of times, the use of an atomic group is the
+only way to avoid some failing matches taking a very long time indeed. The
+pattern
+.sp
+  (\eD+|<\ed+>)*[!?]
+.sp
+matches an unlimited number of substrings that either consist of non-digits, or
+digits enclosed in <>, followed by either ! or ?. When it matches, it runs
+quickly. However, if it is applied to
+.sp
+  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+.sp
+it takes a long time before reporting failure. This is because the string can
+be divided between the internal \eD+ repeat and the external * repeat in a
+large number of ways, and all have to be tried. (The example uses [!?] rather
+than a single character at the end, because both PCRE2 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 so that it uses
+an atomic group, like this:
+.sp
+  ((?>\eD+)|<\ed+>)*[!?]
+.sp
+sequences of non-digits cannot be broken, and failure happens quickly.
+.
+.
+.\" HTML 
+.SH "BACK REFERENCES"
+.rs
+.sp
+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
+(that is, to its left) in the pattern, provided there have been that many
+previous capturing left parentheses.
+.P
+However, if the decimal number following the backslash is less than 8, 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 8. A "forward back reference" of this type can make sense
+when a repetition is involved and the subpattern to the right has participated
+in an earlier iteration.
+.P
+It is not possible to have a numerical "forward back reference" to a subpattern
+whose number is 8 or more using this syntax because a sequence such as \e50 is
+interpreted as a character defined in octal. See the subsection entitled
+"Non-printing characters"
+.\" HTML 
+.\" 
+above
+.\"
+for further details of the handling of digits following a backslash. There is
+no such problem when named parentheses are used. A back reference to any
+subpattern is possible using named parentheses (see below).
+.P
+Another way of avoiding the ambiguity inherent in the use of digits following a
+backslash is to use the \eg escape sequence. This escape must be followed by an
+unsigned number or a negative number, optionally enclosed in braces. These
+examples are all identical:
+.sp
+  (ring), \e1
+  (ring), \eg1
+  (ring), \eg{1}
+.sp
+An unsigned number specifies an absolute reference without the ambiguity that
+is present in the older syntax. It is also useful when literal digits follow
+the reference. A negative number is a relative reference. Consider this
+example:
+.sp
+  (abc(def)ghi)\eg{-1}
+.sp
+The sequence \eg{-1} is a reference to the most recently started capturing
+subpattern before \eg, that is, is it equivalent to \e2 in this example.
+Similarly, \eg{-2} would be equivalent to \e1. The use of relative references
+can be helpful in long patterns, and also in patterns that are created by
+joining together fragments that contain references within themselves.
+.P
+A back reference matches whatever actually matched the capturing subpattern in
+the current subject string, rather than anything matching the subpattern
+itself (see
+.\" HTML 
+.\" 
+"Subpatterns as subroutines"
+.\"
+below for a way of doing that). So the pattern
+.sp
+  (sens|respons)e and \e1ibility
+.sp
+matches "sense and sensibility" and "response and responsibility", but not
+"sense and responsibility". If caseful matching is in force at the time of the
+back reference, the case of letters is relevant. For example,
+.sp
+  ((?i)rah)\es+\e1
+.sp
+matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original
+capturing subpattern is matched caselessly.
+.P
+There are several different ways of writing back references to named
+subpatterns. The .NET syntax \ek{name} and the Perl syntax \ek or
+\ek'name' are supported, as is the Python syntax (?P=name). Perl 5.10's unified
+back reference syntax, in which \eg can be used for both numeric and named
+references, is also supported. We could rewrite the above example in any of
+the following ways:
+.sp
+  (?(?i)rah)\es+\ek
+  (?'p1'(?i)rah)\es+\ek{p1}
+  (?P(?i)rah)\es+(?P=p1)
+  (?(?i)rah)\es+\eg{p1}
+.sp
+A subpattern that is referenced by name may appear in the pattern before or
+after the reference.
+.P
+There may be more than one back reference to the same subpattern. If a
+subpattern has not actually been used in a particular match, any back
+references to it always fail by default. For example, the pattern
+.sp
+  (a|(bc))\e2
+.sp
+always fails if it starts to match "a" rather than "bc". However, if the
+PCRE2_MATCH_UNSET_BACKREF option is set at compile time, a back reference to an
+unset value matches an empty string.
+.P
+Because there may be many capturing parentheses in a pattern, all digits
+following a backslash are taken as part of a potential back reference number.
+If the pattern continues with a digit character, some delimiter must be used to
+terminate the back reference. If the PCRE2_EXTENDED option is set, this can be
+white space. Otherwise, the \eg{ syntax or an empty comment (see
+.\" HTML 
+.\" 
+"Comments"
+.\"
+below) can be used.
+.
+.
+.SS "Recursive back references"
+.rs
+.sp
+A back reference that occurs inside the parentheses to which it refers fails
+when the subpattern is first used, so, for example, (a\e1) never matches.
+However, such references can be useful inside repeated subpatterns. For
+example, the pattern
+.sp
+  (a|b\e1)+
+.sp
+matches any number of "a"s and also "aba", "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.
+.P
+Back references of this type cause the group that they reference to be treated
+as an
+.\" HTML 
+.\" 
+atomic group.
+.\"
+Once the whole group has been matched, a subsequent matching failure cannot
+cause backtracking into the middle of the group.
+.
+.
+.\" HTML 
+.SH ASSERTIONS
+.rs
+.sp
+An assertion is a test on the characters following or preceding the current
+matching point that does not consume any characters. The simple assertions
+coded as \eb, \eB, \eA, \eG, \eZ, \ez, ^ and $ are described
+.\" HTML 
+.\" 
+above.
+.\"
+.P
+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. An assertion subpattern is matched in the normal way,
+except that it does not cause the current matching position to be changed.
+.P
+Assertion subpatterns are not capturing subpatterns. If such an 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. (Perl sometimes, but not
+always, does do capturing in negative assertions.)
+.P
+For compatibility with Perl, assertion subpatterns may be repeated; though
+it makes no sense to assert the same thing several times, the side effect of
+capturing parentheses may occasionally be useful. In practice, there only three
+cases:
+.sp
+(1) If the quantifier is {0}, the assertion is never obeyed during matching.
+However, it may contain internal capturing parenthesized groups that are called
+from elsewhere via the
+.\" HTML 
+.\" 
+subroutine mechanism.
+.\"
+.sp
+(2) If quantifier is {0,n} where n is greater than zero, it is treated as if it
+were {0,1}. At run time, the rest of the pattern match is tried with and
+without the assertion, the order depending on the greediness of the quantifier.
+.sp
+(3) If the minimum repetition is greater than zero, the quantifier is ignored.
+The assertion is obeyed just once when encountered during matching.
+.
+.
+.SS "Lookahead assertions"
+.rs
+.sp
+Lookahead assertions start with (?= for positive assertions and (?! for
+negative assertions. For example,
+.sp
+  \ew+(?=;)
+.sp
+matches a word followed by a semicolon, but does not include the semicolon in
+the match, and
+.sp
+  foo(?!bar)
+.sp
+matches any occurrence of "foo" that is not followed by "bar". Note that the
+apparently similar pattern
+.sp
+  (?!foo)bar
+.sp
+does not find an occurrence of "bar" that is preceded by something other than
+"foo"; it finds any occurrence of "bar" whatsoever, because the assertion
+(?!foo) is always true when the next three characters are "bar". A
+lookbehind assertion is needed to achieve the other effect.
+.P
+If you want to force a matching failure at some point in a pattern, the most
+convenient way to do it is with (?!) because an empty string always matches, so
+an assertion that requires there not to be an empty string must always fail.
+The backtracking control verb (*FAIL) or (*F) is a synonym for (?!).
+.
+.
+.\" HTML 
+.SS "Lookbehind assertions"
+.rs
+.sp
+Lookbehind assertions start with (?<= for positive assertions and (?
+.\" 
+(see above)
+.\"
+can be used instead of a lookbehind assertion to get round the fixed-length
+restriction.
+.P
+The implementation of lookbehind assertions is, for each alternative, to
+temporarily move the current position back by the fixed length and then try to
+match. If there are insufficient characters before the current position, the
+assertion fails.
+.P
+In a UTF mode, PCRE2 does not allow the \eC escape (which matches a single code
+unit even in a UTF mode) to appear in lookbehind assertions, because it makes
+it impossible to calculate the length of the lookbehind. The \eX and \eR
+escapes, which can match different numbers of code units, are also not
+permitted.
+.P
+.\" HTML 
+.\" 
+"Subroutine"
+.\"
+calls (see below) such as (?2) or (?&X) are permitted in lookbehinds, as long
+as the subpattern matches a fixed-length string.
+.\" HTML 
+.\" 
+Recursion,
+.\"
+however, is not supported.
+.P
+Possessive quantifiers can be used in conjunction with lookbehind assertions to
+specify efficient matching of fixed-length strings at the end of subject
+strings. Consider a simple pattern such as
+.sp
+  abcd$
+.sp
+when applied to a long string that does not match. Because matching proceeds
+from left to right, PCRE2 will look for each "a" in the subject and then see if
+what follows matches the rest of the pattern. If the pattern is specified as
+.sp
+  ^.*abcd$
+.sp
+the initial .* matches the entire string at first, but when this fails (because
+there is no following "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 "a"
+covers the entire string, from right to left, so we are no better off. However,
+if the pattern is written as
+.sp
+  ^.*+(?<=abcd)
+.sp
+there can be no backtracking for the .*+ item because of the possessive 
+quantifier; 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.
+.
+.
+.SS "Using multiple assertions"
+.rs
+.sp
+Several assertions (of any sort) may occur in succession. For example,
+.sp
+  (?<=\ed{3})(?
+.SH "CONDITIONAL SUBPATTERNS"
+.rs
+.sp
+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 specific capturing subpattern has
+already been matched. The two possible forms of conditional subpattern are:
+.sp
+  (?(condition)yes-pattern)
+  (?(condition)yes-pattern|no-pattern)
+.sp
+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. Each of the two alternatives may
+itself contain nested subpatterns of any form, including conditional
+subpatterns; the restriction to two alternatives applies only at the level of
+the condition. This pattern fragment is an example where the alternatives are
+complex:
+.sp
+  (?(1) (A|B|C) | (D | (?(2)E|F) | E) )
+.sp
+.P
+There are four kinds of condition: references to subpatterns, references to
+recursion, a pseudo-condition called DEFINE, and assertions.
+.
+.
+.SS "Checking for a used subpattern by number"
+.rs
+.sp
+If the text between the parentheses consists of a sequence of digits, the
+condition is true if a capturing subpattern of that number has previously
+matched. If there is more than one capturing subpattern with the same number
+(see the earlier
+.\"
+.\" HTML 
+.\" 
+section about duplicate subpattern numbers),
+.\"
+the condition is true if any of them have matched. An alternative notation is
+to precede the digits with a plus or minus sign. In this case, the subpattern
+number is relative rather than absolute. The most recently opened parentheses
+can be referenced by (?(-1), the next most recent by (?(-2), and so on. Inside
+loops it can also make sense to refer to subsequent groups. The next
+parentheses to be opened can be referenced as (?(+1), and so on. (The value
+zero in any of these forms is not used; it provokes a compile-time error.)
+.P
+Consider the following pattern, which contains non-significant white space to
+make it more readable (assume the PCRE2_EXTENDED option) and to divide it into
+three parts for ease of discussion:
+.sp
+  ( \e( )?    [^()]+    (?(1) \e) )
+.sp
+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 or not the first set of parentheses
+matched. 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.
+.P
+If you were embedding this pattern in a larger one, you could use a relative
+reference:
+.sp
+  ...other stuff... ( \e( )?    [^()]+    (?(-1) \e) ) ...
+.sp
+This makes the fragment independent of the parentheses in the larger pattern.
+.
+.
+.SS "Checking for a used subpattern by name"
+.rs
+.sp
+Perl uses the syntax (?()...) or (?('name')...) to test for a used
+subpattern by name. For compatibility with earlier versions of PCRE1, which had
+this facility before Perl, the syntax (?(name)...) is also recognized.
+.P
+Rewriting the above example to use a named subpattern gives this:
+.sp
+  (? \e( )?    [^()]+    (?() \e) )
+.sp
+If the name used in a condition of this kind is a duplicate, the test is
+applied to all subpatterns of the same name, and is true if any one of them has
+matched.
+.
+.
+.SS "Checking for pattern recursion"
+.rs
+.sp
+If the condition is the string (R), and there is no subpattern with the name R,
+the condition is true if a recursive call to the whole pattern or any
+subpattern has been made. If digits or a name preceded by ampersand follow the
+letter R, for example:
+.sp
+  (?(R3)...) or (?(R&name)...)
+.sp
+the condition is true if the most recent recursion is into a subpattern whose
+number or name is given. This condition does not check the entire recursion
+stack. If the name used in a condition of this kind is a duplicate, the test is
+applied to all subpatterns of the same name, and is true if any one of them is
+the most recent recursion.
+.P
+At "top level", all these recursion test conditions are false.
+.\" HTML 
+.\" 
+The syntax for recursive patterns
+.\"
+is described below.
+.
+.
+.\" HTML 
+.SS "Defining subpatterns for use by reference only"
+.rs
+.sp
+If the condition is the string (DEFINE), and there is no subpattern with the
+name DEFINE, the condition is always false. In this case, there may be only one
+alternative in the subpattern. It is always skipped if control reaches this
+point in the pattern; the idea of DEFINE is that it can be used to define
+subroutines that can be referenced from elsewhere. (The use of
+.\" HTML 
+.\" 
+subroutines
+.\"
+is described below.) For example, a pattern to match an IPv4 address such as
+"192.168.23.245" could be written like this (ignore white space and line
+breaks):
+.sp
+  (?(DEFINE) (? 2[0-4]\ed | 25[0-5] | 1\ed\ed | [1-9]?\ed) )
+  \eb (?&byte) (\e.(?&byte)){3} \eb
+.sp
+The first part of the pattern is a DEFINE group inside which a another group
+named "byte" is defined. This matches an individual component of an IPv4
+address (a number less than 256). When matching takes place, this part of the
+pattern is skipped because DEFINE acts like a false condition. The rest of the
+pattern uses references to the named group to match the four dot-separated
+components of an IPv4 address, insisting on a word boundary at each end.
+.
+.
+.SS "Assertion conditions"
+.rs
+.sp
+If the condition is not in any of the above formats, 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:
+.sp
+  (?(?=[^a-z]*[a-z])
+  \ed{2}-[a-z]{3}-\ed{2}  |  \ed{2}-\ed{2}-\ed{2} )
+.sp
+The condition is a positive lookahead assertion that matches an optional
+sequence of non-letters followed by a letter. In other words, it tests for the
+presence of at least one letter in the subject. If a letter is found, the
+subject is matched against the first alternative; otherwise it is matched
+against the second. This pattern matches strings in one of the two forms
+dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.
+.
+.
+.\" HTML 
+.SH COMMENTS
+.rs
+.sp
+There are two ways of including comments in patterns that are processed by
+PCRE2. In both cases, the start of the comment must not be in a character
+class, nor in the middle of any other sequence of related characters such as
+(?: or a subpattern name or number. The characters that make up a comment play
+no part in the pattern matching.
+.P
+The sequence (?# marks the start of a comment that continues up to the next
+closing parenthesis. Nested parentheses are not permitted. If the
+PCRE2_EXTENDED option is set, an unescaped # character also introduces a
+comment, which in this case continues to immediately after the next newline
+character or character sequence in the pattern. Which characters are
+interpreted as newlines is controlled by an option passed to the compiling
+function or by a special sequence at the start of the pattern, as described in
+the section entitled
+.\" HTML 
+.\" 
+"Newline conventions"
+.\"
+above. Note that the end of this type of comment is a literal newline sequence
+in the pattern; escape sequences that happen to represent a newline do not
+count. For example, consider this pattern when PCRE2_EXTENDED is set, and the
+default newline convention (a single linefeed character) is in force:
+.sp
+  abc #comment \en still comment
+.sp
+On encountering the # character, \fBpcre2_compile()\fP skips along, looking for
+a newline in the pattern. The sequence \en is still literal at this stage, so
+it does not terminate the comment. Only an actual character with the code value
+0x0a (the default newline) does so.
+.
+.
+.\" HTML 
+.SH "RECURSIVE PATTERNS"
+.rs
+.sp
+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.
+.P
+For some time, Perl has provided a 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 using code interpolation to solve the parentheses problem can be
+created like this:
+.sp
+  $re = qr{\e( (?: (?>[^()]+) | (?p{$re}) )* \e)}x;
+.sp
+The (?p{...}) item interpolates Perl code at run time, and in this case refers
+recursively to the pattern in which it appears.
+.P
+Obviously, PCRE2 cannot support the interpolation of Perl code. Instead, it
+supports special syntax for recursion of the entire pattern, and also for
+individual subpattern recursion. After its introduction in PCRE1 and Python,
+this kind of recursion was subsequently introduced into Perl at release 5.10.
+.P
+A special item that consists of (? followed by a number greater than zero and a
+closing parenthesis is a recursive subroutine call of the subpattern of the
+given number, provided that it occurs inside that subpattern. (If not, it is a
+.\" HTML 
+.\" 
+non-recursive subroutine
+.\"
+call, which is described in the next section.) The special item (?R) or (?0) is
+a recursive call of the entire regular expression.
+.P
+This PCRE2 pattern solves the nested parentheses problem (assume the
+PCRE2_EXTENDED option is set so that white space is ignored):
+.sp
+  \e( ( [^()]++ | (?R) )* \e)
+.sp
+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 (that is, a correctly parenthesized substring).
+Finally there is a closing parenthesis. Note the use of a possessive quantifier
+to avoid backtracking into sequences of non-parentheses.
+.P
+If this were part of a larger pattern, you would not want to recurse the entire
+pattern, so instead you could use this:
+.sp
+  ( \e( ( [^()]++ | (?1) )* \e) )
+.sp
+We have put the pattern into parentheses, and caused the recursion to refer to
+them instead of the whole pattern.
+.P
+In a larger pattern, keeping track of parenthesis numbers can be tricky. This
+is made easier by the use of relative references. Instead of (?1) in the
+pattern above you can write (?-2) to refer to the second most recently opened
+parentheses preceding the recursion. In other words, a negative number counts
+capturing parentheses leftwards from the point at which it is encountered.
+.P
+It is also possible to refer to subsequently opened parentheses, by writing
+references such as (?+2). However, these cannot be recursive because the
+reference is not inside the parentheses that are referenced. They are always
+.\" HTML 
+.\" 
+non-recursive subroutine
+.\"
+calls, as described in the next section.
+.P
+An alternative approach is to use named parentheses. The Perl syntax for this
+is (?&name); PCRE1's earlier syntax (?P>name) is also supported. We could
+rewrite the above example as follows:
+.sp
+  (? \e( ( [^()]++ | (?&pn) )* \e) )
+.sp
+If there is more than one subpattern with the same name, the earliest one is
+used.
+.P
+The example pattern that we have been looking at contains nested unlimited
+repeats, and so the use of a possessive quantifier for matching strings of
+non-parentheses is important when applying the pattern to strings that do not
+match. For example, when this pattern is applied to
+.sp
+  (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
+.sp
+it yields "no match" quickly. However, if a possessive quantifier is not used,
+the match runs for a very long time indeed because there are so many different
+ways the + and * repeats can carve up the subject, and all have to be tested
+before failure can be reported.
+.P
+At the end of a match, the values of capturing parentheses are those from
+the outermost level. If you want to obtain intermediate values, a callout
+function can be used (see below and the
+.\" HREF
+\fBpcre2callout\fP
+.\"
+documentation). If the pattern above is matched against
+.sp
+  (ab(cd)ef)
+.sp
+the value for the inner capturing parentheses (numbered 2) is "ef", which is
+the last value taken on at the top level. If a capturing subpattern is not
+matched at the top level, its final captured value is unset, even if it was
+(temporarily) set at a deeper level during the matching process.
+.P
+If there are more than 15 capturing parentheses in a pattern, PCRE2 has to
+obtain extra memory from the heap to store data during a recursion. If no
+memory can be obtained, the match fails with the PCRE2_ERROR_NOMEMORY error.
+.P
+Do not confuse the (?R) item with the condition (R), which tests for recursion.
+Consider this pattern, which matches text in angle brackets, allowing for
+arbitrary nesting. Only digits are allowed in nested brackets (that is, when
+recursing), whereas any characters are permitted at the outer level.
+.sp
+  < (?: (?(R) \ed++  | [^<>]*+) | (?R)) * >
+.sp
+In this pattern, (?(R) is the start of a conditional subpattern, with two
+different alternatives for the recursive and non-recursive cases. The (?R) item
+is the actual recursive call.
+.
+.
+.\" HTML 
+.SS "Differences in recursion processing between PCRE2 and Perl"
+.rs
+.sp
+Recursion processing in PCRE2 differs from Perl in two important ways. In PCRE2
+(like Python, but unlike Perl), a recursive subpattern call is always treated
+as an atomic group. That is, once it has matched some of the subject string, it
+is never re-entered, even if it contains untried alternatives and there is a
+subsequent matching failure. This can be illustrated by the following pattern,
+which purports to match a palindromic string that contains an odd number of
+characters (for example, "a", "aba", "abcba", "abcdcba"):
+.sp
+  ^(.|(.)(?1)\e2)$
+.sp
+The idea is that it either matches a single character, or two identical
+characters surrounding a sub-palindrome. In Perl, this pattern works; in PCRE2
+it does not if the pattern is longer than three characters. Consider the
+subject string "abcba":
+.P
+At the top level, the first character is matched, but as it is not at the end
+of the string, the first alternative fails; the second alternative is taken
+and the recursion kicks in. The recursive call to subpattern 1 successfully
+matches the next character ("b"). (Note that the beginning and end of line
+tests are not part of the recursion).
+.P
+Back at the top level, the next character ("c") is compared with what
+subpattern 2 matched, which was "a". This fails. Because the recursion is
+treated as an atomic group, there are now no backtracking points, and so the
+entire match fails. (Perl is able, at this point, to re-enter the recursion and
+try the second alternative.) However, if the pattern is written with the
+alternatives in the other order, things are different:
+.sp
+  ^((.)(?1)\e2|.)$
+.sp
+This time, the recursing alternative is tried first, and continues to recurse
+until it runs out of characters, at which point the recursion fails. But this
+time we do have another alternative to try at the higher level. That is the big
+difference: in the previous case the remaining alternative is at a deeper
+recursion level, which PCRE2 cannot use.
+.P
+To change the pattern so that it matches all palindromic strings, not just
+those with an odd number of characters, it is tempting to change the pattern to
+this:
+.sp
+  ^((.)(?1)\e2|.?)$
+.sp
+Again, this works in Perl, but not in PCRE2, and for the same reason. When a
+deeper recursion has matched a single character, it cannot be entered again in
+order to match an empty string. The solution is to separate the two cases, and
+write out the odd and even cases as alternatives at the higher level:
+.sp
+  ^(?:((.)(?1)\e2|)|((.)(?3)\e4|.))
+.sp
+If you want to match typical palindromic phrases, the pattern has to ignore all
+non-word characters, which can be done like this:
+.sp
+  ^\eW*+(?:((.)\eW*+(?1)\eW*+\e2|)|((.)\eW*+(?3)\eW*+\e4|\eW*+.\eW*+))\eW*+$
+.sp
+If run with the PCRE2_CASELESS option, this pattern matches phrases such as "A
+man, a plan, a canal: Panama!" and it works in both PCRE2 and Perl. Note the
+use of the possessive quantifier *+ to avoid backtracking into sequences of
+non-word characters. Without this, PCRE2 takes a great deal longer (ten times
+or more) to match typical phrases, and Perl takes so long that you think it has
+gone into a loop.
+.P
+\fBWARNING\fP: The palindrome-matching patterns above work only if the subject
+string does not start with a palindrome that is shorter than the entire string.
+For example, although "abcba" is correctly matched, if the subject is "ababa",
+PCRE2 finds the palindrome "aba" at the start, then fails at top level because
+the end of the string does not follow. Once again, it cannot jump back into the
+recursion to try other alternatives, so the entire match fails.
+.P
+The second way in which PCRE2 and Perl differ in their recursion processing is
+in the handling of captured values. In Perl, when a subpattern is called
+recursively or as a subpattern (see the next section), it has no access to any
+values that were captured outside the recursion, whereas in PCRE2 these values
+can be referenced. Consider this pattern:
+.sp
+  ^(.)(\e1|a(?2))
+.sp
+In PCRE2, this pattern matches "bab". The first capturing parentheses match "b",
+then in the second group, when the back reference \e1 fails to match "b", the
+second alternative matches "a" and then recurses. In the recursion, \e1 does
+now match "b" and so the whole match succeeds. In Perl, the pattern fails to
+match because inside the recursive call \e1 cannot access the externally set
+value.
+.
+.
+.\" HTML 
+.SH "SUBPATTERNS AS SUBROUTINES"
+.rs
+.sp
+If the syntax for a recursive subpattern call (either by number or by
+name) is used outside the parentheses to which it refers, it operates like a
+subroutine in a programming language. The called subpattern may be defined
+before or after the reference. A numbered reference can be absolute or
+relative, as in these examples:
+.sp
+  (...(absolute)...)...(?2)...
+  (...(relative)...)...(?-1)...
+  (...(?+1)...(relative)...
+.sp
+An earlier example pointed out that the pattern
+.sp
+  (sens|respons)e and \e1ibility
+.sp
+matches "sense and sensibility" and "response and responsibility", but not
+"sense and responsibility". If instead the pattern
+.sp
+  (sens|respons)e and (?1)ibility
+.sp
+is used, it does match "sense and responsibility" as well as the other two
+strings. Another example is given in the discussion of DEFINE above.
+.P
+All subroutine calls, whether recursive or not, are always treated as atomic
+groups. That is, once a subroutine has matched some of the subject string, it
+is never re-entered, even if it contains untried alternatives and there is a
+subsequent matching failure. Any capturing parentheses that are set during the
+subroutine call revert to their previous values afterwards.
+.P
+Processing options such as case-independence are fixed when a subpattern is
+defined, so if it is used as a subroutine, such options cannot be changed for
+different calls. For example, consider this pattern:
+.sp
+  (abc)(?i:(?-1))
+.sp
+It matches "abcabc". It does not match "abcABC" because the change of
+processing option does not affect the called subpattern.
+.
+.
+.\" HTML 
+.SH "ONIGURUMA SUBROUTINE SYNTAX"
+.rs
+.sp
+For compatibility with Oniguruma, the non-Perl syntax \eg followed by a name or
+a number enclosed either in angle brackets or single quotes, is an alternative
+syntax for referencing a subpattern as a subroutine, possibly recursively. Here
+are two of the examples used above, rewritten using this syntax:
+.sp
+  (? \e( ( (?>[^()]+) | \eg )* \e) )
+  (sens|respons)e and \eg'1'ibility
+.sp
+PCRE2 supports an extension to Oniguruma: if a number is preceded by a
+plus or a minus sign it is taken as a relative reference. For example:
+.sp
+  (abc)(?i:\eg<-1>)
+.sp
+Note that \eg{...} (Perl syntax) and \eg<...> (Oniguruma syntax) are \fInot\fP
+synonymous. The former is a back reference; the latter is a subroutine call.
+.
+.
+.SH CALLOUTS
+.rs
+.sp
+Perl has a feature whereby using the sequence (?{...}) causes arbitrary Perl
+code to be obeyed in the middle of matching a regular expression. This makes it
+possible, amongst other things, to extract different substrings that match the
+same pair of parentheses when there is a repetition.
+.P
+PCRE2 provides a similar feature, but of course it cannot obey arbitrary Perl
+code. The feature is called "callout". The caller of PCRE2 provides an external
+function by putting its entry point in a match context using the function 
+\fBpcre2_set_callout()\fP and passing the context to \fBpcre2_match()\fP or 
+\fBpcre2_dfa_match()\fP. If no match context is passed, or if the callout entry
+point is set to NULL, callouts are disabled.
+.P
+Within a regular expression, (?C) indicates the points at which the external
+function is to be called. If you want to identify different callout points, you
+can put a number less than 256 after the letter C. The default value is zero.
+For example, this pattern has two callout points:
+.sp
+  (?C1)abc(?C2)def
+.sp
+If the PCRE2_AUTO_CALLOUT flag is passed to \fBpcre2_compile()\fP, callouts are
+automatically installed before each item in the pattern. They are all numbered
+255. If there is a conditional group in the pattern whose condition is an
+assertion, an additional callout is inserted just before the condition. An
+explicit callout may also be set at this position, as in this example:
+.sp
+  (?(?C9)(?=a)abc|def)
+.sp
+Note that this applies only to assertion conditions, not to other types of
+condition.
+.P
+During matching, when PCRE2 reaches a callout point, the external function is
+called. It is provided with the number of the callout, the position in the
+pattern, and one item of data that is also set in the match block. The callout
+function may cause matching to proceed, to backtrack, or to fail.
+.P
+By default, PCRE2 implements a number of optimizations at matching time, and
+one side-effect is that sometimes callouts are skipped. If you need all
+possible callouts to happen, you need to set options that disable the relevant
+optimizations. More details, and a complete description of the interface to the
+callout function, are given in the
+.\" HREF
+\fBpcre2callout\fP
+.\"
+documentation.
+.
+.
+.\" HTML 
+.SH "BACKTRACKING CONTROL"
+.rs
+.sp
+Perl 5.10 introduced a number of "Special Backtracking Control Verbs", which
+are still described in the Perl documentation as "experimental and subject to
+change or removal in a future version of Perl". It goes on to say: "Their usage
+in production code should be noted to avoid problems during upgrades." The same
+remarks apply to the PCRE2 features described in this section.
+.P
+The new verbs make use of what was previously invalid syntax: an opening
+parenthesis followed by an asterisk. They are generally of the form
+(*VERB) or (*VERB:NAME). Some may take either form, possibly behaving
+differently depending on whether or not a name is present. A name is any
+sequence of characters that does not include a closing parenthesis. The maximum
+length of name is 255 in the 8-bit library and 65535 in the 16-bit and 32-bit
+libraries. If the name is empty, that is, if the closing parenthesis
+immediately follows the colon, the effect is as if the colon were not there.
+Any number of these verbs may occur in a pattern.
+.P
+Since these verbs are specifically related to backtracking, most of them can be
+used only when the pattern is to be matched using the traditional matching
+function, because these use a backtracking algorithm. With the exception of
+(*FAIL), which behaves like a failing negative assertion, the backtracking
+control verbs cause an error if encountered by the DFA matching function.
+.P
+The behaviour of these verbs in
+.\" HTML 
+.\" 
+repeated groups,
+.\"
+.\" HTML 
+.\" 
+assertions,
+.\"
+and in
+.\" HTML 
+.\" 
+subpatterns called as subroutines
+.\"
+(whether or not recursively) is documented below.
+.
+.
+.\" HTML 
+.SS "Optimizations that affect backtracking verbs"
+.rs
+.sp
+PCRE2 contains some optimizations that are used to speed up matching by running
+some checks at the start of each match attempt. For example, it may know the
+minimum length of matching subject, or that a particular character must be
+present. When one of these optimizations bypasses the running of a match, any
+included backtracking verbs will not, of course, be processed. You can suppress
+the start-of-match optimizations by setting the PCRE2_NO_START_OPTIMIZE option
+when calling \fBpcre2_compile()\fP, or by starting the pattern with
+(*NO_START_OPT). There is more discussion of this option in the section
+entitled
+.\" HTML 
+.\" 
+"Compiling a pattern"
+.\"
+in the
+.\" HREF
+\fBpcre2api\fP
+.\"
+documentation.
+.P
+Experiments with Perl suggest that it too has similar optimizations, sometimes
+leading to anomalous results.
+.
+.
+.SS "Verbs that act immediately"
+.rs
+.sp
+The following verbs act as soon as they are encountered. They may not be
+followed by a name.
+.sp
+   (*ACCEPT)
+.sp
+This verb causes the match to end successfully, skipping the remainder of the
+pattern. However, when it is inside a subpattern that is called as a
+subroutine, only that subpattern is ended successfully. Matching then continues
+at the outer level. If (*ACCEPT) in triggered in a positive assertion, the
+assertion succeeds; in a negative assertion, the assertion fails.
+.P
+If (*ACCEPT) is inside capturing parentheses, the data so far is captured. For
+example:
+.sp
+  A((?:A|B(*ACCEPT)|C)D)
+.sp
+This matches "AB", "AAD", or "ACD"; when it matches "AB", "B" is captured by
+the outer parentheses.
+.sp
+  (*FAIL) or (*F)
+.sp
+This verb causes a matching failure, forcing backtracking to occur. It is
+equivalent to (?!) but easier to read. The Perl documentation notes that it is
+probably useful only when combined with (?{}) or (??{}). Those are, of course,
+Perl features that are not present in PCRE2. The nearest equivalent is the
+callout feature, as for example in this pattern:
+.sp
+  a+(?C)(*FAIL)
+.sp
+A match with the string "aaaa" always fails, but the callout is taken before
+each backtrack happens (in this example, 10 times).
+.
+.
+.SS "Recording which path was taken"
+.rs
+.sp
+There is one verb whose main purpose is to track how a match was arrived at,
+though it also has a secondary use in conjunction with advancing the match
+starting point (see (*SKIP) below).
+.sp
+  (*MARK:NAME) or (*:NAME)
+.sp
+A name is always required with this verb. There may be as many instances of
+(*MARK) as you like in a pattern, and their names do not have to be unique.
+.P
+When a match succeeds, the name of the last-encountered (*MARK:NAME),
+(*PRUNE:NAME), or (*THEN:NAME) on the matching path is passed back to the
+caller as described in the section entitled
+.\" HTML 
+.\" 
+"Other information about the match"
+.\"
+in the
+.\" HREF
+\fBpcre2api\fP
+.\"
+documentation. Here is an example of \fBpcre2test\fP output, where the "mark"
+modifier requests the retrieval and outputting of (*MARK) data:
+.sp
+    re> /X(*MARK:A)Y|X(*MARK:B)Z/mark
+  data> XY
+   0: XY
+  MK: A
+  XZ
+   0: XZ
+  MK: B
+.sp
+The (*MARK) name is tagged with "MK:" in this output, and in this example it
+indicates which of the two alternatives matched. This is a more efficient way
+of obtaining this information than putting each alternative in its own
+capturing parentheses.
+.P
+If a verb with a name is encountered in a positive assertion that is true, the
+name is recorded and passed back if it is the last-encountered. This does not
+happen for negative assertions or failing positive assertions.
+.P
+After a partial match or a failed match, the last encountered name in the
+entire match process is returned. For example:
+.sp
+    re> /X(*MARK:A)Y|X(*MARK:B)Z/mark
+  data> XP
+  No match, mark = B
+.sp
+Note that in this unanchored example the mark is retained from the match
+attempt that started at the letter "X" in the subject. Subsequent match
+attempts starting at "P" and then with an empty string do not get as far as the
+(*MARK) item, but nevertheless do not reset it.
+.P
+If you are interested in (*MARK) values after failed matches, you should
+probably set the PCRE2_NO_START_OPTIMIZE option
+.\" HTML 
+.\" 
+(see above)
+.\"
+to ensure that the match is always attempted.
+.
+.
+.SS "Verbs that act after backtracking"
+.rs
+.sp
+The following verbs do nothing when they are encountered. Matching continues
+with what follows, but if there is no subsequent match, causing a backtrack to
+the verb, a failure is forced. That is, backtracking cannot pass to the left of
+the verb. However, when one of these verbs appears inside an atomic group
+(which includes any group that is called as a subroutine) or in an assertion
+that is true, its effect is confined to that group, because once the group has
+been matched, there is never any backtracking into it. In this situation,
+backtracking has to jump to the left of the entire atomic group or assertion.
+.P
+These verbs differ in exactly what kind of failure occurs when backtracking
+reaches them. The behaviour described below is what happens when the verb is
+not in a subroutine or an assertion. Subsequent sections cover these special
+cases.
+.sp
+  (*COMMIT)
+.sp
+This verb, which may not be followed by a name, causes the whole match to fail
+outright if there is a later matching failure that causes backtracking to reach
+it. Even if the pattern is unanchored, no further attempts to find a match by
+advancing the starting point take place. If (*COMMIT) is the only backtracking
+verb that is encountered, once it has been passed \fBpcre2_match()\fP is
+committed to finding a match at the current starting point, or not at all. For
+example:
+.sp
+  a+(*COMMIT)b
+.sp
+This matches "xxaab" but not "aacaab". It can be thought of as a kind of
+dynamic anchor, or "I've started, so I must finish." The name of the most
+recently passed (*MARK) in the path is passed back when (*COMMIT) forces a
+match failure.
+.P
+If there is more than one backtracking verb in a pattern, a different one that
+follows (*COMMIT) may be triggered first, so merely passing (*COMMIT) during a
+match does not always guarantee that a match must be at this starting point.
+.P
+Note that (*COMMIT) at the start of a pattern is not the same as an anchor,
+unless PCRE2's start-of-match optimizations are turned off, as shown in this
+output from \fBpcre2test\fP:
+.sp
+    re> /(*COMMIT)abc/
+  data> xyzabc
+   0: abc
+  data>  
+  re> /(*COMMIT)abc/no_start_optimize
+  data> xyzabc
+  No match
+.sp
+For the first pattern, PCRE2 knows that any match must start with "a", so the
+optimization skips along the subject to "a" before applying the pattern to the
+first set of data. The match attempt then succeeds. The second pattern disables
+the optimization that skips along to the first character. The pattern is now
+applied starting at "x", and so the (*COMMIT) causes the match to fail without
+trying any other starting points.
+.sp
+  (*PRUNE) or (*PRUNE:NAME)
+.sp
+This verb causes the match to fail at the current starting position in the
+subject if there is a later matching failure that causes backtracking to reach
+it. If the pattern is unanchored, the normal "bumpalong" advance to the next
+starting character then happens. Backtracking can occur as usual to the left of
+(*PRUNE), before it is reached, or when matching to the right of (*PRUNE), but
+if there is no match to the right, backtracking cannot cross (*PRUNE). In
+simple cases, the use of (*PRUNE) is just an alternative to an atomic group or
+possessive quantifier, but there are some uses of (*PRUNE) that cannot be
+expressed in any other way. In an anchored pattern (*PRUNE) has the same effect
+as (*COMMIT).
+.P
+The behaviour of (*PRUNE:NAME) is the not the same as (*MARK:NAME)(*PRUNE).
+It is like (*MARK:NAME) in that the name is remembered for passing back to the
+caller. However, (*SKIP:NAME) searches only for names set with (*MARK), 
+ignoring those set by (*PRUNE) or (*THEN).
+.sp
+  (*SKIP)
+.sp
+This verb, when given without a name, is like (*PRUNE), except that if the
+pattern is unanchored, the "bumpalong" advance is not to the next character,
+but to the position in the subject where (*SKIP) was encountered. (*SKIP)
+signifies that whatever text was matched leading up to it cannot be part of a
+successful match. Consider:
+.sp
+  a+(*SKIP)b
+.sp
+If the subject is "aaaac...", after the first match attempt fails (starting at
+the first character in the string), the starting point skips on to start the
+next attempt at "c". Note that a possessive quantifer does not have the same
+effect as this example; although it would suppress backtracking during the
+first match attempt, the second attempt would start at the second character
+instead of skipping on to "c".
+.sp
+  (*SKIP:NAME)
+.sp
+When (*SKIP) has an associated name, its behaviour is modified. When it is
+triggered, the previous path through the pattern is searched for the most
+recent (*MARK) that has the same name. If one is found, the "bumpalong" advance
+is to the subject position that corresponds to that (*MARK) instead of to where
+(*SKIP) was encountered. If no (*MARK) with a matching name is found, the
+(*SKIP) is ignored.
+.P
+Note that (*SKIP:NAME) searches only for names set by (*MARK:NAME). It ignores
+names that are set by (*PRUNE:NAME) or (*THEN:NAME).
+.sp
+  (*THEN) or (*THEN:NAME)
+.sp
+This verb causes a skip to the next innermost alternative when backtracking
+reaches it. That is, it cancels any further backtracking within the current
+alternative. Its name comes from the observation that it can be used for a
+pattern-based if-then-else block:
+.sp
+  ( COND1 (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ ) ...
+.sp
+If the COND1 pattern matches, FOO is tried (and possibly further items after
+the end of the group if FOO succeeds); on failure, the matcher skips to the
+second alternative and tries COND2, without backtracking into COND1. If that
+succeeds and BAR fails, COND3 is tried. If subsequently BAZ fails, there are no
+more alternatives, so there is a backtrack to whatever came before the entire
+group. If (*THEN) is not inside an alternation, it acts like (*PRUNE).
+.P
+The behaviour of (*THEN:NAME) is the not the same as (*MARK:NAME)(*THEN).
+It is like (*MARK:NAME) in that the name is remembered for passing back to the
+caller. However, (*SKIP:NAME) searches only for names set with (*MARK), 
+ignoring those set by (*PRUNE) and (*THEN).
+.P
+A subpattern that does not contain a | character is just a part of the
+enclosing alternative; it is not a nested alternation with only one
+alternative. The effect of (*THEN) extends beyond such a subpattern to the
+enclosing alternative. Consider this pattern, where A, B, etc. are complex
+pattern fragments that do not contain any | characters at this level:
+.sp
+  A (B(*THEN)C) | D
+.sp
+If A and B are matched, but there is a failure in C, matching does not
+backtrack into A; instead it moves to the next alternative, that is, D.
+However, if the subpattern containing (*THEN) is given an alternative, it
+behaves differently:
+.sp
+  A (B(*THEN)C | (*FAIL)) | D
+.sp
+The effect of (*THEN) is now confined to the inner subpattern. After a failure
+in C, matching moves to (*FAIL), which causes the whole subpattern to fail
+because there are no more alternatives to try. In this case, matching does now
+backtrack into A.
+.P
+Note that a conditional subpattern is not considered as having two
+alternatives, because only one is ever used. In other words, the | character in
+a conditional subpattern has a different meaning. Ignoring white space,
+consider:
+.sp
+  ^.*? (?(?=a) a | b(*THEN)c )
+.sp
+If the subject is "ba", this pattern does not match. Because .*? is ungreedy,
+it initially matches zero characters. The condition (?=a) then fails, the
+character "b" is matched, but "c" is not. At this point, matching does not
+backtrack to .*? as might perhaps be expected from the presence of the |
+character. The conditional subpattern is part of the single alternative that
+comprises the whole pattern, and so the match fails. (If there was a backtrack
+into .*?, allowing it to match "b", the match would succeed.)
+.P
+The verbs just described provide four different "strengths" of control when
+subsequent matching fails. (*THEN) is the weakest, carrying on the match at the
+next alternative. (*PRUNE) comes next, failing the match at the current
+starting position, but allowing an advance to the next character (for an
+unanchored pattern). (*SKIP) is similar, except that the advance may be more
+than one character. (*COMMIT) is the strongest, causing the entire match to
+fail.
+.
+.
+.SS "More than one backtracking verb"
+.rs
+.sp
+If more than one backtracking verb is present in a pattern, the one that is
+backtracked onto first acts. For example, consider this pattern, where A, B,
+etc. are complex pattern fragments:
+.sp
+  (A(*COMMIT)B(*THEN)C|ABD)
+.sp
+If A matches but B fails, the backtrack to (*COMMIT) causes the entire match to
+fail. However, if A and B match, but C fails, the backtrack to (*THEN) causes
+the next alternative (ABD) to be tried. This behaviour is consistent, but is
+not always the same as Perl's. It means that if two or more backtracking verbs
+appear in succession, all the the last of them has no effect. Consider this
+example:
+.sp
+  ...(*COMMIT)(*PRUNE)...
+.sp
+If there is a matching failure to the right, backtracking onto (*PRUNE) causes
+it to be triggered, and its action is taken. There can never be a backtrack
+onto (*COMMIT).
+.
+.
+.\" HTML 
+.SS "Backtracking verbs in repeated groups"
+.rs
+.sp
+PCRE2 differs from Perl in its handling of backtracking verbs in repeated
+groups. For example, consider:
+.sp
+  /(a(*COMMIT)b)+ac/
+.sp
+If the subject is "abac", Perl matches, but PCRE2 fails because the (*COMMIT)
+in the second repeat of the group acts.
+.
+.
+.\" HTML 
+.SS "Backtracking verbs in assertions"
+.rs
+.sp
+(*FAIL) in an assertion has its normal effect: it forces an immediate
+backtrack.
+.P
+(*ACCEPT) in a positive assertion causes the assertion to succeed without any
+further processing. In a negative assertion, (*ACCEPT) causes the assertion to
+fail without any further processing.
+.P
+The other backtracking verbs are not treated specially if they appear in a
+positive assertion. In particular, (*THEN) skips to the next alternative in the
+innermost enclosing group that has alternations, whether or not this is within
+the assertion.
+.P
+Negative assertions are, however, different, in order to ensure that changing a
+positive assertion into a negative assertion changes its result. Backtracking
+into (*COMMIT), (*SKIP), or (*PRUNE) causes a negative assertion to be true,
+without considering any further alternative branches in the assertion.
+Backtracking into (*THEN) causes it to skip to the next enclosing alternative
+within the assertion (the normal behaviour), but if the assertion does not have
+such an alternative, (*THEN) behaves like (*PRUNE).
+.
+.
+.\" HTML 
+.SS "Backtracking verbs in subroutines"
+.rs
+.sp
+These behaviours occur whether or not the subpattern is called recursively.
+Perl's treatment of subroutines is different in some cases.
+.P
+(*FAIL) in a subpattern called as a subroutine has its normal effect: it forces
+an immediate backtrack.
+.P
+(*ACCEPT) in a subpattern called as a subroutine causes the subroutine match to
+succeed without any further processing. Matching then continues after the
+subroutine call.
+.P
+(*COMMIT), (*SKIP), and (*PRUNE) in a subpattern called as a subroutine cause
+the subroutine match to fail.
+.P
+(*THEN) skips to the next alternative in the innermost enclosing group within
+the subpattern that has alternatives. If there is no such group within the
+subpattern, (*THEN) causes the subroutine match to fail.
+.
+.
+.SH "SEE ALSO"
+.rs
+.sp
+\fBpcre2api\fP(3), \fBpcre2callout\fP(3), \fBpcre2matching\fP(3),
+\fBpcre2syntax\fP(3), \fBpcre2\fP(3), \fBpcre216(3)\fP, \fBpcre232(3)\fP.
+.
+.
+.SH AUTHOR
+.rs
+.sp
+.nf
+Philip Hazel
+University Computing Service
+Cambridge CB2 3QH, England.
+.fi
+.
+.
+.SH REVISION
+.rs
+.sp
+.nf
+Last updated: 19 October 2014
+Copyright (c) 1997-2014 University of Cambridge.
+.fi
diff --git a/doc/pcre2test.txt b/doc/pcre2test.txt
index 3312257..5da745a 100644
--- a/doc/pcre2test.txt
+++ b/doc/pcre2test.txt
@@ -112,9 +112,9 @@ COMMAND LINE OPTIONS
 
                    ebcdic     compiled for an EBCDIC environment
                    jit        just-in-time support is available
-                   pcre16     the 16-bit library was built
-                   pcre32     the 32-bit library was built
-                   pcre8      the 8-bit library was built
+                   pcre2-16   the 16-bit library was built
+                   pcre2-32   the 32-bit library was built
+                   pcre2-8    the 8-bit library was built
                    unicode    Unicode support is available
 
                  If an unknown option is given, an error  message  is  output;