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

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

Parent Directory | Revision Log | View Patch Patch

-revision 454 by ph10,
Tue Sep 22 09:42:11 2009 UTC
+revision 461 by ph10,
Mon Oct  5 10:59:35 2009 UTC
 Line 2
  This file contains a concatenation of the PCRE man pages, converted to plain
  text format for ease of searching with a text editor, or for use on systems
  that do not have a man page processor. The small individual files that give
  synopses of each function in the library have not been included. Neither has
  the pcredemo program. There are separate text files for the pcregrep and
  pcretest commands.
  -----------------------------------------------------------------------------
 Line 19 
 INTRODUCTION
         The  PCRE  library is a set of functions that implement regular expres-
         sion pattern matching using the same syntax and semantics as Perl, with
-        just  a  few  differences. Certain features that appeared in Python and
+        just  a few differences. Some features that appeared in Python and PCRE
-        PCRE before they appeared in Perl are also available using  the  Python
+        before they appeared in Perl are also available using the  Python  syn-
-        syntax.  There is also some support for certain .NET and Oniguruma syn-
+        tax,  there  is  some  support for one or two .NET and Oniguruma syntax
-        tax items, and there is an option for  requesting  some  minor  changes
+        items, and there is an option for requesting some  minor  changes  that
-        that give better JavaScript compatibility.
+        give better JavaScript compatibility.
-        The  current implementation of PCRE (release 8.xx) corresponds approxi-
+        The  current implementation of PCRE corresponds approximately with Perl
-        mately with Perl 5.10, including support for UTF-8 encoded strings  and
+.10, including support for UTF-8 encoded strings and  Unicode  general
-        Unicode general category properties. However, UTF-8 and Unicode support
+        category  properties.  However,  UTF-8  and  Unicode  support has to be
-        has to be explicitly enabled; it is not the default. The Unicode tables
+        explicitly enabled; it is not the default. The  Unicode  tables  corre-
-        correspond to Unicode release 5.1.
+        spond to Unicode release 5.1.
         In  addition to the Perl-compatible matching function, PCRE contains an
-        alternative matching function that matches the same  compiled  patterns
+        alternative function that matches the same compiled patterns in a  dif-
-        in  a different way. In certain circumstances, the alternative function
+        ferent way. In certain circumstances, the alternative function has some
-        has some advantages. For a discussion of the two  matching  algorithms,
+        advantages.  For a discussion of the two matching algorithms,  see  the
-        see the pcrematching page.
+        pcrematching page.
         PCRE  is  written  in C and released as a C library. A number of people
         have written wrappers and interfaces of various kinds.  In  particular,
 Line 55 
 INTRODUCTION
         library is built. The pcre_config() function makes it  possible  for  a
         client  to  discover  which  features are available. The features them-
         selves are described in the pcrebuild page. Documentation about  build-
-        ing  PCRE for various operating systems can be found in the README file
+        ing  PCRE  for various operating systems can be found in the README and
-        in the source distribution.
+        NON-UNIX-USE files in the source distribution.
         The library contains a number of undocumented  internal  functions  and
         data  tables  that  are  used by more than one of the exported external
 Line 89 
 USER DOCUMENTATION
           pcrepartial       details of the partial matching facility
           pcrepattern       syntax and semantics of supported
                               regular expressions
-          pcresyntax        quick syntax reference
           pcreperform       discussion of performance issues
           pcreposix         the POSIX-compatible C API
           pcreprecompile    details of saving and re-using precompiled patterns
           pcresample        discussion of the pcredemo program
           pcrestack         discussion of stack usage
+          pcresyntax        quick syntax reference
           pcretest          description of the pcretest testing command
         In  addition,  in the "man" and HTML formats, there is a short page for
 Line 142 
 UTF-8 AND UNICODE PROPERTY SUPPORT
         with  the  PCRE_UTF8  option  flag,  or the pattern must start with the
         sequence (*UTF8). When either of these is the case,  both  the  pattern
         and  any  subject  strings  that  are matched against it are treated as
-        UTF-8 strings instead of just strings of bytes.
+        UTF-8 strings instead of strings of 1-byte characters.
         If you compile PCRE with UTF-8 support, but do not use it at run  time,
         the  library will be a bit bigger, but the additional run time overhead
 Line 263 
 AUTHOR
  REVISION
-        Last updated: 01 September 2009
+        Last updated: 28 September 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREBUILD(3)                                                      PCREBUILD(3)
 Line 324 
 UTF-8 SUPPORT
         to  the  configure  command.  Of  itself, this does not make PCRE treat
         strings as UTF-8. As well as compiling PCRE with this option, you  also
         have  have to set the PCRE_UTF8 option when you call the pcre_compile()
-        function.
+        or pcre_compile2() functions.
         If you set --enable-utf8 when compiling in an EBCDIC environment,  PCRE
         expects its input to be either ASCII or UTF-8 (depending on the runtime
 Line 432 
 HANDLING VERY LARGE PATTERNS
         nation metacharacter). By default, two-byte values are used  for  these
         offsets,  leading  to  a  maximum size for a compiled pattern of around
 K. This is sufficient to handle all but the most  gigantic  patterns.
-        Nevertheless,  some  people do want to process enormous patterns, so it
+        Nevertheless,  some  people do want to process truyl enormous patterns,
-        is possible to compile PCRE to use three-byte or four-byte  offsets  by
+        so it is possible to compile PCRE to use three-byte or  four-byte  off-
-        adding a setting such as
+        sets by adding a setting such as
           --with-link-size=3
 Line 461 
 AVOIDING EXCESSIVE STACK USAGE
         to the configure command. With this configuration, PCRE  will  use  the
         pcre_stack_malloc  and pcre_stack_free variables to call memory manage-
         ment functions. By default these point to malloc() and free(), but  you
-        can replace the pointers so that your own functions are used.
+        can replace the pointers so that your own functions are used instead.
         Separate  functions  are  provided  rather  than  using pcre_malloc and
         pcre_free because the  usage  is  very  predictable:  the  block  sizes
 Line 469 
 AVOIDING EXCESSIVE STACK USAGE
         reverse order. A calling program might be able to  implement  optimized
         functions  that  perform  better  than  malloc()  and free(). PCRE runs
         noticeably more slowly when built in this way. This option affects only
-        the   pcre_exec()   function;   it   is   not   relevant  for  the  the
+        the pcre_exec() function; it is not relevant for pcre_dfa_exec().
-        pcre_dfa_exec() function.
  LIMITING PCRE RESOURCE USAGE
-        Internally, PCRE has a function called match(), which it calls  repeat-
+        Internally,  PCRE has a function called match(), which it calls repeat-
-        edly   (sometimes   recursively)  when  matching  a  pattern  with  the
+        edly  (sometimes  recursively)  when  matching  a  pattern   with   the
-        pcre_exec() function. By controlling the maximum number of  times  this
+        pcre_exec()  function.  By controlling the maximum number of times this
-        function  may be called during a single matching operation, a limit can
+        function may be called during a single matching operation, a limit  can
-        be placed on the resources used by a single call  to  pcre_exec().  The
+        be  placed  on  the resources used by a single call to pcre_exec(). The
-        limit  can be changed at run time, as described in the pcreapi documen-
+        limit can be changed at run time, as described in the pcreapi  documen-
-        tation. The default is 10 million, but this can be changed by adding  a
+        tation.  The default is 10 million, but this can be changed by adding a
         setting such as
           --with-match-limit=500000
-        to   the   configure  command.  This  setting  has  no  effect  on  the
+        to  the  configure  command.  This  setting  has  no  effect   on   the
         pcre_dfa_exec() matching function.
-        In some environments it is desirable to limit the  depth  of  recursive
+        In  some  environments  it is desirable to limit the depth of recursive
         calls of match() more strictly than the total number of calls, in order
-        to restrict the maximum amount of stack (or heap,  if  --disable-stack-
+        to  restrict  the maximum amount of stack (or heap, if --disable-stack-
         for-recursion is specified) that is used. A second limit controls this;
-        it defaults to the value that  is  set  for  --with-match-limit,  which
+        it  defaults  to  the  value  that is set for --with-match-limit, which
-        imposes  no  additional constraints. However, you can set a lower limit
+        imposes no additional constraints. However, you can set a  lower  limit
         by adding, for example,
           --with-match-limit-recursion=10000
-        to the configure command. This value can  also  be  overridden  at  run
+        to  the  configure  command.  This  value can also be overridden at run
         time.
  CREATING CHARACTER TABLES AT BUILD TIME
-        PCRE  uses fixed tables for processing characters whose code values are
+        PCRE uses fixed tables for processing characters whose code values  are
-        less than 256. By default, PCRE is built with a set of tables that  are
+        less  than 256. By default, PCRE is built with a set of tables that are
-        distributed  in  the  file pcre_chartables.c.dist. These tables are for
+        distributed in the file pcre_chartables.c.dist. These  tables  are  for
         ASCII codes only. If you add
           --enable-rebuild-chartables
-        to the configure command, the distributed tables are  no  longer  used.
+        to  the  configure  command, the distributed tables are no longer used.
-        Instead,  a  program  called dftables is compiled and run. This outputs
+        Instead, a program called dftables is compiled and  run.  This  outputs
         the source for new set of tables, created in the default locale of your
         C runtime system. (This method of replacing the tables does not work if
-        you are cross compiling, because dftables is run on the local host.  If
+        you  are cross compiling, because dftables is run on the local host. If
-        you  need  to  create alternative tables when cross compiling, you will
+        you need to create alternative tables when cross  compiling,  you  will
         have to do so "by hand".)
  USING EBCDIC CODE
-        PCRE assumes by default that it will run in an  environment  where  the
+        PCRE  assumes  by  default that it will run in an environment where the
-        character  code  is  ASCII  (or Unicode, which is a superset of ASCII).
+        character code is ASCII (or Unicode, which is  a  superset  of  ASCII).
-        This is the case for most computer operating systems.  PCRE  can,  how-
+        This  is  the  case for most computer operating systems. PCRE can, how-
         ever, be compiled to run in an EBCDIC environment by adding
           --enable-ebcdic
         to the configure command. This setting implies --enable-rebuild-charta-
-        bles. You should only use it if you know that  you  are  in  an  EBCDIC
+        bles.  You  should  only  use  it if you know that you are in an EBCDIC
-        environment  (for  example,  an  IBM  mainframe  operating system). The
+        environment (for example,  an  IBM  mainframe  operating  system).  The
         --enable-ebcdic option is incompatible with --enable-utf8.
-Line 546 
 PCREGREP OPTIONS FOR COMPRESSED FILE SUP
+Line 545 
 PCREGREP OPTIONS FOR COMPRESSED FILE SUP
           --enable-pcregrep-libbz2
         to the configure command. These options naturally require that the rel-
-        evant  libraries  are installed on your system. Configuration will fail
+        evant libraries are installed on your system. Configuration  will  fail
         if they are not.
-Line 556 
 PCRETEST OPTION FOR LIBREADLINE SUPPORT
+Line 555 
 PCRETEST OPTION FOR LIBREADLINE SUPPORT
           --enable-pcretest-libreadline
-        to the configure command,  pcretest  is  linked  with  the  libreadline
+        to  the  configure  command,  pcretest  is  linked with the libreadline
-        library,  and  when its input is from a terminal, it reads it using the
+        library, and when its input is from a terminal, it reads it  using  the
         readline() function. This provides line-editing and history facilities.
-        Note that libreadline is GPL-licenced, so if you distribute a binary of
+        Note that libreadline is GPL-licensed, so if you distribute a binary of
         pcretest linked in this way, there may be licensing issues.
-        Setting this option causes the -lreadline option to  be  added  to  the
+        Setting  this  option  causes  the -lreadline option to be added to the
-        pcretest  build.  In many operating environments with a sytem-installed
+        pcretest build. In many operating environments with  a  sytem-installed
         libreadline this is sufficient. However, in some environments (e.g.  if
-        an  unmodified  distribution version of readline is in use), some extra
+        an unmodified distribution version of readline is in use),  some  extra
-        configuration may be necessary. The INSTALL file for  libreadline  says
+        configuration  may  be necessary. The INSTALL file for libreadline says
         this:
           "Readline uses the termcap functions, but does not link with the
           termcap or curses library itself, allowing applications which link
           with readline the to choose an appropriate library."
-        If  your environment has not been set up so that an appropriate library
+        If your environment has not been set up so that an appropriate  library
         is automatically included, you may need to add something like
           LIBS="-ncurses"
-Line 595 
 AUTHOR
+Line 594 
 AUTHOR
  REVISION
-        Last updated: 06 September 2009
+        Last updated: 29 September 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREMATCHING(3)                                                PCREMATCHING(3)
-Line 683 
 THE ALTERNATIVE MATCHING ALGORITHM
+Line 682 
 THE ALTERNATIVE MATCHING ALGORITHM
         though  it is not implemented as a traditional finite state machine (it
         keeps multiple states active simultaneously).
+        Although the general principle of this matching algorithm  is  that  it
+        scans  the subject string only once, without backtracking, there is one
+        exception: when a lookaround assertion is encountered,  the  characters
+        following  or  preceding  the  current  point  have to be independently
+        inspected.
         The scan continues until either the end of the subject is  reached,  or
         there  are  no more unterminated paths. At this point, terminated paths
         represent the different matching possibilities (if there are none,  the
         match  has  failed).   Thus,  if there is more than one possible match,
         this algorithm finds all of them, and in particular, it finds the long-
-        est.  In PCRE, there is an option to stop the algorithm after the first
+        est.  There  is  an  option to stop the algorithm after the first match
-        match (which is necessarily the shortest) has been found.
+        (which is necessarily the shortest) is found.
         Note that all the matches that are found start at the same point in the
         subject. If the pattern
-Line 701 
 THE ALTERNATIVE MATCHING ALGORITHM
+Line 706 
 THE ALTERNATIVE MATCHING ALGORITHM
         at the fourth character of the subject. The algorithm does not automat-
         ically move on to find matches that start at later positions.
-        Although the general principle of this matching algorithm  is  that  it
-        scans  the subject string only once, without backtracking, there is one
-        exception: when a lookbehind assertion is  encountered,  the  preceding
-        characters have to be re-inspected.
         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) matches a
+. The \C escape sequence, which (in the standard algorithm) matches  a
-        single byte, even in UTF-8 mode, is not supported because the  alterna-
+        single  byte, even in UTF-8 mode, is not supported because the alterna-
-        tive  algorithm  moves  through  the  subject string one character at a
+        tive algorithm moves through the subject  string  one  character  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, it is possible to pass very long
+        once, and never needs to backtrack, it is possible to  pass  very  long
-        subject strings to the matching function in  several  pieces,  checking
+        subject  strings  to  the matching function in several pieces, checking
-        for partial matching each time.
+        for partial matching each time.  The  pcrepartial  documentation  gives
+        details of partial matching.
  DISADVANTAGES OF THE ALTERNATIVE ALGORITHM
-Line 793 
 AUTHOR
+Line 794 
 AUTHOR
  REVISION
-        Last updated: 05 September 2009
+        Last updated: 29 September 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREAPI(3)                                                          PCREAPI(3)
-Line 1126 
 COMPILING A PATTERN
+Line 1127 
 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,
-        errorcodeptr, via which a numerical error code can be returned.
+        errorcodeptr, via which a numerical error  code  can  be  returned.  To
+        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
-Line 1144 
 COMPILING A PATTERN
+Line 1147 
 COMPILING A PATTERN
         The options argument contains various bit settings that affect the com-
         pilation. It should be zero if no options are required.  The  available
         options  are  described  below. Some of them (in particular, those that
-        are compatible with Perl, but also some others) 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
         pcrepattern documentation). For those options that can be different  in
         different  parts  of  the pattern, the contents of the options argument
