| 1 |
ChangeLog for PCRE |
ChangeLog for PCRE |
| 2 |
------------------ |
------------------ |
| 3 |
|
|
| 4 |
|
Version 7.4 10-Sep-07 |
| 5 |
|
--------------------- |
| 6 |
|
|
| 7 |
|
1. Change 7.3/28 was implemented for classes by looking at the bitmap. This |
| 8 |
|
means that a class such as [\s] counted as "explicit reference to CR or |
| 9 |
|
LF". That isn't really right - the whole point of the change was to try to |
| 10 |
|
help when there was an actual mention of one of the two characters. So now |
| 11 |
|
the change happens only if \r or \n (or a literal CR or LF) character is |
| 12 |
|
encountered. |
| 13 |
|
|
| 14 |
|
2. The 32-bit options word was also used for 6 internal flags, but the numbers |
| 15 |
|
of both had grown to the point where there were only 3 bits left. |
| 16 |
|
Fortunately, there was spare space in the data structure, and so I have |
| 17 |
|
moved the internal flags into a new 16-bit field to free up more option |
| 18 |
|
bits. |
| 19 |
|
|
| 20 |
|
3. The appearance of (?J) at the start of a pattern set the DUPNAMES option, |
| 21 |
|
but did not set the internal JCHANGED flag - either of these is enough to |
| 22 |
|
control the way the "get" function works - but the PCRE_INFO_JCHANGED |
| 23 |
|
facility is supposed to tell if (?J) was ever used, so now (?J) at the |
| 24 |
|
start sets both bits. |
| 25 |
|
|
| 26 |
|
4. Added options (at build time, compile time, exec time) to change \R from |
| 27 |
|
matching any Unicode line ending sequence to just matching CR, LF, or CRLF. |
| 28 |
|
|
| 29 |
|
5. doc/pcresyntax.html was missing from the distribution. |
| 30 |
|
|
| 31 |
|
6. Put back the definition of PCRE_ERROR_NULLWSLIMIT, for backward |
| 32 |
|
compatibility, even though it is no longer used. |
| 33 |
|
|
| 34 |
|
7. Added macro for snprintf to pcrecpp_unittest.cc and also for strtoll and |
| 35 |
|
strtoull to pcrecpp.cc to select the available functions in WIN32 (where |
| 36 |
|
different names are used). |
| 37 |
|
|
| 38 |
|
|
| 39 |
|
Version 7.3 28-Aug-07 |
| 40 |
|
--------------------- |
| 41 |
|
|
| 42 |
|
1. In the rejigging of the build system that eventually resulted in 7.1, the |
| 43 |
|
line "#include <pcre.h>" was included in pcre_internal.h. The use of angle |
| 44 |
|
brackets there is not right, since it causes compilers to look for an |
| 45 |
|
installed pcre.h, not the version that is in the source that is being |
| 46 |
|
compiled (which of course may be different). I have changed it back to: |
| 47 |
|
|
| 48 |
|
#include "pcre.h" |
| 49 |
|
|
| 50 |
|
I have a vague recollection that the change was concerned with compiling in |
| 51 |
|
different directories, but in the new build system, that is taken care of |
| 52 |
|
by the VPATH setting the Makefile. |
| 53 |
|
|
| 54 |
|
2. The pattern .*$ when run in not-DOTALL UTF-8 mode with newline=any failed |
| 55 |
|
when the subject happened to end in the byte 0x85 (e.g. if the last |
| 56 |
|
character was \x{1ec5}). *Character* 0x85 is one of the "any" newline |
| 57 |
|
characters but of course it shouldn't be taken as a newline when it is part |
| 58 |
|
of another character. The bug was that, for an unlimited repeat of . in |
| 59 |
|
not-DOTALL UTF-8 mode, PCRE was advancing by bytes rather than by |
| 60 |
|
characters when looking for a newline. |
| 61 |
|
|
| 62 |
|
3. A small performance improvement in the DOTALL UTF-8 mode .* case. |
| 63 |
|
|
| 64 |
|
4. Debugging: adjusted the names of opcodes for different kinds of parentheses |
| 65 |
|
in debug output. |
| 66 |
|
|
| 67 |
|
5. Arrange to use "%I64d" instead of "%lld" and "%I64u" instead of "%llu" for |
| 68 |
|
long printing in the pcrecpp unittest when running under MinGW. |
| 69 |
|
|
| 70 |
|
6. ESC_K was left out of the EBCDIC table. |
| 71 |
|
|
| 72 |
|
7. Change 7.0/38 introduced a new limit on the number of nested non-capturing |
| 73 |
|
parentheses; I made it 1000, which seemed large enough. Unfortunately, the |
| 74 |
|
limit also applies to "virtual nesting" when a pattern is recursive, and in |
| 75 |
|
this case 1000 isn't so big. I have been able to remove this limit at the |
| 76 |
|
expense of backing off one optimization in certain circumstances. Normally, |
| 77 |
|
when pcre_exec() would call its internal match() function recursively and |
| 78 |
|
immediately return the result unconditionally, it uses a "tail recursion" |
| 79 |
|
feature to save stack. However, when a subpattern that can match an empty |
| 80 |
|
string has an unlimited repetition quantifier, it no longer makes this |
| 81 |
|
optimization. That gives it a stack frame in which to save the data for |
| 82 |
|
checking that an empty string has been matched. Previously this was taken |
| 83 |
|
from the 1000-entry workspace that had been reserved. So now there is no |
| 84 |
|
explicit limit, but more stack is used. |
| 85 |
|
|
| 86 |
|
8. Applied Daniel's patches to solve problems with the import/export magic |
| 87 |
|
syntax that is required for Windows, and which was going wrong for the |
| 88 |
|
pcreposix and pcrecpp parts of the library. These were overlooked when this |
| 89 |
|
problem was solved for the main library. |
| 90 |
|
|
| 91 |
|
9. There were some crude static tests to avoid integer overflow when computing |
| 92 |
|
the size of patterns that contain repeated groups with explicit upper |
| 93 |
|
limits. As the maximum quantifier is 65535, the maximum group length was |
| 94 |
|
set at 30,000 so that the product of these two numbers did not overflow a |
| 95 |
|
32-bit integer. However, it turns out that people want to use groups that |
| 96 |
|
are longer than 30,000 bytes (though not repeat them that many times). |
| 97 |
|
Change 7.0/17 (the refactoring of the way the pattern size is computed) has |
| 98 |
|
made it possible to implement the integer overflow checks in a much more |
| 99 |
|
dynamic way, which I have now done. The artificial limitation on group |
| 100 |
|
length has been removed - we now have only the limit on the total length of |
| 101 |
|
the compiled pattern, which depends on the LINK_SIZE setting. |
| 102 |
|
|
| 103 |
|
10. Fixed a bug in the documentation for get/copy named substring when |
| 104 |
|
duplicate names are permitted. If none of the named substrings are set, the |
| 105 |
|
functions return PCRE_ERROR_NOSUBSTRING (7); the doc said they returned an |
| 106 |
|
empty string. |
| 107 |
|
|
| 108 |
|
11. Because Perl interprets \Q...\E at a high level, and ignores orphan \E |
| 109 |
|
instances, patterns such as [\Q\E] or [\E] or even [^\E] cause an error, |
| 110 |
|
because the ] is interpreted as the first data character and the |
| 111 |
|
terminating ] is not found. PCRE has been made compatible with Perl in this |
| 112 |
|
regard. Previously, it interpreted [\Q\E] as an empty class, and [\E] could |
| 113 |
|
cause memory overwriting. |
| 114 |
|
|
| 115 |
|
10. Like Perl, PCRE automatically breaks an unlimited repeat after an empty |
| 116 |
|
string has been matched (to stop an infinite loop). It was not recognizing |
| 117 |
|
a conditional subpattern that could match an empty string if that |
| 118 |
|
subpattern was within another subpattern. For example, it looped when |
| 119 |
|
trying to match (((?(1)X|))*) but it was OK with ((?(1)X|)*) where the |
| 120 |
|
condition was not nested. This bug has been fixed. |
| 121 |
|
|
| 122 |
|
12. A pattern like \X?\d or \P{L}?\d in non-UTF-8 mode could cause a backtrack |
| 123 |
|
past the start of the subject in the presence of bytes with the top bit |
| 124 |
|
set, for example "\x8aBCD". |
| 125 |
|
|
| 126 |
|
13. Added Perl 5.10 experimental backtracking controls (*FAIL), (*F), (*PRUNE), |
| 127 |
|
(*SKIP), (*THEN), (*COMMIT), and (*ACCEPT). |
| 128 |
|
|
| 129 |
|
14. Optimized (?!) to (*FAIL). |
| 130 |
|
|
| 131 |
|
15. Updated the test for a valid UTF-8 string to conform to the later RFC 3629. |
| 132 |
|
This restricts code points to be within the range 0 to 0x10FFFF, excluding |
| 133 |
|
the "low surrogate" sequence 0xD800 to 0xDFFF. Previously, PCRE allowed the |
| 134 |
|
full range 0 to 0x7FFFFFFF, as defined by RFC 2279. Internally, it still |
| 135 |
|
does: it's just the validity check that is more restrictive. |
| 136 |
|
|
| 137 |
|
16. Inserted checks for integer overflows during escape sequence (backslash) |
| 138 |
|
processing, and also fixed erroneous offset values for syntax errors during |
| 139 |
|
backslash processing. |
| 140 |
|
|
| 141 |
|
17. Fixed another case of looking too far back in non-UTF-8 mode (cf 12 above) |
| 142 |
|
for patterns like [\PPP\x8a]{1,}\x80 with the subject "A\x80". |
| 143 |
|
|
| 144 |
|
18. An unterminated class in a pattern like (?1)\c[ with a "forward reference" |
| 145 |
|
caused an overrun. |
| 146 |
|
|
| 147 |
|
19. A pattern like (?:[\PPa*]*){8,} which had an "extended class" (one with |
| 148 |
|
something other than just ASCII characters) inside a group that had an |
| 149 |
|
unlimited repeat caused a loop at compile time (while checking to see |
| 150 |
|
whether the group could match an empty string). |
| 151 |
|
|
| 152 |
|
20. Debugging a pattern containing \p or \P could cause a crash. For example, |
| 153 |
|
[\P{Any}] did so. (Error in the code for printing property names.) |
| 154 |
|
|
| 155 |
|
21. An orphan \E inside a character class could cause a crash. |
| 156 |
|
|
| 157 |
|
22. A repeated capturing bracket such as (A)? could cause a wild memory |
| 158 |
|
reference during compilation. |
| 159 |
|
|
| 160 |
|
23. There are several functions in pcre_compile() that scan along a compiled |
| 161 |
|
expression for various reasons (e.g. to see if it's fixed length for look |
| 162 |
|
behind). There were bugs in these functions when a repeated \p or \P was |
| 163 |
|
present in the pattern. These operators have additional parameters compared |
| 164 |
|
with \d, etc, and these were not being taken into account when moving along |
| 165 |
|
the compiled data. Specifically: |
| 166 |
|
|
| 167 |
|
(a) A item such as \p{Yi}{3} in a lookbehind was not treated as fixed |
| 168 |
|
length. |
| 169 |
|
|
| 170 |
|
(b) An item such as \pL+ within a repeated group could cause crashes or |
| 171 |
|
loops. |
| 172 |
|
|
| 173 |
|
(c) A pattern such as \p{Yi}+(\P{Yi}+)(?1) could give an incorrect |
| 174 |
|
"reference to non-existent subpattern" error. |
| 175 |
|
|
| 176 |
|
(d) A pattern like (\P{Yi}{2}\277)? could loop at compile time. |
| 177 |
|
|
| 178 |
|
24. A repeated \S or \W in UTF-8 mode could give wrong answers when multibyte |
| 179 |
|
characters were involved (for example /\S{2}/8g with "A\x{a3}BC"). |
| 180 |
|
|
| 181 |
|
25. Using pcregrep in multiline, inverted mode (-Mv) caused it to loop. |
| 182 |
|
|
| 183 |
|
26. Patterns such as [\P{Yi}A] which include \p or \P and just one other |
| 184 |
|
character were causing crashes (broken optimization). |
| 185 |
|
|
| 186 |
|
27. Patterns such as (\P{Yi}*\277)* (group with possible zero repeat containing |
| 187 |
|
\p or \P) caused a compile-time loop. |
| 188 |
|
|
| 189 |
|
28. More problems have arisen in unanchored patterns when CRLF is a valid line |
| 190 |
|
break. For example, the unstudied pattern [\r\n]A does not match the string |
| 191 |
|
"\r\nA" because change 7.0/46 below moves the current point on by two |
| 192 |
|
characters after failing to match at the start. However, the pattern \nA |
| 193 |
|
*does* match, because it doesn't start till \n, and if [\r\n]A is studied, |
| 194 |
|
the same is true. There doesn't seem any very clean way out of this, but |
| 195 |
|
what I have chosen to do makes the common cases work: PCRE now takes note |
| 196 |
|
of whether there can be an explicit match for \r or \n anywhere in the |
| 197 |
|
pattern, and if so, 7.0/46 no longer applies. As part of this change, |
| 198 |
|
there's a new PCRE_INFO_HASCRORLF option for finding out whether a compiled |
| 199 |
|
pattern has explicit CR or LF references. |
| 200 |
|
|
| 201 |
|
29. Added (*CR) etc for changing newline setting at start of pattern. |
| 202 |
|
|
| 203 |
|
|
| 204 |
|
Version 7.2 19-Jun-07 |
| 205 |
|
--------------------- |
| 206 |
|
|
| 207 |
|
1. If the fr_FR locale cannot be found for test 3, try the "french" locale, |
| 208 |
|
which is apparently normally available under Windows. |
| 209 |
|
|
| 210 |
|
2. Re-jig the pcregrep tests with different newline settings in an attempt |
| 211 |
|
to make them independent of the local environment's newline setting. |
| 212 |
|
|
| 213 |
|
3. Add code to configure.ac to remove -g from the CFLAGS default settings. |
| 214 |
|
|
| 215 |
|
4. Some of the "internals" tests were previously cut out when the link size |
| 216 |
|
was not 2, because the output contained actual offsets. The recent new |
| 217 |
|
"Z" feature of pcretest means that these can be cut out, making the tests |
| 218 |
|
usable with all link sizes. |
| 219 |
|
|
| 220 |
|
5. Implemented Stan Switzer's goto replacement for longjmp() when not using |
| 221 |
|
stack recursion. This gives a massive performance boost under BSD, but just |
| 222 |
|
a small improvement under Linux. However, it saves one field in the frame |
| 223 |
|
in all cases. |
| 224 |
|
|
| 225 |
|
6. Added more features from the forthcoming Perl 5.10: |
| 226 |
|
|
| 227 |
|
(a) (?-n) (where n is a string of digits) is a relative subroutine or |
| 228 |
|
recursion call. It refers to the nth most recently opened parentheses. |
| 229 |
|
|
| 230 |
|
(b) (?+n) is also a relative subroutine call; it refers to the nth next |
| 231 |
|
to be opened parentheses. |
| 232 |
|
|
| 233 |
|
(c) Conditions that refer to capturing parentheses can be specified |
| 234 |
|
relatively, for example, (?(-2)... or (?(+3)... |
| 235 |
|
|
| 236 |
|
(d) \K resets the start of the current match so that everything before |
| 237 |
|
is not part of it. |
| 238 |
|
|
| 239 |
|
(e) \k{name} is synonymous with \k<name> and \k'name' (.NET compatible). |
| 240 |
|
|
| 241 |
|
(f) \g{name} is another synonym - part of Perl 5.10's unification of |
| 242 |
|
reference syntax. |
| 243 |
|
|
| 244 |
|
(g) (?| introduces a group in which the numbering of parentheses in each |
| 245 |
|
alternative starts with the same number. |
| 246 |
|
|
| 247 |
|
(h) \h, \H, \v, and \V match horizontal and vertical whitespace. |
| 248 |
|
|
| 249 |
|
7. Added two new calls to pcre_fullinfo(): PCRE_INFO_OKPARTIAL and |
| 250 |
|
PCRE_INFO_JCHANGED. |
| 251 |
|
|
| 252 |
|
8. A pattern such as (.*(.)?)* caused pcre_exec() to fail by either not |
| 253 |
|
terminating or by crashing. Diagnosed by Viktor Griph; it was in the code |
| 254 |
|
for detecting groups that can match an empty string. |
| 255 |
|
|
| 256 |
|
9. A pattern with a very large number of alternatives (more than several |
| 257 |
|
hundred) was running out of internal workspace during the pre-compile |
| 258 |
|
phase, where pcre_compile() figures out how much memory will be needed. A |
| 259 |
|
bit of new cunning has reduced the workspace needed for groups with |
| 260 |
|
alternatives. The 1000-alternative test pattern now uses 12 bytes of |
| 261 |
|
workspace instead of running out of the 4096 that are available. |
| 262 |
|
|
| 263 |
|
10. Inserted some missing (unsigned int) casts to get rid of compiler warnings. |
| 264 |
|
|
| 265 |
|
11. Applied patch from Google to remove an optimization that didn't quite work. |
| 266 |
|
The report of the bug said: |
| 267 |
|
|
| 268 |
|
pcrecpp::RE("a*").FullMatch("aaa") matches, while |
| 269 |
|
pcrecpp::RE("a*?").FullMatch("aaa") does not, and |
| 270 |
|
pcrecpp::RE("a*?\\z").FullMatch("aaa") does again. |
| 271 |
|
|
| 272 |
|
12. If \p or \P was used in non-UTF-8 mode on a character greater than 127 |
| 273 |
|
it matched the wrong number of bytes. |
| 274 |
|
|
| 275 |
|
|
| 276 |
|
Version 7.1 24-Apr-07 |
| 277 |
|
--------------------- |
| 278 |
|
|
| 279 |
|
1. Applied Bob Rossi and Daniel G's patches to convert the build system to one |
| 280 |
|
that is more "standard", making use of automake and other Autotools. There |
| 281 |
|
is some re-arrangement of the files and adjustment of comments consequent |
| 282 |
|
on this. |
| 283 |
|
|
| 284 |
|
2. Part of the patch fixed a problem with the pcregrep tests. The test of -r |
| 285 |
|
for recursive directory scanning broke on some systems because the files |
| 286 |
|
are not scanned in any specific order and on different systems the order |
| 287 |
|
was different. A call to "sort" has been inserted into RunGrepTest for the |
| 288 |
|
approprate test as a short-term fix. In the longer term there may be an |
| 289 |
|
alternative. |
| 290 |
|
|
| 291 |
|
3. I had an email from Eric Raymond about problems translating some of PCRE's |
| 292 |
|
man pages to HTML (despite the fact that I distribute HTML pages, some |
| 293 |
|
people do their own conversions for various reasons). The problems |
| 294 |
|
concerned the use of low-level troff macros .br and .in. I have therefore |
| 295 |
|
removed all such uses from the man pages (some were redundant, some could |
| 296 |
|
be replaced by .nf/.fi pairs). The 132html script that I use to generate |
| 297 |
|
HTML has been updated to handle .nf/.fi and to complain if it encounters |
| 298 |
|
.br or .in. |
| 299 |
|
|
| 300 |
|
4. Updated comments in configure.ac that get placed in config.h.in and also |
| 301 |
|
arranged for config.h to be included in the distribution, with the name |
| 302 |
|
config.h.generic, for the benefit of those who have to compile without |
| 303 |
|
Autotools (compare pcre.h, which is now distributed as pcre.h.generic). |
| 304 |
|
|
| 305 |
|
5. Updated the support (such as it is) for Virtual Pascal, thanks to Stefan |
| 306 |
|
Weber: (1) pcre_internal.h was missing some function renames; (2) updated |
| 307 |
|
makevp.bat for the current PCRE, using the additional files |
| 308 |
|
makevp_c.txt, makevp_l.txt, and pcregexp.pas. |
| 309 |
|
|
| 310 |
|
6. A Windows user reported a minor discrepancy with test 2, which turned out |
| 311 |
|
to be caused by a trailing space on an input line that had got lost in his |
| 312 |
|
copy. The trailing space was an accident, so I've just removed it. |
| 313 |
|
|
| 314 |
|
7. Add -Wl,-R... flags in pcre-config.in for *BSD* systems, as I'm told |
| 315 |
|
that is needed. |
| 316 |
|
|
| 317 |
|
8. Mark ucp_table (in ucptable.h) and ucp_gentype (in pcre_ucp_searchfuncs.c) |
| 318 |
|
as "const" (a) because they are and (b) because it helps the PHP |
| 319 |
|
maintainers who have recently made a script to detect big data structures |
| 320 |
|
in the php code that should be moved to the .rodata section. I remembered |
| 321 |
|
to update Builducptable as well, so it won't revert if ucptable.h is ever |
| 322 |
|
re-created. |
| 323 |
|
|
| 324 |
|
9. Added some extra #ifdef SUPPORT_UTF8 conditionals into pcretest.c, |
| 325 |
|
pcre_printint.src, pcre_compile.c, pcre_study.c, and pcre_tables.c, in |
| 326 |
|
order to be able to cut out the UTF-8 tables in the latter when UTF-8 |
| 327 |
|
support is not required. This saves 1.5-2K of code, which is important in |
| 328 |
|
some applications. |
| 329 |
|
|
| 330 |
|
Later: more #ifdefs are needed in pcre_ord2utf8.c and pcre_valid_utf8.c |
| 331 |
|
so as not to refer to the tables, even though these functions will never be |
| 332 |
|
called when UTF-8 support is disabled. Otherwise there are problems with a |
| 333 |
|
shared library. |
| 334 |
|
|
| 335 |
|
10. Fixed two bugs in the emulated memmove() function in pcre_internal.h: |
| 336 |
|
|
| 337 |
|
(a) It was defining its arguments as char * instead of void *. |
| 338 |
|
|
| 339 |
|
(b) It was assuming that all moves were upwards in memory; this was true |
| 340 |
|
a long time ago when I wrote it, but is no longer the case. |
| 341 |
|
|
| 342 |
|
The emulated memove() is provided for those environments that have neither |
| 343 |
|
memmove() nor bcopy(). I didn't think anyone used it these days, but that |
| 344 |
|
is clearly not the case, as these two bugs were recently reported. |
| 345 |
|
|
| 346 |
|
11. The script PrepareRelease is now distributed: it calls 132html, CleanTxt, |
| 347 |
|
and Detrail to create the HTML documentation, the .txt form of the man |
| 348 |
|
pages, and it removes trailing spaces from listed files. It also creates |
| 349 |
|
pcre.h.generic and config.h.generic from pcre.h and config.h. In the latter |
| 350 |
|
case, it wraps all the #defines with #ifndefs. This script should be run |
| 351 |
|
before "make dist". |
| 352 |
|
|
| 353 |
|
12. Fixed two fairly obscure bugs concerned with quantified caseless matching |
| 354 |
|
with Unicode property support. |
| 355 |
|
|
| 356 |
|
(a) For a maximizing quantifier, if the two different cases of the |
| 357 |
|
character were of different lengths in their UTF-8 codings (there are |
| 358 |
|
some cases like this - I found 11), and the matching function had to |
| 359 |
|
back up over a mixture of the two cases, it incorrectly assumed they |
| 360 |
|
were both the same length. |
| 361 |
|
|
| 362 |
|
(b) When PCRE was configured to use the heap rather than the stack for |
| 363 |
|
recursion during matching, it was not correctly preserving the data for |
| 364 |
|
the other case of a UTF-8 character when checking ahead for a match |
| 365 |
|
while processing a minimizing repeat. If the check also involved |
| 366 |
|
matching a wide character, but failed, corruption could cause an |
| 367 |
|
erroneous result when trying to check for a repeat of the original |
| 368 |
|
character. |
| 369 |
|
|
| 370 |
|
13. Some tidying changes to the testing mechanism: |
| 371 |
|
|
| 372 |
|
(a) The RunTest script now detects the internal link size and whether there |
| 373 |
|
is UTF-8 and UCP support by running ./pcretest -C instead of relying on |
| 374 |
|
values substituted by "configure". (The RunGrepTest script already did |
| 375 |
|
this for UTF-8.) The configure.ac script no longer substitutes the |
| 376 |
|
relevant variables. |
| 377 |
|
|
| 378 |
|
(b) The debugging options /B and /D in pcretest show the compiled bytecode |
| 379 |
|
with length and offset values. This means that the output is different |
| 380 |
|
for different internal link sizes. Test 2 is skipped for link sizes |
| 381 |
|
other than 2 because of this, bypassing the problem. Unfortunately, |
| 382 |
|
there was also a test in test 3 (the locale tests) that used /B and |
| 383 |
|
failed for link sizes other than 2. Rather than cut the whole test out, |
| 384 |
|
I have added a new /Z option to pcretest that replaces the length and |
| 385 |
|
offset values with spaces. This is now used to make test 3 independent |
| 386 |
|
of link size. (Test 2 will be tidied up later.) |
| 387 |
|
|
| 388 |
|
14. If erroroffset was passed as NULL to pcre_compile, it provoked a |
| 389 |
|
segmentation fault instead of returning the appropriate error message. |
| 390 |
|
|
| 391 |
|
15. In multiline mode when the newline sequence was set to "any", the pattern |
| 392 |
|
^$ would give a match between the \r and \n of a subject such as "A\r\nB". |
| 393 |
|
This doesn't seem right; it now treats the CRLF combination as the line |
| 394 |
|
ending, and so does not match in that case. It's only a pattern such as ^$ |
| 395 |
|
that would hit this one: something like ^ABC$ would have failed after \r |
| 396 |
|
and then tried again after \r\n. |
| 397 |
|
|
| 398 |
|
16. Changed the comparison command for RunGrepTest from "diff -u" to "diff -ub" |
| 399 |
|
in an attempt to make files that differ only in their line terminators |
| 400 |
|
compare equal. This works on Linux. |
| 401 |
|
|
| 402 |
|
17. Under certain error circumstances pcregrep might try to free random memory |
| 403 |
|
as it exited. This is now fixed, thanks to valgrind. |
| 404 |
|
|
| 405 |
|
19. In pcretest, if the pattern /(?m)^$/g<any> was matched against the string |
| 406 |
|
"abc\r\n\r\n", it found an unwanted second match after the second \r. This |
| 407 |
|
was because its rules for how to advance for /g after matching an empty |
| 408 |
|
string at the end of a line did not allow for this case. They now check for |
| 409 |
|
it specially. |
| 410 |
|
|
| 411 |
|
20. pcretest is supposed to handle patterns and data of any length, by |
| 412 |
|
extending its buffers when necessary. It was getting this wrong when the |
| 413 |
|
buffer for a data line had to be extended. |
| 414 |
|
|
| 415 |
|
21. Added PCRE_NEWLINE_ANYCRLF which is like ANY, but matches only CR, LF, or |
| 416 |
|
CRLF as a newline sequence. |
| 417 |
|
|
| 418 |
|
22. Code for handling Unicode properties in pcre_dfa_exec() wasn't being cut |
| 419 |
|
out by #ifdef SUPPORT_UCP. This did no harm, as it could never be used, but |
| 420 |
|
I have nevertheless tidied it up. |
| 421 |
|
|
| 422 |
|
23. Added some casts to kill warnings from HP-UX ia64 compiler. |
| 423 |
|
|
| 424 |
|
24. Added a man page for pcre-config. |
| 425 |
|
|
| 426 |
|
|
| 427 |
|
Version 7.0 19-Dec-06 |
| 428 |
|
--------------------- |
| 429 |
|
|
| 430 |
|
1. Fixed a signed/unsigned compiler warning in pcre_compile.c, shown up by |
| 431 |
|
moving to gcc 4.1.1. |
| 432 |
|
|
| 433 |
|
2. The -S option for pcretest uses setrlimit(); I had omitted to #include |
| 434 |
|
sys/time.h, which is documented as needed for this function. It doesn't |
| 435 |
|
seem to matter on Linux, but it showed up on some releases of OS X. |
| 436 |
|
|
| 437 |
|
3. It seems that there are systems where bytes whose values are greater than |
| 438 |
|
127 match isprint() in the "C" locale. The "C" locale should be the |
| 439 |
|
default when a C program starts up. In most systems, only ASCII printing |
| 440 |
|
characters match isprint(). This difference caused the output from pcretest |
| 441 |
|
to vary, making some of the tests fail. I have changed pcretest so that: |
| 442 |
|
|
| 443 |
|
(a) When it is outputting text in the compiled version of a pattern, bytes |
| 444 |
|
other than 32-126 are always shown as hex escapes. |
| 445 |
|
|
| 446 |
|
(b) When it is outputting text that is a matched part of a subject string, |
| 447 |
|
it does the same, unless a different locale has been set for the match |
| 448 |
|
(using the /L modifier). In this case, it uses isprint() to decide. |
| 449 |
|
|
| 450 |
|
4. Fixed a major bug that caused incorrect computation of the amount of memory |
| 451 |
|
required for a compiled pattern when options that changed within the |
| 452 |
|
pattern affected the logic of the preliminary scan that determines the |
| 453 |
|
length. The relevant options are -x, and -i in UTF-8 mode. The result was |
| 454 |
|
that the computed length was too small. The symptoms of this bug were |
| 455 |
|
either the PCRE error "internal error: code overflow" from pcre_compile(), |
| 456 |
|
or a glibc crash with a message such as "pcretest: free(): invalid next |
| 457 |
|
size (fast)". Examples of patterns that provoked this bug (shown in |
| 458 |
|
pcretest format) are: |
| 459 |
|
|
| 460 |
|
/(?-x: )/x |
| 461 |
|
/(?x)(?-x: \s*#\s*)/ |
| 462 |
|
/((?i)[\x{c0}])/8 |
| 463 |
|
/(?i:[\x{c0}])/8 |
| 464 |
|
|
| 465 |
|
HOWEVER: Change 17 below makes this fix obsolete as the memory computation |
| 466 |
|
is now done differently. |
| 467 |
|
|
| 468 |
|
5. Applied patches from Google to: (a) add a QuoteMeta function to the C++ |
| 469 |
|
wrapper classes; (b) implement a new function in the C++ scanner that is |
| 470 |
|
more efficient than the old way of doing things because it avoids levels of |
| 471 |
|
recursion in the regex matching; (c) add a paragraph to the documentation |
| 472 |
|
for the FullMatch() function. |
| 473 |
|
|
| 474 |
|
6. The escape sequence \n was being treated as whatever was defined as |
| 475 |
|
"newline". Not only was this contrary to the documentation, which states |
| 476 |
|
that \n is character 10 (hex 0A), but it also went horribly wrong when |
| 477 |
|
"newline" was defined as CRLF. This has been fixed. |
| 478 |
|
|
| 479 |
|
7. In pcre_dfa_exec.c the value of an unsigned integer (the variable called c) |
| 480 |
|
was being set to -1 for the "end of line" case (supposedly a value that no |
| 481 |
|
character can have). Though this value is never used (the check for end of |
| 482 |
|
line is "zero bytes in current character"), it caused compiler complaints. |
| 483 |
|
I've changed it to 0xffffffff. |
| 484 |
|
|
| 485 |
|
8. In pcre_version.c, the version string was being built by a sequence of |
| 486 |
|
C macros that, in the event of PCRE_PRERELEASE being defined as an empty |
| 487 |
|
string (as it is for production releases) called a macro with an empty |
| 488 |
|
argument. The C standard says the result of this is undefined. The gcc |
| 489 |
|
compiler treats it as an empty string (which was what was wanted) but it is |
| 490 |
|
reported that Visual C gives an error. The source has been hacked around to |
| 491 |
|
avoid this problem. |
| 492 |
|
|
| 493 |
|
9. On the advice of a Windows user, included <io.h> and <fcntl.h> in Windows |
| 494 |
|
builds of pcretest, and changed the call to _setmode() to use _O_BINARY |
| 495 |
|
instead of 0x8000. Made all the #ifdefs test both _WIN32 and WIN32 (not all |
| 496 |
|
of them did). |
| 497 |
|
|
| 498 |
|
10. Originally, pcretest opened its input and output without "b"; then I was |
| 499 |
|
told that "b" was needed in some environments, so it was added for release |
| 500 |
|
5.0 to both the input and output. (It makes no difference on Unix-like |
| 501 |
|
systems.) Later I was told that it is wrong for the input on Windows. I've |
| 502 |
|
now abstracted the modes into two macros, to make it easier to fiddle with |
| 503 |
|
them, and removed "b" from the input mode under Windows. |
| 504 |
|
|
| 505 |
|
11. Added pkgconfig support for the C++ wrapper library, libpcrecpp. |
| 506 |
|
|
| 507 |
|
12. Added -help and --help to pcretest as an official way of being reminded |
| 508 |
|
of the options. |
| 509 |
|
|
| 510 |
|
13. Removed some redundant semicolons after macro calls in pcrecpparg.h.in |
| 511 |
|
and pcrecpp.cc because they annoy compilers at high warning levels. |
| 512 |
|
|
| 513 |
|
14. A bit of tidying/refactoring in pcre_exec.c in the main bumpalong loop. |
| 514 |
|
|
| 515 |
|
15. Fixed an occurrence of == in configure.ac that should have been = (shell |
| 516 |
|
scripts are not C programs :-) and which was not noticed because it works |
| 517 |
|
on Linux. |
| 518 |
|
|
| 519 |
|
16. pcretest is supposed to handle any length of pattern and data line (as one |
| 520 |
|
line or as a continued sequence of lines) by extending its input buffer if |
| 521 |
|
necessary. This feature was broken for very long pattern lines, leading to |
| 522 |
|
a string of junk being passed to pcre_compile() if the pattern was longer |
| 523 |
|
than about 50K. |
| 524 |
|
|
| 525 |
|
17. I have done a major re-factoring of the way pcre_compile() computes the |
| 526 |
|
amount of memory needed for a compiled pattern. Previously, there was code |
| 527 |
|
that made a preliminary scan of the pattern in order to do this. That was |
| 528 |
|
OK when PCRE was new, but as the facilities have expanded, it has become |
| 529 |
|
harder and harder to keep it in step with the real compile phase, and there |
| 530 |
|
have been a number of bugs (see for example, 4 above). I have now found a |
| 531 |
|
cunning way of running the real compile function in a "fake" mode that |
| 532 |
|
enables it to compute how much memory it would need, while actually only |
| 533 |
|
ever using a few hundred bytes of working memory and without too many |
| 534 |
|
tests of the mode. This should make future maintenance and development |
| 535 |
|
easier. A side effect of this work is that the limit of 200 on the nesting |
| 536 |
|
depth of parentheses has been removed (though this was never a serious |
| 537 |
|
limitation, I suspect). However, there is a downside: pcre_compile() now |
| 538 |
|
runs more slowly than before (30% or more, depending on the pattern). I |
| 539 |
|
hope this isn't a big issue. There is no effect on runtime performance. |
| 540 |
|
|
| 541 |
|
18. Fixed a minor bug in pcretest: if a pattern line was not terminated by a |
| 542 |
|
newline (only possible for the last line of a file) and it was a |
| 543 |
|
pattern that set a locale (followed by /Lsomething), pcretest crashed. |
| 544 |
|
|
| 545 |
|
19. Added additional timing features to pcretest. (1) The -tm option now times |
| 546 |
|
matching only, not compiling. (2) Both -t and -tm can be followed, as a |
| 547 |
|
separate command line item, by a number that specifies the number of |
| 548 |
|
repeats to use when timing. The default is 50000; this gives better |
| 549 |
|
precision, but takes uncomfortably long for very large patterns. |
| 550 |
|
|
| 551 |
|
20. Extended pcre_study() to be more clever in cases where a branch of a |
| 552 |
|
subpattern has no definite first character. For example, (a*|b*)[cd] would |
| 553 |
|
previously give no result from pcre_study(). Now it recognizes that the |
| 554 |
|
first character must be a, b, c, or d. |
| 555 |
|
|
| 556 |
|
21. There was an incorrect error "recursive call could loop indefinitely" if |
| 557 |
|
a subpattern (or the entire pattern) that was being tested for matching an |
| 558 |
|
empty string contained only one non-empty item after a nested subpattern. |
| 559 |
|
For example, the pattern (?>\x{100}*)\d(?R) provoked this error |
| 560 |
|
incorrectly, because the \d was being skipped in the check. |
| 561 |
|
|
| 562 |
|
22. The pcretest program now has a new pattern option /B and a command line |
| 563 |
|
option -b, which is equivalent to adding /B to every pattern. This causes |
| 564 |
|
it to show the compiled bytecode, without the additional information that |
| 565 |
|
-d shows. The effect of -d is now the same as -b with -i (and similarly, /D |
| 566 |
|
is the same as /B/I). |
| 567 |
|
|
| 568 |
|
23. A new optimization is now able automatically to treat some sequences such |
| 569 |
|
as a*b as a*+b. More specifically, if something simple (such as a character |
| 570 |
|
or a simple class like \d) has an unlimited quantifier, and is followed by |
| 571 |
|
something that cannot possibly match the quantified thing, the quantifier |
| 572 |
|
is automatically "possessified". |
| 573 |
|
|
| 574 |
|
24. A recursive reference to a subpattern whose number was greater than 39 |
| 575 |
|
went wrong under certain circumstances in UTF-8 mode. This bug could also |
| 576 |
|
have affected the operation of pcre_study(). |
| 577 |
|
|
| 578 |
|
25. Realized that a little bit of performance could be had by replacing |
| 579 |
|
(c & 0xc0) == 0xc0 with c >= 0xc0 when processing UTF-8 characters. |
| 580 |
|
|
| 581 |
|
26. Timing data from pcretest is now shown to 4 decimal places instead of 3. |
| 582 |
|
|
| 583 |
|
27. Possessive quantifiers such as a++ were previously implemented by turning |
| 584 |
|
them into atomic groups such as ($>a+). Now they have their own opcodes, |
| 585 |
|
which improves performance. This includes the automatically created ones |
| 586 |
|
from 23 above. |
| 587 |
|
|
| 588 |
|
28. A pattern such as (?=(\w+))\1: which simulates an atomic group using a |
| 589 |
|
lookahead was broken if it was not anchored. PCRE was mistakenly expecting |
| 590 |
|
the first matched character to be a colon. This applied both to named and |
| 591 |
|
numbered groups. |
| 592 |
|
|
| 593 |
|
29. The ucpinternal.h header file was missing its idempotency #ifdef. |
| 594 |
|
|
| 595 |
|
30. I was sent a "project" file called libpcre.a.dev which I understand makes |
| 596 |
|
building PCRE on Windows easier, so I have included it in the distribution. |
| 597 |
|
|
| 598 |
|
31. There is now a check in pcretest against a ridiculously large number being |
| 599 |
|
returned by pcre_exec() or pcre_dfa_exec(). If this happens in a /g or /G |
| 600 |
|
loop, the loop is abandoned. |
| 601 |
|
|
| 602 |
|
32. Forward references to subpatterns in conditions such as (?(2)...) where |
| 603 |
|
subpattern 2 is defined later cause pcre_compile() to search forwards in |
| 604 |
|
the pattern for the relevant set of parentheses. This search went wrong |
| 605 |
|
when there were unescaped parentheses in a character class, parentheses |
| 606 |
|
escaped with \Q...\E, or parentheses in a #-comment in /x mode. |
| 607 |
|
|
| 608 |
|
33. "Subroutine" calls and backreferences were previously restricted to |
| 609 |
|
referencing subpatterns earlier in the regex. This restriction has now |
| 610 |
|
been removed. |
| 611 |
|
|
| 612 |
|
34. Added a number of extra features that are going to be in Perl 5.10. On the |
| 613 |
|
whole, these are just syntactic alternatives for features that PCRE had |
| 614 |
|
previously implemented using the Python syntax or my own invention. The |
| 615 |
|
other formats are all retained for compatibility. |
| 616 |
|
|
| 617 |
|
(a) Named groups can now be defined as (?<name>...) or (?'name'...) as well |
| 618 |
|
as (?P<name>...). The new forms, as well as being in Perl 5.10, are |
| 619 |
|
also .NET compatible. |
| 620 |
|
|
| 621 |
|
(b) A recursion or subroutine call to a named group can now be defined as |
| 622 |
|
(?&name) as well as (?P>name). |
| 623 |
|
|
| 624 |
|
(c) A backreference to a named group can now be defined as \k<name> or |
| 625 |
|
\k'name' as well as (?P=name). The new forms, as well as being in Perl |
| 626 |
|
5.10, are also .NET compatible. |
| 627 |
|
|
| 628 |
|
(d) A conditional reference to a named group can now use the syntax |
| 629 |
|
(?(<name>) or (?('name') as well as (?(name). |
| 630 |
|
|
| 631 |
|
(e) A "conditional group" of the form (?(DEFINE)...) can be used to define |
| 632 |
|
groups (named and numbered) that are never evaluated inline, but can be |
| 633 |
|
called as "subroutines" from elsewhere. In effect, the DEFINE condition |
| 634 |
|
is always false. There may be only one alternative in such a group. |
| 635 |
|
|
| 636 |
|
(f) A test for recursion can be given as (?(R1).. or (?(R&name)... as well |
| 637 |
|
as the simple (?(R). The condition is true only if the most recent |
| 638 |
|
recursion is that of the given number or name. It does not search out |
| 639 |
|
through the entire recursion stack. |
| 640 |
|
|
| 641 |
|
(g) The escape \gN or \g{N} has been added, where N is a positive or |
| 642 |
|
negative number, specifying an absolute or relative reference. |
| 643 |
|
|
| 644 |
|
35. Tidied to get rid of some further signed/unsigned compiler warnings and |
| 645 |
|
some "unreachable code" warnings. |
| 646 |
|
|
| 647 |
|
36. Updated the Unicode property tables to Unicode version 5.0.0. Amongst other |
| 648 |
|
things, this adds five new scripts. |
| 649 |
|
|
| 650 |
|
37. Perl ignores orphaned \E escapes completely. PCRE now does the same. |
| 651 |
|
There were also incompatibilities regarding the handling of \Q..\E inside |
| 652 |
|
character classes, for example with patterns like [\Qa\E-\Qz\E] where the |
| 653 |
|
hyphen was adjacent to \Q or \E. I hope I've cleared all this up now. |
| 654 |
|
|
| 655 |
|
38. Like Perl, PCRE detects when an indefinitely repeated parenthesized group |
| 656 |
|
matches an empty string, and forcibly breaks the loop. There were bugs in |
| 657 |
|
this code in non-simple cases. For a pattern such as ^(a()*)* matched |
| 658 |
|
against aaaa the result was just "a" rather than "aaaa", for example. Two |
| 659 |
|
separate and independent bugs (that affected different cases) have been |
| 660 |
|
fixed. |
| 661 |
|
|
| 662 |
|
39. Refactored the code to abolish the use of different opcodes for small |
| 663 |
|
capturing bracket numbers. This is a tidy that I avoided doing when I |
| 664 |
|
removed the limit on the number of capturing brackets for 3.5 back in 2001. |
| 665 |
|
The new approach is not only tidier, it makes it possible to reduce the |
| 666 |
|
memory needed to fix the previous bug (38). |
| 667 |
|
|
| 668 |
|
40. Implemented PCRE_NEWLINE_ANY to recognize any of the Unicode newline |
| 669 |
|
sequences (http://unicode.org/unicode/reports/tr18/) as "newline" when |
| 670 |
|
processing dot, circumflex, or dollar metacharacters, or #-comments in /x |
| 671 |
|
mode. |
| 672 |
|
|
| 673 |
|
41. Add \R to match any Unicode newline sequence, as suggested in the Unicode |
| 674 |
|
report. |
| 675 |
|
|
| 676 |
|
42. Applied patch, originally from Ari Pollak, modified by Google, to allow |
| 677 |
|
copy construction and assignment in the C++ wrapper. |
| 678 |
|
|
| 679 |
|
43. Updated pcregrep to support "--newline=any". In the process, I fixed a |
| 680 |
|
couple of bugs that could have given wrong results in the "--newline=crlf" |
| 681 |
|
case. |
| 682 |
|
|
| 683 |
|
44. Added a number of casts and did some reorganization of signed/unsigned int |
| 684 |
|
variables following suggestions from Dair Grant. Also renamed the variable |
| 685 |
|
"this" as "item" because it is a C++ keyword. |
| 686 |
|
|
| 687 |
|
45. Arranged for dftables to add |
| 688 |
|
|
| 689 |
|
#include "pcre_internal.h" |
| 690 |
|
|
| 691 |
|
to pcre_chartables.c because without it, gcc 4.x may remove the array |
| 692 |
|
definition from the final binary if PCRE is built into a static library and |
| 693 |
|
dead code stripping is activated. |
| 694 |
|
|
| 695 |
|
46. For an unanchored pattern, if a match attempt fails at the start of a |
| 696 |
|
newline sequence, and the newline setting is CRLF or ANY, and the next two |
| 697 |
|
characters are CRLF, advance by two characters instead of one. |
| 698 |
|
|
| 699 |
|
|
| 700 |
Version 6.7 04-Jul-06 |
Version 6.7 04-Jul-06 |
| 701 |
--------------------- |
--------------------- |
| 702 |
|
|
Parent Directory
| 
Revision Log
| 
Patch