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

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

Parent Directory | Revision Log | View Patch Patch

-revision 507 by ph10,
Wed Mar 10 16:08:01 2010 UTC
+revision 512 by ph10,
Tue Mar 30 11:11:52 2010 UTC
 Line 1469 
 COMPILATION ERROR CODES
  \g is not followed by a braced, angle-bracketed, or quoted
                 name/number or by a plain number
  a numbered reference must not be zero
- (*VERB) with an argument is not supported
+ an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)
  (*VERB) not recognized
  number is too big
  subpattern name expected
  digit expected after (?+
  ] is an invalid data character in JavaScript compatibility mode
+ different names for  subpatterns  of  the  same  number  are  not
+        allowed
+ (*MARK) must have an argument
-        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 1485 
 STUDYING A PATTERN
+Line 1488 
 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. In that circumstance, if the calling program
-        wants  to  pass  any  of   the   other   fields   to   pcre_exec()   or
+        wants   to   pass   any   of   the   other  fields  to  pcre_exec()  or
         pcre_dfa_exec(), it must set up its own pcre_extra block.
-        The  second  argument of pcre_study() contains option bits. At present,
+        The second argument of pcre_study() contains option bits.  At  present,
         no options are defined, and this argument should always be zero.
-        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.
         This is a typical call to pcre_study():
-Line 1524 
 STUDYING A PATTERN
+Line 1527 
 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  by
+        it  does  guarantee that no shorter strings match. The value is used by
-        pcre_exec()  and  pcre_dfa_exec()  to  avoid  wasting time by trying to
+        pcre_exec() and pcre_dfa_exec() to avoid  wasting  time  by  trying  to
-        match strings that are shorter than the lower bound. You can  find  out
+        match  strings  that are shorter than the lower bound. You can find out
         the value in a calling program via the pcre_fullinfo() function.
         Studying a pattern is also useful for non-anchored patterns that do not
-        have a single fixed starting character. A bitmap of  possible  starting
+        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.
  LOCALE SUPPORT
-        PCRE handles caseless matching, and determines whether  characters  are
+        PCRE  handles  caseless matching, and determines whether characters are
-        letters,  digits, or whatever, by reference to a set of tables, indexed
+        letters, digits, or whatever, by reference to a set of tables,  indexed
-        by character value. When running in UTF-8 mode, this  applies  only  to
+        by  character  value.  When running in UTF-8 mode, this applies only to
-        characters  with  codes  less than 128. Higher-valued codes never match
+        characters with codes less than 128. Higher-valued  codes  never  match
-        escapes such as \w or \d, but can be tested with \p if  PCRE  is  built
+        escapes  such  as  \w or \d, but can be tested with \p if PCRE is built
-        with  Unicode  character property support. The use of locales with Uni-
+        with Unicode character property support. The use of locales  with  Uni-
-        code is discouraged. If you are handling characters with codes  greater
+        code  is discouraged. If you are handling characters with codes greater
-        than  128, you should either use UTF-8 and Unicode, or use locales, but
+        than 128, you should either use UTF-8 and Unicode, or use locales,  but
         not try to mix the two.
-        PCRE contains an internal set of tables that are used  when  the  final
+        PCRE  contains  an  internal set of tables that are used when the final
-        argument  of  pcre_compile()  is  NULL.  These  are sufficient for many
+        argument of pcre_compile() is  NULL.  These  are  sufficient  for  many
         applications.  Normally, the internal tables recognize only ASCII char-
         acters. However, when PCRE is built, it is possible to cause the inter-
         nal tables to be rebuilt in the default "C" locale of the local system,
         which may cause them to be different.
-        The  internal tables can always be overridden by tables supplied by the
+        The internal tables can always be overridden by tables supplied by  the
         application that calls PCRE. These may be created in a different locale
-        from  the  default.  As more and more applications change to using Uni-
+        from the default. As more and more applications change  to  using  Uni-
         code, the need for this locale support is expected to die away.
-        External tables are built by calling  the  pcre_maketables()  function,
+        External  tables  are  built by calling the pcre_maketables() function,
-        which  has no arguments, in the relevant locale. The result can then be
+        which has no arguments, in the relevant locale. The result can then  be
-        passed to pcre_compile() or pcre_exec()  as  often  as  necessary.  For
+        passed  to  pcre_compile()  or  pcre_exec()  as often as necessary. For
-        example,  to  build  and use tables that are appropriate for the French
+        example, to build and use tables that are appropriate  for  the  French
-        locale (where accented characters with  values  greater  than  128  are
+        locale  (where  accented  characters  with  values greater than 128 are
         treated as letters), the following code could be used:
           setlocale(LC_CTYPE, "fr_FR");
           tables = pcre_maketables();
           re = pcre_compile(..., tables);
-        The  locale  name "fr_FR" is used on Linux and other Unix-like systems;
+        The locale name "fr_FR" is used on Linux and other  Unix-like  systems;
         if you are using Windows, the name for the French locale is "french".
-        When pcre_maketables() runs, the tables are built  in  memory  that  is
+        When  pcre_maketables()  runs,  the  tables are built in memory that is
-        obtained  via  pcre_malloc. It is the caller's responsibility to ensure
+        obtained via pcre_malloc. It is the caller's responsibility  to  ensure
-        that the memory containing the tables remains available for as long  as
+        that  the memory containing the tables remains available for as long as
         it is needed.
         The pointer that is passed to pcre_compile() is saved with the compiled
-        pattern, and the same tables are used via this pointer by  pcre_study()
+        pattern,  and the same tables are used via this pointer by pcre_study()
         and normally also by pcre_exec(). Thus, by default, for any single pat-
         tern, compilation, studying and matching all happen in the same locale,
         but different patterns can be compiled in different locales.
-        It  is  possible to pass a table pointer or NULL (indicating the use of
+        It is possible to pass a table pointer or NULL (indicating the  use  of
-        the internal tables) to pcre_exec(). Although  not  intended  for  this
+        the  internal  tables)  to  pcre_exec(). Although not intended for this
-        purpose,  this facility could be used to match a pattern in a different
+        purpose, this facility could be used to match a pattern in a  different
         locale from the one in which it was compiled. Passing table pointers at
         run time is discussed below in the section on matching a pattern.
-Line 1596 
 INFORMATION ABOUT A PATTERN
+Line 1599 
 INFORMATION ABOUT A PATTERN
         int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
              int what, void *where);
-        The  pcre_fullinfo() function returns information about a compiled pat-
+        The pcre_fullinfo() function returns information about a compiled  pat-
         tern. It replaces the obsolete pcre_info() function, which is neverthe-
         less retained for backwards compability (and is documented below).
-        The  first  argument  for  pcre_fullinfo() is a pointer to the compiled
+        The first argument for pcre_fullinfo() is a  pointer  to  the  compiled
-        pattern. The second argument is the result of pcre_study(), or NULL  if
+        pattern.  The second argument is the result of pcre_study(), or NULL if
-        the  pattern  was not studied. The third argument specifies which piece
+        the pattern was not studied. The third argument specifies  which  piece
-        of information is required, and the fourth argument is a pointer  to  a
+        of  information  is required, and the fourth argument is a pointer to a
-        variable  to  receive  the  data. The yield of the function is zero for
+        variable to receive the data. The yield of the  function  is  zero  for
         success, or one of the following negative numbers:
           PCRE_ERROR_NULL       the argument code was NULL
-Line 1612 
 INFORMATION ABOUT A PATTERN
+Line 1615 
 INFORMATION ABOUT A PATTERN
           PCRE_ERROR_BADMAGIC   the "magic number" was not found
           PCRE_ERROR_BADOPTION  the value of what was invalid