-        specifies their initial settings at the start of compilation and execu-
+        specifies their settings at the start of compilation and execution. The
-        tion.  The PCRE_ANCHORED and PCRE_NEWLINE_xxx options can be set at the
+        PCRE_ANCHORED, PCRE_BSR_xxx, and PCRE_NEWLINE_xxx options can be set at
-        time of matching as well as at compile time.
+        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
         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. The byte offset from the start of the  pattern  to  the
-        character  that  was  being  processes when the error was discovered is
+        character  that  was  being  processed when the error was discovered is
         placed in the variable pointed to by erroffset, which must not be NULL.
         If  it  is,  an  immediate error is given. Some errors are not detected
         until checks are carried out when the whole pattern has  been  scanned;
-Line 1491 
 STUDYING A PATTERN
+Line 1494 
 STUDYING A PATTERN
         the results of the study.
         The  returned  value  from  pcre_study()  can  be  passed  directly  to
-        pcre_exec(). However, a pcre_extra block  also  contains  other  fields
+        pcre_exec() or pcre_dfa_exec(). However, a pcre_extra block  also  con-
-        that  can  be  set  by the caller before the block is passed; these are
+        tains  other  fields  that can be set by the caller before the block is
-        described below in the section on matching a pattern.
+        passed; these are described below in the section on matching a pattern.
-        If studying the pattern does not  produce  any  additional  information
+        If studying the  pattern  does  not  produce  any  useful  information,
         pcre_study() returns NULL. In that circumstance, if the calling program
-        wants to pass any of the other fields to pcre_exec(), it  must  set  up
+        wants  to  pass  any  of   the   other   fields   to   pcre_exec()   or
-        its own pcre_extra block.
+        pcre_dfa_exec(), it must set up its own pcre_extra block.
         The  second  argument of pcre_study() contains option bits. At present,
         no options are defined, and this argument should always be zero.
-Line 1518 
 STUDYING A PATTERN
+Line 1521 
 STUDYING A PATTERN
 ,              /* no options exist */
             &error);        /* set to NULL or points to a message */
-        At present, studying a pattern is useful only for non-anchored patterns
+        Studying a pattern does two things: first, a lower bound for the length
-        that do not have a single fixed starting character. A bitmap of  possi-
+        of subject string that is needed to match the pattern is computed. This
-        ble starting bytes is created.
+        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  by
+        pcre_exec()  and  pcre_dfa_exec()  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 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
+        bytes  is  created. This speeds up finding a position in the subject at
+        which to start matching.
  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 value. When running in UTF-8 mode, this  applies  only  to
-        characters with codes less than 128. Higher-valued  codes  never  match
+        characters  with  codes  less than 128. Higher-valued codes never match
-        escapes  such  as  \w or \d, but can be tested with \p if PCRE is built
+        escapes such as \w or \d, but can be tested with \p if  PCRE  is  built
-        with Unicode character property support. The use of locales  with  Uni-
+        with  Unicode  character property support. The use of locales with Uni-
-        code  is discouraged. If you are handling characters with codes greater
+        code is discouraged. If you are handling characters with codes  greater
-        than 128, you should either use UTF-8 and Unicode, or use locales,  but
+        than  128, you should either use UTF-8 and Unicode, or use locales, but
         not try to mix the two.
-        PCRE  contains  an  internal set of tables that are used when the final
+        PCRE contains an internal set of tables that are used  when  the  final
-        argument of pcre_compile() is  NULL.  These  are  sufficient  for  many
+        argument  of  pcre_compile()  is  NULL.  These  are sufficient for many
         applications.  Normally, the internal tables recognize only ASCII char-
         acters. However, when PCRE is built, it is possible to cause the inter-
         nal tables to be rebuilt in the default "C" locale of the local system,
         which may cause them to be different.
-        The internal tables can always be overridden by tables supplied by  the
+        The  internal tables can always be overridden by tables supplied by the
         application that calls PCRE. These may be created in a different locale
-        from the default. As more and more applications change  to  using  Uni-
+        from  the  default.  As more and more applications change to using Uni-
         code, the need for this locale support is expected to die away.
-        External  tables  are  built by calling the pcre_maketables() function,
+        External tables are built by calling  the  pcre_maketables()  function,
-        which has no arguments, in the relevant locale. The result can then  be
+        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() or pcre_exec()  as  often  as  necessary.  For
-        example, to build and use tables that are appropriate  for  the  French
+        example,  to  build  and use tables that are appropriate for the French
-        locale  (where  accented  characters  with  values greater than 128 are
+        locale (where accented characters with  values  greater  than  128  are
         treated as letters), the following code could be used:
           setlocale(LC_CTYPE, "fr_FR");
           tables = pcre_maketables();
           re = pcre_compile(..., tables);
-        The locale name "fr_FR" is used on Linux and other  Unix-like  systems;
+        The  locale  name "fr_FR" is used on Linux and other Unix-like systems;
         if you are using Windows, the name for the French locale is "french".
-        When  pcre_maketables()  runs,  the  tables are built in memory that is
+        When pcre_maketables() runs, the tables are built  in  memory  that  is
-        obtained via pcre_malloc. It is the caller's responsibility  to  ensure
+        obtained  via  pcre_malloc. It is the caller's responsibility to ensure
-        that  the memory containing the tables remains available for as long as
+        that the memory containing the tables remains available for as long  as
         it is needed.
         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()
+        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-
         tern, compilation, studying and matching all happen in the same locale,
         but different patterns can be compiled in different locales.
-        It is possible to pass a table pointer or NULL (indicating the  use  of
+        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(). Although  not  intended  for  this
-        purpose, this facility could be used to match a pattern in a  different
+        purpose,  this facility could be used to match a pattern in a different
         locale from the one in which it was compiled. Passing table pointers at
         run time is discussed below in the section on matching a pattern.
-Line 1584 
 INFORMATION ABOUT A PATTERN
+Line 1596 
 INFORMATION ABOUT A PATTERN
         int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
              int what, void *where);
-        The pcre_fullinfo() function returns information about a compiled  pat-
+        The  pcre_fullinfo() function returns information about a compiled pat-
         tern. It replaces the obsolete pcre_info() function, which is neverthe-
         less retained for backwards compability (and is documented below).
-        The first argument for pcre_fullinfo() is a  pointer  to  the  compiled
+        The  first  argument  for  pcre_fullinfo() is a pointer to the compiled
-        pattern.  The second argument is the result of pcre_study(), or NULL if
+        pattern. The second argument is the result of pcre_study(), or NULL  if
-        the pattern was not studied. The third argument specifies  which  piece
+        the  pattern  was not studied. The third argument specifies which piece
-        of  information  is required, and the fourth argument is a pointer to a
+        of information is required, and the fourth argument is a pointer  to  a
-        variable to receive the data. The yield of the  function  is  zero  for
+        variable  to  receive  the  data. The yield of the function is zero for
         success, or one of the following negative numbers:
           PCRE_ERROR_NULL       the argument code was NULL
-Line 1600 
 INFORMATION ABOUT A PATTERN
+Line 1612 
 INFORMATION ABOUT A PATTERN
           PCRE_ERROR_BADMAGIC   the "magic number" was not found
           PCRE_ERROR_BADOPTION  the value of what was invalid
-        The  "magic  number" is placed at the start of each compiled pattern as
+        The "magic number" is placed at the start of each compiled  pattern  as
-        an simple check against passing an arbitrary memory pointer. Here is  a
+        an  simple check against passing an arbitrary memory pointer. Here is a
-        typical  call  of pcre_fullinfo(), to obtain the length of the compiled
+        typical call of pcre_fullinfo(), to obtain the length of  the  compiled
         pattern:
           int rc;
-Line 1613 
 INFORMATION ABOUT A PATTERN
+Line 1625 
 INFORMATION ABOUT A PATTERN
             PCRE_INFO_SIZE,   /* what is required */
             &length);         /* where to put the data */
-        The possible values for the third argument are defined in  pcre.h,  and
+        The  possible  values for the third argument are defined in pcre.h, and
         are as follows:
           PCRE_INFO_BACKREFMAX
-        Return  the  number  of  the highest back reference in the pattern. The
+        Return the number of the highest back reference  in  the  pattern.  The
-        fourth argument should point to an int variable. Zero  is  returned  if
+        fourth  argument  should  point to an int variable. Zero is returned if
         there are no back references.
           PCRE_INFO_CAPTURECOUNT
-        Return  the  number of capturing subpatterns in the pattern. The fourth
+        Return the number of capturing subpatterns in the pattern.  The  fourth
         argument should point to an int variable.
           PCRE_INFO_DEFAULT_TABLES
-        Return a pointer to the internal default character tables within  PCRE.
+        Return  a pointer to the internal default character tables within PCRE.
-        The  fourth  argument should point to an unsigned char * variable. This
+        The fourth argument should point to an unsigned char *  variable.  This
         information call is provided for internal use by the pcre_study() func-
-        tion.  External  callers  can  cause PCRE to use its internal tables by
+        tion. External callers can cause PCRE to use  its  internal  tables  by
         passing a NULL table pointer.
           PCRE_INFO_FIRSTBYTE
