/[pcre]/code/trunk/ChangeLog

Diff of /code/trunk/ChangeLog

Parent Directory | Revision Log | View Patch Patch

-revision 608 by ph10,
Sun Jun 12 16:25:55 2011 UTC
+revision 1488 by ph10,
Wed Jun 18 18:38:00 2014 UTC
 Line 1
  ChangeLog for PCRE
  ------------------
- Version 8.13 30-Apr-2011
+ Version 8.36 xx-xxx-2014
+ ------------------------
+.  Got rid of some compiler warnings in the C++ modules that were shown up by
+     -Wmissing-field-initializers and -Wunused-parameter.
+.  The tests for quantifiers being too big (greater than 65535) were being
+     applied after reading the number, and stupidly assuming that integer
+     overflow would give a negative number. The tests are now applied as the
+     numbers are read.
+.  Tidy code in pcre_exec.c where two branches that used to be different are
+     now the same.
+.  The JIT compiler did not generate match limit checks for certain
+     bracketed expressions with quantifiers. This may lead to exponential
+     backtracking, instead of returning with PCRE_ERROR_MATCHLIMIT. This
+     issue should be resolved now.
+.  Fixed an issue, which occures when nested alternatives are optimized
+     with table jumps.
+.  Inserted two casts and changed some ints to size_t in the light of some
+     reported 64-bit compiler warnings (Bugzilla 1477).
+.  Fixed a bug concerned with zero-minimum possessive groups that could match
+     an empty string, which sometimes were behaving incorrectly in the
+     interpreter (though correctly in the JIT matcher). This pcretest input is
+     an example:
+       '\A(?:[^"]++|"(?:[^"]*+|"")*+")++'
+       NON QUOTED "QUOT""ED" AFTER "NOT MATCHED
+     the interpreter was reporting a match of 'NON QUOTED ' only, whereas the
+     JIT matcher and Perl both matched 'NON QUOTED "QUOT""ED" AFTER '. The test
+     for an empty string was breaking the inner loop and carrying on at a lower
+     level, when possessive repeated groups should always return to a higher
+     level as they have no backtrack points in them. The empty string test now
+     occurs at the outer level.
+.  Fixed a bug that was incorrectly auto-possessifying \w+ in the pattern
+     ^\w+(?>\s*)(?<=\w) which caused it not to match "test test".
+.  Give a compile-time error for \o{} (as Perl does) and for \x{} (which Perl
+     doesn't).
+. Change 8.34/15 introduced a bug that caused the amount of memory needed
+     to hold a pattern to be incorrectly computed (too small) when there were
+     named back references to duplicated names. This could cause "internal
+     error: code overflow" or "double free or corruption" or other memory
+     handling errors.
+. When named subpatterns had the same prefixes, back references could be
+     confused. For example, in this pattern:
+       /(?P<Name>a)?(?P<Name2>b)?(?(<Name>)c|d)*l/
+     the reference to 'Name' was incorrectly treated as a reference to a
+     duplicate name.
+. A pattern such as /^s?c/mi8 where the optional character has more than
+     one "other case" was incorrectly compiled such that it would only try to
+     match starting at "c".
+. When a pattern starting with \s was studied, VT was not included in the
+     list of possible starting characters; this should have been part of the
+.34/18 patch.
+. If a character class started [\Qx]... where x is any character, the class
+     was incorrectly terminated at the ].
+. If a pattern that started with a caseless match for a character with more
+     than one "other case" was studied, PCRE did not set up the starting code
+     unit bit map for the list of possible characters. Now it does. This is an
+     optimization improvement, not a bug fix.
+ Version 8.35 04-April-2014
+ --------------------------
+.  A new flag is set, when property checks are present in an XCLASS.
+     When this flag is not set, PCRE can perform certain optimizations
+     such as studying these XCLASS-es.
+.  The auto-possessification of character sets were improved: a normal
+     and an extended character set can be compared now. Furthermore
+     the JIT compiler optimizes more character set checks.
+.  Got rid of some compiler warnings for potentially uninitialized variables
+     that show up only when compiled with -O2.
+.  A pattern such as (?=ab\K) that uses \K in an assertion can set the start
+     of a match later then the end of the match. The pcretest program was not
+     handling the case sensibly - it was outputting from the start to the next
+     binary zero. It now reports this situation in a message, and outputs the
+     text from the end to the start.
+.  Fast forward search is improved in JIT. Instead of the first three
+     characters, any three characters with fixed position can be searched.
+     Search order: first, last, middle.
+.  Improve character range checks in JIT. Characters are read by an inprecise
+     function now, which returns with an unknown value if the character code is
+     above a certain treshold (e.g: 256). The only limitation is that the value
+     must be bigger than the treshold as well. This function is useful, when
+     the characters above the treshold are handled in the same way.
+.  The macros whose names start with RAWUCHAR are placeholders for a future
+     mode in which only the bottom 21 bits of 32-bit data items are used. To
+     make this more memorable for those maintaining the code, the names have
+     been changed to start with UCHAR21, and an extensive comment has been added
+     to their definition.
+.  Add missing (new) files sljitNativeTILEGX.c and sljitNativeTILEGX-encoder.c
+     to the export list in Makefile.am (they were accidentally omitted from the
+.34 tarball).
+.  The informational output from pcretest used the phrase "starting byte set"
+     which is inappropriate for the 16-bit and 32-bit libraries. As the output
+     for "first char" and "need char" really means "non-UTF-char", I've changed
+     "byte" to "char", and slightly reworded the output. The documentation about
+     these values has also been (I hope) clarified.
+. Another JIT related optimization: use table jumps for selecting the correct
+     backtracking path, when more than four alternatives are present inside a
+     bracket.
+. Empty match is not possible, when the minimum length is greater than zero,
+     and there is no \K in the pattern. JIT should avoid empty match checks in
+     such cases.
+. In a caseless character class with UCP support, when a character with more
+     than one alternative case was not the first character of a range, not all
+     the alternative cases were added to the class. For example, s and \x{17f}
+     are both alternative cases for S: the class [RST] was handled correctly,
+     but [R-T] was not.
+. The configure.ac file always checked for pthread support when JIT was
+     enabled. This is not used in Windows, so I have put this test inside a
+     check for the presence of windows.h (which was already tested for).
+. Improve pattern prefix search by a simplified Boyer-Moore algorithm in JIT.
+     The algorithm provides a way to skip certain starting offsets, and usually
+     faster than linear prefix searches.
+. Change 13 for 8.20 updated RunTest to check for the 'fr' locale as well
+     as for 'fr_FR' and 'french'. For some reason, however, it then used the
+     Windows-specific input and output files, which have 'french' screwed in.
+     So this could never have worked. One of the problems with locales is that
+     they aren't always the same. I have now updated RunTest so that it checks
+     the output of the locale test (test 3) against three different output
+     files, and it allows the test to pass if any one of them matches. With luck
+     this should make the test pass on some versions of Solaris where it was
+     failing. Because of the uncertainty, the script did not used to stop if
+     test 3 failed; it now does. If further versions of a French locale ever
+     come to light, they can now easily be added.
+. If --with-pcregrep-bufsize was given a non-integer value such as "50K",
+     there was a message during ./configure, but it did not stop. This now
+     provokes an error. The invalid example in README has been corrected.
+     If a value less than the minimum is given, the minimum value has always
+     been used, but now a warning is given.
+. If --enable-bsr-anycrlf was set, the special 16/32-bit test failed. This
+     was a bug in the test system, which is now fixed. Also, the list of various
+     configurations that are tested for each release did not have one with both
+/32 bits and --enable-bar-anycrlf. It now does.
+. pcretest was missing "-C bsr" for displaying the \R default setting.
+. Little endian PowerPC systems are supported now by the JIT compiler.
+. The fast forward newline mechanism could enter to an infinite loop on
+     certain invalid UTF-8 input. Although we don't support these cases
+     this issue can be fixed by a performance optimization.
+. Change 33 of 8.34 is not sufficient to ensure stack safety because it does
+     not take account if existing stack usage. There is now a new global
+     variable called pcre_stack_guard that can be set to point to an external
+     function to check stack availability. It is called at the start of
+     processing every parenthesized group.
+. A typo in the code meant that in ungreedy mode the max/min qualifier
+     behaved like a min-possessive qualifier, and, for example, /a{1,3}b/U did
+     not match "ab".
+. When UTF was disabled, the JIT program reported some incorrect compile
+     errors. These messages are silenced now.
+. Experimental support for ARM-64 and MIPS-64 has been added to the JIT
+     compiler.
+. Change all the temporary files used in RunGrepTest to be different to those
+     used by RunTest so that the tests can be run simultaneously, for example by
+     "make -j check".
+ Version 8.34 15-December-2013
+ -----------------------------
+.  Add pcre[16|32]_jit_free_unused_memory to forcibly free unused JIT
+     executable memory. Patch inspired by Carsten Klein.
+.  ./configure --enable-coverage defined SUPPORT_GCOV in config.h, although
+     this macro is never tested and has no effect, because the work to support
+     coverage involves only compiling and linking options and special targets in
+     the Makefile. The comment in config.h implied that defining the macro would
+     enable coverage support, which is totally false. There was also support for
+     setting this macro in the CMake files (my fault, I just copied it from
+     configure). SUPPORT_GCOV has now been removed.
+.  Make a small performance improvement in strlen16() and strlen32() in
+     pcretest.
+.  Change 36 for 8.33 left some unreachable statements in pcre_exec.c,
+     detected by the Solaris compiler (gcc doesn't seem to be able to diagnose
+     these cases). There was also one in pcretest.c.
+.  Cleaned up a "may be uninitialized" compiler warning in pcre_exec.c.
+.  In UTF mode, the code for checking whether a group could match an empty
+     string (which is used for indefinitely repeated groups to allow for
+     breaking an infinite loop) was broken when the group contained a repeated
+     negated single-character class with a character that occupied more than one
+     data item and had a minimum repetition of zero (for example, [^\x{100}]* in
+     UTF-8 mode). The effect was undefined: the group might or might not be
+     deemed as matching an empty string, or the program might have crashed.
+.  The code for checking whether a group could match an empty string was not
+     recognizing that \h, \H, \v, \V, and \R must match a character.
+.  Implemented PCRE_INFO_MATCH_EMPTY, which yields 1 if the pattern can match
+     an empty string. If it can, pcretest shows this in its information output.
+.  Fixed two related bugs that applied to Unicode extended grapheme clusters
+     that were repeated with a maximizing qualifier (e.g. \X* or \X{2,5}) when
+     matched by pcre_exec() without using JIT:
+     (a) If the rest of the pattern did not match after a maximal run of
+         grapheme clusters, the code for backing up to try with fewer of them
+         did not always back up over a full grapheme when characters that do not
+         have the modifier quality were involved, e.g. Hangul syllables.
+     (b) If the match point in a subject started with modifier character, and
+         there was no match, the code could incorrectly back up beyond the match
+         point, and potentially beyond the first character in the subject,
+         leading to a segfault or an incorrect match result.
+. A conditional group with an assertion condition could lead to PCRE
+     recording an incorrect first data item for a match if no other first data
+     item was recorded. For example, the pattern (?(?=ab)ab) recorded "a" as a
+     first data item, and therefore matched "ca" after "c" instead of at the
+     start.
+. Change 40 for 8.33 (allowing pcregrep to find empty strings) showed up a
+     bug that caused the command "echo a | ./pcregrep -M '|a'" to loop.
+. The source of pcregrep now includes z/OS-specific code so that it can be
+     compiled for z/OS as part of the special z/OS distribution.
+. Added the -T and -TM options to pcretest.
+. The code in pcre_compile.c for creating the table of named capturing groups
+     has been refactored. Instead of creating the table dynamically during the
+     actual compiling pass, the information is remembered during the pre-compile
+     pass (on the stack unless there are more than 20 named groups, in which
+     case malloc() is used) and the whole table is created before the actual
+     compile happens. This has simplified the code (it is now nearly 150 lines
+     shorter) and prepared the way for better handling of references to groups
+     with duplicate names.
+. A back reference to a named subpattern when there is more than one of the
+     same name now checks them in the order in which they appear in the pattern.
+     The first one that is set is used for the reference. Previously only the
+     first one was inspected. This change makes PCRE more compatible with Perl.
+. Unicode character properties were updated from Unicode 6.3.0.
+. The compile-time code for auto-possessification has been refactored, based
+     on a patch by Zoltan Herczeg. It now happens after instead of during
+     compilation. The code is cleaner, and more cases are handled. The option
+     PCRE_NO_AUTO_POSSESS is added for testing purposes, and the -O and /O
+     options in pcretest are provided to set it. It can also be set by
+     (*NO_AUTO_POSSESS) at the start of a pattern.
+. The character VT has been added to the default ("C" locale) set of
+     characters that match \s and are generally treated as white space,
+     following this same change in Perl 5.18. There is now no difference between
+     "Perl space" and "POSIX space". Whether VT is treated as white space in
+     other locales depends on the locale.
+. The code for checking named groups as conditions, either for being set or
+     for being recursed, has been refactored (this is related to 14 and 15
+     above). Processing unduplicated named groups should now be as fast at
+     numerical groups, and processing duplicated groups should be faster than
+     before.
+. Two patches to the CMake build system, by Alexander Barkov:
+       (1) Replace the "source" command by "." in CMakeLists.txt because
+           "source" is a bash-ism.
+       (2) Add missing HAVE_STDINT_H and HAVE_INTTYPES_H to config-cmake.h.in;
+           without these the CMake build does not work on Solaris.
+. Perl has changed its handling of \8 and \9. If there is no previously
+     encountered capturing group of those numbers, they are treated as the
+     literal characters 8 and 9 instead of a binary zero followed by the
+     literals. PCRE now does the same.
+. Following Perl, added \o{} to specify codepoints in octal, making it
+     possible to specify values greater than 0777 and also making them
+     unambiguous.
+. Perl now gives an error for missing closing braces after \x{... instead of
+     treating the string as literal. PCRE now does the same.
+. RunTest used to grumble if an inappropriate test was selected explicitly,
+     but just skip it when running all tests. This make it awkward to run ranges
+     of tests when one of them was inappropriate. Now it just skips any
+     inappropriate tests, as it always did when running all tests.
+. If PCRE_AUTO_CALLOUT and PCRE_UCP were set for a pattern that contained
+     character types such as \d or \w, too many callouts were inserted, and the
+     data that they returned was rubbish.
+. In UCP mode, \s was not matching two of the characters that Perl matches,
+     namely NEL (U+0085) and MONGOLIAN VOWEL SEPARATOR (U+180E), though they
+     were matched by \h. The code has now been refactored so that the lists of
+     the horizontal and vertical whitespace characters used for \h and \v (which
+     are defined only in one place) are now also used for \s.
+. Add JIT support for the 64 bit TileGX architecture.
+     Patch by Jiong Wang (Tilera Corporation).
+. Possessive quantifiers for classes (both explicit and automatically
+     generated) now use special opcodes instead of wrapping in ONCE brackets.
+. Whereas an item such as A{4}+ ignored the possessivenes of the quantifier
+     (because it's meaningless), this was not happening when PCRE_CASELESS was
+     set. Not wrong, but inefficient.
+. Updated perltest.pl to add /u (force Unicode mode) when /W (use Unicode
+     properties for \w, \d, etc) is present in a test regex. Otherwise if the
+     test contains no characters greater than 255, Perl doesn't realise it
+     should be using Unicode semantics.
+. Upgraded the handling of the POSIX classes [:graph:], [:print:], and
+     [:punct:] when PCRE_UCP is set so as to include the same characters as Perl
+     does in Unicode mode.
+. Added the "forbid" facility to pcretest so that putting tests into the
+     wrong test files can sometimes be quickly detected.
+. There is now a limit (default 250) on the depth of nesting of parentheses.
+     This limit is imposed to control the amount of system stack used at compile
+     time. It can be changed at build time by --with-parens-nest-limit=xxx or
+     the equivalent in CMake.
+. Character classes such as [A-\d] or [a-[:digit:]] now cause compile-time
+     errors. Perl warns for these when in warning mode, but PCRE has no facility
+     for giving warnings.
+. Change 34 for 8.13 allowed quantifiers on assertions, because Perl does.
+     However, this was not working for (?!) because it is optimized to (*FAIL),
+     for which PCRE does not allow quantifiers. The optimization is now disabled
+     when a quantifier follows (?!). I can't see any use for this, but it makes
+     things uniform.
+. Perl no longer allows group names to start with digits, so I have made this
+     change also in PCRE. It simplifies the code a bit.
+. In extended mode, Perl ignores spaces before a + that indicates a
+     possessive quantifier. PCRE allowed a space before the quantifier, but not
+     before the possessive +. It now does.
+. The use of \K (reset reported match start) within a repeated possessive
+     group such as (a\Kb)*+ was not working.
+. Document that the same character tables must be used at compile time and
+     run time, and that the facility to pass tables to pcre_exec() and
+     pcre_dfa_exec() is for use only with saved/restored patterns.
+. Applied Jeff Trawick's patch CMakeLists.txt, which "provides two new
+     features for Builds with MSVC:
+. Support pcre.rc and/or pcreposix.rc (as is already done for MinGW
+        builds). The .rc files can be used to set FileDescription and many other
+        attributes.
+. Add an option (-DINSTALL_MSVC_PDB) to enable installation of .pdb files.
+        This allows higher-level build scripts which want .pdb files to avoid
+        hard-coding the exact files needed."
+. Added support for [[:<:]] and [[:>:]] as used in the BSD POSIX library to
+     mean "start of word" and "end of word", respectively, as a transition aid.
+. A minimizing repeat of a class containing codepoints greater than 255 in
+     non-UTF 16-bit or 32-bit modes caused an internal error when PCRE was
+     compiled to use the heap for recursion.
+. Got rid of some compiler warnings for unused variables when UTF but not UCP
+     is configured.
+ Version 8.33 28-May-2013
+ ------------------------
+.  Added 'U' to some constants that are compared to unsigned integers, to
+     avoid compiler signed/unsigned warnings. Added (int) casts to unsigned
+     variables that are added to signed variables, to ensure the result is
+     signed and can be negated.
+.  Applied patch by Daniel Richard G for quashing MSVC warnings to the
+     CMake config files.
+.  Revise the creation of config.h.generic so that all boolean macros are
+     #undefined, whereas non-boolean macros are #ifndef/#endif-ed. This makes
+     overriding via -D on the command line possible.
+.  Changing the definition of the variable "op" in pcre_exec.c from pcre_uchar
+     to unsigned int is reported to make a quite noticeable speed difference in
+     a specific Windows environment. Testing on Linux did also appear to show
+     some benefit (and it is clearly not harmful). Also fixed the definition of
+     Xop which should be unsigned.
+.  Related to (4), changing the definition of the intermediate variable cc
+     in repeated character loops from pcre_uchar to pcre_uint32 also gave speed
+     improvements.
+.  Fix forward search in JIT when link size is 3 or greater. Also removed some
+     unnecessary spaces.
+.  Adjust autogen.sh and configure.ac to lose warnings given by automake 1.12
+     and later.
+.  Fix two buffer over read issues in 16 and 32 bit modes. Affects JIT only.
+.  Optimizing fast_forward_start_bits in JIT.
+. Adding support for callouts in JIT, and fixing some issues revealed
+     during this work. Namely:
+     (a) Unoptimized capturing brackets incorrectly reset on backtrack.
+     (b) Minimum length was not checked before the matching is started.
+. The value of capture_last that is passed to callouts was incorrect in some
+     cases when there was a capture on one path that was subsequently abandoned
+     after a backtrack. Also, the capture_last value is now reset after a
+     recursion, since all captures are also reset in this case.
+. The interpreter no longer returns the "too many substrings" error in the
+     case when an overflowing capture is in a branch that is subsequently
+     abandoned after a backtrack.
+. In the pathological case when an offset vector of size 2 is used, pcretest
+     now prints out the matched string after a yield of 0 or 1.
+. Inlining subpatterns in recursions, when certain conditions are fulfilled.
+     Only supported by the JIT compiler at the moment.
+. JIT compiler now supports 32 bit Macs thanks to Lawrence Velazquez.
+. Partial matches now set offsets[2] to the "bumpalong" value, that is, the
+     offset of the starting point of the matching process, provided the offsets
+     vector is large enough.
+. The \A escape now records a lookbehind value of 1, though its execution
+     does not actually inspect the previous character. This is to ensure that,
+     in partial multi-segment matching, at least one character from the old
+     segment is retained when a new segment is processed. Otherwise, if there
+     are no lookbehinds in the pattern, \A might match incorrectly at the start
+     of a new segment.
+. Added some #ifdef __VMS code into pcretest.c to help VMS implementations.
+. Redefined some pcre_uchar variables in pcre_exec.c as pcre_uint32; this
+     gives some modest performance improvement in 8-bit mode.
+. Added the PCRE-specific property \p{Xuc} for matching characters that can
+     be expressed in certain programming languages using Universal Character
+     Names.
+. Unicode validation has been updated in the light of Unicode Corrigendum #9,
+     which points out that "non characters" are not "characters that may not
+     appear in Unicode strings" but rather "characters that are reserved for
+     internal use and have only local meaning".
+. When a pattern was compiled with automatic callouts (PCRE_AUTO_CALLOUT) and
+     there was a conditional group that depended on an assertion, if the
+     assertion was false, the callout that immediately followed the alternation
+     in the condition was skipped when pcre_exec() was used for matching.
+. Allow an explicit callout to be inserted before an assertion that is the
+     condition for a conditional group, for compatibility with automatic
+     callouts, which always insert a callout at this point.
+. In 8.31, (*COMMIT) was confined to within a recursive subpattern. Perl also
+     confines (*SKIP) and (*PRUNE) in the same way, and this has now been done.
+. (*PRUNE) is now supported by the JIT compiler.
+. Fix infinite loop when /(?<=(*SKIP)ac)a/ is matched against aa.
+. Fix the case where there are two or more SKIPs with arguments that may be
+     ignored.
+. (*SKIP) is now supported by the JIT compiler.
+. (*THEN) is now supported by the JIT compiler.
+. Update RunTest with additional test selector options.
+. The way PCRE handles backtracking verbs has been changed in two ways.
+     (1) Previously, in something like (*COMMIT)(*SKIP), COMMIT would override
+     SKIP. Now, PCRE acts on whichever backtracking verb is reached first by
+     backtracking. In some cases this makes it more Perl-compatible, but Perl's
+     rather obscure rules do not always do the same thing.
+     (2) Previously, backtracking verbs were confined within assertions. This is
+     no longer the case for positive assertions, except for (*ACCEPT). Again,
+     this sometimes improves Perl compatibility, and sometimes does not.
+. A number of tests that were in test 2 because Perl did things differently
+     have been moved to test 1, because either Perl or PCRE has changed, and
+     these tests are now compatible.
+. Backtracking control verbs are now handled in the same way in JIT and
+     interpreter.
+. An opening parenthesis in a MARK/PRUNE/SKIP/THEN name in a pattern that
+     contained a forward subroutine reference caused a compile error.
+. Auto-detect and optimize limited repetitions in JIT.
+. Implement PCRE_NEVER_UTF to lock out the use of UTF, in particular,
+     blocking (*UTF) etc.
+. In the interpreter, maximizing pattern repetitions for characters and
+     character types now use tail recursion, which reduces stack usage.
+. The value of the max lookbehind was not correctly preserved if a compiled
+     and saved regex was reloaded on a host of different endianness.
+. Implemented (*LIMIT_MATCH) and (*LIMIT_RECURSION). As part of the extension
+     of the compiled pattern block, expand the flags field from 16 to 32 bits
+     because it was almost full.
+. Try madvise first before posix_madvise.
+. Change 7 for PCRE 7.9 made it impossible for pcregrep to find empty lines
+     with a pattern such as ^$. It has taken 4 years for anybody to notice! The
+     original change locked out all matches of empty strings. This has been
+     changed so that one match of an empty string per line is recognized.
+     Subsequent searches on the same line (for colouring or for --only-matching,
+     for example) do not recognize empty strings.
+. Applied a user patch to fix a number of spelling mistakes in comments.
+. Data lines longer than 65536 caused pcretest to crash.
+. Clarified the data type for length and startoffset arguments for pcre_exec
+     and pcre_dfa_exec in the function-specific man pages, where they were
+     explicitly stated to be in bytes, never having been updated. I also added
+     some clarification to the pcreapi man page.
+. A call to pcre_dfa_exec() with an output vector size less than 2 caused
+     a segmentation fault.
+ Version 8.32 30-November-2012
+ -----------------------------
+.  Improved JIT compiler optimizations for first character search and single
+     character iterators.
+.  Supporting IBM XL C compilers for PPC architectures in the JIT compiler.
+     Patch by Daniel Richard G.
+.  Single character iterator optimizations in the JIT compiler.
+.  Improved JIT compiler optimizations for character ranges.
+.  Rename the "leave" variable names to "quit" to improve WinCE compatibility.
+     Reported by Giuseppe D'Angelo.
+.  The PCRE_STARTLINE bit, indicating that a match can occur only at the start
+     of a line, was being set incorrectly in cases where .* appeared inside
+     atomic brackets at the start of a pattern, or where there was a subsequent
+     *PRUNE or *SKIP.
+.  Improved instruction cache flush for POWER/PowerPC.
+     Patch by Daniel Richard G.
+.  Fixed a number of issues in pcregrep, making it more compatible with GNU
+     grep:
+     (a) There is now no limit to the number of patterns to be matched.
+     (b) An error is given if a pattern is too long.
+     (c) Multiple uses of --exclude, --exclude-dir, --include, and --include-dir
+         are now supported.
+     (d) --exclude-from and --include-from (multiple use) have been added.
+     (e) Exclusions and inclusions now apply to all files and directories, not
+         just to those obtained from scanning a directory recursively.
+     (f) Multiple uses of -f and --file-list are now supported.
+     (g) In a Windows environment, the default for -d has been changed from
+         "read" (the GNU grep default) to "skip", because otherwise the presence
+         of a directory in the file list provokes an error.
+     (h) The documentation has been revised and clarified in places.
+.  Improve the matching speed of capturing brackets.
+. Changed the meaning of \X so that it now matches a Unicode extended
+     grapheme cluster.
+. Patch by Daniel Richard G to the autoconf files to add a macro for sorting
+     out POSIX threads when JIT support is configured.
+. Added support for PCRE_STUDY_EXTRA_NEEDED.
+. In the POSIX wrapper regcomp() function, setting re_nsub field in the preg
+     structure could go wrong in environments where size_t is not the same size
+     as int.
+. Applied user-supplied patch to pcrecpp.cc to allow PCRE_NO_UTF8_CHECK to be
+     set.
+. The EBCDIC support had decayed; later updates to the code had included
+     explicit references to (e.g.) \x0a instead of CHAR_LF. There has been a
+     general tidy up of EBCDIC-related issues, and the documentation was also
+     not quite right. There is now a test that can be run on ASCII systems to
+     check some of the EBCDIC-related things (but is it not a full test).
+. The new PCRE_STUDY_EXTRA_NEEDED option is now used by pcregrep, resulting
+     in a small tidy to the code.
+. Fix JIT tests when UTF is disabled and both 8 and 16 bit mode are enabled.
+. If the --only-matching (-o) option in pcregrep is specified multiple
+     times, each one causes appropriate output. For example, -o1 -o2 outputs the
+     substrings matched by the 1st and 2nd capturing parentheses. A separating
+     string can be specified by --om-separator (default empty).
+. Improving the first n character searches.
+. Turn case lists for horizontal and vertical white space into macros so that
+     they are defined only once.
+. This set of changes together give more compatible Unicode case-folding
+     behaviour for characters that have more than one other case when UCP
+     support is available.
+     (a) The Unicode property table now has offsets into a new table of sets of
+         three or more characters that are case-equivalent. The MultiStage2.py
+         script that generates these tables (the pcre_ucd.c file) now scans
+         CaseFolding.txt instead of UnicodeData.txt for character case
+         information.
+     (b) The code for adding characters or ranges of characters to a character
+         class has been abstracted into a generalized function that also handles
+         case-independence. In UTF-mode with UCP support, this uses the new data
+         to handle characters with more than one other case.
+     (c) A bug that is fixed as a result of (b) is that codepoints less than 256
+         whose other case is greater than 256 are now correctly matched
+         caselessly. Previously, the high codepoint matched the low one, but not
+         vice versa.
+     (d) The processing of \h, \H, \v, and \ in character classes now makes use
+         of the new class addition function, using character lists defined as
+         macros alongside the case definitions of 20 above.
+     (e) Caseless back references now work with characters that have more than
+         one other case.
+     (f) General caseless matching of characters with more than one other case
+         is supported.
+. Unicode character properties were updated from Unicode 6.2.0
+. Improved CMake support under Windows. Patch by Daniel Richard G.
+. Add support for 32-bit character strings, and UTF-32
+. Major JIT compiler update (code refactoring and bugfixing).
+     Experimental Sparc 32 support is added.
+. Applied a modified version of Daniel Richard G's patch to create
+     pcre.h.generic and config.h.generic by "make" instead of in the
+     PrepareRelease script.
+. Added a definition for CHAR_NULL (helpful for the z/OS port), and use it in
+     pcre_compile.c when checking for a zero character.
+. Introducing a native interface for JIT. Through this interface, the compiled
+     machine code can be directly executed. The purpose of this interface is to
+     provide fast pattern matching, so several sanity checks are not performed.
+     However, feature tests are still performed. The new interface provides
+.4x speedup compared to the old one.
+. If pcre_exec() or pcre_dfa_exec() was called with a negative value for
+     the subject string length, the error given was PCRE_ERROR_BADOFFSET, which
+     was confusing. There is now a new error PCRE_ERROR_BADLENGTH for this case.
+. In 8-bit UTF-8 mode, pcretest failed to give an error for data codepoints
+     greater than 0x7fffffff (which cannot be represented in UTF-8, even under
+     the "old" RFC 2279). Instead, it ended up passing a negative length to
+     pcre_exec().
+. Add support for GCC's visibility feature to hide internal functions.
+. Running "pcretest -C pcre8" or "pcretest -C pcre16" gave a spurious error
+     "unknown -C option" after outputting 0 or 1.
+. There is now support for generating a code coverage report for the test
+     suite in environments where gcc is the compiler and lcov is installed. This
+     is mainly for the benefit of the developers.
+. If PCRE is built with --enable-valgrind, certain memory regions are marked
+     unaddressable using valgrind annotations, allowing valgrind to detect
+     invalid memory accesses. This is mainly for the benefit of the developers.
+. (*UTF) can now be used to start a pattern in any of the three libraries.
+. Give configure error if --enable-cpp but no C++ compiler found.
+ Version 8.31 06-July-2012
+ -------------------------
+.  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.
+.  (*MARK) control verb is now supported by the JIT compiler.
+. The command "./RunTest list" lists the available tests without actually
+     running any of them. (Because I keep forgetting what they all are.)
+. Add PCRE_INFO_MAXLOOKBEHIND.
+. Applied a (slightly modified) user-supplied patch that improves performance
+     when the heap is used for recursion (compiled with --disable-stack-for-
+     recursion). Instead of malloc and free for each heap frame each time a
+     logical recursion happens, frames are retained on a chain and re-used where
+     possible. This sometimes gives as much as 30% improvement.
+. As documented, (*COMMIT) is now confined to within a recursive subpattern
+     call.
+. As documented, (*COMMIT) is now confined to within a positive assertion.
+. It is now possible to link pcretest with libedit as an alternative to
+     libreadline.
+. (*COMMIT) control verb is now supported by the JIT compiler.
+. The Unicode data tables have been updated to Unicode 6.1.0.
+. Added --file-list option to pcregrep.
+. Added binary file support to pcregrep, including the -a, --binary-files,
+     -I, and --text options.
+. The madvise function is renamed for posix_madvise for QNX compatibility
+     reasons. Fixed by Giuseppe D'Angelo.
+. Fixed a bug for backward assertions with REVERSE 0 in the JIT compiler.
+. Changed the option for creating symbolic links for 16-bit man pages from
+     -s to -sf so that re-installing does not cause issues.
+. Support PCRE_NO_START_OPTIMIZE in JIT as (*MARK) support requires it.
+. Fixed a very old bug in pcretest that caused errors with restarted DFA
+     matches in certain environments (the workspace was not being correctly
+     retained). Also added to pcre_dfa_exec() a simple plausibility check on
+     some of the workspace data at the beginning of a restart.
+. \s*\R was auto-possessifying the \s* when it should not, whereas \S*\R
+     was not doing so when it should - probably a typo introduced by SVN 528
+     (change 8.10/14).
+. When PCRE_UCP was not set, \w+\x{c4} was incorrectly auto-possessifying the
+     \w+ when the character tables indicated that \x{c4} was a word character.
+     There were several related cases, all because the tests for doing a table
+     lookup were testing for characters less than 127 instead of 255.
+. If a pattern contains capturing parentheses that are not used in a match,
+     their slots in the ovector are set to -1. For those that are higher than
+     any matched groups, this happens at the end of processing. In the case when
+     there were back references that the ovector was too small to contain
+     (causing temporary malloc'd memory to be used during matching), and the
+     highest capturing number was not used, memory off the end of the ovector
+     was incorrectly being set to -1. (It was using the size of the temporary
+     memory instead of the true size.)
+. To catch bugs like 27 using valgrind, when pcretest is asked to specify an
+     ovector size, it uses memory at the end of the block that it has got.
+. Check for an overlong MARK name and give an error at compile time. The
+     limit is 255 for the 8-bit library and 65535 for the 16-bit library.
+. JIT compiler update.
+. JIT is now supported on jailbroken iOS devices. Thanks for Ruiger
+     Rill for the patch.
+. Put spaces around SLJIT_PRINT_D in the JIT compiler. Required by CXX11.
+. Variable renamings in the PCRE-JIT compiler. No functionality change.
+. Fixed typos in pcregrep: in two places there was SUPPORT_LIBZ2 instead of
+     SUPPORT_LIBBZ2. This caused a build problem when bzip2 but not gzip (zlib)
+     was enabled.
+. Improve JIT code generation for greedy plus quantifier.
+. When /((?:a?)*)*c/ or /((?>a?)*)*c/ was matched against "aac", it set group
+to "aa" instead of to an empty string. The bug affected repeated groups
+     that could potentially match an empty string.
+. Optimizing single character iterators in JIT.
+. Wide characters specified with \uxxxx in JavaScript mode are now subject to
+     the same checks as \x{...} characters in non-JavaScript mode. Specifically,
+     codepoints that are too big for the mode are faulted, and in a UTF mode,
+     disallowed codepoints are also faulted.
+. If PCRE was compiled with UTF support, in three places in the DFA
+     matcher there was code that should only have been obeyed in UTF mode, but
+     was being obeyed unconditionally. In 8-bit mode this could cause incorrect
+     processing when bytes with values greater than 127 were present. In 16-bit
+     mode the bug would be provoked by values in the range 0xfc00 to 0xdc00. In
+     both cases the values are those that cannot be the first data item in a UTF
+     character. The three items that might have provoked this were recursions,
+     possessively repeated groups, and atomic groups.
+. Ensure that libpcre is explicitly listed in the link commands for pcretest
+     and pcregrep, because some OS require shared objects to be explicitly
+     passed to ld, causing the link step to fail if they are not.
+. There were two incorrect #ifdefs in pcre_study.c, meaning that, in 16-bit
+     mode, patterns that started with \h* or \R* might be incorrectly matched.
+ 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.
-Line 20 
 Version 8.13 30-Apr-2011
+Line 1200 
 Version 8.13 30-Apr-2011
      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 collection of tests with study enabled,
+     using it. It makes it easier to run collections of tests with and without
-     and thereby test pcre_study() more easily.
+     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
  ------------------------
-Line 742 
 Version 7.9 11-Apr-09
+Line 2080 
 Version 7.9 11-Apr-09
 .  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.
+     seems to be how GNU grep behaves. [But see later change 40 for release
+.33.]
 .  The pattern (?(?=.*b)b|^) was incorrectly compiled as "match must be at
      start or after a newline", because the conditional assertion was not being
-Line 985 
 Version 7.7 07-May-08
+Line 2324 
 Version 7.7 07-May-08
      containing () gave an internal compiling error instead of "reference to
      non-existent subpattern". Fortunately, when the pattern did exist, the
      compiled code was correct. (When scanning forwards to check for the
-     existencd of the subpattern, it was treating the data ']' as terminating
+     existence of the subpattern, it was treating the data ']' as terminating
      the class, so got the count wrong. When actually compiling, the reference
      was subsequently set up correctly.)

 Legend:



Removed from v.608
 


changed lines


 
Added in v.1488
 Legend:



Removed from v.608
 


changed lines


 
Added in v.1488
-Removed from v.608
+Added in v.1488

	ViewVC Help
Powered by ViewVC 1.1.5