/[pcre]/code/trunk/ChangeLog
ViewVC logotype

Diff of /code/trunk/ChangeLog

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 600 by ph10, Mon May 9 08:54:11 2011 UTC revision 1530 by zherczeg, Thu Mar 5 08:53:37 2015 UTC
# Line 1  Line 1 
1  ChangeLog for PCRE  ChangeLog for PCRE
2  ------------------  ------------------
3    
4  Version 8.13 30-Apr-2011  Version 8.37 xx-xxx-2015
5    ------------------------
6    
7    1.  When an (*ACCEPT) is triggered inside capturing parentheses, it arranges
8        for those parentheses to be closed with whatever has been captured so far.
9        However, it was failing to mark any other groups between the hightest
10        capture so far and the currrent group as "unset". Thus, the ovector for
11        those groups contained whatever was previously there. An example is the
12        pattern /(x)|((*ACCEPT))/ when matched against "abcd".
13    
14    2.  If an assertion condition was quantified with a minimum of zero (an odd
15        thing to do, but it happened), SIGSEGV or other misbehaviour could occur.
16    
17    3.  If a pattern in pcretest input had the P (POSIX) modifier followed by an
18        unrecognized modifier, a crash could occur.
19    
20    4.  An attempt to do global matching in pcretest with a zero-length ovector
21        caused a crash.
22    
23    5.  Fixed a memory leak during matching that could occur for a subpattern
24        subroutine call (recursive or otherwise) if the number of captured groups
25        that had to be saved was greater than ten.
26    
27    6.  Catch a bad opcode during auto-possessification after compiling a bad UTF
28        string with NO_UTF_CHECK. This is a tidyup, not a bug fix, as passing bad
29        UTF with NO_UTF_CHECK is documented as having an undefined outcome.
30    
31    7.  A UTF pattern containing a "not" match of a non-ASCII character and a
32        subroutine reference could loop at compile time. Example: /[^\xff]((?1))/.
33    
34    8. When a pattern is compiled, it remembers the highest back reference so that
35       when matching, if the ovector is too small, extra memory can be obtained to
36       use instead. A conditional subpattern whose condition is a check on a
37       capture having happened, such as, for example in the pattern
38       /^(?:(a)|b)(?(1)A|B)/, is another kind of back reference, but it was not
39       setting the highest backreference number. This mattered only if pcre_exec()
40       was called with an ovector that was too small to hold the capture, and there
41       was no other kind of back reference (a situation which is probably quite
42       rare). The effect of the bug was that the condition was always treated as
43       FALSE when the capture could not be consulted, leading to a incorrect
44       behaviour by pcre2_match(). This bug has been fixed.
45    
46    9. A reference to a duplicated named group (either a back reference or a test
47       for being set in a conditional) that occurred in a part of the pattern where
48       PCRE_DUPNAMES was not set caused the amount of memory needed for the pattern
49       to be incorrectly calculated, leading to overwriting.
50    
51    10. A mutually recursive set of back references such as (\2)(\1) caused a
52        segfault at study time (while trying to find the minimum matching length).
53        The infinite loop is now broken (with the minimum length unset, that is,
54        zero).
55    
56    11. If an assertion that was used as a condition was quantified with a minimum
57        of zero, matching went wrong. In particular, if the whole group had
58        unlimited repetition and could match an empty string, a segfault was
59        likely. The pattern (?(?=0)?)+ is an example that caused this. Perl allows
60        assertions to be quantified, but not if they are being used as conditions,
61        so the above pattern is faulted by Perl. PCRE has now been changed so that
62        it also rejects such patterns.
63    
64    12. A possessive capturing group such as (a)*+ with a minimum repeat of zero
65        failed to allow the zero-repeat case if pcre2_exec() was called with an
66        ovector too small to capture the group.
67    
68    13. Fixed two bugs in pcretest that were discovered by fuzzing and reported by
69        Red Hat Product Security:
70    
71        (a) A crash if /K and /F were both set with the option to save the compiled
72        pattern.
73    
74        (b) Another crash if the option to print captured substrings in a callout
75        was combined with setting a null ovector, for example \O\C+ as a subject
76        string.
77    
78    14. A pattern such as "((?2){0,1999}())?", which has a group containing a
79        forward reference repeated a large (but limited) number of times within a
80        repeated outer group that has a zero minimum quantifier, caused incorrect
81        code to be compiled, leading to the error "internal error:
82        previously-checked referenced subpattern not found" when an incorrect
83        memory address was read. This bug was reported as "heap overflow",
84        discovered by Kai Lu of Fortinet's FortiGuard Labs.
85    
86    23. A pattern such as "((?+1)(\1))/" containing a forward reference subroutine
87        call within a group that also contained a recursive back reference caused
88        incorrect code to be compiled. This bug was reported as "heap overflow",
89        discovered by Kai Lu of Fortinet's FortiGuard Labs.
90    
91    24. Computing the size of the JIT read-only data in advance has been a source
92        of various issues, and new ones are still appear unfortunately. To fix
93        existing and future issues, size computation is eliminated from the code,
94        and replaced by on-demand memory allocation.
95    
96    
97    Version 8.36 26-September-2014
98    ------------------------------
99    
100    1.  Got rid of some compiler warnings in the C++ modules that were shown up by
101        -Wmissing-field-initializers and -Wunused-parameter.
102    
103    2.  The tests for quantifiers being too big (greater than 65535) were being
104        applied after reading the number, and stupidly assuming that integer
105        overflow would give a negative number. The tests are now applied as the
106        numbers are read.
107    
108    3.  Tidy code in pcre_exec.c where two branches that used to be different are
109        now the same.
110    
111    4.  The JIT compiler did not generate match limit checks for certain
112        bracketed expressions with quantifiers. This may lead to exponential
113        backtracking, instead of returning with PCRE_ERROR_MATCHLIMIT. This
114        issue should be resolved now.
115    
116    5.  Fixed an issue, which occures when nested alternatives are optimized
117        with table jumps.
118    
119    6.  Inserted two casts and changed some ints to size_t in the light of some
120        reported 64-bit compiler warnings (Bugzilla 1477).
121    
122    7.  Fixed a bug concerned with zero-minimum possessive groups that could match
123        an empty string, which sometimes were behaving incorrectly in the
124        interpreter (though correctly in the JIT matcher). This pcretest input is
125        an example:
126    
127          '\A(?:[^"]++|"(?:[^"]*+|"")*+")++'
128          NON QUOTED "QUOT""ED" AFTER "NOT MATCHED
129    
130        the interpreter was reporting a match of 'NON QUOTED ' only, whereas the
131        JIT matcher and Perl both matched 'NON QUOTED "QUOT""ED" AFTER '. The test
132        for an empty string was breaking the inner loop and carrying on at a lower
133        level, when possessive repeated groups should always return to a higher
134        level as they have no backtrack points in them. The empty string test now
135        occurs at the outer level.
136    
137    8.  Fixed a bug that was incorrectly auto-possessifying \w+ in the pattern
138        ^\w+(?>\s*)(?<=\w) which caused it not to match "test test".
139    
140    9.  Give a compile-time error for \o{} (as Perl does) and for \x{} (which Perl
141        doesn't).
142    
143    10. Change 8.34/15 introduced a bug that caused the amount of memory needed
144        to hold a pattern to be incorrectly computed (too small) when there were
145        named back references to duplicated names. This could cause "internal
146        error: code overflow" or "double free or corruption" or other memory
147        handling errors.
148    
149    11. When named subpatterns had the same prefixes, back references could be
150        confused. For example, in this pattern:
151    
152          /(?P<Name>a)?(?P<Name2>b)?(?(<Name>)c|d)*l/
153    
154        the reference to 'Name' was incorrectly treated as a reference to a
155        duplicate name.
156    
157    12. A pattern such as /^s?c/mi8 where the optional character has more than
158        one "other case" was incorrectly compiled such that it would only try to
159        match starting at "c".
160    
161    13. When a pattern starting with \s was studied, VT was not included in the
162        list of possible starting characters; this should have been part of the
163        8.34/18 patch.
164    
165    14. If a character class started [\Qx]... where x is any character, the class
166        was incorrectly terminated at the ].
167    
168    15. If a pattern that started with a caseless match for a character with more
169        than one "other case" was studied, PCRE did not set up the starting code
170        unit bit map for the list of possible characters. Now it does. This is an
171        optimization improvement, not a bug fix.
172    
173    16. The Unicode data tables have been updated to Unicode 7.0.0.
174    
175    17. Fixed a number of memory leaks in pcregrep.
176    
177    18. Avoid a compiler warning (from some compilers) for a function call with
178        a cast that removes "const" from an lvalue by using an intermediate
179        variable (to which the compiler does not object).
180    
181    19. Incorrect code was compiled if a group that contained an internal recursive
182        back reference was optional (had quantifier with a minimum of zero). This
183        example compiled incorrect code: /(((a\2)|(a*)\g<-1>))*/ and other examples
184        caused segmentation faults because of stack overflows at compile time.
185    
186    20. A pattern such as /((?(R)a|(?1)))+/, which contains a recursion within a
187        group that is quantified with an indefinite repeat, caused a compile-time
188        loop which used up all the system stack and provoked a segmentation fault.
189        This was not the same bug as 19 above.
190    
191    21. Add PCRECPP_EXP_DECL declaration to operator<< in pcre_stringpiece.h.
192        Patch by Mike Frysinger.
193    
194    
195    Version 8.35 04-April-2014
196    --------------------------
197    
198    1.  A new flag is set, when property checks are present in an XCLASS.
199        When this flag is not set, PCRE can perform certain optimizations
200        such as studying these XCLASS-es.
201    
202    2.  The auto-possessification of character sets were improved: a normal
203        and an extended character set can be compared now. Furthermore
204        the JIT compiler optimizes more character set checks.
205    
206    3.  Got rid of some compiler warnings for potentially uninitialized variables
207        that show up only when compiled with -O2.
208    
209    4.  A pattern such as (?=ab\K) that uses \K in an assertion can set the start
210        of a match later then the end of the match. The pcretest program was not
211        handling the case sensibly - it was outputting from the start to the next
212        binary zero. It now reports this situation in a message, and outputs the
213        text from the end to the start.
214    
215    5.  Fast forward search is improved in JIT. Instead of the first three
216        characters, any three characters with fixed position can be searched.
217        Search order: first, last, middle.
218    
219    6.  Improve character range checks in JIT. Characters are read by an inprecise
220        function now, which returns with an unknown value if the character code is
221        above a certain threshold (e.g: 256). The only limitation is that the value
222        must be bigger than the threshold as well. This function is useful when
223        the characters above the threshold are handled in the same way.
224    
225    7.  The macros whose names start with RAWUCHAR are placeholders for a future
226        mode in which only the bottom 21 bits of 32-bit data items are used. To
227        make this more memorable for those maintaining the code, the names have
228        been changed to start with UCHAR21, and an extensive comment has been added
229        to their definition.
230    
231    8.  Add missing (new) files sljitNativeTILEGX.c and sljitNativeTILEGX-encoder.c
232        to the export list in Makefile.am (they were accidentally omitted from the
233        8.34 tarball).
234    
235    9.  The informational output from pcretest used the phrase "starting byte set"
236        which is inappropriate for the 16-bit and 32-bit libraries. As the output
237        for "first char" and "need char" really means "non-UTF-char", I've changed
238        "byte" to "char", and slightly reworded the output. The documentation about
239        these values has also been (I hope) clarified.
240    
241    10. Another JIT related optimization: use table jumps for selecting the correct
242        backtracking path, when more than four alternatives are present inside a
243        bracket.
244    
245    11. Empty match is not possible, when the minimum length is greater than zero,
246        and there is no \K in the pattern. JIT should avoid empty match checks in
247        such cases.
248    
249    12. In a caseless character class with UCP support, when a character with more
250        than one alternative case was not the first character of a range, not all
251        the alternative cases were added to the class. For example, s and \x{17f}
252        are both alternative cases for S: the class [RST] was handled correctly,
253        but [R-T] was not.
254    
255    13. The configure.ac file always checked for pthread support when JIT was
256        enabled. This is not used in Windows, so I have put this test inside a
257        check for the presence of windows.h (which was already tested for).
258    
259    14. Improve pattern prefix search by a simplified Boyer-Moore algorithm in JIT.
260        The algorithm provides a way to skip certain starting offsets, and usually
261        faster than linear prefix searches.
262    
263    15. Change 13 for 8.20 updated RunTest to check for the 'fr' locale as well
264        as for 'fr_FR' and 'french'. For some reason, however, it then used the
265        Windows-specific input and output files, which have 'french' screwed in.
266        So this could never have worked. One of the problems with locales is that
267        they aren't always the same. I have now updated RunTest so that it checks
268        the output of the locale test (test 3) against three different output
269        files, and it allows the test to pass if any one of them matches. With luck
270        this should make the test pass on some versions of Solaris where it was
271        failing. Because of the uncertainty, the script did not used to stop if
272        test 3 failed; it now does. If further versions of a French locale ever
273        come to light, they can now easily be added.
274    
275    16. If --with-pcregrep-bufsize was given a non-integer value such as "50K",
276        there was a message during ./configure, but it did not stop. This now
277        provokes an error. The invalid example in README has been corrected.
278        If a value less than the minimum is given, the minimum value has always
279        been used, but now a warning is given.
280    
281    17. If --enable-bsr-anycrlf was set, the special 16/32-bit test failed. This
282        was a bug in the test system, which is now fixed. Also, the list of various
283        configurations that are tested for each release did not have one with both
284        16/32 bits and --enable-bar-anycrlf. It now does.
285    
286    18. pcretest was missing "-C bsr" for displaying the \R default setting.
287    
288    19. Little endian PowerPC systems are supported now by the JIT compiler.
289    
290    20. The fast forward newline mechanism could enter to an infinite loop on
291        certain invalid UTF-8 input. Although we don't support these cases
292        this issue can be fixed by a performance optimization.
293    
294    21. Change 33 of 8.34 is not sufficient to ensure stack safety because it does
295        not take account if existing stack usage. There is now a new global
296        variable called pcre_stack_guard that can be set to point to an external
297        function to check stack availability. It is called at the start of
298        processing every parenthesized group.
299    
300    22. A typo in the code meant that in ungreedy mode the max/min qualifier
301        behaved like a min-possessive qualifier, and, for example, /a{1,3}b/U did
302        not match "ab".
303    
304    23. When UTF was disabled, the JIT program reported some incorrect compile
305        errors. These messages are silenced now.
306    
307    24. Experimental support for ARM-64 and MIPS-64 has been added to the JIT
308        compiler.
309    
310    25. Change all the temporary files used in RunGrepTest to be different to those
311        used by RunTest so that the tests can be run simultaneously, for example by
312        "make -j check".
313    
314    
315    Version 8.34 15-December-2013
316    -----------------------------
317    
318    1.  Add pcre[16|32]_jit_free_unused_memory to forcibly free unused JIT
319        executable memory. Patch inspired by Carsten Klein.
320    
321    2.  ./configure --enable-coverage defined SUPPORT_GCOV in config.h, although
322        this macro is never tested and has no effect, because the work to support
323        coverage involves only compiling and linking options and special targets in
324        the Makefile. The comment in config.h implied that defining the macro would
325        enable coverage support, which is totally false. There was also support for
326        setting this macro in the CMake files (my fault, I just copied it from
327        configure). SUPPORT_GCOV has now been removed.
328    
329    3.  Make a small performance improvement in strlen16() and strlen32() in
330        pcretest.
331    
332    4.  Change 36 for 8.33 left some unreachable statements in pcre_exec.c,
333        detected by the Solaris compiler (gcc doesn't seem to be able to diagnose
334        these cases). There was also one in pcretest.c.
335    
336    5.  Cleaned up a "may be uninitialized" compiler warning in pcre_exec.c.
337    
338    6.  In UTF mode, the code for checking whether a group could match an empty
339        string (which is used for indefinitely repeated groups to allow for
340        breaking an infinite loop) was broken when the group contained a repeated
341        negated single-character class with a character that occupied more than one
342        data item and had a minimum repetition of zero (for example, [^\x{100}]* in
343        UTF-8 mode). The effect was undefined: the group might or might not be
344        deemed as matching an empty string, or the program might have crashed.
345    
346    7.  The code for checking whether a group could match an empty string was not
347        recognizing that \h, \H, \v, \V, and \R must match a character.
348    
349    8.  Implemented PCRE_INFO_MATCH_EMPTY, which yields 1 if the pattern can match
350        an empty string. If it can, pcretest shows this in its information output.
351    
352    9.  Fixed two related bugs that applied to Unicode extended grapheme clusters
353        that were repeated with a maximizing qualifier (e.g. \X* or \X{2,5}) when
354        matched by pcre_exec() without using JIT:
355    
356        (a) If the rest of the pattern did not match after a maximal run of
357            grapheme clusters, the code for backing up to try with fewer of them
358            did not always back up over a full grapheme when characters that do not
359            have the modifier quality were involved, e.g. Hangul syllables.
360    
361        (b) If the match point in a subject started with modifier character, and
362            there was no match, the code could incorrectly back up beyond the match
363            point, and potentially beyond the first character in the subject,
364            leading to a segfault or an incorrect match result.
365    
366    10. A conditional group with an assertion condition could lead to PCRE
367        recording an incorrect first data item for a match if no other first data
368        item was recorded. For example, the pattern (?(?=ab)ab) recorded "a" as a
369        first data item, and therefore matched "ca" after "c" instead of at the
370        start.
371    
372    11. Change 40 for 8.33 (allowing pcregrep to find empty strings) showed up a
373        bug that caused the command "echo a | ./pcregrep -M '|a'" to loop.
374    
375    12. The source of pcregrep now includes z/OS-specific code so that it can be
376        compiled for z/OS as part of the special z/OS distribution.
377    
378    13. Added the -T and -TM options to pcretest.
379    
380    14. The code in pcre_compile.c for creating the table of named capturing groups
381        has been refactored. Instead of creating the table dynamically during the
382        actual compiling pass, the information is remembered during the pre-compile
383        pass (on the stack unless there are more than 20 named groups, in which
384        case malloc() is used) and the whole table is created before the actual
385        compile happens. This has simplified the code (it is now nearly 150 lines
386        shorter) and prepared the way for better handling of references to groups
387        with duplicate names.
388    
389    15. A back reference to a named subpattern when there is more than one of the
390        same name now checks them in the order in which they appear in the pattern.
391        The first one that is set is used for the reference. Previously only the
392        first one was inspected. This change makes PCRE more compatible with Perl.
393    
394    16. Unicode character properties were updated from Unicode 6.3.0.
395    
396    17. The compile-time code for auto-possessification has been refactored, based
397        on a patch by Zoltan Herczeg. It now happens after instead of during
398        compilation. The code is cleaner, and more cases are handled. The option
399        PCRE_NO_AUTO_POSSESS is added for testing purposes, and the -O and /O
400        options in pcretest are provided to set it. It can also be set by
401        (*NO_AUTO_POSSESS) at the start of a pattern.
402    
403    18. The character VT has been added to the default ("C" locale) set of
404        characters that match \s and are generally treated as white space,
405        following this same change in Perl 5.18. There is now no difference between
406        "Perl space" and "POSIX space". Whether VT is treated as white space in
407        other locales depends on the locale.
408    
409    19. The code for checking named groups as conditions, either for being set or
410        for being recursed, has been refactored (this is related to 14 and 15
411        above). Processing unduplicated named groups should now be as fast at
412        numerical groups, and processing duplicated groups should be faster than
413        before.
414    
415    20. Two patches to the CMake build system, by Alexander Barkov:
416    
417          (1) Replace the "source" command by "." in CMakeLists.txt because
418              "source" is a bash-ism.
419    
420          (2) Add missing HAVE_STDINT_H and HAVE_INTTYPES_H to config-cmake.h.in;
421              without these the CMake build does not work on Solaris.
422    
423    21. Perl has changed its handling of \8 and \9. If there is no previously
424        encountered capturing group of those numbers, they are treated as the
425        literal characters 8 and 9 instead of a binary zero followed by the
426        literals. PCRE now does the same.
427    
428    22. Following Perl, added \o{} to specify codepoints in octal, making it
429        possible to specify values greater than 0777 and also making them
430        unambiguous.
431    
432    23. Perl now gives an error for missing closing braces after \x{... instead of
433        treating the string as literal. PCRE now does the same.
434    
435    24. RunTest used to grumble if an inappropriate test was selected explicitly,
436        but just skip it when running all tests. This make it awkward to run ranges
437        of tests when one of them was inappropriate. Now it just skips any
438        inappropriate tests, as it always did when running all tests.
439    
440    25. If PCRE_AUTO_CALLOUT and PCRE_UCP were set for a pattern that contained
441        character types such as \d or \w, too many callouts were inserted, and the
442        data that they returned was rubbish.
443    
444    26. In UCP mode, \s was not matching two of the characters that Perl matches,
445        namely NEL (U+0085) and MONGOLIAN VOWEL SEPARATOR (U+180E), though they
446        were matched by \h. The code has now been refactored so that the lists of
447        the horizontal and vertical whitespace characters used for \h and \v (which
448        are defined only in one place) are now also used for \s.
449    
450    27. Add JIT support for the 64 bit TileGX architecture.
451        Patch by Jiong Wang (Tilera Corporation).
452    
453    28. Possessive quantifiers for classes (both explicit and automatically
454        generated) now use special opcodes instead of wrapping in ONCE brackets.
455    
456    29. Whereas an item such as A{4}+ ignored the possessivenes of the quantifier
457        (because it's meaningless), this was not happening when PCRE_CASELESS was
458        set. Not wrong, but inefficient.
459    
460    30. Updated perltest.pl to add /u (force Unicode mode) when /W (use Unicode
461        properties for \w, \d, etc) is present in a test regex. Otherwise if the
462        test contains no characters greater than 255, Perl doesn't realise it
463        should be using Unicode semantics.
464    
465    31. Upgraded the handling of the POSIX classes [:graph:], [:print:], and
466        [:punct:] when PCRE_UCP is set so as to include the same characters as Perl
467        does in Unicode mode.
468    
469    32. Added the "forbid" facility to pcretest so that putting tests into the
470        wrong test files can sometimes be quickly detected.
471    
472    33. There is now a limit (default 250) on the depth of nesting of parentheses.
473        This limit is imposed to control the amount of system stack used at compile
474        time. It can be changed at build time by --with-parens-nest-limit=xxx or
475        the equivalent in CMake.
476    
477    34. Character classes such as [A-\d] or [a-[:digit:]] now cause compile-time
478        errors. Perl warns for these when in warning mode, but PCRE has no facility
479        for giving warnings.
480    
481    35. Change 34 for 8.13 allowed quantifiers on assertions, because Perl does.
482        However, this was not working for (?!) because it is optimized to (*FAIL),
483        for which PCRE does not allow quantifiers. The optimization is now disabled
484        when a quantifier follows (?!). I can't see any use for this, but it makes
485        things uniform.
486    
487    36. Perl no longer allows group names to start with digits, so I have made this
488        change also in PCRE. It simplifies the code a bit.
489    
490    37. In extended mode, Perl ignores spaces before a + that indicates a
491        possessive quantifier. PCRE allowed a space before the quantifier, but not
492        before the possessive +. It now does.
493    
494    38. The use of \K (reset reported match start) within a repeated possessive
495        group such as (a\Kb)*+ was not working.
496    
497    40. Document that the same character tables must be used at compile time and
498        run time, and that the facility to pass tables to pcre_exec() and
499        pcre_dfa_exec() is for use only with saved/restored patterns.
500    
501    41. Applied Jeff Trawick's patch CMakeLists.txt, which "provides two new
502        features for Builds with MSVC:
503    
504        1. Support pcre.rc and/or pcreposix.rc (as is already done for MinGW
505           builds). The .rc files can be used to set FileDescription and many other
506           attributes.
507    
508        2. Add an option (-DINSTALL_MSVC_PDB) to enable installation of .pdb files.
509           This allows higher-level build scripts which want .pdb files to avoid
510           hard-coding the exact files needed."
511    
512    42. Added support for [[:<:]] and [[:>:]] as used in the BSD POSIX library to
513        mean "start of word" and "end of word", respectively, as a transition aid.
514    
515    43. A minimizing repeat of a class containing codepoints greater than 255 in
516        non-UTF 16-bit or 32-bit modes caused an internal error when PCRE was
517        compiled to use the heap for recursion.
518    
519    44. Got rid of some compiler warnings for unused variables when UTF but not UCP
520        is configured.
521    
522    
523    Version 8.33 28-May-2013
524    ------------------------
525    
526    1.  Added 'U' to some constants that are compared to unsigned integers, to
527        avoid compiler signed/unsigned warnings. Added (int) casts to unsigned
528        variables that are added to signed variables, to ensure the result is
529        signed and can be negated.
530    
531    2.  Applied patch by Daniel Richard G for quashing MSVC warnings to the
532        CMake config files.
533    
534    3.  Revise the creation of config.h.generic so that all boolean macros are
535        #undefined, whereas non-boolean macros are #ifndef/#endif-ed. This makes
536        overriding via -D on the command line possible.
537    
538    4.  Changing the definition of the variable "op" in pcre_exec.c from pcre_uchar
539        to unsigned int is reported to make a quite noticeable speed difference in
540        a specific Windows environment. Testing on Linux did also appear to show
541        some benefit (and it is clearly not harmful). Also fixed the definition of
542        Xop which should be unsigned.
543    
544    5.  Related to (4), changing the definition of the intermediate variable cc
545        in repeated character loops from pcre_uchar to pcre_uint32 also gave speed
546        improvements.
547    
548    6.  Fix forward search in JIT when link size is 3 or greater. Also removed some
549        unnecessary spaces.
550    
551    7.  Adjust autogen.sh and configure.ac to lose warnings given by automake 1.12
552        and later.
553    
554    8.  Fix two buffer over read issues in 16 and 32 bit modes. Affects JIT only.
555    
556    9.  Optimizing fast_forward_start_bits in JIT.
557    
558    10. Adding support for callouts in JIT, and fixing some issues revealed
559        during this work. Namely:
560    
561        (a) Unoptimized capturing brackets incorrectly reset on backtrack.
562    
563        (b) Minimum length was not checked before the matching is started.
564    
565    11. The value of capture_last that is passed to callouts was incorrect in some
566        cases when there was a capture on one path that was subsequently abandoned
567        after a backtrack. Also, the capture_last value is now reset after a
568        recursion, since all captures are also reset in this case.
569    
570    12. The interpreter no longer returns the "too many substrings" error in the
571        case when an overflowing capture is in a branch that is subsequently
572        abandoned after a backtrack.
573    
574    13. In the pathological case when an offset vector of size 2 is used, pcretest
575        now prints out the matched string after a yield of 0 or 1.
576    
577    14. Inlining subpatterns in recursions, when certain conditions are fulfilled.
578        Only supported by the JIT compiler at the moment.
579    
580    15. JIT compiler now supports 32 bit Macs thanks to Lawrence Velazquez.
581    
582    16. Partial matches now set offsets[2] to the "bumpalong" value, that is, the
583        offset of the starting point of the matching process, provided the offsets
584        vector is large enough.
585    
586    17. The \A escape now records a lookbehind value of 1, though its execution
587        does not actually inspect the previous character. This is to ensure that,
588        in partial multi-segment matching, at least one character from the old
589        segment is retained when a new segment is processed. Otherwise, if there
590        are no lookbehinds in the pattern, \A might match incorrectly at the start
591        of a new segment.
592    
593    18. Added some #ifdef __VMS code into pcretest.c to help VMS implementations.
594    
595    19. Redefined some pcre_uchar variables in pcre_exec.c as pcre_uint32; this
596        gives some modest performance improvement in 8-bit mode.
597    
598    20. Added the PCRE-specific property \p{Xuc} for matching characters that can
599        be expressed in certain programming languages using Universal Character
600        Names.
601    
602    21. Unicode validation has been updated in the light of Unicode Corrigendum #9,
603        which points out that "non characters" are not "characters that may not
604        appear in Unicode strings" but rather "characters that are reserved for
605        internal use and have only local meaning".
606    
607    22. When a pattern was compiled with automatic callouts (PCRE_AUTO_CALLOUT) and
608        there was a conditional group that depended on an assertion, if the
609        assertion was false, the callout that immediately followed the alternation
610        in the condition was skipped when pcre_exec() was used for matching.
611    
612    23. Allow an explicit callout to be inserted before an assertion that is the
613        condition for a conditional group, for compatibility with automatic
614        callouts, which always insert a callout at this point.
615    
616    24. In 8.31, (*COMMIT) was confined to within a recursive subpattern. Perl also
617        confines (*SKIP) and (*PRUNE) in the same way, and this has now been done.
618    
619    25. (*PRUNE) is now supported by the JIT compiler.
620    
621    26. Fix infinite loop when /(?<=(*SKIP)ac)a/ is matched against aa.
622    
623    27. Fix the case where there are two or more SKIPs with arguments that may be
624        ignored.
625    
626    28. (*SKIP) is now supported by the JIT compiler.
627    
628    29. (*THEN) is now supported by the JIT compiler.
629    
630    30. Update RunTest with additional test selector options.
631    
632    31. The way PCRE handles backtracking verbs has been changed in two ways.
633    
634        (1) Previously, in something like (*COMMIT)(*SKIP), COMMIT would override
635        SKIP. Now, PCRE acts on whichever backtracking verb is reached first by
636        backtracking. In some cases this makes it more Perl-compatible, but Perl's
637        rather obscure rules do not always do the same thing.
638    
639        (2) Previously, backtracking verbs were confined within assertions. This is
640        no longer the case for positive assertions, except for (*ACCEPT). Again,
641        this sometimes improves Perl compatibility, and sometimes does not.
642    
643    32. A number of tests that were in test 2 because Perl did things differently
644        have been moved to test 1, because either Perl or PCRE has changed, and
645        these tests are now compatible.
646    
647    32. Backtracking control verbs are now handled in the same way in JIT and
648        interpreter.
649    
650    33. An opening parenthesis in a MARK/PRUNE/SKIP/THEN name in a pattern that
651        contained a forward subroutine reference caused a compile error.
652    
653    34. Auto-detect and optimize limited repetitions in JIT.
654    
655    35. Implement PCRE_NEVER_UTF to lock out the use of UTF, in particular,
656        blocking (*UTF) etc.
657    
658    36. In the interpreter, maximizing pattern repetitions for characters and
659        character types now use tail recursion, which reduces stack usage.
660    
661    37. The value of the max lookbehind was not correctly preserved if a compiled
662        and saved regex was reloaded on a host of different endianness.
663    
664    38. Implemented (*LIMIT_MATCH) and (*LIMIT_RECURSION). As part of the extension
665        of the compiled pattern block, expand the flags field from 16 to 32 bits
666        because it was almost full.
667    
668    39. Try madvise first before posix_madvise.
669    
670    40. Change 7 for PCRE 7.9 made it impossible for pcregrep to find empty lines
671        with a pattern such as ^$. It has taken 4 years for anybody to notice! The
672        original change locked out all matches of empty strings. This has been
673        changed so that one match of an empty string per line is recognized.
674        Subsequent searches on the same line (for colouring or for --only-matching,
675        for example) do not recognize empty strings.
676    
677    41. Applied a user patch to fix a number of spelling mistakes in comments.
678    
679    42. Data lines longer than 65536 caused pcretest to crash.
680    
681    43. Clarified the data type for length and startoffset arguments for pcre_exec
682        and pcre_dfa_exec in the function-specific man pages, where they were
683        explicitly stated to be in bytes, never having been updated. I also added
684        some clarification to the pcreapi man page.
685    
686    44. A call to pcre_dfa_exec() with an output vector size less than 2 caused
687        a segmentation fault.
688    
689    
690    Version 8.32 30-November-2012
691    -----------------------------
692    
693    1.  Improved JIT compiler optimizations for first character search and single
694        character iterators.
695    
696    2.  Supporting IBM XL C compilers for PPC architectures in the JIT compiler.
697        Patch by Daniel Richard G.
698    
699    3.  Single character iterator optimizations in the JIT compiler.
700    
701    4.  Improved JIT compiler optimizations for character ranges.
702    
703    5.  Rename the "leave" variable names to "quit" to improve WinCE compatibility.
704        Reported by Giuseppe D'Angelo.
705    
706    6.  The PCRE_STARTLINE bit, indicating that a match can occur only at the start
707        of a line, was being set incorrectly in cases where .* appeared inside
708        atomic brackets at the start of a pattern, or where there was a subsequent
709        *PRUNE or *SKIP.
710    
711    7.  Improved instruction cache flush for POWER/PowerPC.
712        Patch by Daniel Richard G.
713    
714    8.  Fixed a number of issues in pcregrep, making it more compatible with GNU
715        grep:
716    
717        (a) There is now no limit to the number of patterns to be matched.
718    
719        (b) An error is given if a pattern is too long.
720    
721        (c) Multiple uses of --exclude, --exclude-dir, --include, and --include-dir
722            are now supported.
723    
724        (d) --exclude-from and --include-from (multiple use) have been added.
725    
726        (e) Exclusions and inclusions now apply to all files and directories, not
727            just to those obtained from scanning a directory recursively.
728    
729        (f) Multiple uses of -f and --file-list are now supported.
730    
731        (g) In a Windows environment, the default for -d has been changed from
732            "read" (the GNU grep default) to "skip", because otherwise the presence
733            of a directory in the file list provokes an error.
734    
735        (h) The documentation has been revised and clarified in places.
736    
737    9.  Improve the matching speed of capturing brackets.
738    
739    10. Changed the meaning of \X so that it now matches a Unicode extended
740        grapheme cluster.
741    
742    11. Patch by Daniel Richard G to the autoconf files to add a macro for sorting
743        out POSIX threads when JIT support is configured.
744    
745    12. Added support for PCRE_STUDY_EXTRA_NEEDED.
746    
747    13. In the POSIX wrapper regcomp() function, setting re_nsub field in the preg
748        structure could go wrong in environments where size_t is not the same size
749        as int.
750    
751    14. Applied user-supplied patch to pcrecpp.cc to allow PCRE_NO_UTF8_CHECK to be
752        set.
753    
754    15. The EBCDIC support had decayed; later updates to the code had included
755        explicit references to (e.g.) \x0a instead of CHAR_LF. There has been a
756        general tidy up of EBCDIC-related issues, and the documentation was also
757        not quite right. There is now a test that can be run on ASCII systems to
758        check some of the EBCDIC-related things (but is it not a full test).
759    
760    16. The new PCRE_STUDY_EXTRA_NEEDED option is now used by pcregrep, resulting
761        in a small tidy to the code.
762    
763    17. Fix JIT tests when UTF is disabled and both 8 and 16 bit mode are enabled.
764    
765    18. If the --only-matching (-o) option in pcregrep is specified multiple
766        times, each one causes appropriate output. For example, -o1 -o2 outputs the
767        substrings matched by the 1st and 2nd capturing parentheses. A separating
768        string can be specified by --om-separator (default empty).
769    
770    19. Improving the first n character searches.
771    
772    20. Turn case lists for horizontal and vertical white space into macros so that
773        they are defined only once.
774    
775    21. This set of changes together give more compatible Unicode case-folding
776        behaviour for characters that have more than one other case when UCP
777        support is available.
778    
779        (a) The Unicode property table now has offsets into a new table of sets of
780            three or more characters that are case-equivalent. The MultiStage2.py
781            script that generates these tables (the pcre_ucd.c file) now scans
782            CaseFolding.txt instead of UnicodeData.txt for character case
783            information.
784    
785        (b) The code for adding characters or ranges of characters to a character
786            class has been abstracted into a generalized function that also handles
787            case-independence. In UTF-mode with UCP support, this uses the new data
788            to handle characters with more than one other case.
789    
790        (c) A bug that is fixed as a result of (b) is that codepoints less than 256
791            whose other case is greater than 256 are now correctly matched
792            caselessly. Previously, the high codepoint matched the low one, but not
793            vice versa.
794    
795        (d) The processing of \h, \H, \v, and \ in character classes now makes use
796            of the new class addition function, using character lists defined as
797            macros alongside the case definitions of 20 above.
798    
799        (e) Caseless back references now work with characters that have more than
800            one other case.
801    
802        (f) General caseless matching of characters with more than one other case
803            is supported.
804    
805    22. Unicode character properties were updated from Unicode 6.2.0
806    
807    23. Improved CMake support under Windows. Patch by Daniel Richard G.
808    
809    24. Add support for 32-bit character strings, and UTF-32
810    
811    25. Major JIT compiler update (code refactoring and bugfixing).
812        Experimental Sparc 32 support is added.
813    
814    26. Applied a modified version of Daniel Richard G's patch to create
815        pcre.h.generic and config.h.generic by "make" instead of in the
816        PrepareRelease script.
817    
818    27. Added a definition for CHAR_NULL (helpful for the z/OS port), and use it in
819        pcre_compile.c when checking for a zero character.
820    
821    28. Introducing a native interface for JIT. Through this interface, the compiled
822        machine code can be directly executed. The purpose of this interface is to
823        provide fast pattern matching, so several sanity checks are not performed.
824        However, feature tests are still performed. The new interface provides
825        1.4x speedup compared to the old one.
826    
827    29. If pcre_exec() or pcre_dfa_exec() was called with a negative value for
828        the subject string length, the error given was PCRE_ERROR_BADOFFSET, which
829        was confusing. There is now a new error PCRE_ERROR_BADLENGTH for this case.
830    
831    30. In 8-bit UTF-8 mode, pcretest failed to give an error for data codepoints
832        greater than 0x7fffffff (which cannot be represented in UTF-8, even under
833        the "old" RFC 2279). Instead, it ended up passing a negative length to
834        pcre_exec().
835    
836    31. Add support for GCC's visibility feature to hide internal functions.
837    
838    32. Running "pcretest -C pcre8" or "pcretest -C pcre16" gave a spurious error
839        "unknown -C option" after outputting 0 or 1.
840    
841    33. There is now support for generating a code coverage report for the test
842        suite in environments where gcc is the compiler and lcov is installed. This
843        is mainly for the benefit of the developers.
844    
845    34. If PCRE is built with --enable-valgrind, certain memory regions are marked
846        unaddressable using valgrind annotations, allowing valgrind to detect
847        invalid memory accesses. This is mainly for the benefit of the developers.
848    
849    25. (*UTF) can now be used to start a pattern in any of the three libraries.
850    
851    26. Give configure error if --enable-cpp but no C++ compiler found.
852    
853    
854    Version 8.31 06-July-2012
855    -------------------------
856    
857    1.  Fixing a wrong JIT test case and some compiler warnings.
858    
859    2.  Removed a bashism from the RunTest script.
860    
861    3.  Add a cast to pcre_exec.c to fix the warning "unary minus operator applied
862        to unsigned type, result still unsigned" that was given by an MS compiler
863        on encountering the code "-sizeof(xxx)".
864    
865    4.  Partial matching support is added to the JIT compiler.
866    
867    5.  Fixed several bugs concerned with partial matching of items that consist
868        of more than one character:
869    
870        (a) /^(..)\1/ did not partially match "aba" because checking references was
871            done on an "all or nothing" basis. This also applied to repeated
872            references.
873    
874        (b) \R did not give a hard partial match if \r was found at the end of the
875            subject.
876    
877        (c) \X did not give a hard partial match after matching one or more
878            characters at the end of the subject.
879    
880        (d) When newline was set to CRLF, a pattern such as /a$/ did not recognize
881            a partial match for the string "\r".
882    
883        (e) When newline was set to CRLF, the metacharacter "." did not recognize
884            a partial match for a CR character at the end of the subject string.
885    
886    6.  If JIT is requested using /S++ or -s++ (instead of just /S+ or -s+) when
887        running pcretest, the text "(JIT)" added to the output whenever JIT is
888        actually used to run the match.
889    
890    7.  Individual JIT compile options can be set in pcretest by following -s+[+]
891        or /S+[+] with a digit between 1 and 7.
892    
893    8.  OP_NOT now supports any UTF character not just single-byte ones.
894    
895    9.  (*MARK) control verb is now supported by the JIT compiler.
896    
897    10. The command "./RunTest list" lists the available tests without actually
898        running any of them. (Because I keep forgetting what they all are.)
899    
900    11. Add PCRE_INFO_MAXLOOKBEHIND.
901    
902    12. Applied a (slightly modified) user-supplied patch that improves performance
903        when the heap is used for recursion (compiled with --disable-stack-for-
904        recursion). Instead of malloc and free for each heap frame each time a
905        logical recursion happens, frames are retained on a chain and re-used where
906        possible. This sometimes gives as much as 30% improvement.
907    
908    13. As documented, (*COMMIT) is now confined to within a recursive subpattern
909        call.
910    
911    14. As documented, (*COMMIT) is now confined to within a positive assertion.
912    
913    15. It is now possible to link pcretest with libedit as an alternative to
914        libreadline.
915    
916    16. (*COMMIT) control verb is now supported by the JIT compiler.
917    
918    17. The Unicode data tables have been updated to Unicode 6.1.0.
919    
920    18. Added --file-list option to pcregrep.
921    
922    19. Added binary file support to pcregrep, including the -a, --binary-files,
923        -I, and --text options.
924    
925    20. The madvise function is renamed for posix_madvise for QNX compatibility
926        reasons. Fixed by Giuseppe D'Angelo.
927    
928    21. Fixed a bug for backward assertions with REVERSE 0 in the JIT compiler.
929    
930    22. Changed the option for creating symbolic links for 16-bit man pages from
931        -s to -sf so that re-installing does not cause issues.
932    
933    23. Support PCRE_NO_START_OPTIMIZE in JIT as (*MARK) support requires it.
934    
935    24. Fixed a very old bug in pcretest that caused errors with restarted DFA
936        matches in certain environments (the workspace was not being correctly
937        retained). Also added to pcre_dfa_exec() a simple plausibility check on
938        some of the workspace data at the beginning of a restart.
939    
940    25. \s*\R was auto-possessifying the \s* when it should not, whereas \S*\R
941        was not doing so when it should - probably a typo introduced by SVN 528
942        (change 8.10/14).
943    
944    26. When PCRE_UCP was not set, \w+\x{c4} was incorrectly auto-possessifying the
945        \w+ when the character tables indicated that \x{c4} was a word character.
946        There were several related cases, all because the tests for doing a table
947        lookup were testing for characters less than 127 instead of 255.
948    
949    27. If a pattern contains capturing parentheses that are not used in a match,
950        their slots in the ovector are set to -1. For those that are higher than
951        any matched groups, this happens at the end of processing. In the case when
952        there were back references that the ovector was too small to contain
953        (causing temporary malloc'd memory to be used during matching), and the
954        highest capturing number was not used, memory off the end of the ovector
955        was incorrectly being set to -1. (It was using the size of the temporary
956        memory instead of the true size.)
957    
958    28. To catch bugs like 27 using valgrind, when pcretest is asked to specify an
959        ovector size, it uses memory at the end of the block that it has got.
960    
961    29. Check for an overlong MARK name and give an error at compile time. The
962        limit is 255 for the 8-bit library and 65535 for the 16-bit library.
963    
964    30. JIT compiler update.
965    
966    31. JIT is now supported on jailbroken iOS devices. Thanks for Ruiger
967        Rill for the patch.
968    
969    32. Put spaces around SLJIT_PRINT_D in the JIT compiler. Required by CXX11.
970    
971    33. Variable renamings in the PCRE-JIT compiler. No functionality change.
972    
973    34. Fixed typos in pcregrep: in two places there was SUPPORT_LIBZ2 instead of
974        SUPPORT_LIBBZ2. This caused a build problem when bzip2 but not gzip (zlib)
975        was enabled.
976    
977    35. Improve JIT code generation for greedy plus quantifier.
978    
979    36. When /((?:a?)*)*c/ or /((?>a?)*)*c/ was matched against "aac", it set group
980        1 to "aa" instead of to an empty string. The bug affected repeated groups
981        that could potentially match an empty string.
982    
983    37. Optimizing single character iterators in JIT.
984    
985    38. Wide characters specified with \uxxxx in JavaScript mode are now subject to
986        the same checks as \x{...} characters in non-JavaScript mode. Specifically,
987        codepoints that are too big for the mode are faulted, and in a UTF mode,
988        disallowed codepoints are also faulted.
989    
990    39. If PCRE was compiled with UTF support, in three places in the DFA
991        matcher there was code that should only have been obeyed in UTF mode, but
992        was being obeyed unconditionally. In 8-bit mode this could cause incorrect
993        processing when bytes with values greater than 127 were present. In 16-bit
994        mode the bug would be provoked by values in the range 0xfc00 to 0xdc00. In
995        both cases the values are those that cannot be the first data item in a UTF
996        character. The three items that might have provoked this were recursions,
997        possessively repeated groups, and atomic groups.
998    
999    40. Ensure that libpcre is explicitly listed in the link commands for pcretest
1000        and pcregrep, because some OS require shared objects to be explicitly
1001        passed to ld, causing the link step to fail if they are not.
1002    
1003    41. There were two incorrect #ifdefs in pcre_study.c, meaning that, in 16-bit
1004        mode, patterns that started with \h* or \R* might be incorrectly matched.
1005    
1006    
1007    Version 8.30 04-February-2012
1008    -----------------------------
1009    
1010    1.  Renamed "isnumber" as "is_a_number" because in some Mac environments this
1011        name is defined in ctype.h.
1012    
1013    2.  Fixed a bug in fixed-length calculation for lookbehinds that would show up
1014        only in quite long subpatterns.
1015    
1016    3.  Removed the function pcre_info(), which has been obsolete and deprecated
1017        since it was replaced by pcre_fullinfo() in February 2000.
1018    
1019    4.  For a non-anchored pattern, if (*SKIP) was given with a name that did not
1020        match a (*MARK), and the match failed at the start of the subject, a
1021        reference to memory before the start of the subject could occur. This bug
1022        was introduced by fix 17 of release 8.21.
1023    
1024    5.  A reference to an unset group with zero minimum repetition was giving
1025        totally wrong answers (in non-JavaScript-compatibility mode). For example,
1026        /(another)?(\1?)test/ matched against "hello world test". This bug was
1027        introduced in release 8.13.
1028    
1029    6.  Add support for 16-bit character strings (a large amount of work involving
1030        many changes and refactorings).
1031    
1032    7.  RunGrepTest failed on msys because \r\n was replaced by whitespace when the
1033        command "pattern=`printf 'xxx\r\njkl'`" was run. The pattern is now taken
1034        from a file.
1035    
1036    8.  Ovector size of 2 is also supported by JIT based pcre_exec (the ovector size
1037        rounding is not applied in this particular case).
1038    
1039    9.  The invalid Unicode surrogate codepoints U+D800 to U+DFFF are now rejected
1040        if they appear, or are escaped, in patterns.
1041    
1042    10. Get rid of a number of -Wunused-but-set-variable warnings.
1043    
1044    11. The pattern /(?=(*:x))(q|)/ matches an empty string, and returns the mark
1045        "x". The similar pattern /(?=(*:x))((*:y)q|)/ did not return a mark at all.
1046        Oddly, Perl behaves the same way. PCRE has been fixed so that this pattern
1047        also returns the mark "x". This bug applied to capturing parentheses,
1048        non-capturing parentheses, and atomic parentheses. It also applied to some
1049        assertions.
1050    
1051    12. Stephen Kelly's patch to CMakeLists.txt allows it to parse the version
1052        information out of configure.ac instead of relying on pcre.h.generic, which
1053        is not stored in the repository.
1054    
1055    13. Applied Dmitry V. Levin's patch for a more portable method for linking with
1056        -lreadline.
1057    
1058    14. ZH added PCRE_CONFIG_JITTARGET; added its output to pcretest -C.
1059    
1060    15. Applied Graycode's patch to put the top-level frame on the stack rather
1061        than the heap when not using the stack for recursion. This gives a
1062        performance improvement in many cases when recursion is not deep.
1063    
1064    16. Experimental code added to "pcretest -C" to output the stack frame size.
1065    
1066    
1067    Version 8.21 12-Dec-2011
1068    ------------------------
1069    
1070    1.  Updating the JIT compiler.
1071    
1072    2.  JIT compiler now supports OP_NCREF, OP_RREF and OP_NRREF. New test cases
1073        are added as well.
1074    
1075    3.  Fix cache-flush issue on PowerPC (It is still an experimental JIT port).
1076        PCRE_EXTRA_TABLES is not suported by JIT, and should be checked before
1077        calling _pcre_jit_exec. Some extra comments are added.
1078    
1079    4.  (*MARK) settings inside atomic groups that do not contain any capturing
1080        parentheses, for example, (?>a(*:m)), were not being passed out. This bug
1081        was introduced by change 18 for 8.20.
1082    
1083    5.  Supporting of \x, \U and \u in JavaScript compatibility mode based on the
1084        ECMA-262 standard.
1085    
1086    6.  Lookbehinds such as (?<=a{2}b) that contained a fixed repetition were
1087        erroneously being rejected as "not fixed length" if PCRE_CASELESS was set.
1088        This bug was probably introduced by change 9 of 8.13.
1089    
1090    7.  While fixing 6 above, I noticed that a number of other items were being
1091        incorrectly rejected as "not fixed length". This arose partly because newer
1092        opcodes had not been added to the fixed-length checking code. I have (a)
1093        corrected the bug and added tests for these items, and (b) arranged for an
1094        error to occur if an unknown opcode is encountered while checking for fixed
1095        length instead of just assuming "not fixed length". The items that were
1096        rejected were: (*ACCEPT), (*COMMIT), (*FAIL), (*MARK), (*PRUNE), (*SKIP),
1097        (*THEN), \h, \H, \v, \V, and single character negative classes with fixed
1098        repetitions, e.g. [^a]{3}, with and without PCRE_CASELESS.
1099    
1100    8.  A possessively repeated conditional subpattern such as (?(?=c)c|d)++ was
1101        being incorrectly compiled and would have given unpredicatble results.
1102    
1103    9.  A possessively repeated subpattern with minimum repeat count greater than
1104        one behaved incorrectly. For example, (A){2,}+ behaved as if it was
1105        (A)(A)++ which meant that, after a subsequent mismatch, backtracking into
1106        the first (A) could occur when it should not.
1107    
1108    10. Add a cast and remove a redundant test from the code.
1109    
1110    11. JIT should use pcre_malloc/pcre_free for allocation.
1111    
1112    12. Updated pcre-config so that it no longer shows -L/usr/lib, which seems
1113        best practice nowadays, and helps with cross-compiling. (If the exec_prefix
1114        is anything other than /usr, -L is still shown).
1115    
1116    13. In non-UTF-8 mode, \C is now supported in lookbehinds and DFA matching.
1117    
1118    14. Perl does not support \N without a following name in a [] class; PCRE now
1119        also gives an error.
1120    
1121    15. If a forward reference was repeated with an upper limit of around 2000,
1122        it caused the error "internal error: overran compiling workspace". The
1123        maximum number of forward references (including repeats) was limited by the
1124        internal workspace, and dependent on the LINK_SIZE. The code has been
1125        rewritten so that the workspace expands (via pcre_malloc) if necessary, and
1126        the default depends on LINK_SIZE. There is a new upper limit (for safety)
1127        of around 200,000 forward references. While doing this, I also speeded up
1128        the filling in of repeated forward references.
1129    
1130    16. A repeated forward reference in a pattern such as (a)(?2){2}(.) was
1131        incorrectly expecting the subject to contain another "a" after the start.
1132    
1133    17. When (*SKIP:name) is activated without a corresponding (*MARK:name) earlier
1134        in the match, the SKIP should be ignored. This was not happening; instead
1135        the SKIP was being treated as NOMATCH. For patterns such as
1136        /A(*MARK:A)A+(*SKIP:B)Z|AAC/ this meant that the AAC branch was never
1137        tested.
1138    
1139    18. The behaviour of (*MARK), (*PRUNE), and (*THEN) has been reworked and is
1140        now much more compatible with Perl, in particular in cases where the result
1141        is a non-match for a non-anchored pattern. For example, if
1142        /b(*:m)f|a(*:n)w/ is matched against "abc", the non-match returns the name
1143        "m", where previously it did not return a name. A side effect of this
1144        change is that for partial matches, the last encountered mark name is
1145        returned, as for non matches. A number of tests that were previously not
1146        Perl-compatible have been moved into the Perl-compatible test files. The
1147        refactoring has had the pleasing side effect of removing one argument from
1148        the match() function, thus reducing its stack requirements.
1149    
1150    19. If the /S+ option was used in pcretest to study a pattern using JIT,
1151        subsequent uses of /S (without +) incorrectly behaved like /S+.
1152    
1153    21. Retrieve executable code size support for the JIT compiler and fixing
1154        some warnings.
1155    
1156    22. A caseless match of a UTF-8 character whose other case uses fewer bytes did
1157        not work when the shorter character appeared right at the end of the
1158        subject string.
1159    
1160    23. Added some (int) casts to non-JIT modules to reduce warnings on 64-bit
1161        systems.
1162    
1163    24. Added PCRE_INFO_JITSIZE to pass on the value from (21) above, and also
1164        output it when the /M option is used in pcretest.
1165    
1166    25. The CheckMan script was not being included in the distribution. Also, added
1167        an explicit "perl" to run Perl scripts from the PrepareRelease script
1168        because this is reportedly needed in Windows.
1169    
1170    26. If study data was being save in a file and studying had not found a set of
1171        "starts with" bytes for the pattern, the data written to the file (though
1172        never used) was taken from uninitialized memory and so caused valgrind to
1173        complain.
1174    
1175    27. Updated RunTest.bat as provided by Sheri Pierce.
1176    
1177    28. Fixed a possible uninitialized memory bug in pcre_jit_compile.c.
1178    
1179    29. Computation of memory usage for the table of capturing group names was
1180        giving an unnecessarily large value.
1181    
1182    
1183    Version 8.20 21-Oct-2011
1184    ------------------------
1185    
1186    1.  Change 37 of 8.13 broke patterns like [:a]...[b:] because it thought it had
1187        a POSIX class. After further experiments with Perl, which convinced me that
1188        Perl has bugs and confusions, a closing square bracket is no longer allowed
1189        in a POSIX name. This bug also affected patterns with classes that started
1190        with full stops.
1191    
1192    2.  If a pattern such as /(a)b|ac/ is matched against "ac", there is no
1193        captured substring, but while checking the failing first alternative,
1194        substring 1 is temporarily captured. If the output vector supplied to
1195        pcre_exec() was not big enough for this capture, the yield of the function
1196        was still zero ("insufficient space for captured substrings"). This cannot
1197        be totally fixed without adding another stack variable, which seems a lot
1198        of expense for a edge case. However, I have improved the situation in cases
1199        such as /(a)(b)x|abc/ matched against "abc", where the return code
1200        indicates that fewer than the maximum number of slots in the ovector have
1201        been set.
1202    
1203    3.  Related to (2) above: when there are more back references in a pattern than
1204        slots in the output vector, pcre_exec() uses temporary memory during
1205        matching, and copies in the captures as far as possible afterwards. It was
1206        using the entire output vector, but this conflicts with the specification
1207        that only 2/3 is used for passing back captured substrings. Now it uses
1208        only the first 2/3, for compatibility. This is, of course, another edge
1209        case.
1210    
1211    4.  Zoltan Herczeg's just-in-time compiler support has been integrated into the
1212        main code base, and can be used by building with --enable-jit. When this is
1213        done, pcregrep automatically uses it unless --disable-pcregrep-jit or the
1214        runtime --no-jit option is given.
1215    
1216    5.  When the number of matches in a pcre_dfa_exec() run exactly filled the
1217        ovector, the return from the function was zero, implying that there were
1218        other matches that did not fit. The correct "exactly full" value is now
1219        returned.
1220    
1221    6.  If a subpattern that was called recursively or as a subroutine contained
1222        (*PRUNE) or any other control that caused it to give a non-standard return,
1223        invalid errors such as "Error -26 (nested recursion at the same subject
1224        position)" or even infinite loops could occur.
1225    
1226    7.  If a pattern such as /a(*SKIP)c|b(*ACCEPT)|/ was studied, it stopped
1227        computing the minimum length on reaching *ACCEPT, and so ended up with the
1228        wrong value of 1 rather than 0. Further investigation indicates that
1229        computing a minimum subject length in the presence of *ACCEPT is difficult
1230        (think back references, subroutine calls), and so I have changed the code
1231        so that no minimum is registered for a pattern that contains *ACCEPT.
1232    
1233    8.  If (*THEN) was present in the first (true) branch of a conditional group,
1234        it was not handled as intended. [But see 16 below.]
1235    
1236    9.  Replaced RunTest.bat and CMakeLists.txt with improved versions provided by
1237        Sheri Pierce.
1238    
1239    10. A pathological pattern such as /(*ACCEPT)a/ was miscompiled, thinking that
1240        the first byte in a match must be "a".
1241    
1242    11. Change 17 for 8.13 increased the recursion depth for patterns like
1243        /a(?:.)*?a/ drastically. I've improved things by remembering whether a
1244        pattern contains any instances of (*THEN). If it does not, the old
1245        optimizations are restored. It would be nice to do this on a per-group
1246        basis, but at the moment that is not feasible.
1247    
1248    12. In some environments, the output of pcretest -C is CRLF terminated. This
1249        broke RunTest's code that checks for the link size. A single white space
1250        character after the value is now allowed for.
1251    
1252    13. RunTest now checks for the "fr" locale as well as for "fr_FR" and "french".
1253        For "fr", it uses the Windows-specific input and output files.
1254    
1255    14. If (*THEN) appeared in a group that was called recursively or as a
1256        subroutine, it did not work as intended. [But see next item.]
1257    
1258    15. Consider the pattern /A (B(*THEN)C) | D/ where A, B, C, and D are complex
1259        pattern fragments (but not containing any | characters). If A and B are
1260        matched, but there is a failure in C so that it backtracks to (*THEN), PCRE
1261        was behaving differently to Perl. PCRE backtracked into A, but Perl goes to
1262        D. In other words, Perl considers parentheses that do not contain any |
1263        characters to be part of a surrounding alternative, whereas PCRE was
1264        treading (B(*THEN)C) the same as (B(*THEN)C|(*FAIL)) -- which Perl handles
1265        differently. PCRE now behaves in the same way as Perl, except in the case
1266        of subroutine/recursion calls such as (?1) which have in any case always
1267        been different (but PCRE had them first :-).
1268    
1269    16. Related to 15 above: Perl does not treat the | in a conditional group as
1270        creating alternatives. Such a group is treated in the same way as an
1271        ordinary group without any | characters when processing (*THEN). PCRE has
1272        been changed to match Perl's behaviour.
1273    
1274    17. If a user had set PCREGREP_COLO(U)R to something other than 1:31, the
1275        RunGrepTest script failed.
1276    
1277    18. Change 22 for version 13 caused atomic groups to use more stack. This is
1278        inevitable for groups that contain captures, but it can lead to a lot of
1279        stack use in large patterns. The old behaviour has been restored for atomic
1280        groups that do not contain any capturing parentheses.
1281    
1282    19. If the PCRE_NO_START_OPTIMIZE option was set for pcre_compile(), it did not
1283        suppress the check for a minimum subject length at run time. (If it was
1284        given to pcre_exec() or pcre_dfa_exec() it did work.)
1285    
1286    20. Fixed an ASCII-dependent infelicity in pcretest that would have made it
1287        fail to work when decoding hex characters in data strings in EBCDIC
1288        environments.
1289    
1290    21. It appears that in at least one Mac OS environment, the isxdigit() function
1291        is implemented as a macro that evaluates to its argument more than once,
1292        contravening the C 90 Standard (I haven't checked a later standard). There
1293        was an instance in pcretest which caused it to go wrong when processing
1294        \x{...} escapes in subject strings. The has been rewritten to avoid using
1295        things like p++ in the argument of isxdigit().
1296    
1297    
1298    Version 8.13 16-Aug-2011
1299  ------------------------  ------------------------
1300    
1301  1.  The Unicode data tables have been updated to Unicode 6.0.0.  1.  The Unicode data tables have been updated to Unicode 6.0.0.
# Line 20  Version 8.13 30-Apr-2011 Line 1314  Version 8.13 30-Apr-2011
1314      code. (b) A reference to 2 copies of a 3-byte code would not match 2 of a      code. (b) A reference to 2 copies of a 3-byte code would not match 2 of a
1315      2-byte code at the end of the subject (it thought there wasn't enough data      2-byte code at the end of the subject (it thought there wasn't enough data
1316      left).      left).
1317    
1318  5.  Comprehensive information about what went wrong is now returned by  5.  Comprehensive information about what went wrong is now returned by
1319      pcre_exec() and pcre_dfa_exec() when the UTF-8 string check fails, as long      pcre_exec() and pcre_dfa_exec() when the UTF-8 string check fails, as long
1320      as the output vector has at least 2 elements. The offset of the start of      as the output vector has at least 2 elements. The offset of the start of
1321      the failing character and a reason code are placed in the vector.      the failing character and a reason code are placed in the vector.
1322    
1323  6.  When the UTF-8 string check fails for pcre_compile(), the offset that is  6.  When the UTF-8 string check fails for pcre_compile(), the offset that is
1324      now returned is for the first byte of the failing character, instead of the      now returned is for the first byte of the failing character, instead of the
1325      last byte inspected. This is an incompatible change, but I hope it is small      last byte inspected. This is an incompatible change, but I hope it is small
1326      enough not to be a problem. It makes the returned offset consistent with      enough not to be a problem. It makes the returned offset consistent with
1327      pcre_exec() and pcre_dfa_exec().      pcre_exec() and pcre_dfa_exec().
1328    
1329  7.  pcretest now gives a text phrase as well as the error number when  7.  pcretest now gives a text phrase as well as the error number when
1330      pcre_exec() or pcre_dfa_exec() fails; if the error is a UTF-8 check      pcre_exec() or pcre_dfa_exec() fails; if the error is a UTF-8 check
1331      failure, the offset and reason code are output.      failure, the offset and reason code are output.
1332    
1333  8.  When \R was used with a maximizing quantifier it failed to skip backwards  8.  When \R was used with a maximizing quantifier it failed to skip backwards
1334      over a \r\n pair if the subsequent match failed. Instead, it just skipped      over a \r\n pair if the subsequent match failed. Instead, it just skipped
1335      back over a single character (\n). This seems wrong (because it treated the      back over a single character (\n). This seems wrong (because it treated the
1336      two characters as a single entity when going forwards), conflicts with the      two characters as a single entity when going forwards), conflicts with the
1337      documentation that \R is equivalent to (?>\r\n|\n|...etc), and makes the      documentation that \R is equivalent to (?>\r\n|\n|...etc), and makes the
1338      behaviour of \R* different to (\R)*, which also seems wrong. The behaviour      behaviour of \R* different to (\R)*, which also seems wrong. The behaviour
1339      has been changed.      has been changed.
1340    
1341    9.  Some internal refactoring has changed the processing so that the handling
1342        of the PCRE_CASELESS and PCRE_MULTILINE options is done entirely at compile
1343        time (the PCRE_DOTALL option was changed this way some time ago: version
1344        7.7 change 16). This has made it possible to abolish the OP_OPT op code,
1345        which was always a bit of a fudge. It also means that there is one less
1346        argument for the match() function, which reduces its stack requirements
1347        slightly. This change also fixes an incompatibility with Perl: the pattern
1348        (?i:([^b]))(?1) should not match "ab", but previously PCRE gave a match.
1349    
1350    10. More internal refactoring has drastically reduced the number of recursive
1351        calls to match() for possessively repeated groups such as (abc)++ when
1352        using pcre_exec().
1353    
1354    11. While implementing 10, a number of bugs in the handling of groups were
1355        discovered and fixed:
1356    
1357        (?<=(a)+) was not diagnosed as invalid (non-fixed-length lookbehind).
1358        (a|)*(?1) gave a compile-time internal error.
1359        ((a|)+)+  did not notice that the outer group could match an empty string.
1360        (^a|^)+   was not marked as anchored.
1361        (.*a|.*)+ was not marked as matching at start or after a newline.
1362    
1363    12. Yet more internal refactoring has removed another argument from the match()
1364        function. Special calls to this function are now indicated by setting a
1365        value in a variable in the "match data" data block.
1366    
1367    13. Be more explicit in pcre_study() instead of relying on "default" for
1368        opcodes that mean there is no starting character; this means that when new
1369        ones are added and accidentally left out of pcre_study(), testing should
1370        pick them up.
1371    
1372    14. The -s option of pcretest has been documented for ages as being an old
1373        synonym of -m (show memory usage). I have changed it to mean "force study
1374        for every regex", that is, assume /S for every regex. This is similar to -i
1375        and -d etc. It's slightly incompatible, but I'm hoping nobody is still
1376        using it. It makes it easier to run collections of tests with and without
1377        study enabled, and thereby test pcre_study() more easily. All the standard
1378        tests are now run with and without -s (but some patterns can be marked as
1379        "never study" - see 20 below).
1380    
1381    15. When (*ACCEPT) was used in a subpattern that was called recursively, the
1382        restoration of the capturing data to the outer values was not happening
1383        correctly.
1384    
1385    16. If a recursively called subpattern ended with (*ACCEPT) and matched an
1386        empty string, and PCRE_NOTEMPTY was set, pcre_exec() thought the whole
1387        pattern had matched an empty string, and so incorrectly returned a no
1388        match.
1389    
1390    17. There was optimizing code for the last branch of non-capturing parentheses,
1391        and also for the obeyed branch of a conditional subexpression, which used
1392        tail recursion to cut down on stack usage. Unfortunately, now that there is
1393        the possibility of (*THEN) occurring in these branches, tail recursion is
1394        no longer possible because the return has to be checked for (*THEN). These
1395        two optimizations have therefore been removed. [But see 8.20/11 above.]
1396    
1397    18. If a pattern containing \R was studied, it was assumed that \R always
1398        matched two bytes, thus causing the minimum subject length to be
1399        incorrectly computed because \R can also match just one byte.
1400    
1401    19. If a pattern containing (*ACCEPT) was studied, the minimum subject length
1402        was incorrectly computed.
1403    
1404    20. If /S is present twice on a test pattern in pcretest input, it now
1405        *disables* studying, thereby overriding the use of -s on the command line
1406        (see 14 above). This is necessary for one or two tests to keep the output
1407        identical in both cases.
1408    
1409    21. When (*ACCEPT) was used in an assertion that matched an empty string and
1410        PCRE_NOTEMPTY was set, PCRE applied the non-empty test to the assertion.
1411    
1412    22. When an atomic group that contained a capturing parenthesis was
1413        successfully matched, but the branch in which it appeared failed, the
1414        capturing was not being forgotten if a higher numbered group was later
1415        captured. For example, /(?>(a))b|(a)c/ when matching "ac" set capturing
1416        group 1 to "a", when in fact it should be unset. This applied to multi-
1417        branched capturing and non-capturing groups, repeated or not, and also to
1418        positive assertions (capturing in negative assertions does not happen
1419        in PCRE) and also to nested atomic groups.
1420    
1421    23. Add the ++ qualifier feature to pcretest, to show the remainder of the
1422        subject after a captured substring, to make it easier to tell which of a
1423        number of identical substrings has been captured.
1424    
1425    24. The way atomic groups are processed by pcre_exec() has been changed so that
1426        if they are repeated, backtracking one repetition now resets captured
1427        values correctly. For example, if ((?>(a+)b)+aabab) is matched against
1428        "aaaabaaabaabab" the value of captured group 2 is now correctly recorded as
1429        "aaa". Previously, it would have been "a". As part of this code
1430        refactoring, the way recursive calls are handled has also been changed.
1431    
1432    25. If an assertion condition captured any substrings, they were not passed
1433        back unless some other capturing happened later. For example, if
1434        (?(?=(a))a) was matched against "a", no capturing was returned.
1435    
1436    26. When studying a pattern that contained subroutine calls or assertions,
1437        the code for finding the minimum length of a possible match was handling
1438        direct recursions such as (xxx(?1)|yyy) but not mutual recursions (where
1439        group 1 called group 2 while simultaneously a separate group 2 called group
1440        1). A stack overflow occurred in this case. I have fixed this by limiting
1441        the recursion depth to 10.
1442    
1443    27. Updated RunTest.bat in the distribution to the version supplied by Tom
1444        Fortmann. This supports explicit test numbers on the command line, and has
1445        argument validation and error reporting.
1446    
1447    28. An instance of \X with an unlimited repeat could fail if at any point the
1448        first character it looked at was a mark character.
1449    
1450    29. Some minor code refactoring concerning Unicode properties and scripts
1451        should reduce the stack requirement of match() slightly.
1452    
1453    30. Added the '=' option to pcretest to check the setting of unused capturing
1454        slots at the end of the pattern, which are documented as being -1, but are
1455        not included in the return count.
1456    
1457    31. If \k was not followed by a braced, angle-bracketed, or quoted name, PCRE
1458        compiled something random. Now it gives a compile-time error (as does
1459        Perl).
1460    
1461    32. A *MARK encountered during the processing of a positive assertion is now
1462        recorded and passed back (compatible with Perl).
1463    
1464    33. If --only-matching or --colour was set on a pcregrep call whose pattern
1465        had alternative anchored branches, the search for a second match in a line
1466        was done as if at the line start. Thus, for example, /^01|^02/ incorrectly
1467        matched the line "0102" twice. The same bug affected patterns that started
1468        with a backwards assertion. For example /\b01|\b02/ also matched "0102"
1469        twice.
1470    
1471    34. Previously, PCRE did not allow quantification of assertions. However, Perl
1472        does, and because of capturing effects, quantifying parenthesized
1473        assertions may at times be useful. Quantifiers are now allowed for
1474        parenthesized assertions.
1475    
1476    35. A minor code tidy in pcre_compile() when checking options for \R usage.
1477    
1478    36. \g was being checked for fancy things in a character class, when it should
1479        just be a literal "g".
1480    
1481    37. PCRE was rejecting [:a[:digit:]] whereas Perl was not. It seems that the
1482        appearance of a nested POSIX class supersedes an apparent external class.
1483        For example, [:a[:digit:]b:] matches "a", "b", ":", or a digit. Also,
1484        unescaped square brackets may also appear as part of class names. For
1485        example, [:a[:abc]b:] gives unknown class "[:abc]b:]". PCRE now behaves
1486        more like Perl. (But see 8.20/1 above.)
1487    
1488    38. PCRE was giving an error for \N with a braced quantifier such as {1,} (this
1489        was because it thought it was \N{name}, which is not supported).
1490    
1491    39. Add minix to OS list not supporting the -S option in pcretest.
1492    
1493    40. PCRE tries to detect cases of infinite recursion at compile time, but it
1494        cannot analyze patterns in sufficient detail to catch mutual recursions
1495        such as ((?1))((?2)). There is now a runtime test that gives an error if a
1496        subgroup is called recursively as a subpattern for a second time at the
1497        same position in the subject string. In previous releases this might have
1498        been caught by the recursion limit, or it might have run out of stack.
1499    
1500    41. A pattern such as /(?(R)a+|(?R)b)/ is quite safe, as the recursion can
1501        happen only once. PCRE was, however incorrectly giving a compile time error
1502        "recursive call could loop indefinitely" because it cannot analyze the
1503        pattern in sufficient detail. The compile time test no longer happens when
1504        PCRE is compiling a conditional subpattern, but actual runaway loops are
1505        now caught at runtime (see 40 above).
1506    
1507    42. It seems that Perl allows any characters other than a closing parenthesis
1508        to be part of the NAME in (*MARK:NAME) and other backtracking verbs. PCRE
1509        has been changed to be the same.
1510    
1511    43. Updated configure.ac to put in more quoting round AC_LANG_PROGRAM etc. so
1512        as not to get warnings when autogen.sh is called. Also changed
1513        AC_PROG_LIBTOOL (deprecated) to LT_INIT (the current macro).
1514    
1515    44. To help people who use pcregrep to scan files containing exceedingly long
1516        lines, the following changes have been made:
1517    
1518        (a) The default value of the buffer size parameter has been increased from
1519            8K to 20K. (The actual buffer used is three times this size.)
1520    
1521        (b) The default can be changed by ./configure --with-pcregrep-bufsize when
1522            PCRE is built.
1523    
1524        (c) A --buffer-size=n option has been added to pcregrep, to allow the size
1525            to be set at run time.
1526    
1527        (d) Numerical values in pcregrep options can be followed by K or M, for
1528            example --buffer-size=50K.
1529    
1530        (e) If a line being scanned overflows pcregrep's buffer, an error is now
1531            given and the return code is set to 2.
1532    
1533    45. Add a pointer to the latest mark to the callout data block.
1534    
1535    46. The pattern /.(*F)/, when applied to "abc" with PCRE_PARTIAL_HARD, gave a
1536        partial match of an empty string instead of no match. This was specific to
1537        the use of ".".
1538    
1539    47. The pattern /f.*/8s, when applied to "for" with PCRE_PARTIAL_HARD, gave a
1540        complete match instead of a partial match. This bug was dependent on both
1541        the PCRE_UTF8 and PCRE_DOTALL options being set.
1542    
1543    48. For a pattern such as /\babc|\bdef/ pcre_study() was failing to set up the
1544        starting byte set, because \b was not being ignored.
1545    
1546    
1547  Version 8.12 15-Jan-2011  Version 8.12 15-Jan-2011
1548  ------------------------  ------------------------
# Line 695  Version 7.9 11-Apr-09 Line 2194  Version 7.9 11-Apr-09
2194  7.  A pattern that could match an empty string could cause pcregrep to loop; it  7.  A pattern that could match an empty string could cause pcregrep to loop; it
2195      doesn't make sense to accept an empty string match in pcregrep, so I have      doesn't make sense to accept an empty string match in pcregrep, so I have
2196      locked it out (using PCRE's PCRE_NOTEMPTY option). By experiment, this      locked it out (using PCRE's PCRE_NOTEMPTY option). By experiment, this
2197      seems to be how GNU grep behaves.      seems to be how GNU grep behaves. [But see later change 40 for release
2198        8.33.]
2199    
2200  8.  The pattern (?(?=.*b)b|^) was incorrectly compiled as "match must be at  8.  The pattern (?(?=.*b)b|^) was incorrectly compiled as "match must be at
2201      start or after a newline", because the conditional assertion was not being      start or after a newline", because the conditional assertion was not being
# Line 938  Version 7.7 07-May-08 Line 2438  Version 7.7 07-May-08
2438      containing () gave an internal compiling error instead of "reference to      containing () gave an internal compiling error instead of "reference to
2439      non-existent subpattern". Fortunately, when the pattern did exist, the      non-existent subpattern". Fortunately, when the pattern did exist, the
2440      compiled code was correct. (When scanning forwards to check for the      compiled code was correct. (When scanning forwards to check for the
2441      existencd of the subpattern, it was treating the data ']' as terminating      existence of the subpattern, it was treating the data ']' as terminating
2442      the class, so got the count wrong. When actually compiling, the reference      the class, so got the count wrong. When actually compiling, the reference
2443      was subsequently set up correctly.)      was subsequently set up correctly.)
2444    

Legend:
Removed from v.600  
changed lines
  Added in v.1530

  ViewVC Help
Powered by ViewVC 1.1.5