diff options
| author | ph10 <ph10@2f5784b3-3f2a-0410-8824-cb99058d5e15> | 2011-12-06 15:38:01 +0000 |
|---|---|---|
| committer | ph10 <ph10@2f5784b3-3f2a-0410-8824-cb99058d5e15> | 2011-12-06 15:38:01 +0000 |
| commit | 4145bb1ecab77682c81fb99bdd0380bf64a6392e (patch) | |
| tree | 1739fd5605222d1986f72584086519115e0a2046 | |
| parent | 475e97e3c2ef83094b3b2239b7cf4ffcc2c05f68 (diff) | |
| download | pcre-4145bb1ecab77682c81fb99bdd0380bf64a6392e.tar.gz | |
Source tidies for 8.21-RC1
git-svn-id: svn://vcs.exim.org/pcre/code/trunk@788 2f5784b3-3f2a-0410-8824-cb99058d5e15
| -rw-r--r-- | NEWS | 2 | ||||
| -rw-r--r-- | doc/html/index.html | 16 | ||||
| -rw-r--r-- | doc/html/pcreapi.html | 16 | ||||
| -rw-r--r-- | doc/html/pcrecallout.html | 2 | ||||
| -rw-r--r-- | doc/html/pcrecompat.html | 2 | ||||
| -rw-r--r-- | doc/html/pcrejit.html | 14 | ||||
| -rw-r--r-- | doc/html/pcrepattern.html | 20 | ||||
| -rw-r--r-- | doc/html/pcretest.html | 4 | ||||
| -rw-r--r-- | doc/pcre.txt | 68 | ||||
| -rw-r--r-- | doc/pcreapi.3 | 16 | ||||
| -rw-r--r-- | doc/pcrecallout.3 | 2 | ||||
| -rw-r--r-- | doc/pcrecompat.3 | 2 | ||||
| -rw-r--r-- | doc/pcrejit.3 | 14 | ||||
| -rw-r--r-- | doc/pcrepattern.3 | 20 | ||||
| -rw-r--r-- | doc/pcretest.1 | 4 | ||||
| -rw-r--r-- | pcre.h.in | 6 | ||||
| -rw-r--r-- | pcre_compile.c | 132 | ||||
| -rw-r--r-- | pcre_exec.c | 38 | ||||
| -rw-r--r-- | pcre_fullinfo.c | 12 | ||||
| -rw-r--r-- | pcre_internal.h | 6 | ||||
| -rw-r--r-- | pcre_jit_compile.c | 4 | ||||
| -rw-r--r-- | pcreposix.c | 6 | ||||
| -rw-r--r-- | pcretest.c | 12 |
23 files changed, 209 insertions, 209 deletions
@@ -4,7 +4,7 @@ News about PCRE releases Release 8.21 05-Dec-2011 ------------------------ -This is mostly a bug-fix release. The only new feature is the ability to obtain +This is mostly a bug-fix release. The only new feature is the ability to obtain the memory used by the JIT compiler. diff --git a/doc/html/index.html b/doc/html/index.html index fc93ed0..75361fd 100644 --- a/doc/html/index.html +++ b/doc/html/index.html @@ -1,10 +1,10 @@ <html> -<!-- This is a manually maintained file that is the root of the HTML version of - the PCRE documentation. When the HTML documents are built from the man - page versions, the entire doc/html directory is emptied, this file is then - copied into doc/html/index.html, and the remaining files therein are +<!-- This is a manually maintained file that is the root of the HTML version of + the PCRE documentation. When the HTML documents are built from the man + page versions, the entire doc/html directory is emptied, this file is then + copied into doc/html/index.html, and the remaining files therein are created by the 132html script. ---> +--> <head> <title>PCRE specification</title> </head> @@ -83,11 +83,11 @@ The HTML documentation for PCRE comprises the following pages: </table> <p> -There are also individual pages that summarize the interface for each function +There are also individual pages that summarize the interface for each function in the library: </p> -<table> +<table> <tr><td><a href="pcre_assign_jit_stack.html">pcre_assign_jit_stack</a></td> <td> Assign stack for JIT matching</td></tr> @@ -150,7 +150,7 @@ in the library: <tr><td><a href="pcre_maketables.html">pcre_maketables</a></td> <td> Build character tables in current locale</td></tr> - + <tr><td><a href="pcre_refcount.html">pcre_refcount</a></td> <td> Maintain reference count in compiled pattern</td></tr> diff --git a/doc/html/pcreapi.html b/doc/html/pcreapi.html index 9ddae5b..3cbb6be 100644 --- a/doc/html/pcreapi.html +++ b/doc/html/pcreapi.html @@ -651,20 +651,20 @@ pattern such as (\1)(a) succeeds when this option is set (assuming it can find an "a" in the subject), whereas it fails by default, for Perl compatibility. </P> <P> -(3) \U matches an upper case "U" character; by default \U causes a compile +(3) \U matches an upper case "U" character; by default \U causes a compile time error (Perl uses \U to upper case subsequent characters). </P> <P> -(4) \u matches a lower case "u" character unless it is followed by four -hexadecimal digits, in which case the hexadecimal number defines the code point -to match. By default, \u causes a compile time error (Perl uses it to upper +(4) \u matches a lower case "u" character unless it is followed by four +hexadecimal digits, in which case the hexadecimal number defines the code point +to match. By default, \u causes a compile time error (Perl uses it to upper case the following character). </P> <P> -(5) \x matches a lower case "x" character unless it is followed by two -hexadecimal digits, in which case the hexadecimal number defines the code point -to match. By default, as in Perl, a hexadecimal number is always expected after -\x, but it may have zero, one, or two digits (so, for example, \xz matches a +(5) \x matches a lower case "x" character unless it is followed by two +hexadecimal digits, in which case the hexadecimal number defines the code point +to match. By default, as in Perl, a hexadecimal number is always expected after +\x, but it may have zero, one, or two digits (so, for example, \xz matches a binary zero character followed by z). <pre> PCRE_MULTILINE diff --git a/doc/html/pcrecallout.html b/doc/html/pcrecallout.html index e94ffec..e891fdf 100644 --- a/doc/html/pcrecallout.html +++ b/doc/html/pcrecallout.html @@ -190,7 +190,7 @@ same callout number. However, they are set for all callouts. The <i>mark</i> field is present from version 2 of the <i>pcre_callout</i> structure. In callouts from <b>pcre_exec()</b> it contains a pointer to the zero-terminated name of the most recently passed (*MARK), (*PRUNE), or (*THEN) -item in the match, or NULL if no such items have been passed. Instances of +item in the match, or NULL if no such items have been passed. Instances of (*PRUNE) or (*THEN) without a name do not obliterate a previous (*MARK). In callouts from <b>pcre_dfa_exec()</b> this field always contains NULL. </P> diff --git a/doc/html/pcrecompat.html b/doc/html/pcrecompat.html index 9a09318..4e5e18b 100644 --- a/doc/html/pcrecompat.html +++ b/doc/html/pcrecompat.html @@ -53,7 +53,7 @@ represent a binary zero. own, matching a non-newline character, is supported.) In fact these are implemented by Perl's general string-handling and are not part of its pattern matching engine. If any of these are encountered by PCRE, an error is -generated by default. However, if the PCRE_JAVASCRIPT_COMPAT option is set, +generated by default. However, if the PCRE_JAVASCRIPT_COMPAT option is set, \U and \u are interpreted as JavaScript interprets them. </P> <P> diff --git a/doc/html/pcrejit.html b/doc/html/pcrejit.html index c5b2a48..7411ecf 100644 --- a/doc/html/pcrejit.html +++ b/doc/html/pcrejit.html @@ -68,7 +68,7 @@ way that falls back to the ordinary PCRE code if JIT is not available. If your program may sometimes be linked with versions of PCRE that are older than 8.20, but you want to use JIT when it is available, you can test the values of PCRE_MAJOR and PCRE_MINOR, or the existence of a JIT macro such -as PCRE_CONFIG_JIT, for compile-time control of your code. +as PCRE_CONFIG_JIT, for compile-time control of your code. </P> <br><a name="SEC3" href="#TOC1">SIMPLE USE OF JIT</a><br> <P> @@ -88,7 +88,7 @@ For a program that may be linked with pre-8.20 versions of PCRE, you can insert #define PCRE_STUDY_JIT_COMPILE 0 #endif </pre> -so that no option is passed to <b>pcre_study()</b>, and then use something like +so that no option is passed to <b>pcre_study()</b>, and then use something like this to free the study data: <pre> #ifdef PCRE_CONFIG_JIT @@ -188,7 +188,7 @@ is given when there is not enough stack. Three functions are provided for managing blocks of memory for use as JIT stacks. There is further discussion about the use of JIT stacks in the section entitled <a href="#stackcontrol">"JIT stack FAQ"</a> -below. +below. </P> <P> The <b>pcre_jit_stack_alloc()</b> function creates a JIT stack. Its arguments @@ -269,7 +269,7 @@ Although it is possible, its updating time overhead decreases performance. So we do the recursion in memory. </P> <P> -(2) Why don't we simply allocate blocks of memory with <b>malloc()</b>? +(2) Why don't we simply allocate blocks of memory with <b>malloc()</b>? <br> <br> Modern operating systems have a nice feature: they can reserve an address space @@ -280,7 +280,7 @@ only a single memory page (usually 4K) if that is enough. However, we can still grow up to 1M anytime if needed. </P> <P> -(3) Who "owns" a JIT stack? +(3) Who "owns" a JIT stack? <br> <br> The owner of the stack is the user program, not the JIT studied pattern or @@ -317,7 +317,7 @@ list of the currently JIT studied patterns. <P> (6) OK, the stack is for long term memory allocation. But what happens if a pattern causes stack overflow with a stack of 1M? Is that 1M kept until the -stack is freed? +stack is freed? <br> <br> Especially on embedded sytems, it might be a good idea to release @@ -328,7 +328,7 @@ stack) would be a good idea if someone needs this. </P> <P> (7) This is too much of a headache. Isn't there any better solution for JIT -stack handling? +stack handling? <br> <br> No, thanks to Windows. If POSIX threads were used everywhere, we could throw diff --git a/doc/html/pcrepattern.html b/doc/html/pcrepattern.html index 3efb367..aa39d63 100644 --- a/doc/html/pcrepattern.html +++ b/doc/html/pcrepattern.html @@ -269,7 +269,7 @@ one of the following escape sequences than the binary character it represents: \ddd character with octal code ddd, or back reference \xhh character with hex code hh \x{hhh..} character with hex code hhh.. (non-JavaScript mode) - \uhhhh character with hex code hhhh (JavaScript mode only) + \uhhhh character with hex code hhhh (JavaScript mode only) </pre> The precise effect of \cx is as follows: if x is a lower case letter, it is converted to upper case. Then bit 6 of the character (hex 40) is inverted. @@ -295,16 +295,16 @@ initial \x will be interpreted as a basic hexadecimal escape, with no following digits, giving a character whose value is zero. </P> <P> -If the PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \x is -as just described only when it is followed by two hexadecimal digits. +If the PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \x is +as just described only when it is followed by two hexadecimal digits. Otherwise, it matches a literal "x" character. In JavaScript mode, support for -code points greater than 256 is provided by \u, which must be followed by +code points greater than 256 is provided by \u, which must be followed by four hexadecimal digits; otherwise it matches a literal "u" character. </P> <P> Characters whose value is less than 256 can be defined by either of the two syntaxes for \x (or by \u in JavaScript mode). There is no difference in the -way they are handled. For example, \xdc is exactly the same as \x{dc} (or +way they are handled. For example, \xdc is exactly the same as \x{dc} (or \u00dc in JavaScript mode). </P> <P> @@ -411,7 +411,7 @@ Another use of backslash is for specifying generic character types: There is also the single sequence \N, which matches a non-newline character. This is the same as <a href="#fullstopdot">the "." metacharacter</a> -when PCRE_DOTALL is not set. Perl also uses \N to match characters by name; +when PCRE_DOTALL is not set. Perl also uses \N to match characters by name; PCRE does not support this. </P> <P> @@ -2562,7 +2562,7 @@ when calling <b>pcre_compile()</b> or <b>pcre_exec()</b>, or by starting the pattern with (*NO_START_OPT). </P> <P> -Experiments with Perl suggest that it too has similar optimizations, sometimes +Experiments with Perl suggest that it too has similar optimizations, sometimes leading to anomalous results. </P> <br><b> @@ -2612,7 +2612,7 @@ A name is always required with this verb. There may be as many instances of (*MARK) as you like in a pattern, and their names do not have to be unique. </P> <P> -When a match succeeds, the name of the last-encountered (*MARK) on the matching +When a match succeeds, the name of the last-encountered (*MARK) on the matching path is passed back to the caller via the <i>pcre_extra</i> data structure, as described in the <a href="pcreapi.html#extradata">section on <i>pcre_extra</i></a> @@ -2648,8 +2648,8 @@ After a partial match or a failed match, the name of the last encountered No match, mark = B </pre> Note that in this unanchored example the mark is retained from the match -attempt that started at the letter "X". Subsequent match attempts starting at -"P" and then with an empty string do not get as far as the (*MARK) item, but +attempt that started at the letter "X". Subsequent match attempts starting at +"P" and then with an empty string do not get as far as the (*MARK) item, but nevertheless do not reset it. </P> <br><b> diff --git a/doc/html/pcretest.html b/doc/html/pcretest.html index 80d224b..c883064 100644 --- a/doc/html/pcretest.html +++ b/doc/html/pcretest.html @@ -364,9 +364,9 @@ which it appears. </P> <P> The <b>/M</b> modifier causes the size of memory block used to hold the compiled -pattern to be output. This does not include the size of the <b>pcre</b> block; +pattern to be output. This does not include the size of the <b>pcre</b> block; it is just the actual compiled data. If the pattern is successfully studied -with the PCRE_STUDY_JIT_COMPILE option, the size of the JIT compiled code is +with the PCRE_STUDY_JIT_COMPILE option, the size of the JIT compiled code is also output. </P> <P> diff --git a/doc/pcre.txt b/doc/pcre.txt index 126b7dd..4750c59 100644 --- a/doc/pcre.txt +++ b/doc/pcre.txt @@ -120,8 +120,8 @@ REVISION Last updated: 24 August 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREBUILD(3) PCREBUILD(3) @@ -484,8 +484,8 @@ REVISION Last updated: 06 September 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREMATCHING(3) PCREMATCHING(3) @@ -688,8 +688,8 @@ REVISION Last updated: 19 November 2011 Copyright (c) 1997-2010 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREAPI(3) PCREAPI(3) @@ -3007,8 +3007,8 @@ REVISION Last updated: 02 December 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCRECALLOUT(3) PCRECALLOUT(3) @@ -3202,8 +3202,8 @@ REVISION Last updated: 30 November 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCRECOMPAT(3) PCRECOMPAT(3) @@ -3376,8 +3376,8 @@ REVISION Last updated: 14 November 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREPATTERN(3) PCREPATTERN(3) @@ -5963,8 +5963,8 @@ REVISION Last updated: 29 November 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCRESYNTAX(3) PCRESYNTAX(3) @@ -6333,8 +6333,8 @@ REVISION Last updated: 21 November 2010 Copyright (c) 1997-2010 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREUNICODE(3) PCREUNICODE(3) @@ -6487,8 +6487,8 @@ REVISION Last updated: 19 October 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREJIT(3) PCREJIT(3) @@ -6834,8 +6834,8 @@ REVISION Last updated: 26 November 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREPARTIAL(3) PCREPARTIAL(3) @@ -7256,8 +7256,8 @@ REVISION Last updated: 26 August 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREPRECOMPILE(3) PCREPRECOMPILE(3) @@ -7387,8 +7387,8 @@ REVISION Last updated: 26 August 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREPERFORM(3) PCREPERFORM(3) @@ -7555,8 +7555,8 @@ REVISION Last updated: 16 May 2010 Copyright (c) 1997-2010 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCREPOSIX(3) PCREPOSIX(3) @@ -7818,8 +7818,8 @@ REVISION Last updated: 16 May 2010 Copyright (c) 1997-2010 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCRECPP(3) PCRECPP(3) @@ -8160,8 +8160,8 @@ REVISION Last updated: 17 March 2009 Minor typo fixed: 25 July 2011 ------------------------------------------------------------------------------ - - + + PCRESAMPLE(3) PCRESAMPLE(3) @@ -8301,8 +8301,8 @@ REVISION Last updated: 30 November 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + PCRESTACK(3) PCRESTACK(3) @@ -8462,5 +8462,5 @@ REVISION Last updated: 26 August 2011 Copyright (c) 1997-2011 University of Cambridge. ------------------------------------------------------------------------------ - - + + diff --git a/doc/pcreapi.3 b/doc/pcreapi.3 index 7a352fd..a59cd05 100644 --- a/doc/pcreapi.3 +++ b/doc/pcreapi.3 @@ -644,18 +644,18 @@ string (by default this causes the current matching alternative to fail). A pattern such as (\e1)(a) succeeds when this option is set (assuming it can find an "a" in the subject), whereas it fails by default, for Perl compatibility. .P -(3) \eU matches an upper case "U" character; by default \eU causes a compile +(3) \eU matches an upper case "U" character; by default \eU causes a compile time error (Perl uses \eU to upper case subsequent characters). .P -(4) \eu matches a lower case "u" character unless it is followed by four -hexadecimal digits, in which case the hexadecimal number defines the code point -to match. By default, \eu causes a compile time error (Perl uses it to upper +(4) \eu matches a lower case "u" character unless it is followed by four +hexadecimal digits, in which case the hexadecimal number defines the code point +to match. By default, \eu causes a compile time error (Perl uses it to upper case the following character). .P -(5) \ex matches a lower case "x" character unless it is followed by two -hexadecimal digits, in which case the hexadecimal number defines the code point -to match. By default, as in Perl, a hexadecimal number is always expected after -\ex, but it may have zero, one, or two digits (so, for example, \exz matches a +(5) \ex matches a lower case "x" character unless it is followed by two +hexadecimal digits, in which case the hexadecimal number defines the code point +to match. By default, as in Perl, a hexadecimal number is always expected after +\ex, but it may have zero, one, or two digits (so, for example, \exz matches a binary zero character followed by z). .sp PCRE_MULTILINE diff --git a/doc/pcrecallout.3 b/doc/pcrecallout.3 index 6f6102d..ca14277 100644 --- a/doc/pcrecallout.3 +++ b/doc/pcrecallout.3 @@ -161,7 +161,7 @@ same callout number. However, they are set for all callouts. The \fImark\fP field is present from version 2 of the \fIpcre_callout\fP structure. In callouts from \fBpcre_exec()\fP it contains a pointer to the zero-terminated name of the most recently passed (*MARK), (*PRUNE), or (*THEN) -item in the match, or NULL if no such items have been passed. Instances of +item in the match, or NULL if no such items have been passed. Instances of (*PRUNE) or (*THEN) without a name do not obliterate a previous (*MARK). In callouts from \fBpcre_dfa_exec()\fP this field always contains NULL. . diff --git a/doc/pcrecompat.3 b/doc/pcrecompat.3 index 69bcf90..64d3dbc 100644 --- a/doc/pcrecompat.3 +++ b/doc/pcrecompat.3 @@ -38,7 +38,7 @@ represent a binary zero. own, matching a non-newline character, is supported.) In fact these are implemented by Perl's general string-handling and are not part of its pattern matching engine. If any of these are encountered by PCRE, an error is -generated by default. However, if the PCRE_JAVASCRIPT_COMPAT option is set, +generated by default. However, if the PCRE_JAVASCRIPT_COMPAT option is set, \eU and \eu are interpreted as JavaScript interprets them. .P 6. The Perl escape sequences \ep, \eP, and \eX are supported only if PCRE is diff --git a/doc/pcrejit.3 b/doc/pcrejit.3 index fba349c..ba68301 100644 --- a/doc/pcrejit.3 +++ b/doc/pcrejit.3 @@ -43,7 +43,7 @@ way that falls back to the ordinary PCRE code if JIT is not available. If your program may sometimes be linked with versions of PCRE that are older than 8.20, but you want to use JIT when it is available, you can test the values of PCRE_MAJOR and PCRE_MINOR, or the existence of a JIT macro such -as PCRE_CONFIG_JIT, for compile-time control of your code. +as PCRE_CONFIG_JIT, for compile-time control of your code. . . .SH "SIMPLE USE OF JIT" @@ -65,7 +65,7 @@ For a program that may be linked with pre-8.20 versions of PCRE, you can insert #define PCRE_STUDY_JIT_COMPILE 0 #endif .sp -so that no option is passed to \fBpcre_study()\fP, and then use something like +so that no option is passed to \fBpcre_study()\fP, and then use something like this to free the study data: .sp #ifdef PCRE_CONFIG_JIT @@ -179,7 +179,7 @@ about the use of JIT stacks in the section entitled .\" </a> "JIT stack FAQ" .\" -below. +below. .P The \fBpcre_jit_stack_alloc()\fP function creates a JIT stack. Its arguments are a starting size and a maximum size, and it returns a pointer to an opaque @@ -256,7 +256,7 @@ stack chain needs to be updated every time if we extend the stack on PowerPC. Although it is possible, its updating time overhead decreases performance. So we do the recursion in memory. .P -(2) Why don't we simply allocate blocks of memory with \fBmalloc()\fP? +(2) Why don't we simply allocate blocks of memory with \fBmalloc()\fP? .sp Modern operating systems have a nice feature: they can reserve an address space instead of allocating memory. We can safely allocate memory pages inside this @@ -265,7 +265,7 @@ important because of pointers). Thus we can allocate 1M address space, and use only a single memory page (usually 4K) if that is enough. However, we can still grow up to 1M anytime if needed. .P -(3) Who "owns" a JIT stack? +(3) Who "owns" a JIT stack? .sp The owner of the stack is the user program, not the JIT studied pattern or anything else. The user program must ensure that if a stack is used by @@ -296,7 +296,7 @@ list of the currently JIT studied patterns. .P (6) OK, the stack is for long term memory allocation. But what happens if a pattern causes stack overflow with a stack of 1M? Is that 1M kept until the -stack is freed? +stack is freed? .sp Especially on embedded sytems, it might be a good idea to release memory sometimes without freeing the stack. There is no API for this at the @@ -305,7 +305,7 @@ memory for any stack and another which allows releasing memory (shrinking the stack) would be a good idea if someone needs this. .P (7) This is too much of a headache. Isn't there any better solution for JIT -stack handling? +stack handling? .sp No, thanks to Windows. If POSIX threads were used everywhere, we could throw out this complicated API. diff --git a/doc/pcrepattern.3 b/doc/pcrepattern.3 index 84948f3..bb8a4a0 100644 --- a/doc/pcrepattern.3 +++ b/doc/pcrepattern.3 @@ -242,7 +242,7 @@ one of the following escape sequences than the binary character it represents: \eddd character with octal code ddd, or back reference \exhh character with hex code hh \ex{hhh..} character with hex code hhh.. (non-JavaScript mode) - \euhhhh character with hex code hhhh (JavaScript mode only) + \euhhhh character with hex code hhhh (JavaScript mode only) .sp The precise effect of \ecx is as follows: if x is a lower case letter, it is converted to upper case. Then bit 6 of the character (hex 40) is inverted. @@ -265,15 +265,15 @@ there is no terminating }, this form of escape is not recognized. Instead, the initial \ex will be interpreted as a basic hexadecimal escape, with no following digits, giving a character whose value is zero. .P -If the PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \ex is -as just described only when it is followed by two hexadecimal digits. +If the PCRE_JAVASCRIPT_COMPAT option is set, the interpretation of \ex is +as just described only when it is followed by two hexadecimal digits. Otherwise, it matches a literal "x" character. In JavaScript mode, support for -code points greater than 256 is provided by \eu, which must be followed by +code points greater than 256 is provided by \eu, which must be followed by four hexadecimal digits; otherwise it matches a literal "u" character. .P Characters whose value is less than 256 can be defined by either of the two syntaxes for \ex (or by \eu in JavaScript mode). There is no difference in the -way they are handled. For example, \exdc is exactly the same as \ex{dc} (or +way they are handled. For example, \exdc is exactly the same as \ex{dc} (or \eu00dc in JavaScript mode). .P After \e0 up to two further octal digits are read. If there are fewer than two @@ -407,7 +407,7 @@ This is the same as .\" </a> the "." metacharacter .\" -when PCRE_DOTALL is not set. Perl also uses \eN to match characters by name; +when PCRE_DOTALL is not set. Perl also uses \eN to match characters by name; PCRE does not support this. .P Each pair of lower and upper case escape sequences partitions the complete set @@ -2593,7 +2593,7 @@ the start-of-match optimizations by setting the PCRE_NO_START_OPTIMIZE option when calling \fBpcre_compile()\fP or \fBpcre_exec()\fP, or by starting the pattern with (*NO_START_OPT). .P -Experiments with Perl suggest that it too has similar optimizations, sometimes +Experiments with Perl suggest that it too has similar optimizations, sometimes leading to anomalous results. . . @@ -2642,7 +2642,7 @@ starting point (see (*SKIP) below). A name is always required with this verb. There may be as many instances of (*MARK) as you like in a pattern, and their names do not have to be unique. .P -When a match succeeds, the name of the last-encountered (*MARK) on the matching +When a match succeeds, the name of the last-encountered (*MARK) on the matching path is passed back to the caller via the \fIpcre_extra\fP data structure, as described in the .\" HTML <a href="pcreapi.html#extradata"> @@ -2681,8 +2681,8 @@ After a partial match or a failed match, the name of the last encountered No match, mark = B .sp Note that in this unanchored example the mark is retained from the match -attempt that started at the letter "X". Subsequent match attempts starting at -"P" and then with an empty string do not get as far as the (*MARK) item, but +attempt that started at the letter "X". Subsequent match attempts starting at +"P" and then with an empty string do not get as far as the (*MARK) item, but nevertheless do not reset it. . . diff --git a/doc/pcretest.1 b/doc/pcretest.1 index 31656cf..968a232 100644 --- a/doc/pcretest.1 +++ b/doc/pcretest.1 @@ -319,9 +319,9 @@ as the tables pointer; that is, \fB/L\fP applies only to the expression on which it appears. .P The \fB/M\fP modifier causes the size of memory block used to hold the compiled -pattern to be output. This does not include the size of the \fBpcre\fP block; +pattern to be output. This does not include the size of the \fBpcre\fP block; it is just the actual compiled data. If the pattern is successfully studied -with the PCRE_STUDY_JIT_COMPILE option, the size of the JIT compiled code is +with the PCRE_STUDY_JIT_COMPILE option, the size of the JIT compiled code is also output. .P If the \fB/S\fP modifier appears once, it causes \fBpcre_study()\fP to be @@ -98,9 +98,9 @@ extern "C" { /* Options. Some are compile-time only, some are run-time only, and some are both, so we keep them all distinct. However, almost all the bits in the options word are now used. In the long run, we may have to re-use some of the -compile-time only bits for runtime options, or vice versa. In the comments -below, "compile", "exec", and "DFA exec" mean that the option is permitted to -be set for those functions; "used in" means that an option may be set only for +compile-time only bits for runtime options, or vice versa. In the comments +below, "compile", "exec", and "DFA exec" mean that the option is permitted to +be set for those functions; "used in" means that an option may be set only for compile, but is subsequently referenced in exec and/or DFA exec. Any of the compile-time options may be inspected during studying (and therefore JIT compiling). */ diff --git a/pcre_compile.c b/pcre_compile.c index f3d8dd5..568816d 100644 --- a/pcre_compile.c +++ b/pcre_compile.c @@ -88,12 +88,12 @@ so this number is very generous. The same workspace is used during the second, actual compile phase for remembering forward references to groups so that they can be filled in at the end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE -is 4 there is plenty of room for most patterns. However, the memory can get +is 4 there is plenty of room for most patterns. However, the memory can get filled up by repetitions of forward references, for example patterns like -/(?1){0,1999}(b)/, and one user did hit the limit. The code has been changed so +/(?1){0,1999}(b)/, and one user did hit the limit. The code has been changed so that the workspace is expanded using malloc() in this situation. The value below is therefore a minimum, and we put a maximum on it for safety. The -minimum is now also defined in terms of LINK_SIZE so that the use of malloc() +minimum is now also defined in terms of LINK_SIZE so that the use of malloc() kicks in at the same number of forward references in all cases. */ #define COMPILE_WORK_SIZE (2048*LINK_SIZE) @@ -419,8 +419,8 @@ static const char error_texts[] = "\\k is not followed by a braced, angle-bracketed, or quoted name\0" /* 70 */ "internal error: unknown opcode in find_fixedlength()\0" - "\\N is not supported in a class\0" - "too many forward references\0" + "\\N is not supported in a class\0" + "too many forward references\0" ; /* Table to identify digits and hex digits. This is used when compiling @@ -592,9 +592,9 @@ return s; * Expand the workspace * *************************************************/ -/* This function is called during the second compiling phase, if the number of -forward references fills the existing workspace, which is originally a block on -the stack. A larger block is obtained from malloc() unless the ultimate limit +/* This function is called during the second compiling phase, if the number of +forward references fills the existing workspace, which is originally a block on +the stack. A larger block is obtained from malloc() unless the ultimate limit has been reached or the increase will be rather small. Argument: pointer to the compile data block @@ -617,7 +617,7 @@ if (newspace == NULL) return ERR21; memcpy(newspace, cd->start_workspace, cd->workspace_size); cd->hwm = (uschar *)newspace + (cd->hwm - cd->start_workspace); -if (cd->workspace_size > COMPILE_WORK_SIZE) +if (cd->workspace_size > COMPILE_WORK_SIZE) (pcre_free)((void *)cd->start_workspace); cd->start_workspace = newspace; cd->workspace_size = newsize; @@ -1749,7 +1749,7 @@ for (;;) cc++; break; - /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode; + /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode; otherwise \C is coded as OP_ALLANY. */ case OP_ANYBYTE: @@ -3377,7 +3377,7 @@ for (;; ptr++) #ifdef PCRE_DEBUG if (code > cd->hwm) cd->hwm = code; /* High water info */ #endif - if (code > cd->start_workspace + cd->workspace_size - + if (code > cd->start_workspace + cd->workspace_size - WORK_SIZE_SAFETY_MARGIN) /* Check for overrun */ { *errorcodeptr = ERR52; @@ -3428,7 +3428,7 @@ for (;; ptr++) /* In the real compile phase, just check the workspace used by the forward reference list. */ - else if (cd->hwm > cd->start_workspace + cd->workspace_size - + else if (cd->hwm > cd->start_workspace + cd->workspace_size - WORK_SIZE_SAFETY_MARGIN) { *errorcodeptr = ERR52; @@ -3822,8 +3822,8 @@ for (;; ptr++) else if (-c == ESC_N) /* \N is not supported in a class */ { *errorcodeptr = ERR71; - goto FAILED; - } + goto FAILED; + } else if (-c == ESC_Q) /* Handle start of quoted string */ { if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E) @@ -4480,7 +4480,7 @@ for (;; ptr++) past, but it no longer happens for non-repeated recursions. In fact, the repeated ones could be re-implemented independently so as not to need this, but for the moment we rely on the code for repeating groups. */ - + if (*previous == OP_RECURSE) { memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE); @@ -4932,8 +4932,8 @@ for (;; ptr++) } /* This is compiling for real. If there is a set first byte for - the group, and we have not yet set a "required byte", set it. Make - sure there is enough workspace for copying forward references before + the group, and we have not yet set a "required byte", set it. Make + sure there is enough workspace for copying forward references before doing the copy. */ else @@ -4945,7 +4945,7 @@ for (;; ptr++) uschar *hc; uschar *this_hwm = cd->hwm; memcpy(code, previous, len); - + while (cd->hwm > cd->start_workspace + cd->workspace_size - WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm)) { @@ -4954,9 +4954,9 @@ for (;; ptr++) *errorcodeptr = expand_workspace(cd); if (*errorcodeptr != 0) goto FAILED; save_hwm = (uschar *)cd->start_workspace + save_offset; - this_hwm = (uschar *)cd->start_workspace + this_offset; - } - + this_hwm = (uschar *)cd->start_workspace + this_offset; + } + for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE) { PUT(cd->hwm, 0, GET(hc, 0) + len); @@ -4986,7 +4986,7 @@ for (;; ptr++) add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is a 64-bit integer type when available, otherwise double. */ - + if (lengthptr != NULL && repeat_max > 0) { int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) - @@ -5024,10 +5024,10 @@ for (;; ptr++) } memcpy(code, previous, len); - - /* Ensure there is enough workspace for forward references before + + /* Ensure there is enough workspace for forward references before copying them. */ - + while (cd->hwm > cd->start_workspace + cd->workspace_size - WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm)) { @@ -5036,9 +5036,9 @@ for (;; ptr++) *errorcodeptr = expand_workspace(cd); if (*errorcodeptr != 0) goto FAILED; save_hwm = (uschar *)cd->start_workspace + save_offset; - this_hwm = (uschar *)cd->start_workspace + this_offset; - } - + this_hwm = (uschar *)cd->start_workspace + this_offset; + } + for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE) { PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1)); @@ -5069,24 +5069,24 @@ for (;; ptr++) ONCE brackets can be converted into non-capturing brackets, as the behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to deal with possessive ONCEs specially. - + Otherwise, when we are doing the actual compile phase, check to see whether this group is one that could match an empty string. If so, convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so that runtime checking can be done. [This check is also applied to ONCE groups at runtime, but in a different way.] - Then, if the quantifier was possessive and the bracket is not a + Then, if the quantifier was possessive and the bracket is not a conditional, we convert the BRA code to the POS form, and the KET code to KETRPOS. (It turns out to be convenient at runtime to detect this kind of subpattern at both the start and at the end.) The use of special opcodes makes it possible to reduce greatly the stack usage in pcre_exec(). If - the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO. - + the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO. + Then, if the minimum number of matches is 1 or 0, cancel the possessive flag so that the default action below, of wrapping everything inside atomic brackets, does not happen. When the minimum is greater than 1, - there will be earlier copies of the group, and so we still have to wrap + there will be earlier copies of the group, and so we still have to wrap the whole thing. */ else @@ -5095,23 +5095,23 @@ for (;; ptr++) uschar *bracode = ketcode - GET(ketcode, 1); /* Convert possessive ONCE brackets to non-capturing */ - + if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) && possessive_quantifier) *bracode = OP_BRA; /* For non-possessive ONCE brackets, all we need to do is to set the KET. */ - + if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC) *ketcode = OP_KETRMAX + repeat_type; - + /* Handle non-ONCE brackets and possessive ONCEs (which have been - converted to non-capturing above). */ - + converted to non-capturing above). */ + else { /* In the compile phase, check for empty string matching. */ - + if (lengthptr == NULL) { uschar *scode = bracode; @@ -5126,7 +5126,7 @@ for (;; ptr++) } while (*scode == OP_ALT); } - + /* Handle possessive quantifiers. */ if (possessive_quantifier) @@ -5135,7 +5135,7 @@ for (;; ptr++) repeated non-capturing bracket, because we have not invented POS versions of the COND opcodes. Because we are moving code along, we must ensure that any pending recursive references are updated. */ - + if (*bracode == OP_COND || *bracode == OP_SCOND) { int nlen = (int)(code - bracode); @@ -5148,25 +5148,25 @@ for (;; ptr++) *code++ = OP_KETRPOS; PUTINC(code, 0, nlen); PUT(bracode, 1, nlen); - } - + } + /* For non-COND brackets, we modify the BRA code and use KETRPOS. */ - - else + + else { *bracode += 1; /* Switch to xxxPOS opcodes */ *ketcode = OP_KETRPOS; } - - /* If the minimum is zero, mark it as possessive, then unset the + + /* If the minimum is zero, mark it as possessive, then unset the possessive flag when the minimum is 0 or 1. */ - + if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO; if (repeat_min < 2) possessive_quantifier = FALSE; } - + /* Non-possessive quantifier */ - + else *ketcode = OP_KETRMAX + repeat_type; } } @@ -6056,14 +6056,14 @@ for (;; ptr++) /* Fudge the value of "called" so that when it is inserted as an offset below, what it actually inserted is the reference number of the group. Then remember the forward reference. */ - + called = cd->start_code + recno; if (cd->hwm >= cd->start_workspace + cd->workspace_size - WORK_SIZE_SAFETY_MARGIN) { *errorcodeptr = expand_workspace(cd); - if (*errorcodeptr != 0) goto FAILED; - } + if (*errorcodeptr != 0) goto FAILED; + } PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code)); } @@ -6085,13 +6085,13 @@ for (;; ptr++) } /* Insert the recursion/subroutine item. It does not have a set first - byte (relevant if it is repeated, because it will then be wrapped + byte (relevant if it is repeated, because it will then be wrapped with ONCE brackets). */ *code = OP_RECURSE; PUT(code, 1, (int)(called - cd->start_code)); code += 1 + LINK_SIZE; - groupsetfirstbyte = FALSE; + groupsetfirstbyte = FALSE; } /* Can't determine a first byte now */ @@ -6575,8 +6575,8 @@ for (;; ptr++) #endif /* In non-UTF-8 mode, we turn \C into OP_ALLANY instead of OP_ANYBYTE so that it works in DFA mode and in lookbehinds. */ - - { + + { previous = (-c > ESC_b && -c < ESC_Z)? code : NULL; *code++ = (!utf8 && c == -ESC_C)? OP_ALLANY : -c; } @@ -7314,7 +7314,7 @@ compile_data *cd = &compile_block; computing the amount of memory that is needed. Compiled items are thrown away as soon as possible, so that a fairly large buffer should be sufficient for this purpose. The same space is used in the second phase for remembering where -to fill in forward references to subpatterns. That may overflow, in which case +to fill in forward references to subpatterns. That may overflow, in which case new memory is obtained from malloc(). */ uschar cworkspace[COMPILE_WORK_SIZE]; @@ -7620,12 +7620,12 @@ if debugging, leave the test till after things are printed out. */ if (code - codestart > length) errorcode = ERR23; #endif -/* Fill in any forward references that are required. There may be repeated +/* Fill in any forward references that are required. There may be repeated references; optimize for them, as searching a large regex takes time. */ if (cd->hwm > cd->start_workspace) { - int prev_recno = -1; + int prev_recno = -1; const uschar *groupptr = NULL; while (errorcode == 0 && cd->hwm > cd->start_workspace) { @@ -7634,19 +7634,19 @@ if (cd->hwm > cd->start_workspace) offset = GET(cd->hwm, 0); recno = GET(codestart, offset); if (recno != prev_recno) - { + { groupptr = _pcre_find_bracket(codestart, utf8, recno); prev_recno = recno; - } + } if (groupptr == NULL) errorcode = ERR53; else PUT(((uschar *)codestart), offset, (int)(groupptr - codestart)); } - } - + } + /* If the workspace had to be expanded, free the new memory. */ -if (cd->workspace_size > COMPILE_WORK_SIZE) - (pcre_free)((void *)cd->start_workspace); +if (cd->workspace_size > COMPILE_WORK_SIZE) + (pcre_free)((void *)cd->start_workspace); /* Give an error if there's back reference to a non-existent capturing subpattern. */ diff --git a/pcre_exec.c b/pcre_exec.c index 5a52192..46498d5 100644 --- a/pcre_exec.c +++ b/pcre_exec.c @@ -752,15 +752,15 @@ for (;;) RRETURN(MATCH_SKIP); /* Note that, for Perl compatibility, SKIP with an argument does NOT set - nomatch_mark. There is a flag that disables this opcode when re-matching a + nomatch_mark. There is a flag that disables this opcode when re-matching a pattern that ended with a SKIP for which there was not a matching MARK. */ - + case OP_SKIP_ARG: - if (md->ignore_skip_arg) + if (md->ignore_skip_arg) { - ecode += _pcre_OP_lengths[*ecode] + ecode[1]; + ecode += _pcre_OP_lengths[*ecode] + ecode[1]; break; - } + } RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md, eptrb, RM57); if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN) @@ -768,7 +768,7 @@ for (;;) /* Pass back the current skip name by overloading md->start_match_ptr and returning the special MATCH_SKIP_ARG return code. This will either be - caught by a matching MARK, or get to the top, where it causes a rematch + caught by a matching MARK, or get to the top, where it causes a rematch with the md->ignore_skip_arg flag set. */ md->start_match_ptr = ecode + 2; @@ -3037,26 +3037,26 @@ for (;;) } break; - /* Match a single character, caselessly. If we are at the end of the + /* Match a single character, caselessly. If we are at the end of the subject, give up immediately. */ case OP_CHARI: if (eptr >= md->end_subject) { - SCHECK_PARTIAL(); - RRETURN(MATCH_NOMATCH); - } - + SCHECK_PARTIAL(); + RRETURN(MATCH_NOMATCH); + } + #ifdef SUPPORT_UTF8 if (utf8) { length = 1; ecode++; GETCHARLEN(fc, ecode, length); - + /* If the pattern character's value is < 128, we have only one byte, and we know that its other case must also be one byte long, so we can use the - fast lookup table. We know that there is at least one byte left in the + fast lookup table. We know that there is at least one byte left in the subject. */ if (fc < 128) @@ -6456,16 +6456,16 @@ for(;;) switch(rc) { /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched - the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP - entirely. The only way we can do that is to re-do the match at the same - point, with a flag to force SKIP with an argument to be ignored. Just - treating this case as NOMATCH does not work because it does not check other + the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP + entirely. The only way we can do that is to re-do the match at the same + point, with a flag to force SKIP with an argument to be ignored. Just + treating this case as NOMATCH does not work because it does not check other alternatives in patterns such as A(*SKIP:A)B|AC when the subject is AC. */ case MATCH_SKIP_ARG: new_start_match = start_match; md->ignore_skip_arg = TRUE; - break; + break; /* SKIP passes back the next starting point explicitly, but if it is the same as the match we have just done, treat it as NOMATCH. */ @@ -6614,7 +6614,7 @@ if (rc == MATCH_MATCH || rc == MATCH_ACCEPT) } /* Return MARK data if requested */ - + if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0) *(extra_data->mark) = (unsigned char *)(md->mark); DPRINTF((">>>> returning %d\n", rc)); diff --git a/pcre_fullinfo.c b/pcre_fullinfo.c index 33f0b3a..2aca564 100644 --- a/pcre_fullinfo.c +++ b/pcre_fullinfo.c @@ -99,19 +99,19 @@ switch (what) case PCRE_INFO_STUDYSIZE: *((size_t *)where) = (study == NULL)? 0 : study->size; break; - + case PCRE_INFO_JITSIZE: #ifdef SUPPORT_JIT - *((size_t *)where) = + *((size_t *)where) = (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 && extra_data->executable_jit != NULL)? - _pcre_jit_get_size(extra_data->executable_jit) : 0; + _pcre_jit_get_size(extra_data->executable_jit) : 0; #else *((size_t *)where) = 0; -#endif - - break; +#endif + + break; case PCRE_INFO_CAPTURECOUNT: *((int *)where) = re->top_bracket; diff --git a/pcre_internal.h b/pcre_internal.h index 26cc835..6ea397a 100644 --- a/pcre_internal.h +++ b/pcre_internal.h @@ -1741,7 +1741,7 @@ typedef struct compile_data { uschar *name_table; /* The name/number table */ int names_found; /* Number of entries so far */ int name_entry_size; /* Size of each entry */ - int workspace_size; /* Size of workspace */ + int workspace_size; /* Size of workspace */ int bracount; /* Count of capturing parens as we compile */ int final_bracount; /* Saved value after first pass */ int top_backref; /* Maximum back reference */ @@ -1825,7 +1825,7 @@ typedef struct match_data { BOOL hitend; /* Hit the end of the subject at some point */ BOOL bsr_anycrlf; /* \R is just any CRLF, not full Unicode */ BOOL hasthen; /* Pattern contains (*THEN) */ - BOOL ignore_skip_arg; /* For re-run when SKIP name not found */ + BOOL ignore_skip_arg; /* For re-run when SKIP name not found */ const uschar *start_code; /* For use when recursing */ USPTR start_subject; /* Start of the subject string */ USPTR end_subject; /* End of the subject string */ @@ -1842,7 +1842,7 @@ typedef struct match_data { recursion_info *recursive; /* Linked list of recursion data */ void *callout_data; /* To pass back to callouts */ const uschar *mark; /* Mark pointer to pass back on success */ - const uschar *nomatch_mark; /* Mark pointer to pass back on failure */ + const uschar *nomatch_mark; /* Mark pointer to pass back on failure */ const uschar *once_target; /* Where to back up to for atomic groups */ } match_data; diff --git a/pcre_jit_compile.c b/pcre_jit_compile.c index e23e41b..6f2bad0 100644 --- a/pcre_jit_compile.c +++ b/pcre_jit_compile.c @@ -166,7 +166,7 @@ typedef struct executable_function { void *executable_func; pcre_jit_callback callback; void *userdata; - sljit_uw executable_size; + sljit_uw executable_size; } executable_function; typedef struct jump_list { @@ -6430,7 +6430,7 @@ if (common->getucd != NULL) SLJIT_FREE(common->localptrs); executable_func = sljit_generate_code(compiler); -executable_size = sljit_get_generated_code_size(compiler); +executable_size = sljit_get_generated_code_size(compiler); sljit_free_compiler(compiler); if (executable_func == NULL) return; diff --git a/pcreposix.c b/pcreposix.c index 7379917..4ff82e7 100644 --- a/pcreposix.c +++ b/pcreposix.c @@ -154,9 +154,9 @@ static const int eint[] = { REG_BADPAT, /* \c must be followed by an ASCII character */ REG_BADPAT, /* \k is not followed by a braced, angle-bracketed, or quoted name */ /* 70 */ - REG_BADPAT, /* internal error: unknown opcode in find_fixedlength() */ - REG_BADPAT, /* \N is not supported in a class */ - REG_BADPAT, /* too many forward references */ + REG_BADPAT, /* internal error: unknown opcode in find_fixedlength() */ + REG_BADPAT, /* \N is not supported in a class */ + REG_BADPAT, /* too many forward references */ }; /* Table of texts corresponding to POSIX error codes */ @@ -1632,7 +1632,7 @@ while (!done) /* Look for options after final delimiter */ options = 0; - study_options = 0; + study_options = 0; log_store = showstore; /* default from command line */ while (*pp != 0) @@ -1892,18 +1892,18 @@ while (!done) if (error != NULL) fprintf(outfile, "Failed to study: %s\n", error); else if (extra != NULL) - { + { true_study_size = ((pcre_study_data *)(extra->study_data))->size; if (log_store) { - size_t jitsize; + size_t jitsize; new_info(re, extra, PCRE_INFO_JITSIZE, &jitsize); if (jitsize != 0) - fprintf(outfile, "Memory allocation (JIT code): %d\n", jitsize); - } + fprintf(outfile, "Memory allocation (JIT code): %d\n", jitsize); + } } } - + /* If /K was present, we set up for handling MARK data. */ if (do_mark) |