/[pcre]/code/trunk/ChangeLog

Diff of /code/trunk/ChangeLog

Parent Directory | Revision Log | View Patch Patch

-revision 349 by ph10,
Wed Jul  2 18:42:11 2008 UTC
+revision 926 by ph10,
Wed Feb 22 15:01:32 2012 UTC
 Line 1
  ChangeLog for PCRE
  ------------------
- Version 8.0 02 Jul-08
+ Version 8.31
+ -----------------------------
+.  Fixing a wrong JIT test case and some compiler warnings.
+.  Removed a bashism from the RunTest script.
+.  Add a cast to pcre_exec.c to fix the warning "unary minus operator applied
+     to unsigned type, result still unsigned" that was given by an MS compiler
+     on encountering the code "-sizeof(xxx)".
+.  Partial matching support is added to the JIT compiler.
+.  Fixed several bugs concerned with partial matching of items that consist
+     of more than one character:
+     (a) /^(..)\1/ did not partially match "aba" because checking references was
+         done on an "all or nothing" basis. This also applied to repeated
+         references.
+     (b) \R did not give a hard partial match if \r was found at the end of the
+         subject.
+     (c) \X did not give a hard partial match after matching one or more
+         characters at the end of the subject.
+     (d) When newline was set to CRLF, a pattern such as /a$/ did not recognize
+         a partial match for the string "\r".
+     (e) When newline was set to CRLF, the metacharacter "." did not recognize
+         a partial match for a CR character at the end of the subject string.
+.  If JIT is requested using /S++ or -s++ (instead of just /S+ or -s+) when
+     running pcretest, the text "(JIT)" added to the output whenever JIT is
+     actually used to run the match.
+.  Individual JIT compile options can be set in pcretest by following -s+[+]
+     or /S+[+] with a digit between 1 and 7.
+.  OP_NOT now supports any UTF character not just single-byte ones.
+ Version 8.30 04-February-2012
+ -----------------------------
+.  Renamed "isnumber" as "is_a_number" because in some Mac environments this
+     name is defined in ctype.h.
+.  Fixed a bug in fixed-length calculation for lookbehinds that would show up
+     only in quite long subpatterns.
+.  Removed the function pcre_info(), which has been obsolete and deprecated
+     since it was replaced by pcre_fullinfo() in February 2000.
+.  For a non-anchored pattern, if (*SKIP) was given with a name that did not
+     match a (*MARK), and the match failed at the start of the subject, a
+     reference to memory before the start of the subject could occur. This bug
+     was introduced by fix 17 of release 8.21.
+.  A reference to an unset group with zero minimum repetition was giving
+     totally wrong answers (in non-JavaScript-compatibility mode). For example,
+     /(another)?(\1?)test/ matched against "hello world test". This bug was
+     introduced in release 8.13.
+.  Add support for 16-bit character strings (a large amount of work involving
+     many changes and refactorings).
+.  RunGrepTest failed on msys because \r\n was replaced by whitespace when the
+     command "pattern=`printf 'xxx\r\njkl'`" was run. The pattern is now taken
+     from a file.
+.  Ovector size of 2 is also supported by JIT based pcre_exec (the ovector size
+     rounding is not applied in this particular case).
+.  The invalid Unicode surrogate codepoints U+D800 to U+DFFF are now rejected
+     if they appear, or are escaped, in patterns.
+. Get rid of a number of -Wunused-but-set-variable warnings.
+. The pattern /(?=(*:x))(q|)/ matches an empty string, and returns the mark
+     "x". The similar pattern /(?=(*:x))((*:y)q|)/ did not return a mark at all.
+     Oddly, Perl behaves the same way. PCRE has been fixed so that this pattern
+     also returns the mark "x". This bug applied to capturing parentheses,
+     non-capturing parentheses, and atomic parentheses. It also applied to some
+     assertions.
+. Stephen Kelly's patch to CMakeLists.txt allows it to parse the version
+     information out of configure.ac instead of relying on pcre.h.generic, which
+     is not stored in the repository.
+. Applied Dmitry V. Levin's patch for a more portable method for linking with
+     -lreadline.
+. ZH added PCRE_CONFIG_JITTARGET; added its output to pcretest -C.
+. Applied Graycode's patch to put the top-level frame on the stack rather
+     than the heap when not using the stack for recursion. This gives a
+     performance improvement in many cases when recursion is not deep.
+. Experimental code added to "pcretest -C" to output the stack frame size.
+ Version 8.21 12-Dec-2011
+ ------------------------
+.  Updating the JIT compiler.
+.  JIT compiler now supports OP_NCREF, OP_RREF and OP_NRREF. New test cases
+     are added as well.
+.  Fix cache-flush issue on PowerPC (It is still an experimental JIT port).
+     PCRE_EXTRA_TABLES is not suported by JIT, and should be checked before
+     calling _pcre_jit_exec. Some extra comments are added.
+.  (*MARK) settings inside atomic groups that do not contain any capturing
+     parentheses, for example, (?>a(*:m)), were not being passed out. This bug
+     was introduced by change 18 for 8.20.
+.  Supporting of \x, \U and \u in JavaScript compatibility mode based on the
+     ECMA-262 standard.
+.  Lookbehinds such as (?<=a{2}b) that contained a fixed repetition were
+     erroneously being rejected as "not fixed length" if PCRE_CASELESS was set.
+     This bug was probably introduced by change 9 of 8.13.
+.  While fixing 6 above, I noticed that a number of other items were being
+     incorrectly rejected as "not fixed length". This arose partly because newer
+     opcodes had not been added to the fixed-length checking code. I have (a)
+     corrected the bug and added tests for these items, and (b) arranged for an
+     error to occur if an unknown opcode is encountered while checking for fixed
+     length instead of just assuming "not fixed length". The items that were
+     rejected were: (*ACCEPT), (*COMMIT), (*FAIL), (*MARK), (*PRUNE), (*SKIP),
+     (*THEN), \h, \H, \v, \V, and single character negative classes with fixed
+     repetitions, e.g. [^a]{3}, with and without PCRE_CASELESS.
+.  A possessively repeated conditional subpattern such as (?(?=c)c|d)++ was
+     being incorrectly compiled and would have given unpredicatble results.
+.  A possessively repeated subpattern with minimum repeat count greater than
+     one behaved incorrectly. For example, (A){2,}+ behaved as if it was
+     (A)(A)++ which meant that, after a subsequent mismatch, backtracking into
+     the first (A) could occur when it should not.
+. Add a cast and remove a redundant test from the code.
+. JIT should use pcre_malloc/pcre_free for allocation.
+. Updated pcre-config so that it no longer shows -L/usr/lib, which seems
+     best practice nowadays, and helps with cross-compiling. (If the exec_prefix
+     is anything other than /usr, -L is still shown).
+. In non-UTF-8 mode, \C is now supported in lookbehinds and DFA matching.
+. Perl does not support \N without a following name in a [] class; PCRE now
+     also gives an error.
+. If a forward reference was repeated with an upper limit of around 2000,
+     it caused the error "internal error: overran compiling workspace". The
+     maximum number of forward references (including repeats) was limited by the
+     internal workspace, and dependent on the LINK_SIZE. The code has been
+     rewritten so that the workspace expands (via pcre_malloc) if necessary, and
+     the default depends on LINK_SIZE. There is a new upper limit (for safety)
+     of around 200,000 forward references. While doing this, I also speeded up
+     the filling in of repeated forward references.
+. A repeated forward reference in a pattern such as (a)(?2){2}(.) was
+     incorrectly expecting the subject to contain another "a" after the start.
+. When (*SKIP:name) is activated without a corresponding (*MARK:name) earlier
+     in the match, the SKIP should be ignored. This was not happening; instead
+     the SKIP was being treated as NOMATCH. For patterns such as
+     /A(*MARK:A)A+(*SKIP:B)Z|AAC/ this meant that the AAC branch was never
+     tested.
+. The behaviour of (*MARK), (*PRUNE), and (*THEN) has been reworked and is
+     now much more compatible with Perl, in particular in cases where the result
+     is a non-match for a non-anchored pattern. For example, if
+     /b(*:m)f|a(*:n)w/ is matched against "abc", the non-match returns the name
+     "m", where previously it did not return a name. A side effect of this
+     change is that for partial matches, the last encountered mark name is
+     returned, as for non matches. A number of tests that were previously not
+     Perl-compatible have been moved into the Perl-compatible test files. The
+     refactoring has had the pleasing side effect of removing one argument from
+     the match() function, thus reducing its stack requirements.
+. If the /S+ option was used in pcretest to study a pattern using JIT,
+     subsequent uses of /S (without +) incorrectly behaved like /S+.
+. Retrieve executable code size support for the JIT compiler and fixing
+     some warnings.
+. A caseless match of a UTF-8 character whose other case uses fewer bytes did
+     not work when the shorter character appeared right at the end of the
+     subject string.
+. Added some (int) casts to non-JIT modules to reduce warnings on 64-bit
+     systems.
+. Added PCRE_INFO_JITSIZE to pass on the value from (21) above, and also
+     output it when the /M option is used in pcretest.
+. The CheckMan script was not being included in the distribution. Also, added
+     an explicit "perl" to run Perl scripts from the PrepareRelease script
+     because this is reportedly needed in Windows.
+. If study data was being save in a file and studying had not found a set of
+     "starts with" bytes for the pattern, the data written to the file (though
+     never used) was taken from uninitialized memory and so caused valgrind to
+     complain.
+. Updated RunTest.bat as provided by Sheri Pierce.
+. Fixed a possible uninitialized memory bug in pcre_jit_compile.c.
+. Computation of memory usage for the table of capturing group names was
+     giving an unnecessarily large value.
+ Version 8.20 21-Oct-2011
+ ------------------------
+.  Change 37 of 8.13 broke patterns like [:a]...[b:] because it thought it had
+     a POSIX class. After further experiments with Perl, which convinced me that
+     Perl has bugs and confusions, a closing square bracket is no longer allowed
+     in a POSIX name. This bug also affected patterns with classes that started
+     with full stops.
+.  If a pattern such as /(a)b|ac/ is matched against "ac", there is no
+     captured substring, but while checking the failing first alternative,
+     substring 1 is temporarily captured. If the output vector supplied to
+     pcre_exec() was not big enough for this capture, the yield of the function
+     was still zero ("insufficient space for captured substrings"). This cannot
+     be totally fixed without adding another stack variable, which seems a lot
+     of expense for a edge case. However, I have improved the situation in cases
+     such as /(a)(b)x|abc/ matched against "abc", where the return code
+     indicates that fewer than the maximum number of slots in the ovector have
+     been set.
+.  Related to (2) above: when there are more back references in a pattern than
+     slots in the output vector, pcre_exec() uses temporary memory during
+     matching, and copies in the captures as far as possible afterwards. It was
+     using the entire output vector, but this conflicts with the specification
+     that only 2/3 is used for passing back captured substrings. Now it uses
+     only the first 2/3, for compatibility. This is, of course, another edge
+     case.
+.  Zoltan Herczeg's just-in-time compiler support has been integrated into the
+     main code base, and can be used by building with --enable-jit. When this is
+     done, pcregrep automatically uses it unless --disable-pcregrep-jit or the
+     runtime --no-jit option is given.
+.  When the number of matches in a pcre_dfa_exec() run exactly filled the
+     ovector, the return from the function was zero, implying that there were
+     other matches that did not fit. The correct "exactly full" value is now
+     returned.
+.  If a subpattern that was called recursively or as a subroutine contained
+     (*PRUNE) or any other control that caused it to give a non-standard return,
+     invalid errors such as "Error -26 (nested recursion at the same subject
+     position)" or even infinite loops could occur.
+.  If a pattern such as /a(*SKIP)c|b(*ACCEPT)|/ was studied, it stopped
+     computing the minimum length on reaching *ACCEPT, and so ended up with the
+     wrong value of 1 rather than 0. Further investigation indicates that
+     computing a minimum subject length in the presence of *ACCEPT is difficult
+     (think back references, subroutine calls), and so I have changed the code
+     so that no minimum is registered for a pattern that contains *ACCEPT.
+.  If (*THEN) was present in the first (true) branch of a conditional group,
+     it was not handled as intended. [But see 16 below.]
+.  Replaced RunTest.bat and CMakeLists.txt with improved versions provided by
+     Sheri Pierce.
+. A pathological pattern such as /(*ACCEPT)a/ was miscompiled, thinking that
+     the first byte in a match must be "a".
+. Change 17 for 8.13 increased the recursion depth for patterns like
+     /a(?:.)*?a/ drastically. I've improved things by remembering whether a
+     pattern contains any instances of (*THEN). If it does not, the old
+     optimizations are restored. It would be nice to do this on a per-group
+     basis, but at the moment that is not feasible.
+. In some environments, the output of pcretest -C is CRLF terminated. This
+     broke RunTest's code that checks for the link size. A single white space
+     character after the value is now allowed for.
+. RunTest now checks for the "fr" locale as well as for "fr_FR" and "french".
+     For "fr", it uses the Windows-specific input and output files.
+. If (*THEN) appeared in a group that was called recursively or as a
+     subroutine, it did not work as intended. [But see next item.]
+. Consider the pattern /A (B(*THEN)C) | D/ where A, B, C, and D are complex
+     pattern fragments (but not containing any | characters). If A and B are
+     matched, but there is a failure in C so that it backtracks to (*THEN), PCRE
+     was behaving differently to Perl. PCRE backtracked into A, but Perl goes to
+     D. In other words, Perl considers parentheses that do not contain any |
+     characters to be part of a surrounding alternative, whereas PCRE was
+     treading (B(*THEN)C) the same as (B(*THEN)C|(*FAIL)) -- which Perl handles
+     differently. PCRE now behaves in the same way as Perl, except in the case
+     of subroutine/recursion calls such as (?1) which have in any case always
+     been different (but PCRE had them first :-).
+. Related to 15 above: Perl does not treat the | in a conditional group as
+     creating alternatives. Such a group is treated in the same way as an
+     ordinary group without any | characters when processing (*THEN). PCRE has
+     been changed to match Perl's behaviour.
+. If a user had set PCREGREP_COLO(U)R to something other than 1:31, the
+     RunGrepTest script failed.
+. Change 22 for version 13 caused atomic groups to use more stack. This is
+     inevitable for groups that contain captures, but it can lead to a lot of
+     stack use in large patterns. The old behaviour has been restored for atomic
+     groups that do not contain any capturing parentheses.
+. If the PCRE_NO_START_OPTIMIZE option was set for pcre_compile(), it did not
+     suppress the check for a minimum subject length at run time. (If it was
+     given to pcre_exec() or pcre_dfa_exec() it did work.)
+. Fixed an ASCII-dependent infelicity in pcretest that would have made it
+     fail to work when decoding hex characters in data strings in EBCDIC
+     environments.
+. It appears that in at least one Mac OS environment, the isxdigit() function
+     is implemented as a macro that evaluates to its argument more than once,
+     contravening the C 90 Standard (I haven't checked a later standard). There
+     was an instance in pcretest which caused it to go wrong when processing
+     \x{...} escapes in subject strings. The has been rewritten to avoid using
+     things like p++ in the argument of isxdigit().
+ Version 8.13 16-Aug-2011
+ ------------------------
+.  The Unicode data tables have been updated to Unicode 6.0.0.
+.  Two minor typos in pcre_internal.h have been fixed.
+.  Added #include <string.h> to pcre_scanner_unittest.cc, pcrecpp.cc, and
+     pcrecpp_unittest.cc. They are needed for strcmp(), memset(), and strchr()
+     in some environments (e.g. Solaris 10/SPARC using Sun Studio 12U2).
+.  There were a number of related bugs in the code for matching backrefences
+     caselessly in UTF-8 mode when codes for the characters concerned were
+     different numbers of bytes. For example, U+023A and U+2C65 are an upper
+     and lower case pair, using 2 and 3 bytes, respectively. The main bugs were:
+     (a) A reference to 3 copies of a 2-byte code matched only 2 of a 3-byte
+     code. (b) A reference to 2 copies of a 3-byte code would not match 2 of a
+-byte code at the end of the subject (it thought there wasn't enough data
+     left).
+.  Comprehensive information about what went wrong is now returned by
+     pcre_exec() and pcre_dfa_exec() when the UTF-8 string check fails, as long
+     as the output vector has at least 2 elements. The offset of the start of
+     the failing character and a reason code are placed in the vector.
+.  When the UTF-8 string check fails for pcre_compile(), the offset that is
+     now returned is for the first byte of the failing character, instead of the
+     last byte inspected. This is an incompatible change, but I hope it is small
+     enough not to be a problem. It makes the returned offset consistent with
+     pcre_exec() and pcre_dfa_exec().
+.  pcretest now gives a text phrase as well as the error number when
+     pcre_exec() or pcre_dfa_exec() fails; if the error is a UTF-8 check
+     failure, the offset and reason code are output.
+.  When \R was used with a maximizing quantifier it failed to skip backwards
+     over a \r\n pair if the subsequent match failed. Instead, it just skipped
+     back over a single character (\n). This seems wrong (because it treated the
+     two characters as a single entity when going forwards), conflicts with the
+     documentation that \R is equivalent to (?>\r\n|\n|...etc), and makes the
+     behaviour of \R* different to (\R)*, which also seems wrong. The behaviour
+     has been changed.
+.  Some internal refactoring has changed the processing so that the handling
+     of the PCRE_CASELESS and PCRE_MULTILINE options is done entirely at compile
+     time (the PCRE_DOTALL option was changed this way some time ago: version
+.7 change 16). This has made it possible to abolish the OP_OPT op code,
+     which was always a bit of a fudge. It also means that there is one less
+     argument for the match() function, which reduces its stack requirements
+     slightly. This change also fixes an incompatibility with Perl: the pattern
+     (?i:([^b]))(?1) should not match "ab", but previously PCRE gave a match.
+. More internal refactoring has drastically reduced the number of recursive
+     calls to match() for possessively repeated groups such as (abc)++ when
+     using pcre_exec().
+. While implementing 10, a number of bugs in the handling of groups were
+     discovered and fixed:
+     (?<=(a)+) was not diagnosed as invalid (non-fixed-length lookbehind).
+     (a|)*(?1) gave a compile-time internal error.
+     ((a|)+)+  did not notice that the outer group could match an empty string.
+     (^a|^)+   was not marked as anchored.
+     (.*a|.*)+ was not marked as matching at start or after a newline.
+. Yet more internal refactoring has removed another argument from the match()
+     function. Special calls to this function are now indicated by setting a
+     value in a variable in the "match data" data block.
+. Be more explicit in pcre_study() instead of relying on "default" for
+     opcodes that mean there is no starting character; this means that when new
+     ones are added and accidentally left out of pcre_study(), testing should
+     pick them up.
+. The -s option of pcretest has been documented for ages as being an old
+     synonym of -m (show memory usage). I have changed it to mean "force study
+     for every regex", that is, assume /S for every regex. This is similar to -i
+     and -d etc. It's slightly incompatible, but I'm hoping nobody is still
+     using it. It makes it easier to run collections of tests with and without
+     study enabled, and thereby test pcre_study() more easily. All the standard
+     tests are now run with and without -s (but some patterns can be marked as
+     "never study" - see 20 below).
+. When (*ACCEPT) was used in a subpattern that was called recursively, the
+     restoration of the capturing data to the outer values was not happening
+     correctly.
+. If a recursively called subpattern ended with (*ACCEPT) and matched an
+     empty string, and PCRE_NOTEMPTY was set, pcre_exec() thought the whole
+     pattern had matched an empty string, and so incorrectly returned a no
+     match.
+. There was optimizing code for the last branch of non-capturing parentheses,
+     and also for the obeyed branch of a conditional subexpression, which used
+     tail recursion to cut down on stack usage. Unfortunately, now that there is
+     the possibility of (*THEN) occurring in these branches, tail recursion is
+     no longer possible because the return has to be checked for (*THEN). These
+     two optimizations have therefore been removed. [But see 8.20/11 above.]
+. If a pattern containing \R was studied, it was assumed that \R always
+     matched two bytes, thus causing the minimum subject length to be
+     incorrectly computed because \R can also match just one byte.
+. If a pattern containing (*ACCEPT) was studied, the minimum subject length
+     was incorrectly computed.
+. If /S is present twice on a test pattern in pcretest input, it now
+     *disables* studying, thereby overriding the use of -s on the command line
+     (see 14 above). This is necessary for one or two tests to keep the output
+     identical in both cases.
+. When (*ACCEPT) was used in an assertion that matched an empty string and
+     PCRE_NOTEMPTY was set, PCRE applied the non-empty test to the assertion.
+. When an atomic group that contained a capturing parenthesis was
+     successfully matched, but the branch in which it appeared failed, the
+     capturing was not being forgotten if a higher numbered group was later
+     captured. For example, /(?>(a))b|(a)c/ when matching "ac" set capturing
+     group 1 to "a", when in fact it should be unset. This applied to multi-
+     branched capturing and non-capturing groups, repeated or not, and also to
+     positive assertions (capturing in negative assertions does not happen
+     in PCRE) and also to nested atomic groups.
+. Add the ++ qualifier feature to pcretest, to show the remainder of the
+     subject after a captured substring, to make it easier to tell which of a
+     number of identical substrings has been captured.
+. The way atomic groups are processed by pcre_exec() has been changed so that
+     if they are repeated, backtracking one repetition now resets captured
+     values correctly. For example, if ((?>(a+)b)+aabab) is matched against
+     "aaaabaaabaabab" the value of captured group 2 is now correctly recorded as
+     "aaa". Previously, it would have been "a". As part of this code
+     refactoring, the way recursive calls are handled has also been changed.
+. If an assertion condition captured any substrings, they were not passed
+     back unless some other capturing happened later. For example, if
+     (?(?=(a))a) was matched against "a", no capturing was returned.
+. When studying a pattern that contained subroutine calls or assertions,
+     the code for finding the minimum length of a possible match was handling
+     direct recursions such as (xxx(?1)|yyy) but not mutual recursions (where
+     group 1 called group 2 while simultaneously a separate group 2 called group
+). A stack overflow occurred in this case. I have fixed this by limiting
+     the recursion depth to 10.
+. Updated RunTest.bat in the distribution to the version supplied by Tom
+     Fortmann. This supports explicit test numbers on the command line, and has
+     argument validation and error reporting.
+. An instance of \X with an unlimited repeat could fail if at any point the
+     first character it looked at was a mark character.
+. Some minor code refactoring concerning Unicode properties and scripts
+     should reduce the stack requirement of match() slightly.
+. Added the '=' option to pcretest to check the setting of unused capturing
+     slots at the end of the pattern, which are documented as being -1, but are
+     not included in the return count.
+. If \k was not followed by a braced, angle-bracketed, or quoted name, PCRE
+     compiled something random. Now it gives a compile-time error (as does
+     Perl).
+. A *MARK encountered during the processing of a positive assertion is now
+     recorded and passed back (compatible with Perl).
+. If --only-matching or --colour was set on a pcregrep call whose pattern
+     had alternative anchored branches, the search for a second match in a line
+     was done as if at the line start. Thus, for example, /^01|^02/ incorrectly
+     matched the line "0102" twice. The same bug affected patterns that started
+     with a backwards assertion. For example /\b01|\b02/ also matched "0102"
+     twice.
+. Previously, PCRE did not allow quantification of assertions. However, Perl
+     does, and because of capturing effects, quantifying parenthesized
+     assertions may at times be useful. Quantifiers are now allowed for
+     parenthesized assertions.
+. A minor code tidy in pcre_compile() when checking options for \R usage.
+. \g was being checked for fancy things in a character class, when it should
+     just be a literal "g".
+. PCRE was rejecting [:a[:digit:]] whereas Perl was not. It seems that the
+     appearance of a nested POSIX class supersedes an apparent external class.
+     For example, [:a[:digit:]b:] matches "a", "b", ":", or a digit. Also,
+     unescaped square brackets may also appear as part of class names. For
+     example, [:a[:abc]b:] gives unknown class "[:abc]b:]". PCRE now behaves
+     more like Perl. (But see 8.20/1 above.)
+. PCRE was giving an error for \N with a braced quantifier such as {1,} (this
+     was because it thought it was \N{name}, which is not supported).
+. Add minix to OS list not supporting the -S option in pcretest.
+. PCRE tries to detect cases of infinite recursion at compile time, but it
+     cannot analyze patterns in sufficient detail to catch mutual recursions
+     such as ((?1))((?2)). There is now a runtime test that gives an error if a
+     subgroup is called recursively as a subpattern for a second time at the
+     same position in the subject string. In previous releases this might have
+     been caught by the recursion limit, or it might have run out of stack.
+. A pattern such as /(?(R)a+|(?R)b)/ is quite safe, as the recursion can
+     happen only once. PCRE was, however incorrectly giving a compile time error
+     "recursive call could loop indefinitely" because it cannot analyze the
+     pattern in sufficient detail. The compile time test no longer happens when
+     PCRE is compiling a conditional subpattern, but actual runaway loops are
+     now caught at runtime (see 40 above).
+. It seems that Perl allows any characters other than a closing parenthesis
+     to be part of the NAME in (*MARK:NAME) and other backtracking verbs. PCRE
+     has been changed to be the same.
+. Updated configure.ac to put in more quoting round AC_LANG_PROGRAM etc. so
+     as not to get warnings when autogen.sh is called. Also changed
+     AC_PROG_LIBTOOL (deprecated) to LT_INIT (the current macro).
+. To help people who use pcregrep to scan files containing exceedingly long
+     lines, the following changes have been made:
+     (a) The default value of the buffer size parameter has been increased from
+K to 20K. (The actual buffer used is three times this size.)
+     (b) The default can be changed by ./configure --with-pcregrep-bufsize when
+         PCRE is built.
+     (c) A --buffer-size=n option has been added to pcregrep, to allow the size
+         to be set at run time.
+     (d) Numerical values in pcregrep options can be followed by K or M, for
+         example --buffer-size=50K.
+     (e) If a line being scanned overflows pcregrep's buffer, an error is now
+         given and the return code is set to 2.
+. Add a pointer to the latest mark to the callout data block.
+. The pattern /.(*F)/, when applied to "abc" with PCRE_PARTIAL_HARD, gave a
+     partial match of an empty string instead of no match. This was specific to
+     the use of ".".
+. The pattern /f.*/8s, when applied to "for" with PCRE_PARTIAL_HARD, gave a
+     complete match instead of a partial match. This bug was dependent on both
+     the PCRE_UTF8 and PCRE_DOTALL options being set.
+. For a pattern such as /\babc|\bdef/ pcre_study() was failing to set up the
+     starting byte set, because \b was not being ignored.
+ Version 8.12 15-Jan-2011
+ ------------------------
+.  Fixed some typos in the markup of the man pages, and wrote a script that
+     checks for such things as part of the documentation building process.
+.  On a big-endian 64-bit system, pcregrep did not correctly process the
+     --match-limit and --recursion-limit options (added for 8.11). In
+     particular, this made one of the standard tests fail. (The integer value
+     went into the wrong half of a long int.)
+.  If the --colour option was given to pcregrep with -v (invert match), it
+     did strange things, either producing crazy output, or crashing. It should,
+     of course, ignore a request for colour when reporting lines that do not
+     match.
+.  Another pcregrep bug caused similar problems if --colour was specified with
+     -M (multiline) and the pattern match finished with a line ending.
+.  In pcregrep, when a pattern that ended with a literal newline sequence was
+     matched in multiline mode, the following line was shown as part of the
+     match. This seems wrong, so I have changed it.
+.  Another pcregrep bug in multiline mode, when --colour was specified, caused
+     the check for further matches in the same line (so they could be coloured)
+     to overrun the end of the current line. If another match was found, it was
+     incorrectly shown (and then shown again when found in the next line).
+.  If pcregrep was compiled under Windows, there was a reference to the
+     function pcregrep_exit() before it was defined. I am assuming this was
+     the cause of the "error C2371: 'pcregrep_exit' : redefinition;" that was
+     reported by a user. I've moved the definition above the reference.
+ Version 8.11 10-Dec-2010
+ ------------------------
+.  (*THEN) was not working properly if there were untried alternatives prior
+     to it in the current branch. For example, in ((a|b)(*THEN)(*F)|c..) it
+     backtracked to try for "b" instead of moving to the next alternative branch
+     at the same level (in this case, to look for "c"). The Perl documentation
+     is clear that when (*THEN) is backtracked onto, it goes to the "next
+     alternative in the innermost enclosing group".
+.  (*COMMIT) was not overriding (*THEN), as it does in Perl. In a pattern
+     such as   (A(*COMMIT)B(*THEN)C|D)  any failure after matching A should
+     result in overall failure. Similarly, (*COMMIT) now overrides (*PRUNE) and
+     (*SKIP), (*SKIP) overrides (*PRUNE) and (*THEN), and (*PRUNE) overrides
+     (*THEN).
+.  If \s appeared in a character class, it removed the VT character from
+     the class, even if it had been included by some previous item, for example
+     in [\x00-\xff\s]. (This was a bug related to the fact that VT is not part
+     of \s, but is part of the POSIX "space" class.)
+.  A partial match never returns an empty string (because you can always
+     match an empty string at the end of the subject); however the checking for
+     an empty string was starting at the "start of match" point. This has been
+     changed to the "earliest inspected character" point, because the returned
+     data for a partial match starts at this character. This means that, for
+     example, /(?<=abc)def/ gives a partial match for the subject "abc"
+     (previously it gave "no match").
+.  Changes have been made to the way PCRE_PARTIAL_HARD affects the matching
+     of $, \z, \Z, \b, and \B. If the match point is at the end of the string,
+     previously a full match would be given. However, setting PCRE_PARTIAL_HARD
+     has an implication that the given string is incomplete (because a partial
+     match is preferred over a full match). For this reason, these items now
+     give a partial match in this situation. [Aside: previously, the one case
+     /t\b/ matched against "cat" with PCRE_PARTIAL_HARD set did return a partial
+     match rather than a full match, which was wrong by the old rules, but is
+     now correct.]
+.  There was a bug in the handling of #-introduced comments, recognized when
+     PCRE_EXTENDED is set, when PCRE_NEWLINE_ANY and PCRE_UTF8 were also set.
+     If a UTF-8 multi-byte character included the byte 0x85 (e.g. +U0445, whose
+     UTF-8 encoding is 0xd1,0x85), this was misinterpreted as a newline when
+     scanning for the end of the comment. (*Character* 0x85 is an "any" newline,
+     but *byte* 0x85 is not, in UTF-8 mode). This bug was present in several
+     places in pcre_compile().
+.  Related to (6) above, when pcre_compile() was skipping #-introduced
+     comments when looking ahead for named forward references to subpatterns,
+     the only newline sequence it recognized was NL. It now handles newlines
+     according to the set newline convention.
+.  SunOS4 doesn't have strerror() or strtoul(); pcregrep dealt with the
+     former, but used strtoul(), whereas pcretest avoided strtoul() but did not
+     cater for a lack of strerror(). These oversights have been fixed.
+.  Added --match-limit and --recursion-limit to pcregrep.
+. Added two casts needed to build with Visual Studio when NO_RECURSE is set.
+. When the -o option was used, pcregrep was setting a return code of 1, even
+     when matches were found, and --line-buffered was not being honoured.
+. Added an optional parentheses number to the -o and --only-matching options
+     of pcregrep.
+. Imitating Perl's /g action for multiple matches is tricky when the pattern
+     can match an empty string. The code to do it in pcretest and pcredemo
+     needed fixing:
+     (a) When the newline convention was "crlf", pcretest got it wrong, skipping
+         only one byte after an empty string match just before CRLF (this case
+         just got forgotten; "any" and "anycrlf" were OK).
+     (b) The pcretest code also had a bug, causing it to loop forever in UTF-8
+         mode when an empty string match preceded an ASCII character followed by
+         a non-ASCII character. (The code for advancing by one character rather
+         than one byte was nonsense.)
+     (c) The pcredemo.c sample program did not have any code at all to handle
+         the cases when CRLF is a valid newline sequence.
+. Neither pcre_exec() nor pcre_dfa_exec() was checking that the value given
+     as a starting offset was within the subject string. There is now a new
+     error, PCRE_ERROR_BADOFFSET, which is returned if the starting offset is
+     negative or greater than the length of the string. In order to test this,
+     pcretest is extended to allow the setting of negative starting offsets.
+. In both pcre_exec() and pcre_dfa_exec() the code for checking that the
+     starting offset points to the beginning of a UTF-8 character was
+     unnecessarily clumsy. I tidied it up.
+. Added PCRE_ERROR_SHORTUTF8 to make it possible to distinguish between a
+     bad UTF-8 sequence and one that is incomplete when using PCRE_PARTIAL_HARD.
+. Nobody had reported that the --include_dir option, which was added in
+     release 7.7 should have been called --include-dir (hyphen, not underscore)
+     for compatibility with GNU grep. I have changed it to --include-dir, but
+     left --include_dir as an undocumented synonym, and the same for
+     --exclude-dir, though that is not available in GNU grep, at least as of
+     release 2.5.4.
+. At a user's suggestion, the macros GETCHAR and friends (which pick up UTF-8
+     characters from a string of bytes) have been redefined so as not to use
+     loops, in order to improve performance in some environments. At the same
+     time, I abstracted some of the common code into auxiliary macros to save
+     repetition (this should not affect the compiled code).
+. If \c was followed by a multibyte UTF-8 character, bad things happened. A
+     compile-time error is now given if \c is not followed by an ASCII
+     character, that is, a byte less than 128. (In EBCDIC mode, the code is
+     different, and any byte value is allowed.)
+. Recognize (*NO_START_OPT) at the start of a pattern to set the PCRE_NO_
+     START_OPTIMIZE option, which is now allowed at compile time - but just
+     passed through to pcre_exec() or pcre_dfa_exec(). This makes it available
+     to pcregrep and other applications that have no direct access to PCRE
+     options. The new /Y option in pcretest sets this option when calling
+     pcre_compile().
+. Change 18 of release 8.01 broke the use of named subpatterns for recursive
+     back references. Groups containing recursive back references were forced to
+     be atomic by that change, but in the case of named groups, the amount of
+     memory required was incorrectly computed, leading to "Failed: internal
+     error: code overflow". This has been fixed.
+. Some patches to pcre_stringpiece.h, pcre_stringpiece_unittest.cc, and
+     pcretest.c, to avoid build problems in some Borland environments.
+ Version 8.10 25-Jun-2010
+ ------------------------
+.  Added support for (*MARK:ARG) and for ARG additions to PRUNE, SKIP, and
+     THEN.
+.  (*ACCEPT) was not working when inside an atomic group.
+.  Inside a character class, \B is treated as a literal by default, but
+     faulted if PCRE_EXTRA is set. This mimics Perl's behaviour (the -w option
+     causes the error). The code is unchanged, but I tidied the documentation.
+.  Inside a character class, PCRE always treated \R and \X as literals,
+     whereas Perl faults them if its -w option is set. I have changed PCRE so
+     that it faults them when PCRE_EXTRA is set.
+.  Added support for \N, which always matches any character other than
+     newline. (It is the same as "." when PCRE_DOTALL is not set.)
+.  When compiling pcregrep with newer versions of gcc which may have
+     FORTIFY_SOURCE set, several warnings "ignoring return value of 'fwrite',
+     declared with attribute warn_unused_result" were given. Just casting the
+     result to (void) does not stop the warnings; a more elaborate fudge is
+     needed. I've used a macro to implement this.
+.  Minor change to pcretest.c to avoid a compiler warning.
+.  Added four artifical Unicode properties to help with an option to make
+     \s etc use properties (see next item). The new properties are: Xan
+     (alphanumeric), Xsp (Perl space), Xps (POSIX space), and Xwd (word).
+.  Added PCRE_UCP to make \b, \d, \s, \w, and certain POSIX character classes
+     use Unicode properties. (*UCP) at the start of a pattern can be used to set
+     this option. Modified pcretest to add /W to test this facility. Added
+     REG_UCP to make it available via the POSIX interface.
+. Added --line-buffered to pcregrep.
+. In UTF-8 mode, if a pattern that was compiled with PCRE_CASELESS was
+     studied, and the match started with a letter with a code point greater than
+whose first byte was different to the first byte of the other case of
+     the letter, the other case of this starting letter was not recognized
+     (#976).
+. If a pattern that was studied started with a repeated Unicode property
+     test, for example, \p{Nd}+, there was the theoretical possibility of
+     setting up an incorrect bitmap of starting bytes, but fortunately it could
+     not have actually happened in practice until change 8 above was made (it
+     added property types that matched character-matching opcodes).
+. pcre_study() now recognizes \h, \v, and \R when constructing a bit map of
+     possible starting bytes for non-anchored patterns.
+. Extended the "auto-possessify" feature of pcre_compile(). It now recognizes
+     \R, and also a number of cases that involve Unicode properties, both
+     explicit and implicit when PCRE_UCP is set.
+. If a repeated Unicode property match (e.g. \p{Lu}*) was used with non-UTF-8
+     input, it could crash or give wrong results if characters with values
+     greater than 0xc0 were present in the subject string. (Detail: it assumed
+     UTF-8 input when processing these items.)
+. Added a lot of (int) casts to avoid compiler warnings in systems where
+     size_t is 64-bit (#991).
+. Added a check for running out of memory when PCRE is compiled with
+     --disable-stack-for-recursion (#990).
+. If the last data line in a file for pcretest does not have a newline on
+     the end, a newline was missing in the output.
+. The default pcre_chartables.c file recognizes only ASCII characters (values
+     less than 128) in its various bitmaps. However, there is a facility for
+     generating tables according to the current locale when PCRE is compiled. It
+     turns out that in some environments, 0x85 and 0xa0, which are Unicode space
+     characters, are recognized by isspace() and therefore were getting set in
+     these tables, and indeed these tables seem to approximate to ISO 8859. This
+     caused a problem in UTF-8 mode when pcre_study() was used to create a list
+     of bytes that can start a match. For \s, it was including 0x85 and 0xa0,
+     which of course cannot start UTF-8 characters. I have changed the code so
+     that only real ASCII characters (less than 128) and the correct starting
+     bytes for UTF-8 encodings are set for characters greater than 127 when in
+     UTF-8 mode. (When PCRE_UCP is set - see 9 above - the code is different
+     altogether.)
+. Added the /T option to pcretest so as to be able to run tests with non-
+     standard character tables, thus making it possible to include the tests
+     used for 19 above in the standard set of tests.
+. A pattern such as (?&t)(?#()(?(DEFINE)(?<t>a)) which has a forward
+     reference to a subpattern the other side of a comment that contains an
+     opening parenthesis caused either an internal compiling error, or a
+     reference to the wrong subpattern.
+ Version 8.02 19-Mar-2010
+ ------------------------
+.  The Unicode data tables have been updated to Unicode 5.2.0.
+.  Added the option --libs-cpp to pcre-config, but only when C++ support is
+     configured.
+.  Updated the licensing terms in the pcregexp.pas file, as agreed with the
+     original author of that file, following a query about its status.
+.  On systems that do not have stdint.h (e.g. Solaris), check for and include
+     inttypes.h instead. This fixes a bug that was introduced by change 8.01/8.
+.  A pattern such as (?&t)*+(?(DEFINE)(?<t>.)) which has a possessive
+     quantifier applied to a forward-referencing subroutine call, could compile
+     incorrect code or give the error "internal error: previously-checked
+     referenced subpattern not found".
+.  Both MS Visual Studio and Symbian OS have problems with initializing
+     variables to point to external functions. For these systems, therefore,
+     pcre_malloc etc. are now initialized to local functions that call the
+     relevant global functions.
+.  There were two entries missing in the vectors called coptable and poptable
+     in pcre_dfa_exec.c. This could lead to memory accesses outsize the vectors.
+     I've fixed the data, and added a kludgy way of testing at compile time that
+     the lengths are correct (equal to the number of opcodes).
+.  Following on from 7, I added a similar kludge to check the length of the
+     eint vector in pcreposix.c.
+.  Error texts for pcre_compile() are held as one long string to avoid too
+     much relocation at load time. To find a text, the string is searched,
+     counting zeros. There was no check for running off the end of the string,
+     which could happen if a new error number was added without updating the
+     string.
+. \K gave a compile-time error if it appeared in a lookbehind assersion.
+. \K was not working if it appeared in an atomic group or in a group that
+     was called as a "subroutine", or in an assertion. Perl 5.11 documents that
+     \K is "not well defined" if used in an assertion. PCRE now accepts it if
+     the assertion is positive, but not if it is negative.
+. Change 11 fortuitously reduced the size of the stack frame used in the
+     "match()" function of pcre_exec.c by one pointer. Forthcoming
+     implementation of support for (*MARK) will need an extra pointer on the
+     stack; I have reserved it now, so that the stack frame size does not
+     decrease.
+. A pattern such as (?P<L1>(?P<L2>0)|(?P>L2)(?P>L1)) in which the only other
+     item in branch that calls a recursion is a subroutine call - as in the
+     second branch in the above example - was incorrectly given the compile-
+     time error "recursive call could loop indefinitely" because pcre_compile()
+     was not correctly checking the subroutine for matching a non-empty string.
+. The checks for overrunning compiling workspace could trigger after an
+     overrun had occurred. This is a "should never occur" error, but it can be
+     triggered by pathological patterns such as hundreds of nested parentheses.
+     The checks now trigger 100 bytes before the end of the workspace.
+. Fix typo in configure.ac: "srtoq" should be "strtoq".
+ Version 8.01 19-Jan-2010
+ ------------------------
+.  If a pattern contained a conditional subpattern with only one branch (in
+     particular, this includes all (*DEFINE) patterns), a call to pcre_study()
+     computed the wrong minimum data length (which is of course zero for such
+     subpatterns). This could cause incorrect "no match" results.
+.  For patterns such as (?i)a(?-i)b|c where an option setting at the start of
+     the pattern is reset in the first branch, pcre_compile() failed with
+     "internal error: code overflow at offset...". This happened only when
+     the reset was to the original external option setting. (An optimization
+     abstracts leading options settings into an external setting, which was the
+     cause of this.)
+.  A pattern such as ^(?!a(*SKIP)b) where a negative assertion contained one
+     of the verbs SKIP, PRUNE, or COMMIT, did not work correctly. When the
+     assertion pattern did not match (meaning that the assertion was true), it
+     was incorrectly treated as false if the SKIP had been reached during the
+     matching. This also applied to assertions used as conditions.
+.  If an item that is not supported by pcre_dfa_exec() was encountered in an
+     assertion subpattern, including such a pattern used as a condition,
+     unpredictable results occurred, instead of the error return
+     PCRE_ERROR_DFA_UITEM.
+.  The C++ GlobalReplace function was not working like Perl for the special
+     situation when an empty string is matched. It now does the fancy magic
+     stuff that is necessary.
+.  In pcre_internal.h, obsolete includes to setjmp.h and stdarg.h have been
+     removed. (These were left over from very, very early versions of PCRE.)
+.  Some cosmetic changes to the code to make life easier when compiling it
+     as part of something else:
+     (a) Change DEBUG to PCRE_DEBUG.
+     (b) In pcre_compile(), rename the member of the "branch_chain" structure
+         called "current" as "current_branch", to prevent a collision with the
+         Linux macro when compiled as a kernel module.
+     (c) In pcre_study(), rename the function set_bit() as set_table_bit(), to
+         prevent a collision with the Linux macro when compiled as a kernel
+         module.
+.  In pcre_compile() there are some checks for integer overflows that used to
+     cast potentially large values to (double). This has been changed to that
+     when building, a check for int64_t is made, and if it is found, it is used
+     instead, thus avoiding the use of floating point arithmetic. (There is no
+     other use of FP in PCRE.) If int64_t is not found, the fallback is to
+     double.
+.  Added two casts to avoid signed/unsigned warnings from VS Studio Express
+(difference between two addresses compared to an unsigned value).
+. Change the standard AC_CHECK_LIB test for libbz2 in configure.ac to a
+     custom one, because of the following reported problem in Windows:
+       - libbz2 uses the Pascal calling convention (WINAPI) for the functions
+           under Win32.
+       - The standard autoconf AC_CHECK_LIB fails to include "bzlib.h",
+           therefore missing the function definition.
+       - The compiler thus generates a "C" signature for the test function.
+       - The linker fails to find the "C" function.
+       - PCRE fails to configure if asked to do so against libbz2.
+. When running libtoolize from libtool-2.2.6b as part of autogen.sh, these
+     messages were output:
+       Consider adding `AC_CONFIG_MACRO_DIR([m4])' to configure.ac and
+       rerunning libtoolize, to keep the correct libtool macros in-tree.
+       Consider adding `-I m4' to ACLOCAL_AMFLAGS in Makefile.am.
+     I have done both of these things.
+. Although pcre_dfa_exec() does not use nearly as much stack as pcre_exec()
+     most of the time, it *can* run out if it is given a pattern that contains a
+     runaway infinite recursion. I updated the discussion in the pcrestack man
+     page.
+. Now that we have gone to the x.xx style of version numbers, the minor
+     version may start with zero. Using 08 or 09 is a bad idea because users
+     might check the value of PCRE_MINOR in their code, and 08 or 09 may be
+     interpreted as invalid octal numbers. I've updated the previous comment in
+     configure.ac, and also added a check that gives an error if 08 or 09 are
+     used.
+. Change 8.00/11 was not quite complete: code had been accidentally omitted,
+     causing partial matching to fail when the end of the subject matched \W
+     in a UTF-8 pattern where \W was quantified with a minimum of 3.
+. There were some discrepancies between the declarations in pcre_internal.h
+     of _pcre_is_newline(), _pcre_was_newline(), and _pcre_valid_utf8() and
+     their definitions. The declarations used "const uschar *" and the
+     definitions used USPTR. Even though USPTR is normally defined as "const
+     unsigned char *" (and uschar is typedeffed as "unsigned char"), it was
+     reported that: "This difference in casting confuses some C++ compilers, for
+     example, SunCC recognizes above declarations as different functions and
+     generates broken code for hbpcre." I have changed the declarations to use
+     USPTR.
+. GNU libtool is named differently on some systems. The autogen.sh script now
+     tries several variants such as glibtoolize (MacOSX) and libtoolize1x
+     (FreeBSD).
+. Applied Craig's patch that fixes an HP aCC compile error in pcre 8.00
+     (strtoXX undefined when compiling pcrecpp.cc). The patch contains this
+     comment: "Figure out how to create a longlong from a string: strtoll and
+     equivalent. It's not enough to call AC_CHECK_FUNCS: hpux has a strtoll, for
+     instance, but it only takes 2 args instead of 3!"
+. A subtle bug concerned with back references has been fixed by a change of
+     specification, with a corresponding code fix. A pattern such as
+     ^(xa|=?\1a)+$ which contains a back reference inside the group to which it
+     refers, was giving matches when it shouldn't. For example, xa=xaaa would
+     match that pattern. Interestingly, Perl (at least up to 5.11.3) has the
+     same bug. Such groups have to be quantified to be useful, or contained
+     inside another quantified group. (If there's no repetition, the reference
+     can never match.) The problem arises because, having left the group and
+     moved on to the rest of the pattern, a later failure that backtracks into
+     the group uses the captured value from the final iteration of the group
+     rather than the correct earlier one. I have fixed this in PCRE by forcing
+     any group that contains a reference to itself to be an atomic group; that
+     is, there cannot be any backtracking into it once it has completed. This is
+     similar to recursive and subroutine calls.
+ Version 8.00 19-Oct-09
+ ----------------------
+.  The table for translating pcre_compile() error codes into POSIX error codes
+     was out-of-date, and there was no check on the pcre_compile() error code
+     being within the table. This could lead to an OK return being given in
+     error.
+.  Changed the call to open a subject file in pcregrep from fopen(pathname,
+     "r") to fopen(pathname, "rb"), which fixed a problem with some of the tests
+     in a Windows environment.
+.  The pcregrep --count option prints the count for each file even when it is
+     zero, as does GNU grep. However, pcregrep was also printing all files when
+     --files-with-matches was added. Now, when both options are given, it prints
+     counts only for those files that have at least one match. (GNU grep just
+     prints the file name in this circumstance, but including the count seems
+     more useful - otherwise, why use --count?) Also ensured that the
+     combination -clh just lists non-zero counts, with no names.
+.  The long form of the pcregrep -F option was incorrectly implemented as
+     --fixed_strings instead of --fixed-strings. This is an incompatible change,
+     but it seems right to fix it, and I didn't think it was worth preserving
+     the old behaviour.
+.  The command line items --regex=pattern and --regexp=pattern were not
+     recognized by pcregrep, which required --regex pattern or --regexp pattern
+     (with a space rather than an '='). The man page documented the '=' forms,
+     which are compatible with GNU grep; these now work.
+.  No libpcreposix.pc file was created for pkg-config; there was just
+     libpcre.pc and libpcrecpp.pc. The omission has been rectified.
+.  Added #ifndef SUPPORT_UCP into the pcre_ucd.c module, to reduce its size
+     when UCP support is not needed, by modifying the Python script that
+     generates it from Unicode data files. This should not matter if the module
+     is correctly used as a library, but I received one complaint about 50K of
+     unwanted data. My guess is that the person linked everything into his
+     program rather than using a library. Anyway, it does no harm.
+.  A pattern such as /\x{123}{2,2}+/8 was incorrectly compiled; the trigger
+     was a minimum greater than 1 for a wide character in a possessive
+     repetition. The same bug could also affect patterns like /(\x{ff}{0,2})*/8
+     which had an unlimited repeat of a nested, fixed maximum repeat of a wide
+     character. Chaos in the form of incorrect output or a compiling loop could
+     result.
+.  The restrictions on what a pattern can contain when partial matching is
+     requested for pcre_exec() have been removed. All patterns can now be
+     partially matched by this function. In addition, if there are at least two
+     slots in the offset vector, the offset of the earliest inspected character
+     for the match and the offset of the end of the subject are set in them when
+     PCRE_ERROR_PARTIAL is returned.
+. Partial matching has been split into two forms: PCRE_PARTIAL_SOFT, which is
+     synonymous with PCRE_PARTIAL, for backwards compatibility, and
+     PCRE_PARTIAL_HARD, which causes a partial match to supersede a full match,
+     and may be more useful for multi-segment matching.
+. Partial matching with pcre_exec() is now more intuitive. A partial match
+     used to be given if ever the end of the subject was reached; now it is
+     given only if matching could not proceed because another character was
+     needed. This makes a difference in some odd cases such as Z(*FAIL) with the
+     string "Z", which now yields "no match" instead of "partial match". In the
+     case of pcre_dfa_exec(), "no match" is given if every matching path for the
+     final character ended with (*FAIL).
+. Restarting a match using pcre_dfa_exec() after a partial match did not work
+     if the pattern had a "must contain" character that was already found in the
+     earlier partial match, unless partial matching was again requested. For
+     example, with the pattern /dog.(body)?/, the "must contain" character is
+     "g". If the first part-match was for the string "dog", restarting with
+     "sbody" failed. This bug has been fixed.
+. The string returned by pcre_dfa_exec() after a partial match has been
+     changed so that it starts at the first inspected character rather than the
+     first character of the match. This makes a difference only if the pattern
+     starts with a lookbehind assertion or \b or \B (\K is not supported by
+     pcre_dfa_exec()). It's an incompatible change, but it makes the two
+     matching functions compatible, and I think it's the right thing to do.
+. Added a pcredemo man page, created automatically from the pcredemo.c file,
+     so that the demonstration program is easily available in environments where
+     PCRE has not been installed from source.
+. Arranged to add -DPCRE_STATIC to cflags in libpcre.pc, libpcreposix.cp,
+     libpcrecpp.pc and pcre-config when PCRE is not compiled as a shared
+     library.
+. Added REG_UNGREEDY to the pcreposix interface, at the request of a user.
+     It maps to PCRE_UNGREEDY. It is not, of course, POSIX-compatible, but it
+     is not the first non-POSIX option to be added. Clearly some people find
+     these options useful.
+. If a caller to the POSIX matching function regexec() passes a non-zero
+     value for nmatch with a NULL value for pmatch, the value of
+     nmatch is forced to zero.
+. RunGrepTest did not have a test for the availability of the -u option of
+     the diff command, as RunTest does. It now checks in the same way as
+     RunTest, and also checks for the -b option.
+. If an odd number of negated classes containing just a single character
+     interposed, within parentheses, between a forward reference to a named
+     subpattern and the definition of the subpattern, compilation crashed with
+     an internal error, complaining that it could not find the referenced
+     subpattern. An example of a crashing pattern is /(?&A)(([^m])(?<A>))/.
+     [The bug was that it was starting one character too far in when skipping
+     over the character class, thus treating the ] as data rather than
+     terminating the class. This meant it could skip too much.]
+. Added PCRE_NOTEMPTY_ATSTART in order to be able to correctly implement the
+     /g option in pcretest when the pattern contains \K, which makes it possible
+     to have an empty string match not at the start, even when the pattern is
+     anchored. Updated pcretest and pcredemo to use this option.
+. If the maximum number of capturing subpatterns in a recursion was greater
+     than the maximum at the outer level, the higher number was returned, but
+     with unset values at the outer level. The correct (outer level) value is
+     now given.
+. If (*ACCEPT) appeared inside capturing parentheses, previous releases of
+     PCRE did not set those parentheses (unlike Perl). I have now found a way to
+     make it do so. The string so far is captured, making this feature
+     compatible with Perl.
+. The tests have been re-organized, adding tests 11 and 12, to make it
+     possible to check the Perl 5.10 features against Perl 5.10.
+. Perl 5.10 allows subroutine calls in lookbehinds, as long as the subroutine
+     pattern matches a fixed length string. PCRE did not allow this; now it
+     does. Neither allows recursion.
+. I finally figured out how to implement a request to provide the minimum
+     length of subject string that was needed in order to match a given pattern.
+     (It was back references and recursion that I had previously got hung up
+     on.) This code has now been added to pcre_study(); it finds a lower bound
+     to the length of subject needed. It is not necessarily the greatest lower
+     bound, but using it to avoid searching strings that are too short does give
+     some useful speed-ups. The value is available to calling programs via
+     pcre_fullinfo().
+. While implementing 25, I discovered to my embarrassment that pcretest had
+     not been passing the result of pcre_study() to pcre_dfa_exec(), so the
+     study optimizations had never been tested with that matching function.
+     Oops. What is worse, even when it was passed study data, there was a bug in
+     pcre_dfa_exec() that meant it never actually used it. Double oops. There
+     were also very few tests of studied patterns with pcre_dfa_exec().
+. If (?| is used to create subpatterns with duplicate numbers, they are now
+     allowed to have the same name, even if PCRE_DUPNAMES is not set. However,
+     on the other side of the coin, they are no longer allowed to have different
+     names, because these cannot be distinguished in PCRE, and this has caused
+     confusion. (This is a difference from Perl.)
+. When duplicate subpattern names are present (necessarily with different
+     numbers, as required by 27 above), and a test is made by name in a
+     conditional pattern, either for a subpattern having been matched, or for
+     recursion in such a pattern, all the associated numbered subpatterns are
+     tested, and the overall condition is true if the condition is true for any
+     one of them. This is the way Perl works, and is also more like the way
+     testing by number works.
+ Version 7.9 11-Apr-09
+ ---------------------
+.  When building with support for bzlib/zlib (pcregrep) and/or readline
+     (pcretest), all targets were linked against these libraries. This included
+     libpcre, libpcreposix, and libpcrecpp, even though they do not use these
+     libraries. This caused unwanted dependencies to be created. This problem
+     has been fixed, and now only pcregrep is linked with bzlib/zlib and only
+     pcretest is linked with readline.
+.  The "typedef int BOOL" in pcre_internal.h that was included inside the
+     "#ifndef FALSE" condition by an earlier change (probably 7.8/18) has been
+     moved outside it again, because FALSE and TRUE are already defined in AIX,
+     but BOOL is not.
+.  The pcre_config() function was treating the PCRE_MATCH_LIMIT and
+     PCRE_MATCH_LIMIT_RECURSION values as ints, when they should be long ints.
+.  The pcregrep documentation said spaces were inserted as well as colons (or
+     hyphens) following file names and line numbers when outputting matching
+     lines. This is not true; no spaces are inserted. I have also clarified the
+     wording for the --colour (or --color) option.
+.  In pcregrep, when --colour was used with -o, the list of matching strings
+     was not coloured; this is different to GNU grep, so I have changed it to be
+     the same.
+.  When --colo(u)r was used in pcregrep, only the first matching substring in
+     each matching line was coloured. Now it goes on to look for further matches
+     of any of the test patterns, which is the same behaviour as GNU grep.
+.  A pattern that could match an empty string could cause pcregrep to loop; it
+     doesn't make sense to accept an empty string match in pcregrep, so I have
+     locked it out (using PCRE's PCRE_NOTEMPTY option). By experiment, this
+     seems to be how GNU grep behaves.
+.  The pattern (?(?=.*b)b|^) was incorrectly compiled as "match must be at
+     start or after a newline", because the conditional assertion was not being
+     correctly handled. The rule now is that both the assertion and what follows
+     in the first alternative must satisfy the test.
+.  If auto-callout was enabled in a pattern with a conditional group whose
+     condition was an assertion, PCRE could crash during matching, both with
+     pcre_exec() and pcre_dfa_exec().
+. The PCRE_DOLLAR_ENDONLY option was not working when pcre_dfa_exec() was
+     used for matching.
+. Unicode property support in character classes was not working for
+     characters (bytes) greater than 127 when not in UTF-8 mode.
+. Added the -M command line option to pcretest.
+. Added the non-standard REG_NOTEMPTY option to the POSIX interface.
+. Added the PCRE_NO_START_OPTIMIZE match-time option.
+. Added comments and documentation about mis-use of no_arg in the C++
+     wrapper.
+. Implemented support for UTF-8 encoding in EBCDIC environments, a patch
+     from Martin Jerabek that uses macro names for all relevant character and
+     string constants.
+. Added to pcre_internal.h two configuration checks: (a) If both EBCDIC and
+     SUPPORT_UTF8 are set, give an error; (b) If SUPPORT_UCP is set without
+     SUPPORT_UTF8, define SUPPORT_UTF8. The "configure" script handles both of
+     these, but not everybody uses configure.
+. A conditional group that had only one branch was not being correctly
+     recognized as an item that could match an empty string. This meant that an
+     enclosing group might also not be so recognized, causing infinite looping
+     (and probably a segfault) for patterns such as ^"((?(?=[a])[^"])|b)*"$
+     with the subject "ab", where knowledge that the repeated group can match
+     nothing is needed in order to break the loop.
+. If a pattern that was compiled with callouts was matched using pcre_dfa_
+     exec(), but without supplying a callout function, matching went wrong.
+. If PCRE_ERROR_MATCHLIMIT occurred during a recursion, there was a memory
+     leak if the size of the offset vector was greater than 30. When the vector
+     is smaller, the saved offsets during recursion go onto a local stack
+     vector, but for larger vectors malloc() is used. It was failing to free
+     when the recursion yielded PCRE_ERROR_MATCH_LIMIT (or any other "abnormal"
+     error, in fact).
+. There was a missing #ifdef SUPPORT_UTF8 round one of the variables in the
+     heapframe that is used only when UTF-8 support is enabled. This caused no
+     problem, but was untidy.
+. Steven Van Ingelgem's patch to CMakeLists.txt to change the name
+     CMAKE_BINARY_DIR to PROJECT_BINARY_DIR so that it works when PCRE is
+     included within another project.
+. Steven Van Ingelgem's patches to add more options to the CMake support,
+     slightly modified by me:
+       (a) PCRE_BUILD_TESTS can be set OFF not to build the tests, including
+           not building pcregrep.
+       (b) PCRE_BUILD_PCREGREP can be see OFF not to build pcregrep, but only
+           if PCRE_BUILD_TESTS is also set OFF, because the tests use pcregrep.
+. Forward references, both numeric and by name, in patterns that made use of
+     duplicate group numbers, could behave incorrectly or give incorrect errors,
+     because when scanning forward to find the reference group, PCRE was not
+     taking into account the duplicate group numbers. A pattern such as
+     ^X(?3)(a)(?|(b)|(q))(Y) is an example.
+. Changed a few more instances of "const unsigned char *" to USPTR, making
+     the feature of a custom pointer more persuasive (as requested by a user).
+. Wrapped the definitions of fileno and isatty for Windows, which appear in
+     pcretest.c, inside #ifndefs, because it seems they are sometimes already
+     pre-defined.
+. Added support for (*UTF8) at the start of a pattern.
+. Arrange for flags added by the "release type" setting in CMake to be shown
+     in the configuration summary.
+ Version 7.8 05-Sep-08
  ---------------------
 .  Replaced UCP searching code with optimized version as implemented for Ad
      Muncher (http://www.admuncher.com/) by Peter Kankowski. This uses a two-
      stage table and inline lookup instead of a function, giving speed ups of 2
      to 5 times on some simple patterns that I tested. Permission was given to
      distribute the MultiStage2.py script that generates the tables (it's not in
      the tarball, but is in the Subversion repository).
+.  Updated the Unicode datatables to Unicode 5.1.0. This adds yet more
+     scripts.
+.  Change 12 for 7.7 introduced a bug in pcre_study() when a pattern contained
+     a group with a zero qualifier. The result of the study could be incorrect,
+     or the function might crash, depending on the pattern.
+.  Caseless matching was not working for non-ASCII characters in back
+     references. For example, /(\x{de})\1/8i was not matching \x{de}\x{fe}.
+     It now works when Unicode Property Support is available.
+.  In pcretest, an escape such as \x{de} in the data was always generating
+     a UTF-8 string, even in non-UTF-8 mode. Now it generates a single byte in
+     non-UTF-8 mode. If the value is greater than 255, it gives a warning about
+     truncation.
+.  Minor bugfix in pcrecpp.cc (change "" == ... to NULL == ...).
+.  Added two (int) casts to pcregrep when printing the difference of two
+     pointers, in case they are 64-bit values.
+.  Added comments about Mac OS X stack usage to the pcrestack man page and to
+     test 2 if it fails.
+.  Added PCRE_CALL_CONVENTION just before the names of all exported functions,
+     and a #define of that name to empty if it is not externally set. This is to
+     allow users of MSVC to set it if necessary.
+. The PCRE_EXP_DEFN macro which precedes exported functions was missing from
+     the convenience functions in the pcre_get.c source file.
+. An option change at the start of a pattern that had top-level alternatives
+     could cause overwriting and/or a crash. This command provoked a crash in
+     some environments:
+       printf "/(?i)[\xc3\xa9\xc3\xbd]|[\xc3\xa9\xc3\xbdA]/8\n" | pcretest
+     This potential security problem was recorded as CVE-2008-2371.
+. For a pattern where the match had to start at the beginning or immediately
+     after a newline (e.g /.*anything/ without the DOTALL flag), pcre_exec() and
+     pcre_dfa_exec() could read past the end of the passed subject if there was
+     no match. To help with detecting such bugs (e.g. with valgrind), I modified
+     pcretest so that it places the subject at the end of its malloc-ed buffer.
+. The change to pcretest in 12 above threw up a couple more cases when pcre_
+     exec() might read past the end of the data buffer in UTF-8 mode.
+. A similar bug to 7.3/2 existed when the PCRE_FIRSTLINE option was set and
+     the data contained the byte 0x85 as part of a UTF-8 character within its
+     first line. This applied both to normal and DFA matching.
+. Lazy qualifiers were not working in some cases in UTF-8 mode. For example,
+     /^[^d]*?$/8 failed to match "abc".
+. Added a missing copyright notice to pcrecpp_internal.h.
+. Make it more clear in the documentation that values returned from
+     pcre_exec() in ovector are byte offsets, not character counts.
+. Tidied a few places to stop certain compilers from issuing warnings.
+. Updated the Virtual Pascal + BCC files to compile the latest v7.7, as
+     supplied by Stefan Weber. I made a further small update for 7.8 because
+     there is a change of source arrangements: the pcre_searchfuncs.c module is
+     replaced by pcre_ucd.c.
  Version 7.7 07-May-08

 Legend:



Removed from v.349
 


changed lines


 
Added in v.926
 Legend:



Removed from v.349
 


changed lines


 
Added in v.926
-Removed from v.349
+Added in v.926

	ViewVC Help
Powered by ViewVC 1.1.5