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

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

Parent Directory | Revision Log | View Patch Patch

-revision 974 by ph10,
Sat Apr 14 16:16:58 2012 UTC
+revision 975 by ph10,
Sat Jun  2 11:03:06 2012 UTC
 Line 138 
 REVISION
         Last updated: 10 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRE(3)                                                                PCRE(3)
 Line 464 
 REVISION
         Last updated: 14 April 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREBUILD(3)                                                      PCREBUILD(3)
 Line 568 
 UTF-8 and UTF-16 SUPPORT
         tern compiling functions.
         If you set --enable-utf when compiling in an EBCDIC  environment,  PCRE
-        expects its input to be either ASCII or UTF-8 (depending on the runtime
+        expects  its  input  to be either ASCII or UTF-8 (depending on the run-
-        option). It is not possible to support both EBCDIC and UTF-8  codes  in
+        time option). It is not possible to support both EBCDIC and UTF-8 codes
-        the  same  version  of  the  library.  Consequently,  --enable-utf  and
+        in  the  same  version  of  the library. Consequently, --enable-utf and
         --enable-ebcdic are mutually exclusive.
 Line 761 
 CREATING CHARACTER TABLES AT BUILD TIME
         to the configure command, the distributed tables are  no  longer  used.
         Instead,  a  program  called dftables is compiled and run. This outputs
         the source for new set of tables, created in the default locale of your
-        C runtime system. (This method of replacing the tables does not work if
+        C  run-time  system. (This method of replacing the tables does not work
-        you are cross compiling, because dftables is run on the local host.  If
+        if you are cross compiling, because dftables is run on the local  host.
-        you  need  to  create alternative tables when cross compiling, you will
+        If you need to create alternative tables when cross compiling, you will
         have to do so "by hand".)
 Line 860 
 REVISION
         Last updated: 07 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREMATCHING(3)                                                PCREMATCHING(3)
 Line 1067 
 REVISION
         Last updated: 08 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREAPI(3)                                                          PCREAPI(3)
 Line 1311 
 NEWLINES
         feed) character, the two-character sequence CRLF, any of the three pre-
         ceding,  or any Unicode newline sequence. The Unicode newline sequences
         are the three just mentioned, plus the single characters  VT  (vertical
-        tab,  U+000B), FF (formfeed, U+000C), NEL (next line, U+0085), LS (line
+        tab, U+000B), FF (form feed, U+000C), NEL (next line, U+0085), LS (line
         separator, U+2028), and PS (paragraph separator, U+2029).
         Each of the first three conventions is used by at least  one  operating
 Line 1625 
 COMPILING A PATTERN
           PCRE_EXTENDED
-        If  this  bit  is  set,  whitespace  data characters in the pattern are
+        If  this  bit  is  set,  white space data characters in the pattern are
-        totally ignored except when escaped or inside a character class. White-
+        totally ignored except when escaped or inside a character class.  White
         space does not include the VT character (code 11). In addition, charac-
         ters between an unescaped # outside a character class and the next new-
         line,  inclusive,  are  also  ignored.  This is equivalent to Perl's /x
 Line 1642 
 COMPILING A PATTERN
         This option makes it possible to include  comments  inside  complicated
         patterns.   Note,  however,  that this applies only to data characters.
