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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1220 by ph10,
Wed Oct 31 17:42:29 2012 UTC
+revision 1221 by ph10,
Sun Nov 11 20:27:03 2012 UTC
 Line 98 
 SECURITY CONSIDERATIONS
         supply arbitrary patterns for compilation, you should  be  aware  of  a
         feature that allows users to turn on UTF support from within a pattern,
         provided that PCRE was built with UTF support. For  example,  an  8-bit
-        pattern  that  begins  with  "(*UTF8)" turns on UTF-8 mode. This causes
+        pattern  that  begins  with  "(*UTF8)" or "(*UTF)" turns on UTF-8 mode,
-        both the pattern and any data against which it is matched to be checked
+        which interprets patterns and subjects as strings of  UTF-8  characters
-        for UTF-8 validity. If the data string is very long, such a check might
+        instead  of  individual 8-bit characters.  This causes both the pattern
-        use sufficiently many resources as to cause your  application  to  lose
+        and any data against which it is matched to be checked for UTF-8 valid-
-        performance.
+        ity.  If  the  data  string is very long, such a check might use suffi-
+        ciently many resources as to cause your  application  to  lose  perfor-
+        mance.
         The  best  way  of  guarding  against  this  possibility  is to use the
         pcre_fullinfo() function to check the compiled  pattern's  options  for
-Line 172 
 AUTHOR
+Line 174 
 AUTHOR
  REVISION
-        Last updated: 30 October 2012
+        Last updated: 11 November 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRE(3)                                                                PCRE(3)
-Line 315 
 THE PCRE 16-BIT LIBRARY
+Line 317 
 THE PCRE 16-BIT LIBRARY
  THE HEADER FILE
         There is only one header file, pcre.h. It contains prototypes  for  all
-        the  functions  in  both  libraries,  as  well as definitions of flags,
+        the functions in all libraries, as well as definitions of flags, struc-
-        structures, error codes, etc.
+        tures, error codes, etc.
  THE LIBRARY NAME
-Line 334 
 STRING TYPES
+Line 336 
 STRING TYPES
         PCRE_UCHAR16  specifies  an  appropriate  data type, and PCRE_SPTR16 is
         defined as "const PCRE_UCHAR16 *". In very  many  environments,  "short
         int" is a 16-bit data type. When PCRE is built, it defines PCRE_UCHAR16
-        as "short int", but checks that it really is a 16-bit data type. If  it
+        as "unsigned short int", but checks that it really  is  a  16-bit  data
-        is not, the build fails with an error message telling the maintainer to
+        type.  If  it is not, the build fails with an error message telling the
-        modify the definition appropriately.
+        maintainer to modify the definition appropriately.
  STRUCTURE TYPES
-Line 501 
 AUTHOR
+Line 503 
 AUTHOR
  REVISION
-        Last updated: 14 April 2012
+        Last updated: 08 November 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRE(3)                                                                PCRE(3)
-Line 644 
 THE PCRE 32-BIT LIBRARY
+Line 646 
 THE PCRE 32-BIT LIBRARY
  THE HEADER FILE
         There is only one header file, pcre.h. It contains prototypes  for  all
-        the  functions  in  both  libraries,  as  well as definitions of flags,
+        the functions in all libraries, as well as definitions of flags, struc-
-        structures, error codes, etc.
+        tures, error codes, etc.
  THE LIBRARY NAME
-Line 827 
 AUTHOR
+Line 829 
 AUTHOR
  REVISION
-        Last updated: 24 June 2012
+        Last updated: 08 November 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREBUILD(3)                                                      PCREBUILD(3)
-Line 1320 
 REVISION
+Line 1322 
 REVISION
         Last updated: 30 October 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREMATCHING(3)                                                PCREMATCHING(3)
-Line 1529 
 REVISION
+Line 1531 
 REVISION
         Last updated: 08 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREAPI(3)                                                          PCREAPI(3)
-Line 1642 
 PCRE NATIVE API INDIRECTED FUNCTIONS
+Line 1644 
 PCRE NATIVE API INDIRECTED FUNCTIONS
         int (*pcre_callout)(pcre_callout_block *);
- PCRE 8-BIT, 16-BIT AND 32-BIT LIBRARIES
+ PCRE 8-BIT, 16-BIT, AND 32-BIT LIBRARIES
-        From  release  8.30,  PCRE  can  be  compiled as a library for handling
+        As  well  as  support  for  8-bit character strings, PCRE also supports
--bit character strings as  well  as,  or  instead  of,  the  original
+-bit strings (from release 8.30) and  32-bit  strings  (from  release
-        library  that  handles 8-bit character strings. From release 8.32, PCRE
+.32),  by means of two additional libraries. They can be built as well
-        can also be  compiled  as  a  library  for  handling  32-bit  character
+        as, or instead of, the 8-bit library. To avoid too  much  complication,
-        strings.  To  avoid  too much complication, this document describes the
+        this  document describes the 8-bit versions of the functions, with only
--bit versions of the functions, with only occasional references to the
+        occasional references to the 16-bit and 32-bit libraries.
--bit and 32-bit libraries.
+        The 16-bit and 32-bit functions operate in the same way as their  8-bit
-        The  16-bit and 32-bit functions operate in the same way as their 8-bit
+        counterparts;  they  just  use different data types for their arguments
-        counterparts; they just use different data types  for  their  arguments
+        and results, and their names start with pcre16_ or pcre32_  instead  of
-        and  results,  and their names start with pcre16_ or pcre32_ instead of
+        pcre_.  For  every  option  that  has  UTF8  in  its name (for example,
-        pcre_. For every option  that  has  UTF8  in  its  name  (for  example,
+        PCRE_UTF8), there are corresponding 16-bit and 32-bit names  with  UTF8
-        PCRE_UTF8),  there  are corresponding 16-bit and 32-bit names with UTF8
         replaced by UTF16 or UTF32, respectively. This facility is in fact just
-        cosmetic;  the  16-bit and 32-bit option names define the same bit val-
+        cosmetic; the 16-bit and 32-bit option names define the same  bit  val-
         ues.
         References to bytes and UTF-8 in this document should be read as refer-
-        ences  to  16-bit  data  quantities  and  UTF-16  when using the 16-bit
+        ences to 16-bit data  quantities  and  UTF-16  when  using  the  16-bit
-        library, or 32-bit data quantities and UTF-32  when  using  the  32-bit
+        library,  or  32-bit  data  quantities and UTF-32 when using the 32-bit
-        library,  unless specified otherwise. More details of the specific dif-
+        library, unless specified otherwise. More details of the specific  dif-
-        ferences for the 16-bit and 32-bit libraries are given  in  the  pcre16
+        ferences  for  the  16-bit and 32-bit libraries are given in the pcre16
         and pcre32 pages.
  PCRE API OVERVIEW
         PCRE has its own native API, which is described in this document. There
-        are also some wrapper functions (for the 8-bit library only) that  cor-
+        are  also some wrapper functions (for the 8-bit library only) that cor-
-        respond  to  the  POSIX  regular  expression  API, but they do not give
+        respond to the POSIX regular expression  API,  but  they  do  not  give
-        access to all the functionality. They are described  in  the  pcreposix
+        access  to  all  the functionality. They are described in the pcreposix
-        documentation.  Both  of these APIs define a set of C function calls. A
+        documentation. Both of these APIs define a set of C function  calls.  A
         C++ wrapper (again for the 8-bit library only) is also distributed with
         PCRE. It is documented in the pcrecpp page.
-        The  native  API  C  function prototypes are defined in the header file
+        The native API C function prototypes are defined  in  the  header  file
-        pcre.h, and on Unix-like systems the (8-bit) library itself  is  called
+        pcre.h,  and  on Unix-like systems the (8-bit) library itself is called
-        libpcre.  It  can  normally be accessed by adding -lpcre to the command
+        libpcre. It can normally be accessed by adding -lpcre  to  the  command
-        for linking an application that uses PCRE. The header file defines  the
+        for  linking an application that uses PCRE. The header file defines the
         macros PCRE_MAJOR and PCRE_MINOR to contain the major and minor release
-        numbers for the library. Applications can use these to include  support
+        numbers  for the library. Applications can use these to include support
         for different releases of PCRE.
         In a Windows environment, if you want to statically link an application
-        program against a non-dll pcre.a  file,  you  must  define  PCRE_STATIC
+        program  against  a  non-dll  pcre.a  file, you must define PCRE_STATIC
-        before  including  pcre.h or pcrecpp.h, because otherwise the pcre_mal-
+        before including pcre.h or pcrecpp.h, because otherwise  the  pcre_mal-
         loc()   and   pcre_free()   exported   functions   will   be   declared
         __declspec(dllimport), with unwanted results.
-        The   functions   pcre_compile(),  pcre_compile2(),  pcre_study(),  and
+        The  functions  pcre_compile(),  pcre_compile2(),   pcre_study(),   and
-        pcre_exec() are used for compiling and matching regular expressions  in
+        pcre_exec()  are used for compiling and matching regular expressions in
-        a  Perl-compatible  manner. A sample program that demonstrates the sim-
+        a Perl-compatible manner. A sample program that demonstrates  the  sim-
-        plest way of using them is provided in the file  called  pcredemo.c  in
+        plest  way  of  using them is provided in the file called pcredemo.c in
         the PCRE source distribution. A listing of this program is given in the
-        pcredemo documentation, and the pcresample documentation describes  how
+        pcredemo  documentation, and the pcresample documentation describes how
         to compile and run it.
-        Just-in-time  compiler  support is an optional feature of PCRE that can
+        Just-in-time compiler support is an optional feature of PCRE  that  can
         be built in appropriate hardware environments. It greatly speeds up the
-        matching  performance  of  many  patterns.  Simple  programs can easily
+        matching performance of  many  patterns.  Simple  programs  can  easily
-        request that it be used if available, by  setting  an  option  that  is
+        request  that  it  be  used  if available, by setting an option that is
-        ignored  when  it is not relevant. More complicated programs might need
+        ignored when it is not relevant. More complicated programs  might  need
-        to    make    use    of    the    functions     pcre_jit_stack_alloc(),
+        to     make    use    of    the    functions    pcre_jit_stack_alloc(),
-        pcre_jit_stack_free(),  and pcre_assign_jit_stack() in order to control
+        pcre_jit_stack_free(), and pcre_assign_jit_stack() in order to  control
         the JIT code's memory usage.
-        From release 8.32 there is also a direct interface for  JIT  execution,
+        From  release  8.32 there is also a direct interface for JIT execution,
-        which  gives  improved performance. The JIT-specific functions are dis-
+        which gives improved performance. The JIT-specific functions  are  dis-
         cussed in the pcrejit documentation.
         A second matching function, pcre_dfa_exec(), which is not Perl-compati-
-        ble,  is  also provided. This uses a different algorithm for the match-
+        ble, is also provided. This uses a different algorithm for  the  match-
-        ing. The alternative algorithm finds all possible matches (at  a  given
+        ing.  The  alternative algorithm finds all possible matches (at a given
-        point  in  the  subject), and scans the subject just once (unless there
+        point in the subject), and scans the subject just  once  (unless  there
-        are lookbehind assertions). However, this  algorithm  does  not  return
+        are  lookbehind  assertions).  However,  this algorithm does not return
-        captured  substrings.  A description of the two matching algorithms and
+        captured substrings. A description of the two matching  algorithms  and
-        their advantages and disadvantages is given in the  pcrematching  docu-
+        their  advantages  and disadvantages is given in the pcrematching docu-
         mentation.
-        In  addition  to  the  main compiling and matching functions, there are
+        In addition to the main compiling and  matching  functions,  there  are
         convenience functions for extracting captured substrings from a subject
         string that is matched by pcre_exec(). They are:
-Line 1738 
 PCRE API OVERVIEW
+Line 1739 
 PCRE API OVERVIEW
         pcre_free_substring() and pcre_free_substring_list() are also provided,
         to free the memory used for extracted strings.
-        The function pcre_maketables() is used to  build  a  set  of  character
+        The  function  pcre_maketables()  is  used  to build a set of character
-        tables   in   the   current   locale  for  passing  to  pcre_compile(),
+        tables  in  the  current  locale   for   passing   to   pcre_compile(),
-        pcre_exec(), or pcre_dfa_exec(). This is an optional facility  that  is
+        pcre_exec(),  or  pcre_dfa_exec(). This is an optional facility that is
-        provided  for  specialist  use.  Most  commonly,  no special tables are
+        provided for specialist use.  Most  commonly,  no  special  tables  are
-        passed, in which case internal tables that are generated when  PCRE  is
+        passed,  in  which case internal tables that are generated when PCRE is
         built are used.
-        The  function  pcre_fullinfo()  is used to find out information about a
+        The function pcre_fullinfo() is used to find out  information  about  a
-        compiled pattern. The function pcre_version() returns a  pointer  to  a
+        compiled  pattern.  The  function pcre_version() returns a pointer to a
         string containing the version of PCRE and its date of release.
-        The  function  pcre_refcount()  maintains  a  reference count in a data
+        The function pcre_refcount() maintains a  reference  count  in  a  data
-        block containing a compiled pattern. This is provided for  the  benefit
+        block  containing  a compiled pattern. This is provided for the benefit
         of object-oriented applications.
-        The  global  variables  pcre_malloc and pcre_free initially contain the
+        The global variables pcre_malloc and pcre_free  initially  contain  the
-        entry points of the standard malloc()  and  free()  functions,  respec-
+        entry  points  of  the  standard malloc() and free() functions, respec-
         tively. PCRE calls the memory management functions via these variables,
-        so a calling program can replace them if it  wishes  to  intercept  the
+        so  a  calling  program  can replace them if it wishes to intercept the
         calls. This should be done before calling any PCRE functions.
-        The  global  variables  pcre_stack_malloc  and pcre_stack_free are also
+        The global variables pcre_stack_malloc  and  pcre_stack_free  are  also
-        indirections to memory management functions.  These  special  functions
+        indirections  to  memory  management functions. These special functions
-        are  used  only  when  PCRE is compiled to use the heap for remembering
+        are used only when PCRE is compiled to use  the  heap  for  remembering
         data, instead of recursive function calls, when running the pcre_exec()
-        function.  See  the  pcrebuild  documentation  for details of how to do
+        function. See the pcrebuild documentation for  details  of  how  to  do
-        this. It is a non-standard way of building PCRE, for  use  in  environ-
+        this.  It  is  a non-standard way of building PCRE, for use in environ-
-        ments  that  have  limited stacks. Because of the greater use of memory
+        ments that have limited stacks. Because of the greater  use  of  memory
-        management, it runs more slowly. Separate  functions  are  provided  so
+        management,  it  runs  more  slowly. Separate functions are provided so
-        that  special-purpose  external  code  can  be used for this case. When
+        that special-purpose external code can be  used  for  this  case.  When
-        used, these functions are always called in a  stack-like  manner  (last
+        used,  these  functions  are always called in a stack-like manner (last
-        obtained,  first freed), and always for memory blocks of the same size.
+        obtained, first freed), and always for memory blocks of the same  size.
-        There is a discussion about PCRE's stack usage in the  pcrestack  docu-
+        There  is  a discussion about PCRE's stack usage in the pcrestack docu-
         mentation.
         The global variable pcre_callout initially contains NULL. It can be set
-        by the caller to a "callout" function, which PCRE  will  then  call  at
+        by  the  caller  to  a "callout" function, which PCRE will then call at
-        specified  points during a matching operation. Details are given in the
+        specified points during a matching operation. Details are given in  the
         pcrecallout documentation.
  NEWLINES