-        The "magic number" is placed at the start of each compiled  pattern  as
+        The  "magic  number" is placed at the start of each compiled pattern as
-        an  simple check against passing an arbitrary memory pointer. Here is a
+        an simple check against passing an arbitrary memory pointer. Here is  a
-        typical call of pcre_fullinfo(), to obtain the length of  the  compiled
+        typical  call  of pcre_fullinfo(), to obtain the length of the compiled
         pattern:
           int rc;
-Line 1625 
 INFORMATION ABOUT A PATTERN
+Line 1628 
 INFORMATION ABOUT A PATTERN
             PCRE_INFO_SIZE,   /* what is required */
             &length);         /* where to put the data */
-        The  possible  values for the third argument are defined in pcre.h, and
+        The possible values for the third argument are defined in  pcre.h,  and
         are as follows:
           PCRE_INFO_BACKREFMAX
-        Return the number of the highest back reference  in  the  pattern.  The
+        Return  the  number  of  the highest back reference in the pattern. The
-        fourth  argument  should  point to an int variable. Zero is returned if
+        fourth argument should point to an int variable. Zero  is  returned  if
         there are no back references.
           PCRE_INFO_CAPTURECOUNT
-        Return the number of capturing subpatterns in the pattern.  The  fourth
+        Return  the  number of capturing subpatterns in the pattern. The fourth
         argument should point to an int variable.
           PCRE_INFO_DEFAULT_TABLES
-        Return  a pointer to the internal default character tables within PCRE.
+        Return a pointer to the internal default character tables within  PCRE.
-        The fourth argument should point to an unsigned char *  variable.  This
+        The  fourth  argument should point to an unsigned char * variable. This
         information call is provided for internal use by the pcre_study() func-
-        tion. External callers can cause PCRE to use  its  internal  tables  by
+        tion.  External  callers  can  cause PCRE to use its internal tables by
         passing a NULL table pointer.
           PCRE_INFO_FIRSTBYTE
