/[pcre]/code/trunk/doc/pcre.txt

Diff of /code/trunk/doc/pcre.txt

Parent Directory | Revision Log | View Patch Patch

-revision 1403 by ph10,
Fri Jun 14 09:09:28 2013 UTC
+revision 1404 by ph10,
Tue Nov 19 15:36:57 2013 UTC
 Line 53 
 INTRODUCTION
 .12, including support for UTF-8/16/32  encoded  strings  and  Unicode
         general  category  properties. However, UTF-8/16/32 and Unicode support
         has to be explicitly enabled; it is not the default. The Unicode tables
-        correspond to Unicode release 6.2.0.
+        correspond to Unicode release 6.3.0.
         In  addition to the Perl-compatible matching function, PCRE contains an
         alternative function that matches the same compiled patterns in a  dif-
 Line 180 
 REVISION
         Last updated: 13 May 2013
         Copyright (c) 1997-2013 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRE(3)                    Library Functions Manual                    PCRE(3)
 Line 512 
 REVISION
         Last updated: 12 May 2013
         Copyright (c) 1997-2013 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRE(3)                    Library Functions Manual                    PCRE(3)
 Line 840 
 REVISION
         Last updated: 12 May 2013
         Copyright (c) 1997-2013 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREBUILD(3)               Library Functions Manual               PCREBUILD(3)
 Line 1343 
 REVISION
         Last updated: 12 May 2013
         Copyright (c) 1997-2013 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREMATCHING(3)            Library Functions Manual            PCREMATCHING(3)
 Line 1457 
 THE ALTERNATIVE MATCHING ALGORITHM
         at the fifth character of the subject. The algorithm does not automati-
         cally move on to find matches that start at later positions.
+        PCRE'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 PCRE_NO_AUTO_POSSESS
+        option when compiling.
         There are a number of features of PCRE regular expressions that are not
         supported by the alternative matching algorithm. They are as follows:
-. Because the algorithm finds all  possible  matches,  the  greedy  or
+.  Because  the  algorithm  finds  all possible matches, the greedy or
-        ungreedy  nature  of repetition quantifiers is not relevant. Greedy and
+        ungreedy nature of repetition quantifiers is not relevant.  Greedy  and
         ungreedy quantifiers are treated in exactly the same way. However, pos-
-        sessive  quantifiers can make a difference when what follows could also
+        sessive 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
+        This  pattern matches "aaab!" but not "aaa!", which would be matched by
-        a  non-possessive quantifier. Similarly, if an atomic group is present,
+        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,
+        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
+        and the longest match is then "locked in" for the rest of  the  overall
         pattern.
 . When dealing with multiple paths through the tree simultaneously, it
-        is  not  straightforward  to  keep track of captured substrings for the
+        is not straightforward to keep track of  captured  substrings  for  the
-        different matching possibilities, and  PCRE's  implementation  of  this
+        different  matching  possibilities,  and  PCRE's implementation of this
         algorithm does not attempt to do this. This means that no captured sub-
         strings are available.
-. Because no substrings are captured, back references within the  pat-
+.  Because no substrings are captured, back references within the pat-
         tern are not supported, and cause errors if encountered.
-.  For  the same reason, conditional expressions that use a backrefer-
+. For the same reason, conditional expressions that use  a  backrefer-
-        ence as the condition or test for a specific group  recursion  are  not
+        ence  as  the  condition or test for a specific group recursion are not
         supported.
-.  Because  many  paths  through the tree may be active, the \K escape
+. 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
+        be on some paths and not on others), is not  supported.  It  causes  an
         error if encountered.
-. Callouts are supported, but the value of the  capture_top  field  is
+.  Callouts  are  supported, but the value of the capture_top field is
         always 1, and the value of the capture_last field is always -1.
-.  The  \C  escape  sequence, which (in the standard algorithm) always
+. The \C escape sequence, which (in  the  standard  algorithm)  always
-        matches a single data unit, even in UTF-8, UTF-16 or UTF-32  modes,  is
+        matches  a  single data unit, even in UTF-8, UTF-16 or UTF-32 modes, is
-        not  supported  in these modes, because the alternative algorithm moves
+        not supported in these modes, because the alternative  algorithm  moves
         through the subject string one character (not data unit) at a time, for
         all active paths through the tree.
-.  Except for (*FAIL), the backtracking control verbs such as (*PRUNE)
+. Except for (*FAIL), the backtracking control verbs such as  (*PRUNE)
-        are not supported. (*FAIL) is supported, and  behaves  like  a  failing
+        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-
+        Using the alternative matching algorithm provides the following  advan-
         tages:
 . All possible matches (at a single point in the subject) are automat-
-        ically  found,  and  in particular, the longest match is found. To find
+        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.
-.  Because  the  alternative  algorithm  scans the subject string just
+. 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
+        sible to pass very long subject strings to  the  matching  function  in
         several pieces, checking for partial matching each time. Although it is
-        possible  to  do multi-segment matching using the standard algorithm by
+        possible to do multi-segment matching using the standard  algorithm  by
-        retaining partially matched substrings, it  is  more  complicated.  The
+        retaining  partially  matched  substrings,  it is more complicated. The
-        pcrepartial  documentation  gives  details of partial matching and dis-
+        pcrepartial documentation gives details of partial  matching  and  dis-
         cusses multi-segment matching.
-Line 1530 
 DISADVANTAGES OF THE ALTERNATIVE ALGORIT
+Line 1539 
 DISADVANTAGES OF THE ALTERNATIVE ALGORIT
         The alternative algorithm suffers from a number of disadvantages:
-. It is substantially slower than  the  standard  algorithm.  This  is
+.  It  is  substantially  slower  than the standard algorithm. This is
-        partly  because  it has to search for all possible matches, but is also
+        partly because it has to search for all possible matches, but  is  also
         because it is less susceptible to optimization.
 . Capturing parentheses and back references are not supported.
-Line 1549 
 AUTHOR
+Line 1558 
 AUTHOR
  REVISION
-        Last updated: 08 January 2012
+        Last updated: 12 November 2013
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREAPI(3)                 Library Functions Manual                 PCREAPI(3)
-Line 1957 
 CHECKING BUILD-TIME OPTIONS
+Line 1966 
 CHECKING BUILD-TIME OPTIONS
         POSIX interface uses malloc() for output vectors. Further  details  are
         given in the pcreposix documentation.
+          PCRE_CONFIG_PARENS_LIMIT
+        The output is a long integer that gives the maximum depth of nesting of
+        parentheses (of any kind) in a pattern. This limit is  imposed  to  cap
+        the amount of system stack used when a pattern is compiled. It is spec-
+        ified when PCRE is built; the default is 250.
           PCRE_CONFIG_MATCH_LIMIT
-        The  output is a long integer that gives the default limit for the num-
+        The output is a long integer that gives the default limit for the  num-
-        ber of internal matching function calls  in  a  pcre_exec()  execution.
+        ber  of  internal  matching  function calls in a pcre_exec() execution.
         Further details are given with pcre_exec() below.
           PCRE_CONFIG_MATCH_LIMIT_RECURSION
         The output is a long integer that gives the default limit for the depth
-        of  recursion  when  calling  the  internal  matching  function  in   a
+        of   recursion  when  calling  the  internal  matching  function  in  a
-        pcre_exec()  execution.  Further  details  are  given  with pcre_exec()
+        pcre_exec() execution.  Further  details  are  given  with  pcre_exec()
         below.
           PCRE_CONFIG_STACKRECURSE
-        The output is an integer that is set to one if internal recursion  when
+        The  output is an integer that is set to one if internal recursion when
         running pcre_exec() is implemented by recursive function calls that use
-        the stack to remember their state. This is the usual way that  PCRE  is
+        the  stack  to remember their state. This is the usual way that PCRE is
         compiled. The output is zero if PCRE was compiled to use blocks of data
-        on the  heap  instead  of  recursive  function  calls.  In  this  case,
+        on  the  heap  instead  of  recursive  function  calls.  In  this case,
-        pcre_stack_malloc  and  pcre_stack_free  are  called  to  manage memory
+        pcre_stack_malloc and  pcre_stack_free  are  called  to  manage  memory
         blocks on the heap, thus avoiding the use of the stack.
-Line 1994 
 COMPILING A PATTERN
+Line 2010 
 COMPILING A PATTERN
         Either of the functions pcre_compile() or pcre_compile2() can be called
         to compile a pattern into an internal form. The only difference between
-        the two interfaces is that pcre_compile2() has an additional  argument,
+        the  two interfaces is that pcre_compile2() has an additional argument,
-        errorcodeptr,  via  which  a  numerical  error code can be returned. To
+        errorcodeptr, via which a numerical error  code  can  be  returned.  To
-        avoid too much repetition, we refer just to pcre_compile()  below,  but
+        avoid  too  much repetition, we refer just to pcre_compile() below, but
         the information applies equally to pcre_compile2().
         The pattern is a C string terminated by a binary zero, and is passed in
-        the pattern argument. A pointer to a single block  of  memory  that  is
+        the  pattern  argument.  A  pointer to a single block of memory that is
-        obtained  via  pcre_malloc is returned. This contains the compiled code
+        obtained via pcre_malloc is returned. This contains the  compiled  code
         and related data. The pcre type is defined for the returned block; this
         is a typedef for a structure whose contents are not externally defined.
         It is up to the caller to free the memory (via pcre_free) when it is no
         longer required.
-        Although  the compiled code of a PCRE regex is relocatable, that is, it
+        Although the compiled code of a PCRE regex is relocatable, that is,  it
         does not depend on memory location, the complete pcre data block is not
-        fully  relocatable, because it may contain a copy of the tableptr argu-
+        fully relocatable, because it may contain a copy of the tableptr  argu-
         ment, which is an address (see below).
         The options argument contains various bit settings that affect the com-
-        pilation.  It  should be zero if no options are required. The available
+        pilation. It should be zero if no options are required.  The  available
-        options are described below. Some of them (in  particular,  those  that
+        options  are  described  below. Some of them (in particular, those that
-        are  compatible with Perl, but some others as well) can also be set and
+        are compatible with Perl, but some others as well) can also be set  and
-        unset from within the pattern (see  the  detailed  description  in  the
+        unset  from  within  the  pattern  (see the detailed description in the
-        pcrepattern  documentation). For those options that can be different in
+        pcrepattern documentation). For those options that can be different  in
-        different parts of the pattern, the contents of  the  options  argument
+        different  parts  of  the pattern, the contents of the options argument
         specifies their settings at the start of compilation and execution. The
-        PCRE_ANCHORED, PCRE_BSR_xxx, PCRE_NEWLINE_xxx, PCRE_NO_UTF8_CHECK,  and
+        PCRE_ANCHORED,  PCRE_BSR_xxx, PCRE_NEWLINE_xxx, PCRE_NO_UTF8_CHECK, and
-        PCRE_NO_START_OPTIMIZE  options  can  be set at the time of matching as
+        PCRE_NO_START_OPTIMIZE options can be set at the time  of  matching  as
         well as at compile time.
         If errptr is NULL, pcre_compile() returns NULL immediately.  Otherwise,
-        if  compilation  of  a  pattern fails, pcre_compile() returns NULL, and
+        if compilation of a pattern fails,  pcre_compile()  returns  NULL,  and
         sets the variable pointed to by errptr to point to a textual error mes-
         sage. This is a static string that is part of the library. You must not
-        try to free it. Normally, the offset from the start of the  pattern  to
+        try  to  free it. Normally, the offset from the start of the pattern to
         the data unit that was being processed when the error was discovered is
-        placed in the variable pointed to by erroffset, which must not be  NULL
+        placed  in the variable pointed to by erroffset, which must not be NULL
-        (if  it is, an immediate error is given). However, for an invalid UTF-8
+        (if it is, an immediate error is given). However, for an invalid  UTF-8
-        or UTF-16 string, the offset is that of the  first  data  unit  of  the
+        or  UTF-16  string,  the  offset  is that of the first data unit of the
         failing character.
-        Some  errors are not detected until the whole pattern has been scanned;
+        Some errors are not detected until the whole pattern has been  scanned;
-        in these cases, the offset passed back is the length  of  the  pattern.
+        in  these  cases,  the offset passed back is the length of the pattern.
-        Note  that  the  offset is in data units, not characters, even in a UTF
+        Note that the offset is in data units, not characters, even  in  a  UTF
         mode. It may sometimes point into the middle of a UTF-8 or UTF-16 char-
         acter.
-        If  pcre_compile2()  is  used instead of pcre_compile(), and the error-
+        If pcre_compile2() is used instead of pcre_compile(),  and  the  error-
-        codeptr argument is not NULL, a non-zero error code number is  returned
+        codeptr  argument is not NULL, a non-zero error code number is returned
-        via  this argument in the event of an error. This is in addition to the
+        via this argument in the event of an error. This is in addition to  the
         textual error message. Error codes and messages are listed below.
-        If the final argument, tableptr, is NULL, PCRE uses a  default  set  of
+        If  the  final  argument, tableptr, is NULL, PCRE uses a default set of
-        character  tables  that  are  built  when  PCRE  is compiled, using the
+        character tables that are  built  when  PCRE  is  compiled,  using  the
-        default C locale. Otherwise, tableptr must be an address  that  is  the
+        default  C  locale.  Otherwise, tableptr must be an address that is the
-        result  of  a  call to pcre_maketables(). This value is stored with the
+        result of a call to pcre_maketables(). This value is  stored  with  the
-        compiled pattern, and used again by pcre_exec(), unless  another  table
+        compiled  pattern,  and  used  again by pcre_exec() and pcre_dfa_exec()
-        pointer is passed to it. For more discussion, see the section on locale
+        when the pattern is matched. For more discussion, see  the  section  on
-        support below.
+        locale support below.
-        This code fragment shows a typical straightforward  call  to  pcre_com-
+        This  code  fragment  shows a typical straightforward call to pcre_com-
         pile():
           pcre *re;
-Line 2067 
 COMPILING A PATTERN
+Line 2083 
 COMPILING A PATTERN
             &erroffset,       /* for error offset */
             NULL);            /* use default character tables */
-        The  following  names  for option bits are defined in the pcre.h header
+        The following names for option bits are defined in  the  pcre.h  header
         file:
           PCRE_ANCHORED
         If this bit is set, the pattern is forced to be "anchored", that is, it
-        is  constrained to match only at the first matching point in the string
+        is constrained to match only at the first matching point in the  string
-        that is being searched (the "subject string"). This effect can also  be
+        that  is being searched (the "subject string"). This effect can also be
-        achieved  by appropriate constructs in the pattern itself, which is the
+        achieved by appropriate constructs in the pattern itself, which is  the
         only way to do it in Perl.
           PCRE_AUTO_CALLOUT
         If this bit is set, pcre_compile() automatically inserts callout items,
-        all  with  number  255, before each pattern item. For discussion of the
+        all with number 255, before each pattern item. For  discussion  of  the
         callout facility, see the pcrecallout documentation.
           PCRE_BSR_ANYCRLF
           PCRE_BSR_UNICODE
         These options (which are mutually exclusive) control what the \R escape
-        sequence  matches.  The choice is either to match only CR, LF, or CRLF,
+        sequence matches. The choice is either to match only CR, LF,  or  CRLF,
         or to match any Unicode newline sequence. The default is specified when
         PCRE is built. It can be overridden from within the pattern, or by set-
         ting an option when a compiled pattern is matched.
           PCRE_CASELESS
-        If this bit is set, letters in the pattern match both upper  and  lower
+        If  this  bit is set, letters in the pattern match both upper and lower
-        case  letters.  It  is  equivalent  to  Perl's /i option, and it can be
+        case letters. It is equivalent to Perl's  /i  option,  and  it  can  be
-        changed within a pattern by a (?i) option setting. In UTF-8 mode,  PCRE
+        changed  within a pattern by a (?i) option setting. In UTF-8 mode, PCRE
-        always  understands the concept of case for characters whose values are
+        always understands the concept of case for characters whose values  are
-        less than 128, so caseless matching is always possible. For  characters
+        less  than 128, so caseless matching is always possible. For characters
-        with  higher  values,  the concept of case is supported if PCRE is com-
+        with higher values, the concept of case is supported if  PCRE  is  com-
-        piled with Unicode property support, but not otherwise. If you want  to
+        piled  with Unicode property support, but not otherwise. If you want to
-        use  caseless  matching  for  characters 128 and above, you must ensure
+        use caseless matching for characters 128 and  above,  you  must  ensure
-        that PCRE is compiled with Unicode property support  as  well  as  with
+        that  PCRE  is  compiled  with Unicode property support as well as with
         UTF-8 support.
           PCRE_DOLLAR_ENDONLY
-        If  this bit is set, a dollar metacharacter in the pattern matches only
+        If this bit is set, a dollar metacharacter in the pattern matches  only
-        at the end of the subject string. Without this option,  a  dollar  also
+        at  the  end  of the subject string. Without this option, a dollar also
-        matches  immediately before a newline at the end of the string (but not
+        matches immediately before a newline at the end of the string (but  not
-        before any other newlines). The PCRE_DOLLAR_ENDONLY option  is  ignored
+        before  any  other newlines). The PCRE_DOLLAR_ENDONLY option is ignored
-        if  PCRE_MULTILINE  is  set.   There is no equivalent to this option in
+        if PCRE_MULTILINE is set.  There is no equivalent  to  this  option  in
         Perl, and no way to set it within a pattern.
           PCRE_DOTALL
-        If this bit is set, a dot metacharacter in the pattern matches a  char-
+        If  this bit is set, a dot metacharacter in the pattern matches a char-
         acter of any value, including one that indicates a newline. However, it
-        only ever matches one character, even if newlines are  coded  as  CRLF.
+        only  ever  matches  one character, even if newlines are coded as CRLF.
-        Without  this option, a dot does not match when the current position is
+        Without this option, a dot does not match when the current position  is
         at a newline. This option is equivalent to Perl's /s option, and it can
-        be  changed within a pattern by a (?s) option setting. A negative class
+        be changed within a pattern by a (?s) option setting. A negative  class
         such as [^a] always matches newline characters, independent of the set-
         ting of this option.
           PCRE_DUPNAMES
-        If  this  bit is set, names used to identify capturing subpatterns need
+        If this bit is set, names used to identify capturing  subpatterns  need
         not be unique. This can be helpful for certain types of pattern when it
-        is  known  that  only  one instance of the named subpattern can ever be
+        is known that only one instance of the named  subpattern  can  ever  be
-        matched. There are more details of named subpatterns  below;  see  also
+        matched.  There  are  more details of named subpatterns below; see also
         the pcrepattern documentation.
           PCRE_EXTENDED