-        PCRE supports five different conventions for indicating line breaks  in
+        PCRE  supports five different conventions for indicating line breaks in
-        strings:  a  single  CR (carriage return) character, a single LF (line-
+        strings: a single CR (carriage return) character, a  single  LF  (line-
         feed) character, the two-character sequence CRLF, any of the three pre-
-        ceding,  or any Unicode newline sequence. The Unicode newline sequences
+        ceding, or any Unicode newline sequence. The Unicode newline  sequences
-        are the three just mentioned, plus the single characters  VT  (vertical
+        are  the  three just mentioned, plus the single characters VT (vertical
         tab, U+000B), FF (form feed, U+000C), NEL (next line, U+0085), LS (line
         separator, U+2028), and PS (paragraph separator, U+2029).
-        Each of the first three conventions is used by at least  one  operating
+        Each  of  the first three conventions is used by at least one operating
-        system  as its standard newline sequence. When PCRE is built, a default
+        system as its standard newline sequence. When PCRE is built, a  default
-        can be specified.  The default default is LF, which is the  Unix  stan-
+        can  be  specified.  The default default is LF, which is the Unix stan-
-        dard.  When  PCRE  is run, the default can be overridden, either when a
+        dard. When PCRE is run, the default can be overridden,  either  when  a
         pattern is compiled, or when it is matched.
         At compile time, the newline convention can be specified by the options
-        argument  of  pcre_compile(), or it can be specified by special text at
+        argument of pcre_compile(), or it can be specified by special  text  at
         the start of the pattern itself; this overrides any other settings. See
         the pcrepattern page for details of the special character sequences.
         In the PCRE documentation the word "newline" is used to mean "the char-
-        acter or pair of characters that indicate a line break". The choice  of
+        acter  or pair of characters that indicate a line break". The choice of
-        newline  convention  affects  the  handling of the dot, circumflex, and
+        newline convention affects the handling of  the  dot,  circumflex,  and
         dollar metacharacters, the handling of #-comments in /x mode, and, when
-        CRLF  is a recognized line ending sequence, the match position advance-
+        CRLF is a recognized line ending sequence, the match position  advance-
         ment for a non-anchored pattern. There is more detail about this in the
         section on pcre_exec() options below.
-        The  choice of newline convention does not affect the interpretation of
+        The choice of newline convention does not affect the interpretation  of
-        the \n or \r escape sequences, nor does  it  affect  what  \R  matches,
+        the  \n  or  \r  escape  sequences, nor does it affect what \R matches,
         which is controlled in a similar way, but by separate options.
  MULTITHREADING
-        The  PCRE  functions  can be used in multi-threading applications, with
+        The PCRE functions can be used in  multi-threading  applications,  with
         the  proviso  that  the  memory  management  functions  pointed  to  by
         pcre_malloc, pcre_free, pcre_stack_malloc, and pcre_stack_free, and the
         callout function pointed to by pcre_callout, are shared by all threads.
-        The compiled form of a regular expression is not altered during  match-
+        The  compiled form of a regular expression is not altered during match-
         ing, so the same compiled pattern can safely be used by several threads
         at once.
-        If the just-in-time optimization feature is being used, it needs  sepa-
+        If  the just-in-time optimization feature is being used, it needs sepa-
-        rate  memory stack areas for each thread. See the pcrejit documentation
+        rate memory stack areas for each thread. See the pcrejit  documentation
         for more details.
  SAVING PRECOMPILED PATTERNS FOR LATER USE
         The compiled form of a regular expression can be saved and re-used at a
-        later  time,  possibly by a different program, and even on a host other
+        later time, possibly by a different program, and even on a  host  other
-        than the one on which  it  was  compiled.  Details  are  given  in  the
+        than  the  one  on  which  it  was  compiled.  Details are given in the
-        pcreprecompile  documentation,  which  includes  a  description  of the
+        pcreprecompile documentation,  which  includes  a  description  of  the
-        pcre_pattern_to_host_byte_order() function. However, compiling a  regu-
+        pcre_pattern_to_host_byte_order()  function. However, compiling a regu-
-        lar  expression  with one version of PCRE for use with a different ver-
+        lar expression with one version of PCRE for use with a  different  ver-
         sion is not guaranteed to work and may cause crashes.
-Line 1844 
 CHECKING BUILD-TIME OPTIONS
+Line 1845 
 CHECKING BUILD-TIME OPTIONS
         int pcre_config(int what, void *where);
-        The function pcre_config() makes it possible for a PCRE client to  dis-
+        The  function pcre_config() makes it possible for a PCRE client to dis-
         cover which optional features have been compiled into the PCRE library.
-        The pcrebuild documentation has more details about these optional  fea-
+        The  pcrebuild documentation has more details about these optional fea-
         tures.
-        The  first  argument  for pcre_config() is an integer, specifying which
+        The first argument for pcre_config() is an  integer,  specifying  which
         information is required; the second argument is a pointer to a variable
-        into  which  the  information  is placed. The returned value is zero on
+        into which the information is placed. The returned  value  is  zero  on
-        success, or the negative error code PCRE_ERROR_BADOPTION if  the  value
+        success,  or  the negative error code PCRE_ERROR_BADOPTION if the value
-        in  the  first argument is not recognized. The following information is
+        in the first argument is not recognized. The following  information  is
         available:
           PCRE_CONFIG_UTF8
-        The output is an integer that is set to one if UTF-8 support is  avail-
+        The  output is an integer that is set to one if UTF-8 support is avail-
-        able;  otherwise it is set to zero. This value should normally be given
+        able; otherwise it is set to zero. This value should normally be  given
         to the 8-bit version of this function, pcre_config(). If it is given to
-        the   16-bit  or  32-bit  version  of  this  function,  the  result  is
+        the  16-bit  or  32-bit  version  of  this  function,  the  result   is
         PCRE_ERROR_BADOPTION.
           PCRE_CONFIG_UTF16
         The output is an integer that is set to one if UTF-16 support is avail-
-        able;  otherwise it is set to zero. This value should normally be given
+        able; otherwise it is set to zero. This value should normally be  given
         to the 16-bit version of this function, pcre16_config(). If it is given
-        to  the  8-bit  or  32-bit  version  of  this  function,  the result is
+        to the 8-bit  or  32-bit  version  of  this  function,  the  result  is
         PCRE_ERROR_BADOPTION.
           PCRE_CONFIG_UTF32
         The output is an integer that is set to one if UTF-32 support is avail-
-        able;  otherwise it is set to zero. This value should normally be given
+        able; otherwise it is set to zero. This value should normally be  given
         to the 32-bit version of this function, pcre32_config(). If it is given
-        to  the  8-bit  or  16-bit  version  of  this  function,  the result is
+        to the 8-bit  or  16-bit  version  of  this  function,  the  result  is
         PCRE_ERROR_BADOPTION.
           PCRE_CONFIG_UNICODE_PROPERTIES
-        The output is an integer that is set to  one  if  support  for  Unicode
+        The  output  is  an  integer  that is set to one if support for Unicode
         character properties is available; otherwise it is set to zero.
           PCRE_CONFIG_JIT
-Line 1892 
 CHECKING BUILD-TIME OPTIONS
+Line 1893 
 CHECKING BUILD-TIME OPTIONS
           PCRE_CONFIG_JITTARGET
-        The output is a pointer to a zero-terminated "const char *" string.  If
+        The  output is a pointer to a zero-terminated "const char *" string. If
         JIT support is available, the string contains the name of the architec-
-        ture for which the JIT compiler is configured, for example  "x86  32bit
+        ture  for  which the JIT compiler is configured, for example "x86 32bit
-        (little  endian  +  unaligned)".  If  JIT support is not available, the
+        (little endian + unaligned)". If JIT  support  is  not  available,  the
         result is NULL.
           PCRE_CONFIG_NEWLINE
-        The output is an integer whose value specifies  the  default  character
+        The  output  is  an integer whose value specifies the default character
-        sequence  that  is recognized as meaning "newline". The values that are
+        sequence that is recognized as meaning "newline". The values  that  are
         supported in ASCII/Unicode environments are: 10 for LF, 13 for CR, 3338
-        for  CRLF,  -2 for ANYCRLF, and -1 for ANY. In EBCDIC environments, CR,
+        for CRLF, -2 for ANYCRLF, and -1 for ANY. In EBCDIC  environments,  CR,
-        ANYCRLF, and ANY yield the same values. However, the value  for  LF  is
+        ANYCRLF,  and  ANY  yield the same values. However, the value for LF is
-        normally  21, though some EBCDIC environments use 37. The corresponding
+        normally 21, though some EBCDIC environments use 37. The  corresponding
-        values for CRLF are 3349 and 3365. The default should  normally  corre-
+        values  for  CRLF are 3349 and 3365. The default should normally corre-
         spond to the standard sequence for your operating system.
           PCRE_CONFIG_BSR
         The output is an integer whose value indicates what character sequences
-        the \R escape sequence matches by default. A value of 0 means  that  \R
+        the  \R  escape sequence matches by default. A value of 0 means that \R
-        matches  any  Unicode  line ending sequence; a value of 1 means that \R
+        matches any Unicode line ending sequence; a value of 1  means  that  \R
         matches only CR, LF, or CRLF. The default can be overridden when a pat-
         tern is compiled or matched.
           PCRE_CONFIG_LINK_SIZE
-        The  output  is  an  integer that contains the number of bytes used for
+        The output is an integer that contains the number  of  bytes  used  for
         internal  linkage  in  compiled  regular  expressions.  For  the  8-bit
         library, the value can be 2, 3, or 4. For the 16-bit library, the value
-        is either 2 or 4 and is  still  a  number  of  bytes.  For  the  32-bit
+        is  either  2  or  4  and  is  still  a number of bytes. For the 32-bit
         library, the value is either 2 or 4 and is still a number of bytes. The
         default value of 2 is sufficient for all but the most massive patterns,
-        since  it  allows  the compiled pattern to be up to 64K in size. Larger
+        since it allows the compiled pattern to be up to 64K  in  size.  Larger
-        values allow larger regular expressions to be compiled, at the  expense
+        values  allow larger regular expressions to be compiled, at the expense
         of slower matching.
           PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
-        The  output  is  an integer that contains the threshold above which the
+        The output is an integer that contains the threshold  above  which  the
-        POSIX interface uses malloc() for output vectors. Further  details  are
+        POSIX  interface  uses malloc() for output vectors. Further details are
         given in the pcreposix documentation.
           PCRE_CONFIG_MATCH_LIMIT
-        The  output is a long integer that gives the default limit for the num-
+        The output is a long integer that gives the default limit for the  num-
-        ber of internal matching function calls  in  a  pcre_exec()  execution.
+        ber  of  internal  matching  function calls in a pcre_exec() execution.
         Further details are given with pcre_exec() below.
           PCRE_CONFIG_MATCH_LIMIT_RECURSION
         The output is a long integer that gives the default limit for the depth
-        of  recursion  when  calling  the  internal  matching  function  in   a
+        of   recursion  when  calling  the  internal  matching  function  in  a
-        pcre_exec()  execution.  Further  details  are  given  with pcre_exec()
+        pcre_exec() execution.  Further  details  are  given  with  pcre_exec()
         below.
           PCRE_CONFIG_STACKRECURSE
-        The output is an integer that is set to one if internal recursion  when
+        The  output is an integer that is set to one if internal recursion when
         running pcre_exec() is implemented by recursive function calls that use
-        the stack to remember their state. This is the usual way that  PCRE  is
+        the  stack  to remember their state. This is the usual way that PCRE is
         compiled. The output is zero if PCRE was compiled to use blocks of data
-        on the  heap  instead  of  recursive  function  calls.  In  this  case,
+        on  the  heap  instead  of  recursive  function  calls.  In  this case,
-        pcre_stack_malloc  and  pcre_stack_free  are  called  to  manage memory
+        pcre_stack_malloc and  pcre_stack_free  are  called  to  manage  memory
         blocks on the heap, thus avoiding the use of the stack.
-Line 1972 
 COMPILING A PATTERN
+Line 1973 
 COMPILING A PATTERN
         Either of the functions pcre_compile() or pcre_compile2() can be called
         to compile a pattern into an internal form. The only difference between
-        the two interfaces is that pcre_compile2() has an additional  argument,
+        the  two interfaces is that pcre_compile2() has an additional argument,
-        errorcodeptr,  via  which  a  numerical  error code can be returned. To
+        errorcodeptr, via which a numerical error  code  can  be  returned.  To
-        avoid too much repetition, we refer just to pcre_compile()  below,  but
+        avoid  too  much repetition, we refer just to pcre_compile() below, but
         the information applies equally to pcre_compile2().
         The pattern is a C string terminated by a binary zero, and is passed in
-        the pattern argument. A pointer to a single block  of  memory  that  is
+        the  pattern  argument.  A  pointer to a single block of memory that is
-        obtained  via  pcre_malloc is returned. This contains the compiled code
+        obtained via pcre_malloc is returned. This contains the  compiled  code
         and related data. The pcre type is defined for the returned block; this
         is a typedef for a structure whose contents are not externally defined.
         It is up to the caller to free the memory (via pcre_free) when it is no
         longer required.
-        Although  the compiled code of a PCRE regex is relocatable, that is, it
+        Although the compiled code of a PCRE regex is relocatable, that is,  it
         does not depend on memory location, the complete pcre data block is not
-        fully  relocatable, because it may contain a copy of the tableptr argu-
+        fully relocatable, because it may contain a copy of the tableptr  argu-
         ment, which is an address (see below).
         The options argument contains various bit settings that affect the com-
-        pilation.  It  should be zero if no options are required. The available
+        pilation. It should be zero if no options are required.  The  available
-        options are described below. Some of them (in  particular,  those  that
+        options  are  described  below. Some of them (in particular, those that
-        are  compatible with Perl, but some others as well) can also be set and
+        are compatible with Perl, but some others as well) can also be set  and
-        unset from within the pattern (see  the  detailed  description  in  the
+        unset  from  within  the  pattern  (see the detailed description in the
-        pcrepattern  documentation). For those options that can be different in
+        pcrepattern documentation). For those options that can be different  in
-        different parts of the pattern, the contents of  the  options  argument
+        different  parts  of  the pattern, the contents of the options argument
         specifies their settings at the start of compilation and execution. The
-        PCRE_ANCHORED, PCRE_BSR_xxx, PCRE_NEWLINE_xxx, PCRE_NO_UTF8_CHECK,  and
+        PCRE_ANCHORED,  PCRE_BSR_xxx, PCRE_NEWLINE_xxx, PCRE_NO_UTF8_CHECK, and
-        PCRE_NO_START_OPTIMIZE  options  can  be set at the time of matching as
+        PCRE_NO_START_OPTIMIZE options can be set at the time  of  matching  as
         well as at compile time.
         If errptr is NULL, pcre_compile() returns NULL immediately.  Otherwise,
-        if  compilation  of  a  pattern fails, pcre_compile() returns NULL, and
+        if compilation of a pattern fails,  pcre_compile()  returns  NULL,  and
         sets the variable pointed to by errptr to point to a textual error mes-
         sage. This is a static string that is part of the library. You must not
-        try to free it. Normally, the offset from the start of the  pattern  to
+        try  to  free it. Normally, the offset from the start of the pattern to
-        the  byte  that  was  being  processed when the error was discovered is
+        the byte that was being processed when  the  error  was  discovered  is
-        placed in the variable pointed to by erroffset, which must not be  NULL
+        placed  in the variable pointed to by erroffset, which must not be NULL
-        (if  it is, an immediate error is given). However, for an invalid UTF-8
+        (if it is, an immediate error is given). However, for an invalid  UTF-8
         string, the offset is that of the first byte of the failing character.
-        Some errors are not detected until the whole pattern has been  scanned;
+        Some  errors are not detected until the whole pattern has been scanned;
-        in  these  cases,  the offset passed back is the length of the pattern.
+        in these cases, the offset passed back is the length  of  the  pattern.
-        Note that the offset is in bytes, not characters, even in  UTF-8  mode.
+        Note  that  the offset is in bytes, not characters, even in UTF-8 mode.
         It may sometimes point into the middle of a UTF-8 character.
-        If  pcre_compile2()  is  used instead of pcre_compile(), and the error-
+        If pcre_compile2() is used instead of pcre_compile(),  and  the  error-
-        codeptr argument is not NULL, a non-zero error code number is  returned
+        codeptr  argument is not NULL, a non-zero error code number is returned
-        via  this argument in the event of an error. This is in addition to the
+        via this argument in the event of an error. This is in addition to  the
         textual error message. Error codes and messages are listed below.
-        If the final argument, tableptr, is NULL, PCRE uses a  default  set  of
+        If  the  final  argument, tableptr, is NULL, PCRE uses a default set of
-        character  tables  that  are  built  when  PCRE  is compiled, using the
+        character tables that are  built  when  PCRE  is  compiled,  using  the
-        default C locale. Otherwise, tableptr must be an address  that  is  the
+        default  C  locale.  Otherwise, tableptr must be an address that is the
-        result  of  a  call to pcre_maketables(). This value is stored with the
+        result of a call to pcre_maketables(). This value is  stored  with  the
-        compiled pattern, and used again by pcre_exec(), unless  another  table
+        compiled  pattern,  and used again by pcre_exec(), unless another table
         pointer is passed to it. For more discussion, see the section on locale
         support below.
-        This code fragment shows a typical straightforward  call  to  pcre_com-
+        This  code  fragment  shows a typical straightforward call to pcre_com-
         pile():
           pcre *re;
-Line 2043 
 COMPILING A PATTERN
+Line 2044 
 COMPILING A PATTERN
             &erroffset,       /* for error offset */
             NULL);            /* use default character tables */
-        The  following  names  for option bits are defined in the pcre.h header
+        The following names for option bits are defined in  the  pcre.h  header
         file:
           PCRE_ANCHORED
         If this bit is set, the pattern is forced to be "anchored", that is, it
-        is  constrained to match only at the first matching point in the string
+        is constrained to match only at the first matching point in the  string
-        that is being searched (the "subject string"). This effect can also  be
+        that  is being searched (the "subject string"). This effect can also be
-        achieved  by appropriate constructs in the pattern itself, which is the
+        achieved by appropriate constructs in the pattern itself, which is  the
         only way to do it in Perl.
           PCRE_AUTO_CALLOUT
         If this bit is set, pcre_compile() automatically inserts callout items,
-        all  with  number  255, before each pattern item. For discussion of the
+        all with number 255, before each pattern item. For  discussion  of  the
         callout facility, see the pcrecallout documentation.
           PCRE_BSR_ANYCRLF
           PCRE_BSR_UNICODE
         These options (which are mutually exclusive) control what the \R escape
-        sequence  matches.  The choice is either to match only CR, LF, or CRLF,
+        sequence matches. The choice is either to match only CR, LF,  or  CRLF,
         or to match any Unicode newline sequence. The default is specified when
         PCRE is built. It can be overridden from within the pattern, or by set-
         ting an option when a compiled pattern is matched.
           PCRE_CASELESS
-        If this bit is set, letters in the pattern match both upper  and  lower
+        If  this  bit is set, letters in the pattern match both upper and lower
-        case  letters.  It  is  equivalent  to  Perl's /i option, and it can be
+        case letters. It is equivalent to Perl's  /i  option,  and  it  can  be
-        changed within a pattern by a (?i) option setting. In UTF-8 mode,  PCRE
+        changed  within a pattern by a (?i) option setting. In UTF-8 mode, PCRE
-        always  understands the concept of case for characters whose values are
+        always understands the concept of case for characters whose values  are
-        less than 128, so caseless matching is always possible. For  characters
+        less  than 128, so caseless matching is always possible. For characters
-        with  higher  values,  the concept of case is supported if PCRE is com-
+        with higher values, the concept of case is supported if  PCRE  is  com-
-        piled with Unicode property support, but not otherwise. If you want  to
+        piled  with Unicode property support, but not otherwise. If you want to
-        use  caseless  matching  for  characters 128 and above, you must ensure
+        use caseless matching for characters 128 and  above,  you  must  ensure
-        that PCRE is compiled with Unicode property support  as  well  as  with
+        that  PCRE  is  compiled  with Unicode property support as well as with
         UTF-8 support.
           PCRE_DOLLAR_ENDONLY
-        If  this bit is set, a dollar metacharacter in the pattern matches only
+        If this bit is set, a dollar metacharacter in the pattern matches  only
-        at the end of the subject string. Without this option,  a  dollar  also
+        at  the  end  of the subject string. Without this option, a dollar also
-        matches  immediately before a newline at the end of the string (but not
+        matches immediately before a newline at the end of the string (but  not
-        before any other newlines). The PCRE_DOLLAR_ENDONLY option  is  ignored
+        before  any  other newlines). The PCRE_DOLLAR_ENDONLY option is ignored
-        if  PCRE_MULTILINE  is  set.   There is no equivalent to this option in
+        if PCRE_MULTILINE is set.  There is no equivalent  to  this  option  in
         Perl, and no way to set it within a pattern.
           PCRE_DOTALL
-        If this bit is set, a dot metacharacter in the pattern matches a  char-
+        If  this bit is set, a dot metacharacter in the pattern matches a char-
         acter of any value, including one that indicates a newline. However, it
-        only ever matches one character, even if newlines are  coded  as  CRLF.
+        only  ever  matches  one character, even if newlines are coded as CRLF.
-        Without  this option, a dot does not match when the current position is
+        Without this option, a dot does not match when the current position  is
         at a newline. This option is equivalent to Perl's /s option, and it can
-        be  changed within a pattern by a (?s) option setting. A negative class
+        be changed within a pattern by a (?s) option setting. A negative  class
         such as [^a] always matches newline characters, independent of the set-
         ting of this option.
           PCRE_DUPNAMES
-        If  this  bit is set, names used to identify capturing subpatterns need
+        If this bit is set, names used to identify capturing  subpatterns  need
         not be unique. This can be helpful for certain types of pattern when it
-        is  known  that  only  one instance of the named subpattern can ever be
+        is known that only one instance of the named  subpattern  can  ever  be
-        matched. There are more details of named subpatterns  below;  see  also
+        matched.  There  are  more details of named subpatterns below; see also
         the pcrepattern documentation.
           PCRE_EXTENDED
-        If  this  bit  is  set,  white space data characters in the pattern are
+        If this bit is set, white space data  characters  in  the  pattern  are
-        totally ignored except when escaped or inside a character class.  White
+        totally  ignored except when escaped or inside a character class. White
         space does not include the VT character (code 11). In addition, charac-
         ters between an unescaped # outside a character class and the next new-
-        line,  inclusive,  are  also  ignored.  This is equivalent to Perl's /x
+        line, inclusive, are also ignored. This  is  equivalent  to  Perl's  /x
-        option, and it can be changed within a pattern by a  (?x)  option  set-
+        option,  and  it  can be changed within a pattern by a (?x) option set-
         ting.
-        Which  characters  are  interpreted  as  newlines  is controlled by the
+        Which characters are interpreted  as  newlines  is  controlled  by  the
-        options passed to pcre_compile() or by a special sequence at the  start
+        options  passed to pcre_compile() or by a special sequence at the start
-        of  the  pattern, as described in the section entitled "Newline conven-
+        of the pattern, as described in the section entitled  "Newline  conven-
         tions" in the pcrepattern documentation. Note that the end of this type
-        of  comment  is  a  literal  newline  sequence  in  the pattern; escape
+        of comment is  a  literal  newline  sequence  in  the  pattern;  escape
         sequences that happen to represent a newline do not count.
-        This option makes it possible to include  comments  inside  complicated
+        This  option  makes  it possible to include comments inside complicated
-        patterns.   Note,  however,  that this applies only to data characters.
+        patterns.  Note, however, that this applies only  to  data  characters.
-        White space  characters  may  never  appear  within  special  character
+        White  space  characters  may  never  appear  within  special character
         sequences in a pattern, for example within the sequence (?( that intro-
         duces a conditional subpattern.
           PCRE_EXTRA
-        This option was invented in order to turn on  additional  functionality
+        This  option  was invented in order to turn on additional functionality
-        of  PCRE  that  is  incompatible with Perl, but it is currently of very
+        of PCRE that is incompatible with Perl, but it  is  currently  of  very
-        little use. When set, any backslash in a pattern that is followed by  a
+        little  use. When set, any backslash in a pattern that is followed by a
-        letter  that  has  no  special  meaning causes an error, thus reserving
+        letter that has no special meaning  causes  an  error,  thus  reserving
-        these combinations for future expansion. By  default,  as  in  Perl,  a
+        these  combinations  for  future  expansion.  By default, as in Perl, a
-        backslash  followed by a letter with no special meaning is treated as a
+        backslash followed by a letter with no special meaning is treated as  a
         literal. (Perl can, however, be persuaded to give an error for this, by
-        running  it with the -w option.) There are at present no other features
+        running it with the -w option.) There are at present no other  features
-        controlled by this option. It can also be set by a (?X) option  setting
+        controlled  by this option. It can also be set by a (?X) option setting
         within a pattern.
           PCRE_FIRSTLINE
-        If  this  option  is  set,  an  unanchored pattern is required to match
+        If this option is set, an  unanchored  pattern  is  required  to  match
-        before or at the first  newline  in  the  subject  string,  though  the
+        before  or  at  the  first  newline  in  the subject string, though the
         matched text may continue over the newline.
           PCRE_JAVASCRIPT_COMPAT
         If this option is set, PCRE's behaviour is changed in some ways so that
-        it is compatible with JavaScript rather than Perl. The changes  are  as
+        it  is  compatible with JavaScript rather than Perl. The changes are as
         follows:
-        (1)  A  lone  closing square bracket in a pattern causes a compile-time
+        (1) A lone closing square bracket in a pattern  causes  a  compile-time
-        error, because this is illegal in JavaScript (by default it is  treated
+        error,  because this is illegal in JavaScript (by default it is treated
         as a data character). Thus, the pattern AB]CD becomes illegal when this
         option is set.
-        (2) At run time, a back reference to an unset subpattern group  matches
+        (2)  At run time, a back reference to an unset subpattern group matches
-        an  empty  string (by default this causes the current matching alterna-
+        an empty string (by default this causes the current  matching  alterna-
-        tive to fail). A pattern such as (\1)(a) succeeds when this  option  is
+        tive  to  fail). A pattern such as (\1)(a) succeeds when this option is
-        set  (assuming  it can find an "a" in the subject), whereas it fails by
+        set (assuming it can find an "a" in the subject), whereas it  fails  by
         default, for Perl compatibility.
         (3) \U matches an upper case "U" character; by default \U causes a com-
         pile time error (Perl uses \U to upper case subsequent characters).
         (4) \u matches a lower case "u" character unless it is followed by four
-        hexadecimal digits, in which case the hexadecimal  number  defines  the
+        hexadecimal  digits,  in  which case the hexadecimal number defines the
-        code  point  to match. By default, \u causes a compile time error (Perl
+        code point to match. By default, \u causes a compile time  error  (Perl
         uses it to upper case the following character).
-        (5) \x matches a lower case "x" character unless it is followed by  two
+        (5)  \x matches a lower case "x" character unless it is followed by two
-        hexadecimal  digits,  in  which case the hexadecimal number defines the
+        hexadecimal digits, in which case the hexadecimal  number  defines  the
-        code point to match. By default, as in Perl, a  hexadecimal  number  is
+        code  point  to  match. By default, as in Perl, a hexadecimal number is
         always expected after \x, but it may have zero, one, or two digits (so,
         for example, \xz matches a binary zero character followed by z).
           PCRE_MULTILINE
-        By default, PCRE treats the subject string as consisting  of  a  single
+        By  default,  PCRE  treats the subject string as consisting of a single
-        line  of characters (even if it actually contains newlines). The "start
+        line of characters (even if it actually contains newlines). The  "start
-        of line" metacharacter (^) matches only at the  start  of  the  string,
+        of  line"  metacharacter  (^)  matches only at the start of the string,
-        while  the  "end  of line" metacharacter ($) matches only at the end of
+        while the "end of line" metacharacter ($) matches only at  the  end  of
         the string, or before a terminating newline (unless PCRE_DOLLAR_ENDONLY
         is set). This is the same as Perl.
-        When  PCRE_MULTILINE  it  is set, the "start of line" and "end of line"
+        When PCRE_MULTILINE it is set, the "start of line" and  "end  of  line"
-        constructs match immediately following or immediately  before  internal
+        constructs  match  immediately following or immediately before internal
-        newlines  in  the  subject string, respectively, as well as at the very
+        newlines in the subject string, respectively, as well as  at  the  very
-        start and end. This is equivalent to Perl's /m option, and  it  can  be
+        start  and  end.  This is equivalent to Perl's /m option, and it can be
         changed within a pattern by a (?m) option setting. If there are no new-
-        lines in a subject string, or no occurrences of ^ or $  in  a  pattern,
+        lines  in  a  subject string, or no occurrences of ^ or $ in a pattern,
         setting PCRE_MULTILINE has no effect.
           PCRE_NEWLINE_CR
-Line 2206 
 COMPILING A PATTERN
+Line 2207 
 COMPILING A PATTERN
           PCRE_NEWLINE_ANYCRLF
           PCRE_NEWLINE_ANY
-        These  options  override the default newline definition that was chosen
+        These options override the default newline definition that  was  chosen
-        when PCRE was built. Setting the first or the second specifies  that  a
+        when  PCRE  was built. Setting the first or the second specifies that a
-        newline  is  indicated  by a single character (CR or LF, respectively).
+        newline is indicated by a single character (CR  or  LF,  respectively).
-        Setting PCRE_NEWLINE_CRLF specifies that a newline is indicated by  the
+        Setting  PCRE_NEWLINE_CRLF specifies that a newline is indicated by the
-        two-character  CRLF  sequence.  Setting  PCRE_NEWLINE_ANYCRLF specifies
+        two-character CRLF  sequence.  Setting  PCRE_NEWLINE_ANYCRLF  specifies
         that any of the three preceding sequences should be recognized. Setting
-        PCRE_NEWLINE_ANY  specifies that any Unicode newline sequence should be
+        PCRE_NEWLINE_ANY specifies that any Unicode newline sequence should  be
         recognized.
-        In an ASCII/Unicode environment, the Unicode newline sequences are  the
+        In  an ASCII/Unicode environment, the Unicode newline sequences are the
-        three  just  mentioned,  plus  the  single characters VT (vertical tab,
+        three just mentioned, plus the  single  characters  VT  (vertical  tab,
         U+000B), FF (form feed, U+000C), NEL (next line, U+0085), LS (line sep-
-        arator,  U+2028),  and  PS (paragraph separator, U+2029). For the 8-bit
+        arator, U+2028), and PS (paragraph separator, U+2029).  For  the  8-bit
         library, the last two are recognized only in UTF-8 mode.
-        When PCRE is compiled to run in an EBCDIC (mainframe) environment,  the
+        When  PCRE is compiled to run in an EBCDIC (mainframe) environment, the
         code for CR is 0x0d, the same as ASCII. However, the character code for
-        LF is normally 0x15, though in some EBCDIC environments 0x25  is  used.
+        LF  is  normally 0x15, though in some EBCDIC environments 0x25 is used.
-        Whichever  of  these  is  not LF is made to correspond to Unicode's NEL
+        Whichever of these is not LF is made to  correspond  to  Unicode's  NEL
-        character. EBCDIC codes are all less than 256. For  more  details,  see
+        character.  EBCDIC  codes  are all less than 256. For more details, see
         the pcrebuild documentation.
-        The  newline  setting  in  the  options  word  uses three bits that are
+        The newline setting in the  options  word  uses  three  bits  that  are
         treated as a number, giving eight possibilities. Currently only six are
-        used  (default  plus the five values above). This means that if you set
+        used (default plus the five values above). This means that if  you  set
-        more than one newline option, the combination may or may not be  sensi-
+        more  than one newline option, the combination may or may not be sensi-
         ble. For example, PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is equivalent to
-        PCRE_NEWLINE_CRLF, but other combinations may yield unused numbers  and
+        PCRE_NEWLINE_CRLF,  but other combinations may yield unused numbers and
         cause an error.
-        The  only  time  that a line break in a pattern is specially recognized
+        The only time that a line break in a pattern  is  specially  recognized
-        when compiling is when PCRE_EXTENDED is set. CR and LF are white  space
+        when  compiling is when PCRE_EXTENDED is set. CR and LF are white space
-        characters,  and so are ignored in this mode. Also, an unescaped # out-
+        characters, and so are ignored in this mode. Also, an unescaped #  out-
-        side a character class indicates a comment that lasts until  after  the
+        side  a  character class indicates a comment that lasts until after the
-        next  line break sequence. In other circumstances, line break sequences
+        next line break sequence. In other circumstances, line break  sequences
         in patterns are treated as literal data.
         The newline option that is set at compile time becomes the default that
-Line 2249 
 COMPILING A PATTERN
+Line 2250 
 COMPILING A PATTERN
           PCRE_NO_AUTO_CAPTURE
         If this option is set, it disables the use of numbered capturing paren-
-        theses in the pattern. Any opening parenthesis that is not followed  by
+        theses  in the pattern. Any opening parenthesis that is not followed by
-        ?  behaves as if it were followed by ?: but named parentheses can still
+        ? behaves as if it were followed by ?: but named parentheses can  still
-        be used for capturing (and they acquire  numbers  in  the  usual  way).
+        be  used  for  capturing  (and  they acquire numbers in the usual way).
         There is no equivalent of this option in Perl.
           NO_START_OPTIMIZE
-        This  is an option that acts at matching time; that is, it is really an
+        This is an option that acts at matching time; that is, it is really  an
-        option for pcre_exec() or pcre_dfa_exec(). If  it  is  set  at  compile
+        option  for  pcre_exec()  or  pcre_dfa_exec().  If it is set at compile
-        time,  it is remembered with the compiled pattern and assumed at match-
+        time, it is remembered with the compiled pattern and assumed at  match-
-        ing time. For details  see  the  discussion  of  PCRE_NO_START_OPTIMIZE
+        ing  time.  For  details  see  the discussion of PCRE_NO_START_OPTIMIZE
         below.
           PCRE_UCP
-        This  option changes the way PCRE processes \B, \b, \D, \d, \S, \s, \W,
+        This option changes the way PCRE processes \B, \b, \D, \d, \S, \s,  \W,
-        \w, and some of the POSIX character classes.  By  default,  only  ASCII
+        \w,  and  some  of  the POSIX character classes. By default, only ASCII
-        characters  are  recognized, but if PCRE_UCP is set, Unicode properties
+        characters are recognized, but if PCRE_UCP is set,  Unicode  properties
-        are used instead to classify characters. More details are given in  the
+        are  used instead to classify characters. More details are given in the
-        section  on generic character types in the pcrepattern page. If you set
+        section on generic character types in the pcrepattern page. If you  set
-        PCRE_UCP, matching one of the items it affects takes much  longer.  The
+        PCRE_UCP,  matching  one of the items it affects takes much longer. The
-        option  is  available only if PCRE has been compiled with Unicode prop-
+        option is available only if PCRE has been compiled with  Unicode  prop-
         erty support.
           PCRE_UNGREEDY
-        This option inverts the "greediness" of the quantifiers  so  that  they
+        This  option  inverts  the "greediness" of the quantifiers so that they
-        are  not greedy by default, but become greedy if followed by "?". It is
+        are not greedy by default, but become greedy if followed by "?". It  is
-        not compatible with Perl. It can also be set by a (?U)  option  setting
+        not  compatible  with Perl. It can also be set by a (?U) option setting
         within the pattern.
           PCRE_UTF8
-        This  option  causes PCRE to regard both the pattern and the subject as
+        This option causes PCRE to regard both the pattern and the  subject  as
         strings of UTF-8 characters instead of single-byte strings. However, it
-        is  available  only  when PCRE is built to include UTF support. If not,
+        is available only when PCRE is built to include UTF  support.  If  not,
-        the use of this option provokes an error. Details of  how  this  option
+        the  use  of  this option provokes an error. Details of how this option
         changes the behaviour of PCRE are given in the pcreunicode page.
           PCRE_NO_UTF8_CHECK
         When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is
-        automatically checked. There is a  discussion  about  the  validity  of
+        automatically  checked.  There  is  a  discussion about the validity of
-        UTF-8  strings in the pcreunicode page. If an invalid UTF-8 sequence is
+        UTF-8 strings in the pcreunicode page. If an invalid UTF-8 sequence  is
-        found, pcre_compile() returns an error. If you already know  that  your
+        found,  pcre_compile()  returns an error. If you already know that your
-        pattern  is valid, and you want to skip this check for performance rea-
+        pattern is valid, and you want to skip this check for performance  rea-
-        sons, you can set the PCRE_NO_UTF8_CHECK option.  When it is  set,  the
+        sons,  you  can set the PCRE_NO_UTF8_CHECK option.  When it is set, the
         effect of passing an invalid UTF-8 string as a pattern is undefined. It
-        may cause your program to crash. Note that  this  option  can  also  be
+        may  cause  your  program  to  crash. Note that this option can also be
-        passed  to  pcre_exec()  and  pcre_dfa_exec(), to suppress the validity
+        passed to pcre_exec() and pcre_dfa_exec(),  to  suppress  the  validity
-        checking of subject strings only. If the same string is  being  matched
+        checking  of  subject strings only. If the same string is being matched
-        many  times, the option can be safely set for the second and subsequent
+        many times, the option can be safely set for the second and  subsequent
         matchings to improve performance.
  COMPILATION ERROR CODES
-        The following table lists the error  codes  than  may  be  returned  by
+        The  following  table  lists  the  error  codes than may be returned by
-        pcre_compile2(),  along with the error messages that may be returned by
+        pcre_compile2(), along with the error messages that may be returned  by
-        both compiling functions. Note that error  messages  are  always  8-bit
+        both  compiling  functions.  Note  that error messages are always 8-bit
-        ASCII  strings,  even  in 16-bit or 32-bit mode. As PCRE has developed,
+        ASCII strings, even in 16-bit or 32-bit mode. As  PCRE  has  developed,
-        some error codes have fallen out of use. To avoid confusion, they  have
+        some  error codes have fallen out of use. To avoid confusion, they have
         not been re-used.
  no error
-Line 2396 
 COMPILATION ERROR CODES
+Line 2397 
 COMPILATION ERROR CODES
  character value in \u.... sequence is too large
  invalid UTF-32 string (specifically UTF-32)
-        The  numbers  32  and 10000 in errors 48 and 49 are defaults; different
+        The numbers 32 and 10000 in errors 48 and 49  are  defaults;  different
         values may be used if the limits were changed when PCRE was built.
-Line 2405 
 STUDYING A PATTERN
+Line 2406 
 STUDYING A PATTERN
         pcre_extra *pcre_study(const pcre *code, int options
              const char **errptr);
-        If a compiled pattern is going to be used several times,  it  is  worth
+        If  a  compiled  pattern is going to be used several times, it is worth
         spending more time analyzing it in order to speed up the time taken for
-        matching. The function pcre_study() takes a pointer to a compiled  pat-
+        matching.  The function pcre_study() takes a pointer to a compiled pat-
         tern as its first argument. If studying the pattern produces additional
-        information that will help speed up matching,  pcre_study()  returns  a
+        information  that  will  help speed up matching, pcre_study() returns a
-        pointer  to a pcre_extra block, in which the study_data field points to
+        pointer to a pcre_extra block, in which the study_data field points  to
         the results of the study.
         The  returned  value  from  pcre_study()  can  be  passed  directly  to
-        pcre_exec()  or  pcre_dfa_exec(). However, a pcre_extra block also con-
+        pcre_exec() or pcre_dfa_exec(). However, a pcre_extra block  also  con-
-        tains other fields that can be set by the caller before  the  block  is
+        tains  other  fields  that can be set by the caller before the block is
         passed; these are described below in the section on matching a pattern.
-        If  studying  the  pattern  does  not  produce  any useful information,
+        If studying the  pattern  does  not  produce  any  useful  information,
-        pcre_study() returns NULL by default.  In  that  circumstance,  if  the
+        pcre_study()  returns  NULL  by  default.  In that circumstance, if the
         calling program wants to pass any of the other fields to pcre_exec() or
-        pcre_dfa_exec(), it must set up its own pcre_extra block.  However,  if
+        pcre_dfa_exec(),  it  must set up its own pcre_extra block. However, if
-        pcre_study()  is  called  with  the  PCRE_STUDY_EXTRA_NEEDED option, it
+        pcre_study() is called  with  the  PCRE_STUDY_EXTRA_NEEDED  option,  it
         returns a pcre_extra block even if studying did not find any additional
-        information.  It  may still return NULL, however, if an error occurs in
+        information. It may still return NULL, however, if an error  occurs  in
         pcre_study().
-        The second argument of pcre_study() contains  option  bits.  There  are
+        The  second  argument  of  pcre_study() contains option bits. There are
         three further options in addition to PCRE_STUDY_EXTRA_NEEDED:
           PCRE_STUDY_JIT_COMPILE
           PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE
           PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE
-        If  any  of  these are set, and the just-in-time compiler is available,
+        If any of these are set, and the just-in-time  compiler  is  available,
-        the pattern is further compiled into machine code  that  executes  much
+        the  pattern  is  further compiled into machine code that executes much
-        faster  than  the  pcre_exec()  interpretive  matching function. If the
+        faster than the pcre_exec()  interpretive  matching  function.  If  the
-        just-in-time compiler is not available, these options are ignored.  All
+        just-in-time  compiler is not available, these options are ignored. All
         undefined bits in the options argument must be zero.
-        JIT  compilation  is  a heavyweight optimization. It can take some time
+        JIT compilation is a heavyweight optimization. It can  take  some  time
-        for patterns to be analyzed, and for one-off matches  and  simple  pat-
+        for  patterns  to  be analyzed, and for one-off matches and simple pat-
-        terns  the benefit of faster execution might be offset by a much slower
+        terns the benefit of faster execution might be offset by a much  slower
         study time.  Not all patterns can be optimized by the JIT compiler. For
-        those  that cannot be handled, matching automatically falls back to the
+        those that cannot be handled, matching automatically falls back to  the
-        pcre_exec() interpreter. For more details, see the  pcrejit  documenta-
+        pcre_exec()  interpreter.  For more details, see the pcrejit documenta-
         tion.
-        The  third argument for pcre_study() is a pointer for an error message.
+        The third argument for pcre_study() is a pointer for an error  message.
-        If studying succeeds (even if no data is  returned),  the  variable  it
+        If  studying  succeeds  (even  if no data is returned), the variable it
-        points  to  is  set  to NULL. Otherwise it is set to point to a textual
+        points to is set to NULL. Otherwise it is set to  point  to  a  textual
         error message. This is a static string that is part of the library. You
-        must  not  try  to  free it. You should test the error pointer for NULL
+        must not try to free it. You should test the  error  pointer  for  NULL
         after calling pcre_study(), to be sure that it has run successfully.
-        When you are finished with a pattern, you can free the memory used  for
+        When  you are finished with a pattern, you can free the memory used for
         the study data by calling pcre_free_study(). This function was added to
-        the API for release 8.20. For earlier versions,  the  memory  could  be
+        the  API  for  release  8.20. For earlier versions, the memory could be
-        freed  with  pcre_free(), just like the pattern itself. This will still
+        freed with pcre_free(), just like the pattern itself. This  will  still
-        work in cases where JIT optimization is not used, but it  is  advisable
+        work  in  cases where JIT optimization is not used, but it is advisable
         to change to the new function when convenient.
-        This  is  a typical way in which pcre_study() is used (except that in a
+        This is a typical way in which pcre_study() is used (except that  in  a
         real application there should be tests for errors):
           int rc;
-Line 2482 
 STUDYING A PATTERN
+Line 2483 
 STUDYING A PATTERN
         Studying a pattern does two things: first, a lower bound for the length
         of subject string that is needed to match the pattern is computed. This
         does not mean that there are any strings of that length that match, but
-        it  does  guarantee that no shorter strings match. The value is used to
+        it does guarantee that no shorter strings match. The value is  used  to
         avoid wasting time by trying to match strings that are shorter than the
-        lower  bound.  You  can find out the value in a calling program via the
+        lower bound. You can find out the value in a calling  program  via  the
         pcre_fullinfo() function.
         Studying a pattern is also useful for non-anchored patterns that do not
-        have  a  single fixed starting character. A bitmap of possible starting
+        have a single fixed starting character. A bitmap of  possible  starting
-        bytes is created. This speeds up finding a position in the  subject  at
+        bytes  is  created. This speeds up finding a position in the subject at
         which to start matching. (In 16-bit mode, the bitmap is used for 16-bit
-        values less than 256.  In 32-bit mode, the bitmap is  used  for  32-bit
+        values  less  than  256.  In 32-bit mode, the bitmap is used for 32-bit
         values less than 256.)
-        These  two optimizations apply to both pcre_exec() and pcre_dfa_exec(),
+        These two optimizations apply to both pcre_exec() and  pcre_dfa_exec(),
-        and the information is also used by the JIT  compiler.   The  optimiza-
+        and  the  information  is also used by the JIT compiler.  The optimiza-
         tions can be disabled by setting the PCRE_NO_START_OPTIMIZE option when
         calling pcre_exec() or pcre_dfa_exec(), but if this is done, JIT execu-
-        tion  is  also disabled. You might want to do this if your pattern con-
+        tion is also disabled. You might want to do this if your  pattern  con-
-        tains callouts or (*MARK) and you want to make use of these  facilities
+        tains  callouts or (*MARK) and you want to make use of these facilities
-        in    cases    where    matching   fails.   See   the   discussion   of
+        in   cases   where   matching   fails.   See    the    discussion    of
         PCRE_NO_START_OPTIMIZE below.
  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. By default, higher-valued codes
+        characters with codes less than 128. By  default,  higher-valued  codes
         never match escapes such as \w or \d, but they can be tested with \p if
-        PCRE  is  built with Unicode character property support. Alternatively,
+        PCRE is built with Unicode character property  support.  Alternatively,
-        the PCRE_UCP option can be set at compile  time;  this  causes  \w  and
+        the  PCRE_UCP  option  can  be  set at compile time; this causes \w and
         friends to use Unicode property support instead of built-in tables. The
         use of locales with Unicode is discouraged. If you are handling charac-
-        ters  with codes greater than 128, you should either use UTF-8 and Uni-
+        ters with codes greater than 128, you should either use UTF-8 and  Uni-
         code, 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 2567 
 INFORMATION ABOUT A PATTERN
+Line 2568 
 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 pcre_info() function, which was removed from  the
+        tern.  It replaces the pcre_info() function, which was removed from the
         library at version 8.30, after more than 10 years of obsolescence.
-        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 2585 
 INFORMATION ABOUT A PATTERN
+Line 2586 
 INFORMATION ABOUT A PATTERN
                                     endianness
           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. The endi-
+        an simple check against passing an arbitrary memory pointer. The  endi-
         anness error can occur if a compiled pattern is saved and reloaded on a
-        different  host.  Here  is a typical call of pcre_fullinfo(), to obtain
+        different host. Here is a typical call of  pcre_fullinfo(),  to  obtain
         the length of the compiled pattern:
           int rc;
-Line 2599 
 INFORMATION ABOUT A PATTERN
+Line 2600 
 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 data unit of any matched string, for
-        a  non-anchored  pattern.  (The name of this option refers to the 8-bit
+        a non-anchored pattern. (The name of this option refers  to  the  8-bit
-        library, where data units are bytes.) The fourth argument should  point
+        library,  where data units are bytes.) The fourth argument should point
         to an int variable.
-        If  there  is  a  fixed first value, for example, the letter "c" from a
+        If there is a fixed first value, for example, the  letter  "c"  from  a
-        pattern such as (cat|cow|coyote), its value is returned. In  the  8-bit
+        pattern  such  as (cat|cow|coyote), its value is returned. In the 8-bit
-        library,  the  value is always less than 256. In the 16-bit library the
+        library, the value is always less than 256. In the 16-bit  library  the
         value can be up to 0xffff. In the 32-bit library the value can be up to
 x10ffff.
         If there is no fixed first value, and 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.
-        Since  for  the 32-bit library using the non-UTF-32 mode, this function
+        Since for the 32-bit library using the non-UTF-32 mode,  this  function
-        is unable to return the full 32-bit range of the character, this  value
+        is  unable to return the full 32-bit range of the character, this value
-        is    deprecated;   instead   the   PCRE_INFO_FIRSTCHARACTERFLAGS   and
+        is   deprecated;   instead   the   PCRE_INFO_FIRSTCHARACTERFLAGS    and
         PCRE_INFO_FIRSTCHARACTER values should be used.
           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 values for the first data unit
+-bit table indicating a fixed set of values for the first data  unit
-        in any matching string, a pointer to the table is  returned.  Otherwise
+        in  any  matching string, a pointer to the table is returned. Otherwise
-        NULL  is returned. The fourth argument should point to an unsigned char
+        NULL is returned. The fourth argument should point to an unsigned  char
         * variable.
           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_JIT
-        Return  1  if  the pattern was studied with one of the JIT options, and
+        Return 1 if the pattern was studied with one of the  JIT  options,  and
         just-in-time compiling was successful. The fourth argument should point
-        to  an  int variable. A return value of 0 means that JIT support is not
+        to an int variable. A return value of 0 means that JIT support  is  not
-        available in this version of PCRE, or that the pattern was not  studied
+        available  in this version of PCRE, or that the pattern was not studied
-        with  a JIT option, or that the JIT compiler could not handle this par-
+        with a JIT option, or that the JIT compiler could not handle this  par-
-        ticular pattern. See the pcrejit documentation for details of what  can
+        ticular  pattern. See the pcrejit documentation for details of what can
         and cannot be handled.
           PCRE_INFO_JITSIZE
-        If  the  pattern was successfully studied with a JIT option, return the
+        If the pattern was successfully studied with a JIT option,  return  the
-        size of the JIT compiled code, otherwise return zero. The fourth  argu-
+        size  of the JIT compiled code, otherwise return zero. The fourth argu-
         ment should point to a size_t variable.
           PCRE_INFO_LASTLITERAL
-        Return  the value of the rightmost literal data unit that must exist in
+        Return the value of the rightmost literal data unit that must exist  in
-        any matched string, other than at its start, if such a value  has  been
+        any  matched  string, other than at its start, if such a value has been
         recorded. The fourth argument should point to an int variable. If there
         is no such value, -1 is returned. For anchored patterns, a last literal
-        value  is recorded only if it follows something of variable length. For
+        value 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.
-        Since  for  the 32-bit library using the non-UTF-32 mode, this function
+        Since for the 32-bit library using the non-UTF-32 mode,  this  function
-        is unable to return the full 32-bit range of the character, this  value
+        is  unable to return the full 32-bit range of the character, this value
-        is    deprecated;    instead    the   PCRE_INFO_REQUIREDCHARFLAGS   and
+        is   deprecated;   instead    the    PCRE_INFO_REQUIREDCHARFLAGS    and
         PCRE_INFO_REQUIREDCHAR values should be used.
           PCRE_INFO_MAXLOOKBEHIND
-        Return the number of characters (NB not bytes) in the  longest  lookbe-
+        Return  the  number of characters (NB not bytes) in the longest lookbe-
-        hind  assertion  in the pattern. Note that the simple assertions \b and
+        hind assertion in the pattern. Note that the simple assertions  \b  and
-        \B require a one-character lookbehind. This information is useful  when
+        \B  require a one-character lookbehind. This information is useful when
         doing multi-segment matching using the partial matching facilities.
           PCRE_INFO_MINLENGTH
-        If  the  pattern  was studied and a minimum length for matching subject
+        If the pattern was studied and a minimum length  for  matching  subject
-        strings was computed, its value is  returned.  Otherwise  the  returned
+        strings  was  computed,  its  value is returned. Otherwise the returned
-        value  is  -1. The value is a number of characters, which in UTF-8 mode
+        value is -1. The value is a number of characters, which in  UTF-8  mode
-        may be different from the number of bytes. The fourth  argument  should
+        may  be  different from the number of bytes. The fourth argument should
-        point  to an int variable. A non-negative value is a lower bound to the
+        point to an int variable. A non-negative value is a lower bound to  the
-        length of any matching string. There may not be  any  strings  of  that
+        length  of  any  matching  string. There may not be any strings of that
-        length  that  do actually match, but every string that does match is at
+        length that do actually match, but every string that does match  is  at
         least that long.
           PCRE_INFO_NAMECOUNT
           PCRE_INFO_NAMEENTRYSIZE
           PCRE_INFO_NAMETABLE
-        PCRE supports the use of named as well as numbered capturing  parenthe-
+        PCRE  supports the use of named as well as numbered capturing parenthe-
-        ses.  The names are just an additional way of identifying the parenthe-
+        ses. The names are just an additional way of identifying the  parenthe-
         ses, which still acquire numbers. Several convenience functions such as
-        pcre_get_named_substring()  are  provided  for extracting captured sub-
+        pcre_get_named_substring() are provided for  extracting  captured  sub-
-        strings by name. It is also possible to extract the data  directly,  by
+        strings  by  name. It is also possible to extract the data directly, by
-        first  converting  the  name to a number in order to access the correct
+        first converting the name to a number in order to  access  the  correct
         pointers in the output vector (described with pcre_exec() below). To do
-        the  conversion,  you  need  to  use  the  name-to-number map, which is
+        the conversion, you need  to  use  the  name-to-number  map,  which  is
         described by these three values.
         The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT
         gives the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size
-        of each entry; both of these  return  an  int  value.  The  entry  size
+        of  each  entry;  both  of  these  return  an int value. The entry size
-        depends  on the length of the longest name. PCRE_INFO_NAMETABLE returns
+        depends on the length of the longest name. PCRE_INFO_NAMETABLE  returns
         a pointer to the first entry of the table. This is a pointer to char in
         the 8-bit library, where the first two bytes of each entry are the num-
-        ber of the capturing parenthesis, most significant byte first.  In  the
+        ber  of  the capturing parenthesis, most significant byte first. In the
--bit  library,  the pointer points to 16-bit data units, the first of
+-bit library, the pointer points to 16-bit data units, the  first  of
-        which contains the parenthesis number.   In  the  32-bit  library,  the
+        which  contains  the  parenthesis  number.   In the 32-bit library, the
-        pointer  points  to  32-bit data units, the first of which contains the
+        pointer points to 32-bit data units, the first of  which  contains  the
-        parenthesis number. The rest of the entry is  the  corresponding  name,
+        parenthesis  number.  The  rest of the entry is the corresponding name,
         zero terminated.
-        The  names are in alphabetical order. Duplicate names may appear if (?|
+        The names are in alphabetical order. Duplicate names may appear if  (?|
         is used to create multiple groups with the same number, as described in
-        the  section  on  duplicate subpattern numbers in the pcrepattern page.
+        the section on duplicate subpattern numbers in  the  pcrepattern  page.
-        Duplicate names for subpatterns with different  numbers  are  permitted
+        Duplicate  names  for  subpatterns with different numbers are permitted
-        only  if  PCRE_DUPNAMES  is  set. In all cases of duplicate names, they
+        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-
+        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;
+        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
+        As a simple example of the name/number table,  consider  the  following
         pattern after compilation by the 8-bit library (assume PCRE_EXTENDED is
         set, so white space - including newlines - 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 2775 
 INFORMATION ABOUT A PATTERN
+Line 2776 
 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 2813 
 INFORMATION ABOUT A PATTERN
+Line 2814 
 INFORMATION ABOUT A PATTERN
           PCRE_INFO_SIZE
-        Return the size of the compiled pattern in bytes (for both  libraries).
+        Return  the size of the compiled pattern in bytes (for both libraries).
-        The  fourth argument should point to a size_t variable. This value does
+        The fourth argument should point to a size_t variable. This value  does
-        not include the  size  of  the  pcre  structure  that  is  returned  by
+        not  include  the  size  of  the  pcre  structure  that  is returned by
-        pcre_compile().  The  value that is passed as the argument to pcre_mal-
+        pcre_compile(). The value that is passed as the argument  to  pcre_mal-
-        loc() when pcre_compile() is getting memory in which to place the  com-
+        loc()  when pcre_compile() is getting memory in which to place the com-
-        piled  data  is  the value returned by this option plus the size of the
+        piled data is the value returned by this option plus the  size  of  the
-        pcre structure. Studying a compiled pattern, with or without JIT,  does
+        pcre  structure. Studying a compiled pattern, with or without JIT, does
         not alter the value returned by this option.
           PCRE_INFO_STUDYSIZE
         Return the size in bytes of the data block pointed to by the study_data
-        field in a pcre_extra block. If pcre_extra is  NULL,  or  there  is  no
+        field  in  a  pcre_extra  block.  If pcre_extra is NULL, or there is no
-        study  data,  zero  is  returned. The fourth argument should point to a
+        study data, zero is returned. The fourth argument  should  point  to  a
-        size_t variable. The study_data field is set by pcre_study() to  record
+        size_t  variable. The study_data field is set by pcre_study() to record
-        information  that  will  speed  up  matching  (see the section entitled
+        information that will speed  up  matching  (see  the  section  entitled
         "Studying a pattern" above). The format of the study_data block is pri-
-        vate,  but  its length is made available via this option so that it can
+        vate, but its length is made available via this option so that  it  can
         be  saved  and  restored  (see  the  pcreprecompile  documentation  for
         details).
           PCRE_INFO_FIRSTCHARACTERFLAGS
         Return information about the first data unit of any matched string, for
-        a non-anchored pattern. The fourth argument  should  point  to  an  int
+        a  non-anchored  pattern.  The  fourth  argument should point to an int
         variable.
-        If  there  is  a  fixed first value, for example, the letter "c" from a
+        If there is a fixed first value, for example, the  letter  "c"  from  a
-        pattern such as (cat|cow|coyote), 1  is  returned,  and  the  character
+        pattern  such  as  (cat|cow|coyote),  1  is returned, and the character
         value can be retrieved using PCRE_INFO_FIRSTCHARACTER.
         If there is no fixed first value, and 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
-Line 2858 
 INFORMATION ABOUT A PATTERN
+Line 2859 
 INFORMATION ABOUT A PATTERN
           PCRE_INFO_FIRSTCHARACTER
-        Return  the  fixed  first character value, if PCRE_INFO_FIRSTCHARACTER-
+        Return the fixed first character  value,  if  PCRE_INFO_FIRSTCHARACTER-
         FLAGS returned 1; otherwise returns 0. The fourth argument should point
         to an uint_t variable.
-        In  the 8-bit library, the value is always less than 256. In the 16-bit
+        In the 8-bit library, the value is always less than 256. In the  16-bit
-        library the value can be up to 0xffff. In the 32-bit library in  UTF-32
+        library  the value can be up to 0xffff. In the 32-bit library in UTF-32
-        mode  the  value  can  be up to 0x10ffff, and up to 0xffffffff when not
+        mode the value can be up to 0x10ffff, and up  to  0xffffffff  when  not
         using UTF-32 mode.
         If there is no fixed first value, and if either
-        (a) the pattern was compiled with the PCRE_MULTILINE option, and  every
+        (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_REQUIREDCHARFLAGS
-        Returns 1 if there is a rightmost literal data unit that must exist  in
+        Returns  1 if there is a rightmost literal data unit that must exist in
         any matched string, other than at its start. The fourth argument should
-        point to an int variable. If there is no such value, 0 is returned.  If
+        point  to an int variable. If there is no such value, 0 is returned. If
         returning  1,  the  character  value  itself  can  be  retrieved  using
         PCRE_INFO_REQUIREDCHAR.
         For anchored patterns, a last literal value is recorded only if it fol-
-        lows  something  of  variable  length.  For  example,  for  the pattern
+        lows something  of  variable  length.  For  example,  for  the  pattern
-        /^a\d+z\d+/  the   returned   value   1   (with   "z"   returned   from
+        /^a\d+z\d+/   the   returned   value   1   (with   "z"   returned  from
         PCRE_INFO_REQUIREDCHAR), but for /^a\dz\d/ the returned value is 0.
           PCRE_INFO_REQUIREDCHAR
-        Return  the value of the rightmost literal data unit that must exist in
+        Return the value of the rightmost literal data unit that must exist  in
-        any matched string, other than at its start, if such a value  has  been
+        any  matched  string, other than at its start, if such a value has been
-        recorded.  The fourth argument should point to an uint32_t variable. If
+        recorded. The fourth argument should point to an uint32_t variable.  If
         there is no such value, 0 is returned.
-Line 2904 
 REFERENCE COUNTS
+Line 2905 
 REFERENCE COUNTS
         int pcre_refcount(pcre *code, int adjust);
-        The pcre_refcount() function is used to maintain a reference  count  in
+        The  pcre_refcount()  function is used to maintain a reference count in
         the data block that contains a compiled pattern. It is provided for the
-        benefit of applications that  operate  in  an  object-oriented  manner,
+        benefit  of  applications  that  operate  in an object-oriented manner,
         where different parts of the application may be using the same compiled
         pattern, but you want to free the block when they are all done.
         When a pattern is compiled, the reference count field is initialized to
-        zero.   It is changed only by calling this function, whose action is to
+        zero.  It is changed only by calling this function, whose action is  to
-        add the adjust value (which may be positive or  negative)  to  it.  The
+        add  the  adjust  value  (which may be positive or negative) to it. The
         yield of the function is the new value. However, the value of the count
-        is constrained to lie between 0 and 65535, inclusive. If the new  value
+        is  constrained to lie between 0 and 65535, inclusive. If the new value
         is outside these limits, it is forced to the appropriate limit value.
-        Except  when it is zero, the reference count is not correctly preserved
+        Except when it is zero, the reference count is not correctly  preserved
-        if a pattern is compiled on one host and then  transferred  to  a  host
+        if  a  pattern  is  compiled on one host and then transferred to a host
         whose byte-order is different. (This seems a highly unlikely scenario.)
-Line 2928 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2929 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
              const char *subject, int length, int startoffset,
              int options, int *ovector, int ovecsize);
-        The  function pcre_exec() is called to match a subject string against a
+        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
+        compiled  pattern, which is passed in the code argument. If the pattern
-        was  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. You can call pcre_exec() with the same code and  extra  argu-
+        argument.  You  can call pcre_exec() with the same code and extra argu-
-        ments  as  many  times as you like, in order to match different subject
+        ments as many times as you like, in order to  match  different  subject
         strings with the same pattern.
-        This function is the main matching facility  of  the  library,  and  it
+        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
+        operates in a Perl-like manner. For specialist use  there  is  also  an
-        alternative matching function, which is described below in the  section
+        alternative  matching function, which is described below in the section
         about the pcre_dfa_exec() function.
-        In  most applications, the pattern will have been compiled (and option-
+        In most applications, the pattern will have been compiled (and  option-
-        ally studied) in the same process that calls pcre_exec().  However,  it
+        ally  studied)  in the same process that calls pcre_exec(). However, it
         is possible to save compiled patterns and study data, and then use them
-        later in different processes, possibly even on different hosts.  For  a
+        later  in  different processes, possibly even on different hosts. For a
         discussion about this, see the pcreprecompile documentation.
         Here is an example of a simple call to pcre_exec():
-Line 2962 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2963 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
     Extra data for pcre_exec()
-        If  the  extra argument is not NULL, it must point to a pcre_extra data
+        If the extra argument is not NULL, it must point to a  pcre_extra  data
-        block. The pcre_study() function returns such a block (when it  doesn't
+        block.  The pcre_study() function returns such a block (when it doesn't
-        return  NULL), but you can also create one for yourself, and pass addi-
+        return NULL), but you can also create one for yourself, and pass  addi-
-        tional information in it. The pcre_extra block contains  the  following
+        tional  information  in it. The pcre_extra block contains the following
         fields (not necessarily in this order):
           unsigned long int flags;
-Line 2977 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2978 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           const unsigned char *tables;
           unsigned char **mark;
-        In  the  16-bit  version  of  this  structure,  the mark field has type
+        In the 16-bit version of  this  structure,  the  mark  field  has  type
         "PCRE_UCHAR16 **".
-        In the 32-bit version of  this  structure,  the  mark  field  has  type
+        In  the  32-bit  version  of  this  structure,  the mark field has type
         "PCRE_UCHAR32 **".
-        The  flags  field is used to specify which of the other fields are set.
+        The flags field is used to specify which of the other fields  are  set.
         The flag bits are:
           PCRE_EXTRA_CALLOUT_DATA
-Line 2994 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2995 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_EXTRA_STUDY_DATA
           PCRE_EXTRA_TABLES
-        Other flag bits should be set to zero. The study_data field  and  some-
+        Other  flag  bits should be set to zero. The study_data field and some-
-        times  the executable_jit field are set in the pcre_extra block that is
+        times the executable_jit field are set in the pcre_extra block that  is
-        returned by pcre_study(), together with the appropriate flag bits.  You
+        returned  by pcre_study(), together with the appropriate flag bits. You
-        should  not set these yourself, but you may add to the block by setting
+        should not set these yourself, but you may add to the block by  setting
         other fields and their corresponding flag bits.
         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
+        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
+        match,  but  which  have  a very large number of possibilities in their
-        search  trees. The classic example is a pattern that uses nested unlim-
+        search trees. The classic example is a pattern that uses nested  unlim-
         ited repeats.
-        Internally, pcre_exec() uses a function called match(), which it  calls
+        Internally,  pcre_exec() uses a function called match(), which it calls
-        repeatedly  (sometimes  recursively).  The  limit set by match_limit is
+        repeatedly (sometimes recursively). The limit  set  by  match_limit  is
-        imposed on the number of times this function is called during a  match,
+        imposed  on the number of times this function is called during a match,
-        which  has  the  effect of limiting the amount of backtracking that can
+        which has the effect of limiting the amount of  backtracking  that  can
         take place. For patterns that are not anchored, the count restarts from
         zero for each position in the subject string.
         When pcre_exec() is called with a pattern that was successfully studied
-        with a JIT option, the way that the matching is  executed  is  entirely
+        with  a  JIT  option, the way that the matching is executed is entirely
         different.  However, there is still the possibility of runaway matching
         that goes on for a very long time, and so the match_limit value is also
         used in this case (but in a different way) to limit how long the match-
         ing can continue.
-        The default value for the limit can be set  when  PCRE  is  built;  the
+        The  default  value  for  the  limit can be set when PCRE is built; the
-        default  default  is 10 million, which handles all but the most extreme
+        default default is 10 million, which handles all but the  most  extreme
-        cases. You can override the default  by  suppling  pcre_exec()  with  a
+        cases.  You  can  override  the  default by suppling pcre_exec() with a
-        pcre_extra     block    in    which    match_limit    is    set,    and
+        pcre_extra    block    in    which    match_limit    is    set,     and
-        PCRE_EXTRA_MATCH_LIMIT is set in the  flags  field.  If  the  limit  is
+        PCRE_EXTRA_MATCH_LIMIT  is  set  in  the  flags  field. If the limit is
         exceeded, pcre_exec() returns PCRE_ERROR_MATCHLIMIT.
-        The  match_limit_recursion field is similar to match_limit, but instead
+        The match_limit_recursion field is similar to match_limit, but  instead
         of limiting the total number of times that match() is called, it limits
-        the  depth  of  recursion. The recursion depth is a smaller number than
+        the depth of recursion. The recursion depth is a  smaller  number  than
-        the total number of calls, because not all calls to match() are  recur-
+        the  total number of calls, because not all calls to match() are recur-
         sive.  This limit is of use only if it is set smaller than match_limit.
-        Limiting  the  recursion  depth limits the amount of machine stack that
+        Limiting the recursion depth limits the amount of  machine  stack  that
-        can be used, or, when PCRE has been compiled to use memory on the  heap
+        can  be used, or, when PCRE has been compiled to use memory on the heap
-        instead  of the stack, the amount of heap memory that can be used. This
+        instead of the stack, the amount of heap memory that can be used.  This
-        limit is not relevant, and is ignored, when matching is done using  JIT
+        limit  is not relevant, and is ignored, when matching is done using JIT
         compiled code.
-        The  default  value  for  match_limit_recursion can be set when PCRE is
+        The default value for match_limit_recursion can be  set  when  PCRE  is
-        built; the default default  is  the  same  value  as  the  default  for
+        built;  the  default  default  is  the  same  value  as the default for
-        match_limit.  You can override the default by suppling pcre_exec() with
+        match_limit. You can override the default by suppling pcre_exec()  with
-        a  pcre_extra  block  in  which  match_limit_recursion  is   set,   and
+        a   pcre_extra   block  in  which  match_limit_recursion  is  set,  and
-        PCRE_EXTRA_MATCH_LIMIT_RECURSION  is  set  in  the  flags field. If the
+        PCRE_EXTRA_MATCH_LIMIT_RECURSION is set in  the  flags  field.  If  the
         limit is exceeded, pcre_exec() returns PCRE_ERROR_RECURSIONLIMIT.
-        The callout_data field is used in conjunction with the  "callout"  fea-
+        The  callout_data  field is used in conjunction with the "callout" fea-
         ture, and is described in the pcrecallout documentation.
-        The  tables  field  is  used  to  pass  a  character  tables pointer to
+        The tables field  is  used  to  pass  a  character  tables  pointer  to
-        pcre_exec(); this overrides the value that is stored with the  compiled
+        pcre_exec();  this overrides the value that is stored with the compiled
-        pattern.  A  non-NULL value is stored with the compiled pattern only if
+        pattern. A non-NULL value is stored with the compiled pattern  only  if
-        custom tables were supplied to pcre_compile() via  its  tableptr  argu-
+        custom  tables  were  supplied to pcre_compile() via its tableptr argu-
         ment.  If NULL is passed to pcre_exec() using this mechanism, it forces
-        PCRE's internal tables to be used. This facility is  helpful  when  re-
+        PCRE's  internal  tables  to be used. This facility is helpful when re-
-        using  patterns  that  have been saved after compiling with an external
+        using patterns that have been saved after compiling  with  an  external
-        set of tables, because the external tables  might  be  at  a  different
+        set  of  tables,  because  the  external tables might be at a different
-        address  when  pcre_exec() is called. See the pcreprecompile documenta-
+        address when pcre_exec() is called. See the  pcreprecompile  documenta-
         tion for a discussion of saving compiled patterns for later use.
-        If PCRE_EXTRA_MARK is set in the flags field, the mark  field  must  be
+        If  PCRE_EXTRA_MARK  is  set in the flags field, the mark field must be
-        set  to point to a suitable variable. If the pattern contains any back-
+        set to point to a suitable variable. If the pattern contains any  back-
-        tracking control verbs such as (*MARK:NAME), and the execution ends  up
+        tracking  control verbs such as (*MARK:NAME), and the execution ends up
-        with  a  name  to  pass back, a pointer to the name string (zero termi-
+        with a name to pass back, a pointer to the  name  string  (zero  termi-
-        nated) is placed in the variable pointed to  by  the  mark  field.  The
+        nated)  is  placed  in  the  variable pointed to by the mark field. The
-        names  are  within  the  compiled pattern; if you wish to retain such a
+        names are within the compiled pattern; if you wish  to  retain  such  a
-        name you must copy it before freeing the memory of a compiled  pattern.
+        name  you must copy it before freeing the memory of a compiled pattern.
-        If  there  is no name to pass back, the variable pointed to by the mark
+        If there is no name to pass back, the variable pointed to by  the  mark
-        field is set to NULL. For details of the  backtracking  control  verbs,
+        field  is  set  to NULL. For details of the backtracking control verbs,
         see the section entitled "Backtracking control" in the pcrepattern doc-
         umentation.
     Option bits for pcre_exec()
-        The unused bits of the options argument for pcre_exec() must  be  zero.
+        The  unused  bits of the options argument for pcre_exec() must be zero.
-        The  only  bits  that  may  be set are PCRE_ANCHORED, PCRE_NEWLINE_xxx,
+        The only bits that may  be  set  are  PCRE_ANCHORED,  PCRE_NEWLINE_xxx,
-        PCRE_NOTBOL,   PCRE_NOTEOL,    PCRE_NOTEMPTY,    PCRE_NOTEMPTY_ATSTART,
+        PCRE_NOTBOL,    PCRE_NOTEOL,    PCRE_NOTEMPTY,   PCRE_NOTEMPTY_ATSTART,
-        PCRE_NO_START_OPTIMIZE,   PCRE_NO_UTF8_CHECK,   PCRE_PARTIAL_HARD,  and
+        PCRE_NO_START_OPTIMIZE,  PCRE_NO_UTF8_CHECK,   PCRE_PARTIAL_HARD,   and
         PCRE_PARTIAL_SOFT.
-        If the pattern was successfully studied with one  of  the  just-in-time
+        If  the  pattern  was successfully studied with one of the just-in-time
         (JIT) compile options, the only supported options for JIT execution are
-        PCRE_NO_UTF8_CHECK,    PCRE_NOTBOL,     PCRE_NOTEOL,     PCRE_NOTEMPTY,
+        PCRE_NO_UTF8_CHECK,     PCRE_NOTBOL,     PCRE_NOTEOL,    PCRE_NOTEMPTY,
-        PCRE_NOTEMPTY_ATSTART,  PCRE_PARTIAL_HARD, and PCRE_PARTIAL_SOFT. If an
+        PCRE_NOTEMPTY_ATSTART, PCRE_PARTIAL_HARD, and PCRE_PARTIAL_SOFT. If  an
-        unsupported option is used, JIT execution is disabled  and  the  normal
+        unsupported  option  is  used, JIT execution is disabled and the normal
         interpretive code in pcre_exec() is run.
           PCRE_ANCHORED
-        The  PCRE_ANCHORED  option  limits pcre_exec() to matching at the first
+        The PCRE_ANCHORED option limits pcre_exec() to matching  at  the  first
-        matching position. If a pattern was  compiled  with  PCRE_ANCHORED,  or
+        matching  position.  If  a  pattern was compiled with PCRE_ANCHORED, or
-        turned  out to be anchored by virtue of its contents, it cannot be made
+        turned out to be anchored by virtue of its contents, it cannot be  made
         unachored at matching time.
           PCRE_BSR_ANYCRLF
           PCRE_BSR_UNICODE
         These options (which are mutually exclusive) control what the \R escape
-        sequence  matches.  The choice is either to match only CR, LF, or CRLF,
+        sequence matches. The choice is either to match only CR, LF,  or  CRLF,
-        or to match any Unicode newline sequence. These  options  override  the
+        or  to  match  any Unicode newline sequence. These options override the
         choice that was made or defaulted when the pattern was compiled.
           PCRE_NEWLINE_CR
-Line 3108 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 3109 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_NEWLINE_ANYCRLF
           PCRE_NEWLINE_ANY
-        These  options  override  the  newline  definition  that  was chosen or
+        These options override  the  newline  definition  that  was  chosen  or
-        defaulted when the pattern was compiled. For details, see the  descrip-
+        defaulted  when the pattern was compiled. For details, see the descrip-
-        tion  of  pcre_compile()  above.  During  matching,  the newline choice
+        tion of pcre_compile()  above.  During  matching,  the  newline  choice
-        affects the behaviour of the dot, circumflex,  and  dollar  metacharac-
+        affects  the  behaviour  of the dot, circumflex, and dollar metacharac-
-        ters.  It may also alter the way the match position is advanced after a
+        ters. It may also alter the way the match position is advanced after  a
         match failure for an unanchored pattern.
-        When PCRE_NEWLINE_CRLF, PCRE_NEWLINE_ANYCRLF,  or  PCRE_NEWLINE_ANY  is
+        When  PCRE_NEWLINE_CRLF,  PCRE_NEWLINE_ANYCRLF,  or PCRE_NEWLINE_ANY is
-        set,  and a match attempt for an unanchored pattern fails when the cur-
+        set, and a match attempt for an unanchored pattern fails when the  cur-
-        rent position is at a  CRLF  sequence,  and  the  pattern  contains  no
+        rent  position  is  at  a  CRLF  sequence,  and the pattern contains no
-        explicit  matches  for  CR  or  LF  characters,  the  match position is
+        explicit matches for  CR  or  LF  characters,  the  match  position  is
         advanced by two characters instead of one, in other words, to after the
         CRLF.
         The above rule is a compromise that makes the most common cases work as
-        expected. For example, if the  pattern  is  .+A  (and  the  PCRE_DOTALL
+        expected.  For  example,  if  the  pattern  is .+A (and the PCRE_DOTALL
         option is not set), it does not match the string "\r\nA" because, after
-        failing at the start, it skips both the CR and the LF before  retrying.
+        failing  at the start, it skips both the CR and the LF before retrying.
-        However,  the  pattern  [\r\n]A does match that string, because it con-
+        However, the pattern [\r\n]A does match that string,  because  it  con-
         tains an explicit CR or LF reference, and so advances only by one char-
         acter after the first failure.
         An explicit match for CR of LF is either a literal appearance of one of
-        those characters, or one of the \r or  \n  escape  sequences.  Implicit
+        those  characters,  or  one  of the \r or \n escape sequences. Implicit
-        matches  such  as [^X] do not count, nor does \s (which includes CR and
+        matches such as [^X] do not count, nor does \s (which includes  CR  and
         LF in the characters that it matches).
-        Notwithstanding the above, anomalous effects may still occur when  CRLF
+        Notwithstanding  the above, anomalous effects may still occur when CRLF
         is a valid newline sequence and explicit \r or \n escapes appear in the
         pattern.
           PCRE_NOTBOL
         This option specifies that first character of the subject string is not
-        the  beginning  of  a  line, so the circumflex metacharacter should not
+        the beginning of a line, so the  circumflex  metacharacter  should  not
-        match before it. Setting this without PCRE_MULTILINE (at compile  time)
+        match  before it. Setting this without PCRE_MULTILINE (at compile time)
-        causes  circumflex  never to match. This option affects only the behav-
+        causes circumflex never to match. This option affects only  the  behav-
         iour of the circumflex metacharacter. It does not affect \A.
           PCRE_NOTEOL
         This option specifies that the end of the subject string is not the end
-        of  a line, so the dollar metacharacter should not match it nor (except
+        of a line, so the dollar metacharacter should not match it nor  (except
-        in multiline mode) a newline immediately before it. Setting this  with-
+        in  multiline mode) a newline immediately before it. Setting this with-
         out PCRE_MULTILINE (at compile time) causes dollar never to match. This
-        option affects only the behaviour of the dollar metacharacter. It  does
+        option  affects only the behaviour of the dollar metacharacter. It does
         not affect \Z or \z.
           PCRE_NOTEMPTY
         An empty string is not considered to be a valid match if this option is
-        set. If there are alternatives in the pattern, they are tried.  If  all
+        set.  If  there are alternatives in the pattern, they are tried. If all
-        the  alternatives  match  the empty string, the entire match fails. For
+        the alternatives match the empty string, the entire  match  fails.  For
         example, if the pattern
           a?b?
-        is applied to a string not beginning with "a" or  "b",  it  matches  an
+        is  applied  to  a  string not beginning with "a" or "b", it matches an
-        empty  string at the start of the subject. With PCRE_NOTEMPTY set, this
+        empty string at the start of the subject. With PCRE_NOTEMPTY set,  this
         match is not valid, so PCRE searches further into the string for occur-
         rences of "a" or "b".
           PCRE_NOTEMPTY_ATSTART
-        This  is  like PCRE_NOTEMPTY, except that an empty string match that is
+        This is like PCRE_NOTEMPTY, except that an empty string match  that  is
-        not at the start of  the  subject  is  permitted.  If  the  pattern  is
+        not  at  the  start  of  the  subject  is  permitted. If the pattern is
         anchored, such a match can occur only if the pattern contains \K.
-        Perl     has    no    direct    equivalent    of    PCRE_NOTEMPTY    or
+        Perl    has    no    direct    equivalent    of    PCRE_NOTEMPTY     or
-        PCRE_NOTEMPTY_ATSTART, but it does make a special  case  of  a  pattern
+        PCRE_NOTEMPTY_ATSTART,  but  it  does  make a special case of a pattern
-        match  of  the empty string within its split() function, and when using
+        match of the empty string within its split() function, and  when  using
-        the /g modifier. It is  possible  to  emulate  Perl's  behaviour  after
+        the  /g  modifier.  It  is  possible  to emulate Perl's behaviour after
         matching a null string by first trying the match again at the same off-
-        set with PCRE_NOTEMPTY_ATSTART and  PCRE_ANCHORED,  and  then  if  that
+        set  with  PCRE_NOTEMPTY_ATSTART  and  PCRE_ANCHORED,  and then if that
         fails, by advancing the starting offset (see below) and trying an ordi-
-        nary match again. There is some code that demonstrates how to  do  this
+        nary  match  again. There is some code that demonstrates how to do this
-        in  the  pcredemo sample program. In the most general case, you have to
+        in the pcredemo sample program. In the most general case, you  have  to
-        check to see if the newline convention recognizes CRLF  as  a  newline,
+        check  to  see  if the newline convention recognizes CRLF as a newline,
-        and  if so, and the current character is CR followed by LF, advance the
+        and if so, and the current character is CR followed by LF, advance  the
         starting offset by two characters instead of one.
           PCRE_NO_START_OPTIMIZE
-        There are a number of optimizations that pcre_exec() uses at the  start
+        There  are a number of optimizations that pcre_exec() uses at the start
-        of  a  match,  in  order to speed up the process. For example, if it is
+        of a match, in order to speed up the process. For  example,  if  it  is
         known that an unanchored match must start with a specific character, it
-        searches  the  subject  for that character, and fails immediately if it
+        searches the subject for that character, and fails  immediately  if  it
-        cannot find it, without actually running the  main  matching  function.
+        cannot  find  it,  without actually running the main matching function.
         This means that a special item such as (*COMMIT) at the start of a pat-
-        tern is not considered until after a suitable starting  point  for  the
+        tern  is  not  considered until after a suitable starting point for the
-        match  has been found. When callouts or (*MARK) items are in use, these
+        match has been found. When callouts or (*MARK) items are in use,  these
         "start-up" optimizations can cause them to be skipped if the pattern is
-        never  actually  used.  The start-up optimizations are in effect a pre-
+        never actually used. The start-up optimizations are in  effect  a  pre-
         scan of the subject that takes place before the pattern is run.
-        The PCRE_NO_START_OPTIMIZE option disables the start-up  optimizations,
+        The  PCRE_NO_START_OPTIMIZE option disables the start-up optimizations,
-        possibly  causing  performance  to  suffer,  but ensuring that in cases
+        possibly causing performance to suffer,  but  ensuring  that  in  cases
-        where the result is "no match", the callouts do occur, and  that  items
+        where  the  result is "no match", the callouts do occur, and that items
         such as (*COMMIT) and (*MARK) are considered at every possible starting
-        position in the subject string. If  PCRE_NO_START_OPTIMIZE  is  set  at
+        position  in  the  subject  string. If PCRE_NO_START_OPTIMIZE is set at
-        compile  time,  it  cannot  be  unset  at  matching  time.  The  use of
+        compile time,  it  cannot  be  unset  at  matching  time.  The  use  of
         PCRE_NO_START_OPTIMIZE disables JIT execution; when it is set, matching
         is always done using interpretively.
-        Setting  PCRE_NO_START_OPTIMIZE  can  change  the outcome of a matching
+        Setting PCRE_NO_START_OPTIMIZE can change the  outcome  of  a  matching
         operation.  Consider the pattern
           (*COMMIT)ABC
-        When this is compiled, PCRE records the fact that a  match  must  start
+        When  this  is  compiled, PCRE records the fact that a match must start
-        with  the  character  "A".  Suppose the subject string is "DEFABC". The
+        with the character "A". Suppose the subject  string  is  "DEFABC".  The
-        start-up optimization scans along the subject, finds "A" and  runs  the
+        start-up  optimization  scans along the subject, finds "A" and runs the
-        first  match attempt from there. The (*COMMIT) item means that the pat-
+        first match attempt from there. The (*COMMIT) item means that the  pat-
-        tern must match the current starting position, which in this  case,  it
+        tern  must  match the current starting position, which in this case, it
-        does.  However,  if  the  same match is run with PCRE_NO_START_OPTIMIZE
+        does. However, if the same match  is  run  with  PCRE_NO_START_OPTIMIZE
-        set, the initial scan along the subject string  does  not  happen.  The
+        set,  the  initial  scan  along the subject string does not happen. The
-        first  match  attempt  is  run  starting  from "D" and when this fails,
+        first match attempt is run starting  from  "D"  and  when  this  fails,
-        (*COMMIT) prevents any further matches  being  tried,  so  the  overall
+        (*COMMIT)  prevents  any  further  matches  being tried, so the overall
-        result  is  "no  match". If the pattern is studied, more start-up opti-
+        result is "no match". If the pattern is studied,  more  start-up  opti-
-        mizations may be used. For example, a minimum length  for  the  subject
+        mizations  may  be  used. For example, a minimum length for the subject
         may be recorded. Consider the pattern
           (*MARK:A)(X|Y)
-        The  minimum  length  for  a  match is one character. If the subject is
+        The minimum length for a match is one  character.  If  the  subject  is
-        "ABC", there will be attempts to  match  "ABC",  "BC",  "C",  and  then
+        "ABC",  there  will  be  attempts  to  match "ABC", "BC", "C", and then
-        finally  an empty string.  If the pattern is studied, the final attempt
+        finally an empty string.  If the pattern is studied, the final  attempt
-        does not take place, because PCRE knows that the subject is too  short,
+        does  not take place, because PCRE knows that the subject is too short,
-        and  so  the  (*MARK) is never encountered.  In this case, studying the
+        and so the (*MARK) is never encountered.  In this  case,  studying  the
-        pattern does not affect the overall match result, which  is  still  "no
+        pattern  does  not  affect the overall match result, which is still "no
         match", but it does affect the auxiliary information that is returned.
           PCRE_NO_UTF8_CHECK
         When PCRE_UTF8 is set at compile time, the validity of the subject as a
-        UTF-8 string is automatically checked when pcre_exec() is  subsequently
+        UTF-8  string is automatically checked when pcre_exec() is subsequently
         called.  The entire string is checked before any other processing takes
-        place. The value of startoffset is  also  checked  to  ensure  that  it
+        place.  The  value  of  startoffset  is  also checked to ensure that it
-        points  to  the start of a UTF-8 character. There is a discussion about
+        points to the start of a UTF-8 character. There is a  discussion  about
-        the validity of UTF-8 strings in the pcreunicode page.  If  an  invalid
+        the  validity  of  UTF-8 strings in the pcreunicode page. If an invalid
-        sequence   of   bytes   is   found,   pcre_exec()   returns  the  error
+        sequence  of  bytes   is   found,   pcre_exec()   returns   the   error
         PCRE_ERROR_BADUTF8 or, if PCRE_PARTIAL_HARD is set and the problem is a
         truncated character at the end of the subject, PCRE_ERROR_SHORTUTF8. In
-        both cases, information about the precise nature of the error may  also
+        both  cases, information about the precise nature of the error may also
-        be  returned (see the descriptions of these errors in the section enti-
+        be returned (see the descriptions of these errors in the section  enti-
-        tled Error return values from pcre_exec() below).  If startoffset  con-
+        tled  Error return values from pcre_exec() below).  If startoffset con-
         tains a value that does not point to the start of a UTF-8 character (or
         to the end of the subject), PCRE_ERROR_BADUTF8_OFFSET is returned.
-        If you already know that your subject is valid, and you  want  to  skip
+        If  you  already  know that your subject is valid, and you want to skip
-        these    checks    for   performance   reasons,   you   can   set   the
+        these   checks   for   performance   reasons,   you   can    set    the
-        PCRE_NO_UTF8_CHECK option when calling pcre_exec(). You might  want  to
+        PCRE_NO_UTF8_CHECK  option  when calling pcre_exec(). You might want to
-        do  this  for the second and subsequent calls to pcre_exec() if you are
+        do this for the second and subsequent calls to pcre_exec() if  you  are
-        making repeated calls to find all  the  matches  in  a  single  subject
+        making  repeated  calls  to  find  all  the matches in a single subject
-        string.  However,  you  should  be  sure  that the value of startoffset
+        string. However, you should be  sure  that  the  value  of  startoffset
-        points to the start of a character (or the end of  the  subject).  When
+        points  to  the  start of a character (or the end of the subject). When
         PCRE_NO_UTF8_CHECK is set, the effect of passing an invalid string as a
-        subject or an invalid value of startoffset is undefined.  Your  program
+        subject  or  an invalid value of startoffset is undefined. Your program
         may crash.
           PCRE_PARTIAL_HARD
           PCRE_PARTIAL_SOFT
-        These  options turn on the partial matching feature. For backwards com-
+        These options turn on the partial matching feature. For backwards  com-
-        patibility, PCRE_PARTIAL is a synonym for PCRE_PARTIAL_SOFT. A  partial
+        patibility,  PCRE_PARTIAL is a synonym for PCRE_PARTIAL_SOFT. A partial
-        match  occurs if the end of the subject string is reached successfully,
+        match occurs if the end of the subject string is reached  successfully,
-        but there are not enough subject characters to complete the  match.  If
+        but  there  are not enough subject characters to complete the match. If
         this happens when PCRE_PARTIAL_SOFT (but not PCRE_PARTIAL_HARD) is set,
-        matching continues by testing any remaining alternatives.  Only  if  no
+        matching  continues  by  testing any remaining alternatives. Only if no
-        complete  match  can be found is PCRE_ERROR_PARTIAL returned instead of
+        complete match can be found is PCRE_ERROR_PARTIAL returned  instead  of
-        PCRE_ERROR_NOMATCH. In other words,  PCRE_PARTIAL_SOFT  says  that  the
+        PCRE_ERROR_NOMATCH.  In  other  words,  PCRE_PARTIAL_SOFT says that the
-        caller  is  prepared to handle a partial match, but only if no complete
+        caller is prepared to handle a partial match, but only if  no  complete
         match can be found.
-        If PCRE_PARTIAL_HARD is set, it overrides  PCRE_PARTIAL_SOFT.  In  this
+        If  PCRE_PARTIAL_HARD  is  set, it overrides PCRE_PARTIAL_SOFT. In this
-        case,  if  a  partial  match  is found, pcre_exec() immediately returns
+        case, if a partial match  is  found,  pcre_exec()  immediately  returns
-        PCRE_ERROR_PARTIAL, without  considering  any  other  alternatives.  In
+        PCRE_ERROR_PARTIAL,  without  considering  any  other  alternatives. In
-        other  words, when PCRE_PARTIAL_HARD is set, a partial match is consid-
+        other words, when PCRE_PARTIAL_HARD is set, a partial match is  consid-
         ered to be more important that an alternative complete match.
-        In both cases, the portion of the string that was  inspected  when  the
+        In  both  cases,  the portion of the string that was inspected when the
         partial match was found is set as the first matching string. There is a
-        more detailed discussion of partial and  multi-segment  matching,  with
+        more  detailed  discussion  of partial and multi-segment matching, with
         examples, in the pcrepartial documentation.
     The string to be matched by pcre_exec()
-        The  subject string is passed to pcre_exec() as a pointer in subject, a
+        The subject string is passed to pcre_exec() as a pointer in subject,  a
-        length in bytes in length, and a starting byte offset  in  startoffset.
+        length  in  bytes in length, and a starting byte offset in startoffset.
-        If  this  is  negative  or  greater  than  the  length  of the subject,
+        If this is  negative  or  greater  than  the  length  of  the  subject,
-        pcre_exec() returns PCRE_ERROR_BADOFFSET. When the starting  offset  is
+        pcre_exec()  returns  PCRE_ERROR_BADOFFSET. When the starting offset is
-        zero,  the  search  for a match starts at the beginning of the subject,
+        zero, the search for a match starts at the beginning  of  the  subject,
         and this is by far the most common case. In UTF-8 mode, the byte offset
-        must  point  to  the start of a UTF-8 character (or the end of the sub-
+        must point to the start of a UTF-8 character (or the end  of  the  sub-
-        ject). Unlike the pattern string, the subject may contain  binary  zero
+        ject).  Unlike  the pattern string, the subject may contain binary zero
         bytes.
-        A  non-zero  starting offset is useful when searching for another match
+        A non-zero starting offset is useful when searching for  another  match
-        in the same subject by calling pcre_exec() again after a previous  suc-
+        in  the same subject by calling pcre_exec() again after a previous suc-
-        cess.   Setting  startoffset differs from just passing over a shortened
+        cess.  Setting startoffset differs from just passing over  a  shortened
-        string and setting PCRE_NOTBOL in the case of  a  pattern  that  begins
+        string  and  setting  PCRE_NOTBOL  in the case of a pattern that begins
         with any kind of lookbehind. For example, consider the pattern
           \Biss\B
-        which  finds  occurrences  of "iss" in the middle of words. (\B matches
+        which finds occurrences of "iss" in the middle of  words.  (\B  matches
-        only if the current position in the subject is not  a  word  boundary.)
+        only  if  the  current position in the subject is not a word boundary.)
-        When  applied  to the string "Mississipi" the first call to pcre_exec()
+        When applied to the string "Mississipi" the first call  to  pcre_exec()
-        finds the first occurrence. If pcre_exec() is called  again  with  just
+        finds  the  first  occurrence. If pcre_exec() is called again with just
-        the  remainder  of  the  subject,  namely  "issipi", it does not match,
+        the remainder of the subject,  namely  "issipi",  it  does  not  match,
         because \B is always false at the start of the subject, which is deemed
-        to  be  a  word  boundary. However, if pcre_exec() is passed the entire
+        to be a word boundary. However, if pcre_exec()  is  passed  the  entire
         string again, but with startoffset set to 4, it finds the second occur-
-        rence  of "iss" because it is able to look behind the starting point to
+        rence of "iss" because it is able to look behind the starting point  to
         discover that it is preceded by a letter.
-        Finding all the matches in a subject is tricky  when  the  pattern  can
+        Finding  all  the  matches  in a subject is tricky when the pattern can
         match an empty string. It is possible to emulate Perl's /g behaviour by
-        first  trying  the  match  again  at  the   same   offset,   with   the
+        first   trying   the   match   again  at  the  same  offset,  with  the
-        PCRE_NOTEMPTY_ATSTART  and  PCRE_ANCHORED  options,  and  then  if that
+        PCRE_NOTEMPTY_ATSTART and  PCRE_ANCHORED  options,  and  then  if  that
-        fails, advancing the starting  offset  and  trying  an  ordinary  match
+        fails,  advancing  the  starting  offset  and  trying an ordinary match
         again. There is some code that demonstrates how to do this in the pcre-
         demo sample program. In the most general case, you have to check to see
-        if  the newline convention recognizes CRLF as a newline, and if so, and
+        if the newline convention recognizes CRLF as a newline, and if so,  and
         the current character is CR followed by LF, advance the starting offset
         by two characters instead of one.
-        If  a  non-zero starting offset is passed when the pattern is anchored,
+        If a non-zero starting offset is passed when the pattern  is  anchored,
         one attempt to match at the given offset is made. This can only succeed
-        if  the  pattern  does  not require the match to be at the start of the
+        if the pattern does not require the match to be at  the  start  of  the
         subject.
     How pcre_exec() returns captured substrings
-        In general, a pattern matches a certain portion of the subject, and  in
+        In  general, a pattern matches a certain portion of the subject, and in
-        addition,  further  substrings  from  the  subject may be picked out by
+        addition, further substrings from the subject  may  be  picked  out  by
-        parts of the pattern. Following the usage  in  Jeffrey  Friedl's  book,
+        parts  of  the  pattern.  Following the usage in Jeffrey Friedl's book,
-        this  is  called "capturing" in what follows, and the phrase "capturing
+        this is called "capturing" in what follows, and the  phrase  "capturing
-        subpattern" is used for a fragment of a pattern that picks out  a  sub-
+        subpattern"  is  used for a fragment of a pattern that picks out a sub-
-        string.  PCRE  supports several other kinds of parenthesized subpattern
+        string. PCRE supports several other kinds of  parenthesized  subpattern
         that do not cause substrings to be captured.
         Captured substrings are returned to the caller via a vector of integers
-        whose  address is passed in ovector. The number of elements in the vec-
+        whose address is passed in ovector. The number of elements in the  vec-
-        tor is passed in ovecsize, which must be a non-negative  number.  Note:
+        tor  is  passed in ovecsize, which must be a non-negative number. Note:
         this argument is NOT the size of ovector in bytes.
-        The  first  two-thirds of the vector is used to pass back captured sub-
+        The first two-thirds of the vector is used to pass back  captured  sub-
-        strings, each substring using a pair of integers. The  remaining  third
+        strings,  each  substring using a pair of integers. The remaining third
-        of  the  vector is used as workspace by pcre_exec() while matching cap-
+        of the vector is used as workspace by pcre_exec() while  matching  cap-
-        turing subpatterns, and is not available for passing back  information.
+        turing  subpatterns, and is not available for passing back information.
-        The  number passed in ovecsize should always be a multiple of three. If
+        The number passed in ovecsize should always be a multiple of three.  If
         it is not, it is rounded down.
-        When a match is successful, information about  captured  substrings  is
+        When  a  match  is successful, information about captured substrings is
-        returned  in  pairs  of integers, starting at the beginning of ovector,
+        returned in pairs of integers, starting at the  beginning  of  ovector,
-        and continuing up to two-thirds of its length at the  most.  The  first
+        and  continuing  up  to two-thirds of its length at the most. The first
-        element  of  each pair is set to the byte offset of the first character
+        element of each pair is set to the byte offset of the  first  character
-        in a substring, and the second is set to the byte offset of  the  first
+        in  a  substring, and the second is set to the byte offset of the first
-        character  after  the end of a substring. Note: these values are always
+        character after the end of a substring. Note: these values  are  always
         byte offsets, even in UTF-8 mode. They are not character counts.
-        The first pair of integers, ovector[0]  and  ovector[1],  identify  the
+        The  first  pair  of  integers, ovector[0] and ovector[1], identify the
-        portion  of  the subject string matched by the entire pattern. The next
+        portion of the subject string matched by the entire pattern.  The  next
-        pair is used for the first capturing subpattern, and so on.  The  value
+        pair  is  used for the first capturing subpattern, and so on. The value
         returned by pcre_exec() is one more than the highest numbered pair that
-        has been set.  For example, if two substrings have been  captured,  the
+        has  been  set.  For example, if two substrings have been captured, the
-        returned  value is 3. If there are no capturing subpatterns, the return
+        returned value is 3. If there are no capturing subpatterns, the  return
         value from a successful match is 1, indicating that just the first pair
         of offsets has been set.
         If a capturing subpattern is matched repeatedly, it is the last portion
         of the string that it matched that is returned.
-        If the vector is too small to hold all the captured substring  offsets,
+        If  the vector is too small to hold all the captured substring offsets,
         it is used as far as possible (up to two-thirds of its length), and the
-        function returns a value of zero. If neither the actual string  matched
+        function  returns a value of zero. If neither the actual string matched
-        nor  any captured substrings are of interest, pcre_exec() may be called
+        nor any captured substrings are of interest, pcre_exec() may be  called
-        with ovector passed as NULL and ovecsize as zero. However, if the  pat-
+        with  ovector passed as NULL and ovecsize as zero. However, if the pat-
-        tern  contains  back  references  and  the ovector is not big enough to
+        tern contains back references and the ovector  is  not  big  enough  to
-        remember the related substrings, PCRE has to get additional memory  for
+        remember  the related substrings, PCRE has to get additional memory for
-        use  during matching. Thus it is usually advisable to supply an ovector
+        use during matching. Thus it is usually advisable to supply an  ovector
         of reasonable size.
-        There are some cases where zero is returned  (indicating  vector  over-
+        There  are  some  cases where zero is returned (indicating vector over-
-        flow)  when  in fact the vector is exactly the right size for the final
+        flow) when in fact the vector is exactly the right size for  the  final
         match. For example, consider the pattern
           (a)(?:(b)c|bd)
-        If a vector of 6 elements (allowing for only 1 captured  substring)  is
+        If  a  vector of 6 elements (allowing for only 1 captured substring) is
         given with subject string "abd", pcre_exec() will try to set the second
         captured string, thereby recording a vector overflow, before failing to
-        match  "c"  and  backing  up  to  try  the second alternative. The zero
+        match "c" and backing up  to  try  the  second  alternative.  The  zero
-        return, however, does correctly indicate that  the  maximum  number  of
+        return,  however,  does  correctly  indicate that the maximum number of
         slots (namely 2) have been filled. In similar cases where there is tem-
-        porary overflow, but the final number of used slots  is  actually  less
+        porary  overflow,  but  the final number of used slots is actually less
         than the maximum, a non-zero value is returned.
         The pcre_fullinfo() function can be used to find out how many capturing
-        subpatterns there are in a compiled  pattern.  The  smallest  size  for
+        subpatterns  there  are  in  a  compiled pattern. The smallest size for
-        ovector  that  will allow for n captured substrings, in addition to the
+        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.
-        It is possible for capturing subpattern number n+1 to match  some  part
+        It  is  possible for capturing subpattern number n+1 to match some part
         of the subject when subpattern n has not been used at all. For example,
-        if the string "abc" is matched  against  the  pattern  (a|(z))(bc)  the
+        if  the  string  "abc"  is  matched against the pattern (a|(z))(bc) the
         return from the function is 4, and subpatterns 1 and 3 are matched, but
-is not. When this happens, both values in  the  offset  pairs  corre-
+ is  not.  When  this happens, both values in the offset pairs corre-
         sponding to unused subpatterns are set to -1.
-        Offset  values  that correspond to unused subpatterns at the end of the
+        Offset values that correspond to unused subpatterns at the end  of  the
-        expression are also set to -1. For example,  if  the  string  "abc"  is
+        expression  are  also  set  to  -1. For example, if the string "abc" is
-        matched  against the pattern (abc)(x(yz)?)? subpatterns 2 and 3 are not
+        matched against the pattern (abc)(x(yz)?)? subpatterns 2 and 3 are  not
-        matched. The return from the function is 2, because  the  highest  used
+        matched.  The  return  from the function is 2, because the highest used
-        capturing  subpattern  number  is 1, and the offsets for for the second
+        capturing subpattern number is 1, and the offsets for  for  the  second
-        and third capturing subpatterns (assuming the vector is  large  enough,
+        and  third  capturing subpatterns (assuming the vector is large enough,
         of course) are set to -1.
-        Note:  Elements  in  the first two-thirds of ovector that do not corre-
+        Note: Elements in the first two-thirds of ovector that  do  not  corre-
-        spond to capturing parentheses in the pattern are never  changed.  That
+        spond  to  capturing parentheses in the pattern are never changed. That
-        is,  if  a pattern contains n capturing parentheses, no more than ovec-
+        is, if a pattern contains n capturing parentheses, no more  than  ovec-
-        tor[0] to ovector[2n+1] are set by pcre_exec(). The other elements  (in
+        tor[0]  to ovector[2n+1] are set by pcre_exec(). The other elements (in
         the first two-thirds) retain whatever values they previously had.
-        Some  convenience  functions  are  provided for extracting the captured
+        Some convenience functions are provided  for  extracting  the  captured
         substrings as separate strings. These are described below.
     Error return values from pcre_exec()
-        If pcre_exec() fails, it returns a negative number. The  following  are
+        If  pcre_exec()  fails, it returns a negative number. The following are
         defined in the header file:
           PCRE_ERROR_NOMATCH        (-1)
-Line 3447 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 3448 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_ERROR_NULL           (-2)
-        Either  code  or  subject  was  passed as NULL, or ovector was NULL and
+        Either code or subject was passed as NULL,  or  ovector  was  NULL  and
         ovecsize was not zero.
           PCRE_ERROR_BADOPTION      (-3)
-Line 3456 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 3457 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_ERROR_BADMAGIC       (-4)
-        PCRE stores a 4-byte "magic number" at the start of the compiled  code,
+        PCRE  stores a 4-byte "magic number" at the start of the compiled code,
         to catch the case when it is passed a junk pointer and to detect when a
         pattern that was compiled in an environment of one endianness is run in
-        an  environment  with the other endianness. This is the error that PCRE
+        an environment with the other endianness. This is the error  that  PCRE
         gives when the magic number is not present.
           PCRE_ERROR_UNKNOWN_OPCODE (-5)
         While running the pattern match, an unknown item was encountered in the
-        compiled  pattern.  This  error  could be caused by a bug in PCRE or by
+        compiled pattern. This error could be caused by a bug  in  PCRE  or  by
         overwriting of the compiled pattern.
           PCRE_ERROR_NOMEMORY       (-6)
-        If a pattern contains back references, but the ovector that  is  passed
+        If  a  pattern contains back references, but the ovector that is passed
         to pcre_exec() is not big enough to remember the referenced substrings,
-        PCRE gets a block of memory at the start of matching to  use  for  this
+        PCRE  gets  a  block of memory at the start of matching to use for this
-        purpose.  If the call via pcre_malloc() fails, this error is given. The
+        purpose. If the call via pcre_malloc() fails, this error is given.  The
         memory is automatically freed at the end of matching.
-        This error is also given if pcre_stack_malloc() fails  in  pcre_exec().
+        This  error  is also given if pcre_stack_malloc() fails in pcre_exec().
-        This  can happen only when PCRE has been compiled with --disable-stack-
+        This can happen only when PCRE has been compiled with  --disable-stack-
         for-recursion.
           PCRE_ERROR_NOSUBSTRING    (-7)
-        This error is used by the pcre_copy_substring(),  pcre_get_substring(),
+        This  error is used by the pcre_copy_substring(), pcre_get_substring(),
         and  pcre_get_substring_list()  functions  (see  below).  It  is  never
         returned by pcre_exec().
           PCRE_ERROR_MATCHLIMIT     (-8)
-        The backtracking limit, as specified by  the  match_limit  field  in  a
+        The  backtracking  limit,  as  specified  by the match_limit field in a
-        pcre_extra  structure  (or  defaulted) was reached. See the description
+        pcre_extra structure (or defaulted) was reached.  See  the  description
         above.
           PCRE_ERROR_CALLOUT        (-9)
         This error is never generated by pcre_exec() itself. It is provided for
-        use  by  callout functions that want to yield a distinctive error code.
+        use by callout functions that want to yield a distinctive  error  code.
         See the pcrecallout documentation for details.
           PCRE_ERROR_BADUTF8        (-10)
-        A string that contains an invalid UTF-8 byte sequence was passed  as  a
+        A  string  that contains an invalid UTF-8 byte sequence was passed as a
-        subject,  and the PCRE_NO_UTF8_CHECK option was not set. If the size of
+        subject, and the PCRE_NO_UTF8_CHECK option was not set. If the size  of
-        the output vector (ovecsize) is at least 2,  the  byte  offset  to  the
+        the  output  vector  (ovecsize)  is  at least 2, the byte offset to the
-        start  of  the  the invalid UTF-8 character is placed in the first ele-
+        start of the the invalid UTF-8 character is placed in  the  first  ele-
-        ment, and a reason code is placed in the  second  element.  The  reason
+        ment,  and  a  reason  code is placed in the second element. The reason
         codes are listed in the following section.  For backward compatibility,
-        if PCRE_PARTIAL_HARD is set and the problem is a truncated UTF-8  char-
+        if  PCRE_PARTIAL_HARD is set and the problem is a truncated UTF-8 char-
-        acter   at   the   end   of   the   subject  (reason  codes  1  to  5),
+        acter  at  the  end  of  the   subject   (reason   codes   1   to   5),
         PCRE_ERROR_SHORTUTF8 is returned instead of PCRE_ERROR_BADUTF8.
           PCRE_ERROR_BADUTF8_OFFSET (-11)
-        The UTF-8 byte sequence that was passed as a subject  was  checked  and
+        The  UTF-8  byte  sequence that was passed as a subject was checked and
-        found  to be valid (the PCRE_NO_UTF8_CHECK option was not set), but the
+        found to be valid (the PCRE_NO_UTF8_CHECK option was not set), but  the
-        value of startoffset did not point to the beginning of a UTF-8  charac-
+        value  of startoffset did not point to the beginning of a UTF-8 charac-
         ter or the end of the subject.
           PCRE_ERROR_PARTIAL        (-12)
-        The  subject  string did not match, but it did match partially. See the
+        The subject string did not match, but it did match partially.  See  the
         pcrepartial documentation for details of partial matching.
           PCRE_ERROR_BADPARTIAL     (-13)
-        This code is no longer in  use.  It  was  formerly  returned  when  the
+        This  code  is  no  longer  in  use.  It was formerly returned when the
-        PCRE_PARTIAL  option  was used with a compiled pattern containing items
+        PCRE_PARTIAL option was used with a compiled pattern  containing  items
-        that were  not  supported  for  partial  matching.  From  release  8.00
+        that  were  not  supported  for  partial  matching.  From  release 8.00
         onwards, there are no restrictions on partial matching.
           PCRE_ERROR_INTERNAL       (-14)
-        An  unexpected  internal error has occurred. This error could be caused
+        An unexpected internal error has occurred. This error could  be  caused
         by a bug in PCRE or by overwriting of the compiled pattern.
           PCRE_ERROR_BADCOUNT       (-15)
-Line 3541 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 3542 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_ERROR_RECURSIONLIMIT (-21)
         The internal recursion limit, as specified by the match_limit_recursion
-        field  in  a  pcre_extra  structure (or defaulted) was reached. See the
+        field in a pcre_extra structure (or defaulted)  was  reached.  See  the
         description above.
           PCRE_ERROR_BADNEWLINE     (-23)
-Line 3555 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 3556 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_ERROR_SHORTUTF8      (-25)
-        This  error  is returned instead of PCRE_ERROR_BADUTF8 when the subject
+        This error is returned instead of PCRE_ERROR_BADUTF8 when  the  subject
-        string ends with a truncated UTF-8 character and the  PCRE_PARTIAL_HARD
+        string  ends with a truncated UTF-8 character and the PCRE_PARTIAL_HARD
-        option  is  set.   Information  about  the  failure  is returned as for
+        option is set.  Information  about  the  failure  is  returned  as  for
-        PCRE_ERROR_BADUTF8. It is in fact sufficient to detect this  case,  but
+        PCRE_ERROR_BADUTF8.  It  is in fact sufficient to detect this case, but
-        this  special error code for PCRE_PARTIAL_HARD precedes the implementa-
+        this special error code for PCRE_PARTIAL_HARD precedes the  implementa-
-        tion of returned information; it is retained for backwards  compatibil-
+        tion  of returned information; it is retained for backwards compatibil-
         ity.
           PCRE_ERROR_RECURSELOOP    (-26)
         This error is returned when pcre_exec() detects a recursion loop within
-        the pattern. Specifically, it means that either the whole pattern or  a
+        the  pattern. Specifically, it means that either the whole pattern or a
-        subpattern  has been called recursively for the second time at the same
+        subpattern has been called recursively for the second time at the  same
         position in the subject string. Some simple patterns that might do this
-        are  detected  and faulted at compile time, but more complicated cases,
+        are detected and faulted at compile time, but more  complicated  cases,
         in particular mutual recursions between two different subpatterns, can-
         not be detected until run time.
           PCRE_ERROR_JIT_STACKLIMIT (-27)
-        This  error  is  returned  when a pattern that was successfully studied
+        This error is returned when a pattern  that  was  successfully  studied
-        using a JIT compile option is being matched, but the  memory  available
+        using  a  JIT compile option is being matched, but the memory available
-        for  the  just-in-time  processing  stack  is not large enough. See the
+        for the just-in-time processing stack is  not  large  enough.  See  the
         pcrejit documentation for more details.
           PCRE_ERROR_BADMODE        (-28)
-Line 3587 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 3588 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_ERROR_BADENDIANNESS  (-29)
-        This  error  is  given  if  a  pattern  that  was compiled and saved is
+        This error is given if  a  pattern  that  was  compiled  and  saved  is
-        reloaded on a host with  different  endianness.  The  utility  function
+        reloaded  on  a  host  with  different endianness. The utility function
         pcre_pattern_to_host_byte_order() can be used to convert such a pattern
         so that it runs on the new host.
           PCRE_ERROR_JIT_BADOPTION
-        This error is returned when a pattern  that  was  successfully  studied
+        This  error  is  returned  when a pattern that was successfully studied
-        using  a  JIT  compile  option  is being matched, but the matching mode
+        using a JIT compile option is being  matched,  but  the  matching  mode
-        (partial or complete match) does not correspond to any JIT  compilation
+        (partial  or complete match) does not correspond to any JIT compilation
-        mode.  When  the JIT fast path function is used, this error may be also
+        mode. When the JIT fast path function is used, this error may  be  also
-        given for invalid options.  See  the  pcrejit  documentation  for  more
+        given  for  invalid  options.  See  the  pcrejit documentation for more
         details.
           PCRE_ERROR_BADLENGTH      (-32)
-        This  error is given if pcre_exec() is called with a negative value for
+        This error is given if pcre_exec() is called with a negative value  for
         the length argument.
         Error numbers -16 to -20, -22, and 30 are not used by pcre_exec().
     Reason codes for invalid UTF-8 strings
-        This section applies only  to  the  8-bit  library.  The  corresponding
+        This  section  applies  only  to  the  8-bit library. The corresponding
-        information  for  the  16-bit  library is given in the pcre16 page. The
+        information for the 16-bit and 32-bit libraries is given in the  pcre16
-        corresponding information for the 32-bit library is given in the pcre32
+        and pcre32 pages.
-        page.
         When pcre_exec() returns either PCRE_ERROR_BADUTF8 or PCRE_ERROR_SHORT-
         UTF8, and the size of the output vector (ovecsize) is at least  2,  the
 Line 4101 
 AUTHOR
  REVISION
-        Last updated: 31 October 2012
+        Last updated: 08 November 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECALLOUT(3)                                                  PCRECALLOUT(3)
 Line 4313 
 REVISION
         Last updated: 24 June 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECOMPAT(3)                                                    PCRECOMPAT(3)
 Line 4491 
 REVISION
         Last updated: 25 August 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPATTERN(3)                                                  PCREPATTERN(3)
 Line 4520 
 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 strings in the original
         library, an extra library that supports  16-bit  and  UTF-16  character
-        strings, and an extra library that supports 32-bit and UTF-32 character
+        strings,  and a third library that supports 32-bit and UTF-32 character
         strings. To use these features, PCRE must be built to include appropri-
         ate  support. When using UTF strings you must either call the compiling
-        function with the PCRE_UTF8, PCRE_UTF16 or PCRE_UTF32  option,  or  the
+        function with the PCRE_UTF8, PCRE_UTF16, or PCRE_UTF32 option,  or  the
         pattern must start with one of these special sequences:
           (*UTF8)
           (*UTF16)
           (*UTF32)
+          (*UTF)
-        Starting  a  pattern  with such a sequence is equivalent to setting the
+        (*UTF)  is  a  generic  sequence  that  can  be  used  with  any of the
-        relevant option. This feature is not Perl-compatible. How setting a UTF
+        libraries.  Starting a pattern with such a sequence  is  equivalent  to
-        mode  affects  pattern  matching  is mentioned in several places below.
+        setting  the  relevant option. This feature is not Perl-compatible. How
-        There is also a summary of features in the pcreunicode page.
+        setting a UTF mode affects pattern matching  is  mentioned  in  several
+        places  below.  There  is also a summary of features in the pcreunicode
+        page.
         Another special sequence that may appear at the start of a  pattern  or
-        in combination with (*UTF8) or (*UTF16) or (*UTF32) is:
+        in combination with (*UTF8), (*UTF16), (*UTF32) or (*UTF) is:
           (*UCP)
-Line 4600 
 NEWLINE CONVENTIONS
+Line 4603 
 NEWLINE CONVENTIONS
         and that they must be in upper case.  If  more  than  one  of  them  is
         present, the last one is used.
-        The  newline convention affects the interpretation of the dot metachar-
+        The  newline  convention affects where the circumflex and dollar asser-
-        acter when PCRE_DOTALL is not set, and also the behaviour of  \N.  How-
+        tions are true. It also affects the interpretation of the dot metachar-
-        ever,  it  does  not  affect  what  the  \R escape sequence matches. By
+        acter when PCRE_DOTALL is not set, and the behaviour of \N. However, it
-        default, this is any Unicode newline sequence, for Perl  compatibility.
+        does not affect what the \R escape sequence matches. By  default,  this
-        However,  this can be changed; see the description of \R in the section
+        is  any Unicode newline sequence, for Perl compatibility. However, this
-        entitled "Newline sequences" below. A change of \R setting can be  com-
+        can be changed; see the description of \R in the section entitled "New-
-        bined with a change of newline convention.
+        line  sequences"  below.  A change of \R setting can be combined with a
+        change of newline convention.
  CHARACTERS AND METACHARACTERS
-        A  regular  expression  is  a pattern that is matched against a subject
+        A regular expression is a pattern that is  matched  against  a  subject
-        string from left to right. Most characters stand for  themselves  in  a
+        string  from  left  to right. Most characters stand for themselves in a
-        pattern,  and  match  the corresponding characters in the subject. As a
+        pattern, and match the corresponding characters in the  subject.  As  a
         trivial example, the pattern
           The quick brown fox
         matches a portion of a subject string that is identical to itself. When
-        caseless  matching is specified (the PCRE_CASELESS option), letters are
+        caseless matching is specified (the PCRE_CASELESS option), letters  are
-        matched independently of case. In a UTF mode, PCRE  always  understands
+        matched  independently  of case. In a UTF mode, PCRE always understands
-        the  concept  of case for characters whose values are less than 128, so
+        the concept of case for characters whose values are less than  128,  so
-        caseless matching is always possible. For characters with  higher  val-
+        caseless  matching  is always possible. For characters with higher val-
-        ues,  the concept of case is supported if PCRE is compiled with Unicode
+        ues, the concept of case is supported if PCRE is compiled with  Unicode
-        property support, but not otherwise.   If  you  want  to  use  caseless
+        property  support,  but  not  otherwise.   If  you want to use caseless
-        matching  for  characters  128  and above, you must ensure that PCRE is
+        matching for characters 128 and above, you must  ensure  that  PCRE  is
         compiled with Unicode property support as well as with UTF support.
-        The power of regular expressions comes  from  the  ability  to  include
+        The  power  of  regular  expressions  comes from the ability to include
-        alternatives  and  repetitions in the pattern. These are encoded in the
+        alternatives and repetitions in the pattern. These are encoded  in  the
         pattern by the use of metacharacters, which do not stand for themselves
         but instead are interpreted in some special way.
-        There  are  two different sets of metacharacters: those that are recog-
+        There are two different sets of metacharacters: those that  are  recog-
-        nized anywhere in the pattern except within square brackets, and  those
+        nized  anywhere in the pattern except within square brackets, and those
-        that  are  recognized  within square brackets. Outside square brackets,
+        that are recognized within square brackets.  Outside  square  brackets,
         the metacharacters are as follows:
           \      general escape character with several uses
-Line 4654 
 CHARACTERS AND METACHARACTERS
+Line 4658 
 CHARACTERS AND METACHARACTERS
                  also "possessive quantifier"
           {      start min/max quantifier
-        Part of a pattern that is in square brackets  is  called  a  "character
+        Part  of  a  pattern  that is in square brackets is called a "character
         class". In a character class the only metacharacters are:
           \      general escape character
-Line 4671 
 BACKSLASH
+Line 4675 
 BACKSLASH
         The backslash character has several uses. Firstly, if it is followed by
         a character that is not a number or a letter, it takes away any special
-        meaning  that  character  may  have. This use of backslash as an escape
+        meaning that character may have. This use of  backslash  as  an  escape
         character applies both inside and outside character classes.
-        For example, if you want to match a * character, you write  \*  in  the
+        For  example,  if  you want to match a * character, you write \* in the
-        pattern.   This  escaping  action  applies whether or not the following
+        pattern.  This escaping action applies whether  or  not  the  following
-        character would otherwise be interpreted as a metacharacter, so  it  is
+        character  would  otherwise be interpreted as a metacharacter, so it is
-        always  safe  to  precede  a non-alphanumeric with backslash to specify
+        always safe to precede a non-alphanumeric  with  backslash  to  specify
-        that it stands for itself. In particular, if you want to match a  back-
+        that  it stands for itself. In particular, if you want to match a back-
         slash, you write \\.
-        In  a UTF mode, only ASCII numbers and letters have any special meaning
+        In a UTF mode, only ASCII numbers and letters have any special  meaning
-        after a backslash. All other characters  (in  particular,  those  whose
+        after  a  backslash.  All  other characters (in particular, those whose
         codepoints are greater than 127) are treated as literals.
-        If  a pattern is compiled with the PCRE_EXTENDED option, white space in
+        If a pattern is compiled with the PCRE_EXTENDED option, white space  in
-        the pattern (other than in a character class) and characters between  a
+        the  pattern (other than in a character class) and characters between a
         # outside a character class and the next newline are ignored. An escap-
-        ing backslash can be used to include a white space or  #  character  as
+        ing  backslash  can  be used to include a white space or # character as
         part of the pattern.
-        If  you  want  to remove the special meaning from a sequence of charac-
+        If you want to remove the special meaning from a  sequence  of  charac-
-        ters, you can do so by putting them between \Q and \E. This is  differ-
+        ters,  you can do so by putting them between \Q and \E. This is differ-
-        ent  from  Perl  in  that  $  and  @ are handled as literals in \Q...\E
+        ent from Perl in that $ and  @  are  handled  as  literals  in  \Q...\E
-        sequences in PCRE, whereas in Perl, $ and @ cause  variable  interpola-
+        sequences  in  PCRE, whereas in Perl, $ and @ cause variable interpola-
         tion. Note the following examples:
           Pattern            PCRE matches   Perl matches
-Line 4704 
 BACKSLASH
+Line 4708 
 BACKSLASH
           \Qabc\$xyz\E       abc\$xyz       abc\$xyz
           \Qabc\E\$\Qxyz\E   abc$xyz        abc$xyz
-        The  \Q...\E  sequence  is recognized both inside and outside character
+        The \Q...\E sequence is recognized both inside  and  outside  character
-        classes.  An isolated \E that is not preceded by \Q is ignored.  If  \Q
+        classes.   An  isolated \E that is not preceded by \Q is ignored. If \Q
-        is  not followed by \E later in the pattern, the literal interpretation
+        is not followed by \E later in the pattern, the literal  interpretation
-        continues to the end of the pattern (that is,  \E  is  assumed  at  the
+        continues  to  the  end  of  the pattern (that is, \E is assumed at the
-        end).  If  the  isolated \Q is inside a character class, this causes an
+        end). If the isolated \Q is inside a character class,  this  causes  an
         error, because the character class is not terminated.
     Non-printing characters
         A second use of backslash provides a way of encoding non-printing char-
-        acters  in patterns in a visible manner. There is no restriction on the
+        acters in patterns in a visible manner. There is no restriction on  the
-        appearance of non-printing characters, apart from the binary zero  that
+        appearance  of non-printing characters, apart from the binary zero that
-        terminates  a  pattern,  but  when  a pattern is being prepared by text
+        terminates a pattern, but when a pattern  is  being  prepared  by  text
-        editing, it is  often  easier  to  use  one  of  the  following  escape
+        editing,  it  is  often  easier  to  use  one  of  the following escape
         sequences than the binary character it represents:
           \a        alarm, that is, the BEL character (hex 07)
-Line 4732 
 BACKSLASH
+Line 4736 
 BACKSLASH
           \x{hhh..} character with hex code hhh.. (non-JavaScript mode)
           \uhhhh    character with hex code hhhh (JavaScript mode only)
-        The  precise effect of \cx on ASCII characters is as follows: if x is a
+        The precise effect of \cx on ASCII characters is as follows: if x is  a
-        lower case letter, it is converted to upper case. Then  bit  6  of  the
+        lower  case  letter,  it  is converted to upper case. Then bit 6 of the
         character (hex 40) is inverted. Thus \cA to \cZ become hex 01 to hex 1A
-        (A is 41, Z is 5A), but \c{ becomes hex 3B ({ is 7B), and  \c;  becomes
+        (A  is  41, Z is 5A), but \c{ becomes hex 3B ({ is 7B), and \c; becomes
-        hex  7B (; is 3B). If the data item (byte or 16-bit value) following \c
+        hex 7B (; is 3B). If the data item (byte or 16-bit value) following  \c
-        has a value greater than 127, a compile-time error occurs.  This  locks
+        has  a  value greater than 127, a compile-time error occurs. This locks
         out non-ASCII characters in all modes.
-        The  \c  facility  was designed for use with ASCII characters, but with
+        The \c facility was designed for use with ASCII  characters,  but  with
-        the extension to Unicode it is even less useful than it  once  was.  It
+        the  extension  to  Unicode it is even less useful than it once was. It
-        is,  however,  recognized  when  PCRE is compiled in EBCDIC mode, where
+        is, however, recognized when PCRE is compiled  in  EBCDIC  mode,  where
-        data items are always bytes. In this mode, all values are  valid  after
+        data  items  are always bytes. In this mode, all values are valid after
-        \c.  If  the  next character is a lower case letter, it is converted to
+        \c. If the next character is a lower case letter, it  is  converted  to
-        upper case. Then the 0xc0 bits of  the  byte  are  inverted.  Thus  \cA
+        upper  case.  Then  the  0xc0  bits  of the byte are inverted. Thus \cA
-        becomes  hex  01, as in ASCII (A is C1), but because the EBCDIC letters
+        becomes hex 01, as in ASCII (A is C1), but because the  EBCDIC  letters
-        are disjoint, \cZ becomes hex 29 (Z is E9), and other  characters  also
+        are  disjoint,  \cZ becomes hex 29 (Z is E9), and other characters also
         generate different values.
-        By  default,  after  \x,  from  zero to two hexadecimal digits are read
+        By default, after \x, from zero to  two  hexadecimal  digits  are  read
         (letters can be in upper or lower case). Any number of hexadecimal dig-
         its may appear between \x{ and }, but the character code is constrained
         as follows:
-Line 4762 
 BACKSLASH
+Line 4766 
 BACKSLASH
 -bit non-UTF mode   less than 0x80000000
 -bit UTF-32 mode    less than 0x10ffff and a valid codepoint
-        Invalid Unicode codepoints are the range  0xd800  to  0xdfff  (the  so-
+        Invalid  Unicode  codepoints  are  the  range 0xd800 to 0xdfff (the so-
         called "surrogate" codepoints), and 0xffef.
-        If  characters  other than hexadecimal digits appear between \x{ and },
+        If characters other than hexadecimal digits appear between \x{  and  },
         or if there is no terminating }, this form of escape is not recognized.
-        Instead,  the  initial  \x  will  be interpreted as a basic hexadecimal
+        Instead, the initial \x will be  interpreted  as  a  basic  hexadecimal
-        escape, with no following digits, giving a  character  whose  value  is
+        escape,  with  no  following  digits, giving a character whose value is
         zero.
-        If  the  PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \x
+        If the PCRE_JAVASCRIPT_COMPAT option is set, the interpretation  of  \x
-        is as just described only when it is followed by two  hexadecimal  dig-
+        is  as  just described only when it is followed by two hexadecimal dig-
-        its.   Otherwise,  it  matches  a  literal "x" character. In JavaScript
+        its.  Otherwise, it matches a  literal  "x"  character.  In  JavaScript
         mode, support for code points greater than 256 is provided by \u, which
-        must  be  followed  by  four hexadecimal digits; otherwise it matches a
+        must be followed by four hexadecimal digits;  otherwise  it  matches  a
-        literal "u" character.  Character codes specified by \u  in  JavaScript
+        literal  "u"  character.  Character codes specified by \u in JavaScript
-        mode  are  constrained in the same was as those specified by \x in non-
+        mode are constrained in the same was as those specified by \x  in  non-
         JavaScript mode.
         Characters whose value is less than 256 can be defined by either of the
-        two  syntaxes for \x (or by \u in JavaScript mode). There is no differ-
+        two syntaxes for \x (or by \u in JavaScript mode). There is no  differ-
         ence in the way they are handled. For example, \xdc is exactly the same
         as \x{dc} (or \u00dc in JavaScript mode).
-        After  \0  up  to two further octal digits are read. If there are fewer
+        After \0 up to two further octal digits are read. If  there  are  fewer
-        than two digits, just  those  that  are  present  are  used.  Thus  the
+        than  two  digits,  just  those  that  are  present  are used. Thus the
         sequence \0\x\07 specifies two binary zeros followed by a BEL character
-        (code value 7). Make sure you supply two digits after the initial  zero
+        (code  value 7). Make sure you supply two digits after the initial zero
         if the pattern character that follows is itself an octal digit.
         The handling of a backslash followed by a digit other than 0 is compli-
         cated.  Outside a character class, PCRE reads it and any following dig-
-        its  as  a  decimal  number. If the number is less than 10, or if there
+        its as a decimal number. If the number is less than  10,  or  if  there
         have been at least that many previous capturing left parentheses in the
-        expression,  the  entire  sequence  is  taken  as  a  back reference. A
+        expression, the entire  sequence  is  taken  as  a  back  reference.  A
-        description of how this works is given later, following the  discussion
+        description  of how this works is given later, following the discussion
         of parenthesized subpatterns.
-        Inside  a  character  class, or if the decimal number is greater than 9
+        Inside a character class, or if the decimal number is  greater  than  9
-        and there have not been that many capturing subpatterns, PCRE  re-reads
+        and  there have not been that many capturing subpatterns, PCRE re-reads
         up to three octal digits following the backslash, and uses them to gen-
         erate a data character. Any subsequent digits stand for themselves. The
-        value  of  the  character  is constrained in the same way as characters
+        value of the character is constrained in the  same  way  as  characters
         specified in hexadecimal.  For example:
           \040   is another way of writing an ASCII space
-Line 4821 
 BACKSLASH
+Line 4825 
 BACKSLASH
           \81    is either a back reference, or a binary zero
                     followed by the two characters "8" and "1"
-        Note that octal values of 100 or greater must not be  introduced  by  a
+        Note  that  octal  values of 100 or greater must not be introduced by a
         leading zero, because no more than three octal digits are ever read.
         All the sequences that define a single character value can be used both
-        inside and outside character classes. In addition, inside  a  character
+        inside  and  outside character classes. In addition, inside a character
         class, \b is interpreted as the backspace character (hex 08).
-        \N  is not allowed in a character class. \B, \R, and \X are not special
+        \N is not allowed in a character class. \B, \R, and \X are not  special
-        inside a character class. Like  other  unrecognized  escape  sequences,
+        inside  a  character  class.  Like other unrecognized escape sequences,
-        they  are  treated  as  the  literal  characters  "B",  "R", and "X" by
+        they are treated as  the  literal  characters  "B",  "R",  and  "X"  by
-        default, but cause an error if the PCRE_EXTRA option is set. Outside  a
+        default,  but cause an error if the PCRE_EXTRA option is set. Outside a
         character class, these sequences have different meanings.
     Unsupported escape sequences
-        In  Perl, the sequences \l, \L, \u, and \U are recognized by its string
+        In Perl, the sequences \l, \L, \u, and \U are recognized by its  string
-        handler and used  to  modify  the  case  of  following  characters.  By
+        handler  and  used  to  modify  the  case  of  following characters. By
-        default,  PCRE does not support these escape sequences. However, if the
+        default, PCRE does not support these escape sequences. However, if  the
-        PCRE_JAVASCRIPT_COMPAT option is set, \U matches a "U"  character,  and
+        PCRE_JAVASCRIPT_COMPAT  option  is set, \U matches a "U" character, and
         \u can be used to define a character by code point, as described in the
         previous section.
     Absolute and relative back references
-        The sequence \g followed by an unsigned or a negative  number,  option-
+        The  sequence  \g followed by an unsigned or a negative number, option-
-        ally  enclosed  in braces, is an absolute or relative back reference. A
+        ally enclosed in braces, is an absolute or relative back  reference.  A
         named back reference can be coded as \g{name}. Back references are dis-
         cussed later, following the discussion of parenthesized subpatterns.
     Absolute and relative subroutine calls
-        For  compatibility with Oniguruma, the non-Perl syntax \g followed by a
+        For compatibility with Oniguruma, the non-Perl syntax \g followed by  a
         name or a number enclosed either in angle brackets or single quotes, is
-        an  alternative  syntax for referencing a subpattern as a "subroutine".
+        an alternative syntax for referencing a subpattern as  a  "subroutine".
-        Details are discussed later.   Note  that  \g{...}  (Perl  syntax)  and
+        Details  are  discussed  later.   Note  that  \g{...} (Perl syntax) and
-        \g<...>  (Oniguruma  syntax)  are  not synonymous. The former is a back
+        \g<...> (Oniguruma syntax) are not synonymous. The  former  is  a  back
         reference; the latter is a subroutine call.
     Generic character types
-Line 4875 
 BACKSLASH
+Line 4879 
 BACKSLASH
           \W     any "non-word" character
         There is also the single sequence \N, which matches a non-newline char-
-        acter.   This  is the same as the "." metacharacter when PCRE_DOTALL is
+        acter.  This is the same as the "." metacharacter when  PCRE_DOTALL  is
-        not set. Perl also uses \N to match characters by name; PCRE  does  not
+        not  set.  Perl also uses \N to match characters by name; PCRE does not
         support this.
-        Each  pair of lower and upper case escape sequences partitions the com-
+        Each pair of lower and upper case escape sequences partitions the  com-
-        plete set of characters into two disjoint  sets.  Any  given  character
+        plete  set  of  characters  into two disjoint sets. Any given character
-        matches  one, and only one, of each pair. The sequences can appear both
+        matches one, and only one, of each pair. The sequences can appear  both
-        inside and outside character classes. They each match one character  of
+        inside  and outside character classes. They each match one character of
-        the  appropriate  type.  If the current matching point is at the end of
+        the appropriate type. If the current matching point is at  the  end  of
-        the subject string, all of them fail, because there is no character  to
+        the  subject string, all of them fail, because there is no character to
         match.
-        For  compatibility  with Perl, \s does not match the VT character (code
+        For compatibility with Perl, \s does not match the VT  character  (code
-).  This makes it different from the the POSIX "space" class. The  \s
+).   This makes it different from the the POSIX "space" class. The \s
-        characters  are  HT  (9), LF (10), FF (12), CR (13), and space (32). If
+        characters are HT (9), LF (10), FF (12), CR (13), and  space  (32).  If
         "use locale;" is included in a Perl script, \s may match the VT charac-
         ter. In PCRE, it never does.
-        A  "word"  character is an underscore or any character that is a letter
+        A "word" character is an underscore or any character that is  a  letter
-        or digit.  By default, the definition of letters  and  digits  is  con-
+        or  digit.   By  default,  the definition of letters and digits is con-
-        trolled  by PCRE's low-valued character tables, and may vary if locale-
+        trolled by PCRE's low-valued character tables, and may vary if  locale-
-        specific matching is taking place (see "Locale support" in the  pcreapi
+        specific  matching is taking place (see "Locale support" in the pcreapi
-        page).  For  example,  in  a French locale such as "fr_FR" in Unix-like
+        page). For example, in a French locale such  as  "fr_FR"  in  Unix-like
-        systems, or "french" in Windows, some character codes greater than  128
+        systems,  or "french" in Windows, some character codes greater than 128
-        are  used  for  accented letters, and these are then matched by \w. The
+        are used for accented letters, and these are then matched  by  \w.  The
         use of locales with Unicode is discouraged.
-        By default, in a UTF mode, characters  with  values  greater  than  128
+        By  default,  in  a  UTF  mode, characters with values greater than 128
-        never  match  \d,  \s,  or  \w,  and always match \D, \S, and \W. These
+        never match \d, \s, or \w, and always  match  \D,  \S,  and  \W.  These
-        sequences retain their original meanings from before  UTF  support  was
+        sequences  retain  their  original meanings from before UTF support was
-        available,  mainly for efficiency reasons. However, if PCRE is compiled
+        available, mainly for efficiency reasons. However, if PCRE is  compiled
-        with Unicode property support, and the PCRE_UCP option is set, the  be-
+        with  Unicode property support, and the PCRE_UCP option is set, the be-
-        haviour  is  changed  so  that Unicode properties are used to determine
+        haviour is changed so that Unicode properties  are  used  to  determine
         character types, as follows:
           \d  any character that \p{Nd} matches (decimal digit)
           \s  any character that \p{Z} matches, plus HT, LF, FF, CR
           \w  any character that \p{L} or \p{N} matches, plus underscore
-        The upper case escapes match the inverse sets of characters. Note  that
+        The  upper case escapes match the inverse sets of characters. Note that
-        \d  matches  only decimal digits, whereas \w matches any Unicode digit,
+        \d matches only decimal digits, whereas \w matches any  Unicode  digit,
-        as well as any Unicode letter, and underscore. Note also that  PCRE_UCP
+        as  well as any Unicode letter, and underscore. Note also that PCRE_UCP
-        affects  \b,  and  \B  because  they are defined in terms of \w and \W.
+        affects \b, and \B because they are defined in  terms  of  \w  and  \W.
         Matching these sequences is noticeably slower when PCRE_UCP is set.
-        The sequences \h, \H, \v, and \V are features that were added  to  Perl
+        The  sequences  \h, \H, \v, and \V are features that were added to Perl
-        at  release  5.10. In contrast to the other sequences, which match only
+        at release 5.10. In contrast to the other sequences, which  match  only
-        ASCII characters by default, these  always  match  certain  high-valued
+        ASCII  characters  by  default,  these always match certain high-valued
-        codepoints,  whether or not PCRE_UCP is set. The horizontal space char-
+        codepoints, whether or not PCRE_UCP is set. The horizontal space  char-
         acters are:
           U+0009     Horizontal tab (HT)
-Line 4961 
 BACKSLASH
+Line 4965 
 BACKSLASH
     Newline sequences
-        Outside  a  character class, by default, the escape sequence \R matches
+        Outside a character class, by default, the escape sequence  \R  matches
-        any Unicode newline sequence. In 8-bit non-UTF-8 mode \R is  equivalent
+        any  Unicode newline sequence. In 8-bit non-UTF-8 mode \R is equivalent
         to the following:
           (?>\r\n|\n|\x0b|\f|\r|\x85)
-        This  is  an  example  of an "atomic group", details of which are given
+        This is an example of an "atomic group", details  of  which  are  given
         below.  This particular group matches either the two-character sequence
-        CR  followed  by  LF,  or  one  of  the single characters LF (linefeed,
+        CR followed by LF, or  one  of  the  single  characters  LF  (linefeed,
-        U+000A), VT (vertical tab, U+000B), FF (form feed,  U+000C),  CR  (car-
+        U+000A),  VT  (vertical  tab, U+000B), FF (form feed, U+000C), CR (car-
-        riage  return,  U+000D),  or NEL (next line, U+0085). The two-character
+        riage return, U+000D), or NEL (next line,  U+0085).  The  two-character
         sequence is treated as a single unit that cannot be split.
-        In other modes, two additional characters whose codepoints are  greater
+        In  other modes, two additional characters whose codepoints are greater
         than 255 are added: LS (line separator, U+2028) and PS (paragraph sepa-
-        rator, U+2029).  Unicode character property support is not  needed  for
+        rator,  U+2029).   Unicode character property support is not needed for
         these characters to be recognized.
         It is possible to restrict \R to match only CR, LF, or CRLF (instead of
-        the complete set  of  Unicode  line  endings)  by  setting  the  option
+        the  complete  set  of  Unicode  line  endings)  by  setting the option
         PCRE_BSR_ANYCRLF either at compile time or when the pattern is matched.
         (BSR is an abbrevation for "backslash R".) This can be made the default
-        when  PCRE  is  built;  if this is the case, the other behaviour can be
+        when PCRE is built; if this is the case, the  other  behaviour  can  be
-        requested via the PCRE_BSR_UNICODE option.   It  is  also  possible  to
+        requested  via  the  PCRE_BSR_UNICODE  option.   It is also possible to
-        specify  these  settings  by  starting a pattern string with one of the
+        specify these settings by starting a pattern string  with  one  of  the
         following sequences:
           (*BSR_ANYCRLF)   CR, LF, or CRLF only
           (*BSR_UNICODE)   any Unicode newline sequence
         These override the default and the options given to the compiling func-
-        tion,  but  they  can  themselves  be  overridden by options given to a
+        tion, but they can themselves be  overridden  by  options  given  to  a
-        matching function. Note that these  special  settings,  which  are  not
+        matching  function.  Note  that  these  special settings, which are not
-        Perl-compatible,  are  recognized  only at the very start of a pattern,
+        Perl-compatible, are recognized only at the very start  of  a  pattern,
-        and that they must be in upper case.  If  more  than  one  of  them  is
+        and  that  they  must  be  in  upper  case. If more than one of them is
-        present,  the  last  one is used. They can be combined with a change of
+        present, the last one is used. They can be combined with  a  change  of
         newline convention; for example, a pattern can start with:
           (*ANY)(*BSR_ANYCRLF)
-        They can also be combined  with  the  (*UTF8),  (*UTF16),  (*UTF32)  or
+        They  can also be combined with the (*UTF8), (*UTF16), (*UTF32), (*UTF)
-        (*UCP) special sequences. Inside a character class, \R is treated as an
+        or (*UCP) special sequences. Inside a character class, \R is treated as
-        unrecognized escape sequence, and so matches the letter "R" by default,
+        an  unrecognized  escape  sequence,  and  so  matches the letter "R" by
-        but causes an error if PCRE_EXTRA is set.
+        default, but causes an error if PCRE_EXTRA is set.
     Unicode character properties
         When PCRE is built with Unicode character property support, three addi-
-        tional escape sequences that match characters with specific  properties
+        tional  escape sequences that match characters with specific properties
-        are  available.   When  in 8-bit non-UTF-8 mode, these sequences are of
+        are available.  When in 8-bit non-UTF-8 mode, these  sequences  are  of
-        course limited to testing characters whose  codepoints  are  less  than
+        course  limited  to  testing  characters whose codepoints are less than
 , but they do work in this mode.  The extra escape sequences are:
           \p{xx}   a character with the xx property
           \P{xx}   a character without the xx property
           \X       a Unicode extended grapheme cluster
-        The  property  names represented by xx above are limited to the Unicode
+        The property names represented by xx above are limited to  the  Unicode
         script names, the general category properties, "Any", which matches any
-        character   (including  newline),  and  some  special  PCRE  properties
+        character  (including  newline),  and  some  special  PCRE   properties
-        (described in the next section).  Other Perl properties such as  "InMu-
+        (described  in the next section).  Other Perl properties such as "InMu-
-        sicalSymbols"  are  not  currently supported by PCRE. Note that \P{Any}
+        sicalSymbols" are not currently supported by PCRE.  Note  that  \P{Any}
         does not match any characters, so always causes a match failure.
         Sets of Unicode characters are defined as belonging to certain scripts.
-        A  character from one of these sets can be matched using a script name.
+        A character from one of these sets can be matched using a script  name.
         For example:
           \p{Greek}
           \P{Han}
-        Those that are not part of an identified script are lumped together  as
+        Those  that are not part of an identified script are lumped together as
         "Common". The current list of scripts is:
-        Arabic,  Armenian,  Avestan, Balinese, Bamum, Batak, Bengali, Bopomofo,
+        Arabic, Armenian, Avestan, Balinese, Bamum, Batak,  Bengali,  Bopomofo,
-        Brahmi, Braille, Buginese, Buhid, Canadian_Aboriginal, Carian,  Chakma,
+        Brahmi,  Braille, Buginese, Buhid, Canadian_Aboriginal, Carian, Chakma,
-        Cham,  Cherokee, Common, Coptic, Cuneiform, Cypriot, Cyrillic, Deseret,
+        Cham, Cherokee, Common, Coptic, Cuneiform, Cypriot, Cyrillic,  Deseret,
-        Devanagari,  Egyptian_Hieroglyphs,  Ethiopic,   Georgian,   Glagolitic,
+        Devanagari,   Egyptian_Hieroglyphs,   Ethiopic,  Georgian,  Glagolitic,
-        Gothic,  Greek, Gujarati, Gurmukhi, Han, Hangul, Hanunoo, Hebrew, Hira-
+        Gothic, Greek, Gujarati, Gurmukhi, Han, Hangul, Hanunoo, Hebrew,  Hira-
-        gana,  Imperial_Aramaic,  Inherited,  Inscriptional_Pahlavi,   Inscrip-
+        gana,   Imperial_Aramaic,  Inherited,  Inscriptional_Pahlavi,  Inscrip-
-        tional_Parthian,   Javanese,   Kaithi,   Kannada,  Katakana,  Kayah_Li,
+        tional_Parthian,  Javanese,  Kaithi,   Kannada,   Katakana,   Kayah_Li,
-        Kharoshthi, Khmer, Lao, Latin, Lepcha, Limbu, Linear_B,  Lisu,  Lycian,
+        Kharoshthi,  Khmer,  Lao, Latin, Lepcha, Limbu, Linear_B, Lisu, Lycian,
         Lydian,    Malayalam,    Mandaic,    Meetei_Mayek,    Meroitic_Cursive,
-        Meroitic_Hieroglyphs,  Miao,  Mongolian,  Myanmar,  New_Tai_Lue,   Nko,
+        Meroitic_Hieroglyphs,   Miao,  Mongolian,  Myanmar,  New_Tai_Lue,  Nko,
-        Ogham,    Old_Italic,   Old_Persian,   Old_South_Arabian,   Old_Turkic,
+        Ogham,   Old_Italic,   Old_Persian,   Old_South_Arabian,    Old_Turkic,
-        Ol_Chiki, Oriya, Osmanya, Phags_Pa, Phoenician, Rejang, Runic,  Samari-
+        Ol_Chiki,  Oriya, Osmanya, Phags_Pa, Phoenician, Rejang, Runic, Samari-
-        tan,  Saurashtra,  Sharada,  Shavian, Sinhala, Sora_Sompeng, Sundanese,
+        tan, Saurashtra, Sharada, Shavian,  Sinhala,  Sora_Sompeng,  Sundanese,
-        Syloti_Nagri, Syriac, Tagalog, Tagbanwa,  Tai_Le,  Tai_Tham,  Tai_Viet,
+        Syloti_Nagri,  Syriac,  Tagalog,  Tagbanwa, Tai_Le, Tai_Tham, Tai_Viet,
-        Takri,  Tamil,  Telugu, Thaana, Thai, Tibetan, Tifinagh, Ugaritic, Vai,
+        Takri, Tamil, Telugu, Thaana, Thai, Tibetan, Tifinagh,  Ugaritic,  Vai,
         Yi.
         Each character has exactly one Unicode general category property, spec-
-        ified  by a two-letter abbreviation. For compatibility with Perl, nega-
+        ified by a two-letter abbreviation. For compatibility with Perl,  nega-
-        tion can be specified by including a  circumflex  between  the  opening
+        tion  can  be  specified  by including a circumflex between the opening
-        brace  and  the  property  name.  For  example,  \p{^Lu} is the same as
+        brace and the property name.  For  example,  \p{^Lu}  is  the  same  as
         \P{Lu}.
         If only one letter is specified with \p or \P, it includes all the gen-
-        eral  category properties that start with that letter. In this case, in
+        eral category properties that start with that letter. In this case,  in
-        the absence of negation, the curly brackets in the escape sequence  are
+        the  absence of negation, the curly brackets in the escape sequence are
         optional; these two examples have the same effect:
           \p{L}
-Line 5112 
 BACKSLASH
+Line 5116 
 BACKSLASH
           Zp    Paragraph separator
           Zs    Space separator
-        The  special property L& is also supported: it matches a character that
+        The special property L& is also supported: it matches a character  that
-        has the Lu, Ll, or Lt property, in other words, a letter  that  is  not
+        has  the  Lu,  Ll, or Lt property, in other words, a letter that is not
         classified as a modifier or "other".
-        The  Cs  (Surrogate)  property  applies only to characters in the range
+        The Cs (Surrogate) property applies only to  characters  in  the  range
-        U+D800 to U+DFFF. Such characters are not valid in Unicode strings  and
+        U+D800  to U+DFFF. Such characters are not valid in Unicode strings and
-        so  cannot  be  tested  by  PCRE, unless UTF validity checking has been
+        so cannot be tested by PCRE, unless  UTF  validity  checking  has  been
         turned    off    (see    the    discussion    of    PCRE_NO_UTF8_CHECK,
-        PCRE_NO_UTF16_CHECK  and PCRE_NO_UTF32_CHECK in the pcreapi page). Perl
+        PCRE_NO_UTF16_CHECK and PCRE_NO_UTF32_CHECK in the pcreapi page).  Perl
         does not support the Cs property.
-        The long synonyms for  property  names  that  Perl  supports  (such  as
+        The  long  synonyms  for  property  names  that  Perl supports (such as
-        \p{Letter})  are  not  supported by PCRE, nor is it permitted to prefix
+        \p{Letter}) are not supported by PCRE, nor is it  permitted  to  prefix
         any of these properties with "Is".
         No character that is in the Unicode table has the Cn (unassigned) prop-
         erty.  Instead, this property is assumed for any code point that is not
         in the Unicode table.
-        Specifying caseless matching does not affect  these  escape  sequences.
+        Specifying  caseless  matching  does not affect these escape sequences.
         For example, \p{Lu} always matches only upper case letters.
-        Matching  characters  by Unicode property is not fast, because PCRE has
+        Matching characters by Unicode property is not fast, because  PCRE  has
-        to do a multistage table lookup in order to find  a  character's  prop-
+        to  do  a  multistage table lookup in order to find a character's prop-
         erty. That is why the traditional escape sequences such as \d and \w do
         not use Unicode properties in PCRE by default, though you can make them
-        do  so  by  setting the PCRE_UCP option or by starting the pattern with
+        do so by setting the PCRE_UCP option or by starting  the  pattern  with
         (*UCP).
     Extended grapheme clusters
-        The \X escape matches any number of Unicode  characters  that  form  an
+        The  \X  escape  matches  any number of Unicode characters that form an
         "extended grapheme cluster", and treats the sequence as an atomic group
-        (see below).  Up to and including release 8.31, PCRE  matched  an  ear-
+        (see  below).   Up  to and including release 8.31, PCRE matched an ear-
         lier, simpler definition that was equivalent to
           (?>\PM\pM*)
-        That  is,  it matched a character without the "mark" property, followed
+        That is, it matched a character without the "mark"  property,  followed
-        by zero or more characters with the "mark"  property.  Characters  with
+        by  zero  or  more characters with the "mark" property. Characters with
-        the  "mark"  property are typically non-spacing accents that affect the
+        the "mark" property are typically non-spacing accents that  affect  the
         preceding character.
-        This simple definition was extended in Unicode to include more  compli-
+        This  simple definition was extended in Unicode to include more compli-
-        cated  kinds of composite character by giving each character a grapheme
+        cated kinds of composite character by giving each character a  grapheme
-        breaking property, and creating rules  that  use  these  properties  to
+        breaking  property,  and  creating  rules  that use these properties to
-        define  the  boundaries  of  extended grapheme clusters. In releases of
+        define the boundaries of extended grapheme  clusters.  In  releases  of
         PCRE later than 8.31, \X matches one of these clusters.
-        \X always matches at least one character. Then it  decides  whether  to
+        \X  always  matches  at least one character. Then it decides whether to
         add additional characters according to the following rules for ending a
         cluster:
 . End at the end of the subject string.
-. Do not end between CR and LF; otherwise end after any control  char-
+.  Do not end between CR and LF; otherwise end after any control char-
         acter.
-.  Do  not  break  Hangul (a Korean script) syllable sequences. Hangul
+. Do not break Hangul (a Korean  script)  syllable  sequences.  Hangul
-        characters are of five types: L, V, T, LV, and LVT. An L character  may
+        characters  are of five types: L, V, T, LV, and LVT. An L character may
-        be  followed by an L, V, LV, or LVT character; an LV or V character may
+        be followed by an L, V, LV, or LVT character; an LV or V character  may
         be followed by a V or T character; an LVT or T character may be follwed
         only by a T character.
-.  Do not end before extending characters or spacing marks. Characters
+. Do not end before extending characters or spacing marks.  Characters
-        with the "mark" property always have  the  "extend"  grapheme  breaking
+        with  the  "mark"  property  always have the "extend" grapheme breaking
         property.
 . Do not end after prepend characters.
-Line 5186 
 BACKSLASH
+Line 5190 
 BACKSLASH
     PCRE's additional properties
-        As  well  as the standard Unicode properties described above, PCRE sup-
+        As well as the standard Unicode properties described above,  PCRE  sup-
-        ports four more that make it possible  to  convert  traditional  escape
+        ports  four  more  that  make it possible to convert traditional escape
-        sequences  such as \w and \s and POSIX character classes to use Unicode
+        sequences such as \w and \s and POSIX character classes to use  Unicode
-        properties. PCRE uses these non-standard,  non-Perl  properties  inter-
+        properties.  PCRE  uses  these non-standard, non-Perl properties inter-
         nally when PCRE_UCP is set. They are:
           Xan   Any alphanumeric character
-Line 5197 
 BACKSLASH
+Line 5201 
 BACKSLASH
           Xsp   Any Perl space character
           Xwd   Any Perl "word" character
-        Xan  matches  characters that have either the L (letter) or the N (num-
+        Xan matches characters that have either the L (letter) or the  N  (num-
-        ber) property. Xps matches the characters tab, linefeed, vertical  tab,
+        ber)  property. Xps matches the characters tab, linefeed, vertical tab,
-        form  feed,  or carriage return, and any other character that has the Z
+        form feed, or carriage return, and any other character that has  the  Z
         (separator) property.  Xsp is the same as Xps, except that vertical tab
         is excluded. Xwd matches the same characters as Xan, plus underscore.
     Resetting the match start
-        The  escape sequence \K causes any previously matched characters not to
+        The escape sequence \K causes any previously matched characters not  to
         be included in the final matched sequence. For example, the pattern:
           foo\Kbar
-        matches "foobar", but reports that it has matched "bar".  This  feature
+        matches  "foobar",  but reports that it has matched "bar". This feature
-        is  similar  to  a lookbehind assertion (described below).  However, in
+        is similar to a lookbehind assertion (described  below).   However,  in
-        this case, the part of the subject before the real match does not  have
+        this  case, the part of the subject before the real match does not have
-        to  be of fixed length, as lookbehind assertions do. The use of \K does
+        to be of fixed length, as lookbehind assertions do. The use of \K  does
-        not interfere with the setting of captured  substrings.   For  example,
+        not  interfere  with  the setting of captured substrings.  For example,
         when the pattern
           (foo)\Kbar
         matches "foobar", the first substring is still set to "foo".
-        Perl  documents  that  the  use  of  \K  within assertions is "not well
+        Perl documents that the use  of  \K  within  assertions  is  "not  well
-        defined". In PCRE, \K is acted upon  when  it  occurs  inside  positive
+        defined".  In  PCRE,  \K  is  acted upon when it occurs inside positive
         assertions, but is ignored in negative assertions.
     Simple assertions
-        The  final use of backslash is for certain simple assertions. An asser-
+        The final use of backslash is for certain simple assertions. An  asser-
-        tion specifies a condition that has to be met at a particular point  in
+        tion  specifies a condition that has to be met at a particular point in
-        a  match, without consuming any characters from the subject string. The
+        a match, without consuming any characters from the subject string.  The
-        use of subpatterns for more complicated assertions is described  below.
+        use  of subpatterns for more complicated assertions is described below.
         The backslashed assertions are:
           \b     matches at a word boundary
-Line 5241 
 BACKSLASH
+Line 5245 
 BACKSLASH
           \z     matches only at the end of the subject
           \G     matches at the first matching position in the subject
-        Inside  a  character  class, \b has a different meaning; it matches the
+        Inside a character class, \b has a different meaning;  it  matches  the
-        backspace character. If any other of  these  assertions  appears  in  a
+        backspace  character.  If  any  other  of these assertions appears in a
-        character  class, by default it matches the corresponding literal char-
+        character class, by default it matches the corresponding literal  char-
         acter  (for  example,  \B  matches  the  letter  B).  However,  if  the
-        PCRE_EXTRA  option is set, an "invalid escape sequence" error is gener-
+        PCRE_EXTRA option is set, an "invalid escape sequence" error is  gener-
         ated instead.
-        A word boundary is a position in the subject string where  the  current
+        A  word  boundary is a position in the subject string where the current
-        character  and  the previous character do not both match \w or \W (i.e.
+        character and the previous character do not both match \w or  \W  (i.e.
-        one matches \w and the other matches \W), or the start or  end  of  the
+        one  matches  \w  and the other matches \W), or the start or end of the
-        string  if  the  first or last character matches \w, respectively. In a
+        string if the first or last character matches \w,  respectively.  In  a
-        UTF mode, the meanings of \w and \W  can  be  changed  by  setting  the
+        UTF  mode,  the  meanings  of  \w  and \W can be changed by setting the
-        PCRE_UCP  option. When this is done, it also affects \b and \B. Neither
+        PCRE_UCP option. When this is done, it also affects \b and \B.  Neither
-        PCRE nor Perl has a separate "start of word" or "end of  word"  metase-
+        PCRE  nor  Perl has a separate "start of word" or "end of word" metase-
-        quence.  However,  whatever follows \b normally determines which it is.
+        quence. However, whatever follows \b normally determines which  it  is.
         For example, the fragment \ba matches "a" at the start of a word.
-        The \A, \Z, and \z assertions differ from  the  traditional  circumflex
+        The  \A,  \Z,  and \z assertions differ from the traditional circumflex
         and dollar (described in the next section) in that they only ever match
-        at the very start and end of the subject string, whatever  options  are
+        at  the  very start and end of the subject string, whatever options are
-        set.  Thus,  they are independent of multiline mode. These three asser-
+        set. Thus, they are independent of multiline mode. These  three  asser-
         tions are not affected by the PCRE_NOTBOL or PCRE_NOTEOL options, which
-        affect  only the behaviour of the circumflex and dollar metacharacters.
+        affect only the behaviour of the circumflex and dollar  metacharacters.
-        However, if the startoffset argument of pcre_exec() is non-zero,  indi-
+        However,  if the startoffset argument of pcre_exec() is non-zero, indi-
         cating that matching is to start at a point other than the beginning of
-        the subject, \A can never match. The difference between \Z  and  \z  is
+        the  subject,  \A  can never match. The difference between \Z and \z is
         that \Z matches before a newline at the end of the string as well as at
         the very end, whereas \z matches only at the end.
-        The \G assertion is true only when the current matching position is  at
+        The  \G assertion is true only when the current matching position is at
-        the  start point of the match, as specified by the startoffset argument
+        the start point of the match, as specified by the startoffset  argument
-        of pcre_exec(). It differs from \A when the  value  of  startoffset  is
+        of  pcre_exec().  It  differs  from \A when the value of startoffset is
-        non-zero.  By calling pcre_exec() multiple times with appropriate argu-
+        non-zero. By calling pcre_exec() multiple times with appropriate  argu-
         ments, you can mimic Perl's /g option, and it is in this kind of imple-
         mentation where \G can be useful.
-        Note,  however,  that  PCRE's interpretation of \G, as the start of the
+        Note, however, that PCRE's interpretation of \G, as the  start  of  the
         current match, is subtly different from Perl's, which defines it as the
-        end  of  the  previous  match. In Perl, these can be different when the
+        end of the previous match. In Perl, these can  be  different  when  the
-        previously matched string was empty. Because PCRE does just  one  match
+        previously  matched  string was empty. Because PCRE does just one match
         at a time, it cannot reproduce this behaviour.
-        If  all  the alternatives of a pattern begin with \G, the expression is
+        If all the alternatives of a pattern begin with \G, the  expression  is
         anchored to the starting match position, and the "anchored" flag is set
         in the compiled regular expression.
  CIRCUMFLEX AND DOLLAR
+        The circumflex and dollar  metacharacters  are  zero-width  assertions.
+        That  is,  they test for a particular condition being true without con-
+        suming any characters from the subject string.
         Outside a character class, in the default matching mode, the circumflex
-        character is an assertion that is true only  if  the  current  matching
+        character  is  an  assertion  that is true only if the current matching
-        point  is  at the start of the subject string. If the startoffset argu-
+        point is at the start of the subject string. If the  startoffset  argu-
-        ment of pcre_exec() is non-zero, circumflex  can  never  match  if  the
+        ment  of  pcre_exec()  is  non-zero,  circumflex can never match if the
-        PCRE_MULTILINE  option  is  unset. Inside a character class, circumflex
+        PCRE_MULTILINE option is unset. Inside a  character  class,  circumflex
         has an entirely different meaning (see below).
-        Circumflex need not be the first character of the pattern if  a  number
+        Circumflex  need  not be the first character of the pattern if a number
-        of  alternatives are involved, but it should be the first thing in each
+        of alternatives are involved, but it should be the first thing in  each
-        alternative in which it appears if the pattern is ever  to  match  that
+        alternative  in  which  it appears if the pattern is ever to match that
-        branch.  If all possible alternatives start with a circumflex, that is,
+        branch. If all possible alternatives start with a circumflex, that  is,
-        if the pattern is constrained to match only at the start  of  the  sub-
+        if  the  pattern  is constrained to match only at the start of the sub-
-        ject,  it  is  said  to be an "anchored" pattern. (There are also other
+        ject, it is said to be an "anchored" pattern.  (There  are  also  other
         constructs that can cause a pattern to be anchored.)
-        A dollar character is an assertion that is true  only  if  the  current
+        The  dollar  character is an assertion that is true only if the current
-        matching  point  is  at  the  end of the subject string, or immediately
+        matching point is at the end of  the  subject  string,  or  immediately
-        before a newline at the end of the string (by default). Dollar need not
+        before  a newline at the end of the string (by default). Note, however,
-        be  the  last  character of the pattern if a number of alternatives are
+        that it does not actually match the newline. Dollar  need  not  be  the
-        involved, but it should be the last item in  any  branch  in  which  it
+        last character of the pattern if a number of alternatives are involved,
-        appears. Dollar has no special meaning in a character class.
+        but it should be the last item in any branch in which it appears.  Dol-
+        lar has no special meaning in a character class.
         The  meaning  of  dollar  can be changed so that it matches only at the
         very end of the string, by setting the  PCRE_DOLLAR_ENDONLY  option  at
-Line 5640 
 INTERNAL OPTION SETTING
+Line 5649 
 INTERNAL OPTION SETTING
         some cases the pattern can contain special leading  sequences  such  as
         (*CRLF)  to  override  what  the  application  has set or what has been
         defaulted.  Details  are  given  in  the  section   entitled   "Newline
-        sequences"  above.  There  are  also the (*UTF8), (*UTF16),(*UTF32) and
+        sequences"  above.  There  are also the (*UTF8), (*UTF16),(*UTF32), and
         (*UCP) leading sequences that can be used to set UTF and Unicode  prop-
         erty  modes;  they are equivalent to setting the PCRE_UTF8, PCRE_UTF16,
-        PCRE_UTF32 and the PCRE_UCP options, respectively.
+        PCRE_UTF32 and the PCRE_UCP options, respectively. The (*UTF)  sequence
+        is a generic version that can be used with any of the libraries.
  SUBPATTERNS
-Line 5655 
 SUBPATTERNS
+Line 5665 
 SUBPATTERNS
           cat(aract|erpillar|)
-        matches  "cataract",  "caterpillar", or "cat". Without the parentheses,
+        matches "cataract", "caterpillar", or "cat". Without  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  the matching function. (This applies only to the
+        ovector argument of the matching function. (This applies  only  to  the
-        traditional matching functions; the DFA matching functions do not  sup-
+        traditional  matching functions; the DFA matching functions do not sup-
         port capturing.)
         Opening parentheses are counted from left to right (starting from 1) to
-        obtain numbers for the  capturing  subpatterns.  For  example,  if  the
+        obtain  numbers  for  the  capturing  subpatterns.  For example, if the
         string "the red king" is matched against the pattern
           the ((red|white) (king|queen))
-Line 5674 
 SUBPATTERNS
+Line 5684 
 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 5687 
 SUBPATTERNS
+Line 5697 
 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 parentheses that  follow  the
+        each  branch.  The numbers of any capturing parentheses that follow the
-        subpattern  start after the highest number used in any branch. The fol-
+        subpattern start after the highest number used in any branch. The  fol-
         lowing example is taken from the Perl documentation. The numbers under-
         neath show in which buffer the captured content will be stored.
-Line 5725 
 DUPLICATE SUBPATTERN NUMBERS
+Line 5735 
 DUPLICATE SUBPATTERN NUMBERS
           / ( a )  (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
           # 1            2         2  3        2     3     4
-        A  back  reference  to a numbered subpattern uses the most recent value
+        A back reference to a numbered subpattern uses the  most  recent  value
-        that is set for that number by any subpattern.  The  following  pattern
+        that  is  set  for that number by any subpattern. The following pattern
         matches "abcabc" or "defdef":
           /(?|(abc)|(def))\1/
-        In  contrast,  a subroutine call to a numbered subpattern always refers
+        In contrast, a subroutine call to a numbered subpattern  always  refers
-        to the first one in the pattern with the given  number.  The  following
+        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-
+        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-
+        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
+        An alternative approach to using this "branch reset" feature is to  use
         duplicate named subpatterns, as described in the next section.
  NAMED SUBPATTERNS
-        Identifying capturing parentheses by number is simple, but  it  can  be
+        Identifying  capturing  parentheses  by number is simple, but it can be
-        very  hard  to keep track of the numbers in complicated regular expres-
+        very hard to keep track of the numbers in complicated  regular  expres-
-        sions. Furthermore, if an  expression  is  modified,  the  numbers  may
+        sions.  Furthermore,  if  an  expression  is  modified, the numbers may
-        change.  To help with this difficulty, PCRE supports the naming of sub-
+        change. To help with this difficulty, PCRE supports the naming of  sub-
         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
+        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-
+        the  Python syntax. PCRE now supports both the Perl and the Python syn-
-        tax.  Perl  allows  identically  numbered subpatterns to have different
+        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
+        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.  (Duplicate  names are also always permitted for subpatterns with
+        time. (Duplicate names are also always permitted for  subpatterns  with
-        the same number, set up as described in the previous  section.)  Dupli-
+        the  same  number, set up as described in the previous section.) Dupli-
-        cate  names  can  be useful for patterns where only one instance of the
+        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
+        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
+        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 5786 
 NAMED SUBPATTERNS
+Line 5796 
 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 back reference to  a  non-unique  named  subpattern  from
+        If  you  make  a  back  reference to a non-unique named subpattern from
-        elsewhere  in the pattern, the one that corresponds to the first occur-
+        elsewhere in the pattern, the one that corresponds to the first  occur-
         rence of the name is used. In the absence of duplicate numbers (see the
-        previous  section) this is the one with the lowest number. If you use a
+        previous section) this is the one with the lowest number. If you use  a
-        named reference in a condition test (see the section  about  conditions
+        named  reference  in a condition test (see the section about conditions
-        below),  either  to check whether a subpattern has matched, or to check
+        below), either to check whether a subpattern has matched, or  to  check
-        for recursion, all subpatterns with the same name are  tested.  If  the
+        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.
+        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 because PCRE uses only the numbers when
+        patterns with the same number because PCRE uses only the  numbers  when
         matching. For this reason, an error is given at compile time if differ-
-        ent  names  are given to subpatterns with the same number. However, you
+        ent names are given to subpatterns with the same number.  However,  you
-        can give the same name to subpatterns with the same number,  even  when
+        can  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 &nbs