-        Return  information  about  the first byte of any matched string, for a
+        Return information about the first byte of any matched  string,  for  a
-        non-anchored pattern. The fourth argument should point to an int  vari-
+        non-anchored  pattern. The fourth argument should point to an int vari-
-        able.  (This option used to be called PCRE_INFO_FIRSTCHAR; the old name
+        able. (This option used to be called PCRE_INFO_FIRSTCHAR; the old  name
         is still recognized for backwards compatibility.)
-        If there is a fixed first byte, for example, from  a  pattern  such  as
+        If  there  is  a  fixed first byte, for example, from a pattern such as
         (cat|cow|coyote), its value is returned. Otherwise, if either
-        (a)  the pattern was compiled with the PCRE_MULTILINE option, and every
+        (a) the pattern was compiled with the PCRE_MULTILINE option, and  every
         branch starts with "^", or
         (b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not
         set (if it were set, the pattern would be anchored),
-        -1  is  returned, indicating that the pattern matches only at the start
+        -1 is returned, indicating that the pattern matches only at  the  start
-        of a subject string or after any newline within the  string.  Otherwise
+        of  a  subject string or after any newline within the string. Otherwise
         -2 is returned. For anchored patterns, -2 is returned.
           PCRE_INFO_FIRSTTABLE
-        If  the pattern was studied, and this resulted in the construction of a
+        If the pattern was studied, and this resulted in the construction of  a
 -bit table indicating a fixed set of bytes for the first byte in any
-        matching  string, a pointer to the table is returned. Otherwise NULL is
+        matching string, a pointer to the table is returned. Otherwise NULL  is
-        returned. The fourth argument should point to an unsigned char *  vari-
+        returned.  The fourth argument should point to an unsigned char * vari-
         able.
           PCRE_INFO_HASCRORLF
-        Return  1  if  the  pattern  contains any explicit matches for CR or LF
+        Return 1 if the pattern contains any explicit  matches  for  CR  or  LF
-        characters, otherwise 0. The fourth argument should  point  to  an  int
+        characters,  otherwise  0.  The  fourth argument should point to an int
-        variable.  An explicit match is either a literal CR or LF character, or
+        variable. An explicit match is either a literal CR or LF character,  or
         \r or \n.
           PCRE_INFO_JCHANGED
-        Return 1 if the (?J) or (?-J) option setting is used  in  the  pattern,
+        Return  1  if  the (?J) or (?-J) option setting is used in the pattern,
-        otherwise  0. The fourth argument should point to an int variable. (?J)
+        otherwise 0. The fourth argument should point to an int variable.  (?J)
         and (?-J) set and unset the local PCRE_DUPNAMES option, respectively.
           PCRE_INFO_LASTLITERAL
-        Return the value of the rightmost literal byte that must exist  in  any
+        Return  the  value of the rightmost literal byte that must exist in any
-        matched  string,  other  than  at  its  start,  if such a byte has been
+        matched string, other than at its  start,  if  such  a  byte  has  been
         recorded. The fourth argument should point to an int variable. If there
-        is  no such byte, -1 is returned. For anchored patterns, a last literal
+        is no such byte, -1 is returned. For anchored patterns, a last  literal
-        byte is recorded only if it follows something of variable  length.  For
+        byte  is  recorded only if it follows something of variable length. For
         example, for the pattern /^a\d+z\d+/ the returned value is "z", but for
         /^a\dz\d/ the returned value is -1.
           PCRE_INFO_MINLENGTH
-        If the pattern was studied and a minimum length  for  matching  subject
+        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, not bytes  (this  may
+        value  is  -1. The value is a number of characters, not bytes (this may
-        be  relevant in UTF-8 mode). The fourth argument should point to an int
+        be relevant in UTF-8 mode). The fourth argument should point to an  int
-        variable. A non-negative value is a lower bound to the  length  of  any
+        variable.  A  non-negative  value is a lower bound to the length of any
-        matching  string.  There  may not be any strings of that length that do
+        matching string. There may not be any strings of that  length  that  do
         actually match, but every string that does match is at least that long.
           PCRE_INFO_NAMECOUNT
           PCRE_INFO_NAMEENTRYSIZE
           PCRE_INFO_NAMETABLE
-        PCRE supports the use of named as well as numbered capturing  parenthe-
+        PCRE  supports the use of named as well as numbered capturing parenthe-
-        ses.  The names are just an additional way of identifying the parenthe-
+        ses. The names are just an additional way of identifying the  parenthe-
         ses, which still acquire numbers. Several convenience functions such as
-        pcre_get_named_substring()  are  provided  for extracting captured sub-
+        pcre_get_named_substring() are provided for  extracting  captured  sub-
-        strings by name. It is also possible to extract the data  directly,  by
+        strings  by  name. It is also possible to extract the data directly, by
-        first  converting  the  name to a number in order to access the correct
+        first converting the name to a number in order to  access  the  correct
         pointers in the output vector (described with pcre_exec() below). To do
-        the  conversion,  you  need  to  use  the  name-to-number map, which is
+        the conversion, you need  to  use  the  name-to-number  map,  which  is
         described by these three values.
         The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT
         gives the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size
-        of each entry; both of these  return  an  int  value.  The  entry  size
+        of  each  entry;  both  of  these  return  an int value. The entry size
-        depends  on the length of the longest name. PCRE_INFO_NAMETABLE returns
+        depends on the length of the longest name. PCRE_INFO_NAMETABLE  returns
-        a pointer to the first entry of the table  (a  pointer  to  char).  The
+        a  pointer  to  the  first  entry of the table (a pointer to char). The
         first two bytes of each entry are the number of the capturing parenthe-
-        sis, most significant byte first. The rest of the entry is  the  corre-
+        sis,  most  significant byte first. The rest of the entry is the corre-
         sponding name, zero terminated.
-        The  names are in alphabetical order. 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 (assume PCRE_EXTENDED is set, so white space -  including  new-
+        pattern  (assume  PCRE_EXTENDED is set, so white space - including new-
         lines - is ignored):
           (?<date> (?<year>(\d\d)?\d\d) -
           (?<month>\d\d) - (?<day>\d\d) )
-        There  are  four  named subpatterns, so the table has four entries, and
+        There are four named subpatterns, so the table has  four  entries,  and
-        each entry in the table is eight bytes long. The table is  as  follows,
+        each  entry  in the table is eight bytes long. The table is as follows,
         with non-printing bytes shows in hexadecimal, and undefined bytes shown
         as ??:
-Line 1758 
 INFORMATION ABOUT A PATTERN
+Line 1761 
 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 1796 
 INFORMATION ABOUT A PATTERN
+Line 1799 
 INFORMATION ABOUT A PATTERN
           PCRE_INFO_SIZE
-        Return the size of the compiled pattern, that is, the  value  that  was
+        Return  the  size  of the compiled pattern, that is, the value that was
         passed as the argument to pcre_malloc() when PCRE was getting memory in
         which to place the compiled data. The fourth argument should point to a
         size_t variable.
-Line 1804 
 INFORMATION ABOUT A PATTERN
+Line 1807 
 INFORMATION ABOUT A PATTERN
           PCRE_INFO_STUDYSIZE
         Return the size of the data block pointed to by the study_data field in
-        a pcre_extra block. That is,  it  is  the  value  that  was  passed  to
+        a  pcre_extra  block.  That  is,  it  is  the  value that was passed to
         pcre_malloc() when PCRE was getting memory into which to place the data
-        created by pcre_study(). If pcre_extra is NULL, or there  is  no  study
+        created  by  pcre_study().  If pcre_extra is NULL, or there is no study
-        data,  zero  is  returned. The fourth argument should point to a size_t
+        data, zero is returned. The fourth argument should point  to  a  size_t
         variable.
-Line 1815 
 OBSOLETE INFO FUNCTION
+Line 1818 
 OBSOLETE INFO FUNCTION
         int pcre_info(const pcre *code, int *optptr, int *firstcharptr);
-        The pcre_info() function is now obsolete because its interface  is  too
+        The  pcre_info()  function is now obsolete because its interface is too
-        restrictive  to return all the available data about a compiled pattern.
+        restrictive to return all the available data about a compiled  pattern.
-        New  programs  should  use  pcre_fullinfo()  instead.  The   yield   of
+        New   programs   should  use  pcre_fullinfo()  instead.  The  yield  of
-        pcre_info()  is the number of capturing subpatterns, or one of the fol-
+        pcre_info() is the number of capturing subpatterns, or one of the  fol-
         lowing negative numbers:
           PCRE_ERROR_NULL       the argument code was NULL
           PCRE_ERROR_BADMAGIC   the "magic number" was not found
-        If the optptr argument is not NULL, a copy of the  options  with  which
+        If  the  optptr  argument is not NULL, a copy of the options with which
-        the  pattern  was  compiled  is placed in the integer it points to (see
+        the pattern was compiled is placed in the integer  it  points  to  (see
         PCRE_INFO_OPTIONS above).
-        If the pattern is not anchored and the  firstcharptr  argument  is  not
+        If  the  pattern  is  not anchored and the firstcharptr argument is not
-        NULL,  it is used to pass back information about the first character of
+        NULL, it is used to pass back information about the first character  of
         any matched string (see PCRE_INFO_FIRSTBYTE above).
-Line 1837 
 REFERENCE COUNTS
+Line 1840 
 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 1861 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1864 
 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. This function is the main matching facility of  the  library,
+        argument.  This  function is the main matching facility of the library,
         and it operates in a Perl-like manner. For specialist use there is also
-        an alternative matching function, which is described below in the  sec-
+        an  alternative matching function, which is described below in the sec-
         tion 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 1891 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1894 
 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 1903 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1906 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           unsigned long int match_limit_recursion;
           void *callout_data;
           const unsigned char *tables;
+          unsigned char **mark;
-        The  flags  field  is a bitmap that specifies which of the other fields
+        The flags field is a bitmap that specifies which of  the  other  fields
         are set. The flag bits are:
           PCRE_EXTRA_STUDY_DATA
-Line 1912 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 1916 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
           PCRE_EXTRA_MATCH_LIMIT_RECURSION
           PCRE_EXTRA_CALLOUT_DATA
           PCRE_EXTRA_TABLES
+          PCRE_EXTRA_MARK
-        Other flag bits should be set to zero. The study_data field is  set  in
+        Other  flag  bits should be set to zero. The study_data field is set in
-        the  pcre_extra  block  that is returned by pcre_study(), together with
+        the pcre_extra block that is returned by  pcre_study(),  together  with
         the appropriate flag bit. You should not set this yourself, but you may
-        add  to  the  block by setting the other fields and their corresponding
+        add to the block by setting the 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 uses a function called match() which it calls  repeat-
+        Internally,  PCRE uses a function called match() which it calls repeat-
-        edly  (sometimes  recursively). The limit set by match_limit is imposed
+        edly (sometimes recursively). The limit set by match_limit  is  imposed
-        on the number of times this function is called during  a  match,  which
+        on  the  number  of times this function is called during a match, which
-        has  the  effect  of  limiting the amount of backtracking that can take
+        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.
-        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  stack  that  can  be
+        Limiting  the  recursion  depth  limits the amount of stack that 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.
-        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
+        set  to  point  to a char * variable. If the pattern contains any back-
+        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-
+        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
+        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
+        field set to NULL. For details of the backtracking control  verbs,  see
+        the section entitled "Backtracking control" in the pcrepattern documen-
+        tation.
     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_SOFT,   and
+        PCRE_NO_START_OPTIMIZE,   PCRE_NO_UTF8_CHECK,   PCRE_PARTIAL_SOFT,  and
         PCRE_PARTIAL_HARD.
           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 1999 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2016 
 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.
           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  a  match must start with a specific character, it searches
+        known that a match must start with a specific  character,  it  searches
         the subject for that character, and fails immediately if it cannot find
-        it,  without actually running the main matching function. When callouts
+        it, without actually running the main matching function. When  callouts
-        are in use, these optimizations can cause  them  to  be  skipped.  This
+        are  in  use,  these  optimizations  can cause them to be skipped. This
-        option  disables  the  "start-up" optimizations, causing performance to
+        option disables the "start-up" optimizations,  causing  performance  to
         suffer, but ensuring that the callouts do occur.
           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 value of startoffset is also checked  to  ensure  that  it
+        called.   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 section on UTF-8  support  in  the
+        the  validity  of  UTF-8 strings in the section on UTF-8 support in the
-        main  pcre  page.  If  an  invalid  UTF-8  sequence  of bytes is found,
+        main pcre page. If  an  invalid  UTF-8  sequence  of  bytes  is  found,
-        pcre_exec() returns the error PCRE_ERROR_BADUTF8. If  startoffset  con-
+        pcre_exec()  returns  the error PCRE_ERROR_BADUTF8. If startoffset con-
         tains an invalid value, 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 UTF-8 character. When PCRE_NO_UTF8_CHECK is
+        points to the start of a UTF-8 character.  When  PCRE_NO_UTF8_CHECK  is
-        set, the effect of passing an invalid UTF-8 string as a subject,  or  a
+        set,  the  effect of passing an invalid UTF-8 string as a subject, or a
-        value  of startoffset that does not point to the start of a UTF-8 char-
+        value of startoffset that does not point to the start of a UTF-8  char-
         acter, 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_HARD  is  set,  pcre_exec()  immediately
+        this  happens  when  PCRE_PARTIAL_HARD  is set, pcre_exec() immediately
-        returns  PCRE_ERROR_PARTIAL.  Otherwise,  if  PCRE_PARTIAL_SOFT is set,
+        returns PCRE_ERROR_PARTIAL. Otherwise,  if  PCRE_PARTIAL_SOFT  is  set,
-        matching continues by testing any other alternatives. Only if they  all
+        matching  continues by testing any other alternatives. Only if they all
-        fail  is  PCRE_ERROR_PARTIAL  returned (instead of PCRE_ERROR_NOMATCH).
+        fail is PCRE_ERROR_PARTIAL returned  (instead  of  PCRE_ERROR_NOMATCH).
         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
+        found is set as the first matching string. There  is  a  more  detailed
         discussion 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.
         In UTF-8 mode, the byte offset must point to the start of a UTF-8 char-
-        acter.  Unlike  the pattern string, the subject may contain binary zero
+        acter. Unlike the pattern string, the subject may contain  binary  zero
-        bytes. When the starting offset is zero, the search for a match  starts
+        bytes.  When the starting offset is zero, the search for a match starts
-        at  the  beginning  of  the subject, and this is by far the most common
+        at the beginning of the subject, and this is by  far  the  most  common
         case.
-        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.
-        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 the substring offsets are  not  of
+        function  returns  a value of zero. If the substring offsets are not of
-        interest,  pcre_exec()  may  be  called with ovector passed as NULL and
+        interest, pcre_exec() may be called with ovector  passed  as  NULL  and
-        ovecsize as zero. However, if the pattern contains back references  and
+        ovecsize  as zero. However, if the pattern contains back references and
-        the  ovector is not big enough to remember the related substrings, PCRE
+        the ovector is not big enough to remember the related substrings,  PCRE
-        has to get additional memory for use during matching. Thus it  is  usu-
+        has  to  get additional memory for use during matching. Thus it is usu-
         ally advisable to supply an ovector.
         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. However, you can refer to the offsets
-        for the second and third capturing subpatterns if  you  wish  (assuming
+        for  the  second  and third capturing subpatterns if you wish (assuming
         the vector is large enough, of course).
-        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 2244 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2261 
 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 2253 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2270 
 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.
           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.
           PCRE_ERROR_BADUTF8_OFFSET (-11)
         The UTF-8 byte sequence that was passed as a subject was valid, 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.
           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 2326 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2343 
 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 2349 
 EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
+Line 2366 
 EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
         int pcre_get_substring_list(const char *subject,
              int *ovector, int stringcount, const char ***listptr);
-        Captured substrings can be  accessed  directly  by  using  the  offsets
+        Captured  substrings  can  be  accessed  directly  by using the offsets
-        returned  by  pcre_exec()  in  ovector.  For convenience, the functions
+        returned by pcre_exec() in  ovector.  For  convenience,  the  functions
         pcre_copy_substring(),    pcre_get_substring(),    and    pcre_get_sub-
-        string_list()  are  provided for extracting captured substrings as new,
+        string_list() are provided for extracting captured substrings  as  new,
-        separate, zero-terminated strings. These functions identify  substrings
+        separate,  zero-terminated strings. These functions identify substrings
-        by  number.  The  next section describes functions for extracting named
+        by number. The next section describes functions  for  extracting  named
         substrings.
-        A substring that contains a binary zero is correctly extracted and  has
+        A  substring that contains a binary zero is correctly extracted and has
-        a  further zero added on the end, but the result is not, of course, a C
+        a further zero added on the end, but the result is not, of course, a  C
-        string.  However, you can process such a string  by  referring  to  the
+        string.   However,  you  can  process such a string by referring to the
-        length  that  is  returned  by  pcre_copy_substring() and pcre_get_sub-
+        length that is  returned  by  pcre_copy_substring()  and  pcre_get_sub-
         string().  Unfortunately, the interface to pcre_get_substring_list() is
-        not  adequate for handling strings containing binary zeros, because the
+        not adequate for handling strings containing binary zeros, because  the
         end of the final string is not independently indicated.
-        The first three arguments are the same for all  three  of  these  func-
+        The  first  three  arguments  are the same for all three of these func-
-        tions:  subject  is  the subject string that has just been successfully
+        tions: subject is the subject string that has  just  been  successfully
         matched, ovector is a pointer to the vector of integer offsets that was
         passed to pcre_exec(), and stringcount is the number of substrings that
-        were captured by the match, including the substring  that  matched  the
+        were  captured  by  the match, including the substring that matched the
         entire regular expression. This is the value returned by pcre_exec() if
-        it is greater than zero. If pcre_exec() returned zero, indicating  that
+        it  is greater than zero. If pcre_exec() returned zero, indicating that
-        it  ran out of space in ovector, the value passed as stringcount should
+        it ran out of space in ovector, the value passed as stringcount  should
         be the number of elements in the vector divided by three.
-        The functions pcre_copy_substring() and pcre_get_substring() extract  a
+        The  functions pcre_copy_substring() and pcre_get_substring() extract a
-        single  substring,  whose  number  is given as stringnumber. A value of
+        single substring, whose number is given as  stringnumber.  A  value  of
-        zero extracts the substring that matched the  entire  pattern,  whereas
+        zero  extracts  the  substring that matched the entire pattern, whereas
-        higher  values  extract  the  captured  substrings.  For pcre_copy_sub-
+        higher values  extract  the  captured  substrings.  For  pcre_copy_sub-
-        string(), the string is placed in buffer,  whose  length  is  given  by
+        string(),  the  string  is  placed  in buffer, whose length is given by
-        buffersize,  while  for  pcre_get_substring()  a new block of memory is
+        buffersize, while for pcre_get_substring() a new  block  of  memory  is
-        obtained via pcre_malloc, and its address is  returned  via  stringptr.
+        obtained  via  pcre_malloc,  and its address is returned via stringptr.
-        The  yield  of  the function is the length of the string, not including
+        The yield of the function is the length of the  string,  not  including
         the terminating zero, or one of these error codes:
           PCRE_ERROR_NOMEMORY       (-6)
-        The buffer was too small for pcre_copy_substring(), or the  attempt  to
+        The  buffer  was too small for pcre_copy_substring(), or the attempt to
         get memory failed for pcre_get_substring().
           PCRE_ERROR_NOSUBSTRING    (-7)
         There is no substring whose number is stringnumber.
-        The  pcre_get_substring_list()  function  extracts  all  available sub-
+        The pcre_get_substring_list()  function  extracts  all  available  sub-
-        strings and builds a list of pointers to them. All this is  done  in  a
+        strings  and  builds  a list of pointers to them. All this is done in a
         single block of memory that is obtained via pcre_malloc. The address of
-        the memory block is returned via listptr, which is also  the  start  of
+        the  memory  block  is returned via listptr, which is also the start of
-        the  list  of  string pointers. The end of the list is marked by a NULL
+        the list of string pointers. The end of the list is marked  by  a  NULL
-        pointer. The yield of the function is zero if all  went  well,  or  the
+        pointer.  The  yield  of  the function is zero if all went well, or the
         error code
           PCRE_ERROR_NOMEMORY       (-6)
         if the attempt to get the memory block failed.
-        When  any of these functions encounter a substring that is unset, which
+        When any of these functions encounter a substring that is unset,  which
-        can happen when capturing subpattern number n+1 matches  some  part  of
+        can  happen  when  capturing subpattern number n+1 matches some part of
-        the  subject, but subpattern n has not been used at all, they return an
+        the subject, but subpattern n has not been used at all, they return  an
         empty string. This can be distinguished from a genuine zero-length sub-
-        string  by inspecting the appropriate offset in ovector, which is nega-
+        string by inspecting the appropriate offset in ovector, which is  nega-
         tive for unset substrings.
-        The two convenience functions pcre_free_substring() and  pcre_free_sub-
+        The  two convenience functions pcre_free_substring() and pcre_free_sub-
-        string_list()  can  be  used  to free the memory returned by a previous
+        string_list() can be used to free the memory  returned  by  a  previous
         call  of  pcre_get_substring()  or  pcre_get_substring_list(),  respec-
-        tively.  They  do  nothing  more  than  call the function pointed to by
+        tively. They do nothing more than  call  the  function  pointed  to  by
-        pcre_free, which of course could be called directly from a  C  program.
+        pcre_free,  which  of course could be called directly from a C program.
-        However,  PCRE is used in some situations where it is linked via a spe-
+        However, PCRE is used in some situations where it is linked via a  spe-
-        cial  interface  to  another  programming  language  that  cannot   use
+        cial   interface  to  another  programming  language  that  cannot  use
-        pcre_free  directly;  it is for these cases that the functions are pro-
+        pcre_free directly; it is for these cases that the functions  are  pro-
         vided.
-Line 2439 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
+Line 2456 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
              int stringcount, const char *stringname,
              const char **stringptr);
-        To extract a substring by name, you first have to find associated  num-
+        To  extract a substring by name, you first have to find associated num-
         ber.  For example, for this pattern
           (a+)b(?<xxx>\d+)...
-Line 2448 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
+Line 2465 
 EXTRACTING CAPTURED SUBSTRINGS BY NAME
         be unique (PCRE_DUPNAMES was not set), you can find the number from the
         name by calling pcre_get_stringnumber(). The first argument is the com-
         piled pattern, and the second is the name. The yield of the function is
-        the  subpattern  number,  or PCRE_ERROR_NOSUBSTRING (-7) if there is no
+        the subpattern number, or PCRE_ERROR_NOSUBSTRING (-7) if  there  is  no
         subpattern of that name.
         Given the number, you can extract the substring directly, or use one of
         the functions described in the previous section. For convenience, there
         are also two functions that do the whole job.
-        Most   of   the   arguments    of    pcre_copy_named_substring()    and
+        Most    of    the    arguments   of   pcre_copy_named_substring()   and
-        pcre_get_named_substring()  are  the  same  as  those for the similarly
+        pcre_get_named_substring() are the same  as  those  for  the  similarly
-        named functions that extract by number. As these are described  in  the
+        named  functions  that extract by number. As these are described in the
-        previous  section,  they  are not re-described here. There are just two
+        previous section, they are not re-described here. There  are  just  two
         differences:
-        First, instead of a substring number, a substring name is  given.  Sec-
+        First,  instead  of a substring number, a substring name is given. Sec-
         ond, there is an extra argument, given at the start, which is a pointer
-        to the compiled pattern. This is needed in order to gain access to  the
+        to  the compiled pattern. This is needed in order to gain access to the
         name-to-number translation table.
-        These  functions call pcre_get_stringnumber(), and if it succeeds, they
+        These functions call pcre_get_stringnumber(), and if it succeeds,  they
-        then call pcre_copy_substring() or pcre_get_substring(),  as  appropri-
+        then  call  pcre_copy_substring() or pcre_get_substring(), as appropri-
-        ate.  NOTE:  If PCRE_DUPNAMES is set and there are duplicate names, the
+        ate. NOTE: If PCRE_DUPNAMES is set and there are duplicate  names,  the
         behaviour may not be what you want (see the next section).
         Warning: If the pattern uses the (?| feature to set up multiple subpat-
-        terns  with  the  same number, as described in the section on duplicate
+        terns with the same number, as described in the  section  on  duplicate
-        subpattern numbers in the pcrepattern page, you  cannot  use  names  to
+        subpattern  numbers  in  the  pcrepattern page, you cannot use names to
-        distinguish  the  different subpatterns, because names are not included
+        distinguish the different subpatterns, because names are  not  included
-        in the compiled code. The matching process uses only numbers. For  this
+        in  the compiled code. The matching process uses only numbers. For this
-        reason,  the  use of different names for subpatterns of the same number
+        reason, the use of different names for subpatterns of the  same  number
         causes an error at compile time.
-Line 2485 
 DUPLICATE SUBPATTERN NAMES
+Line 2502 
 DUPLICATE SUBPATTERN NAMES
         int pcre_get_stringtable_entries(const pcre *code,
              const char *name, char **first, char **last);
-        When a pattern is compiled with the  PCRE_DUPNAMES  option,  names  for
+        When  a  pattern  is  compiled with the PCRE_DUPNAMES option, names for
-        subpatterns  are not required to be unique. (Duplicate names are always
+        subpatterns are not required to be unique. (Duplicate names are  always
-        allowed for subpatterns with the same number, created by using the  (?|
+        allowed  for subpatterns with the same number, created by using the (?|
-        feature.  Indeed,  if  such subpatterns are named, they are required to
+        feature. Indeed, if such subpatterns are named, they  are  required  to
         use the same names.)
         Normally, patterns with duplicate names are such that in any one match,
-        only  one of the named subpatterns participates. An example is shown in
+        only one of the named subpatterns participates. An example is shown  in
         the pcrepattern documentation.
-        When   duplicates   are   present,   pcre_copy_named_substring()    and
+        When    duplicates   are   present,   pcre_copy_named_substring()   and
-        pcre_get_named_substring()  return the first substring corresponding to
+        pcre_get_named_substring() return the first substring corresponding  to
-        the given name that is set. If  none  are  set,  PCRE_ERROR_NOSUBSTRING
+        the  given  name  that  is set. If none are set, PCRE_ERROR_NOSUBSTRING
-        (-7)  is  returned;  no  data  is returned. The pcre_get_stringnumber()
+        (-7) is returned; no  data  is  returned.  The  pcre_get_stringnumber()
-        function returns one of the numbers that are associated with the  name,
+        function  returns one of the numbers that are associated with the name,
         but it is not defined which it is.
-        If  you want to get full details of all captured substrings for a given
+        If you want to get full details of all captured substrings for a  given
-        name, you must use  the  pcre_get_stringtable_entries()  function.  The
+        name,  you  must  use  the pcre_get_stringtable_entries() function. The
         first argument is the compiled pattern, and the second is the name. The
-        third and fourth are pointers to variables which  are  updated  by  the
+        third  and  fourth  are  pointers to variables which are updated by the
         function. After it has run, they point to the first and last entries in
-        the name-to-number table  for  the  given  name.  The  function  itself
+        the  name-to-number  table  for  the  given  name.  The function itself
-        returns  the  length  of  each entry, or PCRE_ERROR_NOSUBSTRING (-7) if
+        returns the length of each entry,  or  PCRE_ERROR_NOSUBSTRING  (-7)  if
-        there are none. The format of the table is described above in the  sec-
+        there  are none. The format of the table is described above in the sec-
-        tion  entitled  Information  about  a  pattern.  Given all the relevant
+        tion entitled Information about a  pattern.   Given  all  the  relevant
-        entries for the name, you can extract each of their numbers, and  hence
+        entries  for the name, you can extract each of their numbers, and hence
         the captured data, if any.
  FINDING ALL POSSIBLE MATCHES
-        The  traditional  matching  function  uses a similar algorithm to Perl,
+        The traditional matching function uses a  similar  algorithm  to  Perl,
         which stops when it finds the first match, starting at a given point in
-        the  subject.  If you want to find all possible matches, or the longest
+        the subject. If you want to find all possible matches, or  the  longest
-        possible match, consider using the alternative matching  function  (see
+        possible  match,  consider using the alternative matching function (see
-        below)  instead.  If you cannot use the alternative function, but still
+        below) instead. If you cannot use the alternative function,  but  still
-        need to find all possible matches, you can kludge it up by  making  use
+        need  to  find all possible matches, you can kludge it up by making use
         of the callout facility, which is described in the pcrecallout documen-
         tation.
         What you have to do is to insert a callout right at the end of the pat-
-        tern.   When your callout function is called, extract and save the cur-
+        tern.  When your callout function is called, extract and save the  cur-
-        rent matched substring. Then return  1,  which  forces  pcre_exec()  to
+        rent  matched  substring.  Then  return  1, which forces pcre_exec() to
-        backtrack  and  try other alternatives. Ultimately, when it runs out of
+        backtrack and try other alternatives. Ultimately, when it runs  out  of
         matches, pcre_exec() will yield PCRE_ERROR_NOMATCH.
-Line 2540 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2557 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
              int options, int *ovector, int ovecsize,
              int *workspace, int wscount);
-        The function pcre_dfa_exec()  is  called  to  match  a  subject  string
+        The  function  pcre_dfa_exec()  is  called  to  match  a subject string
-        against  a  compiled pattern, using a matching algorithm that scans the
+        against a compiled pattern, using a matching algorithm that  scans  the
-        subject string just once, and does not backtrack.  This  has  different
+        subject  string  just  once, and does not backtrack. This has different
-        characteristics  to  the  normal  algorithm, and is not compatible with
+        characteristics to the normal algorithm, and  is  not  compatible  with
-        Perl. Some of the features of PCRE patterns are not  supported.  Never-
+        Perl.  Some  of the features of PCRE patterns are not supported. Never-
-        theless,  there are times when this kind of matching can be useful. For
+        theless, there are times when this kind of matching can be useful.  For
-        a discussion of the two matching algorithms, and  a  list  of  features
+        a  discussion  of  the  two matching algorithms, and a list of features
-        that  pcre_dfa_exec() does not support, see the pcrematching documenta-
+        that pcre_dfa_exec() does not support, see the pcrematching  documenta-
         tion.
-        The arguments for the pcre_dfa_exec() function  are  the  same  as  for
+        The  arguments  for  the  pcre_dfa_exec()  function are the same as for
         pcre_exec(), plus two extras. The ovector argument is used in a differ-
-        ent way, and this is described below. The other  common  arguments  are
+        ent  way,  and  this is described below. The other common arguments are
-        used  in  the  same way as for pcre_exec(), so their description is not
+        used in the same way as for pcre_exec(), so their  description  is  not
         repeated here.
-        The two additional arguments provide workspace for  the  function.  The
+        The  two  additional  arguments provide workspace for the function. The
-        workspace  vector  should  contain at least 20 elements. It is used for
+        workspace vector should contain at least 20 elements. It  is  used  for
         keeping  track  of  multiple  paths  through  the  pattern  tree.  More
-        workspace  will  be  needed for patterns and subjects where there are a
+        workspace will be needed for patterns and subjects where  there  are  a
         lot of potential matches.
         Here is an example of a simple call to pcre_dfa_exec():
-Line 2581 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2598 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
     Option bits for pcre_dfa_exec()
-        The unused bits of the options argument  for  pcre_dfa_exec()  must  be
+        The  unused  bits  of  the options argument for pcre_dfa_exec() must be
-        zero.  The  only  bits  that  may  be  set are PCRE_ANCHORED, PCRE_NEW-
+        zero. The only bits  that  may  be  set  are  PCRE_ANCHORED,  PCRE_NEW-
         LINE_xxx,        PCRE_NOTBOL,        PCRE_NOTEOL,        PCRE_NOTEMPTY,
         PCRE_NOTEMPTY_ATSTART, PCRE_NO_UTF8_CHECK, PCRE_PARTIAL_HARD, PCRE_PAR-
-        TIAL_SOFT, PCRE_DFA_SHORTEST, and PCRE_DFA_RESTART. All  but  the  last
+        TIAL_SOFT,  PCRE_DFA_SHORTEST,  and  PCRE_DFA_RESTART. All but the last
-        four  of  these  are  exactly  the  same  as  for pcre_exec(), so their
+        four of these are  exactly  the  same  as  for  pcre_exec(),  so  their
         description is not repeated here.
           PCRE_PARTIAL_HARD
           PCRE_PARTIAL_SOFT
-        These have the same general effect as they do for pcre_exec(), but  the
+        These  have the same general effect as they do for pcre_exec(), but the
-        details  are  slightly  different.  When  PCRE_PARTIAL_HARD  is set for
+        details are slightly  different.  When  PCRE_PARTIAL_HARD  is  set  for
-        pcre_dfa_exec(), it returns PCRE_ERROR_PARTIAL if the end of  the  sub-
+        pcre_dfa_exec(),  it  returns PCRE_ERROR_PARTIAL if the end of the sub-
-        ject  is  reached  and there is still at least one matching possibility
+        ject is reached and there is still at least  one  matching  possibility
         that requires additional characters. This happens even if some complete
         matches have also been found. When PCRE_PARTIAL_SOFT is set, the return
         code PCRE_ERROR_NOMATCH is converted into PCRE_ERROR_PARTIAL if the end
-        of  the  subject  is  reached, there have been no complete matches, but
+        of the subject is reached, there have been  no  complete  matches,  but
-        there is still at least one matching possibility. The  portion  of  the
+        there  is  still  at least one matching possibility. The portion of the
-        string  that  was inspected when the longest partial match was found is
+        string that was inspected when the longest partial match was  found  is
         set as the first matching string in both cases.
           PCRE_DFA_SHORTEST
-        Setting the PCRE_DFA_SHORTEST option causes the matching  algorithm  to
+        Setting  the  PCRE_DFA_SHORTEST option causes the matching algorithm to
         stop as soon as it has found one match. Because of the way the alterna-
-        tive algorithm works, this is necessarily the shortest  possible  match
+        tive  algorithm  works, this is necessarily the shortest possible match
         at the first possible matching point in the subject string.
           PCRE_DFA_RESTART
         When pcre_dfa_exec() returns a partial match, it is possible to call it
-        again, with additional subject characters, and have  it  continue  with
+        again,  with  additional  subject characters, and have it continue with
-        the  same match. The PCRE_DFA_RESTART option requests this action; when
+        the same match. The PCRE_DFA_RESTART option requests this action;  when
-        it is set, the workspace and wscount options must  reference  the  same
+        it  is  set,  the workspace and wscount options must reference the same
-        vector  as  before  because data about the match so far is left in them
+        vector as before because data about the match so far is  left  in  them
         after a partial match. There is more discussion of this facility in the
         pcrepartial documentation.
     Successful returns from pcre_dfa_exec()
-        When  pcre_dfa_exec()  succeeds, it may have matched more than one sub-
+        When pcre_dfa_exec() succeeds, it may have matched more than  one  sub-
         string in the subject. Note, however, that all the matches from one run
-        of  the  function  start  at the same point in the subject. The shorter
+        of the function start at the same point in  the  subject.  The  shorter
-        matches are all initial substrings of the longer matches. For  example,
+        matches  are all initial substrings of the longer matches. For example,
         if the pattern
           <.*>
-Line 2641 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 2658 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
           <something> <something else>
           <something> <something else> <something further>
-        On  success,  the  yield of the function is a number greater than zero,
+        On success, the yield of the function is a number  greater  than  zero,
-        which is the number of matched substrings.  The  substrings  themselves
+        which  is  the  number of matched substrings. The substrings themselves
-        are  returned  in  ovector. Each string uses two elements; the first is
+        are returned in ovector. Each string uses two elements;  the  first  is
-        the offset to the start, and the second is the offset to  the  end.  In
+        the  offset  to  the start, and the second is the offset to the end. In
-        fact,  all  the  strings  have the same start offset. (Space could have
+        fact, all the strings have the same start  offset.  (Space  could  have
-        been saved by giving this only once, but it was decided to retain  some
+        been  saved by giving this only once, but it was decided to retain some
-        compatibility  with  the  way pcre_exec() returns data, even though the
+        compatibility with the way pcre_exec() returns data,  even  though  the
         meaning of the strings is different.)
         The strings are returned in reverse order of length; that is, the long-
-        est  matching  string is given first. If there were too many matches to
+        est matching string is given first. If there were too many  matches  to
-        fit into ovector, the yield of the function is zero, and the vector  is
+        fit  into ovector, the yield of the function is zero, and the vector is
         filled with the longest matches.
     Error returns from pcre_dfa_exec()
-        The  pcre_dfa_exec()  function returns a negative number when it fails.
+        The pcre_dfa_exec() function returns a negative number when  it  fails.
-        Many of the errors are the same  as  for  pcre_exec(),  and  these  are
+        Many  of  the  errors  are  the  same as for pcre_exec(), and these are
-        described  above.   There are in addition the following errors that are
+        described above.  There are in addition the following errors  that  are
         specific to pcre_dfa_exec():
           PCRE_ERROR_DFA_UITEM      (-16)
-        This return is given if pcre_dfa_exec() encounters an item in the  pat-
+        This  return is given if pcre_dfa_exec() encounters an item in the pat-
-        tern  that  it  does not support, for instance, the use of \C or a back
+        tern that it does not support, for instance, the use of \C  or  a  back
         reference.
           PCRE_ERROR_DFA_UCOND      (-17)
-        This return is given if pcre_dfa_exec()  encounters  a  condition  item
+        This  return  is  given  if pcre_dfa_exec() encounters a condition item
-        that  uses  a back reference for the condition, or a test for recursion
+        that uses a back reference for the condition, or a test  for  recursion
         in a specific group. These are not supported.
           PCRE_ERROR_DFA_UMLIMIT    (-18)
-        This return is given if pcre_dfa_exec() is called with an  extra  block
+        This  return  is given if pcre_dfa_exec() is called with an extra block
         that contains a setting of the match_limit field. This is not supported
         (it is meaningless).
           PCRE_ERROR_DFA_WSSIZE     (-19)
-        This return is given if  pcre_dfa_exec()  runs  out  of  space  in  the
+        This  return  is  given  if  pcre_dfa_exec()  runs  out of space in the
         workspace vector.
           PCRE_ERROR_DFA_RECURSE    (-20)
-        When  a  recursive subpattern is processed, the matching function calls
+        When a recursive subpattern is processed, the matching  function  calls
-        itself recursively, using private vectors for  ovector  and  workspace.
+        itself  recursively,  using  private vectors for ovector and workspace.
-        This  error  is  given  if  the output vector is not large enough. This
+        This error is given if the output vector  is  not  large  enough.  This
         should be extremely rare, as a vector of size 1000 is used.
  SEE ALSO
-        pcrebuild(3), pcrecallout(3), pcrecpp(3)(3), pcrematching(3),  pcrepar-
+        pcrebuild(3),  pcrecallout(3), pcrecpp(3)(3), pcrematching(3), pcrepar-
         tial(3), pcreposix(3), pcreprecompile(3), pcresample(3), pcrestack(3).
-Line 2708 
 AUTHOR
+Line 2725 
 AUTHOR
  REVISION
-        Last updated: 03 October 2009
+        Last updated: 26 March 2010
-        Copyright (c) 1997-2009 University of Cambridge.
+        Copyright (c) 1997-2010 University of Cambridge.
  ------------------------------------------------------------------------------
-Line 5144 
 BACKTRACKING CONTROL
+Line 5161 
 BACKTRACKING CONTROL
         tested.
         The  new verbs make use of what was previously invalid syntax: an open-
-        ing parenthesis followed by an asterisk. In Perl, they are generally of
+        ing parenthesis followed by an asterisk. They are generally of the form
-        the form (*VERB:ARG) but PCRE does not support the use of arguments, so
+        (*VERB)  or (*VERB:NAME). Some may take either form, with differing be-
-        its general form is just (*VERB). Any number of these verbs  may  occur
+        haviour, depending on whether or not an argument is present. An name is
-        in a pattern. There are two kinds:
+        a  sequence  of letters, digits, and underscores. If the name is empty,
+        that is, if the closing parenthesis immediately follows the colon,  the
+        effect is as if the colon were not there. Any number of these verbs may
+        occur in a pattern.
+        PCRE contains some optimizations that are used to speed up matching  by
+        running some checks at the start of each match attempt. For example, it
+        may know the minimum length of matching subject, or that  a  particular
+        character  must  be present. When one of these optimizations suppresses
+        the running of a match, any included backtracking verbs  will  not,  of
+        course, be processed. You can suppress the start-of-match optimizations
+        by setting the PCRE_NO_START_OPTIMIZE option when calling pcre_exec().
     Verbs that act immediately
-        The following verbs act as soon as they are encountered:
+        The following verbs act as soon as they are encountered. They  may  not
+        be followed by a name.
            (*ACCEPT)
-Line 5180 
 BACKTRACKING CONTROL
+Line 5209 
 BACKTRACKING CONTROL
         A  match  with the string "aaaa" always fails, but the callout is taken
         before each backtrack happens (in this example, 10 times).
+    Recording which path was taken
+        There is one verb whose main purpose  is  to  track  how  a  match  was
+        arrived  at,  though  it  also  has a secondary use in conjunction with
+        advancing the match starting point (see (*SKIP) below).
+          (*MARK:NAME) or (*:NAME)
+        A name is always  required  with  this  verb.  There  may  be  as  many
+        instances  of  (*MARK) as you like in a pattern, and their names do not
+        have to be unique.
+        When a match succeeds, the name  of  the  last-encountered  (*MARK)  is
+        passed  back  to  the  caller  via  the  pcre_extra  data structure, as
+        described in the section on pcre_extra in the pcreapi documentation. No
+        data  is  returned  for a partial match. Here is an example of pcretest
+        output, where the /K modifier requests the retrieval and outputting  of
+        (*MARK) data:
+          /X(*MARK:A)Y|X(*MARK:B)Z/K
+          XY
+: XY
+          MK: A
+          XZ
+: XZ
+          MK: B
+        The (*MARK) name is tagged with "MK:" in this output, and in this exam-
+        ple it indicates which of the two alternatives matched. This is a  more
+        efficient  way of obtaining this information than putting each alterna-
+        tive in its own capturing parentheses.
+        A name may also be returned after a failed  match  if  the  final  path
+        through  the  pattern involves (*MARK). However, unless (*MARK) used in
+        conjunction with (*COMMIT), this is unlikely to  happen  for  an  unan-
+        chored pattern because, as the starting point for matching is advanced,
+        the final check is often with an empty string, causing a failure before
+        (*MARK) is reached. For example:
+          /X(*MARK:A)Y|X(*MARK:B)Z/K
+          XP
+          No match
+        There are three potential starting points for this match (starting with
+        X, starting with P, and with  an  empty  string).  If  the  pattern  is
+        anchored, the result is different:
+          /^X(*MARK:A)Y|^X(*MARK:B)Z/K
+          XP
+          No match, mark = B
+        PCRE's  start-of-match  optimizations can also interfere with this. For
+        example, if, as a result of a call to pcre_study(), it knows the  mini-
+        mum  subject  length for a match, a shorter subject will not be scanned
+        at all.
+        Note that similar anomalies (though different in detail) exist in Perl,
+        no  doubt  for the same reasons. The use of (*MARK) data after a failed
+        match of an unanchored pattern is not recommended, unless (*COMMIT)  is
+        involved.
     Verbs that act after backtracking
         The following verbs do nothing when they are encountered. Matching con-
-        tinues  with what follows, but if there is no subsequent match, a fail-
+        tinues with what follows, but if there is no subsequent match,  causing
-        ure is forced.  The verbs  differ  in  exactly  what  kind  of  failure
+        a  backtrack  to  the  verb, a failure is forced. That is, backtracking
-        occurs.
+        cannot pass to the left of the verb. However, when one of  these  verbs
+        appears  inside  an atomic group, its effect is confined to that group,
+        because once the group has been matched, there is never any  backtrack-
+        ing  into  it.  In  this situation, backtracking can "jump back" to the
+        left of the entire atomic group. (Remember also, as stated above,  that
+        this localization also applies in subroutine calls and assertions.)
+        These  verbs  differ  in exactly what kind of failure occurs when back-
+        tracking reaches them.
           (*COMMIT)
-        This  verb  causes  the whole match to fail outright if the rest of the
+        This verb, which may not be followed by a name, causes the whole  match
-        pattern does not match. Even if the pattern is unanchored,  no  further
+        to fail outright if the rest of the pattern does not match. Even if the
-        attempts  to  find  a match by advancing the starting point take place.
+        pattern is unanchored, no further attempts to find a match by advancing
-        Once (*COMMIT) has been passed, pcre_exec() is committed to  finding  a
+        the  starting  point  take  place.  Once  (*COMMIT)  has  been  passed,
-        match at the current starting point, or not at all. For example:
+        pcre_exec() is committed to finding a match  at  the  current  starting
+        point, or not at all. For example:
           a+(*COMMIT)b
         This  matches  "xxaab" but not "aacaab". It can be thought of as a kind
-        of dynamic anchor, or "I've started, so I must finish."
+        of dynamic anchor, or "I've started, so I must finish." The name of the
+        most  recently passed (*MARK) in the path is passed back when (*COMMIT)
-          (*PRUNE)
+        forces a match failure.
-        This verb causes the match to fail at the current position if the  rest
+        Note that (*COMMIT) at the start of a pattern is not  the  same  as  an
-        of the pattern does not match. If the pattern is unanchored, the normal
+        anchor,  unless  PCRE's start-of-match optimizations are turned off, as
-        "bumpalong" advance to the next starting character then happens.  Back-
+        shown in this pcretest example:
-        tracking  can  occur as usual to the left of (*PRUNE), or when matching
-        to the right of (*PRUNE), but if there is no match to the right,  back-
+          /(*COMMIT)abc/
-        tracking  cannot  cross (*PRUNE).  In simple cases, the use of (*PRUNE)
+          xyzabc
-        is just an alternative to an atomic group or possessive quantifier, but
+: abc
-        there  are  some uses of (*PRUNE) that cannot be expressed in any other
+          xyzabc\Y
-        way.
+          No match
+        PCRE knows that any match must start  with  "a",  so  the  optimization
+        skips  along the subject to "a" before running the first match attempt,
+        which succeeds. When the optimization is disabled by the \Y  escape  in
+        the second subject, the match starts at "x" and so the (*COMMIT) causes
+        it to fail without trying any other starting points.
+          (*PRUNE) or (*PRUNE:NAME)
+        This verb causes the match to fail at the current starting position  in
+        the  subject  if the rest of the pattern does not match. If the pattern
+        is unanchored, the normal "bumpalong"  advance  to  the  next  starting
+        character  then happens. Backtracking can occur as usual to the left of
+        (*PRUNE), before it is reached,  or  when  matching  to  the  right  of
+        (*PRUNE),  but  if  there is no match to the right, backtracking cannot
+        cross (*PRUNE). In simple cases, the use of (*PRUNE) is just an  alter-
+        native  to an atomic group or possessive quantifier, but there are some
+        uses of (*PRUNE) that cannot be expressed in any other way.  The behav-
+        iour  of  (*PRUNE:NAME)  is  the  same as (*MARK:NAME)(*PRUNE) when the
+        match fails completely; the name is passed back if this  is  the  final
+        attempt.   (*PRUNE:NAME)  does  not  pass back a name if the match suc-
+        ceeds. In an anchored pattern (*PRUNE) has the same  effect  as  (*COM-
+        MIT).
           (*SKIP)
-        This verb is like (*PRUNE), except that if the pattern  is  unanchored,
+        This  verb, when given without a name, is like (*PRUNE), except that if
-        the  "bumpalong" advance is not to the next character, but to the posi-
+        the pattern is unanchored, the "bumpalong" advance is not to  the  next
-        tion in the subject where (*SKIP) was  encountered.  (*SKIP)  signifies
+        character, but to the position in the subject where (*SKIP) was encoun-
-        that  whatever  text  was  matched leading up to it cannot be part of a
+        tered. (*SKIP) signifies that whatever text was matched leading  up  to
-        successful match. Consider:
+        it cannot be part of a successful match. Consider:
           a+(*SKIP)b
-        If the subject is "aaaac...",  after  the  first  match  attempt  fails
+        If  the  subject  is  "aaaac...",  after  the first match attempt fails
-        (starting  at  the  first  character in the string), the starting point
+        (starting at the first character in the  string),  the  starting  point
         skips on to start the next attempt at "c". Note that a possessive quan-
-        tifer  does not have the same effect as this example; although it would
+        tifer does not have the same effect as this example; although it  would
-        suppress backtracking  during  the  first  match  attempt,  the  second
+        suppress  backtracking  during  the  first  match  attempt,  the second
-        attempt  would  start at the second character instead of skipping on to
+        attempt would start at the second character instead of skipping  on  to
         "c".
-          (*THEN)
+          (*SKIP:NAME)
+        When  (*SKIP) has an associated name, its behaviour is modified. If the
+        following pattern fails to match, the previous path through the pattern
+        is  searched for the most recent (*MARK) that has the same name. If one
+        is found, the "bumpalong" advance is to the subject position that  cor-
+        responds  to  that (*MARK) instead of to where (*SKIP) was encountered.
+        If no (*MARK) with a matching name is found, normal "bumpalong" of  one
+        character happens (the (*SKIP) is ignored).
+          (*THEN) or (*THEN:NAME)
         This verb causes a skip to the next alternation if the rest of the pat-
         tern does not match. That is, it cancels pending backtracking, but only
-        within the current alternation. Its name  comes  from  the  observation
+        within  the  current  alternation.  Its name comes from the observation
         that it can be used for a pattern-based if-then-else block:
           ( COND1 (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ ) ...
-        If  the COND1 pattern matches, FOO is tried (and possibly further items
+        If the COND1 pattern matches, FOO is tried (and possibly further  items
-        after the end of the group if FOO succeeds);  on  failure  the  matcher
+        after  the  end  of  the group if FOO succeeds); on failure the matcher
-        skips  to  the second alternative and tries COND2, without backtracking
+        skips to the second alternative and tries COND2,  without  backtracking
-        into COND1. If (*THEN) is used outside  of  any  alternation,  it  acts
+        into  COND1.  The  behaviour  of  (*THEN:NAME)  is  exactly the same as
-        exactly like (*PRUNE).
+        (*MARK:NAME)(*THEN) if the overall  match  fails.  If  (*THEN)  is  not
+        directly inside an alternation, it acts like (*PRUNE).
  SEE ALSO
-Line 5260 
 AUTHOR
+Line 5393 
 AUTHOR
  REVISION
-        Last updated: 06 March 2010
+        Last updated: 27 March 2010
         Copyright (c) 1997-2010 University of Cambridge.
  ------------------------------------------------------------------------------

 Legend:



Removed from v.507
 


changed lines


 
Added in v.512
 Legend:



Removed from v.507
 


changed lines


 
Added in v.512
-Removed from v.507
+Added in v.512

	ViewVC Help
Powered by ViewVC 1.1.5