Revision: 788
http://vcs.pcre.org/viewvc?view=rev&revision=788
Author: ph10
Date: 2011-12-06 15:38:01 +0000 (Tue, 06 Dec 2011)
Log Message:
-----------
Source tidies for 8.21-RC1
Modified Paths:
--------------
code/trunk/NEWS
code/trunk/doc/html/index.html
code/trunk/doc/html/pcreapi.html
code/trunk/doc/html/pcrecallout.html
code/trunk/doc/html/pcrecompat.html
code/trunk/doc/html/pcrejit.html
code/trunk/doc/html/pcrepattern.html
code/trunk/doc/html/pcretest.html
code/trunk/doc/pcre.txt
code/trunk/doc/pcreapi.3
code/trunk/doc/pcrecallout.3
code/trunk/doc/pcrecompat.3
code/trunk/doc/pcrejit.3
code/trunk/doc/pcrepattern.3
code/trunk/doc/pcretest.1
code/trunk/pcre.h.in
code/trunk/pcre_compile.c
code/trunk/pcre_exec.c
code/trunk/pcre_fullinfo.c
code/trunk/pcre_internal.h
code/trunk/pcre_jit_compile.c
code/trunk/pcreposix.c
code/trunk/pcretest.c
Modified: code/trunk/NEWS
===================================================================
--- code/trunk/NEWS 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/NEWS 2011-12-06 15:38:01 UTC (rev 788)
@@ -4,7 +4,7 @@
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.
Modified: code/trunk/doc/html/index.html
===================================================================
--- code/trunk/doc/html/index.html 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/html/index.html 2011-12-06 15:38:01 UTC (rev 788)
@@ -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 @@
</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 @@
<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>
Modified: code/trunk/doc/html/pcreapi.html
===================================================================
--- code/trunk/doc/html/pcreapi.html 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/html/pcreapi.html 2011-12-06 15:38:01 UTC (rev 788)
@@ -651,20 +651,20 @@
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
Modified: code/trunk/doc/html/pcrecallout.html
===================================================================
--- code/trunk/doc/html/pcrecallout.html 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/html/pcrecallout.html 2011-12-06 15:38:01 UTC (rev 788)
@@ -190,7 +190,7 @@
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>
Modified: code/trunk/doc/html/pcrecompat.html
===================================================================
--- code/trunk/doc/html/pcrecompat.html 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/html/pcrecompat.html 2011-12-06 15:38:01 UTC (rev 788)
@@ -53,7 +53,7 @@
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>
Modified: code/trunk/doc/html/pcrejit.html
===================================================================
--- code/trunk/doc/html/pcrejit.html 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/html/pcrejit.html 2011-12-06 15:38:01 UTC (rev 788)
@@ -68,7 +68,7 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
<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 @@
</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
Modified: code/trunk/doc/html/pcrepattern.html
===================================================================
--- code/trunk/doc/html/pcrepattern.html 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/html/pcrepattern.html 2011-12-06 15:38:01 UTC (rev 788)
@@ -269,7 +269,7 @@
\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 @@
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 @@
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 @@
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 @@
(*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 @@
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>
Modified: code/trunk/doc/html/pcretest.html
===================================================================
--- code/trunk/doc/html/pcretest.html 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/html/pcretest.html 2011-12-06 15:38:01 UTC (rev 788)
@@ -364,9 +364,9 @@
</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>
Modified: code/trunk/doc/pcre.txt
===================================================================
--- code/trunk/doc/pcre.txt 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/pcre.txt 2011-12-06 15:38:01 UTC (rev 788)
@@ -120,8 +120,8 @@
Last updated: 24 August 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREBUILD(3) PCREBUILD(3)
@@ -484,8 +484,8 @@
Last updated: 06 September 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREMATCHING(3) PCREMATCHING(3)
@@ -688,8 +688,8 @@
Last updated: 19 November 2011
Copyright (c) 1997-2010 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREAPI(3) PCREAPI(3)
@@ -3007,8 +3007,8 @@
Last updated: 02 December 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCRECALLOUT(3) PCRECALLOUT(3)
@@ -3202,8 +3202,8 @@
Last updated: 30 November 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCRECOMPAT(3) PCRECOMPAT(3)
@@ -3376,8 +3376,8 @@
Last updated: 14 November 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREPATTERN(3) PCREPATTERN(3)
@@ -5963,8 +5963,8 @@
Last updated: 29 November 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCRESYNTAX(3) PCRESYNTAX(3)
@@ -6333,8 +6333,8 @@
Last updated: 21 November 2010
Copyright (c) 1997-2010 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREUNICODE(3) PCREUNICODE(3)
@@ -6487,8 +6487,8 @@
Last updated: 19 October 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREJIT(3) PCREJIT(3)
@@ -6834,8 +6834,8 @@
Last updated: 26 November 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREPARTIAL(3) PCREPARTIAL(3)
@@ -7256,8 +7256,8 @@
Last updated: 26 August 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREPRECOMPILE(3) PCREPRECOMPILE(3)
@@ -7387,8 +7387,8 @@
Last updated: 26 August 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREPERFORM(3) PCREPERFORM(3)
@@ -7555,8 +7555,8 @@
Last updated: 16 May 2010
Copyright (c) 1997-2010 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCREPOSIX(3) PCREPOSIX(3)
@@ -7818,8 +7818,8 @@
Last updated: 16 May 2010
Copyright (c) 1997-2010 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCRECPP(3) PCRECPP(3)
@@ -8160,8 +8160,8 @@
Last updated: 17 March 2009
Minor typo fixed: 25 July 2011
------------------------------------------------------------------------------
-
-
+
+
PCRESAMPLE(3) PCRESAMPLE(3)
@@ -8301,8 +8301,8 @@
Last updated: 30 November 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
PCRESTACK(3) PCRESTACK(3)
@@ -8462,5 +8462,5 @@
Last updated: 26 August 2011
Copyright (c) 1997-2011 University of Cambridge.
------------------------------------------------------------------------------
-
-
+
+
Modified: code/trunk/doc/pcreapi.3
===================================================================
--- code/trunk/doc/pcreapi.3 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/pcreapi.3 2011-12-06 15:38:01 UTC (rev 788)
@@ -644,18 +644,18 @@
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
Modified: code/trunk/doc/pcrecallout.3
===================================================================
--- code/trunk/doc/pcrecallout.3 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/pcrecallout.3 2011-12-06 15:38:01 UTC (rev 788)
@@ -161,7 +161,7 @@
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.
.
Modified: code/trunk/doc/pcrecompat.3
===================================================================
--- code/trunk/doc/pcrecompat.3 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/pcrecompat.3 2011-12-06 15:38:01 UTC (rev 788)
@@ -38,7 +38,7 @@
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
Modified: code/trunk/doc/pcrejit.3
===================================================================
--- code/trunk/doc/pcrejit.3 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/pcrejit.3 2011-12-06 15:38:01 UTC (rev 788)
@@ -43,7 +43,7 @@
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 @@
#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 @@
.\" </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 @@
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 @@
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 @@
.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 @@
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.
Modified: code/trunk/doc/pcrepattern.3
===================================================================
--- code/trunk/doc/pcrepattern.3 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/pcrepattern.3 2011-12-06 15:38:01 UTC (rev 788)
@@ -242,7 +242,7 @@
\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 @@
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 @@
.\" </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 @@
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 @@
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 @@
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.
.
.
Modified: code/trunk/doc/pcretest.1
===================================================================
--- code/trunk/doc/pcretest.1 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/doc/pcretest.1 2011-12-06 15:38:01 UTC (rev 788)
@@ -319,9 +319,9 @@
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
Modified: code/trunk/pcre.h.in
===================================================================
--- code/trunk/pcre.h.in 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/pcre.h.in 2011-12-06 15:38:01 UTC (rev 788)
@@ -98,9 +98,9 @@
/* 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). */
Modified: code/trunk/pcre_compile.c
===================================================================
--- code/trunk/pcre_compile.c 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/pcre_compile.c 2011-12-06 15:38:01 UTC (rev 788)
@@ -88,12 +88,12 @@
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 @@
"\\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 @@
* 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 @@
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 @@
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 @@
#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 @@
/* 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 @@
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 @@
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 @@
}
/* 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 @@
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 @@
*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 @@
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 @@
}
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 @@
*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 @@
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 @@
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 @@
}
while (*scode == OP_ALT);
}
-
+
/* Handle possessive quantifiers. */
if (possessive_quantifier)
@@ -5135,7 +5135,7 @@
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 @@
*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 @@
/* 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 @@
}
/* 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 @@
#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 @@
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 (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 @@
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. */
Modified: code/trunk/pcre_exec.c
===================================================================
--- code/trunk/pcre_exec.c 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/pcre_exec.c 2011-12-06 15:38:01 UTC (rev 788)
@@ -752,15 +752,15 @@
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 @@
/* 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 @@
}
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 @@
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 @@
}
/* 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));
Modified: code/trunk/pcre_fullinfo.c
===================================================================
--- code/trunk/pcre_fullinfo.c 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/pcre_fullinfo.c 2011-12-06 15:38:01 UTC (rev 788)
@@ -99,20 +99,20 @@
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;
break;
Modified: code/trunk/pcre_internal.h
===================================================================
--- code/trunk/pcre_internal.h 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/pcre_internal.h 2011-12-06 15:38:01 UTC (rev 788)
@@ -1741,7 +1741,7 @@
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 @@
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 @@
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;
Modified: code/trunk/pcre_jit_compile.c
===================================================================
--- code/trunk/pcre_jit_compile.c 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/pcre_jit_compile.c 2011-12-06 15:38:01 UTC (rev 788)
@@ -166,7 +166,7 @@
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 @@
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;
Modified: code/trunk/pcreposix.c
===================================================================
--- code/trunk/pcreposix.c 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/pcreposix.c 2011-12-06 15:38:01 UTC (rev 788)
@@ -154,9 +154,9 @@
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 */
Modified: code/trunk/pcretest.c
===================================================================
--- code/trunk/pcretest.c 2011-12-06 15:37:24 UTC (rev 787)
+++ code/trunk/pcretest.c 2011-12-06 15:38:01 UTC (rev 788)
@@ -1632,7 +1632,7 @@
/* 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 @@
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)