-        If  this  bit  is  set,  white space data characters in the pattern are
+        If this bit is set, most white space  characters  in  the  pattern  are
-        totally ignored except when escaped or inside a character class.  White
+        totally  ignored  except when escaped or inside a character class. How-
-        space does not include the VT character (code 11). In addition, charac-
+        ever, white space is not allowed within  sequences  such  as  (?>  that
-        ters between an unescaped # outside a character class and the next new-
+        introduce  various  parenthesized  subpatterns,  nor within a numerical
-        line,  inclusive,  are  also  ignored.  This is equivalent to Perl's /x
+        quantifier such as {1,3}.  However, ignorable white space is  permitted
-        option, and it can be changed within a pattern by a  (?x)  option  set-
+        between an item and a following quantifier and between a quantifier and
-        ting.
+        a following + that indicates possessiveness.
-        Which  characters  are  interpreted  as  newlines  is controlled by the
+        White space did not used to include the VT character (code 11), because
-        options passed to pcre_compile() or by a special sequence at the  start
+        Perl did not treat this character as white space. However, Perl changed
-        of  the  pattern, as described in the section entitled "Newline conven-
+        at release 5.18, so PCRE followed  at  release  8.34,  and  VT  is  now
+        treated as white space.
+        PCRE_EXTENDED  also  causes characters between an unescaped # outside a
+        character class  and  the  next  newline,  inclusive,  to  be  ignored.
+        PCRE_EXTENDED  is equivalent to Perl's /x option, and it can be changed
+        within a pattern by a (?x) option setting.
+        Which characters are interpreted  as  newlines  is  controlled  by  the
+        options  passed to pcre_compile() or by a special sequence at the start
+        of the pattern, as described in the section entitled  "Newline  conven-
         tions" in the pcrepattern documentation. Note that the end of this type
-        of  comment  is  a  literal  newline  sequence  in  the pattern; escape
+        of comment is  a  literal  newline  sequence  in  the  pattern;  escape
         sequences that happen to represent a newline do not count.
-        This option makes it possible to include  comments  inside  complicated
+        This  option  makes  it possible to include comments inside complicated
-        patterns.   Note,  however,  that this applies only to data characters.
+        patterns.  Note, however, that this applies only  to  data  characters.
-        White space  characters  may  never  appear  within  special  character
+        White  space  characters  may  never  appear  within  special character
         sequences in a pattern, for example within the sequence (?( that intro-
         duces a conditional subpattern.
           PCRE_EXTRA
-        This option was invented in order to turn on  additional  functionality
+        This  option  was invented in order to turn on additional functionality
-        of  PCRE  that  is  incompatible with Perl, but it is currently of very
+        of PCRE that is incompatible with Perl, but it  is  currently  of  very
-        little use. When set, any backslash in a pattern that is followed by  a
+        little  use. When set, any backslash in a pattern that is followed by a
-        letter  that  has  no  special  meaning causes an error, thus reserving
+        letter that has no special meaning  causes  an  error,  thus  reserving
-        these combinations for future expansion. By  default,  as  in  Perl,  a
+        these  combinations  for  future  expansion.  By default, as in Perl, a
-        backslash  followed by a letter with no special meaning is treated as a
+        backslash followed by a letter with no special meaning is treated as  a
         literal. (Perl can, however, be persuaded to give an error for this, by
-        running  it with the -w option.) There are at present no other features
+        running it with the -w option.) There are at present no other  features
-        controlled by this option. It can also be set by a (?X) option  setting
+        controlled  by this option. It can also be set by a (?X) option setting
         within a pattern.
           PCRE_FIRSTLINE
-        If  this  option  is  set,  an  unanchored pattern is required to match
+        If this option is set, an  unanchored  pattern  is  required  to  match
-        before or at the first  newline  in  the  subject  string,  though  the
+        before  or  at  the  first  newline  in  the subject string, though the
         matched text may continue over the newline.
           PCRE_JAVASCRIPT_COMPAT
         If this option is set, PCRE's behaviour is changed in some ways so that
-        it is compatible with JavaScript rather than Perl. The changes  are  as
+        it  is  compatible with JavaScript rather than Perl. The changes are as
         follows:
-        (1)  A  lone  closing square bracket in a pattern causes a compile-time
+        (1) A lone closing square bracket in a pattern  causes  a  compile-time
-        error, because this is illegal in JavaScript (by default it is  treated
+        error,  because this is illegal in JavaScript (by default it is treated
         as a data character). Thus, the pattern AB]CD becomes illegal when this
         option is set.
-        (2) At run time, a back reference to an unset subpattern group  matches
+        (2)  At run time, a back reference to an unset subpattern group matches
-        an  empty  string (by default this causes the current matching alterna-
+        an empty string (by default this causes the current  matching  alterna-
-        tive to fail). A pattern such as (\1)(a) succeeds when this  option  is
+        tive  to  fail). A pattern such as (\1)(a) succeeds when this option is
-        set  (assuming  it can find an "a" in the subject), whereas it fails by
+        set (assuming it can find an "a" in the subject), whereas it  fails  by
         default, for Perl compatibility.
         (3) \U matches an upper case "U" character; by default \U causes a com-
         pile time error (Perl uses \U to upper case subsequent characters).
         (4) \u matches a lower case "u" character unless it is followed by four
-        hexadecimal digits, in which case the hexadecimal  number  defines  the
+        hexadecimal  digits,  in  which case the hexadecimal number defines the
-        code  point  to match. By default, \u causes a compile time error (Perl
+        code point to match. By default, \u causes a compile time  error  (Perl
         uses it to upper case the following character).
-        (5) \x matches a lower case "x" character unless it is followed by  two
+        (5)  \x matches a lower case "x" character unless it is followed by two
-        hexadecimal  digits,  in  which case the hexadecimal number defines the
+        hexadecimal digits, in which case the hexadecimal  number  defines  the
-        code point to match. By default, as in Perl, a  hexadecimal  number  is
+        code  point  to  match. By default, as in Perl, a hexadecimal number is
         always expected after \x, but it may have zero, one, or two digits (so,
         for example, \xz matches a binary zero character followed by z).
           PCRE_MULTILINE
-        By default, for the purposes of matching "start of line"  and  "end  of
+        By  default,  for  the purposes of matching "start of line" and "end of
         line", PCRE treats the subject string as consisting of a single line of
-        characters, even if it actually contains newlines. The "start of  line"
+        characters,  even if it actually contains newlines. The "start of line"
         metacharacter (^) matches only at the start of the string, and the "end
-        of line" metacharacter ($) matches only at the end of  the  string,  or
+        of  line"  metacharacter  ($) matches only at the end of the string, or
-        before  a terminating newline (except when PCRE_DOLLAR_ENDONLY is set).
+        before a terminating newline (except when PCRE_DOLLAR_ENDONLY is  set).
-        Note, however, that unless PCRE_DOTALL  is  set,  the  "any  character"
+        Note,  however,  that  unless  PCRE_DOTALL  is set, the "any character"
-        metacharacter  (.)  does not match at a newline. This behaviour (for ^,
+        metacharacter (.) does not match at a newline. This behaviour  (for  ^,
         $, and dot) is the same as Perl.
-        When PCRE_MULTILINE it is set, the "start of line" and  "end  of  line"
+        When  PCRE_MULTILINE  it  is set, the "start of line" and "end of line"
-        constructs  match  immediately following or immediately before internal
+        constructs match immediately following or immediately  before  internal
-        newlines in the subject string, respectively, as well as  at  the  very
+        newlines  in  the  subject string, respectively, as well as at the very
-        start  and  end.  This is equivalent to Perl's /m option, and it can be
+        start and end. This is equivalent to Perl's /m option, and  it  can  be
         changed within a pattern by a (?m) option setting. If there are no new-
-        lines  in  a  subject string, or no occurrences of ^ or $ in a pattern,
+        lines in a subject string, or no occurrences of ^ or $  in  a  pattern,
         setting PCRE_MULTILINE has no effect.
           PCRE_NEVER_UTF
         This option locks out interpretation of the pattern as UTF-8 (or UTF-16
-        or  UTF-32  in the 16-bit and 32-bit libraries). In particular, it pre-
+        or UTF-32 in the 16-bit and 32-bit libraries). In particular,  it  pre-
-        vents the creator of the pattern from switching to  UTF  interpretation
+        vents  the  creator of the pattern from switching to UTF interpretation
         by starting the pattern with (*UTF). This may be useful in applications
         that  process  patterns  from  external  sources.  The  combination  of
         PCRE_UTF8 and PCRE_NEVER_UTF also causes an error.
-Line 2242 
 COMPILING A PATTERN
+Line 2268 
 COMPILING A PATTERN
           PCRE_NEWLINE_ANYCRLF
           PCRE_NEWLINE_ANY
-        These  options  override the default newline definition that was chosen
+        These options override the default newline definition that  was  chosen
-        when PCRE was built. Setting the first or the second specifies  that  a
+        when  PCRE  was built. Setting the first or the second specifies that a
-        newline  is  indicated  by a single character (CR or LF, respectively).
+        newline is indicated by a single character (CR  or  LF,  respectively).
-        Setting PCRE_NEWLINE_CRLF specifies that a newline is indicated by  the
+        Setting  PCRE_NEWLINE_CRLF specifies that a newline is indicated by the
-        two-character  CRLF  sequence.  Setting  PCRE_NEWLINE_ANYCRLF specifies
+        two-character CRLF  sequence.  Setting  PCRE_NEWLINE_ANYCRLF  specifies
         that any of the three preceding sequences should be recognized. Setting
-        PCRE_NEWLINE_ANY  specifies that any Unicode newline sequence should be
+        PCRE_NEWLINE_ANY specifies that any Unicode newline sequence should  be
         recognized.
-        In an ASCII/Unicode environment, the Unicode newline sequences are  the
+        In  an ASCII/Unicode environment, the Unicode newline sequences are the
-        three  just  mentioned,  plus  the  single characters VT (vertical tab,
+        three just mentioned, plus the  single  characters  VT  (vertical  tab,
         U+000B), FF (form feed, U+000C), NEL (next line, U+0085), LS (line sep-
-        arator,  U+2028),  and  PS (paragraph separator, U+2029). For the 8-bit
+        arator, U+2028), and PS (paragraph separator, U+2029).  For  the  8-bit
         library, the last two are recognized only in UTF-8 mode.
-        When PCRE is compiled to run in an EBCDIC (mainframe) environment,  the
+        When  PCRE is compiled to run in an EBCDIC (mainframe) environment, the
         code for CR is 0x0d, the same as ASCII. However, the character code for
-        LF is normally 0x15, though in some EBCDIC environments 0x25  is  used.
+        LF  is  normally 0x15, though in some EBCDIC environments 0x25 is used.
-        Whichever  of  these  is  not LF is made to correspond to Unicode's NEL
+        Whichever of these is not LF is made to  correspond  to  Unicode's  NEL
-        character. EBCDIC codes are all less than 256. For  more  details,  see
+        character.  EBCDIC  codes  are all less than 256. For more details, see
         the pcrebuild documentation.
-        The  newline  setting  in  the  options  word  uses three bits that are
+        The newline setting in the  options  word  uses  three  bits  that  are
         treated as a number, giving eight possibilities. Currently only six are
-        used  (default  plus the five values above). This means that if you set
+        used (default plus the five values above). This means that if  you  set
-        more than one newline option, the combination may or may not be  sensi-
+        more  than one newline option, the combination may or may not be sensi-
         ble. For example, PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is equivalent to
-        PCRE_NEWLINE_CRLF, but other combinations may yield unused numbers  and
+        PCRE_NEWLINE_CRLF,  but other combinations may yield unused numbers and
         cause an error.
-        The  only  time  that a line break in a pattern is specially recognized
+        The only time that a line break in a pattern  is  specially  recognized
-        when compiling is when PCRE_EXTENDED is set. CR and LF are white  space
+        when  compiling is when PCRE_EXTENDED is set. CR and LF are white space
-        characters,  and so are ignored in this mode. Also, an unescaped # out-
+        characters, and so are ignored in this mode. Also, an unescaped #  out-
-        side a character class indicates a comment that lasts until  after  the
+        side  a  character class indicates a comment that lasts until after the
-        next  line break sequence. In other circumstances, line break sequences
+        next line break sequence. In other circumstances, line break  sequences
         in patterns are treated as literal data.
         The newline option that is set at compile time becomes the default that
-Line 2285 
 COMPILING A PATTERN
+Line 2311 
 COMPILING A PATTERN
           PCRE_NO_AUTO_CAPTURE
         If this option is set, it disables the use of numbered capturing paren-
-        theses in the pattern. Any opening parenthesis that is not followed  by
+        theses  in the pattern. Any opening parenthesis that is not followed by
-        ?  behaves as if it were followed by ?: but named parentheses can still
+        ? behaves as if it were followed by ?: but named parentheses can  still
-        be used for capturing (and they acquire  numbers  in  the  usual  way).
+        be  used  for  capturing  (and  they acquire numbers in the usual way).
         There is no equivalent of this option in Perl.
+          PCRE_NO_AUTO_POSSESS
+        If this option is set, it disables "auto-possessification". This is  an
+        optimization  that,  for example, turns a+b into a++b in order to avoid
+        backtracks into a+ that can never be successful. However,  if  callouts
+        are  in  use,  auto-possessification  means that some of them are never
+        taken. You can set this option if you want the matching functions to do
+        a  full  unoptimized  search and run all the callouts, but it is mainly
+        provided for testing purposes.
           PCRE_NO_START_OPTIMIZE
-        This  is an option that acts at matching time; that is, it is really an
+        This is an option that acts at matching time; that is, it is really  an
-        option for pcre_exec() or pcre_dfa_exec(). If  it  is  set  at  compile
+        option  for  pcre_exec()  or  pcre_dfa_exec().  If it is set at compile
-        time,  it is remembered with the compiled pattern and assumed at match-
+        time, it is remembered with the compiled pattern and assumed at  match-
-        ing time. This is necessary if you want to use JIT  execution,  because
+        ing  time.  This is necessary if you want to use JIT execution, because
-        the  JIT  compiler needs to know whether or not this option is set. For
+        the JIT compiler needs to know whether or not this option is  set.  For
         details see the discussion of PCRE_NO_START_OPTIMIZE below.
           PCRE_UCP
-        This option changes the way PCRE processes \B, \b, \D, \d, \S, \s,  \W,
+        This  option changes the way PCRE processes \B, \b, \D, \d, \S, \s, \W,
-        \w,  and  some  of  the POSIX character classes. By default, only ASCII
+        \w, and some of the POSIX character classes.  By  default,  only  ASCII
-        characters are recognized, but if PCRE_UCP is set,  Unicode  properties
+        characters  are  recognized, but if PCRE_UCP is set, Unicode properties
-        are  used instead to classify characters. More details are given in the
+        are used instead to classify characters. More details are given in  the
-        section on generic character types in the pcrepattern page. If you  set
+        section  on generic character types in the pcrepattern page. If you set
-        PCRE_UCP,  matching  one of the items it affects takes much longer. The
+        PCRE_UCP, matching one of the items it affects takes much  longer.  The
-        option is available only if PCRE has been compiled with  Unicode  prop-
+        option  is  available only if PCRE has been compiled with Unicode prop-
         erty support.
           PCRE_UNGREEDY
-        This  option  inverts  the "greediness" of the quantifiers so that they
+        This option inverts the "greediness" of the quantifiers  so  that  they
-        are not greedy by default, but become greedy if followed by "?". It  is
+        are  not greedy by default, but become greedy if followed by "?". It is
-        not  compatible  with Perl. It can also be set by a (?U) option setting
+        not compatible with Perl. It can also be set by a (?U)  option  setting
         within the pattern.
           PCRE_UTF8
-        This option causes PCRE to regard both the pattern and the  subject  as
+        This  option  causes PCRE to regard both the pattern and the subject as
         strings of UTF-8 characters instead of single-byte strings. However, it
-        is available only when PCRE is built to include UTF  support.  If  not,
+        is  available  only  when PCRE is built to include UTF support. If not,
-        the  use  of  this option provokes an error. Details of how this option
+        the use of this option provokes an error. Details of  how  this  option
         changes the behaviour of PCRE are given in the pcreunicode page.
           PCRE_NO_UTF8_CHECK
         When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is
-        automatically  checked.  There  is  a  discussion about the validity of
+        automatically checked. There is a  discussion  about  the  validity  of
-        UTF-8 strings in the pcreunicode page. If an invalid UTF-8 sequence  is
+        UTF-8  strings in the pcreunicode page. If an invalid UTF-8 sequence is
-        found,  pcre_compile()  returns an error. If you already know that your
+        found, pcre_compile() returns an error. If you already know  that  your
-        pattern is valid, and you want to skip this check for performance  rea-
+        pattern  is valid, and you want to skip this check for performance rea-
-        sons,  you  can set the PCRE_NO_UTF8_CHECK option.  When it is set, the
+        sons, you can set the PCRE_NO_UTF8_CHECK option.  When it is  set,  the
         effect of passing an invalid UTF-8 string as a pattern is undefined. It
-        may  cause  your  program  to  crash. Note that this option can also be
+        may cause your program to crash or loop. Note that this option can also
-        passed to pcre_exec() and pcre_dfa_exec(),  to  suppress  the  validity
+        be  passed to pcre_exec() and pcre_dfa_exec(), to suppress the validity
-        checking  of  subject strings only. If the same string is being matched
+        checking of subject strings only. If the same string is  being  matched
-        many times, the option can be safely set for the second and  subsequent
+        many  times, the option can be safely set for the second and subsequent
         matchings to improve performance.
  COMPILATION ERROR CODES
-        The  following  table  lists  the  error  codes than may be returned by
+        The following table lists the error  codes  than  may  be  returned  by
-        pcre_compile2(), along with the error messages that may be returned  by
+        pcre_compile2(),  along with the error messages that may be returned by
-        both  compiling  functions.  Note  that error messages are always 8-bit
+        both compiling functions. Note that error  messages  are  always  8-bit
-        ASCII strings, even in 16-bit or 32-bit mode. As  PCRE  has  developed,
+        ASCII  strings,  even  in 16-bit or 32-bit mode. As PCRE has developed,
-        some  error codes have fallen out of use. To avoid confusion, they have
+        some error codes have fallen out of use. To avoid confusion, they  have
         not been re-used.
  no error
-Line 2384 
 COMPILATION ERROR CODES
+Line 2420 
 COMPILATION ERROR CODES
  POSIX collating elements are not supported
  this version of PCRE is compiled without UTF support
  [this code is not in use]
- character value in \x{...} sequence is too large
+ character value in \x{} or \o{} is too large
  invalid condition (?(0)
  \C not allowed in lookbehind assertion
  PCRE does not support \L, \l, \N{name}, \U, or \u
-Line 2432 
 COMPILATION ERROR CODES
+Line 2468 
 COMPILATION ERROR CODES
  name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)
  character value in \u.... sequence is too large
  invalid UTF-32 string (specifically UTF-32)
+ setting UTF is disabled by the application
+ non-hex character in \x{} (closing brace missing?)
+ non-octal character in \o{} (closing brace missing?)
+ missing opening brace after \o
+ parentheses are too deeply nested
+ invalid range in character class
-        The numbers 32 and 10000 in errors 48 and 49  are  defaults;  different
+        The  numbers  32  and 10000 in errors 48 and 49 are defaults; different
         values may be used if the limits were changed when PCRE was built.
-Line 2442 
 STUDYING A PATTERN
+Line 2484 
 STUDYING A PATTERN
         pcre_extra *pcre_study(const pcre *code, int options,
              const char **errptr);
-        If  a  compiled  pattern is going to be used several times, it is worth
+        If a compiled pattern is going to be used several times,  it  is  worth
         spending more time analyzing it in order to speed up the time taken for
-        matching.  The function pcre_study() takes a pointer to a compiled pat-
+        matching. The function pcre_study() takes a pointer to a compiled  pat-
         tern as its first argument. If studying the pattern produces additional
-        information  that  will  help speed up matching, pcre_study() returns a
+        information that will help speed up matching,  pcre_study()  returns  a
-        pointer to a pcre_extra block, in which the study_data field points  to
+        pointer  to a pcre_extra block, in which the study_data field points to
         the results of the study.
         The  returned  value  from  pcre_study()  can  be  passed  directly  to
-        pcre_exec() or pcre_dfa_exec(). However, a pcre_extra block  also  con-
+        pcre_exec()  or  pcre_dfa_exec(). However, a pcre_extra block also con-
-        tains  other  fields  that can be set by the caller before the block is
+        tains other fields that can be set by the caller before  the  block  is
         passed; these are described below in the section on matching a pattern.
-        If studying the  pattern  does  not  produce  any  useful  information,
+        If  studying  the  pattern  does  not  produce  any useful information,
-        pcre_study()  returns  NULL  by  default.  In that circumstance, if the
+        pcre_study() returns NULL by default.  In  that  circumstance,  if  the
         calling program wants to pass any of the other fields to pcre_exec() or
-        pcre_dfa_exec(),  it  must set up its own pcre_extra block. However, if
+        pcre_dfa_exec(), it must set up its own pcre_extra block.  However,  if
-        pcre_study() is called  with  the  PCRE_STUDY_EXTRA_NEEDED  option,  it
+        pcre_study()  is  called  with  the  PCRE_STUDY_EXTRA_NEEDED option, it
         returns a pcre_extra block even if studying did not find any additional
-        information. It may still return NULL, however, if an error  occurs  in
+        information.  It  may still return NULL, however, if an error occurs in
         pcre_study().
-        The  second  argument  of  pcre_study() contains option bits. There are
+        The second argument of pcre_study() contains  option  bits.  There  are
         three further options in addition to PCRE_STUDY_EXTRA_NEEDED:
           PCRE_STUDY_JIT_COMPILE
           PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE
           PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE
-        If any of these are set, and the just-in-time  compiler  is  available,
+        If  any  of  these are set, and the just-in-time compiler is available,
-        the  pattern  is  further compiled into machine code that executes much
+        the pattern is further compiled into machine code  that  executes  much
-        faster than the pcre_exec()  interpretive  matching  function.  If  the
+        faster  than  the  pcre_exec()  interpretive  matching function. If the
-        just-in-time  compiler is not available, these options are ignored. All
+        just-in-time compiler is not available, these options are ignored.  All
         undefined bits in the options argument must be zero.
-        JIT compilation is a heavyweight optimization. It can  take  some  time
+        JIT  compilation  is  a heavyweight optimization. It can take some time
-        for  patterns  to  be analyzed, and for one-off matches and simple pat-
+        for patterns to be analyzed, and for one-off matches  and  simple  pat-
-        terns the benefit of faster execution might be offset by a much  slower
+        terns  the benefit of faster execution might be offset by a much slower
         study time.  Not all patterns can be optimized by the JIT compiler. For
-        those that cannot be handled, matching automatically falls back to  the
+        those  that cannot be handled, matching automatically falls back to the
-        pcre_exec()  interpreter.  For more details, see the pcrejit documenta-
+        pcre_exec() interpreter. For more details, see the  pcrejit  documenta-
         tion.
-        The third argument for pcre_study() is a pointer for an error  message.
+        The  third argument for pcre_study() is a pointer for an error message.
-        If  studying  succeeds  (even  if no data is returned), the variable it
+        If studying succeeds (even if no data is  returned),  the  variable  it
-        points to is set to NULL. Otherwise it is set to  point  to  a  textual
+        points  to  is  set  to NULL. Otherwise it is set to point to a textual
         error message. This is a static string that is part of the library. You
-        must not try to free it. You should test the  error  pointer  for  NULL
+        must  not  try  to  free it. You should test the error pointer for NULL
         after calling pcre_study(), to be sure that it has run successfully.
-        When  you are finished with a pattern, you can free the memory used for
+        When you are finished with a pattern, you can free the memory used  for
         the study data by calling pcre_free_study(). This function was added to
-        the  API  for  release  8.20. For earlier versions, the memory could be
+        the API for release 8.20. For earlier versions,  the  memory  could  be
-        freed with pcre_free(), just like the pattern itself. This  will  still
+        freed  with  pcre_free(), just like the pattern itself. This will still
-        work  in  cases where JIT optimization is not used, but it is advisable
+        work in cases where JIT optimization is not used, but it  is  advisable
         to change to the new function when convenient.
-        This is a typical way in which pcre_study() is used (except that  in  a
+        This  is  a typical way in which pcre_study() is used (except that in a
         real application there should be tests for errors):
           int rc;
-Line 2519 
 STUDYING A PATTERN
+Line 2561 
 STUDYING A PATTERN
         Studying a pattern does two things: first, a lower bound for the length
         of subject string that is needed to match the pattern is computed. This
         does not mean that there are any strings of that length that match, but
-        it does guarantee that no shorter strings match. The value is  used  to
+        it  does  guarantee that no shorter strings match. The value is used to
         avoid wasting time by trying to match strings that are shorter than the
-        lower bound. You can find out the value in a calling  program  via  the
+        lower  bound.  You  can find out the value in a calling program via the
         pcre_fullinfo() function.
         Studying a pattern is also useful for non-anchored patterns that do not
-        have a single fixed starting character. A bitmap of  possible  starting
+        have  a  single fixed starting character. A bitmap of possible starting
-        bytes  is  created. This speeds up finding a position in the subject at
+        bytes is created. This speeds up finding a position in the  subject  at
         which to start matching. (In 16-bit mode, the bitmap is used for 16-bit
-        values  less  than  256.  In 32-bit mode, the bitmap is used for 32-bit
+        values less than 256.  In 32-bit mode, the bitmap is  used  for  32-bit
         values less than 256.)
-        These two optimizations apply to both pcre_exec() and  pcre_dfa_exec(),
+        These  two optimizations apply to both pcre_exec() and pcre_dfa_exec(),
-        and  the  information  is also used by the JIT compiler.  The optimiza-
+        and the information is also used by the JIT  compiler.   The  optimiza-
-        tions can be disabled by  setting  the  PCRE_NO_START_OPTIMIZE  option.
+        tions  can  be  disabled  by setting the PCRE_NO_START_OPTIMIZE option.
-        You  might want to do this if your pattern contains callouts or (*MARK)
+        You might want to do this if your pattern contains callouts or  (*MARK)
-        and you want to make use of these facilities in  cases  where  matching
+        and  you  want  to make use of these facilities in cases where matching
         fails.
-        PCRE_NO_START_OPTIMIZE  can be specified at either compile time or exe-
+        PCRE_NO_START_OPTIMIZE can be specified at either compile time or  exe-
-        cution  time.  However,  if   PCRE_NO_START_OPTIMIZE   is   passed   to
+        cution   time.   However,   if   PCRE_NO_START_OPTIMIZE  is  passed  to
         pcre_exec(), (that is, after any JIT compilation has happened) JIT exe-
-        cution is disabled. For JIT execution to work with  PCRE_NO_START_OPTI-
+        cution  is disabled. For JIT execution to work with PCRE_NO_START_OPTI-
         MIZE, the option must be set at compile time.
         There is a longer discussion of PCRE_NO_START_OPTIMIZE below.
-Line 2549 
 STUDYING A PATTERN
+Line 2591 
 STUDYING A PATTERN
  LOCALE SUPPORT
-        PCRE  handles  caseless matching, and determines whether characters are
+        PCRE handles caseless matching, and determines whether  characters  are
-        letters, digits, or whatever, by reference to a set of tables,  indexed
+        letters,  digits, or whatever, by reference to a set of tables, indexed
-        by  character  value.  When running in UTF-8 mode, this applies only to
+        by character code point. When running in UTF-8 mode, or in the  16-  or
-        characters with codes less than 128. By  default,  higher-valued  codes
+-bit libraries, this applies only to characters with code points less
-        never match escapes such as \w or \d, but they can be tested with \p if
+        than 256. By default, higher-valued code  points  never  match  escapes
-        PCRE is built with Unicode character property  support.  Alternatively,
+        such  as \w or \d. However, if PCRE is built with Unicode property sup-
-        the  PCRE_UCP  option  can  be  set at compile time; this causes \w and
+        port, all characters can be tested with \p and \P,  or,  alternatively,
-        friends to use Unicode property support instead of built-in tables. The
+        the  PCRE_UCP option can be set when a pattern is compiled; this causes
-        use of locales with Unicode is discouraged. If you are handling charac-
+        \w and friends to use Unicode property support instead of the  built-in
-        ters with codes greater than 128, you should either use UTF-8 and  Uni-
+        tables.
-        code, or use locales, but not try to mix the two.
+        The  use  of  locales  with Unicode is discouraged. If you are handling
+        characters with code points greater than 128,  you  should  either  use
+        Unicode support, or use locales, but not try to mix the two.
         PCRE  contains  an  internal set of tables that are used when the final
         argument of pcre_compile() is  NULL.  These  are  sufficient  for  many
-Line 2575 
 LOCALE SUPPORT
+Line 2620 
 LOCALE SUPPORT
         External  tables  are  built by calling the pcre_maketables() function,
         which has no arguments, in the relevant locale. The result can then  be
-        passed  to  pcre_compile()  or  pcre_exec()  as often as necessary. For
+        passed  to  pcre_compile() as often as necessary. For example, to build
-        example, to build and use tables that are appropriate  for  the  French
+        and use tables that  are  appropriate  for  the  French  locale  (where
-        locale  (where  accented  characters  with  values greater than 128 are
+        accented  characters  with  values greater than 128 are treated as let-
-        treated as letters), the following code could be used:
+        ters), the following code could be used:
           setlocale(LC_CTYPE, "fr_FR");
           tables = pcre_maketables();
-Line 2594 
 LOCALE SUPPORT
+Line 2639 
 LOCALE SUPPORT
         The pointer that is passed to pcre_compile() is saved with the compiled
         pattern,  and the same tables are used via this pointer by pcre_study()
-        and normally also by pcre_exec(). Thus, by default, for any single pat-
+        and also by pcre_exec() and pcre_dfa_exec(). Thus, for any single  pat-
         tern, compilation, studying and matching all happen in the same locale,
-        but different patterns can be compiled in different locales.
+        but different patterns can be processed in different locales.
         It is possible to pass a table pointer or NULL (indicating the  use  of
-        the  internal  tables)  to  pcre_exec(). Although not intended for this
+        the internal tables) to pcre_exec() or pcre_dfa_exec() (see the discus-
-        purpose, this facility could be used to match a pattern in a  different
+        sion below in the section on matching a pattern). This facility is pro-
-        locale from the one in which it was compiled. Passing table pointers at
+        vided  for  use  with  pre-compiled  patterns  that have been saved and
-        run time is discussed below in the section on matching a pattern.
+        reloaded.  Character tables are not saved with patterns, so if  a  non-
+        standard table was used at compile time, it must be provided again when
+        the reloaded pattern is matched. Attempting to  use  this  facility  to
+        match a pattern in a different locale from the one in which it was com-
+        piled is likely to lead to anomalous (usually incorrect) results.
  INFORMATION ABOUT A PATTERN
-Line 2743 
 INFORMATION ABOUT A PATTERN
+Line 2792 
 INFORMATION ABOUT A PATTERN
         /^a\dz\d/ the returned value is -1.
         Since for the 32-bit library using the non-UTF-32 mode,  this  function
-        is  unable to return the full 32-bit range of the character, this value
+        is  unable to return the full 32-bit range of characters, this value is
-        is   deprecated;   instead    the    PCRE_INFO_REQUIREDCHARFLAGS    and
+        deprecated;     instead     the     PCRE_INFO_REQUIREDCHARFLAGS     and
         PCRE_INFO_REQUIREDCHAR values should be used.
+          PCRE_INFO_MATCH_EMPTY
+        Return  1  if  the  pattern can match an empty string, otherwise 0. The
+        fourth argument should point to an int variable.
           PCRE_INFO_MATCHLIMIT
-        If  the  pattern  set  a  match  limit by including an item of the form
+        If the pattern set a match limit by  including  an  item  of  the  form
-        (*LIMIT_MATCH=nnnn) at the start, the value  is  returned.  The  fourth
+        (*LIMIT_MATCH=nnnn)  at  the  start,  the value is returned. The fourth
-        argument  should  point to an unsigned 32-bit integer. If no such value
+        argument should point to an unsigned 32-bit integer. If no  such  value
-        has  been  set,  the  call  to  pcre_fullinfo()   returns   the   error
+        has   been   set,   the  call  to  pcre_fullinfo()  returns  the  error
         PCRE_ERROR_UNSET.
           PCRE_INFO_MAXLOOKBEHIND
-        Return  the  number  of  characters  (NB not data units) in the longest
+        Return the number of characters (NB not  data  units)  in  the  longest
-        lookbehind assertion in the pattern. This information  is  useful  when
+        lookbehind  assertion  in  the pattern. This information is useful when
-        doing  multi-segment  matching  using  the partial matching facilities.
+        doing multi-segment matching using  the  partial  matching  facilities.
         Note that the simple assertions \b and \B require a one-character look-
-        behind.  \A  also  registers a one-character lookbehind, though it does
+        behind. \A also registers a one-character lookbehind,  though  it  does
-        not actually inspect the previous character. This is to ensure that  at
+        not  actually inspect the previous character. This is to ensure that at
         least one character from the old segment is retained when a new segment
         is processed. Otherwise, if there are no lookbehinds in the pattern, \A
         might match incorrectly at the start of a new segment.
           PCRE_INFO_MINLENGTH
-        If  the  pattern  was studied and a minimum length for matching subject
+        If the pattern was studied and a minimum length  for  matching  subject
-        strings was computed, its value is  returned.  Otherwise  the  returned
+        strings  was  computed,  its  value is returned. Otherwise the returned
         value is -1. The value is a number of characters, which in UTF mode may
-        be different from the number of data units. The fourth argument  should
+        be  different from the number of data units. The fourth argument should
-        point  to an int variable. A non-negative value is a lower bound to the
+        point to an int variable. A non-negative value is a lower bound to  the
-        length of any matching string. There may not be  any  strings  of  that
+        length  of  any  matching  string. There may not be any strings of that
-        length  that  do actually match, but every string that does match is at
+        length that do actually match, but every string that does match  is  at
         least that long.
           PCRE_INFO_NAMECOUNT
           PCRE_INFO_NAMEENTRYSIZE
           PCRE_INFO_NAMETABLE
-        PCRE supports the use of named as well as numbered capturing  parenthe-
+        PCRE  supports the use of named as well as numbered capturing parenthe-
-        ses.  The names are just an additional way of identifying the parenthe-
+        ses. The names are just an additional way of identifying the  parenthe-
         ses, which still acquire numbers. Several convenience functions such as
-        pcre_get_named_substring()  are  provided  for extracting captured sub-
+        pcre_get_named_substring() are provided for  extracting  captured  sub-
-        strings by name. It is also possible to extract the data  directly,  by
+        strings  by  name. It is also possible to extract the data directly, by
-        first  converting  the  name to a number in order to access the correct
+        first converting the name to a number in order to  access  the  correct
         pointers in the output vector (described with pcre_exec() below). To do
-        the  conversion,  you  need  to  use  the  name-to-number map, which is
+        the conversion, you need  to  use  the  name-to-number  map,  which  is
         described by these three values.
         The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT
         gives the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size
-        of each entry; both of these  return  an  int  value.  The  entry  size
+        of  each  entry;  both  of  these  return  an int value. The entry size
-        depends  on the length of the longest name. PCRE_INFO_NAMETABLE returns
+        depends on the length of the longest name. PCRE_INFO_NAMETABLE  returns
         a pointer to the first entry of the table. This is a pointer to char in
         the 8-bit library, where the first two bytes of each entry are the num-
-        ber of the capturing parenthesis, most significant byte first.  In  the
+        ber  of  the capturing parenthesis, most significant byte first. In the
--bit  library,  the pointer points to 16-bit data units, the first of
+-bit library, the pointer points to 16-bit data units, the  first  of
-        which contains the parenthesis  number.  In  the  32-bit  library,  the
+        which  contains  the  parenthesis  number.  In  the 32-bit library, the
-        pointer  points  to  32-bit data units, the first of which contains the
+        pointer points to 32-bit data units, the first of  which  contains  the
-        parenthesis number. The rest of the entry is  the  corresponding  name,
+        parenthesis  number.  The  rest of the entry is the corresponding name,
         zero terminated.
-        The  names are in alphabetical order. Duplicate names may appear if (?|
+        The names are in alphabetical order. If (?| is used to create  multiple
-        is used to create multiple groups with the same number, as described in
+        groups  with  the same number, as described in the section on duplicate
-        the  section  on  duplicate subpattern numbers in the pcrepattern page.
+        subpattern numbers in the pcrepattern page, the groups may be given the
-        Duplicate names for subpatterns with different  numbers  are  permitted
+        same  name,  but  there is only one entry in the table. Different names
-        only  if  PCRE_DUPNAMES  is  set. In all cases of duplicate names, they
+        for groups of the same number are not permitted.  Duplicate  names  for
-        appear in the table in the order in which they were found in  the  pat-
+        subpatterns with different numbers are permitted, but only if PCRE_DUP-
-        tern.  In  the  absence  of (?| this is the order of increasing number;
+        NAMES is set. They appear in the table in the order in which they  were
-        when (?| is used this is not necessarily the case because later subpat-
+        found  in  the  pattern.  In  the  absence  of (?| this is the order of
-        terns may have lower numbers.
+        increasing number; when (?| is used this is not  necessarily  the  case
+        because later subpatterns may have lower numbers.
         As  a  simple  example of the name/number table, consider the following
         pattern after compilation by the 8-bit library (assume PCRE_EXTENDED is
-Line 2923 
 INFORMATION ABOUT A PATTERN
+Line 2978 
 INFORMATION ABOUT A PATTERN
           PCRE_INFO_FIRSTCHARACTER
-        Return  the  fixed  first character value, if PCRE_INFO_FIRSTCHARACTER-
+        Return   the  fixed  first  character  value  in  the  situation  where
-        FLAGS returned 1; otherwise returns 0. The fourth argument should point
+        PCRE_INFO_FIRSTCHARACTERFLAGS returns 1; otherwise return 0. The fourth
-        to an uint_t variable.
+        argument should point to an uint_t variable.
         In  the 8-bit library, the value is always less than 256. In the 16-bit
         library the value can be up to 0xffff. In the 32-bit library in  UTF-32
         mode  the  value  can  be up to 0x10ffff, and up to 0xffffffff when not
         using UTF-32 mode.
-        If there is no fixed first value, and if either
-        (a) the pattern was compiled with the PCRE_MULTILINE option, and  every
-        branch starts with "^", or
-        (b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not
-        set (if it were set, the pattern would be anchored),
-        -1 is returned, indicating that the pattern matches only at  the  start
-        of  a  subject string or after any newline within the string. Otherwise
-        -2 is returned. For anchored patterns, -2 is returned.
           PCRE_INFO_REQUIREDCHARFLAGS
         Returns 1 if there is a rightmost literal data unit that must exist  in
-Line 3132 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 3175 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
         The callout_data field is used in conjunction with the  "callout"  fea-
         ture, and is described in the pcrecallout documentation.
-        The  tables  field  is  used  to  pass  a  character  tables pointer to
+        The  tables field is provided for use with patterns that have been pre-
-        pcre_exec(); this overrides the value that is stored with the  compiled
+        compiled using custom character tables, saved to disc or elsewhere, and
-        pattern.  A  non-NULL value is stored with the compiled pattern only if
+        then  reloaded,  because the tables that were used to compile a pattern
-        custom tables were supplied to pcre_compile() via  its  tableptr  argu-
+        are not saved with it. See the pcreprecompile documentation for a  dis-
-        ment.  If NULL is passed to pcre_exec() using this mechanism, it forces
+        cussion  of  saving  compiled patterns for later use. If NULL is passed
-        PCRE's internal tables to be used. This facility is  helpful  when  re-
+        using this mechanism, it forces PCRE's internal tables to be used.
-        using  patterns  that  have been saved after compiling with an external
-        set of tables, because the external tables  might  be  at  a  different
+        Warning: The tables that pcre_exec() uses must be  the  same  as  those
-        address  when  pcre_exec() is called. See the pcreprecompile documenta-
+        that  were used when the pattern was compiled. If this is not the case,
-        tion for a discussion of saving compiled patterns for later use.
+        the behaviour of pcre_exec() is undefined. Therefore, when a pattern is
+        compiled  and  matched  in the same process, this field should never be
+        set. In this (the most common) case, the correct table pointer is auto-
+        matically  passed  with  the  compiled  pattern  from pcre_compile() to
+        pcre_exec().
         If PCRE_EXTRA_MARK is set in the flags field, the mark  field  must  be
         set  to point to a suitable variable. If the pattern contains any back-
-Line 3350 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 3397 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
         points  to  the  start of a character (or the end of the subject). When
         PCRE_NO_UTF8_CHECK is set, the effect of passing an invalid string as a
         subject  or  an invalid value of startoffset is undefined. Your program
-        may crash.
+        may crash or loop.
           PCRE_PARTIAL_HARD
           PCRE_PARTIAL_SOFT
-Line 4130 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 4177 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
         filled  with  the  longest matches. Unlike pcre_exec(), pcre_dfa_exec()
         can use the entire ovector for returning matched strings.
+        NOTE: PCRE's "auto-possessification" optimization  usually  applies  to
+        character  repeats at the end of a pattern (as well as internally). For
+        example, 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  possi-
+        ble  match  is  found.  If  you really do want multiple matches in such
+        cases,  either  use  an  ungreedy   repeat   ("a\d+?")   or   set   the
+        PCRE_NO_AUTO_POSSESS option when compiling.
     Error returns from pcre_dfa_exec()
-        The pcre_dfa_exec() function returns a negative number when  it  fails.
+        The  pcre_dfa_exec()  function returns a negative number when it fails.
-        Many  of  the  errors  are  the  same as for pcre_exec(), and these are
+        Many of the errors are the same  as  for  pcre_exec(),  and  these  are
-        described above.  There are in addition the following errors  that  are
+        described  above.   There are in addition the following errors that are
         specific to pcre_dfa_exec():
           PCRE_ERROR_DFA_UITEM      (-16)
-        This  return is given if pcre_dfa_exec() encounters an item in the pat-
+        This return is given if pcre_dfa_exec() encounters an item in the  pat-
-        tern that it does not support, for instance, the use of \C  or  a  back
+        tern  that  it  does not support, for instance, the use of \C or a back
         reference.
           PCRE_ERROR_DFA_UCOND      (-17)
-        This  return  is  given  if pcre_dfa_exec() encounters a condition item
+        This return is given if pcre_dfa_exec()  encounters  a  condition  item
-        that uses a back reference for the condition, or a test  for  recursion
+        that  uses  a back reference for the condition, or a test for recursion
         in a specific group. These are not supported.
           PCRE_ERROR_DFA_UMLIMIT    (-18)
-        This  return  is given if pcre_dfa_exec() is called with an extra block
+        This return is given if pcre_dfa_exec() is called with an  extra  block
-        that contains a setting of  the  match_limit  or  match_limit_recursion
+        that  contains  a  setting  of the match_limit or match_limit_recursion
-        fields.  This  is  not  supported (these fields are meaningless for DFA
+        fields. This is not supported (these fields  are  meaningless  for  DFA
         matching).
           PCRE_ERROR_DFA_WSSIZE     (-19)
-        This return is given if  pcre_dfa_exec()  runs  out  of  space  in  the
+        This  return  is  given  if  pcre_dfa_exec()  runs  out of space in the
         workspace vector.
           PCRE_ERROR_DFA_RECURSE    (-20)
-        When  a  recursive subpattern is processed, the matching function calls
+        When a recursive subpattern is processed, the matching  function  calls
-        itself recursively, using private vectors for  ovector  and  workspace.
+        itself  recursively,  using  private vectors for ovector and workspace.
-        This  error  is  given  if  the output vector is not large enough. This
+        This error is given if the output vector  is  not  large  enough.  This
         should be extremely rare, as a vector of size 1000 is used.
           PCRE_ERROR_DFA_BADRESTART (-30)
-        When pcre_dfa_exec() is called with the PCRE_DFA_RESTART  option,  some
+        When  pcre_dfa_exec()  is called with the PCRE_DFA_RESTART option, some
-        plausibility  checks  are  made on the contents of the workspace, which
+        plausibility checks are made on the contents of  the  workspace,  which
-        should contain data about the previous partial match. If any  of  these
+        should  contain  data about the previous partial match. If any of these
         checks fail, this error is given.
  SEE ALSO
-        pcre16(3),   pcre32(3),  pcrebuild(3),  pcrecallout(3),  pcrecpp(3)(3),
+        pcre16(3),  pcre32(3),  pcrebuild(3),  pcrecallout(3),   pcrecpp(3)(3),
         pcrematching(3), pcrepartial(3), pcreposix(3), pcreprecompile(3), pcre-
         sample(3), pcrestack(3).
-Line 4192 
 AUTHOR
+Line 4248 
 AUTHOR
  REVISION
-        Last updated: 12 June 2013
+        Last updated: 12 November 2013
         Copyright (c) 1997-2013 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECALLOUT(3)             Library Functions Manual             PCRECALLOUT(3)
-Line 4255 
 DESCRIPTION
+Line 4311 
 DESCRIPTION
         independent groups).
         Automatic callouts can be used for tracking  the  progress  of  pattern
-        matching.  The pcretest command has an option that sets automatic call-
+        matching.   The pcretest program has a pattern qualifier (/C) that sets
-        outs; when it is used, the output indicates how the pattern is matched.
+        automatic callouts; when it is used, the output indicates how the  pat-
-        This  is useful information when you are trying to optimize the perfor-
+        tern  is  being matched. This is useful information when you are trying
-        mance of a particular pattern.
+        to optimize the performance of a particular pattern.
  MISSING CALLOUTS
-        You should be aware that, because of  optimizations  in  the  way  PCRE
+        You should be aware that, because of optimizations in the way PCRE com-
-        matches  patterns  by  default,  callouts  sometimes do not happen. For
+        piles and matches patterns, callouts sometimes do not happen exactly as
-        example, if the pattern is
+        you might expect.
+        At compile time, PCRE "auto-possessifies" repeated items when it  knows
+        that  what follows cannot be part of the repeat. For example, a+[bc] is
+        compiled as if it were a++[bc]. The pcretest output when  this  pattern
+        is  anchored  and  then  applied  with automatic callouts to the string
+        "aaaa" is:
+          --->aaaa
+           +0 ^        ^
+           +1 ^        a+
+           +3 ^   ^    [bc]
+          No match
+        This indicates that when matching [bc] fails, there is no  backtracking
+        into  a+  and  therefore the callouts that would be taken for the back-
+        tracks do not occur.  You can disable the  auto-possessify  feature  by
+        passing PCRE_NO_AUTO_POSSESS to pcre_compile(), or starting the pattern
+        with (*NO_AUTO_POSSESS). If this is done  in  pcretest  (using  the  /O
+        qualifier), the output changes to this:
+          --->aaaa
+           +0 ^        ^
+           +1 ^        a+
+           +3 ^   ^    [bc]
+           +3 ^  ^     [bc]
+           +3 ^ ^      [bc]
+           +3 ^^       [bc]
+          No match
+        This time, when matching [bc] fails, the matcher backtracks into a+ and
+        tries again, repeatedly, until a+ itself fails.
+        Other optimizations that provide fast "no match"  results  also  affect
+        callouts.  For example, if the pattern is
           ab(?C4)cd
         PCRE knows that any matching string must contain the letter "d". If the
-        subject  string  is "abyz", the lack of "d" means that matching doesn't
+        subject string is "abyz", the lack of "d" means that  matching  doesn't
-        ever start, and the callout is never  reached.  However,  with  "abyd",
+        ever  start,  and  the  callout is never reached. However, with "abyd",
         though the result is still no match, the callout is obeyed.
-        If  the pattern is studied, PCRE knows the minimum length of a matching
+        If the pattern is studied, PCRE knows the minimum length of a  matching
-        string, and will immediately give a "no match" return without  actually
+        string,  and will immediately give a "no match" return without actually
-        running  a  match if the subject is not long enough, or, for unanchored
+        running a match if the subject is not long enough, or,  for  unanchored
         patterns, if it has been scanned far enough.
-        You can disable these optimizations by passing the  PCRE_NO_START_OPTI-
+        You  can disable these optimizations by passing the PCRE_NO_START_OPTI-
-        MIZE  option  to the matching function, or by starting the pattern with
+        MIZE option to the matching function, or by starting the  pattern  with
-        (*NO_START_OPT). This slows down the matching process, but does  ensure
+        (*NO_START_OPT).  This slows down the matching process, but does ensure
         that callouts such as the example above are obeyed.
  THE CALLOUT INTERFACE
-        During  matching, when PCRE reaches a callout point, the external func-
+        During matching, when PCRE reaches a callout point, the external  func-
         tion defined by pcre_callout or pcre[16|32]_callout is called (if it is
-        set).  This  applies to both normal and DFA matching. The only argument
+        set). This applies to both normal and DFA matching. The  only  argument
-        to  the  callout  function  is  a  pointer   to   a   pcre_callout   or
+        to   the   callout   function   is  a  pointer  to  a  pcre_callout  or
-        pcre[16|32]_callout  block.   These  structures  contains the following
+        pcre[16|32]_callout block.  These  structures  contains  the  following
         fields:
           int           version;
-Line 4312 
 THE CALLOUT INTERFACE
+Line 4402 
 THE CALLOUT INTERFACE
           const PCRE_UCHAR16  *mark;       (16-bit version)
           const PCRE_UCHAR32  *mark;       (32-bit version)
-        The version field is an integer containing the version  number  of  the
+        The  version  field  is an integer containing the version number of the
-        block  format. The initial version was 0; the current version is 2. The
+        block format. The initial version was 0; the current version is 2.  The
-        version number will change again in future  if  additional  fields  are
+        version  number  will  change  again in future if additional fields are
         added, but the intention is never to remove any of the existing fields.
-        The  callout_number  field  contains the number of the callout, as com-
+        The callout_number field contains the number of the  callout,  as  com-
-        piled into the pattern (that is, the number after ?C for  manual  call-
+        piled  into  the pattern (that is, the number after ?C for manual call-
         outs, and 255 for automatically generated callouts).
-        The  offset_vector field is a pointer to the vector of offsets that was
+        The offset_vector field is a pointer to the vector of offsets that  was
-        passed by the caller to the  matching  function.  When  pcre_exec()  or
+        passed  by  the  caller  to  the matching function. When pcre_exec() or
-        pcre[16|32]_exec()  is used, the contents can be inspected, in order to
+        pcre[16|32]_exec() is used, the contents can be inspected, in order  to
-        extract substrings that have been matched so far, in the  same  way  as
+        extract  substrings  that  have been matched so far, in the same way as
-        for  extracting  substrings  after  a  match has completed. For the DFA
+        for extracting substrings after a match  has  completed.  For  the  DFA
         matching functions, this field is not useful.
         The subject and subject_length fields contain copies of the values that
         were passed to the matching function.
-        The  start_match  field normally contains the offset within the subject
+        The start_match field normally contains the offset within  the  subject
-        at which the current match attempt  started.  However,  if  the  escape
+        at  which  the  current  match  attempt started. However, if the escape
-        sequence  \K has been encountered, this value is changed to reflect the
+        sequence \K has been encountered, this value is changed to reflect  the
-        modified starting point. If the pattern is not  anchored,  the  callout
+        modified  starting  point.  If the pattern is not anchored, the callout
         function may be called several times from the same point in the pattern
         for different starting points in the subject.
-        The current_position field contains the offset within  the  subject  of
+        The  current_position  field  contains the offset within the subject of
         the current match pointer.
-        When  the  pcre_exec()  or  pcre[16|32]_exec() is used, the capture_top
+        When the pcre_exec() or pcre[16|32]_exec()  is  used,  the  capture_top
-        field contains one more than the number of the  highest  numbered  cap-
+        field  contains  one  more than the number of the highest numbered cap-
-        tured  substring so far. If no substrings have been captured, the value
+        tured substring so far. If no substrings have been captured, the  value
-        of capture_top is one. This is always the case when the  DFA  functions
+        of  capture_top  is one. This is always the case when the DFA functions
         are used, because they do not support captured substrings.
-        The  capture_last  field  contains the number of the most recently cap-
+        The capture_last field contains the number of the  most  recently  cap-
-        tured substring. However, when a recursion exits, the value reverts  to
+        tured  substring. However, when a recursion exits, the value reverts to
-        what  it  was  outside  the recursion, as do the values of all captured
+        what it was outside the recursion, as do the  values  of  all  captured
-        substrings. If no substrings have been  captured,  the  value  of  cap-
+        substrings.  If  no  substrings  have  been captured, the value of cap-
-        ture_last  is  -1.  This  is always the case for the DFA matching func-
+        ture_last is -1. This is always the case for  the  DFA  matching  func-
         tions.
-        The callout_data field contains a value that is passed  to  a  matching
+        The  callout_data  field  contains a value that is passed to a matching
-        function  specifically so that it can be passed back in callouts. It is
+        function specifically so that it can be passed back in callouts. It  is
-        passed in the callout_data field of a pcre_extra  or  pcre[16|32]_extra
+        passed  in  the callout_data field of a pcre_extra or pcre[16|32]_extra
-        data  structure.  If no such data was passed, the value of callout_data
+        data structure. If no such data was passed, the value  of  callout_data
-        in a callout block is NULL. There is a description  of  the  pcre_extra
+        in  a  callout  block is NULL. There is a description of the pcre_extra
         structure in the pcreapi documentation.
-        The  pattern_position  field  is  present from version 1 of the callout
+        The pattern_position field is present from version  1  of  the  callout
         structure. It contains the offset to the next item to be matched in the
         pattern string.
-        The  next_item_length  field  is  present from version 1 of the callout
+        The next_item_length field is present from version  1  of  the  callout
         structure. It contains the length of the next item to be matched in the
-        pattern  string.  When  the callout immediately precedes an alternation
+        pattern string. When the callout immediately  precedes  an  alternation
-        bar, a closing parenthesis, or the end of the pattern,  the  length  is
+        bar,  a  closing  parenthesis, or the end of the pattern, the length is
-        zero.  When  the callout precedes an opening parenthesis, the length is
+        zero. When the callout precedes an opening parenthesis, the  length  is
         that of the entire subpattern.
-        The pattern_position and next_item_length fields are intended  to  help
+        The  pattern_position  and next_item_length fields are intended to help
-        in  distinguishing between different automatic callouts, which all have
+        in distinguishing between different automatic callouts, which all  have
         the same callout number. However, they are set for all callouts.
-        The mark field is present from version 2 of the callout  structure.  In
+        The  mark  field is present from version 2 of the callout structure. In
-        callouts  from  pcre_exec() or pcre[16|32]_exec() it contains a pointer
+        callouts from pcre_exec() or pcre[16|32]_exec() it contains  a  pointer
-        to the zero-terminated  name  of  the  most  recently  passed  (*MARK),
+        to  the  zero-terminated  name  of  the  most  recently passed (*MARK),
-        (*PRUNE),  or  (*THEN) item in the match, or NULL if no such items have
+        (*PRUNE), or (*THEN) item in the match, or NULL if no such  items  have
-        been passed. Instances of (*PRUNE) or (*THEN) without  a  name  do  not
+        been  passed.  Instances  of  (*PRUNE) or (*THEN) without a name do not
-        obliterate  a previous (*MARK). In callouts from the DFA matching func-
+        obliterate a previous (*MARK). In callouts from the DFA matching  func-
         tions this field always contains NULL.
  RETURN VALUES
-        The external callout function returns an integer to PCRE. If the  value
+        The  external callout function returns an integer to PCRE. If the value
-        is  zero,  matching  proceeds  as  normal. If the value is greater than
+        is zero, matching proceeds as normal. If  the  value  is  greater  than
-        zero, matching fails at the current point, but  the  testing  of  other
+        zero,  matching  fails  at  the current point, but the testing of other
         matching possibilities goes ahead, just as if a lookahead assertion had
-        failed. If the value is less than zero, the  match  is  abandoned,  the
+        failed.  If  the  value  is less than zero, the match is abandoned, the
         matching function returns the negative value.
-        Negative   values   should   normally   be   chosen  from  the  set  of
+        Negative  values  should  normally  be   chosen   from   the   set   of
         PCRE_ERROR_xxx values. In particular, PCRE_ERROR_NOMATCH forces a stan-
-        dard  "no  match"  failure.   The  error  number  PCRE_ERROR_CALLOUT is
+        dard "no  match"  failure.   The  error  number  PCRE_ERROR_CALLOUT  is
-        reserved for use by callout functions; it will never be  used  by  PCRE
+        reserved  for  use  by callout functions; it will never be used by PCRE
         itself.
-Line 4410 
 AUTHOR
+Line 4500 
 AUTHOR
  REVISION
-        Last updated: 03 March 2013
+        Last updated: 12 November 2013
         Copyright (c) 1997-2013 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECOMPAT(3)              Library Functions Manual              PCRECOMPAT(3)
-Line 4532 
 DIFFERENCES BETWEEN PCRE AND PERL
+Line 4622 
 DIFFERENCES BETWEEN PCRE AND PERL
 . Perl recognizes comments in some places that  PCRE  does  not,  for
         example,  between  the  ( and ? at the start of a subpattern. If the /x
-        modifier is set, Perl allows white space between ( and ? but PCRE never
+        modifier is set, Perl allows white space between ( and ?  (though  cur-
-        does, even if the PCRE_EXTENDED option is set.
+        rent  Perls  warn that this is deprecated) but PCRE never does, even if
+        the PCRE_EXTENDED option is set.
+. Perl, when in warning mode, gives warnings  for  character  classes
+        such  as  [A-\d] or [a-[:digit:]]. It then treats the hyphens as liter-
+        als. PCRE has no warning features, so it gives an error in these  cases
+        because they are almost certainly user mistakes.
 .  In  PCRE,  the upper/lower case character properties Lu and Ll are
         not affected when case-independent matching is specified. For  example,
         \p{Lu} always matches an upper case letter. I think Perl has changed in
         this respect; in the release at the time of writing (5.16), \p{Lu}  and
         \p{Ll} match all letters, regardless of case, when case independence is
         specified.
 . PCRE provides some extensions to the Perl regular expression facil-
         ities.   Perl  5.10  includes new features that are not in earlier ver-
         sions of Perl, some of which (such as named parentheses) have  been  in
         PCRE for some time. This list is with respect to Perl 5.10:
-Line 4599 
 AUTHOR
+Line 4695 
 AUTHOR
  REVISION
-        Last updated: 19 March 2013
+        Last updated: 10 November 2013
         Copyright (c) 1997-2013 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPATTERN(3)             Library Functions Manual             PCREPATTERN(3)
-Line 4678 
 SPECIAL START-OF-PATTERN ITEMS
+Line 4774 
 SPECIAL START-OF-PATTERN ITEMS
     Unicode property support
-        Another special sequence that may appear at the start of a pattern is
+        Another special sequence that may appear at the start of a  pattern  is
+        (*UCP).   This  has  the same effect as setting the PCRE_UCP option: it
-          (*UCP)
+        causes sequences such as \d and \w to use Unicode properties to  deter-
+        mine character types, instead of recognizing only characters with codes
-        This has the same effect as setting  the  PCRE_UCP  option:  it  causes
+        less than 128 via a lookup table.
-        sequences  such  as  \d  and  \w to use Unicode properties to determine
-        character types, instead of recognizing only characters with codes less
+    Disabling auto-possessification
-        than 128 via a lookup table.
+        If a pattern starts with (*NO_AUTO_POSSESS), it has the same effect  as
+        setting  the  PCRE_NO_AUTO_POSSESS  option  at compile time. This stops
+        PCRE 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 pcreapi documentation.
     Disabling start-up optimizations
-        If  a  pattern  starts  with (*NO_START_OPT), it has the same effect as
+        If a pattern starts with (*NO_START_OPT), it has  the  same  effect  as
         setting the PCRE_NO_START_OPTIMIZE option either at compile or matching
-        time.
+        time. This disables several  optimizations  for  quickly  reaching  "no
+        match" results. For more details, see the pcreapi documentation.
     Newline conventions
-Line 4745 
 SPECIAL START-OF-PATTERN ITEMS
+Line 4847 
 SPECIAL START-OF-PATTERN ITEMS
           (*LIMIT_RECURSION=d)
         where d is any number of decimal digits. However, the value of the set-
-        ting must be less than the value set by the caller of  pcre_exec()  for
+        ting must be less than the value set (or defaulted) by  the  caller  of
-        it to have any effect. In other words, the pattern writer can lower the
+        pcre_exec()  for  it  to  have  any effect. In other words, the pattern
-        limit set by the programmer, but not raise it. If there  is  more  than
+        writer can lower the limits set by the programmer, but not raise  them.
-        one setting of one of these limits, the lower value is used.
+        If  there  is  more  than one setting of one of these limits, the lower
+        value is used.
  EBCDIC CHARACTER CODES
-        PCRE  can  be compiled to run in an environment that uses EBCDIC as its
+        PCRE can be compiled to run in an environment that uses EBCDIC  as  its
         character code rather than ASCII or Unicode (typically a mainframe sys-
-        tem).  In  the  sections below, character code values are ASCII or Uni-
+        tem). In the sections below, character code values are  ASCII  or  Uni-
         code; 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
+        A regular expression is a pattern that is  matched  against  a  subject
-        string from left to right. Most characters stand for  themselves  in  a
+        string  from  left  to right. Most characters stand for themselves in a
-        pattern,  and  match  the corresponding characters in the subject. As 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 PCRE_CASELESS option), letters are
+        caseless matching is specified (the PCRE_CASELESS option), letters  are
-        matched independently of case. In a UTF mode, PCRE  always  understands
+        matched  independently  of case. In a UTF mode, PCRE always understands
-        the  concept  of case for characters whose values are less than 128, so
+        the concept of case for characters whose values are less than  128,  so
-        caseless matching is always possible. For characters with  higher  val-
+        caseless  matching  is always possible. For characters with higher val-
-        ues,  the concept of case is supported if PCRE is compiled with Unicode
+        ues, the concept of case is supported if PCRE is compiled with  Unicode
-        property support, but not otherwise.   If  you  want  to  use  caseless
+        property  support,  but  not  otherwise.   If  you want to use caseless
-        matching  for  characters  128  and above, you must ensure that PCRE is
+        matching for characters 128 and above, you must  ensure  that  PCRE  is
         compiled with Unicode property support as well as with UTF support.
-        The power of regular expressions comes  from  the  ability  to  include
+        The  power  of  regular  expressions  comes from the ability to include
-        alternatives  and  repetitions in the pattern. These are encoded in the
+        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 recog-
+        There are two different sets of metacharacters: those that  are  recog-
-        nized anywhere in the pattern except within square brackets, and  those
+        nized  anywhere in the pattern except within square brackets, and those
-        that  are  recognized  within square brackets. Outside square brackets,
+        that are recognized within square brackets.  Outside  square  brackets,
         the metacharacters are as follows:
           \      general escape character with several uses
-Line 4805 
 CHARACTERS AND METACHARACTERS
+Line 4908 
 CHARACTERS AND METACHARACTERS
                  also "possessive quantifier"
           {      start min/max quantifier
-        Part of a pattern that is in square brackets  is  called  a  "character
+        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
-Line 4822 
 BACKSLASH
+Line 4925 
 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
+        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
+        For  example,  if  you want to match a * character, you write \* in the
-        pattern.   This  escaping  action  applies whether or not the following
+        pattern.  This escaping action applies whether  or  not  the  following
-        character would otherwise be interpreted as a metacharacter, so  it  is
+        character  would  otherwise be interpreted as a metacharacter, so it is
-        always  safe  to  precede  a non-alphanumeric with backslash to specify
+        always safe to precede a non-alphanumeric  with  backslash  to  specify
-        that it stands for itself. In particular, if you want to match a  back-
+        that  it stands for itself. In particular, if you want to match a back-
         slash, you write \\.
-        In  a UTF mode, only ASCII numbers and letters have any special meaning
+        In a UTF mode, only ASCII numbers and letters have any special  meaning
-        after a backslash. All other characters  (in  particular,  those  whose
+        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 PCRE_EXTENDED option, white space in
+        If a pattern is compiled with  the  PCRE_EXTENDED  option,  most  white
-        the pattern (other than in a character class) and characters between  a
+        space  in the pattern (other than in a character class), and characters
-        # outside a character class and the next newline are ignored. An escap-
+        between a # outside a character class and the next newline,  inclusive,
-        ing backslash can be used to include a white space or  #  character  as
+        are ignored. An escaping backslash can be used to include a white space
-        part of the pattern.
+        or # character as part of the pattern.
-        If  you  want  to remove the special meaning from a sequence of charac-
+        If you want to remove the special meaning from a  sequence  of  charac-
-        ters, you can do so by putting them between \Q and \E. This is  differ-
+        ters,  you can do so by putting them between \Q and \E. This is differ-
-        ent  from  Perl  in  that  $  and  @ are handled as literals in \Q...\E
+        ent from Perl in that $ and  @  are  handled  as  literals  in  \Q...\E
-        sequences in PCRE, whereas in Perl, $ and @ cause  variable  interpola-
+        sequences  in  PCRE, whereas in Perl, $ and @ cause variable interpola-
         tion. Note the following examples:
           Pattern            PCRE matches   Perl matches
-Line 4855 
 BACKSLASH
+Line 4958 
 BACKSLASH
           \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
+        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
+        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
+        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
+        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
+        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 char-
-        acters  in patterns in a visible manner. There is no restriction on the
+        acters in patterns in a visible manner. There is no restriction on  the
-        appearance of non-printing characters, apart from the binary zero  that
+        appearance  of non-printing characters, apart from the binary zero that
-        terminates  a  pattern,  but  when  a pattern is being prepared by text
+        terminates a pattern, but when a pattern  is  being  prepared  by  text
-        editing, it is  often  easier  to  use  one  of  the  following  escape
+        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)
-Line 4878 
 BACKSLASH
+Line 4981 
 BACKSLASH
           \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.. (non-JavaScript mode)
           \uhhhh    character with hex code hhhh (JavaScript mode only)
-        The  precise effect of \cx on ASCII characters is as follows: if x is a
+        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
+        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
+        (A  is  41, Z is 5A), but \c{ becomes hex 3B ({ is 7B), and \c; becomes
-        hex  7B (; is 3B). If the data item (byte or 16-bit value) following \c
+        hex 7B (; is 3B). If the data item (byte or 16-bit value) following  \c
-        has a value greater than 127, a compile-time error occurs.  This  locks
+        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 \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
+        the  extension  to  Unicode it is even less useful than it once was. It
-        is,  however,  recognized  when  PCRE is compiled in EBCDIC mode, where
+        is, however, recognized when PCRE is compiled  in  EBCDIC  mode,  where
-        data items are always bytes. In this mode, all values are  valid  after
+        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
+        \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
+        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
+        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
+        are  disjoint,  \cZ becomes hex 29 (Z is E9), and other characters also
         generate different values.
-        By  default,  after  \x,  from  zero to two hexadecimal digits are read
+        After \0 up to two further octal digits are read. If  there  are  fewer
-        (letters can be in upper or lower case). Any number of hexadecimal dig-
+        than  two  digits,  just  those  that  are  present  are used. Thus the
-        its may appear between \x{ and }, but the character code is constrained
-        as follows:
--bit non-UTF mode    less than 0x100
--bit UTF-8 mode      less than 0x10ffff and a valid codepoint
--bit non-UTF mode   less than 0x10000
--bit UTF-16 mode    less than 0x10ffff and a valid codepoint
--bit non-UTF mode   less than 0x80000000
--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.
-        If  characters  other than hexadecimal digits appear between \x{ and },
-        or if there is no terminating }, this form of escape is not recognized.
-        Instead,  the  initial  \x  will  be interpreted as a basic hexadecimal
-        escape, with no following digits, giving a  character  whose  value  is
-        zero.
-        If  the  PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \x
-        is as just described only when it is followed by two  hexadecimal  dig-
-        its.   Otherwise,  it  matches  a  literal "x" character. In JavaScript
-        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.  Character codes specified by \u  in  JavaScript
-        mode  are  constrained in the same was as those specified by \x in non-
-        JavaScript mode.
-        Characters whose value is less than 256 can be defined by either of the
-        two  syntaxes for \x (or by \u in JavaScript mode). There is no differ-
-        ence in the way they are handled. For example, \xdc is exactly the same
-        as \x{dc} (or \u00dc in JavaScript mode).
-        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
+        (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 charac-
+        ter numbers, and \g{} to specify back references. The  following  para-
+        graphs describe the old, ambiguous syntax.
         The handling of a backslash followed by a digit other than 0 is compli-
-        cated.  Outside a character class, PCRE reads it and any following dig-
+        cated, and Perl has changed in recent releases, causing  PCRE  also  to
-        its  as  a  decimal  number. If the number is less than 10, or if there
+        change. Outside a character class, PCRE reads the digit and any follow-
-        have been at least that many previous capturing left parentheses in the
+        ing digits as a decimal number. If the number is less  than  8,  or  if
-        expression,  the  entire  sequence  is  taken  as  a  back reference. A
+        there  have been at least that many previous capturing left parentheses
-        description of how this works is given later, following the  discussion
+        in the expression, the entire sequence is taken as a back reference.  A
+        description  of how this works is given later, following the discussion
         of parenthesized subpatterns.
-        Inside  a  character  class, or if the decimal number is greater than 9
+        Inside a character class, or if  the  decimal  number  following  \  is
-        and there have not been that many capturing subpatterns, PCRE  re-reads
+        greater than 7 and there have not been that many capturing subpatterns,
-        up to three octal digits following the backslash, and uses them to gen-
+        PCRE handles \8 and \9 as the literal characters "8" and "9", and  oth-
-        erate a data character. Any subsequent digits stand for themselves. The
+        erwise re-reads up to three octal digits following the backslash, using
-        value  of  the  character  is constrained in the same way as characters
+        them to generate a data character.  Any  subsequent  digits  stand  for
-        specified in hexadecimal.  For example:
+        themselves. For example:
           \040   is another way of writing an ASCII space
           \40    is the same, provided there are fewer than 40
-Line 4969 
 BACKSLASH
+Line 5051 
 BACKSLASH
                     character with octal code 113
           \377   might be a back reference, otherwise
                     the value 255 (decimal)
-          \81    is either a back reference, or a binary zero
+          \81    is either a back reference, or the two
-                    followed by the two characters "8" and "1"
+                    characters "8" and "1"
-        Note that octal values of 100 or greater must not be  introduced  by  a
+        Note  that octal values of 100 or greater that are specified using this
-        leading zero, because no more than three octal digits are ever read.
+        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 hexa-
+        decimal digits are read (letters can be in upper or  lower  case).  Any
+        number of hexadecimal digits may appear between \x{ and }. If a charac-
+        ter other than a hexadecimal digit appears between \x{  and  },  or  if
+        there is no terminating }, an error occurs.
+        If  the  PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \x
+        is as just described only when it is followed by two  hexadecimal  dig-
+        its.   Otherwise,  it  matches  a  literal "x" character. In JavaScript
+        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 JavaScript mode). There is no differ-
+        ence in the way they are handled. For example, \xdc is exactly the same
+        as \x{dc} (or \u00dc in JavaScript mode).
+    Constraints on character values
+        Characters  that  are  specified using octal or hexadecimal numbers are
+        limited to certain values, as follows:
+-bit non-UTF mode    less than 0x100
+-bit UTF-8 mode      less than 0x10ffff and a valid codepoint
+-bit non-UTF mode   less than 0x10000
+-bit UTF-16 mode    less than 0x10ffff and a valid codepoint
+-bit non-UTF mode   less than 0x100000000
+-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
-Line 5038 
 BACKSLASH
+Line 5156 
 BACKSLASH
         the subject string, all of them fail, because there is no character  to
         match.
-        For  compatibility  with Perl, \s does not match the VT character (code
+        For  compatibility with Perl, \s did not used to match the VT character
-).  This makes it different from the the POSIX "space" class. The  \s
+        (code 11), which made it different from the the  POSIX  "space"  class.
-        characters  are  HT  (9), LF (10), FF (12), CR (13), and space (32). If
+        However,  Perl  added  VT  at  release  5.18, and PCRE followed suit at
-        "use locale;" is included in a Perl script, \s may match the VT charac-
+        release 8.34. The default \s characters are now HT  (9),  LF  (10),  VT
-        ter. In PCRE, it never does.
+        (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
-        A  "word"  character is an underscore or any character that is a letter
+        is  taking  place;  in  particular,  in  some locales the "non-breaking
-        or digit.  By default, the definition of letters  and  digits  is  con-
+        space" character (\xA0) is recognized as white space.
-        trolled  by PCRE's low-valued character tables, and may vary if locale-
-        specific matching is taking place (see "Locale support" in the  pcreapi
+        A "word" character is an underscore or any character that is  a  letter
-        page).  For  example,  in  a French locale such as "fr_FR" in Unix-like
+        or  digit.   By  default,  the definition of letters and digits is con-
-        systems, or "french" in Windows, some character codes greater than  128
+        trolled by PCRE's low-valued character tables, and may vary if  locale-
-        are  used  for  accented letters, and these are then matched by \w. The
+        specific  matching is taking place (see "Locale support" in the pcreapi
+        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, in a UTF mode, characters  with  values  greater  than  128
+        By  default,  characters  whose  code points are greater than 127 never
-        never  match  \d,  \s,  or  \w,  and always match \D, \S, and \W. These
+        match \d, \s, or \w, and always match \D, \S, and \W, although this may
-        sequences retain their original meanings from before  UTF  support  was
+        vary  for characters in the range 128-255 when locale-specific matching
-        available,  mainly for efficiency reasons. However, if PCRE is compiled
+        is happening.  These escape sequences retain  their  original  meanings
-        with Unicode property support, and the PCRE_UCP option is set, the  be-
+        from  before  Unicode support was available, mainly for efficiency rea-
-        haviour  is  changed  so  that Unicode properties are used to determine
+        sons. If PCRE is  compiled  with  Unicode  property  support,  and  the
-        character types, as follows:
+        PCRE_UCP  option is set, the behaviour is changed so that Unicode prop-
+        erties are used to determine character types, as follows:
-          \d  any character that \p{Nd} matches (decimal digit)
-          \s  any character that \p{Z} matches, plus HT, LF, FF, CR
+          \d  any character that matches \p{Nd} (decimal digit)
-          \w  any character that \p{L} or \p{N} matches, plus underscore
+          \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,
-Line 5074 
 BACKSLASH
+Line 5196 
 BACKSLASH
         The sequences \h, \H, \v, and \V are features that were added  to  Perl
         at  release  5.10. In contrast to the other sequences, which match only
         ASCII characters by default, these  always  match  certain  high-valued
-        codepoints,  whether or not PCRE_UCP is set. The horizontal space char-
+        code points, whether or not PCRE_UCP is set. The horizontal space char-
         acters are:
           U+0009     Horizontal tab (HT)
-Line 5340 
 BACKSLASH
+Line 5462 
 BACKSLASH
         As well as the standard Unicode properties described above,  PCRE  sup-
         ports  four  more  that  make it possible to convert traditional escape
-        sequences such as \w and \s and POSIX character classes to use  Unicode
+        sequences such as \w and \s to use Unicode properties. PCRE uses  these
-        properties.  PCRE  uses  these non-standard, non-Perl properties inter-
+        non-standard, non-Perl properties internally when PCRE_UCP is set. How-
-        nally when PCRE_UCP is set. However, they may also be used  explicitly.
+        ever, they may also be used explicitly. These properties are:
-        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 (num-
+        Xan matches characters that have either the L (letter) or the  N  (num-
-        ber) property. Xps matches the characters tab, linefeed, vertical  tab,
+        ber)  property. Xps matches the characters tab, linefeed, vertical tab,
-        form  feed,  or carriage return, and any other character that has the Z
+        form feed, or carriage return, and any other character that has  the  Z
-        (separator) property.  Xsp is the same as Xps, except that vertical tab
+        (separator)  property.  Xsp is the same as Xps; it used to exclude ver-
-        is excluded. Xwd matches the same characters as Xan, plus underscore.
+        tical tab, for Perl compatibility, but Perl changed, and so  PCRE  fol-
+        lowed  at  release  8.34.  Xwd matches the same characters as Xan, plus
-        There  is another non-standard property, Xuc, which matches any charac-
+        underscore.
-        ter that can be represented by a Universal Character Name  in  C++  and
-        other  programming  languages.  These are the characters $, @, ` (grave
+        There is another non-standard property, Xuc, which matches any  charac-
-        accent), and all characters with Unicode code points  greater  than  or
+        ter  that  can  be represented by a Universal Character Name in C++ and
-        equal  to U+00A0, except for the surrogates U+D800 to U+DFFF. Note that
+        other programming languages. These are the characters $,  @,  `  (grave
-        most base (ASCII) characters are excluded. (Universal  Character  Names
+        accent),  and  all  characters with Unicode code points greater than or
-        are  of  the  form \uHHHH or \UHHHHHHHH where H is a hexadecimal digit.
+        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 char-
         acters that they represent.)
     Resetting the match start
-        The  escape sequence \K causes any previously matched characters not to
+        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
+        matches  "foobar",  but reports that it has matched "bar". This feature
-        is  similar  to  a lookbehind assertion (described below).  However, in
+        is similar to a lookbehind assertion (described  below).   However,  in
-        this case, the part of the subject before the real match does not  have
+        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
+        to be of fixed length, as lookbehind assertions do. The use of \K  does
-        not interfere with the setting of captured  substrings.   For  example,
+        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
+        Perl documents that the use  of  \K  within  assertions  is  "not  well
-        defined". In PCRE, \K is acted upon  when  it  occurs  inside  positive
+        defined".  In  PCRE,  \K  is  acted upon when it occurs inside positive
         assertions, but is ignored in negative assertions.
     Simple assertions
-        The  final use of backslash is for certain simple assertions. An asser-
+        The final use of backslash is for certain simple assertions. An  asser-
-        tion specifies a condition that has to be met at a particular point  in
+        tion  specifies a condition that has to be met at a particular point in
-        a  match, without consuming any characters from the subject string. The
+        a match, without consuming any characters from the subject string.  The
-        use of subpatterns for more complicated assertions is described  below.
+        use  of subpatterns for more complicated assertions is described below.
         The backslashed assertions are:
           \b     matches at a word boundary
-Line 5404 
 BACKSLASH
+Line 5527 
 BACKSLASH
           \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
+        Inside a character class, \b has a different meaning;  it  matches  the
-        backspace character. If any other of  these  assertions  appears  in  a
+        backspace  character.  If  any  other  of these assertions appears in a
-        character  class, by default it matches the corresponding literal char-
+        character class, by default it matches the corresponding literal  char-
         acter  (for  example,  \B  matches  the  letter  B).  However,  if  the
-        PCRE_EXTRA  option is set, an "invalid escape sequence" error is gener-
+        PCRE_EXTRA option is set, an "invalid escape sequence" error is  gener-
         ated instead.
-        A word boundary is a position in the subject string where  the  current
+        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.
+        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
+        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
+        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
+        UTF  mode,  the  meanings  of  \w  and \W can be changed by setting the
-        PCRE_UCP  option. When this is done, it also affects \b and \B. Neither
+        PCRE_UCP option. When this is done, it also affects \b and \B.  Neither
-        PCRE nor Perl has a separate "start of word" or "end of  word"  metase-
+        PCRE  nor  Perl has a separate "start of word" or "end of word" metase-
-        quence.  However,  whatever follows \b normally determines which it is.
+        quence. 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
+        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
+        at  the  very start and end of the subject string, whatever options are
-        set.  Thus,  they are independent of multiline mode. These three asser-
+        set. Thus, they are independent of multiline mode. These  three  asser-
         tions are not affected by the PCRE_NOTBOL or PCRE_NOTEOL options, which
-        affect  only the behaviour of the circumflex and dollar metacharacters.
+        affect only the behaviour of the circumflex and dollar  metacharacters.
-        However, if the startoffset argument of pcre_exec() is non-zero,  indi-
+        However,  if the startoffset argument of pcre_exec() is non-zero, indi-
         cating 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
+        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  \G assertion is true only when the current matching position is at
-        the  start point of the match, as specified by the startoffset argument
+        the start point of the match, as specified by the startoffset  argument
-        of pcre_exec(). It differs from \A when the  value  of  startoffset  is
+        of  pcre_exec().  It  differs  from \A when the value of startoffset is
-        non-zero.  By calling pcre_exec() multiple times with appropriate argu-
+        non-zero. By calling pcre_exec() multiple times with appropriate  argu-
         ments, you can mimic Perl's /g option, and it is in this kind of imple-
         mentation where \G can be useful.
-        Note,  however,  that  PCRE's interpretation of \G, as the start of the
+        Note, however, that PCRE'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
+        end of the previous match. In Perl, these can  be  different  when  the
-        previously matched string was empty. Because PCRE does just  one  match
+        previously  matched  string was empty. Because PCRE 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
+        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.
+        The circumflex and dollar  metacharacters  are  zero-width  assertions.
-        That is, they test for a particular condition being true  without  con-
+        That  is,  they test for a particular condition being true without con-
         suming 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
+        character  is  an  assertion  that is true only if the current matching
-        point  is  at the start of the subject string. If the startoffset argu-
+        point is at the start of the subject string. If the  startoffset  argu-
-        ment of pcre_exec() is non-zero, circumflex  can  never  match  if  the
+        ment  of  pcre_exec()  is  non-zero,  circumflex can never match if the
-        PCRE_MULTILINE  option  is  unset. Inside a character class, circumflex
+        PCRE_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
+        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
+        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
+        alternative  in  which  it appears if the pattern is ever to match that
-        branch.  If all possible alternatives start with a circumflex, that is,
+        branch. If all possible alternatives start with a circumflex, that  is,
-        if the pattern is constrained to match only at the start  of  the  sub-
+        if  the  pattern  is constrained to match only at the start of the sub-
-        ject,  it  is  said  to be an "anchored" pattern. (There are also other
+        ject, 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
+        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
+        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,
+        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
+        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. Dol-
+        but it should be the last item in any branch in which it appears.  Dol-
         lar has no special meaning in a character class.
-        The meaning of dollar can be changed so that it  matches  only  at  the
+        The  meaning  of  dollar  can be changed so that it matches only at the
-        very  end  of  the string, by setting the PCRE_DOLLAR_ENDONLY option at
+        very end of the string, by setting the  PCRE_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
-        PCRE_MULTILINE  option  is  set.  When  this  is the case, a circumflex
+        PCRE_MULTILINE option is set. When  this  is  the  case,  a  circumflex
-        matches immediately after internal newlines as well as at the start  of
+        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
+        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
+        string.  A dollar matches before any newlines in the string, as well as
-        at  the very end, when PCRE_MULTILINE is set. When newline is specified
+        at the very end, when PCRE_MULTILINE is set. When newline is  specified
-        as the two-character sequence CRLF, isolated CR and  LF  characters  do
+        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"
+        For example, the pattern /^abc$/ matches the subject string  "def\nabc"
-        (where \n represents a newline) in multiline mode, but  not  otherwise.
+        (where  \n  represents a newline) in multiline mode, but not otherwise.
-        Consequently,  patterns  that  are anchored in single line mode because
+        Consequently, patterns that are anchored in single  line  mode  because
-        all branches start with ^ are not anchored in  multiline  mode,  and  a
+        all  branches  start  with  ^ are not anchored in multiline mode, and a
-        match  for  circumflex  is  possible  when  the startoffset argument of
+        match for circumflex is  possible  when  the  startoffset  argument  of
-        pcre_exec() is non-zero. The PCRE_DOLLAR_ENDONLY option is  ignored  if
+        pcre_exec()  is  non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if
         PCRE_MULTILINE is set.
-        Note  that  the sequences \A, \Z, and \z can be used to match the start
+        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
+        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 PCRE_MULTILINE is
+        start with \A it is always anchored, whether or not  PCRE_MULTILINE  is
         set.
  FULL STOP (PERIOD, DOT) AND \N
         Outside a character class, a dot in the pattern matches any one charac-
-        ter  in  the subject string except (by default) a character that signi-
+        ter in the subject string except (by default) a character  that  signi-
         fies the end of a line.
-        When a line ending is defined as a single character, dot never  matches
+        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
+        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
+        not  match  CR  if  it  is immediately followed by LF, but otherwise it
-        matches  all characters (including isolated CRs and LFs). When any Uni-
+        matches all characters (including isolated CRs and LFs). When any  Uni-
-        code line endings are being recognized, dot does not match CR or LF  or
+        code  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
+        The behaviour of dot with regard to newlines can  be  changed.  If  the
-        PCRE_DOTALL option is set, a dot matches  any  one  character,  without
+        PCRE_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  circum-
+        The  handling of dot is entirely independent of the handling of circum-
-        flex  and  dollar,  the  only relationship being that they both involve
+        flex 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
+        The  escape  sequence  \N  behaves  like  a  dot, except that it is not
-        affected  by  the  PCRE_DOTALL  option.  In other words, it matches any
+        affected by the PCRE_DOTALL option. In  other  words,  it  matches  any
-        character except one that signifies the end of a line. Perl  also  uses
+        character  except  one that signifies the end of a line. Perl also uses
         \N to match characters by name; PCRE does not support this.
  MATCHING A SINGLE DATA UNIT
-        Outside  a character class, the escape sequence \C matches any one data
+        Outside a character class, the escape sequence \C matches any one  data
-        unit, whether or not a UTF mode is set. In the 8-bit library, one  data
+        unit,  whether or not a UTF mode is set. In the 8-bit library, one data
-        unit  is  one  byte;  in the 16-bit library it is a 16-bit unit; in the
+        unit is one byte; in the 16-bit library it is a  16-bit  unit;  in  the
--bit library it is a 32-bit unit. Unlike a  dot,  \C  always  matches
+-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
+        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 use-
-        fully  be  used.  Because  \C breaks up characters into individual data
+        fully be used. Because \C breaks up  characters  into  individual  data
-        units, matching one unit with \C in a UTF mode means that the  rest  of
+        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 PCRE assumes that it is dealing with valid UTF strings
-        (and  by  default  it checks this at the start of processing unless the
+        (and by default it checks this at the start of  processing  unless  the
-        PCRE_NO_UTF8_CHECK, PCRE_NO_UTF16_CHECK or  PCRE_NO_UTF32_CHECK  option
+        PCRE_NO_UTF8_CHECK,  PCRE_NO_UTF16_CHECK  or PCRE_NO_UTF32_CHECK option
         is used).
-        PCRE  does  not  allow \C to appear in lookbehind assertions (described
+        PCRE does not allow \C to appear in  lookbehind  assertions  (described
-        below) in a UTF mode, because this would make it impossible  to  calcu-
+        below)  in  a UTF mode, because this would make it impossible to calcu-
         late 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
+        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 pat-
+        a lookahead to check the length of the next character, as in this  pat-
-        tern, which could be used with a UTF-8 string (ignore white  space  and
+        tern,  which  could be used with a UTF-8 string (ignore white space and
         line breaks):
           (?| (?=[\x00-\x7f])(\C) |
-Line 5566 
 MATCHING A SINGLE DATA UNIT
+Line 5689 
 MATCHING A SINGLE DATA UNIT
               (?=[\x{800}-\x{ffff}])(\C)(\C)(\C) |
               (?=[\x{10000}-\x{1fffff}])(\C)(\C)(\C)(\C))
-        A  group  that starts with (?| resets the capturing parentheses numbers
+        A group that starts with (?| resets the capturing  parentheses  numbers
-        in each alternative (see "Duplicate  Subpattern  Numbers"  below).  The
+        in  each  alternative  (see  "Duplicate Subpattern Numbers" below). The
-        assertions  at  the start of each branch check the next UTF-8 character
+        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
+        for  values  whose encoding uses 1, 2, 3, or 4 bytes, respectively. The
-        character's  individual bytes are then captured by the appropriate num-
+        character's individual bytes are then captured by the appropriate  num-
         ber of groups.
-Line 5580 
 SQUARE BRACKETS AND CHARACTER CLASSES
+Line 5703 
 SQUARE BRACKETS AND CHARACTER CLASSES
         closing square bracket. A closing square bracket on its own is not spe-
         cial by default.  However, if the PCRE_JAVASCRIPT_COMPAT option is set,
         a lone closing square bracket causes a compile-time error. If a closing
-        square bracket is required as a member of the class, it should  be  the
+        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
+        first data character in the class  (after  an  initial  circumflex,  if
         present) or escaped with a backslash.
-        A character class matches a single character in the subject. In  a  UTF
+        A  character  class matches a single character in the subject. In a UTF
-        mode,  the  character  may  be  more than one data unit long. A matched
+        mode, the character may be more than one  data  unit  long.  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
+        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
+        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,
+        For  example, the character class [aeiou] matches any lower case vowel,
-        while  [^aeiou]  matches  any character that is not a 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
+        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  con-
+        class  that starts with a circumflex is not an assertion; it still con-
-        sumes  a  character  from the subject string, and therefore it fails if
+        sumes a character from the subject string, and therefore  it  fails  if
         the current pointer is at the end of the string.
         In UTF-8 (UTF-16, UTF-32) mode, characters with values greater than 255
-        (0xffff)  can be included in a class as a literal string of data units,
+        (0xffff) can be included in a class as a literal string of data  units,
         or by using the \x{ escaping mechanism.
-        When caseless matching is set, any letters in a  class  represent  both
+        When  caseless  matching  is set, any letters in a class represent both
-        their  upper  case  and lower case versions, so for example, a caseless
+        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
+        [aeiou]  matches  "A"  as well as "a", and a caseless [^aeiou] does not
-        match  "A", whereas a caseful version would. In a UTF mode, PCRE always
+        match "A", whereas a caseful version would. In a UTF mode, PCRE  always
-        understands the concept of case for characters whose  values  are  less
+        understands  the  concept  of case for characters whose values are less
-        than  128, so caseless matching is always possible. For characters with
+        than 128, so caseless matching is always possible. For characters  with
-        higher values, the concept of case is supported  if  PCRE  is  compiled
+        higher  values,  the  concept  of case is supported if PCRE is compiled
-        with  Unicode  property support, but not otherwise.  If you want to use
+        with Unicode property support, but not otherwise.  If you want  to  use
-        caseless matching in a UTF mode for characters 128 and above, you  must
+        caseless  matching in a UTF mode for characters 128 and above, you must
-        ensure  that  PCRE is compiled with Unicode property support as well as
+        ensure that PCRE is compiled with Unicode property support as  well  as
         with UTF support.
-        Characters that might indicate line breaks are  never  treated  in  any
+        Characters  that  might  indicate  line breaks are never treated in any
-        special  way  when  matching  character  classes,  whatever line-ending
+        special way  when  matching  character  classes,  whatever  line-ending
-        sequence is in  use,  and  whatever  setting  of  the  PCRE_DOTALL  and
+        sequence  is  in  use,  and  whatever  setting  of  the PCRE_DOTALL and
         PCRE_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  charac-
+        The  minus (hyphen) character can be used to specify a range of charac-
-        ters  in  a  character  class.  For  example,  [d-m] matches any letter
+        ters in a character  class.  For  example,  [d-m]  matches  any  letter
-        between d and m, inclusive. If a  minus  character  is  required  in  a
+        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
+        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
+        where  it cannot be interpreted as indicating a range, typically as the
-        first or last character in the class.
+        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 charac-
+        ter, or z.
         It is not possible to have the literal character "]" as the end charac-
-        ter of a range. A pattern such as [W-]46] is interpreted as a class  of
+        ter  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
+        two characters ("W" and "-") followed by a literal string "46]", so  it
-        would match "W46]" or "-46]". However, if the "]"  is  escaped  with  a
+        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 inter-
+        backslash it is interpreted as the end of range, so [W-\]46] is  inter-
-        preted as a class containing a range followed by two other  characters.
+        preted  as a class containing a range followed by two other characters.
-        The  octal or hexadecimal representation of "]" can also be used to end
+        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
-Line 5700 
 POSIX CHARACTER CLASSES
+Line 5830 
 POSIX CHARACTER CLASSES
           lower    lower case letters
           print    printing characters, including space
           punct    printing characters, excluding letters and digits and space
-          space    white space (not quite the same as \s)
+          space    white space (the same as \s from PCRE 8.34)
           upper    upper case letters
           word     "word" characters (same as \w)
           xdigit   hexadecimal digits
-        The  "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13),
+        The  default  "space" characters are HT (9), LF (10), VT (11), FF (12),
-        and space (32). Notice that this list includes the VT  character  (code
+        CR (13), and space (32). If locale-specific matching is  taking  place,
-). This makes "space" different to \s, which does not include VT (for
+        there  may be additional space characters. "Space" used to be different
-        Perl compatibility).
+        to \s, which did not include VT, for Perl compatibility. However,  Perl
+        changed at release 5.18, and PCRE followed at release 8.34. "Space" and
+        \s now 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
-Line 5720 
 POSIX CHARACTER CLASSES
+Line 5852 
 POSIX CHARACTER CLASSES
         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, in UTF modes, characters with values greater  than  128  do
+        By default, characters with values greater than 128 do not match any of
-        not  match any of the POSIX character classes. However, if the PCRE_UCP
+        the  POSIX character classes. However, if the PCRE_UCP option is passed
-        option is passed to pcre_compile(), some of the classes are changed  so
+        to pcre_compile(), some of the classes  are  changed  so  that  Unicode
-        that Unicode character properties are used. This is achieved by replac-
+        character  properties  are  used. This is achieved by replacing certain
-        ing the POSIX classes by other sequences, as follows:
+        POSIX classes by other sequences, as follows:
           [:alnum:]  becomes  \p{Xan}
           [:alpha:]  becomes  \p{L}
-Line 5735 
 POSIX CHARACTER CLASSES
+Line 5867 
 POSIX CHARACTER CLASSES
           [:upper:]  becomes  \p{Lu}
           [:word:]   becomes  \p{Xwd}
-        Negated versions, such as [:^alpha:] use \P instead of  \p.  The  other
+        Negated versions, such as [:^alpha:] use \P instead of \p. Three  other
-        POSIX classes are unchanged, and match only characters with code points
+        POSIX classes are handled specially in UCP mode:
-        less than 128.
+        [:graph:] This  matches  characters that have glyphs that mark the page
+                  when printed. In Unicode property terms, it matches all char-
+                  acters 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 (punctua-
+                  tion) property, plus those characters whose code  points  are
+                  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.
  VERTICAL BAR
-Line 5934 
 NAMED SUBPATTERNS
+Line 6085 
 NAMED SUBPATTERNS
         references,  recursion,  and conditions, can be made by name as well as
         by number.
-        Names consist of up to  32  alphanumeric  characters  and  underscores.
+        Names consist of up to 32 alphanumeric characters and underscores,  but
-        Named  capturing  parentheses  are  still  allocated numbers as well as
+        must  start  with  a  non-digit.  Named capturing parentheses are still
-        names, exactly as if the names were not present. The PCRE API  provides
+        allocated numbers as well as names, exactly as if the  names  were  not
-        function calls for extracting the name-to-number translation table from
+        present.  The PCRE API provides function calls for extracting the name-
-        a compiled pattern. There is also a convenience function for extracting
+        to-number translation table from a compiled pattern. There  is  also  a
-        a captured substring by name.
+        convenience function 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 PCRE_DUPNAMES option at compile
-Line 5967 
 NAMED SUBPATTERNS
+Line 6118 
 NAMED SUBPATTERNS
         subpattern it was.
         If you make a back reference to  a  non-unique  named  subpattern  from
-        elsewhere  in the pattern, the one that corresponds to the first occur-
+        elsewhere  in the pattern, the subpatterns to which the name refers are
-        rence of the name is used. In the absence of duplicate numbers (see the
+        checked in the order in which they appear in the overall  pattern.  The
-        previous  section) this is the one with the lowest number. If you use a
+        first one that is set is used for the reference. For example, this pat-
-        named reference in a condition test (see the section  about  conditions
+        tern matches both "foofoo" and "barbar" but not "foobar" or "barfoo":
-        below),  either  to check whether a subpattern has matched, or to check
-        for recursion, all subpatterns with the same name are  tested.  If  the
+          (?:(?<n>foo)|(?<n>bar))\k<n>
-        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 pcreapi documen-
+        If you make a subroutine call to a non-unique named subpattern, the one
-        tation.
+        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
+        pcreapi documentation.
         Warning: You cannot use different names to distinguish between two sub-
-        patterns  with  the same number because PCRE uses only the numbers when
+        patterns with the same number because PCRE uses only the  numbers  when
         matching. For this reason, an error is given at compile time if differ-
-        ent  names  are given to subpatterns with the same number. However, you
+        ent names are given to subpatterns with the same number.  However,  you
-        can give the same name to subpatterns with the same number,  even  when
+        can always give the same name to subpatterns with the same number, even
-        PCRE_DUPNAMES is not set.
+        when PCRE_DUPNAMES is not set.
  REPETITION
-        Repetition  is  specified  by  quantifiers, which can follow any of the
+        Repetition is specified by quantifiers, which can  follow  any  of  the
         following items:
           a literal data character
-Line 6002 
 REPETITION
+Line 6163 
 REPETITION
           a parenthesized subpattern (including assertions)
           a subroutine call to a subpattern (recursive or otherwise)
-        The general repetition quantifier specifies a minimum and maximum  num-
+        The  general repetition quantifier specifies a minimum and maximum num-
-        ber  of  permitted matches, by giving the two numbers in curly brackets
+        ber of permitted matches, by giving the two numbers in  curly  brackets
-        (braces), separated by a comma. The numbers must be  less  than  65536,
+        (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
+        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
+        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
+        present, there is no upper limit; if the second number  and  the  comma
-        are both omitted, the quantifier specifies an exact number of  required
+        are  both omitted, the quantifier specifies an exact number of required
         matches. Thus
           [aeiou]{3,}
-Line 6021 
 REPETITION
+Line 6182 
 REPETITION
           \d{8}
-        matches  exactly  8  digits. An opening curly bracket that appears in a
+        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
+        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 exam-
+        the syntax of a quantifier, is taken as a literal character. For  exam-
         ple, {,6} is not a quantifier, but a literal string of four characters.
         In UTF modes, quantifiers apply to characters rather than to individual
-        data  units. Thus, for example, \x{100}{2} matches two characters, each
+        data 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. Simi-
-        larly,  \X{3} matches three Unicode extended grapheme clusters, each of
+        larly, \X{3} matches three Unicode extended grapheme clusters, each  of
-        which may be several data units long (and  they  may  be  of  different
+        which  may  be  several  data  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 use-
-        ful  for  subpatterns that are referenced as subroutines from elsewhere
+        ful 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
+        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-charac-
+        For  convenience, the three most common quantifiers have single-charac-
         ter 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
+        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 PCRE used to give an error at compile time
-        for such patterns. However, because there are cases where this  can  be
+        for  such  patterns. However, because there are cases where this can be
-        useful,  such  patterns  are now accepted, but if any repetition of the
+        useful, such patterns are now accepted, but if any  repetition  of  the
-        subpattern does in fact match no characters, the loop is forcibly  bro-
+        subpattern  does in fact match no characters, the loop is forcibly bro-
         ken.
-        By  default,  the quantifiers are "greedy", that is, they match as much
+        By default, the quantifiers are "greedy", that is, they match  as  much
-        as possible (up to the maximum  number  of  permitted  times),  without
+        as  possible  (up  to  the  maximum number of permitted times), without
-        causing  the  rest of the pattern to fail. The classic example of where
+        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 /
+        appear between /* and */ and within the comment,  individual  *  and  /
-        characters may appear. An attempt to match C comments by  applying  the
+        characters  may  appear. An attempt to match C comments by applying the
         pattern
           /\*.*\*/
-Line 6073 
 REPETITION
+Line 6234 
 REPETITION
           /* first comment */  not comment  /* second comment */
-        fails,  because it matches the entire string owing to the greediness of
+        fails, because it matches the entire string owing to the greediness  of
         the .*  item.
-        However, if a quantifier is followed by a question mark, it  ceases  to
+        However,  if  a quantifier is followed by a question mark, it ceases to
         be greedy, and instead matches the minimum number of times possible, so
         the pattern
           /\*.*?\*/
-        does the right thing with the C comments. The meaning  of  the  various
+        does  the  right  thing with the C comments. The meaning of the various
-        quantifiers  is  not  otherwise  changed,  just the preferred number of
+        quantifiers is not otherwise changed,  just  the  preferred  number  of
-        matches.  Do not confuse this use of question mark with its  use  as  a
+        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
+        quantifier in its own right. Because it has two uses, it can  sometimes
         appear doubled, as in
           \d??\d
-Line 6093 
 REPETITION
+Line 6254 
 REPETITION
         which matches one digit by preference, but can match two if that is the
         only way the rest of the pattern matches.
-        If  the PCRE_UNGREEDY option is set (an option that is not available in
+        If the PCRE_UNGREEDY option is set (an option that is not available  in
-        Perl), the quantifiers are not greedy by default, but  individual  ones
+        Perl),  the  quantifiers are not greedy by default, but individual ones
-        can  be  made  greedy  by following them with a question mark. In other
+        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
+        When  a  parenthesized  subpattern  is quantified with a minimum repeat
-        count  that is greater than 1 or with a limited maximum, more memory is
+        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
+        required  for  the  compiled  pattern, in proportion to the size of the
         minimum or maximum.
         If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equiv-
-        alent to Perl's /s) is set, thus allowing the dot  to  match  newlines,
+        alent  to  Perl's  /s) is set, thus allowing the dot to match newlines,
-        the  pattern  is  implicitly anchored, because whatever follows will be
+        the pattern is implicitly anchored, because whatever  follows  will  be
-        tried against every character position in the subject string, so  there
+        tried  against every character position in the subject string, so there
-        is  no  point  in  retrying the overall match at any position after the
+        is no point in retrying the overall match at  any  position  after  the
-        first. PCRE normally treats such a pattern as though it  were  preceded
+        first.  PCRE  normally treats such a pattern as though it were preceded
         by \A.
-        In  cases  where  it  is known that the subject string contains no new-
+        In cases where it is known that the subject  string  contains  no  new-
-        lines, it is worth setting PCRE_DOTALL in order to  obtain  this  opti-
+        lines,  it  is  worth setting PCRE_DOTALL in order to obtain this opti-
         mization, or alternatively using ^ to indicate anchoring explicitly.
-        However,  there  are  some cases where the optimization cannot be used.
+        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  charac-
+        If  the subject is "xyz123abc123" the match point is the fourth charac-
         ter. For this reason, such a pattern is not implicitly anchored.
-        Another  case where implicit anchoring is not applied is when the lead-
+        Another case where implicit anchoring is not applied is when the  lead-
-        ing .* is inside an atomic group. Once again, a match at the start  may
+        ing  .* 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 con-
+        It matches "ab" in the subject "aab". The use of the backtracking  con-
         trol verbs (*PRUNE) and (*SKIP) also disable this optimization.
         When a capturing subpattern is repeated, the value captured is the sub-
-Line 6140 
 REPETITION
+Line 6301 
 REPETITION
           (tweedle[dume]{3}\s*)+
         has matched "tweedledum tweedledee" the value of the captured substring
-        is "tweedledee". However, if there are  nested  capturing  subpatterns,
+        is  "tweedledee".  However,  if there are nested capturing subpatterns,
-        the  corresponding captured values may have been set in previous itera-
+        the corresponding captured values may have been set in previous  itera-
         tions. For example, after
           /(a|(b))+/
-Line 6151 
 REPETITION
+Line 6312 
 REPETITION
  ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS
-        With both maximizing ("greedy") and minimizing ("ungreedy"  or  "lazy")
+        With  both  maximizing ("greedy") and minimizing ("ungreedy" or "lazy")
-        repetition,  failure  of what follows normally causes the repeated item
+        repetition, failure of what follows normally causes the  repeated  item
-        to be re-evaluated to see if a different number of repeats  allows  the
+        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,
+        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
+        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
+        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
+        Consider,  for  example, the pattern \d+foo when applied to the subject
         line
 bar
         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
+        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.
+        \d+ item, and then with  4,  and  so  on,  before  ultimately  failing.
-        "Atomic grouping" (a term taken from Jeffrey  Friedl's  book)  provides
+        "Atomic  grouping"  (a  term taken from Jeffrey Friedl's book) provides
-        the  means for specifying that once a subpattern has matched, it is not
+        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
+        If  we  use atomic grouping for the previous example, the matcher gives
-        up  immediately  on failing to match "foo" the first time. The notation
+        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  con-
+        This  kind  of  parenthesis "locks up" the  part of the pattern it con-
-        tains  once  it  has matched, and a failure further into the pattern is
+        tains once it has matched, and a failure further into  the  pattern  is
-        prevented from backtracking into it. Backtracking past it  to  previous
+        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
+        An alternative description is that a subpattern of  this  type  matches
-        the string of characters that an  identical  standalone  pattern  would
+        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 pre-
+        must swallow everything it can. So, while both \d+ and  \d+?  are  pre-
-        pared to adjust the number of digits they match in order  to  make  the
+        pared  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
+        Atomic  groups in general can of course contain arbitrarily complicated
-        subpatterns,  and  can  be  nested. However, when the subpattern for an
+        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
+        simpler notation, called a "possessive quantifier" can  be  used.  This
-        consists of an additional + character  following  a  quantifier.  Using
+        consists  of  an  additional  + character following a quantifier. Using
         this notation, the previous example can be rewritten as
           \d++foo
-Line 6207 
 ATOMIC GROUPING AND POSSESSIVE QUANTIFIE
+Line 6368 
 ATOMIC GROUPING AND POSSESSIVE QUANTIFIE
           (abc|xyz){2,3}+
-        Possessive  quantifiers  are  always  greedy;  the   setting   of   the
+        Possessive   quantifiers   are   always  greedy;  the  setting  of  the
         PCRE_UNGREEDY option is ignored. They are a convenient notation for the
-        simpler forms of atomic group. However, there is no difference  in  the
+        simpler  forms  of atomic group. However, there is no difference in the
-        meaning  of  a  possessive  quantifier and the equivalent atomic group,
+        meaning of a possessive quantifier and  the  equivalent  atomic  group,
-        though there may be a performance  difference;  possessive  quantifiers
+        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 syn-
+        The possessive quantifier syntax is an extension to the Perl  5.8  syn-
-        tax.  Jeffrey Friedl originated the idea (and the name)  in  the  first
+        tax.   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 PCRE copied it from there. It  ultimately
+        built  Sun's Java package, and PCRE copied it from there. It ultimately
         found its way into Perl at release 5.10.
         PCRE has an optimization that automatically "possessifies" certain sim-
-        ple pattern constructs. For example, the sequence  A+B  is  treated  as
+        ple  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
+        A++B because there is no point in backtracking into a sequence  of  A's
         when B must follow.
-        When a pattern contains an unlimited repeat inside  a  subpattern  that
+        When  a  pattern  contains an unlimited repeat inside a subpattern that
-        can  itself  be  repeated  an  unlimited number of times, the use of an
+        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
+        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-
+        matches an unlimited number of substrings that either consist  of  non-
-        digits, or digits enclosed in <>, followed by either ! or  ?.  When  it
+        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
+        it takes a long time before reporting  failure.  This  is  because  the
-        string can be divided between the internal \D+ repeat and the  external
+        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
+        * 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
+        example  uses  [!?]  rather than a single character at the end, because
-        both  PCRE  and  Perl have an optimization that allows for fast failure
+        both PCRE and Perl have an optimization that allows  for  fast  failure
-        when a single character is used. They remember the last single  charac-
+        when  a single character is used. They remember the last single charac-
-        ter  that  is required for a match, and fail early if it is not present
+        ter 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
+        in  the  string.)  If  the pattern is changed so that it uses an atomic
         group, like this:
           ((?>\D+)|<\d+>)*[!?]
-Line 6257 
 BACK REFERENCES
+Line 6418 
 BACK REFERENCES
         Outside a character class, a backslash followed by a digit greater than
 (and possibly further digits) is a back reference to a capturing sub-
-        pattern  earlier  (that is, to its left) in the pattern, provided there
+        pattern 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 10,
-        it  is  always  taken  as a back reference, and causes an error only if
+        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  pat-
+        there  are  not that many capturing left parentheses in the entire pat-
-        tern.  In  other words, the parentheses that are referenced need not be
+        tern. In other words, the parentheses that are referenced need  not  be
-        to the left of the reference for numbers less than 10. A "forward  back
+        to  the left of the reference for numbers less than 10. A "forward back
-        reference"  of  this  type can make sense when a repetition is involved
+        reference" of this type can make sense when a  repetition  is  involved
-        and the subpattern to the right has participated in an  earlier  itera-
+        and  the  subpattern to the right has participated in an earlier itera-
         tion.
-        It  is  not  possible to have a numerical "forward back reference" to a
+        It is not possible to have a numerical "forward back  reference"  to  a
-        subpattern whose number is 10 or  more  using  this  syntax  because  a
+        subpattern  whose  number  is  10  or  more using this syntax because a
-        sequence  such  as  \50 is interpreted as a character defined in octal.
+        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
+        details of the handling of digits following a backslash.  There  is  no
-        such problem when named parentheses are used. A back reference  to  any
+        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
+        Another way of avoiding the ambiguity inherent in  the  use  of  digits
-        following a backslash is to use the \g  escape  sequence.  This  escape
+        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:
-Line 6286 
 BACK REFERENCES
+Line 6447 
 BACK REFERENCES
           (ring), \g1
           (ring), \g{1}
-        An unsigned number specifies an absolute reference without the  ambigu-
+        An  unsigned number specifies an absolute reference without the ambigu-
         ity 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:
-Line 6295 
 BACK REFERENCES
+Line 6456 
 BACK REFERENCES
         The sequence \g{-1} is a reference to the most recently started captur-
         ing subpattern before \g, that is, is it equivalent to \2 in this exam-
-        ple.   Similarly, \g{-2} would be equivalent to \1. The use of relative
+        ple.  Similarly, \g{-2} would be equivalent to \1. The use of  relative
-        references can be helpful in long patterns, and also in  patterns  that
+        references  can  be helpful in long patterns, and also in patterns that
-        are  created  by  joining  together  fragments  that contain references
+        are created by  joining  together  fragments  that  contain  references
         within themselves.
-        A back reference matches whatever actually matched the  capturing  sub-
+        A  back  reference matches whatever actually matched the capturing sub-
-        pattern  in  the  current subject string, rather than anything matching
+        pattern 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
+        matches "sense and sensibility" and "response and responsibility",  but
-        not "sense and responsibility". If caseful matching is in force at  the
+        not  "sense and responsibility". If caseful matching is in force at the
-        time  of the back reference, the case of letters is relevant. For exam-
+        time of the back reference, the case of letters is relevant. For  exam-
         ple,
           ((?i)rah)\s+\1
-        matches "rah rah" and "RAH RAH", but not "RAH  rah",  even  though  the
+        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
+        There are several different ways of writing back  references  to  named
-        subpatterns. The .NET syntax \k{name} and the Perl syntax  \k<name>  or
+        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
+        \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
+        and named references, is also supported. We  could  rewrite  the  above
         example in any of the following ways:
           (?<p1>(?i)rah)\s+\k<p1>
-Line 6329 
 BACK REFERENCES
+Line 6490 
 BACK REFERENCES
           (?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
+        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
+        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
+        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
+        always fails if it starts to match "a" rather than  "bc".  However,  if
         the PCRE_JAVASCRIPT_COMPAT option is set at compile time, a back refer-
         ence to an unset value matches an empty string.
-        Because  there may be many capturing parentheses in a pattern, all dig-
+        Because there may be many capturing parentheses in a pattern, all  dig-
-        its following a backslash are taken as part of a potential back  refer-
+        its  following a backslash are taken as part of a potential back refer-
-        ence  number.   If  the  pattern continues with a digit character, some
+        ence number.  If the pattern continues with  a  digit  character,  some
-        delimiter must  be  used  to  terminate  the  back  reference.  If  the
+        delimiter  must  be  used  to  terminate  the  back  reference.  If the
-        PCRE_EXTENDED  option  is  set, this can be white space. Otherwise, the
+        PCRE_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
+        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
+        fails when the subpattern is first used, so, for example,  (a\1)  never
-        matches.  However, such references can be useful inside  repeated  sub-
+        matches.   However,  such references can be useful inside repeated sub-
         patterns. For example, the pattern
           (a|b\1)+
         matches any number of "a"s and also "aba", "ababbaa" etc. At each iter-
-        ation of the subpattern,  the  back  reference  matches  the  character
+        ation  of  the  subpattern,  the  back  reference matches the character
-        string  corresponding  to  the previous iteration. In order for this to
+        string corresponding to the previous iteration. In order  for  this  to
-        work, the pattern must be such that the first iteration does  not  need
+        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
+        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
+        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
+        treated as an atomic group.  Once the whole group has been  matched,  a
-        subsequent matching failure cannot cause backtracking into  the  middle
+        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
+        An assertion is a test on the characters  following  or  preceding  the
-        current matching point that does not actually consume  any  characters.
+        current  matching  point that does not actually consume any characters.
-        The  simple  assertions  coded  as  \b, \B, \A, \G, \Z, \z, ^ and $ are
+        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
+        More  complicated  assertions  are  coded as subpatterns. There are two
-        kinds:  those  that  look  ahead of the current position in the subject
+        kinds: those that look ahead of the current  position  in  the  subject
-        string, and those that look  behind  it.  An  assertion  subpattern  is
+        string,  and  those  that  look  behind  it. An assertion subpattern is
-        matched  in  the  normal way, except that it does not cause the current
+        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  asser-
+        Assertion  subpatterns are not capturing subpatterns. If such an asser-
-        tion  contains  capturing  subpatterns within it, these are counted for
+        tion contains capturing subpatterns within it, these  are  counted  for
-        the purposes of numbering the capturing subpatterns in the  whole  pat-
+        the  purposes  of numbering the capturing subpatterns in the whole pat-
-        tern.  However,  substring  capturing  is carried out only for positive
+        tern. However, substring capturing is carried  out  only  for  positive
         assertions. (Perl sometimes, but not always, does do capturing in nega-
         tive assertions.)
-        For  compatibility  with  Perl,  assertion subpatterns may be repeated;
+        For compatibility with Perl, assertion  subpatterns  may  be  repeated;
-        though it makes no sense to assert the same thing  several  times,  the
+        though  it  makes  no sense to assert the same thing several times, the
-        side  effect  of  capturing  parentheses may occasionally be useful. In
+        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
+        (1)  If  the  quantifier  is  {0}, the assertion is never obeyed during
-        matching.   However,  it  may  contain internal capturing parenthesized
+        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
+        (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
+        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 greed-
         iness of the quantifier.
-        (3)  If  the minimum repetition is greater than zero, the quantifier is
+        (3) If the minimum repetition is greater than zero, the  quantifier  is
-        ignored.  The assertion is obeyed just  once  when  encountered  during
+        ignored.   The  assertion  is  obeyed just once when encountered during
         matching.
     Lookahead assertions
-Line 6416 
 ASSERTIONS
+Line 6577 
 ASSERTIONS
           \w+(?=;)
-        matches a word followed by a semicolon, but does not include the  semi-
+        matches  a word followed by a semicolon, but does not include the semi-
         colon in the match, and
           foo(?!bar)
-        matches  any  occurrence  of  "foo" that is not followed by "bar". Note
+        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
+        does  not  find  an  occurrence  of "bar" that is preceded by something
-        other  than "foo"; it finds any occurrence of "bar" whatsoever, because
+        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
+        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
+        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 (?<!
+        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
+        does  find  an  occurrence  of "bar" that is not preceded by "foo". The
-        contents  of  a  lookbehind  assertion are restricted such that all the
+        contents of a lookbehind assertion are restricted  such  that  all  the
         strings it matches must have a fixed length. However, if there are sev-
-        eral  top-level  alternatives,  they  do  not all have to have the same
+        eral top-level alternatives, they do not all  have  to  have  the  same
         fixed length. Thus
           (?<=bullock|donkey)
-Line 6456 
 ASSERTIONS
+Line 6617 
 ASSERTIONS
           (?<!dogs?|cats?)
-        causes an error at compile time. Branches that match  different  length
+        causes  an  error at compile time. Branches that match different length
-        strings  are permitted only at the top level of a lookbehind assertion.
+        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
+        is not permitted, because its single top-level  branch  can  match  two
         different lengths, but it is acceptable to PCRE if rewritten to use two
         top-level branches:
           (?<=abc|abde)
-        In  some  cases, the escape sequence \K (see above) can be used instead
+        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,
+        The  implementation  of lookbehind assertions is, for each alternative,
-        to  temporarily  move the current position back by the fixed length and
+        to temporarily move the current position back by the fixed  length  and
         then try to match. If there are insufficient characters before the cur-
         rent position, the assertion fails.
-        In  a UTF mode, PCRE does not allow the \C escape (which matches a sin-
+        In a UTF mode, PCRE does not allow the \C escape (which matches a  sin-
-        gle data unit even in a UTF mode) to appear in  lookbehind  assertions,
+        gle  data  unit even in a UTF mode) to appear in lookbehind assertions,
-        because  it  makes it impossible to calculate the length of the lookbe-
+        because it makes it impossible to calculate the length of  the  lookbe-
-        hind. The \X and \R escapes, which can match different numbers of  data
+        hind.  The \X and \R escapes, which can match different numbers of data
         units, are also not permitted.
-        "Subroutine"  calls  (see below) such as (?2) or (?&X) are permitted in
+        "Subroutine" calls (see below) such as (?2) or (?&X) are  permitted  in
-        lookbehinds, as long as the subpattern matches a  fixed-length  string.
+        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
+        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
+        when applied to a long string that does  not  match.  Because  matching
         proceeds from left to right, PCRE will look for each "a" in the subject
-        and  then  see  if what follows matches the rest of the pattern. If the
+        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
+        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
+        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,
+        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; it can  match  only  the
+        there  can  be  no backtracking for the .*+ item; it can match only the
-        entire  string.  The subsequent lookbehind assertion does a single test
+        entire string. The subsequent lookbehind assertion does a  single  test
-        on the last four characters. If it fails, the match fails  immediately.
+        on  the last four characters. If it fails, the match fails immediately.
-        For  long  strings, this approach makes a significant difference to the
+        For long strings, this approach makes a significant difference  to  the
         processing time.
     Using multiple assertions
-Line 6520 
 ASSERTIONS
+Line 6681 
 ASSERTIONS
           (?<=\d{3})(?<!999)foo
-        matches "foo" preceded by three digits that are not "999". Notice  that
+        matches  "foo" preceded by three digits that are not "999". Notice that
-        each  of  the  assertions is applied independently at the same point in
+        each of the assertions is applied independently at the  same  point  in
-        the subject string. First there is a  check  that  the  previous  three
+        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
+        characters are all digits, and then there is  a  check  that  the  same
         three characters are not "999".  This pattern does not match "foo" pre-
-        ceded  by  six  characters,  the first of which are digits and the last
+        ceded by six characters, the first of which are  digits  and  the  last
-        three of which are not "999". For example, it  doesn't  match  "123abc-
+        three  of  which  are not "999". For example, it doesn't match "123abc-
         foo". A pattern to do that is
           (?<=\d{3}...)(?<!999)foo
-        This  time  the  first assertion looks at the preceding six characters,
+        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".
-Line 6539 
 ASSERTIONS
+Line 6700 
 ASSERTIONS
           (?<=(?<!foo)bar)baz
-        matches  an occurrence of "baz" that is preceded by "bar" which in turn
+        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
+        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 con-
+        It is possible to cause the matching process to obey a subpattern  con-
-        ditionally or to choose between two alternative subpatterns,  depending
+        ditionally  or to choose between two alternative subpatterns, depending
-        on  the result of an assertion, or whether a specific capturing subpat-
+        on the result of an assertion, or whether a specific capturing  subpat-
-        tern has already been matched. The two possible  forms  of  conditional
+        tern  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
+        If the condition is satisfied, the yes-pattern is used;  otherwise  the
-        no-pattern (if present) is used. If there are more  than  two  alterna-
+        no-pattern  (if  present)  is used. If there are more than two alterna-
-        tives  in  the subpattern, a compile-time error occurs. Each of the two
+        tives in the subpattern, a compile-time error occurs. Each of  the  two
         alternatives may itself contain nested subpatterns of any form, includ-
         ing  conditional  subpatterns;  the  restriction  to  two  alternatives
         applies only at the level of the condition. This pattern fragment is an
-Line 6570 
 CONDITIONAL SUBPATTERNS
+Line 6731 
 CONDITIONAL SUBPATTERNS
           (?(1) (A|B|C) | (D | (?(2)E|F) | E) )
-        There  are  four  kinds of condition: references to subpatterns, refer-
+        There are four kinds of condition: references  to  subpatterns,  refer-
         ences 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,
+        If  the  text between the parentheses consists of a sequence of digits,
         the condition is true if a capturing subpattern of that number has pre-
-        viously matched. If there is more than one  capturing  subpattern  with
+        viously  matched.  If  there is more than one capturing subpattern with
-        the  same  number  (see  the earlier section about duplicate subpattern
+        the same number (see the earlier  section  about  duplicate  subpattern
-        numbers), the condition is true if any of them have matched. An  alter-
+        numbers),  the condition is true if any of them have matched. An alter-
-        native  notation is to precede the digits with a plus or minus sign. In
+        native notation is to precede the digits with a plus or minus sign.  In
-        this case, the subpattern number is relative rather than absolute.  The
+        this  case, the subpattern number is relative rather than absolute. The
-        most  recently opened parentheses can be referenced by (?(-1), the next
+        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
+        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
+        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
+        Consider the following pattern, which  contains  non-significant  white
         space to make it more readable (assume the PCRE_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
+        The first part matches an optional opening  parenthesis,  and  if  that
         character is present, sets it as the first captured substring. The sec-
-        ond  part  matches one or more characters that are not parentheses. The
+        ond part matches one or more characters that are not  parentheses.  The
-        third part is a conditional subpattern that tests whether  or  not  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
+        first set of parentheses matched. If they  did,  that  is,  if  subject
-        started with an opening parenthesis, the condition is true, and so  the
+        started  with an opening parenthesis, the condition is true, and so the
-        yes-pattern  is  executed and a closing parenthesis is required. Other-
+        yes-pattern is executed and a closing parenthesis is  required.  Other-
-        wise, since no-pattern is not present, the subpattern matches  nothing.
+        wise,  since no-pattern is not present, the subpattern matches nothing.
-        In  other  words,  this  pattern matches a sequence of non-parentheses,
+        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
+        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
+        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
+        Perl  uses  the  syntax  (?(<name>)...) or (?('name')...) to test for a
-        used  subpattern  by  name.  For compatibility with earlier versions of
+        used subpattern by name. For compatibility  with  earlier  versions  of
-        PCRE, which had this facility before Perl, the syntax  (?(name)...)  is
+        PCRE,  which  had this facility before Perl, the syntax (?(name)...) is
-        also  recognized. However, there is a possible ambiguity with this syn-
+        also recognized.
-        tax, because subpattern names may  consist  entirely  of  digits.  PCRE
-        looks  first for a named subpattern; if it cannot find one and the name
-        consists entirely of digits, PCRE looks for a subpattern of  that  num-
-        ber,  which must be greater than zero. Using subpattern names that con-
-        sist entirely of digits is not recommended.
         Rewriting the above example to use a named subpattern gives this:
-Line 7032 
 CALLOUTS
+Line 7188 
 CALLOUTS
         tion is called. It is provided with the  number  of  the  callout,  the
         position  in  the pattern, and, optionally, one item of data originally
         supplied by the caller of the matching function. The  callout  function
-        may  cause  matching to proceed, to backtrack, or to fail altogether. A
+        may cause matching to proceed, to backtrack, or to fail altogether.
-        complete description of the interface to the callout function is  given
-        in the pcrecallout documentation.
+        By  default,  PCRE implements a number of optimizations at compile time
+        and 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 pcrecallout documentation.
  BACKTRACKING CONTROL
-        Perl  5.10 introduced a number of "Special Backtracking Control Verbs",
+        Perl 5.10 introduced a number of "Special Backtracking Control  Verbs",
-        which are still described in the Perl  documentation  as  "experimental
+        which  are  still  described in the Perl documentation as "experimental
-        and  subject to change or removal in a future version of Perl". It goes
+        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
+        on  to  say:  "Their  usage in production code should be noted to avoid
-        problems  during upgrades." The same remarks apply to the PCRE features
+        problems during upgrades." The same remarks apply to the PCRE  features
         described in this section.
-        The new verbs make use of what was previously invalid syntax: an  open-
+        The  new verbs make use of what was previously invalid syntax: an open-
         ing parenthesis followed by an asterisk. They are generally of the form
-        (*VERB) or (*VERB:NAME). Some may take either form,  possibly  behaving
+        (*VERB)  or  (*VERB:NAME). Some may take either form, possibly behaving
-        differently  depending  on  whether or not a name is present. A name is
+        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
--bit and 32-bit libraries. If the name is  empty,  that  is,  if  the
+-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
+        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
+        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
+        Since these verbs are specifically related  to  backtracking,  most  of
-        them can be used only when the pattern is to be matched  using  one  of
+        them  can  be  used only when the pattern is to be matched using one of
-        the  traditional  matching  functions, because these use a backtracking
+        the traditional matching functions, because these  use  a  backtracking
-        algorithm. With the exception of (*FAIL), which behaves like a  failing
+        algorithm.  With the exception of (*FAIL), which behaves like a failing
-        negative  assertion,  the  backtracking control verbs cause an error if
+        negative assertion, the backtracking control verbs cause  an  error  if
         encountered by a DFA matching function.
-        The behaviour of these verbs in repeated  groups,  assertions,  and  in
+        The  behaviour  of  these  verbs in repeated groups, assertions, and in
         subpatterns called as subroutines (whether or not recursively) is docu-
         mented below.
     Optimizations that affect backtracking verbs
-        PCRE contains some optimizations that are used to speed up matching  by
+        PCRE  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
+        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
+        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 PCRE_NO_START_OPTIMIZE  option  when  calling  pcre_com-
+        by  setting  the  PCRE_NO_START_OPTIMIZE  option when calling pcre_com-
         pile() or pcre_exec(), or by starting the pattern with (*NO_START_OPT).
         There is more discussion of this option in the section entitled "Option
         bits for pcre_exec()" in the pcreapi documentation.
-        Experiments  with  Perl  suggest that it too has similar optimizations,
+        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
+        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
+        This verb causes the match to end successfully, skipping the  remainder
-        of the pattern. However, when it is inside a subpattern that is  called
+        of  the pattern. However, when it is inside a subpattern that is called
-        as  a  subroutine, only that subpattern is ended successfully. Matching
+        as a subroutine, only that subpattern is ended  successfully.  Matching
         then continues at the outer level. If (*ACCEPT) in triggered in a posi-
-        tive  assertion,  the  assertion succeeds; in a negative assertion, the
+        tive assertion, the assertion succeeds; in a  negative  assertion,  the
         assertion fails.
-        If (*ACCEPT) is inside capturing parentheses, the data so far  is  cap-
+        If  (*ACCEPT)  is inside capturing parentheses, the data so far is cap-
         tured. For example:
           A((?:A|B(*ACCEPT)|C)D)
-        This  matches  "AB", "AAD", or "ACD"; when it matches "AB", "B" is cap-
+        This matches "AB", "AAD", or "ACD"; when it matches "AB", "B"  is  cap-
         tured by the outer parentheses.
           (*FAIL) or (*F)
-        This verb causes a matching failure, forcing backtracking to occur.  It
+        This  verb causes a matching failure, forcing backtracking to occur. It
-        is  equivalent to (?!) but easier to read. The Perl documentation notes
+        is equivalent to (?!) but easier to read. The Perl documentation  notes
-        that it is probably useful only when combined  with  (?{})  or  (??{}).
+        that  it  is  probably  useful only when combined with (?{}) or (??{}).
-        Those  are,  of course, Perl features that are not present in PCRE. The
+        Those are, of course, Perl features that are not present in  PCRE.  The
-        nearest equivalent is the callout feature, as for example in this  pat-
+        nearest  equivalent is the callout feature, as for example in this pat-
         tern:
           a+(?C)(*FAIL)
-        A  match  with the string "aaaa" always fails, but the callout is taken
+        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
+        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
+        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
+        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
+        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),
+        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
+        (*PRUNE:NAME), or (*THEN:NAME) on the matching path is passed  back  to
-        the caller as  described  in  the  section  entitled  "Extra  data  for
+        the  caller  as  described  in  the  section  entitled  "Extra data for
-        pcre_exec()"  in  the  pcreapi  documentation.  Here  is  an example of
+        pcre_exec()" in the  pcreapi  documentation.  Here  is  an  example  of
-        pcretest output, where the /K modifier requests the retrieval and  out-
+        pcretest  output, where the /K modifier requests the retrieval and out-
         putting of (*MARK) data:
             re> /X(*MARK:A)Y|X(*MARK:B)Z/K
-Line 7148 
 BACKTRACKING CONTROL
+Line 7309 
 BACKTRACKING CONTROL
           MK: B
         The (*MARK) name is tagged with "MK:" in this output, and in this exam-
-        ple it indicates which of the two alternatives matched. This is a  more
+        ple  it indicates which of the two alternatives matched. This is a more
-        efficient  way of obtaining this information than putting each alterna-
+        efficient way of obtaining this information than putting each  alterna-
         tive in its own capturing parentheses.
-        If a verb with a name is encountered in a positive  assertion  that  is
+        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-encoun-
+        true, the name is recorded and passed back if it  is  the  last-encoun-
         tered. This does not happen for negative assertions or failing positive
         assertions.
-        After  a  partial match or a failed match, the last encountered name in
+        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/K
           data> XP
           No match, mark = B
-        Note that in this unanchored example the  mark  is  retained  from  the
+        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
+        If you are interested in  (*MARK)  values  after  failed  matches,  you
-        should probably set the PCRE_NO_START_OPTIMIZE option  (see  above)  to
+        should  probably  set  the PCRE_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 con-
-        tinues with what follows, but if there is no subsequent match,  causing
+        tinues  with what follows, but if there is no subsequent match, causing
-        a  backtrack  to  the  verb, a failure is forced. That is, backtracking
+        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
+        cannot  pass  to the left of the verb. However, when one of these verbs
         appears inside an atomic group or an assertion that is true, its effect
-        is confined to that group, because once the  group  has  been  matched,
+        is  confined  to  that  group, because once the group has been matched,
-        there  is never any backtracking into it. In this situation, backtrack-
+        there is never any backtracking into it. In this situation,  backtrack-
-        ing can "jump back" to the left of the entire atomic  group  or  asser-
+        ing  can  "jump  back" to the left of the entire atomic group or asser-
-        tion.  (Remember  also,  as  stated  above, that this localization also
+        tion. (Remember also, as stated  above,  that  this  localization  also
         applies in subroutine calls.)
-        These verbs differ in exactly what kind of failure  occurs  when  back-
+        These  verbs  differ  in exactly what kind of failure occurs when back-
-        tracking  reaches  them.  The behaviour described below is what happens
+        tracking reaches them. The behaviour described below  is  what  happens
-        when the verb is not in a subroutine or an assertion.  Subsequent  sec-
+        when  the  verb is not in a subroutine or an assertion. Subsequent sec-
         tions cover these special cases.
           (*COMMIT)
-        This  verb, which may not be followed by a name, causes the whole match
+        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 back-
-        tracking  to  reach  it.  Even if the pattern is unanchored, no further
+        tracking 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
+        (*COMMIT) is the only backtracking verb that is  encountered,  once  it
         has been passed pcre_exec() is committed to finding a match at the cur-
         rent 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
+        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)
+        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
+        If  there  is more than one backtracking verb in a pattern, a different
-        one  that  follows  (*COMMIT) may be triggered first, so merely passing
+        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
+        Note that (*COMMIT) at the start of a pattern is not  the  same  as  an
-        anchor, unless PCRE's start-of-match optimizations are turned  off,  as
+        anchor,  unless  PCRE's start-of-match optimizations are turned off, as
         shown in this pcretest example:
             re> /(*COMMIT)abc/
-Line 7223 
 BACKTRACKING CONTROL
+Line 7384 
 BACKTRACKING CONTROL
           xyzabc\Y
           No match
-        PCRE  knows  that  any  match  must start with "a", so the optimization
+        PCRE knows that any match must start  with  "a",  so  the  optimization
-        skips along the subject to "a" before running the first match  attempt,
+        skips  along the subject to "a" before running the first match attempt,
-        which  succeeds.  When the optimization is disabled by the \Y escape in
+        which succeeds. When the optimization is disabled by the \Y  escape  in
         the second subject, the match starts at "x" and so the (*COMMIT) causes
         it 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
+        This verb causes the match to fail at the current starting position  in
         the subject if there is a later matching failure that causes backtrack-
-        ing  to  reach it. If the pattern is unanchored, the normal "bumpalong"
+        ing to reach it. If the pattern is unanchored, the  normal  "bumpalong"
-        advance to the next starting character then happens.  Backtracking  can
+        advance  to  the next starting character then happens. Backtracking can
-        occur  as  usual to the left of (*PRUNE), before it is reached, or when
+        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
+        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
+        right, backtracking cannot cross (*PRUNE). In simple cases, the use  of
-        (*PRUNE) is just an alternative to an atomic group or possessive  quan-
+        (*PRUNE)  is just an alternative to an atomic group or possessive quan-
         tifier, 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
+        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
+        (*MARK:NAME)(*PRUNE).   It  is  like  (*MARK:NAME)  in that the name is
-        remembered  for  passing  back  to  the  caller.  However, (*SKIP:NAME)
+        remembered for  passing  back  to  the  caller.  However,  (*SKIP:NAME)
         searches only for names set with (*MARK).
           (*SKIP)
-        This verb, when given without a name, is like (*PRUNE), except that  if
+        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
+        the pattern is unanchored, the "bumpalong" advance is not to  the  next
         character, but to the position in the subject where (*SKIP) was encoun-
-        tered.  (*SKIP)  signifies that whatever text was matched leading up to
+        tered. (*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
+        If  the  subject  is  "aaaac...",  after  the first match attempt fails
-        (starting  at  the  first  character in the string), the starting point
+        (starting at the first character in the  string),  the  starting  point
         skips on to start the next attempt at "c". Note that a possessive quan-
-        tifer  does not have the same effect as this example; although it would
+        tifer does not have the same effect as this example; although it  would
-        suppress backtracking  during  the  first  match  attempt,  the  second
+        suppress  backtracking  during  the  first  match  attempt,  the second
-        attempt  would  start at the second character instead of skipping on to
+        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
+        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
+        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  back-
+        This  verb  causes  a skip to the next innermost alternative when back-
-        tracking  reaches  it.  That  is,  it  cancels any further backtracking
+        tracking reaches it. That  is,  it  cancels  any  further  backtracking
-        within the current alternative. Its name  comes  from  the  observation
+        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
+        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
+        after  the  end  of the group if FOO succeeds); on failure, the matcher
-        skips  to  the second alternative and tries COND2, without backtracking
+        skips to the second alternative and tries COND2,  without  backtracking
-        into COND1. If that succeeds and BAR fails, COND3 is tried.  If  subse-
+        into  COND1.  If that succeeds and BAR fails, COND3 is tried. If subse-
-        quently  BAZ fails, there are no more alternatives, so there is a back-
+        quently BAZ fails, there are no more alternatives, so there is a  back-
-        track to whatever came before the  entire  group.  If  (*THEN)  is  not
+        track  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
+        The   behaviour   of   (*THEN:NAME)   is   the   not   the   same    as
-        (*MARK:NAME)(*THEN).  It is like  (*MARK:NAME)  in  that  the  name  is
+        (*MARK:NAME)(*THEN).   It  is  like  (*MARK:NAME)  in  that the name is
-        remembered  for  passing  back  to  the  caller.  However, (*SKIP:NAME)
+        remembered for  passing  back  to  the  caller.  However,  (*SKIP:NAME)
         searches only for names set with (*MARK).
-        A subpattern that does not contain a | character is just a part of  the
+        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
+        enclosing alternative; it is not a nested  alternation  with  only  one
-        alternative. The effect of (*THEN) extends beyond such a subpattern  to
+        alternative.  The effect of (*THEN) extends beyond such a subpattern to
-        the  enclosing alternative. Consider this pattern, where A, B, etc. are
+        the enclosing alternative. Consider this pattern, where A, B, etc.  are
-        complex pattern fragments that do not contain any | characters at  this
+        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
+        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,
+        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
+        The  effect of (*THEN) is now confined to the inner subpattern. After a
         failure in C, matching moves to (*FAIL), which causes the whole subpat-
-        tern to fail because there are no more alternatives  to  try.  In  this
+        tern  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
+        Note that a conditional subpattern is  not  considered  as  having  two
-        alternatives, because only one is ever used.  In  other  words,  the  |
+        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 )