-        Whitespace  characters  may  never  appear  within  special   character
+        White space  characters  may  never  appear  within  special  character
         sequences in a pattern, for example within the sequence (?( that intro-
         duces a conditional subpattern.
 Line 1727 
 COMPILING A PATTERN
         that any of the three preceding sequences should be recognized. Setting
         PCRE_NEWLINE_ANY  specifies that any Unicode newline sequence should be
         recognized. The Unicode newline sequences are the three just mentioned,
-        plus  the  single  characters  VT (vertical tab, U+000B), FF (formfeed,
+        plus  the  single  characters VT (vertical tab, U+000B), FF (form feed,
         U+000C), NEL (next line, U+0085), LS (line separator, U+2028),  and  PS
         (paragraph  separator, U+2029). For the 8-bit library, the last two are
         recognized only in UTF-8 mode.
 Line 1741 
 COMPILING A PATTERN
         cause an error.
         The only time that a line break in a pattern  is  specially  recognized
-        when  compiling  is when PCRE_EXTENDED is set. CR and LF are whitespace
+        when  compiling is when PCRE_EXTENDED is set. CR and LF are white space
         characters, and so are ignored in this mode. Also, an unescaped #  out-
         side  a  character class indicates a comment that lasts until after the
         next line break sequence. In other circumstances, line break  sequences
 Line 1894 
 COMPILATION ERROR CODES
  too many forward references
  disallowed Unicode code point (>= 0xd800 && <= 0xdfff)
  invalid UTF-16 string (specifically UTF-16)
+ name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)
         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 2993 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
+Line 2994 
 MATCHING A PATTERN: THE TRADITIONAL FUNC
         for the just-in-time processing stack is  not  large  enough.  See  the
         pcrejit documentation for more details.
-          PCRE_ERROR_BADMODE (-28)
+          PCRE_ERROR_BADMODE        (-28)
         This error is given if a pattern that was compiled by the 8-bit library
         is passed to a 16-bit library function, or vice versa.
-          PCRE_ERROR_BADENDIANNESS (-29)
+          PCRE_ERROR_BADENDIANNESS  (-29)
         This error is given if  a  pattern  that  was  compiled  and  saved  is
         reloaded  on  a  host  with  different endianness. The utility function
         pcre_pattern_to_host_byte_order() can be used to convert such a pattern
         so that it runs on the new host.
-        Error numbers -16 to -20 and -22 are not used by pcre_exec().
+        Error numbers -16 to -20, -22, and -30 are not used by pcre_exec().
     Reason codes for invalid UTF-8 strings
-Line 3468 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
+Line 3469 
 MATCHING A PATTERN: THE ALTERNATIVE FUNC
         This error is given if the output vector  is  not  large  enough.  This
         should be extremely rare, as a vector of size 1000 is used.
+          PCRE_ERROR_DFA_BADRESTART (-30)
+        When  pcre_dfa_exec()  is called with the PCRE_DFA_RESTART option, some
+        plausibility checks are made on the contents of  the  workspace,  which
+        should  contain  data about the previous partial match. If any of these
+        checks fail, this error is given.
  SEE ALSO
-        pcre16(3),   pcrebuild(3),  pcrecallout(3),  pcrecpp(3)(3),  pcrematch-
+        pcre16(3),  pcrebuild(3),  pcrecallout(3),  pcrecpp(3)(3),   pcrematch-
         ing(3), pcrepartial(3), pcreposix(3), pcreprecompile(3), pcresample(3),
         pcrestack(3).
-Line 3485 
 AUTHOR
+Line 3493 
 AUTHOR
  REVISION
-        Last updated: 14 April 2012
+        Last updated: 04 May 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECALLOUT(3)                                                  PCRECALLOUT(3)
-Line 3687 
 REVISION
+Line 3695 
 REVISION
         Last updated: 08 Janurary 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECOMPAT(3)                                                    PCRECOMPAT(3)
-Line 3777 
 DIFFERENCES BETWEEN PCRE AND PERL
+Line 3785 
 DIFFERENCES BETWEEN PCRE AND PERL
         There is a discussion that explains these differences in more detail in
         the section on recursion differences from Perl in the pcrepattern page.
-.  If  (*THEN)  is present in a group that is called as a subroutine,
+.  If  any of the backtracking control verbs are used in an assertion
-        its action is limited to that group, even if the group does not contain
+        or in a subpattern that is called  as  a  subroutine  (whether  or  not
-        any | characters.
+        recursively),  their effect is confined to that subpattern; it does not
+        extend to the surrounding pattern. This is not always the case in Perl.
+        In  particular,  if  (*THEN)  is present in a group that is called as a
+        subroutine, its action is limited to that group, even if the group does
+        not  contain any | characters. There is one exception to this: the name
+        from a *(MARK), (*PRUNE), or (*THEN) that is encountered in a  success-
+        ful  positive  assertion  is passed back when a match succeeds (compare
+        capturing parentheses in assertions). Note that  such  subpatterns  are
+        processed as anchored at the point where they are tested.
 .  There are some differences that are concerned with the settings of
         captured strings when part of  a  pattern  is  repeated.  For  example,
-Line 3799 
 DIFFERENCES BETWEEN PCRE AND PERL
+Line 3815 
 DIFFERENCES BETWEEN PCRE AND PERL
 .  Perl  recognizes  comments  in some places that PCRE does not, for
         example, between the ( and ? at the start of a subpattern.  If  the  /x
-        modifier  is set, Perl allows whitespace between ( and ? but PCRE never
+        modifier is set, Perl allows white space between ( and ? but PCRE never
         does, even if the PCRE_EXTENDED option is set.
 . PCRE provides some extensions to the Perl regular expression facil-
-Line 3859 
 AUTHOR
+Line 3875 
 AUTHOR
  REVISION
-        Last updated: 08 Januray 2012
+        Last updated: 01 June 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPATTERN(3)                                                  PCREPATTERN(3)
-Line 4045 
 BACKSLASH
+Line 4061 
 BACKSLASH
         after  a  backslash.  All  other characters (in particular, those whose
         codepoints are greater than 127) are treated as literals.
-        If a pattern is compiled with the PCRE_EXTENDED option,  whitespace  in
+        If a pattern is compiled with the PCRE_EXTENDED option, white space  in
         the  pattern (other than in a character class) and characters between a
         # outside a character class and the next newline are ignored. An escap-
-        ing  backslash  can  be  used to include a whitespace or # character as
+        ing  backslash  can  be used to include a white space or # character as
         part of the pattern.
         If you want to remove the special meaning from a  sequence  of  charac-
-Line 4083 
 BACKSLASH
+Line 4099 
 BACKSLASH
           \a        alarm, that is, the BEL character (hex 07)
           \cx       "control-x", where x is any ASCII character
           \e        escape (hex 1B)
-          \f        formfeed (hex 0C)
+          \f        form feed (hex 0C)
           \n        linefeed (hex 0A)
           \r        carriage return (hex 0D)
           \t        tab (hex 09)
-Line 4212 
 BACKSLASH
+Line 4228 
 BACKSLASH
           \d     any decimal digit
           \D     any character that is not a decimal digit
-          \h     any horizontal whitespace character
+          \h     any horizontal white space character
-          \H     any character that is not a horizontal whitespace character
+          \H     any character that is not a horizontal white space character
-          \s     any whitespace character
+          \s     any white space character
-          \S     any character that is not a whitespace character
+          \S     any character that is not a white space character
-          \v     any vertical whitespace character
+          \v     any vertical white space character
-          \V     any character that is not a vertical whitespace character
+          \V     any character that is not a vertical white space character
           \w     any "word" character
           \W     any "non-word" character
-Line 4297 
 BACKSLASH
+Line 4313 
 BACKSLASH
           U+000A     Linefeed
           U+000B     Vertical tab
-          U+000C     Formfeed
+          U+000C     Form feed
           U+000D     Carriage return
           U+0085     Next line
           U+2028     Line separator
-Line 4317 
 BACKSLASH
+Line 4333 
 BACKSLASH
         This  is  an  example  of an "atomic group", details of which are given
         below.  This particular group matches either the two-character sequence
         CR  followed  by  LF,  or  one  of  the single characters LF (linefeed,
-        U+000A), VT (vertical tab, U+000B), FF (formfeed, U+000C), CR (carriage
+        U+000A), VT (vertical tab, U+000B), FF (form feed,  U+000C),  CR  (car-
-        return, U+000D), or NEL (next line, U+0085). The two-character sequence
+        riage  return,  U+000D),  or NEL (next line, U+0085). The two-character
-        is treated as a single unit that cannot be split.
+        sequence is treated as a single unit that cannot be split.
         In other modes, two additional characters whose codepoints are  greater
         than 255 are added: LS (line separator, U+2028) and PS (paragraph sepa-
-Line 4519 
 BACKSLASH
+Line 4535 
 BACKSLASH
         Xan matches characters that have either the L (letter) or the  N  (num-
         ber)  property. Xps matches the characters tab, linefeed, vertical tab,
-        formfeed, or carriage return, and any other character that  has  the  Z
+        form feed, or carriage return, and any other character that has  the  Z
         (separator) property.  Xsp is the same as Xps, except that vertical tab
         is excluded. Xwd matches the same characters as Xan, plus underscore.
-Line 5484 
 BACK REFERENCES
+Line 5500 
 BACK REFERENCES
         its following a backslash are taken as part of a potential back  refer-
         ence  number.   If  the  pattern continues with a digit character, some
         delimiter must  be  used  to  terminate  the  back  reference.  If  the
-        PCRE_EXTENDED option is set, this can be whitespace. Otherwise, the \g{
+        PCRE_EXTENDED  option  is  set, this can be white space. Otherwise, the
-        syntax or an empty comment (see "Comments" below) can be used.
+        \g{ syntax or an empty comment (see "Comments" below) can be used.
     Recursive back references
-Line 5797 
 CONDITIONAL SUBPATTERNS
+Line 5813 
 CONDITIONAL SUBPATTERNS
         DEFINE  is that it can be used to define subroutines that can be refer-
         enced from elsewhere. (The use of subroutines is described below.)  For
         example,  a  pattern  to match an IPv4 address such as "192.168.23.245"
-        could be written like this (ignore whitespace and line breaks):
+        could be written like this (ignore white space and line breaks):
           (?(DEFINE) (?<byte> 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )
           \b (?&byte) (\.(?&byte)){3} \b
-Line 6188 
 BACKTRACKING CONTROL
+Line 6204 
 BACKTRACKING CONTROL
         that  is  encountered in a successful positive assertion is passed back
         when a match succeeds (compare capturing  parentheses  in  assertions).
         Note that such subpatterns are processed as anchored at the point where
-        they are tested. Note also that Perl's treatment of subroutines is dif-
+        they are tested. Note also that Perl's  treatment  of  subroutines  and
-        ferent in some cases.
+        assertions is different in some cases.
         The  new verbs make use of what was previously invalid syntax: an open-
         ing parenthesis followed by an asterisk. They are generally of the form
         (*VERB)  or (*VERB:NAME). Some may take either form, with differing be-
         haviour, depending on whether or not an argument is present. A name  is
         any sequence of characters that does not include a closing parenthesis.
-        If the name is empty, that is, if the closing  parenthesis  immediately
+        The maximum length of name is 255 in the 8-bit library and 65535 in the
-        follows  the  colon,  the effect is as if the colon were not there. Any
+-bit library. If the name is empty, that is, if the closing parenthe-
-        number of these verbs may occur in a pattern.
+        sis immediately follows the colon, the effect is as if the  colon  were
+        not there. Any number of these verbs may occur in a pattern.
     Optimizations that affect backtracking verbs
-        PCRE contains some optimizations that are used to speed up matching  by
+        PCRE  contains some optimizations that are used to speed up matching by
         running some checks at the start of each match attempt. For example, it
-        may know the minimum length of matching subject, or that  a  particular
+        may  know  the minimum length of matching subject, or that a particular
-        character  must  be present. When one of these optimizations suppresses
+        character must be present. When one of these  optimizations  suppresses
-        the running of a match, any included backtracking verbs  will  not,  of
+        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_com-
+        by  setting  the  PCRE_NO_START_OPTIMIZE  option when calling pcre_com-
         pile() or pcre_exec(), or by starting the pattern with (*NO_START_OPT).
         There is more discussion of this option in the section entitled "Option
         bits for pcre_exec()" in the pcreapi documentation.
-        Experiments  with  Perl  suggest that it too has similar optimizations,
+        Experiments with Perl suggest that it too  has  similar  optimizations,
         sometimes leading to anomalous results.
     Verbs that act immediately
-        The following verbs act as soon as they are encountered. They  may  not
+        The  following  verbs act as soon as they are encountered. They may not
         be followed by a name.
            (*ACCEPT)
-        This  verb causes the match to end successfully, skipping the remainder
+        This verb causes the match to end successfully, skipping the  remainder
-        of the pattern. However, when it is inside a subpattern that is  called
+        of  the pattern. However, when it is inside a subpattern that is called
-        as  a  subroutine, only that subpattern is ended successfully. Matching
+        as a subroutine, only that subpattern is ended  successfully.  Matching
-        then continues at the outer level. If  (*ACCEPT)  is  inside  capturing
+        then  continues  at  the  outer level. If (*ACCEPT) is inside capturing
         parentheses, the data so far is captured. For example:
           A((?:A|B(*ACCEPT)|C)D)
-        This  matches  "AB", "AAD", or "ACD"; when it matches "AB", "B" is cap-
+        This matches "AB", "AAD", or "ACD"; when it matches "AB", "B"  is  cap-
         tured by the outer parentheses.
           (*FAIL) or (*F)
-        This verb causes a matching failure, forcing backtracking to occur.  It
+        This  verb causes a matching failure, forcing backtracking to occur. It
-        is  equivalent to (?!) but easier to read. The Perl documentation notes
+        is equivalent to (?!) but easier to read. The Perl documentation  notes
-        that it is probably useful only when combined  with  (?{})  or  (??{}).
+        that  it  is  probably  useful only when combined with (?{}) or (??{}).
-        Those  are,  of course, Perl features that are not present in PCRE. The
+        Those are, of course, Perl features that are not present in  PCRE.  The
-        nearest equivalent is the callout feature, as for example in this  pat-
+        nearest  equivalent is the callout feature, as for example in this pat-
         tern:
           a+(?C)(*FAIL)
-        A  match  with the string "aaaa" always fails, but the callout is taken
+        A match with the string "aaaa" always fails, but the callout  is  taken
         before each backtrack happens (in this example, 10 times).
     Recording which path was taken
-        There is one verb whose main purpose  is  to  track  how  a  match  was
+        There  is  one  verb  whose  main  purpose  is to track how a match was
-        arrived  at,  though  it  also  has a secondary use in conjunction with
+        arrived at, though it also has a  secondary  use  in  conjunction  with
         advancing the match starting point (see (*SKIP) below).
           (*MARK:NAME) or (*:NAME)
-        A name is always  required  with  this  verb.  There  may  be  as  many
+        A  name  is  always  required  with  this  verb.  There  may be as many
-        instances  of  (*MARK) as you like in a pattern, and their names do not
+        instances of (*MARK) as you like in a pattern, and their names  do  not
         have to be unique.
-        When a match succeeds, the name of the last-encountered (*MARK) on  the
+        When  a match succeeds, the name of the last-encountered (*MARK) on the
-        matching  path is passed back to the caller as described in the section
+        matching path is passed back to the caller as described in the  section
-        entitled "Extra data for pcre_exec()"  in  the  pcreapi  documentation.
+        entitled  "Extra  data  for  pcre_exec()" in the pcreapi documentation.
-        Here  is  an example of pcretest output, where the /K modifier requests
+        Here is an example of pcretest output, where the /K  modifier  requests
         the retrieval and outputting of (*MARK) data:
             re> /X(*MARK:A)Y|X(*MARK:B)Z/K
-Line 6275 
 BACKTRACKING CONTROL
+Line 6292 
 BACKTRACKING CONTROL
           MK: B
         The (*MARK) name is tagged with "MK:" in this output, and in this exam-
-        ple  it indicates which of the two alternatives matched. This is a more
+        ple it indicates which of the two alternatives matched. This is a  more
-        efficient way of obtaining this information than putting each  alterna-
+        efficient  way of obtaining this information than putting each alterna-
         tive in its own capturing parentheses.
         If (*MARK) is encountered in a positive assertion, its name is recorded
         and passed back if it is the last-encountered. This does not happen for
         negative assertions.
-        After  a  partial match or a failed match, the name of the last encoun-
+        After a partial match or a failed match, the name of the  last  encoun-
         tered (*MARK) in the entire match process is returned. For example:
             re> /X(*MARK:A)Y|X(*MARK:B)Z/K
           data> XP
           No match, mark = B
-        Note that in this unanchored example the  mark  is  retained  from  the
+        Note  that  in  this  unanchored  example the mark is retained from the
         match attempt that started at the letter "X" in the subject. Subsequent
         match attempts starting at "P" and then with an empty string do not get
         as far as the (*MARK) item, but nevertheless do not reset it.
-        If  you  are  interested  in  (*MARK)  values after failed matches, you
+        If you are interested in  (*MARK)  values  after  failed  matches,  you
-        should probably set the PCRE_NO_START_OPTIMIZE option  (see  above)  to
+        should  probably  set  the PCRE_NO_START_OPTIMIZE option (see above) to
         ensure that the match is always attempted.
     Verbs that act after backtracking
         The following verbs do nothing when they are encountered. Matching con-
-        tinues with what follows, but if there is no subsequent match,  causing
+        tinues  with what follows, but if there is no subsequent match, causing
-        a  backtrack  to  the  verb, a failure is forced. That is, backtracking
+        a backtrack to the verb, a failure is  forced.  That  is,  backtracking
-        cannot pass to the left of the verb. However, when one of  these  verbs
+        cannot  pass  to the left of the verb. However, when one of these verbs
-        appears  inside  an atomic group, its effect is confined to that group,
+        appears inside an atomic group, its effect is confined to  that  group,
-        because once the group has been matched, there is never any  backtrack-
+        because  once the group has been matched, there is never any backtrack-
-        ing  into  it.  In  this situation, backtracking can "jump back" to the
+        ing into it. In this situation, backtracking can  "jump  back"  to  the
-        left of the entire atomic group. (Remember also, as stated above,  that
+        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-
+        These verbs differ in exactly what kind of failure  occurs  when  back-
         tracking reaches them.
           (*COMMIT)
-        This verb, which may not be followed by a name, causes the whole  match
+        This  verb, which may not be followed by a name, causes the whole match
         to fail outright if the rest of the pattern does not match. Even if the
         pattern is unanchored, no further attempts to find a match by advancing
         the  starting  point  take  place.  Once  (*COMMIT)  has  been  passed,
-        pcre_exec() is committed to finding a match  at  the  current  starting
+        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
+        This matches "xxaab" but not "aacaab". It can be thought of as  a  kind
         of dynamic anchor, or "I've started, so I must finish." The name of the
-        most  recently passed (*MARK) in the path is passed back when (*COMMIT)
+        most recently passed (*MARK) in the path is passed back when  (*COMMIT)
         forces a match failure.
-        Note that (*COMMIT) at the start of a pattern is not  the  same  as  an
+        Note  that  (*COMMIT)  at  the start of a pattern is not the same as an
-        anchor,  unless  PCRE's start-of-match optimizations are turned off, as
+        anchor, unless PCRE's start-of-match optimizations are turned  off,  as
         shown in this pcretest example:
             re> /(*COMMIT)abc/
-Line 6340 
 BACKTRACKING CONTROL
+Line 6357 
 BACKTRACKING CONTROL
           xyzabc\Y
           No match
-        PCRE knows that any match must start  with  "a",  so  the  optimization
+        PCRE  knows  that  any  match  must start with "a", so the optimization
-        skips  along the subject to "a" before running the first match attempt,
+        skips along the subject to "a" before running the first match  attempt,
-        which succeeds. When the optimization is disabled by the \Y  escape  in
+        which  succeeds.  When the optimization is disabled by the \Y escape in
         the second subject, the match starts at "x" and so the (*COMMIT) causes
         it to fail without trying any other starting points.
           (*PRUNE) or (*PRUNE:NAME)
-        This verb causes the match to fail at the current starting position  in
+        This  verb causes the match to fail at the current starting position in
-        the  subject  if the rest of the pattern does not match. If the pattern
+        the subject if the rest of the pattern does not match. If  the  pattern
-        is unanchored, the normal "bumpalong"  advance  to  the  next  starting
+        is  unanchored,  the  normal  "bumpalong"  advance to the next starting
-        character  then happens. Backtracking can occur as usual to the left of
+        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),  before  it  is  reached,  or  when  matching to the right of
-        (*PRUNE),  but  if  there is no match to the right, backtracking cannot
+        (*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-
+        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
+        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). In an
+        iour of (*PRUNE:NAME)  is  the  same  as  (*MARK:NAME)(*PRUNE).  In  an
         anchored pattern (*PRUNE) has the same effect as (*COMMIT).
           (*SKIP)
-        This verb, when given without a name, is like (*PRUNE), except that  if
+        This  verb, when given without a name, is like (*PRUNE), except that if
-        the  pattern  is unanchored, the "bumpalong" advance is not to the next
+        the pattern is unanchored, the "bumpalong" advance is not to  the  next
         character, but to the position in the subject where (*SKIP) was encoun-
-        tered.  (*SKIP)  signifies that whatever text was matched leading up to
+        tered. (*SKIP) signifies that whatever text was matched leading  up  to
         it cannot be part of a successful match. Consider:
           a+(*SKIP)b
-        If the subject is "aaaac...",  after  the  first  match  attempt  fails
+        If  the  subject  is  "aaaac...",  after  the first match attempt fails
-        (starting  at  the  first  character in the string), the starting point
+        (starting at the first character in the  string),  the  starting  point
         skips on to start the next attempt at "c". Note that a possessive quan-
-        tifer  does not have the same effect as this example; although it would
+        tifer does not have the same effect as this example; although it  would
-        suppress backtracking  during  the  first  match  attempt,  the  second
+        suppress  backtracking  during  the  first  match  attempt,  the second
-        attempt  would  start at the second character instead of skipping on to
+        attempt would start at the second character instead of skipping  on  to
         "c".
           (*SKIP:NAME)
-        When (*SKIP) has an associated name, its behaviour is modified. If  the
+        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  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-
+        is found, the "bumpalong" advance is to the subject position that  cor-
-        responds to that (*MARK) instead of to where (*SKIP)  was  encountered.
+        responds  to  that (*MARK) instead of to where (*SKIP) was encountered.
         If no (*MARK) with a matching name is found, the (*SKIP) is ignored.
           (*THEN) or (*THEN:NAME)
-        This  verb  causes a skip to the next innermost alternative if the rest
+        This verb causes a skip to the next innermost alternative if  the  rest
-        of the pattern does not match. That is, it cancels  pending  backtrack-
+        of  the  pattern does not match. That is, it cancels pending backtrack-
-        ing,  but  only within the current alternative. Its name comes from the
+        ing, but only within the current alternative. Its name comes  from  the
         observation that it can be used for a pattern-based if-then-else block:
           ( COND1 (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ ) ...
-        If the COND1 pattern matches, FOO is tried (and possibly further  items
+        If  the COND1 pattern matches, FOO is tried (and possibly further items
-        after  the  end  of the group if FOO succeeds); on failure, the matcher
+        after the end of the group if FOO succeeds); on  failure,  the  matcher
-        skips to the second alternative and tries COND2,  without  backtracking
+        skips  to  the second alternative and tries COND2, without backtracking
-        into  COND1.  The  behaviour  of  (*THEN:NAME)  is  exactly the same as
+        into COND1. The behaviour  of  (*THEN:NAME)  is  exactly  the  same  as
-        (*MARK:NAME)(*THEN).  If (*THEN) is not inside an alternation, it  acts
+        (*MARK:NAME)(*THEN).   If (*THEN) is not inside an alternation, it acts
         like (*PRUNE).
-        Note  that  a  subpattern that does not contain a | character is just a
+        Note that a subpattern that does not contain a | character  is  just  a
-        part of the enclosing alternative; it is not a nested alternation  with
+        part  of the enclosing alternative; it is not a nested alternation with
-        only  one alternative. The effect of (*THEN) extends beyond such a sub-
+        only one alternative. The effect of (*THEN) extends beyond such a  sub-
-        pattern to the enclosing alternative. Consider this pattern,  where  A,
+        pattern  to  the enclosing alternative. Consider this pattern, where A,
         B, etc. are complex pattern fragments that do not contain any | charac-
         ters at this level:
           A (B(*THEN)C) | D
-        If A and B are matched, but there is a failure in C, matching does  not
+        If  A and B are matched, but there is a failure in C, matching does not
         backtrack into A; instead it moves to the next alternative, that is, D.
-        However, if the subpattern containing (*THEN) is given an  alternative,
+        However,  if the subpattern containing (*THEN) is given an alternative,
         it behaves differently:
           A (B(*THEN)C | (*FAIL)) | D
-        The  effect of (*THEN) is now confined to the inner subpattern. After a
+        The effect of (*THEN) is now confined to the inner subpattern. After  a
         failure in C, matching moves to (*FAIL), which causes the whole subpat-
-        tern  to  fail  because  there are no more alternatives to try. In this
+        tern to fail because there are no more alternatives  to  try.  In  this
         case, matching does now backtrack into A.
         Note also that a conditional subpattern is not considered as having two
-        alternatives,  because  only  one  is  ever used. In other words, the |
+        alternatives, because only one is ever used.  In  other  words,  the  |
         character in a conditional subpattern has a different meaning. Ignoring
         white space, consider:
           ^.*? (?(?=a) a | b(*THEN)c )
-        If  the  subject  is  "ba", this pattern does not match. Because .*? is
+        If the subject is "ba", this pattern does not  match.  Because  .*?  is
-        ungreedy, it initially matches zero  characters.  The  condition  (?=a)
+        ungreedy,  it  initially  matches  zero characters. The condition (?=a)
-        then  fails,  the  character  "b"  is  matched, but "c" is not. At this
+        then fails, the character "b" is matched,  but  "c"  is  not.  At  this
-        point, matching does not backtrack to .*? as might perhaps be  expected
+        point,  matching does not backtrack to .*? as might perhaps be expected
-        from  the  presence  of  the | character. The conditional subpattern is
+        from the presence of the | character.  The  conditional  subpattern  is
         part of the single alternative that comprises the whole pattern, and so
-        the  match  fails.  (If  there was a backtrack into .*?, allowing it to
+        the match fails. (If there was a backtrack into  .*?,  allowing  it  to
         match "b", the match would succeed.)
-        The verbs just described provide four different "strengths" of  control
+        The  verbs just described provide four different "strengths" of control
         when subsequent matching fails. (*THEN) is the weakest, carrying on the
-        match at the next alternative. (*PRUNE) comes next, failing  the  match
+        match  at  the next alternative. (*PRUNE) comes next, failing the match
-        at  the  current starting position, but allowing an advance to the next
+        at the current starting position, but allowing an advance to  the  next
-        character (for an unanchored pattern). (*SKIP) is similar, except  that
+        character  (for an unanchored pattern). (*SKIP) is similar, except that
         the advance may be more than one character. (*COMMIT) is the strongest,
         causing the entire match to fail.
-Line 6454 
 BACKTRACKING CONTROL
+Line 6471 
 BACKTRACKING CONTROL
           (A(*COMMIT)B(*THEN)C|D)
-        Once A has matched, PCRE is committed to this  match,  at  the  current
+        Once  A  has  matched,  PCRE is committed to this match, at the current
-        starting  position. If subsequently B matches, but C does not, the nor-
+        starting position. If subsequently B matches, but C does not, the  nor-
         mal (*THEN) action of trying the next alternative (that is, D) does not
         happen because (*COMMIT) overrides.
  SEE ALSO
-        pcreapi(3),  pcrecallout(3),  pcrematching(3),  pcresyntax(3), pcre(3),
+        pcreapi(3), pcrecallout(3),  pcrematching(3),  pcresyntax(3),  pcre(3),
         pcre16(3).
-Line 6475 
 AUTHOR
+Line 6492 
 AUTHOR
  REVISION
-        Last updated: 14 April 2012
+        Last updated: 01 June 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRESYNTAX(3)                                                    PCRESYNTAX(3)
-Line 6505 
 CHARACTERS
+Line 6522 
 CHARACTERS
           \a         alarm, that is, the BEL character (hex 07)
           \cx        "control-x", where x is any ASCII character
           \e         escape (hex 1B)
-          \f         formfeed (hex 0C)
+          \f         form feed (hex 0C)
           \n         newline (hex 0A)
           \r         carriage return (hex 0D)
           \t         tab (hex 09)
-Line 6521 
 CHARACTER TYPES
+Line 6538 
 CHARACTER TYPES
           \C         one data unit, even in UTF mode (best avoided)
           \d         a decimal digit
           \D         a character that is not a decimal digit
-          \h         a horizontal whitespace character
+          \h         a horizontal white space character
-          \H         a character that is not a horizontal whitespace character
+          \H         a character that is not a horizontal white space character
           \N         a character that is not a newline
           \p{xx}     a character with the xx property
           \P{xx}     a character without the xx property
           \R         a newline sequence
-          \s         a whitespace character
+          \s         a white space character
-          \S         a character that is not a whitespace character
+          \S         a character that is not a white space character
-          \v         a vertical whitespace character
+          \v         a vertical white space character
-          \V         a character that is not a vertical whitespace character
+          \V         a character that is not a vertical white space character
           \w         a "word" character
           \W         a "non-word" character
           \X         an extended Unicode sequence
-Line 6634 
 CHARACTER CLASSES
+Line 6651 
 CHARACTER CLASSES
           lower       lower case letter
           print       printing, including space
           punct       printing, excluding alphanumeric
-          space       whitespace
+          space       white space
           upper       upper case letter
           word        same as \w
           xdigit      hexadecimal digit
-Line 6856 
 REVISION
+Line 6873 
 REVISION
         Last updated: 10 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREUNICODE(3)                                                  PCREUNICODE(3)
-Line 6935 
 UNICODE PROPERTY SUPPORT
+Line 6952 
 UNICODE PROPERTY SUPPORT
         If an invalid UTF-8 string is passed to PCRE, an error return is given.
         At compile time, the only additional information is the offset  to  the
-        first  byte of the failing character. The runtime functions pcre_exec()
+        first byte of the failing character. The run-time functions pcre_exec()
         and pcre_dfa_exec() also pass back this information, as well as a  more
         detailed  reason  code if the caller has provided memory in which to do
         this.
-Line 6976 
 UNICODE PROPERTY SUPPORT
+Line 6993 
 UNICODE PROPERTY SUPPORT
         If an invalid UTF-16 string is passed  to  PCRE,  an  error  return  is
         given.  At  compile time, the only additional information is the offset
-        to the first data unit of the failing character. The runtime  functions
+        to the first data unit of the failing character. The run-time functions
         pcre16_exec() and pcre16_dfa_exec() also pass back this information, as
         well as a more detailed reason code if the caller has  provided  memory
         in which to do this.
-Line 7030 
 UNICODE PROPERTY SUPPORT
+Line 7047 
 UNICODE PROPERTY SUPPORT
 .  Similarly,  characters that match the POSIX named character classes
         are all low-valued characters, unless the PCRE_UCP option is set.
-. However, the horizontal and  vertical  whitespace  matching  escapes
+. However, the horizontal and vertical white  space  matching  escapes
         (\h,  \H,  \v, and \V) do match all the appropriate Unicode characters,
         whether or not PCRE_UCP is set.
-Line 7057 
 REVISION
+Line 7074 
 REVISION
         Last updated: 14 April 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREJIT(3)                                                          PCREJIT(3)
-Line 7209 
 UNSUPPORTED OPTIONS AND PATTERN ITEMS
+Line 7226 
 UNSUPPORTED OPTIONS AND PATTERN ITEMS
           \C             match a single byte; not supported in UTF-8 mode
           (?Cn)          callouts
-          (*COMMIT)      )
+          (*PRUNE)       )
-          (*MARK)        )
+          (*SKIP)        ) backtracking control verbs
-          (*PRUNE)       ) the backtracking control verbs
-          (*SKIP)        )
           (*THEN)        )
         Support for some of these may be added in future.
-Line 7441 
 AUTHOR
+Line 7456 
 AUTHOR
  REVISION
-        Last updated: 14 April 2012
+        Last updated: 04 May 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPARTIAL(3)                                                  PCREPARTIAL(3)
-Line 7894 
 REVISION
+Line 7909 
 REVISION
         Last updated: 24 February 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPRECOMPILE(3)                                            PCREPRECOMPILE(3)
-Line 8029 
 REVISION
+Line 8044 
 REVISION
         Last updated: 10 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPERFORM(3)                                                  PCREPERFORM(3)
-Line 8199 
 REVISION
+Line 8214 
 REVISION
         Last updated: 09 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCREPOSIX(3)                                                      PCREPOSIX(3)
-Line 8463 
 REVISION
+Line 8478 
 REVISION
         Last updated: 09 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRECPP(3)                                                          PCRECPP(3)
-Line 8641 
 PASSING MODIFIERS TO THE REGULAR EXPRESS
+Line 8656 
 PASSING MODIFIERS TO THE REGULAR EXPRESS
            PCRE_DOTALL           dot matches newlines        /s
            PCRE_DOLLAR_ENDONLY   $ matches only at end       N/A
            PCRE_EXTRA            strict escape parsing       N/A
-           PCRE_EXTENDED         ignore whitespaces          /x
+           PCRE_EXTENDED         ignore white spaces         /x
            PCRE_UTF8             handles UTF8 chars          built-in
            PCRE_UNGREEDY         reverses * and *?           N/A
            PCRE_NO_AUTO_CAPTURE  disables capturing parens   N/A (*)
-Line 8805 
 REVISION
+Line 8820 
 REVISION
         Last updated: 08 January 2012
  ------------------------------------------------------------------------------
  PCRESAMPLE(3)                                                    PCRESAMPLE(3)
-Line 8929 
 SIZE AND OTHER LIMITATIONS
+Line 8944 
 SIZE AND OTHER LIMITATIONS
         The maximum length of name for a named subpattern is 32 characters, and
         the maximum number of named subpatterns is 10000.
+        The maximum length of a  name  in  a  (*MARK),  (*PRUNE),  (*SKIP),  or
+        (*THEN)  verb  is  255  for  the 8-bit library and 65535 for the 16-bit
+        library.
         The maximum length of a subject string is the largest  positive  number
         that  an integer variable can hold. However, when using the traditional
         matching function, PCRE uses recursion to handle subpatterns and indef-
-Line 8946 
 AUTHOR
+Line 8965 
 AUTHOR
  REVISION
-        Last updated: 08 January 2012
+        Last updated: 04 May 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------
  PCRESTACK(3)                                                      PCRESTACK(3)
-Line 9134 
 REVISION
+Line 9153 
 REVISION
         Last updated: 21 January 2012
         Copyright (c) 1997-2012 University of Cambridge.
  ------------------------------------------------------------------------------

 Legend:



Removed from v.974
 


changed lines


 
Added in v.975
 Legend:



Removed from v.974
 


changed lines


 
Added in v.975
-Removed from v.974
+Added in v.975

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12