-        Return information about the first byte of any matched  string,  for  a
+        Return  information  about  the first byte of any matched string, for a
-        non-anchored  pattern. The fourth argument should point to an int vari-
+        non-anchored pattern. The fourth argument should point to an int  vari-
-        able. (This option used to be called PCRE_INFO_FIRSTCHAR; the old  name
+        able.  (This option used to be called PCRE_INFO_FIRSTCHAR; the old name
         is still recognized for backwards compatibility.)
-        If  there  is  a  fixed first byte, for example, from a pattern such as
+        If there is a fixed first byte, for example, from  a  pattern  such  as
         (cat|cow|coyote), its value is returned. Otherwise, if either
-        (a) the pattern was compiled with the PCRE_MULTILINE option, and  every
+        (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
+        -1  is  returned, indicating that the pattern matches only at the start
-        of  a  subject string or after any newline within the string. Otherwise
+        of a subject string or after any newline within the  string.  Otherwise
         -2 is returned. For anchored patterns, -2 is returned.
           PCRE_INFO_FIRSTTABLE
-        If the pattern was studied, and this resulted in the construction of  a
+        If  the pattern was studied, and this resulted in the construction of a
 -bit table indicating a fixed set of bytes for the first byte in any
-        matching string, a pointer to the table is returned. Otherwise NULL  is
+        matching  string, a pointer to the table is returned. Otherwise NULL is
-        returned.  The fourth argument should point to an unsigned char * vari-
+        returned. The fourth argument should point to an unsigned char *  vari-
         able.
           PCRE_INFO_HASCRORLF
-        Return 1 if the pattern contains any explicit  matches  for  CR  or  LF
+        Return  1  if  the  pattern  contains any explicit matches for CR or LF
-        characters,  otherwise  0.  The  fourth argument should point to an int
+        characters, otherwise 0. The fourth argument should  point  to  an  int
-        variable. An explicit match is either a literal CR or LF character,  or
+        variable.  An explicit match is either a literal CR or LF character, or
         \r or \n.
           PCRE_INFO_JCHANGED
-        Return  1  if  the (?J) or (?-J) option setting is used in the pattern,
+        Return 1 if the (?J) or (?-J) option setting is used  in  the  pattern,
-        otherwise 0. The fourth argument should point to an int variable.  (?J)
+        otherwise  0. The fourth argument should point to an int variable. (?J)
         and (?-J) set and unset the local PCRE_DUPNAMES option, respectively.
           PCRE_INFO_LASTLITERAL
-        Return  the  value of the rightmost literal byte that must exist in any
+        Return the value of the rightmost literal byte that must exist  in  any
-        matched string, other than at its  start,  if  such  a  byte  has  been
+        matched  string,  other  than  at  its  start,  if such a byte has been
         recorded. The fourth argument should point to an int variable. If there
-        is no such byte, -1 is returned. For anchored patterns, a last  literal
+        is  no such byte, -1 is returned. For anchored patterns, a last literal
-        byte  is  recorded only if it follows something of variable length. For
+        byte is recorded only if it follows something of variable  length.  For
         example, for the pattern /^a\d+z\d+/ the returned value is "z", but for
         /^a\dz\d/ the returned value is -1.
+          PCRE_INFO_MINLENGTH
+        If the pattern was studied and a minimum length  for  matching  subject
+        strings  was  computed,  its  value is returned. Otherwise the returned
+        value is -1. The value is a number of characters, not bytes  (this  may
+        be  relevant in UTF-8 mode). The fourth argument should 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 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 (a pointer to char). The
+        a pointer to the first entry of the table  (a  pointer  to  char).  The
         first two bytes of each entry are the number of the capturing parenthe-
-        sis,  most  significant byte first. The rest of the entry is the corre-
+        sis, most significant byte first. The rest of the entry is  the  corre-
-        sponding name, zero terminated. The names are  in  alphabetical  order.
+        sponding name, zero terminated.
-        When PCRE_DUPNAMES is set, duplicate names are in order of their paren-
-        theses numbers. For example, consider  the  following  pattern  (assume
+        The  names are in alphabetical order. Duplicate names may appear if (?|
-        PCRE_EXTENDED  is  set,  so  white  space  -  including  newlines  - is
+        is used to create multiple groups with the same number, as described in
-        ignored):
+        the  section  on  duplicate subpattern numbers in the pcrepattern page.
+        Duplicate names for subpatterns with different  numbers  are  permitted
+        only  if  PCRE_DUPNAMES  is  set. In all cases of duplicate names, they
+        appear in the table in the order in which they were found in  the  pat-
+        tern.  In  the  absence  of (?| this is the order of increasing number;
+        when (?| is used this is not necessarily the case because later subpat-
+        terns may have lower numbers.
+        As  a  simple  example of the name/number table, consider the following
+        pattern (assume PCRE_EXTENDED is set, so white space -  including  new-
+        lines - is ignored):
           (?<date> (?<year>(\d\d)?\d\d) -
           (?<month>\d\d) - (?<day>\d\d) )
-        There are four named subpatterns, so the table has  four  entries,  and
+        There  are  four  named subpatterns, so the table has four entries, and
-        each  entry  in the table is eight bytes long. The table is as follows,
+        each entry in the table is eight bytes long. The table is  as  follows,
         with non-printing bytes shows in hexadecimal, and undefined bytes shown
         as ??:
-Line 1726 
 INFORMATION ABOUT A PATTERN
+Line 1758 
 INFORMATION ABOUT A PATTERN
 04 m  o  n  t  h  00
 02 y  e  a  r  00 ??
-        When  writing  code  to  extract  data from named subpatterns using the
+        When writing code to extract data  from  named  subpatterns  using  the
-        name-to-number map, remember that the length of the entries  is  likely
+        name-to-number  map,  remember that the length of the entries is likely
         to be different for each compiled pattern.
           PCRE_INFO_OKPARTIAL
-        Return  1  if  the  pattern  can  be  used  for  partial  matching with
+        Return 1  if  the  pattern  can  be  used  for  partial  matching  with
-        pcre_exec(), otherwise 0. The fourth argument should point  to  an  int
+        pcre_exec(),  otherwise  0.  The fourth argument should point to an int
-        variable.  From  release  8.00,  this  always  returns  1,  because the
+        variable. From  release  8.00,  this  always  returns  1,  because  the
-        restrictions that previously applied  to  partial  matching  have  been
+        restrictions  that  previously  applied  to  partial matching have been
-        lifted.  The  pcrepartial documentation gives details of partial match-
+        lifted. The pcrepartial documentation gives details of  partial  match-
         ing.
           PCRE_INFO_OPTIONS
-        Return a copy of the options with which the pattern was  compiled.  The
+        Return  a  copy of the options with which the pattern was compiled. The
-        fourth  argument  should  point to an unsigned long int variable. These
+        fourth argument should point to an unsigned long  int  variable.  These
         option bits are those specified in the call to pcre_compile(), modified
         by any top-level option settings at the start of the pattern itself. In
-        other words, they are the options that will be in force  when  matching
+        other  words,  they are the options that will be in force when matching
-        starts.  For  example, if the pattern /(?im)abc(?-i)d/ is compiled with
+        starts. For example, if the pattern /(?im)abc(?-i)d/ is  compiled  with
-        the PCRE_EXTENDED option, the result is PCRE_CASELESS,  PCRE_MULTILINE,
+        the  PCRE_EXTENDED option, the result is PCRE_CASELESS, PCRE_MULTILINE,
         and PCRE_EXTENDED.
-        A  pattern  is  automatically  anchored by PCRE if all of its top-level
+        A pattern is automatically anchored by PCRE if  all  of  its  top-level
         alternatives begin with one of the following:
           ^     unless PCRE_MULTILINE is set
-Line 1764 
 INFORMATION ABOUT A PATTERN
+Line 1796 
 INFORMATION ABOUT A PATTERN
           PCRE_INFO_SIZE
-        Return  the  size  of the compiled pattern, that is, the value that was
+        Return the size of the compiled pattern, that is, the  value  that  was
         passed as the argument to pcre_malloc() when PCRE was getting memory in
         which to place the compiled data. The fourth argument should point to a
         size_t variable.
-Line 1772 
 INFORMATION ABOUT A PATTERN
+Line 1804 
 INFORMATION ABOUT A PATTERN
           PCRE_INFO_STUDYSIZE
         Return the size of the data block pointed to by the study_data field in
-        a  pcre_extra  block.  That  is,  it  is  the  value that was passed to
+        a pcre_extra block. That is,  it  is  the  value  that  was  passed  to
         pcre_malloc() when PCRE was getting memory into which to place the data
-        created  by  pcre_study(). The fourth argument should point to a size_t
+        created by pcre_study(). If pcre_extra is NULL, or there  is  no  study
+        data,  zero  is  returned. The fourth argument should point to a size_t
         variable.
-Line 1830 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1863 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
         The  function pcre_exec() is called to match a subject string against a
         compiled pattern, which is passed in the code argument. If the  pattern
-        has been studied, the result of the study should be passed in the extra
+        was  studied,  the  result  of  the study should be passed in the extra
         argument. This function is the main matching facility of  the  library,
         and it operates in a Perl-like manner. For specialist use there is also
         an alternative matching function, which is described below in the  sec-
-Line 1889 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1922 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
         The match_limit field provides a means of preventing PCRE from using up
         a  vast amount of resources when running patterns that are not going to
         match, but which have a very large number  of  possibilities  in  their
-        search  trees.  The  classic  example  is  the  use of nested unlimited
+        search  trees. The classic example is a pattern that uses nested unlim-
-        repeats.
+        ited repeats.
         Internally, PCRE uses a function called match() which it calls  repeat-
         edly  (sometimes  recursively). The limit set by match_limit is imposed
-Line 2177 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2210 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
         has to get additional memory for use during matching. Thus it  is  usu-
         ally advisable to supply an ovector.
-        The  pcre_info()  function  can  be used to find out how many capturing
+        The pcre_fullinfo() function can be used to find out how many capturing
         subpatterns there are in a compiled  pattern.  The  smallest  size  for
         ovector  that  will allow for n captured substrings, in addition to the
         offsets of the substring matched by the whole pattern, is (n+1)*3.
-Line 2438 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
+Line 2471 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
         ate.  NOTE:  If PCRE_DUPNAMES is set and there are duplicate names, the
         behaviour may not be what you want (see the next section).
-        Warning: If the pattern uses the "(?|" feature to set up multiple  sub-
+        Warning: If the pattern uses the (?| feature to set up multiple subpat-
-        patterns  with  the  same  number,  you cannot use names to distinguish
+        terns  with  the  same number, as described in the section on duplicate
-        them, because names are not included in the compiled code. The matching
+        subpattern numbers in the pcrepattern page, you  cannot  use  names  to
-        process uses only numbers.
+        distinguish  the  different subpatterns, because names are not included
+        in the compiled code. The matching process uses only numbers. For  this
+        reason,  the  use of different names for subpatterns of the same number
+        causes an error at compile time.
  DUPLICATE SUBPATTERN NAMES
-Line 2449 
 DUPLICATE SUBPATTERN NAMES
+Line 2485 
 DUPLICATE SUBPATTERN NAMES
         int pcre_get_stringtable_entries(const pcre *code,
              const char *name, char **first, char **last);
-        When  a  pattern  is  compiled with the PCRE_DUPNAMES option, names for
+        When a pattern is compiled with the  PCRE_DUPNAMES  option,  names  for
-        subpatterns are not required to  be  unique.  Normally,  patterns  with
+        subpatterns  are not required to be unique. (Duplicate names are always
-        duplicate  names  are such that in any one match, only one of the named
+        allowed for subpatterns with the same number, created by using the  (?|
-        subpatterns participates. An example is shown in the pcrepattern  docu-
+        feature.  Indeed,  if  such subpatterns are named, they are required to
-        mentation.
+        use the same names.)
+        Normally, patterns with duplicate names are such that in any one match,
+        only  one of the named subpatterns participates. An example is shown in
+        the pcrepattern documentation.
-        When    duplicates   are   present,   pcre_copy_named_substring()   and
+        When   duplicates   are   present,   pcre_copy_named_substring()    and
-        pcre_get_named_substring() return the first substring corresponding  to
+        pcre_get_named_substring()  return the first substring corresponding to
-        the  given  name  that  is set. If none are set, PCRE_ERROR_NOSUBSTRING
+        the given name that is set. If  none  are  set,  PCRE_ERROR_NOSUBSTRING
-        (-7) is returned; no  data  is  returned.  The  pcre_get_stringnumber()
+        (-7)  is  returned;  no  data  is returned. The pcre_get_stringnumber()
-        function  returns one of the numbers that are associated with the name,
+        function returns one of the numbers that are associated with the  name,
         but it is not defined which it is.
-        If you want to get full details of all captured substrings for a  given
+        If  you want to get full details of all captured substrings for a given
-        name,  you  must  use  the pcre_get_stringtable_entries() function. The
+        name, you must use  the  pcre_get_stringtable_entries()  function.  The
         first argument is the compiled pattern, and the second is the name. The
-        third  and  fourth  are  pointers to variables which are updated by the
+        third and fourth are pointers to variables which  are  updated  by  the
         function. After it has run, they point to the first and last entries in
-        the  name-to-number  table  for  the  given  name.  The function itself
+        the name-to-number table  for  the  given  name.  The  function  itself
-        returns the length of each entry,  or  PCRE_ERROR_NOSUBSTRING  (-7)  if
+        returns  the  length  of  each entry, or PCRE_ERROR_NOSUBSTRING (-7) if
-        there  are none. The format of the table is described above in the sec-
+        there are none. The format of the table is described above in the  sec-
-        tion entitled Information about a  pattern.   Given  all  the  relevant
+        tion  entitled  Information  about  a  pattern.  Given all the relevant
-        entries  for the name, you can extract each of their numbers, and hence
+        entries for the name, you can extract each of their numbers, and  hence
         the captured data, if any.
  FINDING ALL POSSIBLE MATCHES
-        The traditional matching function uses a  similar  algorithm  to  Perl,
+        The  traditional  matching  function  uses a similar algorithm to Perl,
         which stops when it finds the first match, starting at a given point in
-        the subject. If you want to find all possible matches, or  the  longest
+        the  subject.  If you want to find all possible matches, or the longest
-        possible  match,  consider using the alternative matching function (see
+        possible match, consider using the alternative matching  function  (see
-        below) instead. If you cannot use the alternative function,  but  still
+        below)  instead.  If you cannot use the alternative function, but still
-        need  to  find all possible matches, you can kludge it up by making use
+        need to find all possible matches, you can kludge it up by  making  use
         of the callout facility, which is described in the pcrecallout documen-
         tation.
         What you have to do is to insert a callout right at the end of the pat-
-        tern.  When your callout function is called, extract and save the  cur-
+        tern.   When your callout function is called, extract and save the cur-
-        rent  matched  substring.  Then  return  1, which forces pcre_exec() to
+        rent matched substring. Then return  1,  which  forces  pcre_exec()  to
-        backtrack and try other alternatives. Ultimately, when it runs  out  of
+        backtrack  and  try other alternatives. Ultimately, when it runs out of
         matches, pcre_exec() will yield PCRE_ERROR_NOMATCH.
-Line 2500 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2540 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
              int options, int *ovector, int ovecsize,
              int *workspace, int wscount);
-        The  function  pcre_dfa_exec()  is  called  to  match  a subject string
+        The function pcre_dfa_exec()  is  called  to  match  a  subject  string
-        against a compiled pattern, using a matching algorithm that  scans  the
+        against  a  compiled pattern, using a matching algorithm that scans the
-        subject  string  just  once, and does not backtrack. This has different
+        subject string just once, and does not backtrack.  This  has  different
-        characteristics to the normal algorithm, and  is  not  compatible  with
+        characteristics  to  the  normal  algorithm, and is not compatible with
-        Perl.  Some  of the features of PCRE patterns are not supported. Never-
+        Perl. Some of the features of PCRE patterns are not  supported.  Never-
-        theless, there are times when this kind of matching can be useful.  For
+        theless,  there are times when this kind of matching can be useful. For
-        a  discussion  of  the  two matching algorithms, and a list of features
+        a discussion of the two matching algorithms, and  a  list  of  features
-        that pcre_dfa_exec() does not support, see the pcrematching  documenta-
+        that  pcre_dfa_exec() does not support, see the pcrematching documenta-
         tion.
-        The  arguments  for  the  pcre_dfa_exec()  function are the same as for
+        The arguments for the pcre_dfa_exec() function  are  the  same  as  for
         pcre_exec(), plus two extras. The ovector argument is used in a differ-
-        ent  way,  and  this is described below. The other common arguments are
+        ent way, and this is described below. The other  common  arguments  are
-        used in the same way as for pcre_exec(), so their  description  is  not
+        used  in  the  same way as for pcre_exec(), so their description is not
         repeated here.
-        The  two  additional  arguments provide workspace for the function. The
+        The two additional arguments provide workspace for  the  function.  The
-        workspace vector should contain at least 20 elements. It  is  used  for
+        workspace  vector  should  contain at least 20 elements. It is used for
         keeping  track  of  multiple  paths  through  the  pattern  tree.  More
-        workspace will be needed for patterns and subjects where  there  are  a
+        workspace  will  be  needed for patterns and subjects where there are a
         lot of potential matches.
         Here is an example of a simple call to pcre_dfa_exec():
-Line 2541 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2581 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
     Option bits for pcre_dfa_exec()
-        The  unused  bits  of  the options argument for pcre_dfa_exec() must be
+        The unused bits of the options argument  for  pcre_dfa_exec()  must  be
-        zero. The only bits  that  may  be  set  are  PCRE_ANCHORED,  PCRE_NEW-
+        zero.  The  only  bits  that  may  be  set are PCRE_ANCHORED, PCRE_NEW-
         LINE_xxx,        PCRE_NOTBOL,        PCRE_NOTEOL,        PCRE_NOTEMPTY,
         PCRE_NOTEMPTY_ATSTART, PCRE_NO_UTF8_CHECK, PCRE_PARTIAL_HARD, PCRE_PAR-
-        TIAL_SOFT,  PCRE_DFA_SHORTEST,  and  PCRE_DFA_RESTART. All but the last
+        TIAL_SOFT, PCRE_DFA_SHORTEST, and PCRE_DFA_RESTART. All  but  the  last
-        four of these are  exactly  the  same  as  for  pcre_exec(),  so  their
+        four  of  these  are  exactly  the  same  as  for pcre_exec(), so their
         description is not repeated here.
           PCRE_PARTIAL_HARD
           PCRE_PARTIAL_SOFT
-        These  have the same general effect as they do for pcre_exec(), but the
+        These have the same general effect as they do for pcre_exec(), but  the
-        details are slightly  different.  When  PCRE_PARTIAL_HARD  is  set  for
+        details  are  slightly  different.  When  PCRE_PARTIAL_HARD  is set for
-        pcre_dfa_exec(),  it  returns PCRE_ERROR_PARTIAL if the end of the sub-
+        pcre_dfa_exec(), it returns PCRE_ERROR_PARTIAL if the end of  the  sub-
-        ject is reached and there is still at least  one  matching  possibility
+        ject  is  reached  and there is still at least one matching possibility
         that requires additional characters. This happens even if some complete
         matches have also been found. When PCRE_PARTIAL_SOFT is set, the return
         code PCRE_ERROR_NOMATCH is converted into PCRE_ERROR_PARTIAL if the end
-        of the subject is reached, there have been  no  complete  matches,  but
+        of  the  subject  is  reached, there have been no complete matches, but
-        there  is  still  at least one matching possibility. The portion of the
+        there is still at least one matching possibility. The  portion  of  the
-        string that was inspected when the longest partial match was  found  is
+        string  that  was inspected when the longest partial match was found is
         set as the first matching string in both cases.
           PCRE_DFA_SHORTEST
-        Setting  the  PCRE_DFA_SHORTEST option causes the matching algorithm to
+        Setting the PCRE_DFA_SHORTEST option causes the matching  algorithm  to
         stop as soon as it has found one match. Because of the way the alterna-
-        tive  algorithm  works, this is necessarily the shortest possible match
+        tive algorithm works, this is necessarily the shortest  possible  match
         at the first possible matching point in the subject string.
           PCRE_DFA_RESTART
         When pcre_dfa_exec() returns a partial match, it is possible to call it
-        again,  with  additional  subject characters, and have it continue with
+        again, with additional subject characters, and have  it  continue  with
-        the same match. The PCRE_DFA_RESTART option requests this action;  when
+        the  same match. The PCRE_DFA_RESTART option requests this action; when
-        it  is  set,  the workspace and wscount options must reference the same
+        it is set, the workspace and wscount options must  reference  the  same
-        vector as before because data about the match so far is  left  in  them
+        vector  as  before  because data about the match so far is left in them
         after a partial match. There is more discussion of this facility in the
         pcrepartial documentation.
     Successful returns from pcre_dfa_exec()
-        When pcre_dfa_exec() succeeds, it may have matched more than  one  sub-
+        When  pcre_dfa_exec()  succeeds, it may have matched more than one sub-
         string in the subject. Note, however, that all the matches from one run
-        of the function start at the same point in  the  subject.  The  shorter
+        of  the  function  start  at the same point in the subject. The shorter
-        matches  are all initial substrings of the longer matches. For example,
+        matches are all initial substrings of the longer matches. For  example,
         if the pattern
           <.*>
-Line 2601 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2641 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
           <something> <something else>
           <something> <something else> <something further>
-        On success, the yield of the function is a number  greater  than  zero,
+        On  success,  the  yield of the function is a number greater than zero,
-        which  is  the  number of matched substrings. The substrings themselves
+        which is the number of matched substrings.  The  substrings  themselves
-        are returned in ovector. Each string uses two elements;  the  first  is
+        are  returned  in  ovector. Each string uses two elements; the first is
-        the  offset  to  the start, and the second is the offset to the end. In
+        the offset to the start, and the second is the offset to  the  end.  In
-        fact, all the strings have the same start  offset.  (Space  could  have
+        fact,  all  the  strings  have the same start offset. (Space could have
-        been  saved by giving this only once, but it was decided to retain some
+        been saved by giving this only once, but it was decided to retain  some
-        compatibility with the way pcre_exec() returns data,  even  though  the
+        compatibility  with  the  way pcre_exec() returns data, even though the
         meaning of the strings is different.)
         The strings are returned in reverse order of length; that is, the long-
-        est matching string is given first. If there were too many  matches  to
+        est  matching  string is given first. If there were too many matches to
-        fit  into ovector, the yield of the function is zero, and the vector is
+        fit into ovector, the yield of the function is zero, and the vector  is
         filled with the longest matches.
     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 field. This is not supported
         (it is meaningless).
           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.
  SEE ALSO
-        pcrebuild(3),  pcrecallout(3), pcrecpp(3)(3), pcrematching(3), pcrepar-
+        pcrebuild(3), pcrecallout(3), pcrecpp(3)(3), pcrematching(3),  pcrepar-
         tial(3), pcreposix(3), pcreprecompile(3), pcresample(3), pcrestack(3).
-Line 2668 
 AUTHOR
+Line 2708 
 AUTHOR
  REVISION
-        Last updated: 22 September 2009
+        Last updated: 03 October 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECALLOUT(3)                                                  PCRECALLOUT(3)
-Line 2698 
 PCRE CALLOUTS
+Line 2738 
 PCRE CALLOUTS
           (?C1)abc(?C2)def
-        If  the  PCRE_AUTO_CALLOUT  option  bit  is  set when pcre_compile() is
+        If  the  PCRE_AUTO_CALLOUT  option  bit  is  set when pcre_compile() or
-        called, PCRE automatically  inserts  callouts,  all  with  number  255,
+        pcre_compile2() is called, PCRE  automatically  inserts  callouts,  all
-        before  each  item in the pattern. For example, if PCRE_AUTO_CALLOUT is
+        with  number  255,  before  each  item  in the pattern. For example, if
-        used with the pattern
+        PCRE_AUTO_CALLOUT is used with the pattern
           A(\d{2}|--)
-Line 2730 
 MISSING CALLOUTS
+Line 2770 
 MISSING CALLOUTS
         ever  start,  and  the  callout is never reached. However, with "abyd",
         though the result is still no match, the callout is obeyed.
-        You can disable these optimizations by passing the  PCRE_NO_START_OPTI-
+        If the pattern is studied, PCRE knows the minimum length of a  matching
-        MIZE  option  to  pcre_exec()  or  pcre_dfa_exec(). This slows down the
+        string,  and will immediately give a "no match" return without actually
-        matching process, but does ensure that callouts  such  as  the  example
+        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-
+        MIZE option to pcre_exec() or  pcre_dfa_exec().  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 is called (if it is set). This applies  to
+        tion  defined by pcre_callout is called (if it is set). This applies to
-        both  the  pcre_exec()  and the pcre_dfa_exec() matching functions. The
+        both the pcre_exec() and the pcre_dfa_exec()  matching  functions.  The
-        only argument to the callout function is a pointer  to  a  pcre_callout
+        only  argument  to  the callout function is a pointer to a pcre_callout
         block. This structure contains the following fields:
           int          version;
-Line 2757 
 THE CALLOUT INTERFACE
+Line 2802 
 THE CALLOUT INTERFACE
           int          pattern_position;
           int          next_item_length;
-        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 1.  The
+        block  format. The initial version was 0; the current version is 1. 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  pcre_exec()  or  pcre_dfa_exec().  When
+        passed  by  the  caller  to  pcre_exec()   or   pcre_dfa_exec().   When
-        pcre_exec() is used, the contents can be inspected in order to  extract
+        pcre_exec()  is used, the contents can be inspected in order to extract
-        substrings  that  have  been  matched  so  far,  in the same way as for
+        substrings that have been matched so  far,  in  the  same  way  as  for
-        extracting substrings after a match has completed. For  pcre_dfa_exec()
+        extracting  substrings after a match has completed. For pcre_dfa_exec()
         this field is not useful.
         The subject and subject_length fields contain copies of the values that
         were passed to pcre_exec().
-        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() function is used, the capture_top  field  contains
+        When  the  pcre_exec() function is used, the capture_top field contains
-        one  more than the number of the highest numbered captured substring so
+        one more than the number of the highest numbered captured substring  so
-        far. If no substrings have been captured, the value of  capture_top  is
+        far.  If  no substrings have been captured, the value of capture_top is
-        one.  This  is always the case when pcre_dfa_exec() is used, because it
+        one. This is always the case when pcre_dfa_exec() is used,  because  it
         does 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. If no substrings have been captured, its value is -1.
+        tured substring. If no substrings have been captured, its value is  -1.
         This is always the case when pcre_dfa_exec() is used.
-        The callout_data field contains a value that is passed  to  pcre_exec()
+        The  callout_data  field contains a value that is passed to pcre_exec()
-        or  pcre_dfa_exec() specifically so that it can be passed back in call-
+        or pcre_dfa_exec() specifically so that it can be passed back in  call-
-        outs. It is passed in the pcre_callout field  of  the  pcre_extra  data
+        outs.  It  is  passed  in the pcre_callout field of the pcre_extra data
-        structure.  If  no such data was passed, the value of callout_data in a
+        structure. If no such data was passed, the value of callout_data  in  a
-        pcre_callout block is NULL. There is a description  of  the  pcre_extra
+        pcre_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 pcre_call-
+        The pattern_position field is present from version 1 of the  pcre_call-
         out 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 pcre_call-
+        The next_item_length field is present from version 1 of the  pcre_call-
         out structure. It contains the length of the next item to be matched in
-        the  pattern  string. When the callout immediately precedes an alterna-
+        the pattern string. When the callout immediately precedes  an  alterna-
-        tion bar, a closing parenthesis, or the end of the pattern, the  length
+        tion  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.
  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,  and
+        failed.  If  the  value  is less than zero, the match is abandoned, and
-        pcre_exec() (or pcre_dfa_exec()) returns the negative value.
+        pcre_exec() or pcre_dfa_exec() 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 2844 
 AUTHOR
+Line 2889 
 AUTHOR
  REVISION
-        Last updated: 15 March 2009
+        Last updated: 29 September 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECOMPAT(3)                                                    PCRECOMPAT(3)
-Line 2859 
 NAME
+Line 2904 
 NAME
  DIFFERENCES BETWEEN PCRE AND PERL
         This  document describes the differences in the ways that PCRE and Perl
-        handle regular expressions. The differences described here  are  mainly
+        handle regular expressions. The differences  described  here  are  with
-        with  respect  to  Perl 5.8, though PCRE versions 7.0 and later contain
+        respect to Perl 5.10.
-        some features that are in Perl 5.10.
-. PCRE has only a subset of Perl's UTF-8 and Unicode support.  Details
+.  PCRE has only a subset of Perl's UTF-8 and Unicode support. Details
-        of  what  it does have are given in the section on UTF-8 support in the
+        of what it does have are given in the section on UTF-8 support  in  the
         main pcre page.
 . PCRE does not allow repeat quantifiers on lookahead assertions. Perl
-        permits  them,  but they do not mean what you might think. For example,
+        permits them, but they do not mean what you might think.  For  example,
         (?!a){3} does not assert that the next three characters are not "a". It
         just asserts that the next character is not "a" three times.
-.  Capturing  subpatterns  that occur inside negative lookahead asser-
+. Capturing subpatterns that occur inside  negative  lookahead  asser-
-        tions are counted, but their entries in the offsets  vector  are  never
+        tions  are  counted,  but their entries in the offsets vector are never
-        set.  Perl sets its numerical variables from any such patterns that are
+        set. Perl sets its numerical variables from any such patterns that  are
         matched before the assertion fails to match something (thereby succeed-
-        ing),  but  only  if the negative lookahead assertion contains just one
+        ing), but only if the negative lookahead assertion  contains  just  one
         branch.
-. Though binary zero characters are supported in the  subject  string,
+.  Though  binary zero characters are supported in the subject string,
         they are not allowed in a pattern string because it is passed as a nor-
         mal C string, terminated by zero. The escape sequence \0 can be used in
         the pattern to represent a binary zero.
-.  The  following Perl escape sequences are not supported: \l, \u, \L,
+. The following Perl escape sequences are not supported: \l,  \u,  \L,
         \U, and \N. In fact these are implemented by Perl's general string-han-
-        dling  and are not part of its pattern matching engine. If any of these
+        dling and are not part of its pattern matching engine. If any of  these
         are encountered by PCRE, an error is generated.
-. The Perl escape sequences \p, \P, and \X are supported only if  PCRE
+.  The Perl escape sequences \p, \P, and \X are supported only if PCRE
-        is  built  with Unicode character property support. The properties that
+        is built with Unicode character property support. The  properties  that
-        can be tested with \p and \P are limited to the general category  prop-
+        can  be tested with \p and \P are limited to the general category prop-
-        erties  such  as  Lu and Nd, script names such as Greek or Han, and the
+        erties such as Lu and Nd, script names such as Greek or  Han,  and  the
-        derived properties Any and L&. PCRE does  support  the  Cs  (surrogate)
+        derived  properties  Any  and  L&. PCRE does support the Cs (surrogate)
-        property,  which  Perl  does  not; the Perl documentation says "Because
+        property, which Perl does not; the  Perl  documentation  says  "Because
         Perl hides the need for the user to understand the internal representa-
-        tion  of Unicode characters, there is no need to implement the somewhat
+        tion of Unicode characters, there is no need to implement the  somewhat
         messy concept of surrogates."
 . PCRE does support the \Q...\E escape for quoting substrings. Charac-
-        ters  in  between  are  treated as literals. This is slightly different
+        ters in between are treated as literals.  This  is  slightly  different
-        from Perl in that $ and @ are  also  handled  as  literals  inside  the
+        from  Perl  in  that  $  and  @ are also handled as literals inside the
-        quotes.  In Perl, they cause variable interpolation (but of course PCRE
+        quotes. In Perl, they cause variable interpolation (but of course  PCRE
         does not have variables). Note the following examples:
             Pattern            PCRE matches      Perl matches
-Line 2912 
 DIFFERENCES BETWEEN PCRE AND PERL
+Line 2956 
 DIFFERENCES BETWEEN PCRE AND PERL
             \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.
 . Fairly obviously, PCRE does not support the (?{code}) and (??{code})
-        constructions. However, there is support for recursive  patterns.  This
+        constructions.  However,  there is support for recursive patterns. This
-        is  not  available  in Perl 5.8, but it is in Perl 5.10. Also, the PCRE
+        is not available in Perl 5.8, but it is in Perl 5.10.  Also,  the  PCRE
-        "callout" feature allows an external function to be called during  pat-
+        "callout"  feature allows an external function to be called during pat-
         tern matching. See the pcrecallout documentation for details.
-.  Subpatterns  that  are  called  recursively or as "subroutines" are
+. Subpatterns that are called  recursively  or  as  "subroutines"  are
-        always treated as atomic groups in  PCRE.  This  is  like  Python,  but
+        always  treated  as  atomic  groups  in  PCRE. This is like Python, but
-        unlike  Perl. There is a discussion of an example that explains this in
+        unlike Perl. There is a discussion of an example that explains this  in
-        more detail in the section on recursion differences from  Perl  in  the
+        more  detail  in  the section on recursion differences from Perl in the
-        pcrecompat page.
+        pcrepattern page.
-.  There are some differences that are concerned with the settings of
+. There are some differences that are concerned with the settings  of
-        captured strings when part of  a  pattern  is  repeated.  For  example,
+        captured  strings  when  part  of  a  pattern is repeated. For example,
-        matching  "aba"  against  the  pattern  /^(a(b)?)+$/  in Perl leaves $2
+        matching "aba" against the  pattern  /^(a(b)?)+$/  in  Perl  leaves  $2
         unset, but in PCRE it is set to "b".
 .  PCRE  does  support  Perl  5.10's  backtracking  verbs  (*ACCEPT),
-        (*FAIL),  (*F),  (*COMMIT), (*PRUNE), (*SKIP), and (*THEN), but only in
+        (*FAIL), (*F), (*COMMIT), (*PRUNE), (*SKIP), and (*THEN), but  only  in
         the forms without an argument. PCRE does not support (*MARK).
-. PCRE provides some extensions to the Perl regular expression facil-
+.  PCRE's handling of duplicate subpattern numbers and duplicate sub-
-        ities.   Perl  5.10  will  include new features that are not in earlier
+        pattern names is not as general as Perl's. This is a consequence of the
-        versions, some of which (such as named parentheses) have been  in  PCRE
+        fact the PCRE works internally just with numbers, using an external ta-
-        for some time. This list is with respect to Perl 5.10:
+        ble to translate between numbers and names. In  particular,  a  pattern
+        such  as  (?|(?<a>A)|(?<b)B),  where the two capturing parentheses have
-        (a)  Although  lookbehind  assertions  must match fixed length strings,
+        the same number but different names, is not supported,  and  causes  an
-        each alternative branch of a lookbehind assertion can match a different
+        error  at compile time. If it were allowed, it would not be possible to
-        length of string. Perl requires them all to have the same length.
+        distinguish which parentheses matched, because both names map  to  cap-
+        turing subpattern number 1. To avoid this confusing situation, an error
+        is given at compile time.
+. 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:
+        (a)  Although  lookbehind  assertions  in  PCRE must match fixed length
+        strings, each alternative branch of a lookbehind assertion can match  a
+        different  length  of  string.  Perl requires them all to have the same
+        length.
-        (b)  If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $
+        (b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the  $
         meta-character matches only at the very end of the string.
         (c) If PCRE_EXTRA is set, a backslash followed by a letter with no spe-
         cial meaning is faulted. Otherwise, like Perl, the backslash is quietly
         ignored.  (Perl can be made to issue a warning.)
-        (d) If PCRE_UNGREEDY is set, the greediness of the  repetition  quanti-
+        (d)  If  PCRE_UNGREEDY is set, the greediness of the repetition quanti-
         fiers is inverted, that is, by default they are not greedy, but if fol-
         lowed by a question mark they are.
-Line 2960 
 DIFFERENCES BETWEEN PCRE AND PERL
+Line 3016 
 DIFFERENCES BETWEEN PCRE AND PERL
         tried only at the first matching position in the subject string.
         (f) The PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NOTEMPTY_ATSTART,
-        and PCRE_NO_AUTO_CAPTURE options for pcre_exec() have no  Perl  equiva-
+        and  PCRE_NO_AUTO_CAPTURE  options for pcre_exec() have no Perl equiva-
         lents.
-        (g)  The  \R escape sequence can be restricted to match only CR, LF, or
+        (g) The \R escape sequence can be restricted to match only CR,  LF,  or
         CRLF by the PCRE_BSR_ANYCRLF option.
         (h) The callout facility is PCRE-specific.
-Line 2973 
 DIFFERENCES BETWEEN PCRE AND PERL
+Line 3029 
 DIFFERENCES BETWEEN PCRE AND PERL
         (j) Patterns compiled by PCRE can be saved and re-used at a later time,
         even on different hosts that have the other endianness.
-        (k)  The  alternative  matching function (pcre_dfa_exec()) matches in a
+        (k) The alternative matching function (pcre_dfa_exec())  matches  in  a
         different way and is not Perl-compatible.
-        (l) PCRE recognizes some special sequences such as (*CR) at  the  start
+        (l)  PCRE  recognizes some special sequences such as (*CR) at the start
         of a pattern that set overall options that cannot be changed within the
         pattern.
-Line 2990 
 AUTHOR
+Line 3046 
 AUTHOR
  REVISION
-        Last updated: 18 September 2009
+        Last updated: 04 October 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPATTERN(3)                                                  PCREPATTERN(3)
-Line 3021 
 PCRE REGULAR EXPRESSION DETAILS
+Line 3077 
 PCRE REGULAR EXPRESSION DETAILS
         The original operation of PCRE was on strings of  one-byte  characters.
         However,  there is now also support for UTF-8 character strings. To use
-        this, you must build PCRE to  include  UTF-8  support,  and  then  call
+        this, PCRE must be built to include UTF-8 support, and  you  must  call
-        pcre_compile()  with  the  PCRE_UTF8  option.  There  is also a special
+        pcre_compile()  or  pcre_compile2() with the PCRE_UTF8 option. There is
-        sequence that can be given at the start of a pattern:
+        also a special sequence that can be given at the start of a pattern:
           (*UTF8)
-Line 3061 
 NEWLINE CONVENTIONS
+Line 3117 
 NEWLINE CONVENTIONS
           (*ANYCRLF)   any of the three above
           (*ANY)       all Unicode newline sequences
-        These override the default and the options given to pcre_compile(). For
+        These  override  the default and the options given to pcre_compile() or
-        example, on a Unix system where LF is the default newline sequence, the
+        pcre_compile2(). For example, on a Unix system where LF is the  default
-        pattern
+        newline sequence, the pattern
           (*CR)a.b
-Line 3180 
 BACKSLASH
+Line 3236 
 BACKSLASH
         acters  in patterns in a visible manner. There is no restriction on the
         appearance of non-printing characters, apart from the binary zero  that
         terminates  a  pattern,  but  when  a pattern is being prepared by text
-        editing, it is usually 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 3392 
 BACKSLASH
+Line 3448 
 BACKSLASH
           (*BSR_ANYCRLF)   CR, LF, or CRLF only
           (*BSR_UNICODE)   any Unicode newline sequence
-        These override the default and the options given to pcre_compile(), but
+        These override the default and the options given to  pcre_compile()  or
-        they can be overridden by options given to pcre_exec(). Note that these
+        pcre_compile2(),  but  they  can  be  overridden  by  options  given to
-        special settings, which are not Perl-compatible, are recognized only at
+        pcre_exec() or pcre_dfa_exec(). Note that these special settings, which
-        the  very  start  of a pattern, and that they must be in upper case. If
+        are  not  Perl-compatible,  are  recognized only at the very start of a
-        more than one of them is present, the last one is  used.  They  can  be
+        pattern, and that they must be in upper case. If more than one of  them
-        combined  with  a  change of newline convention, for example, a pattern
+        is present, the last one is used. They can be combined with a change of
-        can start with:
+        newline convention, for example, a pattern can start with:
           (*ANY)(*BSR_ANYCRLF)
-Line 3581 
 BACKSLASH
+Line 3637 
 BACKSLASH
         A word boundary is a position in the subject string where  the  current
         character  and  the previous character do not both match \w or \W (i.e.
         one matches \w and the other matches \W), or the start or  end  of  the
-        string if the first or last character matches \w, respectively.
+        string if the first or last character matches \w, respectively. Neither
+        PCRE nor Perl has a separte "start of word" or "end  of  word"  metase-
+        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.
-Line 3616 
 BACKSLASH
+Line 3675 
 BACKSLASH
  CIRCUMFLEX AND DOLLAR
         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.)
-        A  dollar  character  is  an assertion that is true only if the current
+        A 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). Dollar need not
-        be the last character of the pattern if a number  of  alternatives  are
+        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
+        involved, but it should be the last item in  any  branch  in  which  it
         appears. Dollar has no special meaning in a character class.
-        The meaning of dollar can be changed so that it  matches  only  at  the
+        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)
         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. In UTF-8 mode, the  matched  character  may  be
+        fies  the  end  of  a line. In UTF-8 mode, the matched character may be
         more than one byte long.
-        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.
  MATCHING A SINGLE BYTE
         Outside a character class, the escape sequence \C matches any one byte,
-        both in and out of UTF-8 mode. Unlike a  dot,  it  always  matches  any
+        both  in  and  out  of  UTF-8 mode. Unlike a dot, it always matches any
-        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. Because it breaks up UTF-8  char-
+        match  individual bytes in UTF-8 mode. Because it breaks up UTF-8 char-
-        acters  into individual bytes, what remains in the string may be a mal-
+        acters into individual bytes, what remains in the string may be a  mal-
-        formed UTF-8 string. For this reason, the \C escape  sequence  is  best
+        formed  UTF-8  string.  For this reason, the \C escape sequence is best
         avoided.
-        PCRE  does  not  allow \C to appear in lookbehind assertions (described
+        PCRE does not allow \C to appear in  lookbehind  assertions  (described
-        below), because in UTF-8 mode this would make it impossible  to  calcu-
+        below),  because  in UTF-8 mode this would make it impossible to calcu-
         late the length of the lookbehind.
-Line 3707 
 SQUARE BRACKETS AND CHARACTER CLASSES
+Line 3766 
 SQUARE BRACKETS AND CHARACTER CLASSES
         An opening square bracket introduces a character class, terminated by a
         closing square bracket. A closing square bracket on its own is not spe-
-        cial. If a closing square bracket is required as a member of the class,
+        cial by default.  However, if the PCRE_JAVASCRIPT_COMPAT option is set,
-        it should be the first data character in the class  (after  an  initial
+        a lone closing square bracket causes a compile-time error. If a closing
-        circumflex, if present) or escaped with a backslash.
+        square bracket is required as a member of the class, it should  be  the
+        first  data  character  in  the  class (after an initial circumflex, if
+        present) or escaped with a backslash.
-        A  character  class matches a single character in the subject. In UTF-8
+        A character class matches a single character in the subject.  In  UTF-8
-        mode, the character may occupy more than one byte. A matched  character
+        mode, the character may be more than one byte 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  case  the
+        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
+        subject character must not be in the set defined by  the  class.  If  a
-        circumflex is actually required as a member of the class, ensure it  is
+        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 mode, characters with values greater than 255 can be included
+        In UTF-8 mode, characters with values greater than 255 can be  included
-        in a class as a literal string of bytes, or by using the  \x{  escaping
+        in  a  class as a literal string of bytes, 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 UTF-8 mode, PCRE  always
+        match  "A", whereas a caseful version would. In UTF-8 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  for  characters 128 and above, you must ensure that
+        caseless matching in UTF8-mode for characters 128 and above,  you  must
-        PCRE is compiled with Unicode property support as well  as  with  UTF-8
+        ensure  that  PCRE is compiled with Unicode property support as well as
-        support.
+        with UTF-8 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.
         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.
-        Ranges  operate in the collating sequence of character values. They can
+        Ranges operate in the collating sequence of character values. They  can
-        also  be  used  for  characters  specified  numerically,  for   example
+        also   be  used  for  characters  specified  numerically,  for  example
-        [\000-\037].  In UTF-8 mode, ranges can include characters whose values
+        [\000-\037]. In UTF-8 mode, ranges can include characters whose  values
         are greater than 255, for example [\x{100}-\x{2ff}].
         If a range that includes letters is used when caseless matching is set,
         it matches the letters in either case. For example, [W-c] is equivalent
-        to [][\\^_`wxyzabc], matched caselessly,  and  in  non-UTF-8  mode,  if
+        to  [][\\^_`wxyzabc],  matched  caselessly,  and  in non-UTF-8 mode, if
-        character  tables  for  a French locale are in use, [\xc8-\xcb] matches
+        character tables for a French locale are in  use,  [\xc8-\xcb]  matches
-        accented E characters in both cases. In UTF-8 mode, PCRE  supports  the
+        accented  E  characters in both cases. In UTF-8 mode, PCRE supports the
-        concept  of  case for characters with values greater than 128 only when
+        concept of case for characters with values greater than 128  only  when
         it is compiled with Unicode property support.
-        The character types \d, \D, \p, \P, \s, \S, \w, and \W may also  appear
+        The  character types \d, \D, \p, \P, \s, \S, \w, and \W may also appear
-        in  a  character  class,  and add the characters that they match to the
+        in a character class, and add the characters that  they  match  to  the
         class. For example, [\dABCDEF] matches any hexadecimal digit. A circum-
-        flex  can  conveniently  be used with the upper case character types to
+        flex can conveniently be used with the upper case  character  types  to
-        specify a more restricted set of characters  than  the  matching  lower
+        specify  a  more  restricted  set of characters than the matching lower
-        case  type.  For example, the class [^\W_] matches any letter or digit,
+        case type. For example, the class [^\W_] matches any letter  or  digit,
         but not underscore.
-        The only metacharacters that are recognized in  character  classes  are
+        The  only  metacharacters  that are recognized in character classes are
-        backslash,  hyphen  (only  where  it can be interpreted as specifying a
+        backslash, hyphen (only where it can be  interpreted  as  specifying  a
-        range), circumflex (only at the start), opening  square  bracket  (only
+        range),  circumflex  (only  at the start), opening square bracket (only
-        when  it can be interpreted as introducing a POSIX class name - see the
+        when it can be interpreted as introducing a POSIX class name - see  the
-        next section), and the terminating  closing  square  bracket.  However,
+        next  section),  and  the  terminating closing square bracket. However,
         escaping other non-alphanumeric characters does no harm.
  POSIX CHARACTER CLASSES
         Perl supports the POSIX notation for character classes. This uses names
-        enclosed by [: and :] within the enclosing square brackets.  PCRE  also
+        enclosed  by  [: and :] within the enclosing square brackets. PCRE also
         supports this notation. For example,
           [01[:alpha:]%]
-Line 3820 
 POSIX CHARACTER CLASSES
+Line 3881 
 POSIX CHARACTER CLASSES
           word     "word" characters (same as \w)
           xdigit   hexadecimal digits
-        The "space" characters are HT (9), LF (10), VT (11), FF (12), CR  (13),
+        The  "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13),
-        and  space  (32). Notice that this list includes the VT character (code
+        and space (32). Notice that this list includes the VT  character  (code
 ). This makes "space" different to \s, which does not include VT (for
         Perl compatibility).
-        The  name  "word"  is  a Perl extension, and "blank" is a GNU extension
+        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
+        from  Perl  5.8. Another Perl extension is negation, which is indicated
         by a ^ character after the colon. For example,
           [12[:^digit:]]
-        matches  "1", "2", or any non-digit. PCRE (and Perl) also recognize the
+        matches "1", "2", or any non-digit. PCRE (and Perl) also recognize  the
         POSIX syntax [.ch.] and [=ch=] where "ch" is a "collating element", but
         these are not supported, and an error is given if they are encountered.
-Line 3841 
 POSIX CHARACTER CLASSES
+Line 3902 
 POSIX CHARACTER CLASSES
  VERTICAL BAR
-        Vertical bar characters are used to separate alternative patterns.  For
+        Vertical  bar characters are used to separate alternative patterns. For
         example, the pattern
           gilbert|sullivan
-        matches  either "gilbert" or "sullivan". Any number of alternatives may
+        matches either "gilbert" or "sullivan". Any number of alternatives  may
-        appear, and an empty  alternative  is  permitted  (matching  the  empty
+        appear,  and  an  empty  alternative  is  permitted (matching the empty
         string). The matching process tries each alternative in turn, from left
-        to right, and the first one that succeeds is used. If the  alternatives
+        to  right, and the first one that succeeds is used. If the alternatives
-        are  within a subpattern (defined below), "succeeds" means matching the
+        are within a subpattern (defined below), "succeeds" means matching  the
         rest of the main pattern as well as the alternative in the subpattern.
  INTERNAL OPTION SETTING
-        The settings of the  PCRE_CASELESS,  PCRE_MULTILINE,  PCRE_DOTALL,  and
+        The  settings  of  the  PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and
-        PCRE_EXTENDED  options  (which are Perl-compatible) can be changed from
+        PCRE_EXTENDED options (which are Perl-compatible) can be  changed  from
-        within the pattern by  a  sequence  of  Perl  option  letters  enclosed
+        within  the  pattern  by  a  sequence  of  Perl option letters enclosed
         between "(?" and ")".  The option letters are
           i  for PCRE_CASELESS
-Line 3868 
 INTERNAL OPTION SETTING
+Line 3929 
 INTERNAL OPTION SETTING
         For example, (?im) sets caseless, multiline matching. It is also possi-
         ble to unset these options by preceding the letter with a hyphen, and a
-        combined  setting and unsetting such as (?im-sx), which sets PCRE_CASE-
+        combined setting and unsetting such as (?im-sx), which sets  PCRE_CASE-
-        LESS and PCRE_MULTILINE while unsetting PCRE_DOTALL and  PCRE_EXTENDED,
+        LESS  and PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED,
-        is  also  permitted.  If  a  letter  appears  both before and after the
+        is also permitted. If a  letter  appears  both  before  and  after  the
         hyphen, the option is unset.
-        The PCRE-specific options PCRE_DUPNAMES, PCRE_UNGREEDY, and  PCRE_EXTRA
+        The  PCRE-specific options PCRE_DUPNAMES, PCRE_UNGREEDY, and PCRE_EXTRA
-        can  be changed in the same way as the Perl-compatible options by using
+        can be changed in the same way as the Perl-compatible options by  using
         the characters J, U and X respectively.
-        When one of these option changes occurs at  top  level  (that  is,  not
+        When  one  of  these  option  changes occurs at top level (that is, not
-        inside  subpattern parentheses), the change applies to the remainder of
+        inside subpattern parentheses), the change applies to the remainder  of
         the pattern that follows. If the change is placed right at the start of
         a pattern, PCRE extracts it into the global options (and it will there-
         fore show up in data extracted by the pcre_fullinfo() function).
-        An option change within a subpattern (see below for  a  description  of
+        An  option  change  within a subpattern (see below for a description of
         subpatterns) affects only that part of the current pattern that follows
         it, so
           (a(?i)b)c
         matches abc and aBc and no other strings (assuming PCRE_CASELESS is not
-        used).   By  this means, options can be made to have different settings
+        used).  By this means, options can be made to have  different  settings
-        in different parts of the pattern. Any changes made in one  alternative
+        in  different parts of the pattern. Any changes made in one alternative
-        do  carry  on  into subsequent branches within the same subpattern. For
+        do carry on into subsequent branches within the  same  subpattern.  For
         example,
           (a(?i)b|c)
-        matches "ab", "aB", "c", and "C", even though  when  matching  "C"  the
+        matches  "ab",  "aB",  "c",  and "C", even though when matching "C" the
-        first  branch  is  abandoned before the option setting. This is because
+        first branch is abandoned before the option setting.  This  is  because
-        the effects of option settings happen at compile time. There  would  be
+        the  effects  of option settings happen at compile time. There would be
         some very weird behaviour otherwise.
-        Note:  There  are  other  PCRE-specific  options that can be set by the
+        Note: There are other PCRE-specific options that  can  be  set  by  the
-        application when the compile or match functions  are  called.  In  some
+        application  when  the  compile  or match functions are called. In some
         cases the pattern can contain special leading sequences such as (*CRLF)
-        to override what the application has set or what  has  been  defaulted.
+        to  override  what  the application has set or what has been defaulted.
-        Details  are  given  in the section entitled "Newline sequences" above.
+        Details are given in the section entitled  "Newline  sequences"  above.
-        There is also the (*UTF8) leading sequence that  can  be  used  to  set
+        There  is  also  the  (*UTF8)  leading sequence that can be used to set
         UTF-8 mode; this is equivalent to setting the PCRE_UTF8 option.
-Line 3920 
 SUBPATTERNS
+Line 3981 
 SUBPATTERNS
           cat(aract|erpillar|)
-        matches one of the words "cat", "cataract", or  "caterpillar".  Without
+        matches  one  of the words "cat", "cataract", or "caterpillar". Without
-        the  parentheses,  it  would  match  "cataract", "erpillar" or an empty
+        the parentheses, it would match  "cataract",  "erpillar"  or  an  empty
         string.
-. It sets up the subpattern as  a  capturing  subpattern.  This  means
+.  It  sets  up  the  subpattern as a capturing subpattern. This means
-        that,  when  the  whole  pattern  matches,  that portion of the subject
+        that, when the whole pattern  matches,  that  portion  of  the  subject
         string that matched the subpattern is passed back to the caller via the
-        ovector  argument  of pcre_exec(). Opening parentheses are counted from
+        ovector argument of pcre_exec(). Opening parentheses are  counted  from
-        left to right (starting from 1) to obtain  numbers  for  the  capturing
+        left  to  right  (starting  from 1) to obtain numbers for the capturing
         subpatterns.
-        For  example,  if the string "the red king" is matched against the pat-
+        For example, if the string "the red king" is matched against  the  pat-
         tern
           the ((red|white) (king|queen))
-Line 3939 
 SUBPATTERNS
+Line 4000 
 SUBPATTERNS
         the captured substrings are "red king", "red", and "king", and are num-
         bered 1, 2, and 3, respectively.
-        The  fact  that  plain  parentheses  fulfil two functions is not always
+        The fact that plain parentheses fulfil  two  functions  is  not  always
-        helpful.  There are often times when a grouping subpattern is  required
+        helpful.   There are often times when a grouping subpattern is required
-        without  a capturing requirement. If an opening parenthesis is followed
+        without a capturing requirement. If an opening parenthesis is  followed
-        by a question mark and a colon, the subpattern does not do any  captur-
+        by  a question mark and a colon, the subpattern does not do any captur-
-        ing,  and  is  not  counted when computing the number of any subsequent
+        ing, and is not counted when computing the  number  of  any  subsequent
-        capturing subpatterns. For example, if the string "the white queen"  is
+        capturing  subpatterns. For example, if the string "the white queen" is
         matched against the pattern
           the ((?:red|white) (king|queen))
-Line 3952 
 SUBPATTERNS
+Line 4013 
 SUBPATTERNS
         the captured substrings are "white queen" and "queen", and are numbered
 and 2. The maximum number of capturing subpatterns is 65535.
-        As a convenient shorthand, if any option settings are required  at  the
+        As  a  convenient shorthand, if any option settings are required at the
-        start  of  a  non-capturing  subpattern,  the option letters may appear
+        start of a non-capturing subpattern,  the  option  letters  may  appear
         between the "?" and the ":". Thus the two patterns
           (?i:saturday|sunday)
           (?:(?i)saturday|sunday)
         match exactly the same set of strings. Because alternative branches are
-        tried  from  left  to right, and options are not reset until the end of
+        tried from left to right, and options are not reset until  the  end  of
-        the subpattern is reached, an option setting in one branch does  affect
+        the  subpattern is reached, an option setting in one branch does affect
-        subsequent  branches,  so  the above patterns match "SUNDAY" as well as
+        subsequent branches, so the above patterns match "SUNDAY"  as  well  as
         "Saturday".
  DUPLICATE SUBPATTERN NUMBERS
         Perl 5.10 introduced a feature whereby each alternative in a subpattern
-        uses  the same numbers for its capturing parentheses. Such a subpattern
+        uses the same numbers for its capturing parentheses. Such a  subpattern
-        starts with (?| and is itself a non-capturing subpattern. For  example,
+        starts  with (?| and is itself a non-capturing subpattern. For example,
         consider this pattern:
           (?|(Sat)ur|(Sun))day
-        Because  the two alternatives are inside a (?| group, both sets of cap-
+        Because the two alternatives are inside a (?| group, both sets of  cap-
-        turing parentheses are numbered one. Thus, when  the  pattern  matches,
+        turing  parentheses  are  numbered one. Thus, when the pattern matches,
-        you  can  look  at captured substring number one, whichever alternative
+        you can look at captured substring number  one,  whichever  alternative
-        matched. This construct is useful when you want to  capture  part,  but
+        matched.  This  construct  is useful when you want to capture part, but
         not all, of one of a number of alternatives. Inside a (?| group, paren-
-        theses are numbered as usual, but the number is reset at the  start  of
+        theses  are  numbered as usual, but the number is reset at the start of
-        each  branch. The numbers of any capturing buffers that follow the sub-
+        each branch. The numbers of any capturing buffers that follow the  sub-
-        pattern start after the highest number used in any branch. The  follow-
+        pattern  start after the highest number used in any branch. The follow-
-        ing  example  is taken from the Perl documentation.  The numbers under-
+        ing example is taken from the Perl documentation.  The  numbers  under-
         neath show in which buffer the captured content will be stored.
           # before  ---------------branch-reset----------- after
           / ( a )  (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
           # 1            2         2  3        2     3     4
-        A backreference or a recursive call to  a  numbered  subpattern  always
+        A  backreference  to  a  numbered subpattern uses the most recent value
-        refers to the first one in the pattern with the given number.
+        that is set for that number by any subpattern.  The  following  pattern
+        matches "abcabc" or "defdef":
+          /(?|(abc)|(def))\1/
+        In  contrast, a recursive or "subroutine" call to a numbered subpattern
+        always refers to the first one in the pattern with  the  given  number.
+        The following pattern matches "abcabc" or "defabc":
+          /(?|(abc)|(def))(?1)/
+        If  a condition test for a subpattern's having matched refers to a non-
+        unique number, the test is true if any of the subpatterns of that  num-
+        ber have matched.
         An  alternative approach to using this "branch reset" feature is to use
         duplicate named subpatterns, as described in the next section.
-Line 4006 
 NAMED SUBPATTERNS
+Line 4080 
 NAMED SUBPATTERNS
         patterns. This feature was not added to Perl until release 5.10. Python
         had  the  feature earlier, and PCRE introduced it at release 4.0, using
         the Python syntax. PCRE now supports both the Perl and the Python  syn-
-        tax.
+        tax.  Perl  allows  identically  numbered subpatterns to have different
+        names, but PCRE does not.
-        In  PCRE,  a subpattern can be named in one of three ways: (?<name>...)
+        In PCRE, a subpattern can be named in one of three  ways:  (?<name>...)
-        or (?'name'...) as in Perl, or (?P<name>...) as in  Python.  References
+        or  (?'name'...)  as in Perl, or (?P<name>...) as in Python. References
         to capturing parentheses from other parts of the pattern, such as back-
-        references, recursion, and conditions, can be made by name as  well  as
+        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.
-        Named capturing parentheses are still  allocated  numbers  as  well  as
+        Named  capturing  parentheses  are  still  allocated numbers as well as
-        names,  exactly as if the names were not present. The PCRE API provides
+        names, exactly as if the names were not present. The PCRE API  provides
         function calls for extracting the name-to-number translation table from
         a compiled pattern. There is also a convenience function for extracting
         a captured substring by name.
-        By default, a name must be unique within a pattern, but it is  possible
+        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
-        time. This can be useful for patterns where only one  instance  of  the
+        time.  (Duplicate  names are also always permitted for subpatterns with
-        named  parentheses  can  match. Suppose you want to match the name of a
+        the same number, set up as described in the previous  section.)  Dupli-
-        weekday, either as a 3-letter abbreviation or as the full name, and  in
+        cate  names  can  be useful for patterns where only one instance of the
+        named parentheses can match. Suppose you want to match the  name  of  a
+        weekday,  either as a 3-letter abbreviation or as the full name, and in
         both cases you want to extract the abbreviation. This pattern (ignoring
         the line breaks) does the job:
-Line 4035 
 NAMED SUBPATTERNS
+Line 4112 
 NAMED SUBPATTERNS
           (?<DN>Thu)(?:rsday)?|
           (?<DN>Sat)(?:urday)?
-        There are five capturing substrings, but only one is ever set  after  a
+        There  are  five capturing substrings, but only one is ever set after a
         match.  (An alternative way of solving this problem is to use a "branch
         reset" subpattern, as described in the previous section.)
-        The convenience function for extracting the data by  name  returns  the
+        The  convenience  function  for extracting the data by name returns the
-        substring  for  the first (and in this example, the only) subpattern of
+        substring for the first (and in this example, the only)  subpattern  of
-        that name that matched. This saves searching  to  find  which  numbered
+        that  name  that  matched.  This saves searching to find which numbered
-        subpattern  it  was. If you make a reference to a non-unique named sub-
+        subpattern it was.
-        pattern from elsewhere in the pattern, the one that corresponds to  the
-        lowest  number  is used. For further details of the interfaces for han-
+        If you make a backreference to a non-unique named subpattern from else-
-        dling named subpatterns, see the pcreapi documentation.
+        where  in the pattern, the one that corresponds to the first occurrence
+        of the name is used. In the absence of duplicate numbers (see the  pre-
+        vious  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 documen-
+        tation.
         Warning: You cannot use different names to distinguish between two sub-
-        patterns  with  the same number (see the previous section) because PCRE
+        patterns  with  the same number because PCRE uses only the numbers when
-        uses only the numbers when matching.
+        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
+        can give the same name to subpatterns with the same number,  even  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 4066 
 REPETITION
+Line 4155 
 REPETITION
           a character class
           a back reference (see next section)
           a parenthesized subpattern (unless it is an assertion)
+          a recursive or "subroutine" call to a subpattern
-        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 4086 
 REPETITION
+Line 4176 
 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-8  mode,  quantifiers  apply to UTF-8 characters rather than to
+        In UTF-8 mode, quantifiers apply to UTF-8  characters  rather  than  to
         individual bytes. Thus, for example, \x{100}{2} matches two UTF-8 char-
         acters, each of which is represented by a two-byte sequence. Similarly,
         when Unicode property support is available, \X{3} matches three Unicode
-        extended  sequences,  each of which may be several bytes long (and they
+        extended sequences, each of which may be several bytes 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. 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 4137 
 REPETITION
+Line 4227 
 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 4157 
 REPETITION
+Line 4247 
 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 is one situation where the optimization cannot be used.
+        However, there is one situation where the optimization cannot be  used.
-        When .*  is inside capturing parentheses that  are  the  subject  of  a
+        When  .*   is  inside  capturing  parentheses that are the subject of a
-        backreference  elsewhere  in the pattern, a match at the start may fail
+        backreference 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.
         When a capturing subpattern is repeated, the value captured is the sub-
-Line 4195 
 REPETITION
+Line 4285 
 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 4206 
 REPETITION
+Line 4296 
 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 4262 
 ATOMIC GROUPING AND POSSESSIVE QUANTIFIE
+Line 4352 
 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 4312 
 BACK REFERENCES
+Line 4402 
 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, which is a fea-
-        ture introduced in Perl 5.10.  This  escape  must  be  followed  by  an
+        ture  introduced  in  Perl  5.10.  This  escape  must be followed by an
-        unsigned  number  or  a negative number, optionally enclosed in braces.
+        unsigned number or a negative number, optionally  enclosed  in  braces.
         These examples are all identical:
           (ring), \1
           (ring), \g1
           (ring), \g{1}
-        An unsigned number specifies an absolute reference without the  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 4350 
 BACK REFERENCES
+Line 4440 
 BACK REFERENCES
           (abc(def)ghi)\g{-1}
         The sequence \g{-1} is a reference to the most recently started captur-
-        ing subpattern before \g, that is, is it equivalent to  \2.  Similarly,
+        ing  subpattern  before \g, that is, is it equivalent to \2. Similarly,
         \g{-2} would be equivalent to \1. The use of relative references can be
-        helpful in long patterns, and also in  patterns  that  are  created  by
+        helpful  in  long  patterns,  and  also in patterns that are created by
         joining together fragments that contain references within themselves.
-        A  back  reference matches whatever actually matched the capturing 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 4384 
 BACK REFERENCES
+Line 4474 
 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. For example, the pattern
+        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". Because  there
+        always  fails  if  it starts to match "a" rather than "bc". However, if
-        may  be  many  capturing parentheses in a pattern, all digits following
+        the PCRE_JAVASCRIPT_COMPAT option is set at compile time, a back refer-
-        the backslash are taken as part of a potential back  reference  number.
+        ence to an unset value matches an empty string.
-        If the pattern continues with a digit character, some delimiter must be
-        used to terminate the back reference. If the  PCRE_EXTENDED  option  is
+        Because  there may be many capturing parentheses in a pattern, all dig-
-        set,  this  can  be  whitespace.  Otherwise an empty comment (see "Com-
+        its following a backslash are taken as part of a potential back  refer-
-        ments" below) can be used.
+        ence  number.   If  the  pattern continues with a digit character, some
+        delimiter must  be  used  to  terminate  the  back  reference.  If  the
+        PCRE_EXTENDED option is set, this can be whitespace. Otherwise, the \g{
+        syntax or an empty comment (see "Comments" below) can be used.
         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
-Line 4462 
 ASSERTIONS
+Line 4555 
 ASSERTIONS
         If you want to force a matching failure at some point in a pattern, the
         most convenient way to do it is  with  (?!)  because  an  empty  string
         always  matches, so an assertion that requires there not to be an empty
-        string must always fail.
+        string must always fail.   The  Perl  5.10  backtracking  control  verb
+        (*FAIL) or (*F) is essentially 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 4483 
 ASSERTIONS
+Line 4577 
 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 (5.8 and 5.10), which requires
+        This is an extension compared with Perl (5.8 and 5.10), 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 Perl 5.10 escape sequence \K (see above) can be used
-        instead  of  a  lookbehind  assertion  to  get  round  the fixed-length
+        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.
         PCRE does not allow the \C escape (which matches a single byte in UTF-8
-        mode) to appear in lookbehind assertions, because it makes it  impossi-
+        mode)  to appear in lookbehind assertions, because it makes it impossi-
-        ble  to  calculate the length of the lookbehind. The \X and \R escapes,
+        ble to calculate the length of the lookbehind. The \X and  \R  escapes,
         which can match different numbers of bytes, 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  at the end of the subject
+        assertions to specify efficient matching of fixed-length strings at the
-        string. Consider a simple pattern such as
+        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 4547 
 ASSERTIONS
+Line 4641 
 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 4566 
 ASSERTIONS
+Line 4660 
 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 previous capturing  subpat-
+        on  the result of an assertion, or whether a specific capturing subpat-
-        tern  matched  or not. The two possible forms of conditional subpattern
+        tern has already been matched. The two possible  forms  of  conditional
-        are
+        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.
-        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 the capturing subpattern of  that  number  has
+        the condition is true if a capturing subpattern of that number has pre-
-        previously  matched.  An  alternative notation is to precede the digits
+        viously matched. If there is more than one  capturing  subpattern  with
-        with a plus or minus sign. In this case, the subpattern number is rela-
+        the  same  number  (see  the earlier section about duplicate subpattern
-        tive rather than absolute.  The most recently opened parentheses can be
+        numbers), the condition is true if any of them have been set. An alter-
-        referenced by (?(-1), the next most recent by (?(-2),  and  so  on.  In
+        native  notation is to precede the digits with a plus or minus sign. In
-        looping constructs it can also make sense to refer to subsequent groups
+        this case, the subpattern number is relative rather than absolute.  The
-        with constructs such as (?(+2).
+        most  recently opened parentheses can be referenced by (?(-1), the next
+        most recent by (?(-2), and so on. In looping  constructs  it  can  also
+        make  sense  to  refer  to  subsequent  groups  with constructs such as
+        (?(+2).
         Consider the following pattern, which  contains  non-significant  white
         space to make it more readable (assume the PCRE_EXTENDED option) and to
-Line 4645 
 CONDITIONAL SUBPATTERNS
+Line 4742 
 CONDITIONAL SUBPATTERNS
           (?<OPEN> \( )?    [^()]+    (?(<OPEN>) \) )
+        If  the  name used in a condition of this kind is a duplicate, the test
+        is applied to all subpatterns of the same name, and is true if any  one
+        of them has matched.
     Checking for pattern recursion
-Line 4655 
 CONDITIONAL SUBPATTERNS
+Line 4755 
 CONDITIONAL SUBPATTERNS
           (?(R3)...) or (?(R&name)...)
-        the condition is true if the most recent recursion is into the  subpat-
+        the condition is true if the most recent recursion is into a subpattern
-        tern  whose  number or name is given. This condition does not check the
+        whose number or name is given. This condition does not check the entire
-        entire recursion stack.
+        recursion stack. If the name used in a condition  of  this  kind  is  a
+        duplicate, the test is applied to all subpatterns of the same name, and
+        is true if any one of them is the most recent recursion.
-        At "top level", all these recursion test conditions are false.   Recur-
+        At "top level", all these recursion test  conditions  are  false.   The
-        sive patterns are described below.
+        syntax for recursive patterns is described below.
     Defining subpatterns for use by reference only
-Line 4680 
 CONDITIONAL SUBPATTERNS
+Line 4782 
 CONDITIONAL SUBPATTERNS
         group  named "byte" is defined. This matches an individual component of
         an IPv4 address (a number less than 256). When  matching  takes  place,
         this  part  of  the pattern is skipped because DEFINE acts like a false
-        condition.
+        condition. The rest of the pattern uses references to the  named  group
+        to  match the four dot-separated components of an IPv4 address, insist-
-        The rest of the pattern uses references to the named group to match the
+        ing on a word boundary at each end.
-        four  dot-separated  components of an IPv4 address, insisting on a word
-        boundary at each end.
     Assertion conditions
-Line 4752 
 RECURSIVE PATTERNS
+Line 4852 
 RECURSIVE PATTERNS
         This PCRE pattern solves the nested  parentheses  problem  (assume  the
         PCRE_EXTENDED option is set so that white space is ignored):
-          \( ( (?>[^()]+) | (?R) )* \)
+          \( ( [^()]++ | (?R) )* \)
         First  it matches an opening parenthesis. Then it matches any number of
         substrings which can either be a  sequence  of  non-parentheses,  or  a
         recursive  match  of the pattern itself (that is, a correctly parenthe-
-        sized substring).  Finally there is a closing parenthesis.
+        sized substring).  Finally there is a closing parenthesis. Note the use
+        of a possessive quantifier to avoid backtracking into sequences of non-
+        parentheses.
         If this were part of a larger pattern, you would not  want  to  recurse
         the entire pattern, so instead you could use this:
-          ( \( ( (?>[^()]+) | (?1) )* \) )
+          ( \( ( [^()]++ | (?1) )* \) )
         We  have  put the pattern into parentheses, and caused the recursion to
         refer to them instead of the whole pattern.
         In a larger pattern,  keeping  track  of  parenthesis  numbers  can  be
-        tricky.  This is made easier by the use of relative references. (A Perl
+        tricky.  This  is made easier by the use of relative references (a Perl
-.10 feature.)  Instead of (?1) in the  pattern  above  you  can  write
+.10 feature).  Instead of (?1) in the  pattern  above  you  can  write
         (?-2) to refer to the second most recently opened parentheses preceding
         the recursion. In other  words,  a  negative  number  counts  capturing
         parentheses leftwards from the point at which it is encountered.
-Line 4784 
 RECURSIVE PATTERNS
+Line 4886 
 RECURSIVE PATTERNS
         syntax for this is (?&name); PCRE's earlier syntax  (?P>name)  is  also
         supported. We could rewrite the above example as follows:
-          (?<pn> \( ( (?>[^()]+) | (?&pn) )* \) )
+          (?<pn> \( ( [^()]++ | (?&pn) )* \) )
         If  there  is more than one subpattern with the same name, the earliest
         one is used.
         This particular example pattern that we have been looking  at  contains
-        nested  unlimited repeats, and so the use of atomic grouping for match-
+        nested unlimited repeats, and so the use of a possessive quantifier for
-        ing strings of non-parentheses is important when applying  the  pattern
+        matching strings of non-parentheses is important when applying the pat-
-        to strings that do not match. For example, when this pattern is applied
+        tern  to  strings  that do not match. For example, when this pattern is
-        to
+        applied to
           (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
-        it yields "no match" quickly. However, if atomic grouping is not  used,
+        it yields "no match" quickly. However, if a  possessive  quantifier  is
-        the  match  runs  for a very long time indeed because there are so many
+        not  used, the match runs for a very long time indeed because there are
-        different ways the + and * repeats can carve up the  subject,  and  all
+        so many different ways the + and * repeats can carve  up  the  subject,
-        have to be tested before failure can be reported.
+        and all have to be tested before failure can be reported.
         At the end of a match, the values set for any capturing subpatterns are
         those from the outermost level of the recursion at which the subpattern
-Line 4814 
 RECURSIVE PATTERNS
+Line 4916 
 RECURSIVE PATTERNS
         value taken on at the top level. If additional parentheses  are  added,
         giving
-          \( ( ( (?>[^()]+) | (?R) )* ) \)
+          \( ( ( [^()]++ | (?R) )* ) \)
              ^                        ^
              ^                        ^
-Line 4894 
 RECURSIVE PATTERNS
+Line 4996 
 RECURSIVE PATTERNS
         If you want to match typical palindromic phrases, the  pattern  has  to
         ignore all non-word characters, which can be done like this:
-          ^\W*+(?:((.)\W*+(?1)\W*+\2|)|((.)\W*+(?3)\W*+4|\W*+.\W*+))\W*+$
+          ^\W*+(?:((.)\W*+(?1)\W*+\2|)|((.)\W*+(?3)\W*+\4|\W*+.\W*+))\W*+$
         If run with the PCRE_CASELESS option, this pattern matches phrases such
         as "A man, a plan, a canal: Panama!" and it works well in both PCRE and
-Line 4903 
 RECURSIVE PATTERNS
+Line 5005 
 RECURSIVE PATTERNS
         great  deal  longer  (ten  times or more) to match typical phrases, and
         Perl takes so long that you think it has gone into a loop.
+        WARNING: The palindrome-matching patterns above work only if  the  sub-
+        ject  string  does not start with a palindrome that is shorter than the
+        entire string.  For example, although "abcba" is correctly matched,  if
+        the  subject  is "ababa", PCRE finds the palindrome "aba" at the start,
+        then fails at top level because the end of the string does not  follow.
+        Once  again, it cannot jump back into the recursion to try other alter-
+        natives, so the entire match fails.
  SUBPATTERNS AS SUBROUTINES
-Line 5034 
 BACKTRACKING CONTROL
+Line 5144 
 BACKTRACKING CONTROL
         This verb causes the match to end successfully, skipping the  remainder
         of  the pattern. When inside a recursion, only the innermost pattern is
-        ended immediately. If the (*ACCEPT) is  inside  capturing  parentheses,
+        ended immediately. If (*ACCEPT) is inside  capturing  parentheses,  the
-        the data so far is captured. (This feature was added to PCRE at release
+        data  so  far  is  captured. (This feature was added to PCRE at release
 .00.) For example:
           A((?:A|B(*ACCEPT)|C)D)
-Line 5068 
 BACKTRACKING CONTROL
+Line 5178 
 BACKTRACKING CONTROL
         This verb causes the whole match to fail outright if the  rest  of  the
         pattern  does  not match. Even if the pattern is unanchored, no further
-        attempts to find a match by advancing the start point take place.  Once
+        attempts to find a match by advancing the starting  point  take  place.
-        (*COMMIT)  has been passed, pcre_exec() is committed to finding a match
+        Once  (*COMMIT)  has been passed, pcre_exec() is committed to finding a
-        at the current starting point, or not at all. For example:
+        match at the current starting point, or not at all. For example:
           a+(*COMMIT)b
-Line 5102 
 BACKTRACKING CONTROL
+Line 5212 
 BACKTRACKING CONTROL
         If  the  subject  is  "aaaac...",  after  the first match attempt fails
         (starting at the first character in the  string),  the  starting  point
         skips on to start the next attempt at "c". Note that a possessive quan-
-        tifer does not have the same effect in 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
         attempt would start at the second character instead of skipping  on  to
         "c".
-Line 5125 
 BACKTRACKING CONTROL
+Line 5235 
 BACKTRACKING CONTROL
  SEE ALSO
-        pcreapi(3), pcrecallout(3), pcrematching(3), pcre(3).
+        pcreapi(3), pcrecallout(3), pcrematching(3), pcresyntax(3), pcre(3).
  AUTHOR
-Line 5137 
 AUTHOR
+Line 5247 
 AUTHOR
  REVISION
-        Last updated: 22 September 2009
+        Last updated: 04 October 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRESYNTAX(3)                                                    PCRESYNTAX(3)
-Line 5493 
 REVISION
+Line 5603 
 REVISION
         Last updated: 11 April 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPARTIAL(3)                                                  PCREPARTIAL(3)
-Line 5533 
 PARTIAL MATCHING IN PCRE
+Line 5643 
 PARTIAL MATCHING IN PCRE
         plete  match,  though the details differ between the two matching func-
         tions. If both options are set, PCRE_PARTIAL_HARD takes precedence.
-        Setting a partial matching option disables one of PCRE's optimizations.
+        Setting a partial matching option disables two of PCRE's optimizations.
         PCRE  remembers the last literal byte in a pattern, and abandons match-
         ing immediately if such a byte is not present in  the  subject  string.
         This  optimization cannot be used for a subject string that might match
-        only partially.
+        only partially. If the pattern was  studied,  PCRE  knows  the  minimum
+        length  of  a  matching string, and does not bother to run the matching
+        function on shorter strings. This optimization  is  also  disabled  for
+        partial matching.
  PARTIAL MATCHING USING pcre_exec()
         A partial match occurs during a call to pcre_exec() whenever the end of
-        the  subject  string  is reached successfully, but matching cannot con-
+        the subject string is reached successfully, but  matching  cannot  con-
         tinue because more characters are needed. However, at least one charac-
-        ter  must have been matched. (In other words, a partial match can never
+        ter must have been matched. (In other words, a partial match can  never
         be an empty string.)
-        If PCRE_PARTIAL_SOFT is set,  the  partial  match  is  remembered,  but
+        If  PCRE_PARTIAL_SOFT  is  set,  the  partial  match is remembered, but
         matching continues as normal, and other alternatives in the pattern are
-        tried.  If  no  complete  match  can  be  found,  pcre_exec()   returns
+        tried.   If  no  complete  match  can  be  found,  pcre_exec()  returns
         PCRE_ERROR_PARTIAL instead of PCRE_ERROR_NOMATCH. If there are at least
         two slots in the offsets vector, the first of them is set to the offset
         of the earliest character that was inspected when the partial match was
-        found. For convenience, the second offset points  to  the  end  of  the
+        found.  For  convenience,  the  second  offset points to the end of the
-        string so that a substring can easily be extracted.
+        string so that a substring can easily be identified.
-        For  the majority of patterns, the first offset identifies the start of
+        For the majority of patterns, the first offset identifies the start  of
-        the partially matched string. However, for patterns that contain  look-
+        the  partially matched string. However, for patterns that contain look-
-        behind  assertions,  or  \K, or begin with \b or \B, earlier characters
+        behind assertions, or \K, or begin with \b or  \B,  earlier  characters
         have been inspected while carrying out the match. For example:
           /(?<=abc)123/
         This pattern matches "123", but only if it is preceded by "abc". If the
         subject string is "xyzabc12", the offsets after a partial match are for
-        the substring "abc12", because  all  these  characters  are  needed  if
+        the  substring  "abc12",  because  all  these  characters are needed if
         another match is tried with extra characters added.
-        If  there  is more than one partial match, the first one that was found
+        If there is more than one partial match, the first one that  was  found
         provides the data that is returned. Consider this pattern:
           /123\w+X|dogY/
-        If this is matched against the subject string "abc123dog", both  alter-
+        If  this is matched against the subject string "abc123dog", both alter-
-        natives  fail  to  match,  but the end of the subject is reached during
+        natives fail to match, but the end of the  subject  is  reached  during
-        matching,   so    PCRE_ERROR_PARTIAL    is    returned    instead    of
+        matching,    so    PCRE_ERROR_PARTIAL    is    returned    instead   of
-        PCRE_ERROR_NOMATCH.  The  offsets  are  set  to  3  and  9, identifying
+        PCRE_ERROR_NOMATCH. The  offsets  are  set  to  3  and  9,  identifying
-        "123dog" as the first partial match that was found. (In  this  example,
+        "123dog"  as  the first partial match that was found. (In this example,
-        there  are  two  partial  matches,  because  "dog" on its own partially
+        there are two partial matches,  because  "dog"  on  its  own  partially
         matches the second alternative.)
         If PCRE_PARTIAL_HARD is set for pcre_exec(), it returns PCRE_ERROR_PAR-
-        TIAL  as soon as a partial match is found, without continuing to search
+        TIAL as soon as a partial match is found, without continuing to  search
-        for possible complete matches. The difference between the  two  options
+        for  possible  complete matches. The difference between the two options
         can be illustrated by a pattern such as:
           /dog(sbody)?/
-        This  matches either "dog" or "dogsbody", greedily (that is, it prefers
+        This matches either "dog" or "dogsbody", greedily (that is, it  prefers
-        the longer string if possible). If it is  matched  against  the  string
+        the  longer  string  if  possible). If it is matched against the string
-        "dog"  with  PCRE_PARTIAL_SOFT,  it  yields a complete match for "dog".
+        "dog" with PCRE_PARTIAL_SOFT, it yields a  complete  match  for  "dog".
         However, if PCRE_PARTIAL_HARD is set, the result is PCRE_ERROR_PARTIAL.
-        On  the  other hand, if the pattern is made ungreedy the result is dif-
+        On the other hand, if the pattern is made ungreedy the result  is  dif-
         ferent:
           /dog(sbody)??/
-        In this case the result is always a complete match because  pcre_exec()
+        In  this case the result is always a complete match because pcre_exec()
-        finds  that  first,  and  it  never continues after finding a match. It
+        finds that first, and it never continues  after  finding  a  match.  It
-        might be easier to follow this explanation by thinking of the two  pat-
+        might  be easier to follow this explanation by thinking of the two pat-
         terns like this:
           /dog(sbody)?/    is the same as  /dogsbody|dog/
           /dog(sbody)??/   is the same as  /dog|dogsbody/
-        The  second  pattern  will  never  match "dogsbody" when pcre_exec() is
+        The second pattern will never  match  "dogsbody"  when  pcre_exec()  is
         used, because it will always find the shorter match first.
  PARTIAL MATCHING USING pcre_dfa_exec()
-        The pcre_dfa_exec() function moves along the subject  string  character
+        The  pcre_dfa_exec()  function moves along the subject string character
-        by  character, without backtracking, searching for all possible matches
+        by character, without backtracking, searching for all possible  matches
-        simultaneously. If the end of the subject is reached before the end  of
+        simultaneously.  If the end of the subject is reached before the end of
-        the  pattern,  there  is the possibility of a partial match, again pro-
+        the pattern, there is the possibility of a partial  match,  again  pro-
         vided that at least one character has matched.
-        When PCRE_PARTIAL_SOFT is set, PCRE_ERROR_PARTIAL is returned  only  if
+        When  PCRE_PARTIAL_SOFT  is set, PCRE_ERROR_PARTIAL is returned only if
-        there  have  been  no complete matches. Otherwise, the complete matches
+        there have been no complete matches. Otherwise,  the  complete  matches
-        are returned.  However, if PCRE_PARTIAL_HARD is set,  a  partial  match
+        are  returned.   However,  if PCRE_PARTIAL_HARD is set, a partial match
-        takes  precedence  over any complete matches. The portion of the string
+        takes precedence over any complete matches. The portion of  the  string
-        that was inspected when the longest partial match was found is  set  as
+        that  was  inspected when the longest partial match was found is set as
         the first matching string, provided there are at least two slots in the
         offsets vector.
-        Because pcre_dfa_exec() always searches for all possible  matches,  and
+        Because  pcre_dfa_exec()  always searches for all possible matches, and
-        there  is no difference between greedy and ungreedy repetition, its be-
+        there is no difference between greedy and ungreedy repetition, its  be-
         haviour is different from pcre_exec when PCRE_PARTIAL_HARD is set. Con-
-        sider  the  string  "dog"  matched  against  the ungreedy pattern shown
+        sider the string "dog"  matched  against  the  ungreedy  pattern  shown
         above:
           /dog(sbody)??/
-        Whereas pcre_exec() stops as soon as it finds the  complete  match  for
+        Whereas  pcre_exec()  stops  as soon as it finds the complete match for
         "dog", pcre_dfa_exec() also finds the partial match for "dogsbody", and
         so returns that when PCRE_PARTIAL_HARD is set.
  PARTIAL MATCHING AND WORD BOUNDARIES
-        If a pattern ends with one of sequences \w or \W, which test  for  word
+        If  a  pattern ends with one of sequences \w or \W, which test for word
-        boundaries,  partial  matching with PCRE_PARTIAL_SOFT can give counter-
+        boundaries, partial matching with PCRE_PARTIAL_SOFT can  give  counter-
         intuitive results. Consider this pattern:
           /\bcat\b/
         This matches "cat", provided there is a word boundary at either end. If
         the subject string is "the cat", the comparison of the final "t" with a
-        following character cannot take place, so a  partial  match  is  found.
+        following  character  cannot  take  place, so a partial match is found.
-        However,  pcre_exec() carries on with normal matching, which matches \b
+        However, pcre_exec() carries on with normal matching, which matches  \b
-        at the end of the subject when the last character  is  a  letter,  thus
+        at  the  end  of  the subject when the last character is a letter, thus
         finding a complete match. The result, therefore, is not PCRE_ERROR_PAR-
-        TIAL. The same thing happens  with  pcre_dfa_exec(),  because  it  also
+        TIAL.  The  same  thing  happens  with pcre_dfa_exec(), because it also
         finds the complete match.
-        Using  PCRE_PARTIAL_HARD  in  this  case does yield PCRE_ERROR_PARTIAL,
+        Using PCRE_PARTIAL_HARD in this  case  does  yield  PCRE_ERROR_PARTIAL,
         because then the partial match takes precedence.
  FORMERLY RESTRICTED PATTERNS
         For releases of PCRE prior to 8.00, because of the way certain internal
-        optimizations   were  implemented  in  the  pcre_exec()  function,  the
+        optimizations  were  implemented  in  the  pcre_exec()  function,   the
-        PCRE_PARTIAL option (predecessor of  PCRE_PARTIAL_SOFT)  could  not  be
+        PCRE_PARTIAL  option  (predecessor  of  PCRE_PARTIAL_SOFT) could not be
-        used  with all patterns. From release 8.00 onwards, the restrictions no
+        used with all patterns. From release 8.00 onwards, the restrictions  no
-        longer apply, and partial matching with pcre_exec()  can  be  requested
+        longer  apply,  and  partial matching with pcre_exec() can be requested
         for any pattern.
         Items that were formerly restricted were repeated single characters and
-        repeated metasequences. If PCRE_PARTIAL was set for a pattern that  did
+        repeated  metasequences. If PCRE_PARTIAL was set for a pattern that did
-        not  conform  to  the restrictions, pcre_exec() returned the error code
+        not conform to the restrictions, pcre_exec() returned  the  error  code
-        PCRE_ERROR_BADPARTIAL (-13). This error code is no longer in  use.  The
+        PCRE_ERROR_BADPARTIAL  (-13).  This error code is no longer in use. The
-        PCRE_INFO_OKPARTIAL  call  to pcre_fullinfo() to find out if a compiled
+        PCRE_INFO_OKPARTIAL call to pcre_fullinfo() to find out if  a  compiled
         pattern can be used for partial matching now always returns 1.
  EXAMPLE OF PARTIAL MATCHING USING PCRETEST
-        If the escape sequence \P is present  in  a  pcretest  data  line,  the
+        If  the  escape  sequence  \P  is  present in a pcretest data line, the
-        PCRE_PARTIAL_SOFT  option  is  used  for  the  match.  Here is a run of
+        PCRE_PARTIAL_SOFT option is used for  the  match.  Here  is  a  run  of
         pcretest that uses the date example quoted above:
             re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
-Line 5696 
 EXAMPLE OF PARTIAL MATCHING USING PCRETE
+Line 5809 
 EXAMPLE OF PARTIAL MATCHING USING PCRETE
           data> j\P
           No match
-        The first data string is matched  completely,  so  pcretest  shows  the
+        The  first  data  string  is  matched completely, so pcretest shows the
-        matched  substrings.  The  remaining four strings do not match the com-
+        matched substrings. The remaining four strings do not  match  the  com-
         plete pattern, but the first two are partial matches. Similar output is
         obtained when pcre_dfa_exec() is used.
-        If  the escape sequence \P is present more than once in a pcretest data
+        If the escape sequence \P is present more than once in a pcretest  data
         line, the PCRE_PARTIAL_HARD option is set for the match.
  MULTI-SEGMENT MATCHING WITH pcre_dfa_exec()
         When a partial match has been found using pcre_dfa_exec(), it is possi-
-        ble  to  continue  the  match  by providing additional subject data and
+        ble to continue the match by  providing  additional  subject  data  and
-        calling pcre_dfa_exec() again with the same  compiled  regular  expres-
+        calling  pcre_dfa_exec()  again  with the same compiled regular expres-
-        sion,  this time setting the PCRE_DFA_RESTART option. You must pass the
+        sion, this time setting the PCRE_DFA_RESTART option. You must pass  the
         same working space as before, because this is where details of the pre-
-        vious  partial  match  are  stored.  Here is an example using pcretest,
+        vious partial match are stored. Here  is  an  example  using  pcretest,
-        using the \R escape sequence to set  the  PCRE_DFA_RESTART  option  (\D
+        using  the  \R  escape  sequence to set the PCRE_DFA_RESTART option (\D
         specifies the use of pcre_dfa_exec()):
             re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
-Line 5722 
 MULTI-SEGMENT MATCHING WITH pcre_dfa_exe
+Line 5835 
 MULTI-SEGMENT MATCHING WITH pcre_dfa_exe
           data> n05\R\D
 : n05
-        The  first  call has "23ja" as the subject, and requests partial match-
+        The first call has "23ja" as the subject, and requests  partial  match-
-        ing; the second call  has  "n05"  as  the  subject  for  the  continued
+        ing;  the  second  call  has  "n05"  as  the  subject for the continued
-        (restarted)  match.   Notice  that when the match is complete, only the
+        (restarted) match.  Notice that when the match is  complete,  only  the
-        last part is shown; PCRE does  not  retain  the  previously  partially-
+        last  part  is  shown;  PCRE  does not retain the previously partially-
-        matched  string. It is up to the calling program to do that if it needs
+        matched string. It is up to the calling program to do that if it  needs
         to.
-        You can set the PCRE_PARTIAL_SOFT  or  PCRE_PARTIAL_HARD  options  with
+        You  can  set  the  PCRE_PARTIAL_SOFT or PCRE_PARTIAL_HARD options with
-        PCRE_DFA_RESTART  to  continue partial matching over multiple segments.
+        PCRE_DFA_RESTART to continue partial matching over  multiple  segments.
-        This facility can  be  used  to  pass  very  long  subject  strings  to
+        This  facility  can  be  used  to  pass  very  long  subject strings to
         pcre_dfa_exec().
  MULTI-SEGMENT MATCHING WITH pcre_exec()
-        From  release  8.00,  pcre_exec()  can also be used to do multi-segment
+        From release 8.00, pcre_exec() can also be  used  to  do  multi-segment
-        matching. Unlike pcre_dfa_exec(), it is not  possible  to  restart  the
+        matching.  Unlike  pcre_dfa_exec(),  it  is not possible to restart the
-        previous  match  with  a new segment of data. Instead, new data must be
+        previous match with a new segment of data. Instead, new  data  must  be
-        added to the previous subject string,  and  the  entire  match  re-run,
+        added  to  the  previous  subject  string, and the entire match re-run,
-        starting  from the point where the partial match occurred. Earlier data
+        starting from the point where the partial match occurred. Earlier  data
         can be discarded.  Consider an unanchored pattern that matches dates:
             re> /\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d/
-Line 5749 
 MULTI-SEGMENT MATCHING WITH pcre_exec()
+Line 5862 
 MULTI-SEGMENT MATCHING WITH pcre_exec()
           Partial match: 23ja
         The this stage, an application could discard the text preceding "23ja",
-        add  on  text from the next segment, and call pcre_exec() again. Unlike
+        add on text from the next segment, and call pcre_exec()  again.  Unlike
-        pcre_dfa_exec(), the entire matching string must always  be  available,
+        pcre_dfa_exec(),  the  entire matching string must always be available,
-        and  the complete matching process occurs for each call, so more memory
+        and the complete matching process occurs for each call, so more  memory
         and more processing time is needed.
-        Note: If the pattern contains lookbehind assertions, or \K,  or  starts
+        Note:  If  the pattern contains lookbehind assertions, or \K, or starts
-        with  \b  or  \B,  the string that is returned for a partial match will
+        with \b or \B, the string that is returned for  a  partial  match  will
-        include characters that precede the partially  matched  string  itself,
+        include  characters  that  precede the partially matched string itself,
-        because  these  must  be  retained when adding on more characters for a
+        because these must be retained when adding on  more  characters  for  a
         subsequent matching attempt.
-Line 5766 
 ISSUES WITH MULTI-SEGMENT MATCHING
+Line 5879 
 ISSUES WITH MULTI-SEGMENT MATCHING
         Certain types of pattern may give problems with multi-segment matching,
         whichever matching function is used.
-.  If  the  pattern contains tests for the beginning or end of a line,
+. If the pattern contains tests for the beginning or end  of  a  line,
-        you need to pass the PCRE_NOTBOL or PCRE_NOTEOL options,  as  appropri-
+        you  need  to pass the PCRE_NOTBOL or PCRE_NOTEOL options, as appropri-
-        ate,  when  the subject string for any call does not contain the begin-
+        ate, when the subject string for any call does not contain  the  begin-
         ning or end of a line.
-. Lookbehind assertions at the start of a pattern are catered  for  in
+.  Lookbehind  assertions at the start of a pattern are catered for in
-        the  offsets that are returned for a partial match. However, in theory,
+        the offsets that are returned for a partial match. However, in  theory,
-        a lookbehind assertion later in the pattern could require even  earlier
+        a  lookbehind assertion later in the pattern could require even earlier
-        characters  to  be inspected, and it might not have been reached when a
+        characters to be inspected, and it might not have been reached  when  a
-        partial match occurs. This is probably an extremely unlikely case;  you
+        partial  match occurs. This is probably an extremely unlikely case; you
-        could  guard  against  it to a certain extent by always including extra
+        could guard against it to a certain extent by  always  including  extra
         characters at the start.
-. Matching a subject string that is split into multiple  segments  may
+.  Matching  a subject string that is split into multiple segments may
-        not  always produce exactly the same result as matching over one single
+        not always produce exactly the same result as matching over one  single
-        long string, especially when PCRE_PARTIAL_SOFT  is  used.  The  section
+        long  string,  especially  when  PCRE_PARTIAL_SOFT is used. The section
-        "Partial  Matching  and  Word Boundaries" above describes an issue that
+        "Partial Matching and Word Boundaries" above describes  an  issue  that
-        arises if the pattern ends with \b or \B. Another  kind  of  difference
+        arises  if  the  pattern ends with \b or \B. Another kind of difference
-        may  occur  when  there  are multiple matching possibilities, because a
+        may occur when there are multiple  matching  possibilities,  because  a
         partial match result is given only when there are no completed matches.
         This means that as soon as the shortest match has been found, continua-
-        tion to a new subject segment is no longer  possible.   Consider  again
+        tion  to  a  new subject segment is no longer possible.  Consider again
         this pcretest example:
             re> /dog(sbody)?/
-Line 5801 
 ISSUES WITH MULTI-SEGMENT MATCHING
+Line 5914 
 ISSUES WITH MULTI-SEGMENT MATCHING
 : dogsbody
 : dog
-        The  first  data line passes the string "dogsb" to pcre_exec(), setting
+        The first data line passes the string "dogsb" to  pcre_exec(),  setting
-        the PCRE_PARTIAL_SOFT option. Although the string is  a  partial  match
+        the  PCRE_PARTIAL_SOFT  option.  Although the string is a partial match
-        for  "dogsbody",  the  result  is  not  PCRE_ERROR_PARTIAL, because the
+        for "dogsbody", the  result  is  not  PCRE_ERROR_PARTIAL,  because  the
-        shorter string "dog" is a complete match. Similarly, when  the  subject
+        shorter  string  "dog" is a complete match. Similarly, when the subject
-        is  presented to pcre_dfa_exec() in several parts ("do" and "gsb" being
+        is presented to pcre_dfa_exec() in several parts ("do" and "gsb"  being
         the first two) the match stops when "dog" has been found, and it is not
-        possible  to continue. On the other hand, if "dogsbody" is presented as
+        possible to continue. On the other hand, if "dogsbody" is presented  as
         a single string, pcre_dfa_exec() finds both matches.
         Because of these problems, it is probably best to use PCRE_PARTIAL_HARD
-        when  matching  multi-segment data. The example above then behaves dif-
+        when matching multi-segment data. The example above then  behaves  dif-
         ferently:
             re> /dog(sbody)?/
-Line 5824 
 ISSUES WITH MULTI-SEGMENT MATCHING
+Line 5937 
 ISSUES WITH MULTI-SEGMENT MATCHING
 . Patterns that contain alternatives at the top level which do not all
-        start  with  the  same  pattern  item  may  not  work  as expected when
+        start with the  same  pattern  item  may  not  work  as  expected  when
         pcre_dfa_exec() is used. For example, consider this pattern:
 |3789
-        If the first part of the subject is "ABC123", a partial  match  of  the
+        If  the  first  part of the subject is "ABC123", a partial match of the
-        first  alternative  is found at offset 3. There is no partial match for
+        first alternative is found at offset 3. There is no partial  match  for
         the second alternative, because such a match does not start at the same
-        point  in  the  subject  string. Attempting to continue with the string
+        point in the subject string. Attempting to  continue  with  the  string
-        "7890" does not yield a match  because  only  those  alternatives  that
+        "7890"  does  not  yield  a  match because only those alternatives that
-        match  at  one  point in the subject are remembered. The problem arises
+        match at one point in the subject are remembered.  The  problem  arises
-        because the start of the second alternative matches  within  the  first
+        because  the  start  of the second alternative matches within the first
-        alternative.  There  is  no  problem with anchored patterns or patterns
+        alternative. There is no problem with  anchored  patterns  or  patterns
         such as:
 |ABCD
-        where no string can be a partial match for both alternatives.  This  is
+        where  no  string can be a partial match for both alternatives. This is
-        not  a  problem if pcre_exec() is used, because the entire match has to
+        not a problem if pcre_exec() is used, because the entire match  has  to
         be rerun each time:
             re> /1234|3789/
-Line 5861 
 AUTHOR
+Line 5974 
 AUTHOR
  REVISION
-        Last updated: 05 September 2009
+        Last updated: 29 September 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPRECOMPILE(3)                                            PCREPRECOMPILE(3)
-Line 5988 
 REVISION
+Line 6101 
 REVISION
         Last updated: 13 June 2007
         Copyright (c) 1997-2007 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPERFORM(3)                                                  PCREPERFORM(3)
-Line 6138 
 REVISION
+Line 6251 
 REVISION
         Last updated: 06 March 2007
         Copyright (c) 1997-2007 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPOSIX(3)                                                      PCREPOSIX(3)
-Line 6394 
 REVISION
+Line 6507 
 REVISION
         Last updated: 02 September 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECPP(3)                                                          PCRECPP(3)
-Line 6735 
 REVISION
+Line 6848 
 REVISION
         Last updated: 17 March 2009
  ------------------------------------------------------------------------------
  PCRESAMPLE(3)                                                    PCRESAMPLE(3)
-Line 6765 
 PCRE SAMPLE PROGRAM
+Line 6878 
 PCRE SAMPLE PROGRAM
         is going on.
         If  PCRE  is  installed in the standard include and library directories
-        for your system, you should be able to compile the  demonstration  pro-
+        for your operating system, you should be able to compile the demonstra-
-        gram using this command:
+        tion program using this command:
           gcc -o pcredemo pcredemo.c -lpcre
-Line 6813 
 AUTHOR
+Line 6926 
 AUTHOR
  REVISION
-        Last updated: 01 September 2009
+        Last updated: 30 September 2009
         Copyright (c) 1997-2009 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRESTACK(3)                                                      PCRESTACK(3)
-Line 6952 
 REVISION
+Line 7065 
 REVISION
         Last updated: 09 July 2008