1 : /*************************************************
2 : * Perl-Compatible Regular Expressions *
3 : *************************************************/
4 :
5 : /* PCRE is a library of functions to support regular expressions whose syntax
6 : and semantics are as close as possible to those of the Perl 5 language.
7 :
8 : Written by Philip Hazel
9 : Copyright (c) 1997-2006 University of Cambridge
10 :
11 : -----------------------------------------------------------------------------
12 : Redistribution and use in source and binary forms, with or without
13 : modification, are permitted provided that the following conditions are met:
14 :
15 : * Redistributions of source code must retain the above copyright notice,
16 : this list of conditions and the following disclaimer.
17 :
18 : * Redistributions in binary form must reproduce the above copyright
19 : notice, this list of conditions and the following disclaimer in the
20 : documentation and/or other materials provided with the distribution.
21 :
22 : * Neither the name of the University of Cambridge nor the names of its
23 : contributors may be used to endorse or promote products derived from
24 : this software without specific prior written permission.
25 :
26 : THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27 : AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 : IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 : ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30 : LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 : CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 : SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 : INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 : CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 : ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 : POSSIBILITY OF SUCH DAMAGE.
37 : -----------------------------------------------------------------------------
38 : */
39 :
40 :
41 : /* This module contains the external function pcre_compile(), along with
42 : supporting internal functions that are not used by other modules. */
43 :
44 :
45 : #define NLBLOCK cd /* Block containing newline information */
46 : #define PSSTART start_pattern /* Field containing processed string start */
47 : #define PSEND end_pattern /* Field containing processed string end */
48 :
49 :
50 : #include "pcre_internal.h"
51 :
52 :
53 : /* When DEBUG is defined, we need the pcre_printint() function, which is also
54 : used by pcretest. DEBUG is not defined when building a production library. */
55 :
56 : #ifdef DEBUG
57 : #include "pcre_printint.src"
58 : #endif
59 :
60 :
61 : /*************************************************
62 : * Code parameters and static tables *
63 : *************************************************/
64 :
65 : /* This value specifies the size of stack workspace that is used during the
66 : first pre-compile phase that determines how much memory is required. The regex
67 : is partly compiled into this space, but the compiled parts are discarded as
68 : soon as they can be, so that hopefully there will never be an overrun. The code
69 : does, however, check for an overrun. The largest amount I've seen used is 218,
70 : so this number is very generous.
71 :
72 : The same workspace is used during the second, actual compile phase for
73 : remembering forward references to groups so that they can be filled in at the
74 : end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE
75 : is 4 there is plenty of room. */
76 :
77 : #define COMPILE_WORK_SIZE (4096)
78 :
79 :
80 : /* Table for handling escaped characters in the range '0'-'z'. Positive returns
81 : are simple data values; negative values are for special things like \d and so
82 : on. Zero means further processing is needed (for things like \x), or the escape
83 : is invalid. */
84 :
85 : #if !EBCDIC /* This is the "normal" table for ASCII systems */
86 : static const short int escapes[] = {
87 : 0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 7 */
88 : 0, 0, ':', ';', '<', '=', '>', '?', /* 8 - ? */
89 : '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E, 0, -ESC_G, /* @ - G */
90 : 0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
91 : -ESC_P, -ESC_Q, -ESC_R, -ESC_S, 0, 0, 0, -ESC_W, /* P - W */
92 : -ESC_X, 0, -ESC_Z, '[', '\\', ']', '^', '_', /* X - _ */
93 : '`', 7, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0, /* ` - g */
94 : 0, 0, 0, -ESC_k, 0, 0, ESC_n, 0, /* h - o */
95 : -ESC_p, 0, ESC_r, -ESC_s, ESC_tee, 0, 0, -ESC_w, /* p - w */
96 : 0, 0, -ESC_z /* x - z */
97 : };
98 :
99 : #else /* This is the "abnormal" table for EBCDIC systems */
100 : static const short int escapes[] = {
101 : /* 48 */ 0, 0, 0, '.', '<', '(', '+', '|',
102 : /* 50 */ '&', 0, 0, 0, 0, 0, 0, 0,
103 : /* 58 */ 0, 0, '!', '$', '*', ')', ';', '~',
104 : /* 60 */ '-', '/', 0, 0, 0, 0, 0, 0,
105 : /* 68 */ 0, 0, '|', ',', '%', '_', '>', '?',
106 : /* 70 */ 0, 0, 0, 0, 0, 0, 0, 0,
107 : /* 78 */ 0, '`', ':', '#', '@', '\'', '=', '"',
108 : /* 80 */ 0, 7, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0,
109 : /* 88 */ 0, 0, 0, '{', 0, 0, 0, 0,
110 : /* 90 */ 0, 0, -ESC_k, 'l', 0, ESC_n, 0, -ESC_p,
111 : /* 98 */ 0, ESC_r, 0, '}', 0, 0, 0, 0,
112 : /* A0 */ 0, '~', -ESC_s, ESC_tee, 0, 0, -ESC_w, 0,
113 : /* A8 */ 0,-ESC_z, 0, 0, 0, '[', 0, 0,
114 : /* B0 */ 0, 0, 0, 0, 0, 0, 0, 0,
115 : /* B8 */ 0, 0, 0, 0, 0, ']', '=', '-',
116 : /* C0 */ '{',-ESC_A, -ESC_B, -ESC_C, -ESC_D,-ESC_E, 0, -ESC_G,
117 : /* C8 */ 0, 0, 0, 0, 0, 0, 0, 0,
118 : /* D0 */ '}', 0, 0, 0, 0, 0, 0, -ESC_P,
119 : /* D8 */-ESC_Q,-ESC_R, 0, 0, 0, 0, 0, 0,
120 : /* E0 */ '\\', 0, -ESC_S, 0, 0, 0, -ESC_W, -ESC_X,
121 : /* E8 */ 0,-ESC_Z, 0, 0, 0, 0, 0, 0,
122 : /* F0 */ 0, 0, 0, 0, 0, 0, 0, 0,
123 : /* F8 */ 0, 0, 0, 0, 0, 0, 0, 0
124 : };
125 : #endif
126 :
127 :
128 : /* Tables of names of POSIX character classes and their lengths. The list is
129 : terminated by a zero length entry. The first three must be alpha, lower, upper,
130 : as this is assumed for handling case independence. */
131 :
132 : static const char *const posix_names[] = {
133 : "alpha", "lower", "upper",
134 : "alnum", "ascii", "blank", "cntrl", "digit", "graph",
135 : "print", "punct", "space", "word", "xdigit" };
136 :
137 : static const uschar posix_name_lengths[] = {
138 : 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
139 :
140 : /* Table of class bit maps for each POSIX class. Each class is formed from a
141 : base map, with an optional addition or removal of another map. Then, for some
142 : classes, there is some additional tweaking: for [:blank:] the vertical space
143 : characters are removed, and for [:alpha:] and [:alnum:] the underscore
144 : character is removed. The triples in the table consist of the base map offset,
145 : second map offset or -1 if no second map, and a non-negative value for map
146 : addition or a negative value for map subtraction (if there are two maps). The
147 : absolute value of the third field has these meanings: 0 => no tweaking, 1 =>
148 : remove vertical space characters, 2 => remove underscore. */
149 :
150 : static const int posix_class_maps[] = {
151 : cbit_word, cbit_digit, -2, /* alpha */
152 : cbit_lower, -1, 0, /* lower */
153 : cbit_upper, -1, 0, /* upper */
154 : cbit_word, -1, 2, /* alnum - word without underscore */
155 : cbit_print, cbit_cntrl, 0, /* ascii */
156 : cbit_space, -1, 1, /* blank - a GNU extension */
157 : cbit_cntrl, -1, 0, /* cntrl */
158 : cbit_digit, -1, 0, /* digit */
159 : cbit_graph, -1, 0, /* graph */
160 : cbit_print, -1, 0, /* print */
161 : cbit_punct, -1, 0, /* punct */
162 : cbit_space, -1, 0, /* space */
163 : cbit_word, -1, 0, /* word - a Perl extension */
164 : cbit_xdigit,-1, 0 /* xdigit */
165 : };
166 :
167 :
168 : #define STRING(a) # a
169 : #define XSTRING(s) STRING(s)
170 :
171 : /* The texts of compile-time error messages. These are "char *" because they
172 : are passed to the outside world. Do not ever re-use any error number, because
173 : they are documented. Always add a new error instead. Messages marked DEAD below
174 : are no longer used. */
175 :
176 : static const char *error_texts[] = {
177 : "no error",
178 : "\\ at end of pattern",
179 : "\\c at end of pattern",
180 : "unrecognized character follows \\",
181 : "numbers out of order in {} quantifier",
182 : /* 5 */
183 : "number too big in {} quantifier",
184 : "missing terminating ] for character class",
185 : "invalid escape sequence in character class",
186 : "range out of order in character class",
187 : "nothing to repeat",
188 : /* 10 */
189 : "operand of unlimited repeat could match the empty string", /** DEAD **/
190 : "internal error: unexpected repeat",
191 : "unrecognized character after (?",
192 : "POSIX named classes are supported only within a class",
193 : "missing )",
194 : /* 15 */
195 : "reference to non-existent subpattern",
196 : "erroffset passed as NULL",
197 : "unknown option bit(s) set",
198 : "missing ) after comment",
199 : "parentheses nested too deeply", /** DEAD **/
200 : /* 20 */
201 : "regular expression too large",
202 : "failed to get memory",
203 : "unmatched parentheses",
204 : "internal error: code overflow",
205 : "unrecognized character after (?<",
206 : /* 25 */
207 : "lookbehind assertion is not fixed length",
208 : "malformed number or name after (?(",
209 : "conditional group contains more than two branches",
210 : "assertion expected after (?(",
211 : "(?R or (?digits must be followed by )",
212 : /* 30 */
213 : "unknown POSIX class name",
214 : "POSIX collating elements are not supported",
215 : "this version of PCRE is not compiled with PCRE_UTF8 support",
216 : "spare error", /** DEAD **/
217 : "character value in \\x{...} sequence is too large",
218 : /* 35 */
219 : "invalid condition (?(0)",
220 : "\\C not allowed in lookbehind assertion",
221 : "PCRE does not support \\L, \\l, \\N, \\U, or \\u",
222 : "number after (?C is > 255",
223 : "closing ) for (?C expected",
224 : /* 40 */
225 : "recursive call could loop indefinitely",
226 : "unrecognized character after (?P",
227 : "syntax error in subpattern name (missing terminator)",
228 : "two named subpatterns have the same name",
229 : "invalid UTF-8 string",
230 : /* 45 */
231 : "support for \\P, \\p, and \\X has not been compiled",
232 : "malformed \\P or \\p sequence",
233 : "unknown property name after \\P or \\p",
234 : "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)",
235 : "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")",
236 : /* 50 */
237 : "repeated subpattern is too long",
238 : "octal value is greater than \\377 (not in UTF-8 mode)",
239 : "internal error: overran compiling workspace",
240 : "internal error: previously-checked referenced subpattern not found",
241 : "DEFINE group contains more than one branch",
242 : /* 55 */
243 : "repeating a DEFINE group is not allowed",
244 : "inconsistent NEWLINE options",
245 : "\\g is not followed by an (optionally braced) non-zero number"
246 : };
247 :
248 :
249 : /* Table to identify digits and hex digits. This is used when compiling
250 : patterns. Note that the tables in chartables are dependent on the locale, and
251 : may mark arbitrary characters as digits - but the PCRE compiling code expects
252 : to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
253 : a private table here. It costs 256 bytes, but it is a lot faster than doing
254 : character value tests (at least in some simple cases I timed), and in some
255 : applications one wants PCRE to compile efficiently as well as match
256 : efficiently.
257 :
258 : For convenience, we use the same bit definitions as in chartables:
259 :
260 : 0x04 decimal digit
261 : 0x08 hexadecimal digit
262 :
263 : Then we can use ctype_digit and ctype_xdigit in the code. */
264 :
265 : #if !EBCDIC /* This is the "normal" case, for ASCII systems */
266 : static const unsigned char digitab[] =
267 : {
268 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */
269 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */
270 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */
271 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
272 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - ' */
273 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ( - / */
274 : 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 */
275 : 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /* 8 - ? */
276 : 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* @ - G */
277 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H - O */
278 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* P - W */
279 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* X - _ */
280 : 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* ` - g */
281 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h - o */
282 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* p - w */
283 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* x -127 */
284 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
285 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
286 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
287 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
288 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
289 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
290 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
291 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
292 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
293 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
294 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
295 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
296 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
297 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
298 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
299 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
300 :
301 : #else /* This is the "abnormal" case, for EBCDIC systems */
302 : static const unsigned char digitab[] =
303 : {
304 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 0 */
305 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */
306 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 10 */
307 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
308 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 32- 39 20 */
309 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */
310 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 30 */
311 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */
312 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 40 */
313 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 72- | */
314 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 50 */
315 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 88- ¬ */
316 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 60 */
317 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ? */
318 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
319 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */
320 : 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g 80 */
321 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */
322 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p 90 */
323 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */
324 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x A0 */
325 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */
326 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 B0 */
327 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
328 : 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* { - G C0 */
329 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */
330 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* } - P D0 */
331 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */
332 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* \ - X E0 */
333 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */
334 : 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 F0 */
335 : 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */
336 :
337 : static const unsigned char ebcdic_chartab[] = { /* chartable partial dup */
338 : 0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 0- 7 */
339 : 0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /* 8- 15 */
340 : 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 16- 23 */
341 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
342 : 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 32- 39 */
343 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */
344 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 */
345 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */
346 : 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 */
347 : 0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /* 72- | */
348 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 */
349 : 0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /* 88- ¬ */
350 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 */
351 : 0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ? */
352 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
353 : 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */
354 : 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g */
355 : 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */
356 : 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p */
357 : 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */
358 : 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x */
359 : 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */
360 : 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 */
361 : 0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
362 : 0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* { - G */
363 : 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */
364 : 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* } - P */
365 : 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */
366 : 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* \ - X */
367 : 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */
368 : 0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */
369 : 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */
370 : #endif
371 :
372 :
373 : /* Definition to allow mutual recursion */
374 :
375 : static BOOL
376 : compile_regex(int, int, uschar **, const uschar **, int *, BOOL, int, int *,
377 : int *, branch_chain *, compile_data *, int *);
378 :
379 :
380 :
381 : /*************************************************
382 : * Handle escapes *
383 : *************************************************/
384 :
385 : /* This function is called when a \ has been encountered. It either returns a
386 : positive value for a simple escape such as \n, or a negative value which
387 : encodes one of the more complicated things such as \d. A backreference to group
388 : n is returned as -(ESC_REF + n); ESC_REF is the highest ESC_xxx macro. When
389 : UTF-8 is enabled, a positive value greater than 255 may be returned. On entry,
390 : ptr is pointing at the \. On exit, it is on the final character of the escape
391 : sequence.
392 :
393 : Arguments:
394 : ptrptr points to the pattern position pointer
395 : errorcodeptr points to the errorcode variable
396 : bracount number of previous extracting brackets
397 : options the options bits
398 : isclass TRUE if inside a character class
399 :
400 : Returns: zero or positive => a data character
401 : negative => a special escape sequence
402 : on error, errorptr is set
403 : */
404 :
405 : static int
406 : check_escape(const uschar **ptrptr, int *errorcodeptr, int bracount,
407 : int options, BOOL isclass)
408 7656 : {
409 7656 : BOOL utf8 = (options & PCRE_UTF8) != 0;
410 7656 : const uschar *ptr = *ptrptr + 1;
411 : int c, i;
412 :
413 7656 : GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */
414 7656 : ptr--; /* Set pointer back to the last byte */
415 :
416 : /* If backslash is at the end of the pattern, it's an error. */
417 :
418 7656 : if (c == 0) *errorcodeptr = ERR1;
419 :
420 : /* Non-alphamerics are literals. For digits or letters, do an initial lookup in
421 : a table. A non-zero result is something that can be returned immediately.
422 : Otherwise further processing may be required. */
423 :
424 : #if !EBCDIC /* ASCII coding */
425 7656 : else if (c < '0' || c > 'z') {} /* Not alphameric */
426 3990 : else if ((i = escapes[c - '0']) != 0) c = i;
427 :
428 : #else /* EBCDIC coding */
429 : else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {} /* Not alphameric */
430 : else if ((i = escapes[c - 0x48]) != 0) c = i;
431 : #endif
432 :
433 : /* Escapes that need further processing, or are illegal. */
434 :
435 : else
436 : {
437 : const uschar *oldptr;
438 : BOOL braced, negated;
439 :
440 0 : switch (c)
441 : {
442 : /* A number of Perl escapes are not handled by PCRE. We give an explicit
443 : error. */
444 :
445 : case 'l':
446 : case 'L':
447 : case 'N':
448 : case 'u':
449 : case 'U':
450 0 : *errorcodeptr = ERR37;
451 0 : break;
452 :
453 : /* \g must be followed by a number, either plain or braced. If positive, it
454 : is an absolute backreference. If negative, it is a relative backreference.
455 : This is a Perl 5.10 feature. */
456 :
457 : case 'g':
458 0 : if (ptr[1] == '{')
459 : {
460 0 : braced = TRUE;
461 0 : ptr++;
462 : }
463 0 : else braced = FALSE;
464 :
465 0 : if (ptr[1] == '-')
466 : {
467 0 : negated = TRUE;
468 0 : ptr++;
469 : }
470 0 : else negated = FALSE;
471 :
472 0 : c = 0;
473 0 : while ((digitab[ptr[1]] & ctype_digit) != 0)
474 0 : c = c * 10 + *(++ptr) - '0';
475 :
476 0 : if (c == 0 || (braced && *(++ptr) != '}'))
477 : {
478 0 : *errorcodeptr = ERR57;
479 0 : return 0;
480 : }
481 :
482 0 : if (negated)
483 : {
484 0 : if (c > bracount)
485 : {
486 0 : *errorcodeptr = ERR15;
487 0 : return 0;
488 : }
489 0 : c = bracount - (c - 1);
490 : }
491 :
492 0 : c = -(ESC_REF + c);
493 0 : break;
494 :
495 : /* The handling of escape sequences consisting of a string of digits
496 : starting with one that is not zero is not straightforward. By experiment,
497 : the way Perl works seems to be as follows:
498 :
499 : Outside a character class, the digits are read as a decimal number. If the
500 : number is less than 10, or if there are that many previous extracting
501 : left brackets, then it is a back reference. Otherwise, up to three octal
502 : digits are read to form an escaped byte. Thus \123 is likely to be octal
503 : 123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
504 : value is greater than 377, the least significant 8 bits are taken. Inside a
505 : character class, \ followed by a digit is always an octal number. */
506 :
507 : case '1': case '2': case '3': case '4': case '5':
508 : case '6': case '7': case '8': case '9':
509 :
510 0 : if (!isclass)
511 : {
512 0 : oldptr = ptr;
513 0 : c -= '0';
514 0 : while ((digitab[ptr[1]] & ctype_digit) != 0)
515 0 : c = c * 10 + *(++ptr) - '0';
516 0 : if (c < 10 || c <= bracount)
517 : {
518 0 : c = -(ESC_REF + c);
519 0 : break;
520 : }
521 0 : ptr = oldptr; /* Put the pointer back and fall through */
522 : }
523 :
524 : /* Handle an octal number following \. If the first digit is 8 or 9, Perl
525 : generates a binary zero byte and treats the digit as a following literal.
526 : Thus we have to pull back the pointer by one. */
527 :
528 0 : if ((c = *ptr) >= '8')
529 : {
530 0 : ptr--;
531 0 : c = 0;
532 0 : break;
533 : }
534 :
535 : /* \0 always starts an octal number, but we may drop through to here with a
536 : larger first octal digit. The original code used just to take the least
537 : significant 8 bits of octal numbers (I think this is what early Perls used
538 : to do). Nowadays we allow for larger numbers in UTF-8 mode, but no more
539 : than 3 octal digits. */
540 :
541 : case '0':
542 0 : c -= '0';
543 0 : while(i++ < 2 && ptr[1] >= '0' && ptr[1] <= '7')
544 0 : c = c * 8 + *(++ptr) - '0';
545 0 : if (!utf8 && c > 255) *errorcodeptr = ERR51;
546 0 : break;
547 :
548 : /* \x is complicated. \x{ddd} is a character number which can be greater
549 : than 0xff in utf8 mode, but only if the ddd are hex digits. If not, { is
550 : treated as a data character. */
551 :
552 : case 'x':
553 0 : if (ptr[1] == '{')
554 : {
555 0 : const uschar *pt = ptr + 2;
556 0 : int count = 0;
557 :
558 0 : c = 0;
559 0 : while ((digitab[*pt] & ctype_xdigit) != 0)
560 : {
561 0 : register int cc = *pt++;
562 0 : if (c == 0 && cc == '0') continue; /* Leading zeroes */
563 0 : count++;
564 :
565 : #if !EBCDIC /* ASCII coding */
566 0 : if (cc >= 'a') cc -= 32; /* Convert to upper case */
567 0 : c = (c << 4) + cc - ((cc < 'A')? '0' : ('A' - 10));
568 : #else /* EBCDIC coding */
569 : if (cc >= 'a' && cc <= 'z') cc += 64; /* Convert to upper case */
570 : c = (c << 4) + cc - ((cc >= '0')? '0' : ('A' - 10));
571 : #endif
572 : }
573 :
574 0 : if (*pt == '}')
575 : {
576 0 : if (c < 0 || count > (utf8? 8 : 2)) *errorcodeptr = ERR34;
577 0 : ptr = pt;
578 0 : break;
579 : }
580 :
581 : /* If the sequence of hex digits does not end with '}', then we don't
582 : recognize this construct; fall through to the normal \x handling. */
583 : }
584 :
585 : /* Read just a single-byte hex-defined char */
586 :
587 0 : c = 0;
588 0 : while (i++ < 2 && (digitab[ptr[1]] & ctype_xdigit) != 0)
589 : {
590 : int cc; /* Some compilers don't like ++ */
591 0 : cc = *(++ptr); /* in initializers */
592 : #if !EBCDIC /* ASCII coding */
593 0 : if (cc >= 'a') cc -= 32; /* Convert to upper case */
594 0 : c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
595 : #else /* EBCDIC coding */
596 : if (cc <= 'z') cc += 64; /* Convert to upper case */
597 : c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
598 : #endif
599 : }
600 0 : break;
601 :
602 : /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
603 : This coding is ASCII-specific, but then the whole concept of \cx is
604 : ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
605 :
606 : case 'c':
607 0 : c = *(++ptr);
608 0 : if (c == 0)
609 : {
610 0 : *errorcodeptr = ERR2;
611 0 : return 0;
612 : }
613 :
614 : #if !EBCDIC /* ASCII coding */
615 0 : if (c >= 'a' && c <= 'z') c -= 32;
616 0 : c ^= 0x40;
617 : #else /* EBCDIC coding */
618 : if (c >= 'a' && c <= 'z') c += 64;
619 : c ^= 0xC0;
620 : #endif
621 0 : break;
622 :
623 : /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
624 : other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
625 : for Perl compatibility, it is a literal. This code looks a bit odd, but
626 : there used to be some cases other than the default, and there may be again
627 : in future, so I haven't "optimized" it. */
628 :
629 : default:
630 0 : if ((options & PCRE_EXTRA) != 0) switch(c)
631 : {
632 : default:
633 0 : *errorcodeptr = ERR3;
634 : break;
635 : }
636 : break;
637 : }
638 : }
639 :
640 7656 : *ptrptr = ptr;
641 7656 : return c;
642 : }
643 :
644 :
645 :
646 : #ifdef SUPPORT_UCP
647 : /*************************************************
648 : * Handle \P and \p *
649 : *************************************************/
650 :
651 : /* This function is called after \P or \p has been encountered, provided that
652 : PCRE is compiled with support for Unicode properties. On entry, ptrptr is
653 : pointing at the P or p. On exit, it is pointing at the final character of the
654 : escape sequence.
655 :
656 : Argument:
657 : ptrptr points to the pattern position pointer
658 : negptr points to a boolean that is set TRUE for negation else FALSE
659 : dptr points to an int that is set to the detailed property value
660 : errorcodeptr points to the error code variable
661 :
662 : Returns: type value from ucp_type_table, or -1 for an invalid type
663 : */
664 :
665 : static int
666 : get_ucp(const uschar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr)
667 0 : {
668 : int c, i, bot, top;
669 0 : const uschar *ptr = *ptrptr;
670 : char name[32];
671 :
672 0 : c = *(++ptr);
673 0 : if (c == 0) goto ERROR_RETURN;
674 :
675 0 : *negptr = FALSE;
676 :
677 : /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
678 : negation. */
679 :
680 0 : if (c == '{')
681 : {
682 0 : if (ptr[1] == '^')
683 : {
684 0 : *negptr = TRUE;
685 0 : ptr++;
686 : }
687 0 : for (i = 0; i < sizeof(name) - 1; i++)
688 : {
689 0 : c = *(++ptr);
690 0 : if (c == 0) goto ERROR_RETURN;
691 0 : if (c == '}') break;
692 0 : name[i] = c;
693 : }
694 0 : if (c !='}') goto ERROR_RETURN;
695 0 : name[i] = 0;
696 : }
697 :
698 : /* Otherwise there is just one following character */
699 :
700 : else
701 : {
702 0 : name[0] = c;
703 0 : name[1] = 0;
704 : }
705 :
706 0 : *ptrptr = ptr;
707 :
708 : /* Search for a recognized property name using binary chop */
709 :
710 0 : bot = 0;
711 0 : top = _pcre_utt_size;
712 :
713 0 : while (bot < top)
714 : {
715 0 : i = (bot + top) >> 1;
716 0 : c = strcmp(name, _pcre_utt[i].name);
717 0 : if (c == 0)
718 : {
719 0 : *dptr = _pcre_utt[i].value;
720 0 : return _pcre_utt[i].type;
721 : }
722 0 : if (c > 0) bot = i + 1; else top = i;
723 : }
724 :
725 0 : *errorcodeptr = ERR47;
726 0 : *ptrptr = ptr;
727 0 : return -1;
728 :
729 0 : ERROR_RETURN:
730 0 : *errorcodeptr = ERR46;
731 0 : *ptrptr = ptr;
732 0 : return -1;
733 : }
734 : #endif
735 :
736 :
737 :
738 :
739 : /*************************************************
740 : * Check for counted repeat *
741 : *************************************************/
742 :
743 : /* This function is called when a '{' is encountered in a place where it might
744 : start a quantifier. It looks ahead to see if it really is a quantifier or not.
745 : It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
746 : where the ddds are digits.
747 :
748 : Arguments:
749 : p pointer to the first char after '{'
750 :
751 : Returns: TRUE or FALSE
752 : */
753 :
754 : static BOOL
755 : is_counted_repeat(const uschar *p)
756 0 : {
757 0 : if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
758 0 : while ((digitab[*p] & ctype_digit) != 0) p++;
759 0 : if (*p == '}') return TRUE;
760 :
761 0 : if (*p++ != ',') return FALSE;
762 0 : if (*p == '}') return TRUE;
763 :
764 0 : if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
765 0 : while ((digitab[*p] & ctype_digit) != 0) p++;
766 :
767 0 : return (*p == '}');
768 : }
769 :
770 :
771 :
772 : /*************************************************
773 : * Read repeat counts *
774 : *************************************************/
775 :
776 : /* Read an item of the form {n,m} and return the values. This is called only
777 : after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
778 : so the syntax is guaranteed to be correct, but we need to check the values.
779 :
780 : Arguments:
781 : p pointer to first char after '{'
782 : minp pointer to int for min
783 : maxp pointer to int for max
784 : returned as -1 if no max
785 : errorcodeptr points to error code variable
786 :
787 : Returns: pointer to '}' on success;
788 : current ptr on error, with errorcodeptr set non-zero
789 : */
790 :
791 : static const uschar *
792 : read_repeat_counts(const uschar *p, int *minp, int *maxp, int *errorcodeptr)
793 0 : {
794 0 : int min = 0;
795 0 : int max = -1;
796 :
797 : /* Read the minimum value and do a paranoid check: a negative value indicates
798 : an integer overflow. */
799 :
800 0 : while ((digitab[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
801 0 : if (min < 0 || min > 65535)
802 : {
803 0 : *errorcodeptr = ERR5;
804 0 : return p;
805 : }
806 :
807 : /* Read the maximum value if there is one, and again do a paranoid on its size.
808 : Also, max must not be less than min. */
809 :
810 0 : if (*p == '}') max = min; else
811 : {
812 0 : if (*(++p) != '}')
813 : {
814 0 : max = 0;
815 0 : while((digitab[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
816 0 : if (max < 0 || max > 65535)
817 : {
818 0 : *errorcodeptr = ERR5;
819 0 : return p;
820 : }
821 0 : if (max < min)
822 : {
823 0 : *errorcodeptr = ERR4;
824 0 : return p;
825 : }
826 : }
827 : }
828 :
829 : /* Fill in the required variables, and pass back the pointer to the terminating
830 : '}'. */
831 :
832 0 : *minp = min;
833 0 : *maxp = max;
834 0 : return p;
835 : }
836 :
837 :
838 :
839 : /*************************************************
840 : * Find forward referenced subpattern *
841 : *************************************************/
842 :
843 : /* This function scans along a pattern's text looking for capturing
844 : subpatterns, and counting them. If it finds a named pattern that matches the
845 : name it is given, it returns its number. Alternatively, if the name is NULL, it
846 : returns when it reaches a given numbered subpattern. This is used for forward
847 : references to subpatterns. We know that if (?P< is encountered, the name will
848 : be terminated by '>' because that is checked in the first pass.
849 :
850 : Arguments:
851 : ptr current position in the pattern
852 : count current count of capturing parens so far encountered
853 : name name to seek, or NULL if seeking a numbered subpattern
854 : lorn name length, or subpattern number if name is NULL
855 : xmode TRUE if we are in /x mode
856 :
857 : Returns: the number of the named subpattern, or -1 if not found
858 : */
859 :
860 : static int
861 : find_parens(const uschar *ptr, int count, const uschar *name, int lorn,
862 : BOOL xmode)
863 0 : {
864 : const uschar *thisname;
865 :
866 0 : for (; *ptr != 0; ptr++)
867 : {
868 : int term;
869 :
870 : /* Skip over backslashed characters and also entire \Q...\E */
871 :
872 0 : if (*ptr == '\\')
873 : {
874 0 : if (*(++ptr) == 0) return -1;
875 0 : if (*ptr == 'Q') for (;;)
876 : {
877 0 : while (*(++ptr) != 0 && *ptr != '\\');
878 0 : if (*ptr == 0) return -1;
879 0 : if (*(++ptr) == 'E') break;
880 0 : }
881 0 : continue;
882 : }
883 :
884 : /* Skip over character classes */
885 :
886 0 : if (*ptr == '[')
887 : {
888 0 : while (*(++ptr) != ']')
889 : {
890 0 : if (*ptr == '\\')
891 : {
892 0 : if (*(++ptr) == 0) return -1;
893 0 : if (*ptr == 'Q') for (;;)
894 : {
895 0 : while (*(++ptr) != 0 && *ptr != '\\');
896 0 : if (*ptr == 0) return -1;
897 0 : if (*(++ptr) == 'E') break;
898 0 : }
899 0 : continue;
900 : }
901 : }
902 0 : continue;
903 : }
904 :
905 : /* Skip comments in /x mode */
906 :
907 0 : if (xmode && *ptr == '#')
908 : {
909 0 : while (*(++ptr) != 0 && *ptr != '\n');
910 0 : if (*ptr == 0) return -1;
911 0 : continue;
912 : }
913 :
914 : /* An opening parens must now be a real metacharacter */
915 :
916 0 : if (*ptr != '(') continue;
917 0 : if (ptr[1] != '?')
918 : {
919 0 : count++;
920 0 : if (name == NULL && count == lorn) return count;
921 0 : continue;
922 : }
923 :
924 0 : ptr += 2;
925 0 : if (*ptr == 'P') ptr++; /* Allow optional P */
926 :
927 : /* We have to disambiguate (?<! and (?<= from (?<name> */
928 :
929 0 : if ((*ptr != '<' || ptr[1] == '!' || ptr[1] == '=') &&
930 : *ptr != '\'')
931 0 : continue;
932 :
933 0 : count++;
934 :
935 0 : if (name == NULL && count == lorn) return count;
936 0 : term = *ptr++;
937 0 : if (term == '<') term = '>';
938 0 : thisname = ptr;
939 0 : while (*ptr != term) ptr++;
940 0 : if (name != NULL && lorn == ptr - thisname &&
941 : strncmp((const char *)name, (const char *)thisname, lorn) == 0)
942 0 : return count;
943 : }
944 :
945 0 : return -1;
946 : }
947 :
948 :
949 :
950 : /*************************************************
951 : * Find first significant op code *
952 : *************************************************/
953 :
954 : /* This is called by several functions that scan a compiled expression looking
955 : for a fixed first character, or an anchoring op code etc. It skips over things
956 : that do not influence this. For some calls, a change of option is important.
957 : For some calls, it makes sense to skip negative forward and all backward
958 : assertions, and also the \b assertion; for others it does not.
959 :
960 : Arguments:
961 : code pointer to the start of the group
962 : options pointer to external options
963 : optbit the option bit whose changing is significant, or
964 : zero if none are
965 : skipassert TRUE if certain assertions are to be skipped
966 :
967 : Returns: pointer to the first significant opcode
968 : */
969 :
970 : static const uschar*
971 : first_significant_code(const uschar *code, int *options, int optbit,
972 : BOOL skipassert)
973 186 : {
974 : for (;;)
975 : {
976 186 : switch ((int)*code)
977 : {
978 : case OP_OPT:
979 0 : if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))
980 0 : *options = (int)code[1];
981 0 : code += 2;
982 0 : break;
983 :
984 : case OP_ASSERT_NOT:
985 : case OP_ASSERTBACK:
986 : case OP_ASSERTBACK_NOT:
987 0 : if (!skipassert) return code;
988 0 : do code += GET(code, 1); while (*code == OP_ALT);
989 0 : code += _pcre_OP_lengths[*code];
990 0 : break;
991 :
992 : case OP_WORD_BOUNDARY:
993 : case OP_NOT_WORD_BOUNDARY:
994 0 : if (!skipassert) return code;
995 : /* Fall through */
996 :
997 : case OP_CALLOUT:
998 : case OP_CREF:
999 : case OP_RREF:
1000 : case OP_DEF:
1001 0 : code += _pcre_OP_lengths[*code];
1002 0 : break;
1003 :
1004 : default:
1005 186 : return code;
1006 : }
1007 0 : }
1008 : /* Control never reaches here */
1009 : }
1010 :
1011 :
1012 :
1013 :
1014 : /*************************************************
1015 : * Find the fixed length of a pattern *
1016 : *************************************************/
1017 :
1018 : /* Scan a pattern and compute the fixed length of subject that will match it,
1019 : if the length is fixed. This is needed for dealing with backward assertions.
1020 : In UTF8 mode, the result is in characters rather than bytes.
1021 :
1022 : Arguments:
1023 : code points to the start of the pattern (the bracket)
1024 : options the compiling options
1025 :
1026 : Returns: the fixed length, or -1 if there is no fixed length,
1027 : or -2 if \C was encountered
1028 : */
1029 :
1030 : static int
1031 : find_fixedlength(uschar *code, int options)
1032 0 : {
1033 0 : int length = -1;
1034 :
1035 0 : register int branchlength = 0;
1036 0 : register uschar *cc = code + 1 + LINK_SIZE;
1037 :
1038 : /* Scan along the opcodes for this branch. If we get to the end of the
1039 : branch, check the length against that of the other branches. */
1040 :
1041 : for (;;)
1042 : {
1043 : int d;
1044 0 : register int op = *cc;
1045 :
1046 0 : switch (op)
1047 : {
1048 : case OP_CBRA:
1049 : case OP_BRA:
1050 : case OP_ONCE:
1051 : case OP_COND:
1052 0 : d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), options);
1053 0 : if (d < 0) return d;
1054 0 : branchlength += d;
1055 0 : do cc += GET(cc, 1); while (*cc == OP_ALT);
1056 0 : cc += 1 + LINK_SIZE;
1057 0 : break;
1058 :
1059 : /* Reached end of a branch; if it's a ket it is the end of a nested
1060 : call. If it's ALT it is an alternation in a nested call. If it is
1061 : END it's the end of the outer call. All can be handled by the same code. */
1062 :
1063 : case OP_ALT:
1064 : case OP_KET:
1065 : case OP_KETRMAX:
1066 : case OP_KETRMIN:
1067 : case OP_END:
1068 0 : if (length < 0) length = branchlength;
1069 0 : else if (length != branchlength) return -1;
1070 0 : if (*cc != OP_ALT) return length;
1071 0 : cc += 1 + LINK_SIZE;
1072 0 : branchlength = 0;
1073 0 : break;
1074 :
1075 : /* Skip over assertive subpatterns */
1076 :
1077 : case OP_ASSERT:
1078 : case OP_ASSERT_NOT:
1079 : case OP_ASSERTBACK:
1080 : case OP_ASSERTBACK_NOT:
1081 0 : do cc += GET(cc, 1); while (*cc == OP_ALT);
1082 : /* Fall through */
1083 :
1084 : /* Skip over things that don't match chars */
1085 :
1086 : case OP_REVERSE:
1087 : case OP_CREF:
1088 : case OP_RREF:
1089 : case OP_DEF:
1090 : case OP_OPT:
1091 : case OP_CALLOUT:
1092 : case OP_SOD:
1093 : case OP_SOM:
1094 : case OP_EOD:
1095 : case OP_EODN:
1096 : case OP_CIRC:
1097 : case OP_DOLL:
1098 : case OP_NOT_WORD_BOUNDARY:
1099 : case OP_WORD_BOUNDARY:
1100 0 : cc += _pcre_OP_lengths[*cc];
1101 0 : break;
1102 :
1103 : /* Handle literal characters */
1104 :
1105 : case OP_CHAR:
1106 : case OP_CHARNC:
1107 : case OP_NOT:
1108 0 : branchlength++;
1109 0 : cc += 2;
1110 : #ifdef SUPPORT_UTF8
1111 0 : if ((options & PCRE_UTF8) != 0)
1112 : {
1113 0 : while ((*cc & 0xc0) == 0x80) cc++;
1114 : }
1115 : #endif
1116 0 : break;
1117 :
1118 : /* Handle exact repetitions. The count is already in characters, but we
1119 : need to skip over a multibyte character in UTF8 mode. */
1120 :
1121 : case OP_EXACT:
1122 0 : branchlength += GET2(cc,1);
1123 0 : cc += 4;
1124 : #ifdef SUPPORT_UTF8
1125 0 : if ((options & PCRE_UTF8) != 0)
1126 : {
1127 0 : while((*cc & 0x80) == 0x80) cc++;
1128 : }
1129 : #endif
1130 0 : break;
1131 :
1132 : case OP_TYPEEXACT:
1133 0 : branchlength += GET2(cc,1);
1134 0 : cc += 4;
1135 0 : break;
1136 :
1137 : /* Handle single-char matchers */
1138 :
1139 : case OP_PROP:
1140 : case OP_NOTPROP:
1141 0 : cc += 2;
1142 : /* Fall through */
1143 :
1144 : case OP_NOT_DIGIT:
1145 : case OP_DIGIT:
1146 : case OP_NOT_WHITESPACE:
1147 : case OP_WHITESPACE:
1148 : case OP_NOT_WORDCHAR:
1149 : case OP_WORDCHAR:
1150 : case OP_ANY:
1151 0 : branchlength++;
1152 0 : cc++;
1153 0 : break;
1154 :
1155 : /* The single-byte matcher isn't allowed */
1156 :
1157 : case OP_ANYBYTE:
1158 0 : return -2;
1159 :
1160 : /* Check a class for variable quantification */
1161 :
1162 : #ifdef SUPPORT_UTF8
1163 : case OP_XCLASS:
1164 0 : cc += GET(cc, 1) - 33;
1165 : /* Fall through */
1166 : #endif
1167 :
1168 : case OP_CLASS:
1169 : case OP_NCLASS:
1170 0 : cc += 33;
1171 :
1172 0 : switch (*cc)
1173 : {
1174 : case OP_CRSTAR:
1175 : case OP_CRMINSTAR:
1176 : case OP_CRQUERY:
1177 : case OP_CRMINQUERY:
1178 0 : return -1;
1179 :
1180 : case OP_CRRANGE:
1181 : case OP_CRMINRANGE:
1182 0 : if (GET2(cc,1) != GET2(cc,3)) return -1;
1183 0 : branchlength += GET2(cc,1);
1184 0 : cc += 5;
1185 0 : break;
1186 :
1187 : default:
1188 0 : branchlength++;
1189 : }
1190 0 : break;
1191 :
1192 : /* Anything else is variable length */
1193 :
1194 : default:
1195 0 : return -1;
1196 : }
1197 0 : }
1198 : /* Control never gets here */
1199 : }
1200 :
1201 :
1202 :
1203 :
1204 : /*************************************************
1205 : * Scan compiled regex for numbered bracket *
1206 : *************************************************/
1207 :
1208 : /* This little function scans through a compiled pattern until it finds a
1209 : capturing bracket with the given number.
1210 :
1211 : Arguments:
1212 : code points to start of expression
1213 : utf8 TRUE in UTF-8 mode
1214 : number the required bracket number
1215 :
1216 : Returns: pointer to the opcode for the bracket, or NULL if not found
1217 : */
1218 :
1219 : static const uschar *
1220 : find_bracket(const uschar *code, BOOL utf8, int number)
1221 0 : {
1222 : for (;;)
1223 : {
1224 0 : register int c = *code;
1225 0 : if (c == OP_END) return NULL;
1226 :
1227 : /* XCLASS is used for classes that cannot be represented just by a bit
1228 : map. This includes negated single high-valued characters. The length in
1229 : the table is zero; the actual length is stored in the compiled code. */
1230 :
1231 0 : if (c == OP_XCLASS) code += GET(code, 1);
1232 :
1233 : /* Handle capturing bracket */
1234 :
1235 0 : else if (c == OP_CBRA)
1236 : {
1237 0 : int n = GET2(code, 1+LINK_SIZE);
1238 0 : if (n == number) return (uschar *)code;
1239 0 : code += _pcre_OP_lengths[c];
1240 : }
1241 :
1242 : /* In UTF-8 mode, opcodes that are followed by a character may be followed by
1243 : a multi-byte character. The length in the table is a minimum, so we have to
1244 : arrange to skip the extra bytes. */
1245 :
1246 : else
1247 : {
1248 0 : code += _pcre_OP_lengths[c];
1249 0 : if (utf8) switch(c)
1250 : {
1251 : case OP_CHAR:
1252 : case OP_CHARNC:
1253 : case OP_EXACT:
1254 : case OP_UPTO:
1255 : case OP_MINUPTO:
1256 : case OP_POSUPTO:
1257 : case OP_STAR:
1258 : case OP_MINSTAR:
1259 : case OP_POSSTAR:
1260 : case OP_PLUS:
1261 : case OP_MINPLUS:
1262 : case OP_POSPLUS:
1263 : case OP_QUERY:
1264 : case OP_MINQUERY:
1265 : case OP_POSQUERY:
1266 0 : if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
1267 : break;
1268 : }
1269 : }
1270 0 : }
1271 : }
1272 :
1273 :
1274 :
1275 : /*************************************************
1276 : * Scan compiled regex for recursion reference *
1277 : *************************************************/
1278 :
1279 : /* This little function scans through a compiled pattern until it finds an
1280 : instance of OP_RECURSE.
1281 :
1282 : Arguments:
1283 : code points to start of expression
1284 : utf8 TRUE in UTF-8 mode
1285 :
1286 : Returns: pointer to the opcode for OP_RECURSE, or NULL if not found
1287 : */
1288 :
1289 : static const uschar *
1290 : find_recurse(const uschar *code, BOOL utf8)
1291 170 : {
1292 : for (;;)
1293 : {
1294 170 : register int c = *code;
1295 170 : if (c == OP_END) return NULL;
1296 136 : if (c == OP_RECURSE) return code;
1297 :
1298 : /* XCLASS is used for classes that cannot be represented just by a bit
1299 : map. This includes negated single high-valued characters. The length in
1300 : the table is zero; the actual length is stored in the compiled code. */
1301 :
1302 136 : if (c == OP_XCLASS) code += GET(code, 1);
1303 :
1304 : /* Otherwise, we get the item's length from the table. In UTF-8 mode, opcodes
1305 : that are followed by a character may be followed by a multi-byte character.
1306 : The length in the table is a minimum, so we have to arrange to skip the extra
1307 : bytes. */
1308 :
1309 : else
1310 : {
1311 136 : code += _pcre_OP_lengths[c];
1312 136 : if (utf8) switch(c)
1313 : {
1314 : case OP_CHAR:
1315 : case OP_CHARNC:
1316 : case OP_EXACT:
1317 : case OP_UPTO:
1318 : case OP_MINUPTO:
1319 : case OP_POSUPTO:
1320 : case OP_STAR:
1321 : case OP_MINSTAR:
1322 : case OP_POSSTAR:
1323 : case OP_PLUS:
1324 : case OP_MINPLUS:
1325 : case OP_POSPLUS:
1326 : case OP_QUERY:
1327 : case OP_MINQUERY:
1328 : case OP_POSQUERY:
1329 0 : if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
1330 : break;
1331 : }
1332 : }
1333 136 : }
1334 : }
1335 :
1336 :
1337 :
1338 : /*************************************************
1339 : * Scan compiled branch for non-emptiness *
1340 : *************************************************/
1341 :
1342 : /* This function scans through a branch of a compiled pattern to see whether it
1343 : can match the empty string or not. It is called from could_be_empty()
1344 : below and from compile_branch() when checking for an unlimited repeat of a
1345 : group that can match nothing. Note that first_significant_code() skips over
1346 : assertions. If we hit an unclosed bracket, we return "empty" - this means we've
1347 : struck an inner bracket whose current branch will already have been scanned.
1348 :
1349 : Arguments:
1350 : code points to start of search
1351 : endcode points to where to stop
1352 : utf8 TRUE if in UTF8 mode
1353 :
1354 : Returns: TRUE if what is matched could be empty
1355 : */
1356 :
1357 : static BOOL
1358 : could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8)
1359 0 : {
1360 : register int c;
1361 0 : for (code = first_significant_code(code + _pcre_OP_lengths[*code], NULL, 0, TRUE);
1362 0 : code < endcode;
1363 0 : code = first_significant_code(code + _pcre_OP_lengths[c], NULL, 0, TRUE))
1364 : {
1365 : const uschar *ccode;
1366 :
1367 0 : c = *code;
1368 :
1369 0 : if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE)
1370 : {
1371 : BOOL empty_branch;
1372 0 : if (GET(code, 1) == 0) return TRUE; /* Hit unclosed bracket */
1373 :
1374 : /* Scan a closed bracket */
1375 :
1376 0 : empty_branch = FALSE;
1377 : do
1378 : {
1379 0 : if (!empty_branch && could_be_empty_branch(code, endcode, utf8))
1380 0 : empty_branch = TRUE;
1381 0 : code += GET(code, 1);
1382 : }
1383 0 : while (*code == OP_ALT);
1384 0 : if (!empty_branch) return FALSE; /* All branches are non-empty */
1385 :
1386 : /* Move past the KET and fudge things so that the increment in the "for"
1387 : above has no effect. */
1388 :
1389 0 : c = OP_END;
1390 0 : code += 1 + LINK_SIZE - _pcre_OP_lengths[c];
1391 0 : continue;
1392 : }
1393 :
1394 : /* Handle the other opcodes */
1395 :
1396 0 : switch (c)
1397 : {
1398 : /* Check for quantifiers after a class */
1399 :
1400 : #ifdef SUPPORT_UTF8
1401 : case OP_XCLASS:
1402 0 : ccode = code + GET(code, 1);
1403 0 : goto CHECK_CLASS_REPEAT;
1404 : #endif
1405 :
1406 : case OP_CLASS:
1407 : case OP_NCLASS:
1408 0 : ccode = code + 33;
1409 :
1410 : #ifdef SUPPORT_UTF8
1411 0 : CHECK_CLASS_REPEAT:
1412 : #endif
1413 :
1414 0 : switch (*ccode)
1415 : {
1416 : case OP_CRSTAR: /* These could be empty; continue */
1417 : case OP_CRMINSTAR:
1418 : case OP_CRQUERY:
1419 : case OP_CRMINQUERY:
1420 0 : break;
1421 :
1422 : default: /* Non-repeat => class must match */
1423 : case OP_CRPLUS: /* These repeats aren't empty */
1424 : case OP_CRMINPLUS:
1425 0 : return FALSE;
1426 :
1427 : case OP_CRRANGE:
1428 : case OP_CRMINRANGE:
1429 0 : if (GET2(ccode, 1) > 0) return FALSE; /* Minimum > 0 */
1430 : break;
1431 : }
1432 0 : break;
1433 :
1434 : /* Opcodes that must match a character */
1435 :
1436 : case OP_PROP:
1437 : case OP_NOTPROP:
1438 : case OP_EXTUNI:
1439 : case OP_NOT_DIGIT:
1440 : case OP_DIGIT:
1441 : case OP_NOT_WHITESPACE:
1442 : case OP_WHITESPACE:
1443 : case OP_NOT_WORDCHAR:
1444 : case OP_WORDCHAR:
1445 : case OP_ANY:
1446 : case OP_ANYBYTE:
1447 : case OP_CHAR:
1448 : case OP_CHARNC:
1449 : case OP_NOT:
1450 : case OP_PLUS:
1451 : case OP_MINPLUS:
1452 : case OP_POSPLUS:
1453 : case OP_EXACT:
1454 : case OP_NOTPLUS:
1455 : case OP_NOTMINPLUS:
1456 : case OP_NOTPOSPLUS:
1457 : case OP_NOTEXACT:
1458 : case OP_TYPEPLUS:
1459 : case OP_TYPEMINPLUS:
1460 : case OP_TYPEPOSPLUS:
1461 : case OP_TYPEEXACT:
1462 0 : return FALSE;
1463 :
1464 : /* End of branch */
1465 :
1466 : case OP_KET:
1467 : case OP_KETRMAX:
1468 : case OP_KETRMIN:
1469 : case OP_ALT:
1470 0 : return TRUE;
1471 :
1472 : /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
1473 : MINUPTO, and POSUPTO may be followed by a multibyte character */
1474 :
1475 : #ifdef SUPPORT_UTF8
1476 : case OP_STAR:
1477 : case OP_MINSTAR:
1478 : case OP_POSSTAR:
1479 : case OP_QUERY:
1480 : case OP_MINQUERY:
1481 : case OP_POSQUERY:
1482 : case OP_UPTO:
1483 : case OP_MINUPTO:
1484 : case OP_POSUPTO:
1485 0 : if (utf8) while ((code[2] & 0xc0) == 0x80) code++;
1486 : break;
1487 : #endif
1488 : }
1489 : }
1490 :
1491 0 : return TRUE;
1492 : }
1493 :
1494 :
1495 :
1496 : /*************************************************
1497 : * Scan compiled regex for non-emptiness *
1498 : *************************************************/
1499 :
1500 : /* This function is called to check for left recursive calls. We want to check
1501 : the current branch of the current pattern to see if it could match the empty
1502 : string. If it could, we must look outwards for branches at other levels,
1503 : stopping when we pass beyond the bracket which is the subject of the recursion.
1504 :
1505 : Arguments:
1506 : code points to start of the recursion
1507 : endcode points to where to stop (current RECURSE item)
1508 : bcptr points to the chain of current (unclosed) branch starts
1509 : utf8 TRUE if in UTF-8 mode
1510 :
1511 : Returns: TRUE if what is matched could be empty
1512 : */
1513 :
1514 : static BOOL
1515 : could_be_empty(const uschar *code, const uschar *endcode, branch_chain *bcptr,
1516 : BOOL utf8)
1517 0 : {
1518 0 : while (bcptr != NULL && bcptr->current >= code)
1519 : {
1520 0 : if (!could_be_empty_branch(bcptr->current, endcode, utf8)) return FALSE;
1521 0 : bcptr = bcptr->outer;
1522 : }
1523 0 : return TRUE;
1524 : }
1525 :
1526 :
1527 :
1528 : /*************************************************
1529 : * Check for POSIX class syntax *
1530 : *************************************************/
1531 :
1532 : /* This function is called when the sequence "[:" or "[." or "[=" is
1533 : encountered in a character class. It checks whether this is followed by an
1534 : optional ^ and then a sequence of letters, terminated by a matching ":]" or
1535 : ".]" or "=]".
1536 :
1537 : Argument:
1538 : ptr pointer to the initial [
1539 : endptr where to return the end pointer
1540 : cd pointer to compile data
1541 :
1542 : Returns: TRUE or FALSE
1543 : */
1544 :
1545 : static BOOL
1546 : check_posix_syntax(const uschar *ptr, const uschar **endptr, compile_data *cd)
1547 0 : {
1548 : int terminator; /* Don't combine these lines; the Solaris cc */
1549 0 : terminator = *(++ptr); /* compiler warns about "non-constant" initializer. */
1550 0 : if (*(++ptr) == '^') ptr++;
1551 0 : while ((cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;
1552 0 : if (*ptr == terminator && ptr[1] == ']')
1553 : {
1554 0 : *endptr = ptr;
1555 0 : return TRUE;
1556 : }
1557 0 : return FALSE;
1558 : }
1559 :
1560 :
1561 :
1562 :
1563 : /*************************************************
1564 : * Check POSIX class name *
1565 : *************************************************/
1566 :
1567 : /* This function is called to check the name given in a POSIX-style class entry
1568 : such as [:alnum:].
1569 :
1570 : Arguments:
1571 : ptr points to the first letter
1572 : len the length of the name
1573 :
1574 : Returns: a value representing the name, or -1 if unknown
1575 : */
1576 :
1577 : static int
1578 : check_posix_name(const uschar *ptr, int len)
1579 0 : {
1580 0 : register int yield = 0;
1581 0 : while (posix_name_lengths[yield] != 0)
1582 : {
1583 0 : if (len == posix_name_lengths[yield] &&
1584 0 : strncmp((const char *)ptr, posix_names[yield], len) == 0) return yield;
1585 0 : yield++;
1586 : }
1587 0 : return -1;
1588 : }
1589 :
1590 :
1591 : /*************************************************
1592 : * Adjust OP_RECURSE items in repeated group *
1593 : *************************************************/
1594 :
1595 : /* OP_RECURSE items contain an offset from the start of the regex to the group
1596 : that is referenced. This means that groups can be replicated for fixed
1597 : repetition simply by copying (because the recursion is allowed to refer to
1598 : earlier groups that are outside the current group). However, when a group is
1599 : optional (i.e. the minimum quantifier is zero), OP_BRAZERO is inserted before
1600 : it, after it has been compiled. This means that any OP_RECURSE items within it
1601 : that refer to the group itself or any contained groups have to have their
1602 : offsets adjusted. That one of the jobs of this function. Before it is called,
1603 : the partially compiled regex must be temporarily terminated with OP_END.
1604 :
1605 : This function has been extended with the possibility of forward references for
1606 : recursions and subroutine calls. It must also check the list of such references
1607 : for the group we are dealing with. If it finds that one of the recursions in
1608 : the current group is on this list, it adjusts the offset in the list, not the
1609 : value in the reference (which is a group number).
1610 :
1611 : Arguments:
1612 : group points to the start of the group
1613 : adjust the amount by which the group is to be moved
1614 : utf8 TRUE in UTF-8 mode
1615 : cd contains pointers to tables etc.
1616 : save_hwm the hwm forward reference pointer at the start of the group
1617 :
1618 : Returns: nothing
1619 : */
1620 :
1621 : static void
1622 : adjust_recurse(uschar *group, int adjust, BOOL utf8, compile_data *cd,
1623 : uschar *save_hwm)
1624 34 : {
1625 34 : uschar *ptr = group;
1626 68 : while ((ptr = (uschar *)find_recurse(ptr, utf8)) != NULL)
1627 : {
1628 : int offset;
1629 : uschar *hc;
1630 :
1631 : /* See if this recursion is on the forward reference list. If so, adjust the
1632 : reference. */
1633 :
1634 0 : for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)
1635 : {
1636 0 : offset = GET(hc, 0);
1637 0 : if (cd->start_code + offset == ptr + 1)
1638 : {
1639 0 : PUT(hc, 0, offset + adjust);
1640 0 : break;
1641 : }
1642 : }
1643 :
1644 : /* Otherwise, adjust the recursion offset if it's after the start of this
1645 : group. */
1646 :
1647 0 : if (hc >= cd->hwm)
1648 : {
1649 0 : offset = GET(ptr, 1);
1650 0 : if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
1651 : }
1652 :
1653 0 : ptr += 1 + LINK_SIZE;
1654 : }
1655 34 : }
1656 :
1657 :
1658 :
1659 : /*************************************************
1660 : * Insert an automatic callout point *
1661 : *************************************************/
1662 :
1663 : /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
1664 : callout points before each pattern item.
1665 :
1666 : Arguments:
1667 : code current code pointer
1668 : ptr current pattern pointer
1669 : cd pointers to tables etc
1670 :
1671 : Returns: new code pointer
1672 : */
1673 :
1674 : static uschar *
1675 : auto_callout(uschar *code, const uschar *ptr, compile_data *cd)
1676 0 : {
1677 0 : *code++ = OP_CALLOUT;
1678 0 : *code++ = 255;
1679 0 : PUT(code, 0, ptr - cd->start_pattern); /* Pattern offset */
1680 0 : PUT(code, LINK_SIZE, 0); /* Default length */
1681 0 : return code + 2*LINK_SIZE;
1682 : }
1683 :
1684 :
1685 :
1686 : /*************************************************
1687 : * Complete a callout item *
1688 : *************************************************/
1689 :
1690 : /* A callout item contains the length of the next item in the pattern, which
1691 : we can't fill in till after we have reached the relevant point. This is used
1692 : for both automatic and manual callouts.
1693 :
1694 : Arguments:
1695 : previous_callout points to previous callout item
1696 : ptr current pattern pointer
1697 : cd pointers to tables etc
1698 :
1699 : Returns: nothing
1700 : */
1701 :
1702 : static void
1703 : complete_callout(uschar *previous_callout, const uschar *ptr, compile_data *cd)
1704 0 : {
1705 0 : int length = ptr - cd->start_pattern - GET(previous_callout, 2);
1706 0 : PUT(previous_callout, 2 + LINK_SIZE, length);
1707 0 : }
1708 :
1709 :
1710 :
1711 : #ifdef SUPPORT_UCP
1712 : /*************************************************
1713 : * Get othercase range *
1714 : *************************************************/
1715 :
1716 : /* This function is passed the start and end of a class range, in UTF-8 mode
1717 : with UCP support. It searches up the characters, looking for internal ranges of
1718 : characters in the "other" case. Each call returns the next one, updating the
1719 : start address.
1720 :
1721 : Arguments:
1722 : cptr points to starting character value; updated
1723 : d end value
1724 : ocptr where to put start of othercase range
1725 : odptr where to put end of othercase range
1726 :
1727 : Yield: TRUE when range returned; FALSE when no more
1728 : */
1729 :
1730 : static BOOL
1731 : get_othercase_range(unsigned int *cptr, unsigned int d, unsigned int *ocptr,
1732 : unsigned int *odptr)
1733 0 : {
1734 : unsigned int c, othercase, next;
1735 :
1736 0 : for (c = *cptr; c <= d; c++)
1737 0 : { if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR) break; }
1738 :
1739 0 : if (c > d) return FALSE;
1740 :
1741 0 : *ocptr = othercase;
1742 0 : next = othercase + 1;
1743 :
1744 0 : for (++c; c <= d; c++)
1745 : {
1746 0 : if (_pcre_ucp_othercase(c) != next) break;
1747 0 : next++;
1748 : }
1749 :
1750 0 : *odptr = next - 1;
1751 0 : *cptr = c;
1752 :
1753 0 : return TRUE;
1754 : }
1755 : #endif /* SUPPORT_UCP */
1756 :
1757 :
1758 :
1759 : /*************************************************
1760 : * Check if auto-possessifying is possible *
1761 : *************************************************/
1762 :
1763 : /* This function is called for unlimited repeats of certain items, to see
1764 : whether the next thing could possibly match the repeated item. If not, it makes
1765 : sense to automatically possessify the repeated item.
1766 :
1767 : Arguments:
1768 : op_code the repeated op code
1769 : this data for this item, depends on the opcode
1770 : utf8 TRUE in UTF-8 mode
1771 : utf8_char used for utf8 character bytes, NULL if not relevant
1772 : ptr next character in pattern
1773 : options options bits
1774 : cd contains pointers to tables etc.
1775 :
1776 : Returns: TRUE if possessifying is wanted
1777 : */
1778 :
1779 : static BOOL
1780 : check_auto_possessive(int op_code, int item, BOOL utf8, uschar *utf8_char,
1781 : const uschar *ptr, int options, compile_data *cd)
1782 494 : {
1783 : int next;
1784 :
1785 : /* Skip whitespace and comments in extended mode */
1786 :
1787 494 : if ((options & PCRE_EXTENDED) != 0)
1788 : {
1789 : for (;;)
1790 : {
1791 0 : while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
1792 0 : if (*ptr == '#')
1793 : {
1794 0 : while (*(++ptr) != 0)
1795 0 : if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
1796 : }
1797 0 : else break;
1798 0 : }
1799 : }
1800 :
1801 : /* If the next item is one that we can handle, get its value. A non-negative
1802 : value is a character, a negative value is an escape value. */
1803 :
1804 494 : if (*ptr == '\\')
1805 : {
1806 12 : int temperrorcode = 0;
1807 12 : next = check_escape(&ptr, &temperrorcode, cd->bracount, options, FALSE);
1808 12 : if (temperrorcode != 0) return FALSE;
1809 12 : ptr++; /* Point after the escape sequence */
1810 : }
1811 :
1812 482 : else if ((cd->ctypes[*ptr] & ctype_meta) == 0)
1813 : {
1814 : #ifdef SUPPORT_UTF8
1815 448 : if (utf8) { GETCHARINC(next, ptr); } else
1816 : #endif
1817 448 : next = *ptr++;
1818 : }
1819 :
1820 34 : else return FALSE;
1821 :
1822 : /* Skip whitespace and comments in extended mode */
1823 :
1824 460 : if ((options & PCRE_EXTENDED) != 0)
1825 : {
1826 : for (;;)
1827 : {
1828 0 : while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
1829 0 : if (*ptr == '#')
1830 : {
1831 0 : while (*(++ptr) != 0)
1832 0 : if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
1833 : }
1834 0 : else break;
1835 0 : }
1836 : }
1837 :
1838 : /* If the next thing is itself optional, we have to give up. */
1839 :
1840 460 : if (*ptr == '*' || *ptr == '?' || strncmp((char *)ptr, "{0,", 3) == 0)
1841 0 : return FALSE;
1842 :
1843 : /* Now compare the next item with the previous opcode. If the previous is a
1844 : positive single character match, "item" either contains the character or, if
1845 : "item" is greater than 127 in utf8 mode, the character's bytes are in
1846 : utf8_char. */
1847 :
1848 :
1849 : /* Handle cases when the next item is a character. */
1850 :
1851 460 : if (next >= 0) switch(op_code)
1852 : {
1853 : case OP_CHAR:
1854 : #ifdef SUPPORT_UTF8
1855 6 : if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
1856 : #endif
1857 6 : return item != next;
1858 :
1859 : /* For CHARNC (caseless character) we must check the other case. If we have
1860 : Unicode property support, we can use it to test the other case of
1861 : high-valued characters. */
1862 :
1863 : case OP_CHARNC:
1864 : #ifdef SUPPORT_UTF8
1865 0 : if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
1866 : #endif
1867 0 : if (item == next) return FALSE;
1868 : #ifdef SUPPORT_UTF8
1869 0 : if (utf8)
1870 : {
1871 : unsigned int othercase;
1872 0 : if (next < 128) othercase = cd->fcc[next]; else
1873 : #ifdef SUPPORT_UCP
1874 0 : othercase = _pcre_ucp_othercase((unsigned int)next);
1875 : #else
1876 : othercase = NOTACHAR;
1877 : #endif
1878 0 : return (unsigned int)item != othercase;
1879 : }
1880 : else
1881 : #endif /* SUPPORT_UTF8 */
1882 0 : return (item != cd->fcc[next]); /* Non-UTF-8 mode */
1883 :
1884 : /* For OP_NOT, "item" must be a single-byte character. */
1885 :
1886 : case OP_NOT:
1887 0 : if (next < 0) return FALSE; /* Not a character */
1888 0 : if (item == next) return TRUE;
1889 0 : if ((options & PCRE_CASELESS) == 0) return FALSE;
1890 : #ifdef SUPPORT_UTF8
1891 0 : if (utf8)
1892 : {
1893 : unsigned int othercase;
1894 0 : if (next < 128) othercase = cd->fcc[next]; else
1895 : #ifdef SUPPORT_UCP
1896 0 : othercase = _pcre_ucp_othercase(next);
1897 : #else
1898 : othercase = NOTACHAR;
1899 : #endif
1900 0 : return (unsigned int)item == othercase;
1901 : }
1902 : else
1903 : #endif /* SUPPORT_UTF8 */
1904 0 : return (item == cd->fcc[next]); /* Non-UTF-8 mode */
1905 :
1906 : case OP_DIGIT:
1907 0 : return next > 127 || (cd->ctypes[next] & ctype_digit) == 0;
1908 :
1909 : case OP_NOT_DIGIT:
1910 0 : return next <= 127 && (cd->ctypes[next] & ctype_digit) != 0;
1911 :
1912 : case OP_WHITESPACE:
1913 2 : return next > 127 || (cd->ctypes[next] & ctype_space) == 0;
1914 :
1915 : case OP_NOT_WHITESPACE:
1916 0 : return next <= 127 && (cd->ctypes[next] & ctype_space) != 0;
1917 :
1918 : case OP_WORDCHAR:
1919 0 : return next > 127 || (cd->ctypes[next] & ctype_word) == 0;
1920 :
1921 : case OP_NOT_WORDCHAR:
1922 0 : return next <= 127 && (cd->ctypes[next] & ctype_word) != 0;
1923 :
1924 : default:
1925 452 : return FALSE;
1926 : }
1927 :
1928 :
1929 : /* Handle the case when the next item is \d, \s, etc. */
1930 :
1931 0 : switch(op_code)
1932 : {
1933 : case OP_CHAR:
1934 : case OP_CHARNC:
1935 : #ifdef SUPPORT_UTF8
1936 0 : if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
1937 : #endif
1938 0 : switch(-next)
1939 : {
1940 : case ESC_d:
1941 0 : return item > 127 || (cd->ctypes[item] & ctype_digit) == 0;
1942 :
1943 : case ESC_D:
1944 0 : return item <= 127 && (cd->ctypes[item] & ctype_digit) != 0;
1945 :
1946 : case ESC_s:
1947 0 : return item > 127 || (cd->ctypes[item] & ctype_space) == 0;
1948 :
1949 : case ESC_S:
1950 0 : return item <= 127 && (cd->ctypes[item] & ctype_space) != 0;
1951 :
1952 : case ESC_w:
1953 0 : return item > 127 || (cd->ctypes[item] & ctype_word) == 0;
1954 :
1955 : case ESC_W:
1956 0 : return item <= 127 && (cd->ctypes[item] & ctype_word) != 0;
1957 :
1958 : default:
1959 0 : return FALSE;
1960 : }
1961 :
1962 : case OP_DIGIT:
1963 0 : return next == -ESC_D || next == -ESC_s || next == -ESC_W;
1964 :
1965 : case OP_NOT_DIGIT:
1966 0 : return next == -ESC_d;
1967 :
1968 : case OP_WHITESPACE:
1969 0 : return next == -ESC_S || next == -ESC_d || next == -ESC_w;
1970 :
1971 : case OP_NOT_WHITESPACE:
1972 0 : return next == -ESC_s;
1973 :
1974 : case OP_WORDCHAR:
1975 0 : return next == -ESC_W || next == -ESC_s;
1976 :
1977 : case OP_NOT_WORDCHAR:
1978 0 : return next == -ESC_w || next == -ESC_d;
1979 :
1980 : default:
1981 0 : return FALSE;
1982 : }
1983 :
1984 : /* Control does not reach here */
1985 : }
1986 :
1987 :
1988 :
1989 : /*************************************************
1990 : * Compile one branch *
1991 : *************************************************/
1992 :
1993 : /* Scan the pattern, compiling it into the a vector. If the options are
1994 : changed during the branch, the pointer is used to change the external options
1995 : bits. This function is used during the pre-compile phase when we are trying
1996 : to find out the amount of memory needed, as well as during the real compile
1997 : phase. The value of lengthptr distinguishes the two phases.
1998 :
1999 : Arguments:
2000 : optionsptr pointer to the option bits
2001 : codeptr points to the pointer to the current code point
2002 : ptrptr points to the current pattern pointer
2003 : errorcodeptr points to error code variable
2004 : firstbyteptr set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
2005 : reqbyteptr set to the last literal character required, else < 0
2006 : bcptr points to current branch chain
2007 : cd contains pointers to tables etc.
2008 : lengthptr NULL during the real compile phase
2009 : points to length accumulator during pre-compile phase
2010 :
2011 : Returns: TRUE on success
2012 : FALSE, with *errorcodeptr set non-zero on error
2013 : */
2014 :
2015 : static BOOL
2016 : compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,
2017 : int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
2018 : compile_data *cd, int *lengthptr)
2019 406 : {
2020 : int repeat_type, op_type;
2021 406 : int repeat_min = 0, repeat_max = 0; /* To please picky compilers */
2022 406 : int bravalue = 0;
2023 : int greedy_default, greedy_non_default;
2024 : int firstbyte, reqbyte;
2025 : int zeroreqbyte, zerofirstbyte;
2026 : int req_caseopt, reqvary, tempreqvary;
2027 406 : int options = *optionsptr;
2028 406 : int after_manual_callout = 0;
2029 406 : int length_prevgroup = 0;
2030 : register int c;
2031 406 : register uschar *code = *codeptr;
2032 406 : uschar *last_code = code;
2033 406 : uschar *orig_code = code;
2034 : uschar *tempcode;
2035 406 : BOOL inescq = FALSE;
2036 406 : BOOL groupsetfirstbyte = FALSE;
2037 406 : const uschar *ptr = *ptrptr;
2038 : const uschar *tempptr;
2039 406 : uschar *previous = NULL;
2040 406 : uschar *previous_callout = NULL;
2041 406 : uschar *save_hwm = NULL;
2042 : uschar classbits[32];
2043 :
2044 : #ifdef SUPPORT_UTF8
2045 : BOOL class_utf8;
2046 406 : BOOL utf8 = (options & PCRE_UTF8) != 0;
2047 : uschar *class_utf8data;
2048 : uschar utf8_char[6];
2049 : #else
2050 : BOOL utf8 = FALSE;
2051 : uschar *utf8_char = NULL;
2052 : #endif
2053 :
2054 : #ifdef DEBUG
2055 : if (lengthptr != NULL) DPRINTF((">> start branch\n"));
2056 : #endif
2057 :
2058 : /* Set up the default and non-default settings for greediness */
2059 :
2060 406 : greedy_default = ((options & PCRE_UNGREEDY) != 0);
2061 406 : greedy_non_default = greedy_default ^ 1;
2062 :
2063 : /* Initialize no first byte, no required byte. REQ_UNSET means "no char
2064 : matching encountered yet". It gets changed to REQ_NONE if we hit something that
2065 : matches a non-fixed char first char; reqbyte just remains unset if we never
2066 : find one.
2067 :
2068 : When we hit a repeat whose minimum is zero, we may have to adjust these values
2069 : to take the zero repeat into account. This is implemented by setting them to
2070 : zerofirstbyte and zeroreqbyte when such a repeat is encountered. The individual
2071 : item types that can be repeated set these backoff variables appropriately. */
2072 :
2073 406 : firstbyte = reqbyte = zerofirstbyte = zeroreqbyte = REQ_UNSET;
2074 :
2075 : /* The variable req_caseopt contains either the REQ_CASELESS value or zero,
2076 : according to the current setting of the caseless flag. REQ_CASELESS is a bit
2077 : value > 255. It is added into the firstbyte or reqbyte variables to record the
2078 : case status of the value. This is used only for ASCII characters. */
2079 :
2080 406 : req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
2081 :
2082 : /* Switch on next character until the end of the branch */
2083 :
2084 73508 : for (;; ptr++)
2085 : {
2086 : BOOL negate_class;
2087 : BOOL possessive_quantifier;
2088 : BOOL is_quantifier;
2089 : BOOL is_recurse;
2090 : int class_charcount;
2091 : int class_lastchar;
2092 : int newoptions;
2093 : int recno;
2094 : int skipbytes;
2095 : int subreqbyte;
2096 : int subfirstbyte;
2097 : int terminator;
2098 : int mclength;
2099 : uschar mcbuffer[8];
2100 :
2101 : /* Get next byte in the pattern */
2102 :
2103 73914 : c = *ptr;
2104 :
2105 : /* If we are in the pre-compile phase, accumulate the length used for the
2106 : previous cycle of this loop. */
2107 :
2108 73914 : if (lengthptr != NULL)
2109 : {
2110 : #ifdef DEBUG
2111 : if (code > cd->hwm) cd->hwm = code; /* High water info */
2112 : #endif
2113 36957 : if (code > cd->start_workspace + COMPILE_WORK_SIZE) /* Check for overrun */
2114 : {
2115 0 : *errorcodeptr = ERR52;
2116 0 : goto FAILED;
2117 : }
2118 :
2119 : /* There is at least one situation where code goes backwards: this is the
2120 : case of a zero quantifier after a class (e.g. [ab]{0}). At compile time,
2121 : the class is simply eliminated. However, it is created first, so we have to
2122 : allow memory for it. Therefore, don't ever reduce the length at this point.
2123 : */
2124 :
2125 36957 : if (code < last_code) code = last_code;
2126 36957 : *lengthptr += code - last_code;
2127 : DPRINTF(("length=%d added %d c=%c\n", *lengthptr, code - last_code, c));
2128 :
2129 : /* If "previous" is set and it is not at the start of the work space, move
2130 : it back to there, in order to avoid filling up the work space. Otherwise,
2131 : if "previous" is NULL, reset the current code pointer to the start. */
2132 :
2133 36957 : if (previous != NULL)
2134 : {
2135 35760 : if (previous > orig_code)
2136 : {
2137 34961 : memmove(orig_code, previous, code - previous);
2138 34961 : code -= previous - orig_code;
2139 34961 : previous = orig_code;
2140 : }
2141 : }
2142 1197 : else code = orig_code;
2143 :
2144 : /* Remember where this code item starts so we can pick up the length
2145 : next time round. */
2146 :
2147 36957 : last_code = code;
2148 : }
2149 :
2150 : /* In the real compile phase, just check the workspace used by the forward
2151 : reference list. */
2152 :
2153 36957 : else if (cd->hwm > cd->start_workspace + COMPILE_WORK_SIZE)
2154 : {
2155 0 : *errorcodeptr = ERR52;
2156 0 : goto FAILED;
2157 : }
2158 :
2159 : /* If in \Q...\E, check for the end; if not, we have a literal */
2160 :
2161 73914 : if (inescq && c != 0)
2162 : {
2163 0 : if (c == '\\' && ptr[1] == 'E')
2164 : {
2165 0 : inescq = FALSE;
2166 0 : ptr++;
2167 0 : continue;
2168 : }
2169 : else
2170 : {
2171 0 : if (previous_callout != NULL)
2172 : {
2173 0 : if (lengthptr == NULL) /* Don't attempt in pre-compile phase */
2174 0 : complete_callout(previous_callout, ptr, cd);
2175 0 : previous_callout = NULL;
2176 : }
2177 0 : if ((options & PCRE_AUTO_CALLOUT) != 0)
2178 : {
2179 0 : previous_callout = code;
2180 0 : code = auto_callout(code, ptr, cd);
2181 : }
2182 0 : goto NORMAL_CHAR;
2183 : }
2184 : }
2185 :
2186 : /* Fill in length of a previous callout, except when the next thing is
2187 : a quantifier. */
2188 :
2189 73914 : is_quantifier = c == '*' || c == '+' || c == '?' ||
2190 : (c == '{' && is_counted_repeat(ptr+1));
2191 :
2192 73914 : if (!is_quantifier && previous_callout != NULL &&
2193 : after_manual_callout-- <= 0)
2194 : {
2195 0 : if (lengthptr == NULL) /* Don't attempt in pre-compile phase */
2196 0 : complete_callout(previous_callout, ptr, cd);
2197 0 : previous_callout = NULL;
2198 : }
2199 :
2200 : /* In extended mode, skip white space and comments */
2201 :
2202 73914 : if ((options & PCRE_EXTENDED) != 0)
2203 : {
2204 0 : if ((cd->ctypes[c] & ctype_space) != 0) continue;
2205 0 : if (c == '#')
2206 : {
2207 0 : while (*(++ptr) != 0)
2208 : {
2209 0 : if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
2210 : }
2211 0 : if (*ptr != 0) continue;
2212 :
2213 : /* Else fall through to handle end of string */
2214 0 : c = 0;
2215 : }
2216 : }
2217 :
2218 : /* No auto callout for quantifiers. */
2219 :
2220 73914 : if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier)
2221 : {
2222 0 : previous_callout = code;
2223 0 : code = auto_callout(code, ptr, cd);
2224 : }
2225 :
2226 73914 : switch(c)
2227 : {
2228 : /* ===================================================================*/
2229 : case 0: /* The branch terminates at string end */
2230 : case '|': /* or | or ) */
2231 : case ')':
2232 406 : *firstbyteptr = firstbyte;
2233 406 : *reqbyteptr = reqbyte;
2234 406 : *codeptr = code;
2235 406 : *ptrptr = ptr;
2236 406 : if (lengthptr != NULL)
2237 : {
2238 203 : *lengthptr += code - last_code; /* To include callout length */
2239 : DPRINTF((">> end branch\n"));
2240 : }
2241 406 : return TRUE;
2242 :
2243 :
2244 : /* ===================================================================*/
2245 : /* Handle single-character metacharacters. In multiline mode, ^ disables
2246 : the setting of any following char as a first character. */
2247 :
2248 : case '^':
2249 364 : if ((options & PCRE_MULTILINE) != 0)
2250 : {
2251 0 : if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2252 : }
2253 364 : previous = NULL;
2254 364 : *code++ = OP_CIRC;
2255 364 : break;
2256 :
2257 : case '$':
2258 360 : previous = NULL;
2259 360 : *code++ = OP_DOLL;
2260 360 : break;
2261 :
2262 : /* There can never be a first char if '.' is first, whatever happens about
2263 : repeats. The value of reqbyte doesn't change either. */
2264 :
2265 : case '.':
2266 482 : if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2267 482 : zerofirstbyte = firstbyte;
2268 482 : zeroreqbyte = reqbyte;
2269 482 : previous = code;
2270 482 : *code++ = OP_ANY;
2271 482 : break;
2272 :
2273 :
2274 : /* ===================================================================*/
2275 : /* Character classes. If the included characters are all < 256, we build a
2276 : 32-byte bitmap of the permitted characters, except in the special case
2277 : where there is only one such character. For negated classes, we build the
2278 : map as usual, then invert it at the end. However, we use a different opcode
2279 : so that data characters > 255 can be handled correctly.
2280 :
2281 : If the class contains characters outside the 0-255 range, a different
2282 : opcode is compiled. It may optionally have a bit map for characters < 256,
2283 : but those above are are explicitly listed afterwards. A flag byte tells
2284 : whether the bitmap is present, and whether this is a negated class or not.
2285 : */
2286 :
2287 : case '[':
2288 634 : previous = code;
2289 :
2290 : /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
2291 : they are encountered at the top level, so we'll do that too. */
2292 :
2293 634 : if ((ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
2294 : check_posix_syntax(ptr, &tempptr, cd))
2295 : {
2296 0 : *errorcodeptr = (ptr[1] == ':')? ERR13 : ERR31;
2297 0 : goto FAILED;
2298 : }
2299 :
2300 : /* If the first character is '^', set the negation flag and skip it. */
2301 :
2302 634 : if ((c = *(++ptr)) == '^')
2303 : {
2304 0 : negate_class = TRUE;
2305 0 : c = *(++ptr);
2306 : }
2307 : else
2308 : {
2309 634 : negate_class = FALSE;
2310 : }
2311 :
2312 : /* Keep a count of chars with values < 256 so that we can optimize the case
2313 : of just a single character (as long as it's < 256). However, For higher
2314 : valued UTF-8 characters, we don't yet do any optimization. */
2315 :
2316 634 : class_charcount = 0;
2317 634 : class_lastchar = -1;
2318 :
2319 : /* Initialize the 32-char bit map to all zeros. We build the map in a
2320 : temporary bit of memory, in case the class contains only 1 character (less
2321 : than 256), because in that case the compiled code doesn't use the bit map.
2322 : */
2323 :
2324 634 : memset(classbits, 0, 32 * sizeof(uschar));
2325 :
2326 : #ifdef SUPPORT_UTF8
2327 634 : class_utf8 = FALSE; /* No chars >= 256 */
2328 634 : class_utf8data = code + LINK_SIZE + 2; /* For UTF-8 items */
2329 : #endif
2330 :
2331 : /* Process characters until ] is reached. By writing this as a "do" it
2332 : means that an initial ] is taken as a data character. At the start of the
2333 : loop, c contains the first byte of the character. */
2334 :
2335 634 : if (c != 0) do
2336 : {
2337 : const uschar *oldptr;
2338 :
2339 : #ifdef SUPPORT_UTF8
2340 672 : if (utf8 && c > 127)
2341 : { /* Braces are required because the */
2342 0 : GETCHARLEN(c, ptr, ptr); /* macro generates multiple statements */
2343 : }
2344 : #endif
2345 :
2346 : /* Inside \Q...\E everything is literal except \E */
2347 :
2348 672 : if (inescq)
2349 : {
2350 0 : if (c == '\\' && ptr[1] == 'E') /* If we are at \E */
2351 : {
2352 0 : inescq = FALSE; /* Reset literal state */
2353 0 : ptr++; /* Skip the 'E' */
2354 0 : continue; /* Carry on with next */
2355 : }
2356 0 : goto CHECK_RANGE; /* Could be range if \E follows */
2357 : }
2358 :
2359 : /* Handle POSIX class names. Perl allows a negation extension of the
2360 : form [:^name:]. A square bracket that doesn't match the syntax is
2361 : treated as a literal. We also recognize the POSIX constructions
2362 : [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
2363 : 5.6 and 5.8 do. */
2364 :
2365 672 : if (c == '[' &&
2366 : (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
2367 : check_posix_syntax(ptr, &tempptr, cd))
2368 : {
2369 0 : BOOL local_negate = FALSE;
2370 : int posix_class, taboffset, tabopt;
2371 0 : register const uschar *cbits = cd->cbits;
2372 : uschar pbits[32];
2373 :
2374 0 : if (ptr[1] != ':')
2375 : {
2376 0 : *errorcodeptr = ERR31;
2377 0 : goto FAILED;
2378 : }
2379 :
2380 0 : ptr += 2;
2381 0 : if (*ptr == '^')
2382 : {
2383 0 : local_negate = TRUE;
2384 0 : ptr++;
2385 : }
2386 :
2387 0 : posix_class = check_posix_name(ptr, tempptr - ptr);
2388 0 : if (posix_class < 0)
2389 : {
2390 0 : *errorcodeptr = ERR30;
2391 0 : goto FAILED;
2392 : }
2393 :
2394 : /* If matching is caseless, upper and lower are converted to
2395 : alpha. This relies on the fact that the class table starts with
2396 : alpha, lower, upper as the first 3 entries. */
2397 :
2398 0 : if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
2399 0 : posix_class = 0;
2400 :
2401 : /* We build the bit map for the POSIX class in a chunk of local store
2402 : because we may be adding and subtracting from it, and we don't want to
2403 : subtract bits that may be in the main map already. At the end we or the
2404 : result into the bit map that is being built. */
2405 :
2406 0 : posix_class *= 3;
2407 :
2408 : /* Copy in the first table (always present) */
2409 :
2410 0 : memcpy(pbits, cbits + posix_class_maps[posix_class],
2411 : 32 * sizeof(uschar));
2412 :
2413 : /* If there is a second table, add or remove it as required. */
2414 :
2415 0 : taboffset = posix_class_maps[posix_class + 1];
2416 0 : tabopt = posix_class_maps[posix_class + 2];
2417 :
2418 0 : if (taboffset >= 0)
2419 : {
2420 0 : if (tabopt >= 0)
2421 0 : for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];
2422 : else
2423 0 : for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];
2424 : }
2425 :
2426 : /* Not see if we need to remove any special characters. An option
2427 : value of 1 removes vertical space and 2 removes underscore. */
2428 :
2429 0 : if (tabopt < 0) tabopt = -tabopt;
2430 0 : if (tabopt == 1) pbits[1] &= ~0x3c;
2431 0 : else if (tabopt == 2) pbits[11] &= 0x7f;
2432 :
2433 : /* Add the POSIX table or its complement into the main table that is
2434 : being built and we are done. */
2435 :
2436 0 : if (local_negate)
2437 0 : for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];
2438 : else
2439 0 : for (c = 0; c < 32; c++) classbits[c] |= pbits[c];
2440 :
2441 0 : ptr = tempptr + 1;
2442 0 : class_charcount = 10; /* Set > 1; assumes more than 1 per class */
2443 0 : continue; /* End of POSIX syntax handling */
2444 : }
2445 :
2446 : /* Backslash may introduce a single character, or it may introduce one
2447 : of the specials, which just set a flag. The sequence \b is a special
2448 : case. Inside a class (and only there) it is treated as backspace.
2449 : Elsewhere it marks a word boundary. Other escapes have preset maps ready
2450 : to or into the one we are building. We assume they have more than one
2451 : character in them, so set class_charcount bigger than one. */
2452 :
2453 672 : if (c == '\\')
2454 : {
2455 34 : c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
2456 34 : if (*errorcodeptr != 0) goto FAILED;
2457 :
2458 34 : if (-c == ESC_b) c = '\b'; /* \b is backslash in a class */
2459 34 : else if (-c == ESC_X) c = 'X'; /* \X is literal X in a class */
2460 34 : else if (-c == ESC_R) c = 'R'; /* \R is literal R in a class */
2461 34 : else if (-c == ESC_Q) /* Handle start of quoted string */
2462 : {
2463 0 : if (ptr[1] == '\\' && ptr[2] == 'E')
2464 : {
2465 0 : ptr += 2; /* avoid empty string */
2466 : }
2467 0 : else inescq = TRUE;
2468 0 : continue;
2469 : }
2470 :
2471 34 : if (c < 0)
2472 : {
2473 0 : register const uschar *cbits = cd->cbits;
2474 0 : class_charcount += 2; /* Greater than 1 is what matters */
2475 :
2476 : /* Save time by not doing this in the pre-compile phase. */
2477 :
2478 0 : if (lengthptr == NULL) switch (-c)
2479 : {
2480 : case ESC_d:
2481 0 : for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];
2482 0 : continue;
2483 :
2484 : case ESC_D:
2485 0 : for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
2486 0 : continue;
2487 :
2488 : case ESC_w:
2489 0 : for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];
2490 0 : continue;
2491 :
2492 : case ESC_W:
2493 0 : for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
2494 0 : continue;
2495 :
2496 : case ESC_s:
2497 0 : for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
2498 0 : classbits[1] &= ~0x08; /* Perl 5.004 onwards omits VT from \s */
2499 0 : continue;
2500 :
2501 : case ESC_S:
2502 0 : for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
2503 0 : classbits[1] |= 0x08; /* Perl 5.004 onwards omits VT from \s */
2504 0 : continue;
2505 :
2506 : case ESC_E: /* Perl ignores an orphan \E */
2507 0 : continue;
2508 :
2509 : default: /* Not recognized; fall through */
2510 : break; /* Need "default" setting to stop compiler warning. */
2511 : }
2512 :
2513 : /* In the pre-compile phase, just do the recognition. */
2514 :
2515 0 : else if (c == -ESC_d || c == -ESC_D || c == -ESC_w ||
2516 : c == -ESC_W || c == -ESC_s || c == -ESC_S) continue;
2517 :
2518 : /* We need to deal with \P and \p in both phases. */
2519 :
2520 : #ifdef SUPPORT_UCP
2521 0 : if (-c == ESC_p || -c == ESC_P)
2522 : {
2523 : BOOL negated;
2524 : int pdata;
2525 0 : int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
2526 0 : if (ptype < 0) goto FAILED;
2527 0 : class_utf8 = TRUE;
2528 0 : *class_utf8data++ = ((-c == ESC_p) != negated)?
2529 : XCL_PROP : XCL_NOTPROP;
2530 0 : *class_utf8data++ = ptype;
2531 0 : *class_utf8data++ = pdata;
2532 0 : class_charcount -= 2; /* Not a < 256 character */
2533 0 : continue;
2534 : }
2535 : #endif
2536 : /* Unrecognized escapes are faulted if PCRE is running in its
2537 : strict mode. By default, for compatibility with Perl, they are
2538 : treated as literals. */
2539 :
2540 0 : if ((options & PCRE_EXTRA) != 0)
2541 : {
2542 0 : *errorcodeptr = ERR7;
2543 0 : goto FAILED;
2544 : }
2545 :
2546 0 : class_charcount -= 2; /* Undo the default count from above */
2547 0 : c = *ptr; /* Get the final character and fall through */
2548 : }
2549 :
2550 : /* Fall through if we have a single character (c >= 0). This may be
2551 : greater than 256 in UTF-8 mode. */
2552 :
2553 : } /* End of backslash handling */
2554 :
2555 : /* A single character may be followed by '-' to form a range. However,
2556 : Perl does not permit ']' to be the end of the range. A '-' character
2557 : at the end is treated as a literal. Perl ignores orphaned \E sequences
2558 : entirely. The code for handling \Q and \E is messy. */
2559 :
2560 672 : CHECK_RANGE:
2561 1344 : while (ptr[1] == '\\' && ptr[2] == 'E')
2562 : {
2563 0 : inescq = FALSE;
2564 0 : ptr += 2;
2565 : }
2566 :
2567 672 : oldptr = ptr;
2568 :
2569 672 : if (!inescq && ptr[1] == '-')
2570 : {
2571 : int d;
2572 598 : ptr += 2;
2573 598 : while (*ptr == '\\' && ptr[1] == 'E') ptr += 2;
2574 :
2575 : /* If we hit \Q (not followed by \E) at this point, go into escaped
2576 : mode. */
2577 :
2578 1196 : while (*ptr == '\\' && ptr[1] == 'Q')
2579 : {
2580 0 : ptr += 2;
2581 0 : if (*ptr == '\\' && ptr[1] == 'E') { ptr += 2; continue; }
2582 0 : inescq = TRUE;
2583 0 : break;
2584 : }
2585 :
2586 598 : if (*ptr == 0 || (!inescq && *ptr == ']'))
2587 : {
2588 0 : ptr = oldptr;
2589 0 : goto LONE_SINGLE_CHARACTER;
2590 : }
2591 :
2592 : #ifdef SUPPORT_UTF8
2593 598 : if (utf8)
2594 : { /* Braces are required because the */
2595 0 : GETCHARLEN(d, ptr, ptr); /* macro generates multiple statements */
2596 : }
2597 : else
2598 : #endif
2599 598 : d = *ptr; /* Not UTF-8 mode */
2600 :
2601 : /* The second part of a range can be a single-character escape, but
2602 : not any of the other escapes. Perl 5.6 treats a hyphen as a literal
2603 : in such circumstances. */
2604 :
2605 598 : if (!inescq && d == '\\')
2606 : {
2607 0 : d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
2608 0 : if (*errorcodeptr != 0) goto FAILED;
2609 :
2610 : /* \b is backslash; \X is literal X; \R is literal R; any other
2611 : special means the '-' was literal */
2612 :
2613 0 : if (d < 0)
2614 : {
2615 0 : if (d == -ESC_b) d = '\b';
2616 0 : else if (d == -ESC_X) d = 'X';
2617 0 : else if (d == -ESC_R) d = 'R'; else
2618 : {
2619 0 : ptr = oldptr;
2620 0 : goto LONE_SINGLE_CHARACTER; /* A few lines below */
2621 : }
2622 : }
2623 : }
2624 :
2625 : /* Check that the two values are in the correct order. Optimize
2626 : one-character ranges */
2627 :
2628 598 : if (d < c)
2629 : {
2630 0 : *errorcodeptr = ERR8;
2631 0 : goto FAILED;
2632 : }
2633 :
2634 598 : if (d == c) goto LONE_SINGLE_CHARACTER; /* A few lines below */
2635 :
2636 : /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
2637 : matching, we have to use an XCLASS with extra data items. Caseless
2638 : matching for characters > 127 is available only if UCP support is
2639 : available. */
2640 :
2641 : #ifdef SUPPORT_UTF8
2642 598 : if (utf8 && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
2643 : {
2644 0 : class_utf8 = TRUE;
2645 :
2646 : /* With UCP support, we can find the other case equivalents of
2647 : the relevant characters. There may be several ranges. Optimize how
2648 : they fit with the basic range. */
2649 :
2650 : #ifdef SUPPORT_UCP
2651 0 : if ((options & PCRE_CASELESS) != 0)
2652 : {
2653 : unsigned int occ, ocd;
2654 0 : unsigned int cc = c;
2655 0 : unsigned int origd = d;
2656 0 : while (get_othercase_range(&cc, origd, &occ, &ocd))
2657 : {
2658 0 : if (occ >= c && ocd <= d) continue; /* Skip embedded ranges */
2659 :
2660 0 : if (occ < c && ocd >= c - 1) /* Extend the basic range */
2661 : { /* if there is overlap, */
2662 0 : c = occ; /* noting that if occ < c */
2663 0 : continue; /* we can't have ocd > d */
2664 : } /* because a subrange is */
2665 0 : if (ocd > d && occ <= d + 1) /* always shorter than */
2666 : { /* the basic range. */
2667 0 : d = ocd;
2668 0 : continue;
2669 : }
2670 :
2671 0 : if (occ == ocd)
2672 : {
2673 0 : *class_utf8data++ = XCL_SINGLE;
2674 : }
2675 : else
2676 : {
2677 0 : *class_utf8data++ = XCL_RANGE;
2678 0 : class_utf8data += _pcre_ord2utf8(occ, class_utf8data);
2679 : }
2680 0 : class_utf8data += _pcre_ord2utf8(ocd, class_utf8data);
2681 : }
2682 : }
2683 : #endif /* SUPPORT_UCP */
2684 :
2685 : /* Now record the original range, possibly modified for UCP caseless
2686 : overlapping ranges. */
2687 :
2688 0 : *class_utf8data++ = XCL_RANGE;
2689 0 : class_utf8data += _pcre_ord2utf8(c, class_utf8data);
2690 0 : class_utf8data += _pcre_ord2utf8(d, class_utf8data);
2691 :
2692 : /* With UCP support, we are done. Without UCP support, there is no
2693 : caseless matching for UTF-8 characters > 127; we can use the bit map
2694 : for the smaller ones. */
2695 :
2696 : #ifdef SUPPORT_UCP
2697 0 : continue; /* With next character in the class */
2698 : #else
2699 : if ((options & PCRE_CASELESS) == 0 || c > 127) continue;
2700 :
2701 : /* Adjust upper limit and fall through to set up the map */
2702 :
2703 : d = 127;
2704 :
2705 : #endif /* SUPPORT_UCP */
2706 : }
2707 : #endif /* SUPPORT_UTF8 */
2708 :
2709 : /* We use the bit map for all cases when not in UTF-8 mode; else
2710 : ranges that lie entirely within 0-127 when there is UCP support; else
2711 : for partial ranges without UCP support. */
2712 :
2713 598 : class_charcount += d - c + 1;
2714 598 : class_lastchar = d;
2715 :
2716 : /* We can save a bit of time by skipping this in the pre-compile. */
2717 :
2718 3604 : if (lengthptr == NULL) for (; c <= d; c++)
2719 : {
2720 3006 : classbits[c/8] |= (1 << (c&7));
2721 3006 : if ((options & PCRE_CASELESS) != 0)
2722 : {
2723 0 : int uc = cd->fcc[c]; /* flip case */
2724 0 : classbits[uc/8] |= (1 << (uc&7));
2725 : }
2726 : }
2727 :
2728 598 : continue; /* Go get the next char in the class */
2729 : }
2730 :
2731 : /* Handle a lone single character - we can get here for a normal
2732 : non-escape char, or after \ that introduces a single character or for an
2733 : apparent range that isn't. */
2734 :
2735 74 : LONE_SINGLE_CHARACTER:
2736 :
2737 : /* Handle a character that cannot go in the bit map */
2738 :
2739 : #ifdef SUPPORT_UTF8
2740 74 : if (utf8 && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
2741 : {
2742 0 : class_utf8 = TRUE;
2743 0 : *class_utf8data++ = XCL_SINGLE;
2744 0 : class_utf8data += _pcre_ord2utf8(c, class_utf8data);
2745 :
2746 : #ifdef SUPPORT_UCP
2747 0 : if ((options & PCRE_CASELESS) != 0)
2748 : {
2749 : unsigned int othercase;
2750 0 : if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR)
2751 : {
2752 0 : *class_utf8data++ = XCL_SINGLE;
2753 0 : class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
2754 : }
2755 : }
2756 : #endif /* SUPPORT_UCP */
2757 :
2758 : }
2759 : else
2760 : #endif /* SUPPORT_UTF8 */
2761 :
2762 : /* Handle a single-byte character */
2763 : {
2764 74 : classbits[c/8] |= (1 << (c&7));
2765 74 : if ((options & PCRE_CASELESS) != 0)
2766 : {
2767 0 : c = cd->fcc[c]; /* flip case */
2768 0 : classbits[c/8] |= (1 << (c&7));
2769 : }
2770 74 : class_charcount++;
2771 74 : class_lastchar = c;
2772 : }
2773 : }
2774 :
2775 : /* Loop until ']' reached. This "while" is the end of the "do" above. */
2776 :
2777 672 : while ((c = *(++ptr)) != 0 && (c != ']' || inescq));
2778 :
2779 634 : if (c == 0) /* Missing terminating ']' */
2780 : {
2781 0 : *errorcodeptr = ERR6;
2782 0 : goto FAILED;
2783 : }
2784 :
2785 : /* If class_charcount is 1, we saw precisely one character whose value is
2786 : less than 256. In non-UTF-8 mode we can always optimize. In UTF-8 mode, we
2787 : can optimize the negative case only if there were no characters >= 128
2788 : because OP_NOT and the related opcodes like OP_NOTSTAR operate on
2789 : single-bytes only. This is an historical hangover. Maybe one day we can
2790 : tidy these opcodes to handle multi-byte characters.
2791 :
2792 : The optimization throws away the bit map. We turn the item into a
2793 : 1-character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
2794 : that OP_NOT does not support multibyte characters. In the positive case, it
2795 : can cause firstbyte to be set. Otherwise, there can be no first char if
2796 : this item is first, whatever repeat count may follow. In the case of
2797 : reqbyte, save the previous value for reinstating. */
2798 :
2799 : #ifdef SUPPORT_UTF8
2800 634 : if (class_charcount == 1 &&
2801 : (!utf8 ||
2802 : (!class_utf8 && (!negate_class || class_lastchar < 128))))
2803 :
2804 : #else
2805 : if (class_charcount == 1)
2806 : #endif
2807 : {
2808 0 : zeroreqbyte = reqbyte;
2809 :
2810 : /* The OP_NOT opcode works on one-byte characters only. */
2811 :
2812 0 : if (negate_class)
2813 : {
2814 0 : if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2815 0 : zerofirstbyte = firstbyte;
2816 0 : *code++ = OP_NOT;
2817 0 : *code++ = class_lastchar;
2818 0 : break;
2819 : }
2820 :
2821 : /* For a single, positive character, get the value into mcbuffer, and
2822 : then we can handle this with the normal one-character code. */
2823 :
2824 : #ifdef SUPPORT_UTF8
2825 0 : if (utf8 && class_lastchar > 127)
2826 0 : mclength = _pcre_ord2utf8(class_lastchar, mcbuffer);
2827 : else
2828 : #endif
2829 : {
2830 0 : mcbuffer[0] = class_lastchar;
2831 0 : mclength = 1;
2832 : }
2833 0 : goto ONE_CHAR;
2834 : } /* End of 1-char optimization */
2835 :
2836 : /* The general case - not the one-char optimization. If this is the first
2837 : thing in the branch, there can be no first char setting, whatever the
2838 : repeat count. Any reqbyte setting must remain unchanged after any kind of
2839 : repeat. */
2840 :
2841 634 : if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2842 634 : zerofirstbyte = firstbyte;
2843 634 : zeroreqbyte = reqbyte;
2844 :
2845 : /* If there are characters with values > 255, we have to compile an
2846 : extended class, with its own opcode. If there are no characters < 256,
2847 : we can omit the bitmap in the actual compiled code. */
2848 :
2849 : #ifdef SUPPORT_UTF8
2850 634 : if (class_utf8)
2851 : {
2852 0 : *class_utf8data++ = XCL_END; /* Marks the end of extra data */
2853 0 : *code++ = OP_XCLASS;
2854 0 : code += LINK_SIZE;
2855 0 : *code = negate_class? XCL_NOT : 0;
2856 :
2857 : /* If the map is required, move up the extra data to make room for it;
2858 : otherwise just move the code pointer to the end of the extra data. */
2859 :
2860 0 : if (class_charcount > 0)
2861 : {
2862 0 : *code++ |= XCL_MAP;
2863 0 : memmove(code + 32, code, class_utf8data - code);
2864 0 : memcpy(code, classbits, 32);
2865 0 : code = class_utf8data + 32;
2866 : }
2867 0 : else code = class_utf8data;
2868 :
2869 : /* Now fill in the complete length of the item */
2870 :
2871 0 : PUT(previous, 1, code - previous);
2872 0 : break; /* End of class handling */
2873 : }
2874 : #endif
2875 :
2876 : /* If there are no characters > 255, negate the 32-byte map if necessary,
2877 : and copy it into the code vector. If this is the first thing in the branch,
2878 : there can be no first char setting, whatever the repeat count. Any reqbyte
2879 : setting must remain unchanged after any kind of repeat. */
2880 :
2881 634 : if (negate_class)
2882 : {
2883 0 : *code++ = OP_NCLASS;
2884 0 : if (lengthptr == NULL) /* Save time in the pre-compile phase */
2885 0 : for (c = 0; c < 32; c++) code[c] = ~classbits[c];
2886 : }
2887 : else
2888 : {
2889 634 : *code++ = OP_CLASS;
2890 634 : memcpy(code, classbits, 32);
2891 : }
2892 634 : code += 32;
2893 634 : break;
2894 :
2895 :
2896 : /* ===================================================================*/
2897 : /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
2898 : has been tested above. */
2899 :
2900 : case '{':
2901 0 : if (!is_quantifier) goto NORMAL_CHAR;
2902 0 : ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);
2903 0 : if (*errorcodeptr != 0) goto FAILED;
2904 0 : goto REPEAT;
2905 :
2906 : case '*':
2907 46 : repeat_min = 0;
2908 46 : repeat_max = -1;
2909 46 : goto REPEAT;
2910 :
2911 : case '+':
2912 1048 : repeat_min = 1;
2913 1048 : repeat_max = -1;
2914 1048 : goto REPEAT;
2915 :
2916 : case '?':
2917 170 : repeat_min = 0;
2918 170 : repeat_max = 1;
2919 :
2920 1264 : REPEAT:
2921 1264 : if (previous == NULL)
2922 : {
2923 0 : *errorcodeptr = ERR9;
2924 0 : goto FAILED;
2925 : }
2926 :
2927 1264 : if (repeat_min == 0)
2928 : {
2929 216 : firstbyte = zerofirstbyte; /* Adjust for zero repeat */
2930 216 : reqbyte = zeroreqbyte; /* Ditto */
2931 : }
2932 :
2933 : /* Remember whether this is a variable length repeat */
2934 :
2935 1264 : reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;
2936 :
2937 1264 : op_type = 0; /* Default single-char op codes */
2938 1264 : possessive_quantifier = FALSE; /* Default not possessive quantifier */
2939 :
2940 : /* Save start of previous item, in case we have to move it up to make space
2941 : for an inserted OP_ONCE for the additional '+' extension. */
2942 :
2943 1264 : tempcode = previous;
2944 :
2945 : /* If the next character is '+', we have a possessive quantifier. This
2946 : implies greediness, whatever the setting of the PCRE_UNGREEDY option.
2947 : If the next character is '?' this is a minimizing repeat, by default,
2948 : but if PCRE_UNGREEDY is set, it works the other way round. We change the
2949 : repeat type to the non-default. */
2950 :
2951 1264 : if (ptr[1] == '+')
2952 : {
2953 0 : repeat_type = 0; /* Force greedy */
2954 0 : possessive_quantifier = TRUE;
2955 0 : ptr++;
2956 : }
2957 1264 : else if (ptr[1] == '?')
2958 : {
2959 478 : repeat_type = greedy_non_default;
2960 478 : ptr++;
2961 : }
2962 786 : else repeat_type = greedy_default;
2963 :
2964 : /* If previous was a character match, abolish the item and generate a
2965 : repeat item instead. If a char item has a minumum of more than one, ensure
2966 : that it is set in reqbyte - it might not be if a sequence such as x{3} is
2967 : the first thing in a branch because the x will have gone into firstbyte
2968 : instead. */
2969 :
2970 1264 : if (*previous == OP_CHAR || *previous == OP_CHARNC)
2971 : {
2972 : /* Deal with UTF-8 characters that take up more than one byte. It's
2973 : easier to write this out separately than try to macrify it. Use c to
2974 : hold the length of the character in bytes, plus 0x80 to flag that it's a
2975 : length rather than a small character. */
2976 :
2977 : #ifdef SUPPORT_UTF8
2978 108 : if (utf8 && (code[-1] & 0x80) != 0)
2979 : {
2980 0 : uschar *lastchar = code - 1;
2981 0 : while((*lastchar & 0xc0) == 0x80) lastchar--;
2982 0 : c = code - lastchar; /* Length of UTF-8 character */
2983 0 : memcpy(utf8_char, lastchar, c); /* Save the char */
2984 0 : c |= 0x80; /* Flag c as a length */
2985 : }
2986 : else
2987 : #endif
2988 :
2989 : /* Handle the case of a single byte - either with no UTF8 support, or
2990 : with UTF-8 disabled, or for a UTF-8 character < 128. */
2991 :
2992 : {
2993 108 : c = code[-1];
2994 108 : if (repeat_min > 1) reqbyte = c | req_caseopt | cd->req_varyopt;
2995 : }
2996 :
2997 : /* If the repetition is unlimited, it pays to see if the next thing on
2998 : the line is something that cannot possibly match this character. If so,
2999 : automatically possessifying this item gains some performance in the case
3000 : where the match fails. */
3001 :
3002 108 : if (!possessive_quantifier &&
3003 : repeat_max < 0 &&
3004 : check_auto_possessive(*previous, c, utf8, utf8_char, ptr + 1,
3005 : options, cd))
3006 : {
3007 6 : repeat_type = 0; /* Force greedy */
3008 6 : possessive_quantifier = TRUE;
3009 : }
3010 :
3011 108 : goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */
3012 : }
3013 :
3014 : /* If previous was a single negated character ([^a] or similar), we use
3015 : one of the special opcodes, replacing it. The code is shared with single-
3016 : character repeats by setting opt_type to add a suitable offset into
3017 : repeat_type. We can also test for auto-possessification. OP_NOT is
3018 : currently used only for single-byte chars. */
3019 :
3020 1156 : else if (*previous == OP_NOT)
3021 : {
3022 0 : op_type = OP_NOTSTAR - OP_STAR; /* Use "not" opcodes */
3023 0 : c = previous[1];
3024 0 : if (!possessive_quantifier &&
3025 : repeat_max < 0 &&
3026 : check_auto_possessive(OP_NOT, c, utf8, NULL, ptr + 1, options, cd))
3027 : {
3028 0 : repeat_type = 0; /* Force greedy */
3029 0 : possessive_quantifier = TRUE;
3030 : }
3031 0 : goto OUTPUT_SINGLE_REPEAT;
3032 : }
3033 :
3034 : /* If previous was a character type match (\d or similar), abolish it and
3035 : create a suitable repeat item. The code is shared with single-character
3036 : repeats by setting op_type to add a suitable offset into repeat_type. Note
3037 : the the Unicode property types will be present only when SUPPORT_UCP is
3038 : defined, but we don't wrap the little bits of code here because it just
3039 : makes it horribly messy. */
3040 :
3041 1156 : else if (*previous < OP_EODN)
3042 : {
3043 : uschar *oldcode;
3044 : int prop_type, prop_value;
3045 488 : op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */
3046 488 : c = *previous;
3047 :
3048 488 : if (!possessive_quantifier &&
3049 : repeat_max < 0 &&
3050 : check_auto_possessive(c, 0, utf8, NULL, ptr + 1, options, cd))
3051 : {
3052 2 : repeat_type = 0; /* Force greedy */
3053 2 : possessive_quantifier = TRUE;
3054 : }
3055 :
3056 596 : OUTPUT_SINGLE_REPEAT:
3057 596 : if (*previous == OP_PROP || *previous == OP_NOTPROP)
3058 : {
3059 0 : prop_type = previous[1];
3060 0 : prop_value = previous[2];
3061 : }
3062 596 : else prop_type = prop_value = -1;
3063 :
3064 596 : oldcode = code;
3065 596 : code = previous; /* Usually overwrite previous item */
3066 :
3067 : /* If the maximum is zero then the minimum must also be zero; Perl allows
3068 : this case, so we do too - by simply omitting the item altogether. */
3069 :
3070 596 : if (repeat_max == 0) goto END_REPEAT;
3071 :
3072 : /* All real repeats make it impossible to handle partial matching (maybe
3073 : one day we will be able to remove this restriction). */
3074 :
3075 596 : if (repeat_max != 1) cd->nopartial = TRUE;
3076 :
3077 : /* Combine the op_type with the repeat_type */
3078 :
3079 596 : repeat_type += op_type;
3080 :
3081 : /* A minimum of zero is handled either as the special case * or ?, or as
3082 : an UPTO, with the maximum given. */
3083 :
3084 596 : if (repeat_min == 0)
3085 : {
3086 114 : if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
3087 102 : else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
3088 : else
3089 : {
3090 0 : *code++ = OP_UPTO + repeat_type;
3091 0 : PUT2INC(code, 0, repeat_max);
3092 : }
3093 : }
3094 :
3095 : /* A repeat minimum of 1 is optimized into some special cases. If the
3096 : maximum is unlimited, we use OP_PLUS. Otherwise, the original item is
3097 : left in place and, if the maximum is greater than 1, we use OP_UPTO with
3098 : one less than the maximum. */
3099 :
3100 482 : else if (repeat_min == 1)
3101 : {
3102 482 : if (repeat_max == -1)
3103 482 : *code++ = OP_PLUS + repeat_type;
3104 : else
3105 : {
3106 0 : code = oldcode; /* leave previous item in place */
3107 0 : if (repeat_max == 1) goto END_REPEAT;
3108 0 : *code++ = OP_UPTO + repeat_type;
3109 0 : PUT2INC(code, 0, repeat_max - 1);
3110 : }
3111 : }
3112 :
3113 : /* The case {n,n} is just an EXACT, while the general case {n,m} is
3114 : handled as an EXACT followed by an UPTO. */
3115 :
3116 : else
3117 : {
3118 0 : *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */
3119 0 : PUT2INC(code, 0, repeat_min);
3120 :
3121 : /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
3122 : we have to insert the character for the previous code. For a repeated
3123 : Unicode property match, there are two extra bytes that define the
3124 : required property. In UTF-8 mode, long characters have their length in
3125 : c, with the 0x80 bit as a flag. */
3126 :
3127 0 : if (repeat_max < 0)
3128 : {
3129 : #ifdef SUPPORT_UTF8
3130 0 : if (utf8 && c >= 128)
3131 : {
3132 0 : memcpy(code, utf8_char, c & 7);
3133 0 : code += c & 7;
3134 : }
3135 : else
3136 : #endif
3137 : {
3138 0 : *code++ = c;
3139 0 : if (prop_type >= 0)
3140 : {
3141 0 : *code++ = prop_type;
3142 0 : *code++ = prop_value;
3143 : }
3144 : }
3145 0 : *code++ = OP_STAR + repeat_type;
3146 : }
3147 :
3148 : /* Else insert an UPTO if the max is greater than the min, again
3149 : preceded by the character, for the previously inserted code. If the
3150 : UPTO is just for 1 instance, we can use QUERY instead. */
3151 :
3152 0 : else if (repeat_max != repeat_min)
3153 : {
3154 : #ifdef SUPPORT_UTF8
3155 0 : if (utf8 && c >= 128)
3156 : {
3157 0 : memcpy(code, utf8_char, c & 7);
3158 0 : code += c & 7;
3159 : }
3160 : else
3161 : #endif
3162 0 : *code++ = c;
3163 0 : if (prop_type >= 0)
3164 : {
3165 0 : *code++ = prop_type;
3166 0 : *code++ = prop_value;
3167 : }
3168 0 : repeat_max -= repeat_min;
3169 :
3170 0 : if (repeat_max == 1)
3171 : {
3172 0 : *code++ = OP_QUERY + repeat_type;
3173 : }
3174 : else
3175 : {
3176 0 : *code++ = OP_UPTO + repeat_type;
3177 0 : PUT2INC(code, 0, repeat_max);
3178 : }
3179 : }
3180 : }
3181 :
3182 : /* The character or character type itself comes last in all cases. */
3183 :
3184 : #ifdef SUPPORT_UTF8
3185 596 : if (utf8 && c >= 128)
3186 : {
3187 0 : memcpy(code, utf8_char, c & 7);
3188 0 : code += c & 7;
3189 : }
3190 : else
3191 : #endif
3192 596 : *code++ = c;
3193 :
3194 : /* For a repeated Unicode property match, there are two extra bytes that
3195 : define the required property. */
3196 :
3197 : #ifdef SUPPORT_UCP
3198 596 : if (prop_type >= 0)
3199 : {
3200 0 : *code++ = prop_type;
3201 0 : *code++ = prop_value;
3202 : }
3203 : #endif
3204 : }
3205 :
3206 : /* If previous was a character class or a back reference, we put the repeat
3207 : stuff after it, but just skip the item if the repeat was {0,0}. */
3208 :
3209 1302 : else if (*previous == OP_CLASS ||
3210 : *previous == OP_NCLASS ||
3211 : #ifdef SUPPORT_UTF8
3212 : *previous == OP_XCLASS ||
3213 : #endif
3214 : *previous == OP_REF)
3215 : {
3216 634 : if (repeat_max == 0)
3217 : {
3218 0 : code = previous;
3219 0 : goto END_REPEAT;
3220 : }
3221 :
3222 : /* All real repeats make it impossible to handle partial matching (maybe
3223 : one day we will be able to remove this restriction). */
3224 :
3225 634 : if (repeat_max != 1) cd->nopartial = TRUE;
3226 :
3227 668 : if (repeat_min == 0 && repeat_max == -1)
3228 34 : *code++ = OP_CRSTAR + repeat_type;
3229 1166 : else if (repeat_min == 1 && repeat_max == -1)
3230 566 : *code++ = OP_CRPLUS + repeat_type;
3231 68 : else if (repeat_min == 0 && repeat_max == 1)
3232 34 : *code++ = OP_CRQUERY + repeat_type;
3233 : else
3234 : {
3235 0 : *code++ = OP_CRRANGE + repeat_type;
3236 0 : PUT2INC(code, 0, repeat_min);
3237 0 : if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */
3238 0 : PUT2INC(code, 0, repeat_max);
3239 : }
3240 : }
3241 :
3242 : /* If previous was a bracket group, we may have to replicate it in certain
3243 : cases. */
3244 :
3245 68 : else if (*previous == OP_BRA || *previous == OP_CBRA ||
3246 : *previous == OP_ONCE || *previous == OP_COND)
3247 : {
3248 : register int i;
3249 34 : int ketoffset = 0;
3250 34 : int len = code - previous;
3251 34 : uschar *bralink = NULL;
3252 :
3253 : /* Repeating a DEFINE group is pointless */
3254 :
3255 34 : if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)
3256 : {
3257 0 : *errorcodeptr = ERR55;
3258 0 : goto FAILED;
3259 : }
3260 :
3261 : /* This is a paranoid check to stop integer overflow later on */
3262 :
3263 34 : if (len > MAX_DUPLENGTH)
3264 : {
3265 0 : *errorcodeptr = ERR50;
3266 0 : goto FAILED;
3267 : }
3268 :
3269 : /* If the maximum repeat count is unlimited, find the end of the bracket
3270 : by scanning through from the start, and compute the offset back to it
3271 : from the current code pointer. There may be an OP_OPT setting following
3272 : the final KET, so we can't find the end just by going back from the code
3273 : pointer. */
3274 :
3275 34 : if (repeat_max == -1)
3276 : {
3277 0 : register uschar *ket = previous;
3278 0 : do ket += GET(ket, 1); while (*ket != OP_KET);
3279 0 : ketoffset = code - ket;
3280 : }
3281 :
3282 : /* The case of a zero minimum is special because of the need to stick
3283 : OP_BRAZERO in front of it, and because the group appears once in the
3284 : data, whereas in other cases it appears the minimum number of times. For
3285 : this reason, it is simplest to treat this case separately, as otherwise
3286 : the code gets far too messy. There are several special subcases when the
3287 : minimum is zero. */
3288 :
3289 34 : if (repeat_min == 0)
3290 : {
3291 : /* If the maximum is also zero, we just omit the group from the output
3292 : altogether. */
3293 :
3294 34 : if (repeat_max == 0)
3295 : {
3296 0 : code = previous;
3297 0 : goto END_REPEAT;
3298 : }
3299 :
3300 : /* If the maximum is 1 or unlimited, we just have to stick in the
3301 : BRAZERO and do no more at this point. However, we do need to adjust
3302 : any OP_RECURSE calls inside the group that refer to the group itself or
3303 : any internal or forward referenced group, because the offset is from
3304 : the start of the whole regex. Temporarily terminate the pattern while
3305 : doing this. */
3306 :
3307 34 : if (repeat_max <= 1)
3308 : {
3309 34 : *code = OP_END;
3310 34 : adjust_recurse(previous, 1, utf8, cd, save_hwm);
3311 34 : memmove(previous+1, previous, len);
3312 34 : code++;
3313 34 : *previous++ = OP_BRAZERO + repeat_type;
3314 : }
3315 :
3316 : /* If the maximum is greater than 1 and limited, we have to replicate
3317 : in a nested fashion, sticking OP_BRAZERO before each set of brackets.
3318 : The first one has to be handled carefully because it's the original
3319 : copy, which has to be moved up. The remainder can be handled by code
3320 : that is common with the non-zero minimum case below. We have to
3321 : adjust the value or repeat_max, since one less copy is required. Once
3322 : again, we may have to adjust any OP_RECURSE calls inside the group. */
3323 :
3324 : else
3325 : {
3326 : int offset;
3327 0 : *code = OP_END;
3328 0 : adjust_recurse(previous, 2 + LINK_SIZE, utf8, cd, save_hwm);
3329 0 : memmove(previous + 2 + LINK_SIZE, previous, len);
3330 0 : code += 2 + LINK_SIZE;
3331 0 : *previous++ = OP_BRAZERO + repeat_type;
3332 0 : *previous++ = OP_BRA;
3333 :
3334 : /* We chain together the bracket offset fields that have to be
3335 : filled in later when the ends of the brackets are reached. */
3336 :
3337 0 : offset = (bralink == NULL)? 0 : previous - bralink;
3338 0 : bralink = previous;
3339 0 : PUTINC(previous, 0, offset);
3340 : }
3341 :
3342 34 : repeat_max--;
3343 : }
3344 :
3345 : /* If the minimum is greater than zero, replicate the group as many
3346 : times as necessary, and adjust the maximum to the number of subsequent
3347 : copies that we need. If we set a first char from the group, and didn't
3348 : set a required char, copy the latter from the former. If there are any
3349 : forward reference subroutine calls in the group, there will be entries on
3350 : the workspace list; replicate these with an appropriate increment. */
3351 :
3352 : else
3353 : {
3354 0 : if (repeat_min > 1)
3355 : {
3356 : /* In the pre-compile phase, we don't actually do the replication. We
3357 : just adjust the length as if we had. */
3358 :
3359 0 : if (lengthptr != NULL)
3360 0 : *lengthptr += (repeat_min - 1)*length_prevgroup;
3361 :
3362 : /* This is compiling for real */
3363 :
3364 : else
3365 : {
3366 0 : if (groupsetfirstbyte && reqbyte < 0) reqbyte = firstbyte;
3367 0 : for (i = 1; i < repeat_min; i++)
3368 : {
3369 : uschar *hc;
3370 0 : uschar *this_hwm = cd->hwm;
3371 0 : memcpy(code, previous, len);
3372 0 : for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
3373 : {
3374 0 : PUT(cd->hwm, 0, GET(hc, 0) + len);
3375 0 : cd->hwm += LINK_SIZE;
3376 : }
3377 0 : save_hwm = this_hwm;
3378 0 : code += len;
3379 : }
3380 : }
3381 : }
3382 :
3383 0 : if (repeat_max > 0) repeat_max -= repeat_min;
3384 : }
3385 :
3386 : /* This code is common to both the zero and non-zero minimum cases. If
3387 : the maximum is limited, it replicates the group in a nested fashion,
3388 : remembering the bracket starts on a stack. In the case of a zero minimum,
3389 : the first one was set up above. In all cases the repeat_max now specifies
3390 : the number of additional copies needed. Again, we must remember to
3391 : replicate entries on the forward reference list. */
3392 :
3393 34 : if (repeat_max >= 0)
3394 : {
3395 : /* In the pre-compile phase, we don't actually do the replication. We
3396 : just adjust the length as if we had. For each repetition we must add 1
3397 : to the length for BRAZERO and for all but the last repetition we must
3398 : add 2 + 2*LINKSIZE to allow for the nesting that occurs. */
3399 :
3400 34 : if (lengthptr != NULL && repeat_max > 0)
3401 0 : *lengthptr += repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
3402 : 2 - 2*LINK_SIZE; /* Last one doesn't nest */
3403 :
3404 : /* This is compiling for real */
3405 :
3406 34 : else for (i = repeat_max - 1; i >= 0; i--)
3407 : {
3408 : uschar *hc;
3409 0 : uschar *this_hwm = cd->hwm;
3410 :
3411 0 : *code++ = OP_BRAZERO + repeat_type;
3412 :
3413 : /* All but the final copy start a new nesting, maintaining the
3414 : chain of brackets outstanding. */
3415 :
3416 0 : if (i != 0)
3417 : {
3418 : int offset;
3419 0 : *code++ = OP_BRA;
3420 0 : offset = (bralink == NULL)? 0 : code - bralink;
3421 0 : bralink = code;
3422 0 : PUTINC(code, 0, offset);
3423 : }
3424 :
3425 0 : memcpy(code, previous, len);
3426 0 : for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
3427 : {
3428 0 : PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));
3429 0 : cd->hwm += LINK_SIZE;
3430 : }
3431 0 : save_hwm = this_hwm;
3432 0 : code += len;
3433 : }
3434 :
3435 : /* Now chain through the pending brackets, and fill in their length
3436 : fields (which are holding the chain links pro tem). */
3437 :
3438 68 : while (bralink != NULL)
3439 : {
3440 : int oldlinkoffset;
3441 0 : int offset = code - bralink + 1;
3442 0 : uschar *bra = code - offset;
3443 0 : oldlinkoffset = GET(bra, 1);
3444 0 : bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
3445 0 : *code++ = OP_KET;
3446 0 : PUTINC(code, 0, offset);
3447 0 : PUT(bra, 1, offset);
3448 : }
3449 : }
3450 :
3451 : /* If the maximum is unlimited, set a repeater in the final copy. We
3452 : can't just offset backwards from the current code point, because we
3453 : don't know if there's been an options resetting after the ket. The
3454 : correct offset was computed above.
3455 :
3456 : Then, when we are doing the actual compile phase, check to see whether
3457 : this group is a non-atomic one that could match an empty string. If so,
3458 : convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
3459 : that runtime checking can be done. [This check is also applied to
3460 : atomic groups at runtime, but in a different way.] */
3461 :
3462 : else
3463 : {
3464 0 : uschar *ketcode = code - ketoffset;
3465 0 : uschar *bracode = ketcode - GET(ketcode, 1);
3466 0 : *ketcode = OP_KETRMAX + repeat_type;
3467 0 : if (lengthptr == NULL && *bracode != OP_ONCE)
3468 : {
3469 0 : uschar *scode = bracode;
3470 : do
3471 : {
3472 0 : if (could_be_empty_branch(scode, ketcode, utf8))
3473 : {
3474 0 : *bracode += OP_SBRA - OP_BRA;
3475 0 : break;
3476 : }
3477 0 : scode += GET(scode, 1);
3478 : }
3479 0 : while (*scode == OP_ALT);
3480 : }
3481 : }
3482 : }
3483 :
3484 : /* Else there's some kind of shambles */
3485 :
3486 : else
3487 : {
3488 0 : *errorcodeptr = ERR11;
3489 0 : goto FAILED;
3490 : }
3491 :
3492 : /* If the character following a repeat is '+', or if certain optimization
3493 : tests above succeeded, possessive_quantifier is TRUE. For some of the
3494 : simpler opcodes, there is an special alternative opcode for this. For
3495 : anything else, we wrap the entire repeated item inside OP_ONCE brackets.
3496 : The '+' notation is just syntactic sugar, taken from Sun's Java package,
3497 : but the special opcodes can optimize it a bit. The repeated item starts at
3498 : tempcode, not at previous, which might be the first part of a string whose
3499 : (former) last char we repeated.
3500 :
3501 : Possessifying an 'exact' quantifier has no effect, so we can ignore it. But
3502 : an 'upto' may follow. We skip over an 'exact' item, and then test the
3503 : length of what remains before proceeding. */
3504 :
3505 1264 : if (possessive_quantifier)
3506 : {
3507 : int len;
3508 8 : if (*tempcode == OP_EXACT || *tempcode == OP_TYPEEXACT ||
3509 : *tempcode == OP_NOTEXACT)
3510 0 : tempcode += _pcre_OP_lengths[*tempcode];
3511 8 : len = code - tempcode;
3512 8 : if (len > 0) switch (*tempcode)
3513 : {
3514 6 : case OP_STAR: *tempcode = OP_POSSTAR; break;
3515 0 : case OP_PLUS: *tempcode = OP_POSPLUS; break;
3516 0 : case OP_QUERY: *tempcode = OP_POSQUERY; break;
3517 0 : case OP_UPTO: *tempcode = OP_POSUPTO; break;
3518 :
3519 2 : case OP_TYPESTAR: *tempcode = OP_TYPEPOSSTAR; break;
3520 0 : case OP_TYPEPLUS: *tempcode = OP_TYPEPOSPLUS; break;
3521 0 : case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;
3522 0 : case OP_TYPEUPTO: *tempcode = OP_TYPEPOSUPTO; break;
3523 :
3524 0 : case OP_NOTSTAR: *tempcode = OP_NOTPOSSTAR; break;
3525 0 : case OP_NOTPLUS: *tempcode = OP_NOTPOSPLUS; break;
3526 0 : case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;
3527 0 : case OP_NOTUPTO: *tempcode = OP_NOTPOSUPTO; break;
3528 :
3529 : default:
3530 0 : memmove(tempcode + 1+LINK_SIZE, tempcode, len);
3531 0 : code += 1 + LINK_SIZE;
3532 0 : len += 1 + LINK_SIZE;
3533 0 : tempcode[0] = OP_ONCE;
3534 0 : *code++ = OP_KET;
3535 0 : PUTINC(code, 0, len);
3536 0 : PUT(tempcode, 1, len);
3537 : break;
3538 : }
3539 : }
3540 :
3541 : /* In all case we no longer have a previous item. We also set the
3542 : "follows varying string" flag for subsequently encountered reqbytes if
3543 : it isn't already set and we have just passed a varying length item. */
3544 :
3545 1264 : END_REPEAT:
3546 1264 : previous = NULL;
3547 1264 : cd->req_varyopt |= reqvary;
3548 1264 : break;
3549 :
3550 :
3551 : /* ===================================================================*/
3552 : /* Start of nested parenthesized sub-expression, or comment or lookahead or
3553 : lookbehind or option setting or condition or all the other extended
3554 : parenthesis forms. First deal with the specials; all are introduced by ?,
3555 : and the appearance of any of them means that this is not a capturing
3556 : group. */
3557 :
3558 : case '(':
3559 38 : newoptions = options;
3560 38 : skipbytes = 0;
3561 38 : bravalue = OP_CBRA;
3562 38 : save_hwm = cd->hwm;
3563 :
3564 38 : if (*(++ptr) == '?')
3565 : {
3566 : int i, set, unset, namelen;
3567 : int *optset;
3568 : const uschar *name;
3569 : uschar *slot;
3570 :
3571 0 : switch (*(++ptr))
3572 : {
3573 : case '#': /* Comment; skip to ket */
3574 0 : ptr++;
3575 0 : while (*ptr != 0 && *ptr != ')') ptr++;
3576 0 : if (*ptr == 0)
3577 : {
3578 0 : *errorcodeptr = ERR18;
3579 0 : goto FAILED;
3580 : }
3581 0 : continue;
3582 :
3583 :
3584 : /* ------------------------------------------------------------ */
3585 : case ':': /* Non-capturing bracket */
3586 0 : bravalue = OP_BRA;
3587 0 : ptr++;
3588 0 : break;
3589 :
3590 :
3591 : /* ------------------------------------------------------------ */
3592 : case '(':
3593 0 : bravalue = OP_COND; /* Conditional group */
3594 :
3595 : /* A condition can be an assertion, a number (referring to a numbered
3596 : group), a name (referring to a named group), or 'R', referring to
3597 : recursion. R<digits> and R&name are also permitted for recursion tests.
3598 :
3599 : There are several syntaxes for testing a named group: (?(name)) is used
3600 : by Python; Perl 5.10 onwards uses (?(<name>) or (?('name')).
3601 :
3602 : There are two unfortunate ambiguities, caused by history. (a) 'R' can
3603 : be the recursive thing or the name 'R' (and similarly for 'R' followed
3604 : by digits), and (b) a number could be a name that consists of digits.
3605 : In both cases, we look for a name first; if not found, we try the other
3606 : cases. */
3607 :
3608 : /* For conditions that are assertions, check the syntax, and then exit
3609 : the switch. This will take control down to where bracketed groups,
3610 : including assertions, are processed. */
3611 :
3612 0 : if (ptr[1] == '?' && (ptr[2] == '=' || ptr[2] == '!' || ptr[2] == '<'))
3613 : break;
3614 :
3615 : /* Most other conditions use OP_CREF (a couple change to OP_RREF
3616 : below), and all need to skip 3 bytes at the start of the group. */
3617 :
3618 0 : code[1+LINK_SIZE] = OP_CREF;
3619 0 : skipbytes = 3;
3620 :
3621 : /* Check for a test for recursion in a named group. */
3622 :
3623 0 : if (ptr[1] == 'R' && ptr[2] == '&')
3624 : {
3625 0 : terminator = -1;
3626 0 : ptr += 2;
3627 0 : code[1+LINK_SIZE] = OP_RREF; /* Change the type of test */
3628 : }
3629 :
3630 : /* Check for a test for a named group's having been set, using the Perl
3631 : syntax (?(<name>) or (?('name') */
3632 :
3633 0 : else if (ptr[1] == '<')
3634 : {
3635 0 : terminator = '>';
3636 0 : ptr++;
3637 : }
3638 0 : else if (ptr[1] == '\'')
3639 : {
3640 0 : terminator = '\'';
3641 0 : ptr++;
3642 : }
3643 0 : else terminator = 0;
3644 :
3645 : /* We now expect to read a name; any thing else is an error */
3646 :
3647 0 : if ((cd->ctypes[ptr[1]] & ctype_word) == 0)
3648 : {
3649 0 : ptr += 1; /* To get the right offset */
3650 0 : *errorcodeptr = ERR28;
3651 0 : goto FAILED;
3652 : }
3653 :
3654 : /* Read the name, but also get it as a number if it's all digits */
3655 :
3656 0 : recno = 0;
3657 0 : name = ++ptr;
3658 0 : while ((cd->ctypes[*ptr] & ctype_word) != 0)
3659 : {
3660 0 : if (recno >= 0)
3661 0 : recno = ((digitab[*ptr] & ctype_digit) != 0)?
3662 : recno * 10 + *ptr - '0' : -1;
3663 0 : ptr++;
3664 : }
3665 0 : namelen = ptr - name;
3666 :
3667 0 : if ((terminator > 0 && *ptr++ != terminator) || *ptr++ != ')')
3668 : {
3669 0 : ptr--; /* Error offset */
3670 0 : *errorcodeptr = ERR26;
3671 0 : goto FAILED;
3672 : }
3673 :
3674 : /* Do no further checking in the pre-compile phase. */
3675 :
3676 0 : if (lengthptr != NULL) break;
3677 :
3678 : /* In the real compile we do the work of looking for the actual
3679 : reference. */
3680 :
3681 0 : slot = cd->name_table;
3682 0 : for (i = 0; i < cd->names_found; i++)
3683 : {
3684 0 : if (strncmp((char *)name, (char *)slot+2, namelen) == 0) break;
3685 0 : slot += cd->name_entry_size;
3686 : }
3687 :
3688 : /* Found a previous named subpattern */
3689 :
3690 0 : if (i < cd->names_found)
3691 : {
3692 0 : recno = GET2(slot, 0);
3693 0 : PUT2(code, 2+LINK_SIZE, recno);
3694 : }
3695 :
3696 : /* Search the pattern for a forward reference */
3697 :
3698 0 : else if ((i = find_parens(ptr, cd->bracount, name, namelen,
3699 : (options & PCRE_EXTENDED) != 0)) > 0)
3700 : {
3701 0 : PUT2(code, 2+LINK_SIZE, i);
3702 : }
3703 :
3704 : /* If terminator == 0 it means that the name followed directly after
3705 : the opening parenthesis [e.g. (?(abc)...] and in this case there are
3706 : some further alternatives to try. For the cases where terminator != 0
3707 : [things like (?(<name>... or (?('name')... or (?(R&name)... ] we have
3708 : now checked all the possibilities, so give an error. */
3709 :
3710 0 : else if (terminator != 0)
3711 : {
3712 0 : *errorcodeptr = ERR15;
3713 0 : goto FAILED;
3714 : }
3715 :
3716 : /* Check for (?(R) for recursion. Allow digits after R to specify a
3717 : specific group number. */
3718 :
3719 0 : else if (*name == 'R')
3720 : {
3721 0 : recno = 0;
3722 0 : for (i = 1; i < namelen; i++)
3723 : {
3724 0 : if ((digitab[name[i]] & ctype_digit) == 0)
3725 : {
3726 0 : *errorcodeptr = ERR15;
3727 0 : goto FAILED;
3728 : }
3729 0 : recno = recno * 10 + name[i] - '0';
3730 : }
3731 0 : if (recno == 0) recno = RREF_ANY;
3732 0 : code[1+LINK_SIZE] = OP_RREF; /* Change test type */
3733 0 : PUT2(code, 2+LINK_SIZE, recno);
3734 : }
3735 :
3736 : /* Similarly, check for the (?(DEFINE) "condition", which is always
3737 : false. */
3738 :
3739 0 : else if (namelen == 6 && strncmp((char *)name, "DEFINE", 6) == 0)
3740 : {
3741 0 : code[1+LINK_SIZE] = OP_DEF;
3742 0 : skipbytes = 1;
3743 : }
3744 :
3745 : /* Check for the "name" actually being a subpattern number. */
3746 :
3747 0 : else if (recno > 0)
3748 : {
3749 0 : PUT2(code, 2+LINK_SIZE, recno);
3750 : }
3751 :
3752 : /* Either an unidentified subpattern, or a reference to (?(0) */
3753 :
3754 : else
3755 : {
3756 0 : *errorcodeptr = (recno == 0)? ERR35: ERR15;
3757 0 : goto FAILED;
3758 : }
3759 0 : break;
3760 :
3761 :
3762 : /* ------------------------------------------------------------ */
3763 : case '=': /* Positive lookahead */
3764 0 : bravalue = OP_ASSERT;
3765 0 : ptr++;
3766 0 : break;
3767 :
3768 :
3769 : /* ------------------------------------------------------------ */
3770 : case '!': /* Negative lookahead */
3771 0 : bravalue = OP_ASSERT_NOT;
3772 0 : ptr++;
3773 0 : break;
3774 :
3775 :
3776 : /* ------------------------------------------------------------ */
3777 : case '<': /* Lookbehind or named define */
3778 0 : switch (ptr[1])
3779 : {
3780 : case '=': /* Positive lookbehind */
3781 0 : bravalue = OP_ASSERTBACK;
3782 0 : ptr += 2;
3783 0 : break;
3784 :
3785 : case '!': /* Negative lookbehind */
3786 0 : bravalue = OP_ASSERTBACK_NOT;
3787 0 : ptr += 2;
3788 0 : break;
3789 :
3790 : default: /* Could be name define, else bad */
3791 0 : if ((cd->ctypes[ptr[1]] & ctype_word) != 0) goto DEFINE_NAME;
3792 0 : ptr++; /* Correct offset for error */
3793 0 : *errorcodeptr = ERR24;
3794 0 : goto FAILED;
3795 : }
3796 0 : break;
3797 :
3798 :
3799 : /* ------------------------------------------------------------ */
3800 : case '>': /* One-time brackets */
3801 0 : bravalue = OP_ONCE;
3802 0 : ptr++;
3803 0 : break;
3804 :
3805 :
3806 : /* ------------------------------------------------------------ */
3807 : case 'C': /* Callout - may be followed by digits; */
3808 0 : previous_callout = code; /* Save for later completion */
3809 0 : after_manual_callout = 1; /* Skip one item before completing */
3810 0 : *code++ = OP_CALLOUT;
3811 : {
3812 0 : int n = 0;
3813 0 : while ((digitab[*(++ptr)] & ctype_digit) != 0)
3814 0 : n = n * 10 + *ptr - '0';
3815 0 : if (*ptr != ')')
3816 : {
3817 0 : *errorcodeptr = ERR39;
3818 0 : goto FAILED;
3819 : }
3820 0 : if (n > 255)
3821 : {
3822 0 : *errorcodeptr = ERR38;
3823 0 : goto FAILED;
3824 : }
3825 0 : *code++ = n;
3826 0 : PUT(code, 0, ptr - cd->start_pattern + 1); /* Pattern offset */
3827 0 : PUT(code, LINK_SIZE, 0); /* Default length */
3828 0 : code += 2 * LINK_SIZE;
3829 : }
3830 0 : previous = NULL;
3831 0 : continue;
3832 :
3833 :
3834 : /* ------------------------------------------------------------ */
3835 : case 'P': /* Python-style named subpattern handling */
3836 0 : if (*(++ptr) == '=' || *ptr == '>') /* Reference or recursion */
3837 : {
3838 0 : is_recurse = *ptr == '>';
3839 0 : terminator = ')';
3840 0 : goto NAMED_REF_OR_RECURSE;
3841 : }
3842 0 : else if (*ptr != '<') /* Test for Python-style definition */
3843 : {
3844 0 : *errorcodeptr = ERR41;
3845 0 : goto FAILED;
3846 : }
3847 : /* Fall through to handle (?P< as (?< is handled */
3848 :
3849 :
3850 : /* ------------------------------------------------------------ */
3851 0 : DEFINE_NAME: /* Come here from (?< handling */
3852 : case '\'':
3853 : {
3854 0 : terminator = (*ptr == '<')? '>' : '\'';
3855 0 : name = ++ptr;
3856 :
3857 0 : while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
3858 0 : namelen = ptr - name;
3859 :
3860 : /* In the pre-compile phase, just do a syntax check. */
3861 :
3862 0 : if (lengthptr != NULL)
3863 : {
3864 0 : if (*ptr != terminator)
3865 : {
3866 0 : *errorcodeptr = ERR42;
3867 0 : goto FAILED;
3868 : }
3869 0 : if (cd->names_found >= MAX_NAME_COUNT)
3870 : {
3871 0 : *errorcodeptr = ERR49;
3872 0 : goto FAILED;
3873 : }
3874 0 : if (namelen + 3 > cd->name_entry_size)
3875 : {
3876 0 : cd->name_entry_size = namelen + 3;
3877 0 : if (namelen > MAX_NAME_SIZE)
3878 : {
3879 0 : *errorcodeptr = ERR48;
3880 0 : goto FAILED;
3881 : }
3882 : }
3883 : }
3884 :
3885 : /* In the real compile, create the entry in the table */
3886 :
3887 : else
3888 : {
3889 0 : slot = cd->name_table;
3890 0 : for (i = 0; i < cd->names_found; i++)
3891 : {
3892 0 : int crc = memcmp(name, slot+2, namelen);
3893 0 : if (crc == 0)
3894 : {
3895 0 : if (slot[2+namelen] == 0)
3896 : {
3897 0 : if ((options & PCRE_DUPNAMES) == 0)
3898 : {
3899 0 : *errorcodeptr = ERR43;
3900 0 : goto FAILED;
3901 : }
3902 : }
3903 0 : else crc = -1; /* Current name is substring */
3904 : }
3905 0 : if (crc < 0)
3906 : {
3907 0 : memmove(slot + cd->name_entry_size, slot,
3908 : (cd->names_found - i) * cd->name_entry_size);
3909 0 : break;
3910 : }
3911 0 : slot += cd->name_entry_size;
3912 : }
3913 :
3914 0 : PUT2(slot, 0, cd->bracount + 1);
3915 0 : memcpy(slot + 2, name, namelen);
3916 0 : slot[2+namelen] = 0;
3917 : }
3918 : }
3919 :
3920 : /* In both cases, count the number of names we've encountered. */
3921 :
3922 0 : ptr++; /* Move past > or ' */
3923 0 : cd->names_found++;
3924 0 : goto NUMBERED_GROUP;
3925 :
3926 :
3927 : /* ------------------------------------------------------------ */
3928 : case '&': /* Perl recursion/subroutine syntax */
3929 0 : terminator = ')';
3930 0 : is_recurse = TRUE;
3931 : /* Fall through */
3932 :
3933 : /* We come here from the Python syntax above that handles both
3934 : references (?P=name) and recursion (?P>name), as well as falling
3935 : through from the Perl recursion syntax (?&name). */
3936 :
3937 0 : NAMED_REF_OR_RECURSE:
3938 0 : name = ++ptr;
3939 0 : while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
3940 0 : namelen = ptr - name;
3941 :
3942 : /* In the pre-compile phase, do a syntax check and set a dummy
3943 : reference number. */
3944 :
3945 0 : if (lengthptr != NULL)
3946 : {
3947 0 : if (*ptr != terminator)
3948 : {
3949 0 : *errorcodeptr = ERR42;
3950 0 : goto FAILED;
3951 : }
3952 0 : if (namelen > MAX_NAME_SIZE)
3953 : {
3954 0 : *errorcodeptr = ERR48;
3955 0 : goto FAILED;
3956 : }
3957 0 : recno = 0;
3958 : }
3959 :
3960 : /* In the real compile, seek the name in the table */
3961 :
3962 : else
3963 : {
3964 0 : slot = cd->name_table;
3965 0 : for (i = 0; i < cd->names_found; i++)
3966 : {
3967 0 : if (strncmp((char *)name, (char *)slot+2, namelen) == 0) break;
3968 0 : slot += cd->name_entry_size;
3969 : }
3970 :
3971 0 : if (i < cd->names_found) /* Back reference */
3972 : {
3973 0 : recno = GET2(slot, 0);
3974 : }
3975 0 : else if ((recno = /* Forward back reference */
3976 : find_parens(ptr, cd->bracount, name, namelen,
3977 : (options & PCRE_EXTENDED) != 0)) <= 0)
3978 : {
3979 0 : *errorcodeptr = ERR15;
3980 0 : goto FAILED;
3981 : }
3982 : }
3983 :
3984 : /* In both phases, we can now go to the code than handles numerical
3985 : recursion or backreferences. */
3986 :
3987 0 : if (is_recurse) goto HANDLE_RECURSION;
3988 0 : else goto HANDLE_REFERENCE;
3989 :
3990 :
3991 : /* ------------------------------------------------------------ */
3992 : case 'R': /* Recursion */
3993 0 : ptr++; /* Same as (?0) */
3994 : /* Fall through */
3995 :
3996 :
3997 : /* ------------------------------------------------------------ */
3998 : case '0': case '1': case '2': case '3': case '4': /* Recursion or */
3999 : case '5': case '6': case '7': case '8': case '9': /* subroutine */
4000 : {
4001 : const uschar *called;
4002 0 : recno = 0;
4003 0 : while((digitab[*ptr] & ctype_digit) != 0)
4004 0 : recno = recno * 10 + *ptr++ - '0';
4005 0 : if (*ptr != ')')
4006 : {
4007 0 : *errorcodeptr = ERR29;
4008 0 : goto FAILED;
4009 : }
4010 :
4011 : /* Come here from code above that handles a named recursion */
4012 :
4013 0 : HANDLE_RECURSION:
4014 :
4015 0 : previous = code;
4016 0 : called = cd->start_code;
4017 :
4018 : /* When we are actually compiling, find the bracket that is being
4019 : referenced. Temporarily end the regex in case it doesn't exist before
4020 : this point. If we end up with a forward reference, first check that
4021 : the bracket does occur later so we can give the error (and position)
4022 : now. Then remember this forward reference in the workspace so it can
4023 : be filled in at the end. */
4024 :
4025 0 : if (lengthptr == NULL)
4026 : {
4027 0 : *code = OP_END;
4028 0 : if (recno != 0) called = find_bracket(cd->start_code, utf8, recno);
4029 :
4030 : /* Forward reference */
4031 :
4032 0 : if (called == NULL)
4033 : {
4034 0 : if (find_parens(ptr, cd->bracount, NULL, recno,
4035 : (options & PCRE_EXTENDED) != 0) < 0)
4036 : {
4037 0 : *errorcodeptr = ERR15;
4038 0 : goto FAILED;
4039 : }
4040 0 : called = cd->start_code + recno;
4041 0 : PUTINC(cd->hwm, 0, code + 2 + LINK_SIZE - cd->start_code);
4042 : }
4043 :
4044 : /* If not a forward reference, and the subpattern is still open,
4045 : this is a recursive call. We check to see if this is a left
4046 : recursion that could loop for ever, and diagnose that case. */
4047 :
4048 0 : else if (GET(called, 1) == 0 &&
4049 : could_be_empty(called, code, bcptr, utf8))
4050 : {
4051 0 : *errorcodeptr = ERR40;
4052 0 : goto FAILED;
4053 : }
4054 : }
4055 :
4056 : /* Insert the recursion/subroutine item, automatically wrapped inside
4057 : "once" brackets. Set up a "previous group" length so that a
4058 : subsequent quantifier will work. */
4059 :
4060 0 : *code = OP_ONCE;
4061 0 : PUT(code, 1, 2 + 2*LINK_SIZE);
4062 0 : code += 1 + LINK_SIZE;
4063 :
4064 0 : *code = OP_RECURSE;
4065 0 : PUT(code, 1, called - cd->start_code);
4066 0 : code += 1 + LINK_SIZE;
4067 :
4068 0 : *code = OP_KET;
4069 0 : PUT(code, 1, 2 + 2*LINK_SIZE);
4070 0 : code += 1 + LINK_SIZE;
4071 :
4072 0 : length_prevgroup = 3 + 3*LINK_SIZE;
4073 : }
4074 :
4075 : /* Can't determine a first byte now */
4076 :
4077 0 : if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
4078 0 : continue;
4079 :
4080 :
4081 : /* ------------------------------------------------------------ */
4082 : default: /* Other characters: check option setting */
4083 0 : set = unset = 0;
4084 0 : optset = &set;
4085 :
4086 0 : while (*ptr != ')' && *ptr != ':')
4087 : {
4088 0 : switch (*ptr++)
4089 : {
4090 0 : case '-': optset = &unset; break;
4091 :
4092 : case 'J': /* Record that it changed in the external options */
4093 0 : *optset |= PCRE_DUPNAMES;
4094 0 : cd->external_options |= PCRE_JCHANGED;
4095 0 : break;
4096 :
4097 0 : case 'i': *optset |= PCRE_CASELESS; break;
4098 0 : case 'm': *optset |= PCRE_MULTILINE; break;
4099 0 : case 's': *optset |= PCRE_DOTALL; break;
4100 0 : case 'x': *optset |= PCRE_EXTENDED; break;
4101 0 : case 'U': *optset |= PCRE_UNGREEDY; break;
4102 0 : case 'X': *optset |= PCRE_EXTRA; break;
4103 :
4104 0 : default: *errorcodeptr = ERR12;
4105 0 : ptr--; /* Correct the offset */
4106 0 : goto FAILED;
4107 : }
4108 : }
4109 :
4110 : /* Set up the changed option bits, but don't change anything yet. */
4111 :
4112 0 : newoptions = (options | set) & (~unset);
4113 :
4114 : /* If the options ended with ')' this is not the start of a nested
4115 : group with option changes, so the options change at this level. If this
4116 : item is right at the start of the pattern, the options can be
4117 : abstracted and made external in the pre-compile phase, and ignored in
4118 : the compile phase. This can be helpful when matching -- for instance in
4119 : caseless checking of required bytes.
4120 :
4121 : If the code pointer is not (cd->start_code + 1 + LINK_SIZE), we are
4122 : definitely *not* at the start of the pattern because something has been
4123 : compiled. In the pre-compile phase, however, the code pointer can have
4124 : that value after the start, because it gets reset as code is discarded
4125 : during the pre-compile. However, this can happen only at top level - if
4126 : we are within parentheses, the starting BRA will still be present. At
4127 : any parenthesis level, the length value can be used to test if anything
4128 : has been compiled at that level. Thus, a test for both these conditions
4129 : is necessary to ensure we correctly detect the start of the pattern in
4130 : both phases.
4131 :
4132 : If we are not at the pattern start, compile code to change the ims
4133 : options if this setting actually changes any of them. We also pass the
4134 : new setting back so that it can be put at the start of any following
4135 : branches, and when this group ends (if we are in a group), a resetting
4136 : item can be compiled. */
4137 :
4138 0 : if (*ptr == ')')
4139 : {
4140 0 : if (code == cd->start_code + 1 + LINK_SIZE &&
4141 : (lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))
4142 : {
4143 0 : cd->external_options = newoptions;
4144 0 : options = newoptions;
4145 : }
4146 : else
4147 : {
4148 0 : if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))
4149 : {
4150 0 : *code++ = OP_OPT;
4151 0 : *code++ = newoptions & PCRE_IMS;
4152 : }
4153 :
4154 : /* Change options at this level, and pass them back for use
4155 : in subsequent branches. Reset the greedy defaults and the case
4156 : value for firstbyte and reqbyte. */
4157 :
4158 0 : *optionsptr = options = newoptions;
4159 0 : greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
4160 0 : greedy_non_default = greedy_default ^ 1;
4161 0 : req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
4162 : }
4163 :
4164 0 : previous = NULL; /* This item can't be repeated */
4165 0 : continue; /* It is complete */
4166 : }
4167 :
4168 : /* If the options ended with ':' we are heading into a nested group
4169 : with possible change of options. Such groups are non-capturing and are
4170 : not assertions of any kind. All we need to do is skip over the ':';
4171 : the newoptions value is handled below. */
4172 :
4173 0 : bravalue = OP_BRA;
4174 0 : ptr++;
4175 : } /* End of switch for character following (? */
4176 : } /* End of (? handling */
4177 :
4178 : /* Opening parenthesis not followed by '?'. If PCRE_NO_AUTO_CAPTURE is set,
4179 : all unadorned brackets become non-capturing and behave like (?:...)
4180 : brackets. */
4181 :
4182 38 : else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)
4183 : {
4184 0 : bravalue = OP_BRA;
4185 : }
4186 :
4187 : /* Else we have a capturing group. */
4188 :
4189 : else
4190 : {
4191 38 : NUMBERED_GROUP:
4192 38 : cd->bracount += 1;
4193 38 : PUT2(code, 1+LINK_SIZE, cd->bracount);
4194 38 : skipbytes = 2;
4195 : }
4196 :
4197 : /* Process nested bracketed regex. Assertions may not be repeated, but
4198 : other kinds can be. All their opcodes are >= OP_ONCE. We copy code into a
4199 : non-register variable in order to be able to pass its address because some
4200 : compilers complain otherwise. Pass in a new setting for the ims options if
4201 : they have changed. */
4202 :
4203 38 : previous = (bravalue >= OP_ONCE)? code : NULL;
4204 38 : *code = bravalue;
4205 38 : tempcode = code;
4206 38 : tempreqvary = cd->req_varyopt; /* Save value before bracket */
4207 38 : length_prevgroup = 0; /* Initialize for pre-compile phase */
4208 :
4209 38 : if (!compile_regex(
4210 : newoptions, /* The complete new option state */
4211 : options & PCRE_IMS, /* The previous ims option state */
4212 : &tempcode, /* Where to put code (updated) */
4213 : &ptr, /* Input pointer (updated) */
4214 : errorcodeptr, /* Where to put an error message */
4215 : (bravalue == OP_ASSERTBACK ||
4216 : bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
4217 : skipbytes, /* Skip over bracket number */
4218 : &subfirstbyte, /* For possible first char */
4219 : &subreqbyte, /* For possible last char */
4220 : bcptr, /* Current branch chain */
4221 : cd, /* Tables block */
4222 : (lengthptr == NULL)? NULL : /* Actual compile phase */
4223 : &length_prevgroup /* Pre-compile phase */
4224 : ))
4225 0 : goto FAILED;
4226 :
4227 : /* At the end of compiling, code is still pointing to the start of the
4228 : group, while tempcode has been updated to point past the end of the group
4229 : and any option resetting that may follow it. The pattern pointer (ptr)
4230 : is on the bracket. */
4231 :
4232 : /* If this is a conditional bracket, check that there are no more than
4233 : two branches in the group, or just one if it's a DEFINE group. */
4234 :
4235 38 : if (bravalue == OP_COND)
4236 : {
4237 0 : uschar *tc = code;
4238 0 : int condcount = 0;
4239 :
4240 : do {
4241 0 : condcount++;
4242 0 : tc += GET(tc,1);
4243 : }
4244 0 : while (*tc != OP_KET);
4245 :
4246 : /* A DEFINE group is never obeyed inline (the "condition" is always
4247 : false). It must have only one branch. */
4248 :
4249 0 : if (code[LINK_SIZE+1] == OP_DEF)
4250 : {
4251 0 : if (condcount > 1)
4252 : {
4253 0 : *errorcodeptr = ERR54;
4254 0 : goto FAILED;
4255 : }
4256 0 : bravalue = OP_DEF; /* Just a flag to suppress char handling below */
4257 : }
4258 :
4259 : /* A "normal" conditional group. If there is just one branch, we must not
4260 : make use of its firstbyte or reqbyte, because this is equivalent to an
4261 : empty second branch. */
4262 :
4263 : else
4264 : {
4265 0 : if (condcount > 2)
4266 : {
4267 0 : *errorcodeptr = ERR27;
4268 0 : goto FAILED;
4269 : }
4270 0 : if (condcount == 1) subfirstbyte = subreqbyte = REQ_NONE;
4271 : }
4272 : }
4273 :
4274 : /* Error if hit end of pattern */
4275 :
4276 38 : if (*ptr != ')')
4277 : {
4278 0 : *errorcodeptr = ERR14;
4279 0 : goto FAILED;
4280 : }
4281 :
4282 : /* In the pre-compile phase, update the length by the length of the nested
4283 : group, less the brackets at either end. Then reduce the compiled code to
4284 : just the brackets so that it doesn't use much memory if it is duplicated by
4285 : a quantifier. */
4286 :
4287 38 : if (lengthptr != NULL)
4288 : {
4289 19 : *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;
4290 19 : code++;
4291 19 : PUTINC(code, 0, 1 + LINK_SIZE);
4292 19 : *code++ = OP_KET;
4293 19 : PUTINC(code, 0, 1 + LINK_SIZE);
4294 : }
4295 :
4296 : /* Otherwise update the main code pointer to the end of the group. */
4297 :
4298 19 : else code = tempcode;
4299 :
4300 : /* For a DEFINE group, required and first character settings are not
4301 : relevant. */
4302 :
4303 38 : if (bravalue == OP_DEF) break;
4304 :
4305 : /* Handle updating of the required and first characters for other types of
4306 : group. Update for normal brackets of all kinds, and conditions with two
4307 : branches (see code above). If the bracket is followed by a quantifier with
4308 : zero repeat, we have to back off. Hence the definition of zeroreqbyte and
4309 : zerofirstbyte outside the main loop so that they can be accessed for the
4310 : back off. */
4311 :
4312 38 : zeroreqbyte = reqbyte;
4313 38 : zerofirstbyte = firstbyte;
4314 38 : groupsetfirstbyte = FALSE;
4315 :
4316 38 : if (bravalue >= OP_ONCE)
4317 : {
4318 : /* If we have not yet set a firstbyte in this branch, take it from the
4319 : subpattern, remembering that it was set here so that a repeat of more
4320 : than one can replicate it as reqbyte if necessary. If the subpattern has
4321 : no firstbyte, set "none" for the whole branch. In both cases, a zero
4322 : repeat forces firstbyte to "none". */
4323 :
4324 38 : if (firstbyte == REQ_UNSET)
4325 : {
4326 0 : if (subfirstbyte >= 0)
4327 : {
4328 0 : firstbyte = subfirstbyte;
4329 0 : groupsetfirstbyte = TRUE;
4330 : }
4331 0 : else firstbyte = REQ_NONE;
4332 0 : zerofirstbyte = REQ_NONE;
4333 : }
4334 :
4335 : /* If firstbyte was previously set, convert the subpattern's firstbyte
4336 : into reqbyte if there wasn't one, using the vary flag that was in
4337 : existence beforehand. */
4338 :
4339 38 : else if (subfirstbyte >= 0 && subreqbyte < 0)
4340 17 : subreqbyte = subfirstbyte | tempreqvary;
4341 :
4342 : /* If the subpattern set a required byte (or set a first byte that isn't
4343 : really the first byte - see above), set it. */
4344 :
4345 38 : if (subreqbyte >= 0) reqbyte = subreqbyte;
4346 : }
4347 :
4348 : /* For a forward assertion, we take the reqbyte, if set. This can be
4349 : helpful if the pattern that follows the assertion doesn't set a different
4350 : char. For example, it's useful for /(?=abcde).+/. We can't set firstbyte
4351 : for an assertion, however because it leads to incorrect effect for patterns
4352 : such as /(?=a)a.+/ when the "real" "a" would then become a reqbyte instead
4353 : of a firstbyte. This is overcome by a scan at the end if there's no
4354 : firstbyte, looking for an asserted first char. */
4355 :
4356 0 : else if (bravalue == OP_ASSERT && subreqbyte >= 0) reqbyte = subreqbyte;
4357 38 : break; /* End of processing '(' */
4358 :
4359 :
4360 : /* ===================================================================*/
4361 : /* Handle metasequences introduced by \. For ones like \d, the ESC_ values
4362 : are arranged to be the negation of the corresponding OP_values. For the
4363 : back references, the values are ESC_REF plus the reference number. Only
4364 : back references and those types that consume a character may be repeated.
4365 : We can test for values between ESC_b and ESC_Z for the latter; this may
4366 : have to change if any new ones are ever created. */
4367 :
4368 : case '\\':
4369 7610 : tempptr = ptr;
4370 7610 : c = check_escape(&ptr, errorcodeptr, cd->bracount, options, FALSE);
4371 7610 : if (*errorcodeptr != 0) goto FAILED;
4372 :
4373 7610 : if (c < 0)
4374 : {
4375 6 : if (-c == ESC_Q) /* Handle start of quoted string */
4376 : {
4377 0 : if (ptr[1] == '\\' && ptr[2] == 'E') ptr += 2; /* avoid empty string */
4378 0 : else inescq = TRUE;
4379 0 : continue;
4380 : }
4381 :
4382 6 : if (-c == ESC_E) continue; /* Perl ignores an orphan \E */
4383 :
4384 : /* For metasequences that actually match a character, we disable the
4385 : setting of a first character if it hasn't already been set. */
4386 :
4387 6 : if (firstbyte == REQ_UNSET && -c > ESC_b && -c < ESC_Z)
4388 2 : firstbyte = REQ_NONE;
4389 :
4390 : /* Set values to reset to if this is followed by a zero repeat. */
4391 :
4392 6 : zerofirstbyte = firstbyte;
4393 6 : zeroreqbyte = reqbyte;
4394 :
4395 : /* \k<name> or \k'name' is a back reference by name (Perl syntax) */
4396 :
4397 6 : if (-c == ESC_k && (ptr[1] == '<' || ptr[1] == '\''))
4398 : {
4399 0 : is_recurse = FALSE;
4400 0 : terminator = (*(++ptr) == '<')? '>' : '\'';
4401 0 : goto NAMED_REF_OR_RECURSE;
4402 : }
4403 :
4404 : /* Back references are handled specially; must disable firstbyte if
4405 : not set to cope with cases like (?=(\w+))\1: which would otherwise set
4406 : ':' later. */
4407 :
4408 6 : if (-c >= ESC_REF)
4409 : {
4410 0 : recno = -c - ESC_REF;
4411 :
4412 0 : HANDLE_REFERENCE: /* Come here from named backref handling */
4413 0 : if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
4414 0 : previous = code;
4415 0 : *code++ = OP_REF;
4416 0 : PUT2INC(code, 0, recno);
4417 0 : cd->backref_map |= (recno < 32)? (1 << recno) : 1;
4418 0 : if (recno > cd->top_backref) cd->top_backref = recno;
4419 : }
4420 :
4421 : /* So are Unicode property matches, if supported. */
4422 :
4423 : #ifdef SUPPORT_UCP
4424 6 : else if (-c == ESC_P || -c == ESC_p)
4425 : {
4426 : BOOL negated;
4427 : int pdata;
4428 0 : int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
4429 0 : if (ptype < 0) goto FAILED;
4430 0 : previous = code;
4431 0 : *code++ = ((-c == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
4432 0 : *code++ = ptype;
4433 0 : *code++ = pdata;
4434 : }
4435 : #else
4436 :
4437 : /* If Unicode properties are not supported, \X, \P, and \p are not
4438 : allowed. */
4439 :
4440 : else if (-c == ESC_X || -c == ESC_P || -c == ESC_p)
4441 : {
4442 : *errorcodeptr = ERR45;
4443 : goto FAILED;
4444 : }
4445 : #endif
4446 :
4447 : /* For the rest (including \X when Unicode properties are supported), we
4448 : can obtain the OP value by negating the escape value. */
4449 :
4450 : else
4451 : {
4452 6 : previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
4453 6 : *code++ = -c;
4454 : }
4455 6 : continue;
4456 : }
4457 :
4458 : /* We have a data character whose value is in c. In UTF-8 mode it may have
4459 : a value > 127. We set its representation in the length/buffer, and then
4460 : handle it as a data character. */
4461 :
4462 : #ifdef SUPPORT_UTF8
4463 7604 : if (utf8 && c > 127)
4464 0 : mclength = _pcre_ord2utf8(c, mcbuffer);
4465 : else
4466 : #endif
4467 :
4468 : {
4469 7604 : mcbuffer[0] = c;
4470 7604 : mclength = 1;
4471 : }
4472 7604 : goto ONE_CHAR;
4473 :
4474 :
4475 : /* ===================================================================*/
4476 : /* Handle a literal character. It is guaranteed not to be whitespace or #
4477 : when the extended flag is set. If we are in UTF-8 mode, it may be a
4478 : multi-byte literal character. */
4479 :
4480 : default:
4481 62756 : NORMAL_CHAR:
4482 62756 : mclength = 1;
4483 62756 : mcbuffer[0] = c;
4484 :
4485 : #ifdef SUPPORT_UTF8
4486 62756 : if (utf8 && c >= 0xc0)
4487 : {
4488 0 : while ((ptr[1] & 0xc0) == 0x80)
4489 0 : mcbuffer[mclength++] = *(++ptr);
4490 : }
4491 : #endif
4492 :
4493 : /* At this point we have the character's bytes in mcbuffer, and the length
4494 : in mclength. When not in UTF-8 mode, the length is always 1. */
4495 :
4496 70360 : ONE_CHAR:
4497 70360 : previous = code;
4498 70360 : *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARNC : OP_CHAR;
4499 70360 : for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
4500 :
4501 : /* Set the first and required bytes appropriately. If no previous first
4502 : byte, set it from this character, but revert to none on a zero repeat.
4503 : Otherwise, leave the firstbyte value alone, and don't change it on a zero
4504 : repeat. */
4505 :
4506 70360 : if (firstbyte == REQ_UNSET)
4507 : {
4508 268 : zerofirstbyte = REQ_NONE;
4509 268 : zeroreqbyte = reqbyte;
4510 :
4511 : /* If the character is more than one byte long, we can set firstbyte
4512 : only if it is not to be matched caselessly. */
4513 :
4514 536 : if (mclength == 1 || req_caseopt == 0)
4515 : {
4516 268 : firstbyte = mcbuffer[0] | req_caseopt;
4517 268 : if (mclength != 1) reqbyte = code[-1] | cd->req_varyopt;
4518 : }
4519 0 : else firstbyte = reqbyte = REQ_NONE;
4520 : }
4521 :
4522 : /* firstbyte was previously set; we can set reqbyte only the length is
4523 : 1 or the matching is caseful. */
4524 :
4525 : else
4526 : {
4527 70092 : zerofirstbyte = firstbyte;
4528 70092 : zeroreqbyte = reqbyte;
4529 70092 : if (mclength == 1 || req_caseopt == 0)
4530 70092 : reqbyte = code[-1] | req_caseopt | cd->req_varyopt;
4531 : }
4532 :
4533 : break; /* End of literal character handling */
4534 : }
4535 73508 : } /* end of big loop */
4536 :
4537 :
4538 : /* Control never reaches here by falling through, only by a goto for all the
4539 : error states. Pass back the position in the pattern so that it can be displayed
4540 : to the user for diagnosing the error. */
4541 :
4542 0 : FAILED:
4543 0 : *ptrptr = ptr;
4544 0 : return FALSE;
4545 : }
4546 :
4547 :
4548 :
4549 :
4550 : /*************************************************
4551 : * Compile sequence of alternatives *
4552 : *************************************************/
4553 :
4554 : /* On entry, ptr is pointing past the bracket character, but on return it
4555 : points to the closing bracket, or vertical bar, or end of string. The code
4556 : variable is pointing at the byte into which the BRA operator has been stored.
4557 : If the ims options are changed at the start (for a (?ims: group) or during any
4558 : branch, we need to insert an OP_OPT item at the start of every following branch
4559 : to ensure they get set correctly at run time, and also pass the new options
4560 : into every subsequent branch compile.
4561 :
4562 : This function is used during the pre-compile phase when we are trying to find
4563 : out the amount of memory needed, as well as during the real compile phase. The
4564 : value of lengthptr distinguishes the two phases.
4565 :
4566 : Argument:
4567 : options option bits, including any changes for this subpattern
4568 : oldims previous settings of ims option bits
4569 : codeptr -> the address of the current code pointer
4570 : ptrptr -> the address of the current pattern pointer
4571 : errorcodeptr -> pointer to error code variable
4572 : lookbehind TRUE if this is a lookbehind assertion
4573 : skipbytes skip this many bytes at start (for brackets and OP_COND)
4574 : firstbyteptr place to put the first required character, or a negative number
4575 : reqbyteptr place to put the last required character, or a negative number
4576 : bcptr pointer to the chain of currently open branches
4577 : cd points to the data block with tables pointers etc.
4578 : lengthptr NULL during the real compile phase
4579 : points to length accumulator during pre-compile phase
4580 :
4581 : Returns: TRUE on success
4582 : */
4583 :
4584 : static BOOL
4585 : compile_regex(int options, int oldims, uschar **codeptr, const uschar **ptrptr,
4586 : int *errorcodeptr, BOOL lookbehind, int skipbytes, int *firstbyteptr,
4587 : int *reqbyteptr, branch_chain *bcptr, compile_data *cd, int *lengthptr)
4588 406 : {
4589 406 : const uschar *ptr = *ptrptr;
4590 406 : uschar *code = *codeptr;
4591 406 : uschar *last_branch = code;
4592 406 : uschar *start_bracket = code;
4593 406 : uschar *reverse_count = NULL;
4594 : int firstbyte, reqbyte;
4595 : int branchfirstbyte, branchreqbyte;
4596 : int length;
4597 : branch_chain bc;
4598 :
4599 406 : bc.outer = bcptr;
4600 406 : bc.current = code;
4601 :
4602 406 : firstbyte = reqbyte = REQ_UNSET;
4603 :
4604 : /* Accumulate the length for use in the pre-compile phase. Start with the
4605 : length of the BRA and KET and any extra bytes that are required at the
4606 : beginning. We accumulate in a local variable to save frequent testing of
4607 : lenthptr for NULL. We cannot do this by looking at the value of code at the
4608 : start and end of each alternative, because compiled items are discarded during
4609 : the pre-compile phase so that the work space is not exceeded. */
4610 :
4611 406 : length = 2 + 2*LINK_SIZE + skipbytes;
4612 :
4613 : /* WARNING: If the above line is changed for any reason, you must also change
4614 : the code that abstracts option settings at the start of the pattern and makes
4615 : them global. It tests the value of length for (2 + 2*LINK_SIZE) in the
4616 : pre-compile phase to find out whether anything has yet been compiled or not. */
4617 :
4618 : /* Offset is set zero to mark that this bracket is still open */
4619 :
4620 406 : PUT(code, 1, 0);
4621 406 : code += 1 + LINK_SIZE + skipbytes;
4622 :
4623 : /* Loop for each alternative branch */
4624 :
4625 : for (;;)
4626 : {
4627 : /* Handle a change of ims options at the start of the branch */
4628 :
4629 406 : if ((options & PCRE_IMS) != oldims)
4630 : {
4631 0 : *code++ = OP_OPT;
4632 0 : *code++ = options & PCRE_IMS;
4633 0 : length += 2;
4634 : }
4635 :
4636 : /* Set up dummy OP_REVERSE if lookbehind assertion */
4637 :
4638 406 : if (lookbehind)
4639 : {
4640 0 : *code++ = OP_REVERSE;
4641 0 : reverse_count = code;
4642 0 : PUTINC(code, 0, 0);
4643 0 : length += 1 + LINK_SIZE;
4644 : }
4645 :
4646 : /* Now compile the branch; in the pre-compile phase its length gets added
4647 : into the length. */
4648 :
4649 406 : if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,
4650 : &branchreqbyte, &bc, cd, (lengthptr == NULL)? NULL : &length))
4651 : {
4652 0 : *ptrptr = ptr;
4653 0 : return FALSE;
4654 : }
4655 :
4656 : /* In the real compile phase, there is some post-processing to be done. */
4657 :
4658 406 : if (lengthptr == NULL)
4659 : {
4660 : /* If this is the first branch, the firstbyte and reqbyte values for the
4661 : branch become the values for the regex. */
4662 :
4663 203 : if (*last_branch != OP_ALT)
4664 : {
4665 203 : firstbyte = branchfirstbyte;
4666 203 : reqbyte = branchreqbyte;
4667 : }
4668 :
4669 : /* If this is not the first branch, the first char and reqbyte have to
4670 : match the values from all the previous branches, except that if the
4671 : previous value for reqbyte didn't have REQ_VARY set, it can still match,
4672 : and we set REQ_VARY for the regex. */
4673 :
4674 : else
4675 : {
4676 : /* If we previously had a firstbyte, but it doesn't match the new branch,
4677 : we have to abandon the firstbyte for the regex, but if there was
4678 : previously no reqbyte, it takes on the value of the old firstbyte. */
4679 :
4680 0 : if (firstbyte >= 0 && firstbyte != branchfirstbyte)
4681 : {
4682 0 : if (reqbyte < 0) reqbyte = firstbyte;
4683 0 : firstbyte = REQ_NONE;
4684 : }
4685 :
4686 : /* If we (now or from before) have no firstbyte, a firstbyte from the
4687 : branch becomes a reqbyte if there isn't a branch reqbyte. */
4688 :
4689 0 : if (firstbyte < 0 && branchfirstbyte >= 0 && branchreqbyte < 0)
4690 0 : branchreqbyte = branchfirstbyte;
4691 :
4692 : /* Now ensure that the reqbytes match */
4693 :
4694 0 : if ((reqbyte & ~REQ_VARY) != (branchreqbyte & ~REQ_VARY))
4695 0 : reqbyte = REQ_NONE;
4696 0 : else reqbyte |= branchreqbyte; /* To "or" REQ_VARY */
4697 : }
4698 :
4699 : /* If lookbehind, check that this branch matches a fixed-length string, and
4700 : put the length into the OP_REVERSE item. Temporarily mark the end of the
4701 : branch with OP_END. */
4702 :
4703 203 : if (lookbehind)
4704 : {
4705 : int fixed_length;
4706 0 : *code = OP_END;
4707 0 : fixed_length = find_fixedlength(last_branch, options);
4708 : DPRINTF(("fixed length = %d\n", fixed_length));
4709 0 : if (fixed_length < 0)
4710 : {
4711 0 : *errorcodeptr = (fixed_length == -2)? ERR36 : ERR25;
4712 0 : *ptrptr = ptr;
4713 0 : return FALSE;
4714 : }
4715 0 : PUT(reverse_count, 0, fixed_length);
4716 : }
4717 : }
4718 :
4719 : /* Reached end of expression, either ')' or end of pattern. Go back through
4720 : the alternative branches and reverse the chain of offsets, with the field in
4721 : the BRA item now becoming an offset to the first alternative. If there are
4722 : no alternatives, it points to the end of the group. The length in the
4723 : terminating ket is always the length of the whole bracketed item. If any of
4724 : the ims options were changed inside the group, compile a resetting op-code
4725 : following, except at the very end of the pattern. Return leaving the pointer
4726 : at the terminating char. */
4727 :
4728 406 : if (*ptr != '|')
4729 : {
4730 406 : int branch_length = code - last_branch;
4731 : do
4732 : {
4733 406 : int prev_length = GET(last_branch, 1);
4734 406 : PUT(last_branch, 1, branch_length);
4735 406 : branch_length = prev_length;
4736 406 : last_branch -= branch_length;
4737 : }
4738 406 : while (branch_length > 0);
4739 :
4740 : /* Fill in the ket */
4741 :
4742 406 : *code = OP_KET;
4743 406 : PUT(code, 1, code - start_bracket);
4744 406 : code += 1 + LINK_SIZE;
4745 :
4746 : /* Resetting option if needed */
4747 :
4748 406 : if ((options & PCRE_IMS) != oldims && *ptr == ')')
4749 : {
4750 0 : *code++ = OP_OPT;
4751 0 : *code++ = oldims;
4752 0 : length += 2;
4753 : }
4754 :
4755 : /* Set values to pass back */
4756 :
4757 406 : *codeptr = code;
4758 406 : *ptrptr = ptr;
4759 406 : *firstbyteptr = firstbyte;
4760 406 : *reqbyteptr = reqbyte;
4761 406 : if (lengthptr != NULL) *lengthptr += length;
4762 406 : return TRUE;
4763 : }
4764 :
4765 : /* Another branch follows; insert an "or" node. Its length field points back
4766 : to the previous branch while the bracket remains open. At the end the chain
4767 : is reversed. It's done like this so that the start of the bracket has a
4768 : zero offset until it is closed, making it possible to detect recursion. */
4769 :
4770 0 : *code = OP_ALT;
4771 0 : PUT(code, 1, code - last_branch);
4772 0 : bc.current = last_branch = code;
4773 0 : code += 1 + LINK_SIZE;
4774 0 : ptr++;
4775 0 : length += 1 + LINK_SIZE;
4776 0 : }
4777 : /* Control never reaches here */
4778 : }
4779 :
4780 :
4781 :
4782 :
4783 : /*************************************************
4784 : * Check for anchored expression *
4785 : *************************************************/
4786 :
4787 : /* Try to find out if this is an anchored regular expression. Consider each
4788 : alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
4789 : all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
4790 : it's anchored. However, if this is a multiline pattern, then only OP_SOD
4791 : counts, since OP_CIRC can match in the middle.
4792 :
4793 : We can also consider a regex to be anchored if OP_SOM starts all its branches.
4794 : This is the code for \G, which means "match at start of match position, taking
4795 : into account the match offset".
4796 :
4797 : A branch is also implicitly anchored if it starts with .* and DOTALL is set,
4798 : because that will try the rest of the pattern at all possible matching points,
4799 : so there is no point trying again.... er ....
4800 :
4801 : .... except when the .* appears inside capturing parentheses, and there is a
4802 : subsequent back reference to those parentheses. We haven't enough information
4803 : to catch that case precisely.
4804 :
4805 : At first, the best we could do was to detect when .* was in capturing brackets
4806 : and the highest back reference was greater than or equal to that level.
4807 : However, by keeping a bitmap of the first 31 back references, we can catch some
4808 : of the more common cases more precisely.
4809 :
4810 : Arguments:
4811 : code points to start of expression (the bracket)
4812 : options points to the options setting
4813 : bracket_map a bitmap of which brackets we are inside while testing; this
4814 : handles up to substring 31; after that we just have to take
4815 : the less precise approach
4816 : backref_map the back reference bitmap
4817 :
4818 : Returns: TRUE or FALSE
4819 : */
4820 :
4821 : static BOOL
4822 : is_anchored(register const uschar *code, int *options, unsigned int bracket_map,
4823 : unsigned int backref_map)
4824 184 : {
4825 : do {
4826 : const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
4827 184 : options, PCRE_MULTILINE, FALSE);
4828 184 : register int op = *scode;
4829 :
4830 : /* Non-capturing brackets */
4831 :
4832 184 : if (op == OP_BRA)
4833 : {
4834 0 : if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
4835 : }
4836 :
4837 : /* Capturing brackets */
4838 :
4839 184 : else if (op == OP_CBRA)
4840 : {
4841 0 : int n = GET2(scode, 1+LINK_SIZE);
4842 0 : int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
4843 0 : if (!is_anchored(scode, options, new_map, backref_map)) return FALSE;
4844 : }
4845 :
4846 : /* Other brackets */
4847 :
4848 184 : else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
4849 : {
4850 0 : if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
4851 : }
4852 :
4853 : /* .* is not anchored unless DOTALL is set and it isn't in brackets that
4854 : are or may be referenced. */
4855 :
4856 184 : else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
4857 : op == OP_TYPEPOSSTAR) &&
4858 : (*options & PCRE_DOTALL) != 0)
4859 : {
4860 0 : if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
4861 : }
4862 :
4863 : /* Check for explicit anchoring */
4864 :
4865 184 : else if (op != OP_SOD && op != OP_SOM &&
4866 : ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
4867 2 : return FALSE;
4868 182 : code += GET(code, 1);
4869 : }
4870 182 : while (*code == OP_ALT); /* Loop for each alternative */
4871 182 : return TRUE;
4872 : }
4873 :
4874 :
4875 :
4876 : /*************************************************
4877 : * Check for starting with ^ or .* *
4878 : *************************************************/
4879 :
4880 : /* This is called to find out if every branch starts with ^ or .* so that
4881 : "first char" processing can be done to speed things up in multiline
4882 : matching and for non-DOTALL patterns that start with .* (which must start at
4883 : the beginning or after \n). As in the case of is_anchored() (see above), we
4884 : have to take account of back references to capturing brackets that contain .*
4885 : because in that case we can't make the assumption.
4886 :
4887 : Arguments:
4888 : code points to start of expression (the bracket)
4889 : bracket_map a bitmap of which brackets we are inside while testing; this
4890 : handles up to substring 31; after that we just have to take
4891 : the less precise approach
4892 : backref_map the back reference bitmap
4893 :
4894 : Returns: TRUE or FALSE
4895 : */
4896 :
4897 : static BOOL
4898 : is_startline(const uschar *code, unsigned int bracket_map,
4899 : unsigned int backref_map)
4900 1 : {
4901 : do {
4902 : const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
4903 1 : NULL, 0, FALSE);
4904 1 : register int op = *scode;
4905 :
4906 : /* Non-capturing brackets */
4907 :
4908 1 : if (op == OP_BRA)
4909 : {
4910 0 : if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
4911 : }
4912 :
4913 : /* Capturing brackets */
4914 :
4915 1 : else if (op == OP_CBRA)
4916 : {
4917 0 : int n = GET2(scode, 1+LINK_SIZE);
4918 0 : int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
4919 0 : if (!is_startline(scode, new_map, backref_map)) return FALSE;
4920 : }
4921 :
4922 : /* Other brackets */
4923 :
4924 1 : else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
4925 0 : { if (!is_startline(scode, bracket_map, backref_map)) return FALSE; }
4926 :
4927 : /* .* means "start at start or after \n" if it isn't in brackets that
4928 : may be referenced. */
4929 :
4930 1 : else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)
4931 : {
4932 0 : if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
4933 : }
4934 :
4935 : /* Check for explicit circumflex */
4936 :
4937 1 : else if (op != OP_CIRC) return FALSE;
4938 :
4939 : /* Move on to the next alternative */
4940 :
4941 0 : code += GET(code, 1);
4942 : }
4943 0 : while (*code == OP_ALT); /* Loop for each alternative */
4944 0 : return TRUE;
4945 : }
4946 :
4947 :
4948 :
4949 : /*************************************************
4950 : * Check for asserted fixed first char *
4951 : *************************************************/
4952 :
4953 : /* During compilation, the "first char" settings from forward assertions are
4954 : discarded, because they can cause conflicts with actual literals that follow.
4955 : However, if we end up without a first char setting for an unanchored pattern,
4956 : it is worth scanning the regex to see if there is an initial asserted first
4957 : char. If all branches start with the same asserted char, or with a bracket all
4958 : of whose alternatives start with the same asserted char (recurse ad lib), then
4959 : we return that char, otherwise -1.
4960 :
4961 : Arguments:
4962 : code points to start of expression (the bracket)
4963 : options pointer to the options (used to check casing changes)
4964 : inassert TRUE if in an assertion
4965 :
4966 : Returns: -1 or the fixed first char
4967 : */
4968 :
4969 : static int
4970 : find_firstassertedchar(const uschar *code, int *options, BOOL inassert)
4971 1 : {
4972 1 : register int c = -1;
4973 : do {
4974 : int d;
4975 : const uschar *scode =
4976 1 : first_significant_code(code + 1+LINK_SIZE, options, PCRE_CASELESS, TRUE);
4977 1 : register int op = *scode;
4978 :
4979 1 : switch(op)
4980 : {
4981 : default:
4982 1 : return -1;
4983 :
4984 : case OP_BRA:
4985 : case OP_CBRA:
4986 : case OP_ASSERT:
4987 : case OP_ONCE:
4988 : case OP_COND:
4989 0 : if ((d = find_firstassertedchar(scode, options, op == OP_ASSERT)) < 0)
4990 0 : return -1;
4991 0 : if (c < 0) c = d; else if (c != d) return -1;
4992 0 : break;
4993 :
4994 : case OP_EXACT: /* Fall through */
4995 0 : scode += 2;
4996 :
4997 : case OP_CHAR:
4998 : case OP_CHARNC:
4999 : case OP_PLUS:
5000 : case OP_MINPLUS:
5001 : case OP_POSPLUS:
5002 0 : if (!inassert) return -1;
5003 0 : if (c < 0)
5004 : {
5005 0 : c = scode[1];
5006 0 : if ((*options & PCRE_CASELESS) != 0) c |= REQ_CASELESS;
5007 : }
5008 0 : else if (c != scode[1]) return -1;
5009 : break;
5010 : }
5011 :
5012 0 : code += GET(code, 1);
5013 : }
5014 0 : while (*code == OP_ALT);
5015 0 : return c;
5016 : }
5017 :
5018 :
5019 :
5020 : /*************************************************
5021 : * Compile a Regular Expression *
5022 : *************************************************/
5023 :
5024 : /* This function takes a string and returns a pointer to a block of store
5025 : holding a compiled version of the expression. The original API for this
5026 : function had no error code return variable; it is retained for backwards
5027 : compatibility. The new function is given a new name.
5028 :
5029 : Arguments:
5030 : pattern the regular expression
5031 : options various option bits
5032 : errorcodeptr pointer to error code variable (pcre_compile2() only)
5033 : can be NULL if you don't want a code value
5034 : errorptr pointer to pointer to error text
5035 : erroroffset ptr offset in pattern where error was detected
5036 : tables pointer to character tables or NULL
5037 :
5038 : Returns: pointer to compiled data block, or NULL on error,
5039 : with errorptr and erroroffset set
5040 : */
5041 :
5042 : PCRE_DATA_SCOPE pcre *
5043 : pcre_compile(const char *pattern, int options, const char **errorptr,
5044 : int *erroroffset, const unsigned char *tables)
5045 184 : {
5046 184 : return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
5047 : }
5048 :
5049 :
5050 : PCRE_DATA_SCOPE pcre *
5051 : pcre_compile2(const char *pattern, int options, int *errorcodeptr,
5052 : const char **errorptr, int *erroroffset, const unsigned char *tables)
5053 184 : {
5054 : real_pcre *re;
5055 184 : int length = 1; /* For final END opcode */
5056 : int firstbyte, reqbyte, newline;
5057 184 : int errorcode = 0;
5058 : #ifdef SUPPORT_UTF8
5059 : BOOL utf8;
5060 : #endif
5061 : size_t size;
5062 : uschar *code;
5063 : const uschar *codestart;
5064 : const uschar *ptr;
5065 : compile_data compile_block;
5066 184 : compile_data *cd = &compile_block;
5067 :
5068 : /* This space is used for "compiling" into during the first phase, when we are
5069 : computing the amount of memory that is needed. Compiled items are thrown away
5070 : as soon as possible, so that a fairly large buffer should be sufficient for
5071 : this purpose. The same space is used in the second phase for remembering where
5072 : to fill in forward references to subpatterns. */
5073 :
5074 : uschar cworkspace[COMPILE_WORK_SIZE];
5075 :
5076 :
5077 : /* Set this early so that early errors get offset 0. */
5078 :
5079 184 : ptr = (const uschar *)pattern;
5080 :
5081 : /* We can't pass back an error message if errorptr is NULL; I guess the best we
5082 : can do is just return NULL, but we can set a code value if there is a code
5083 : pointer. */
5084 :
5085 184 : if (errorptr == NULL)
5086 : {
5087 0 : if (errorcodeptr != NULL) *errorcodeptr = 99;
5088 0 : return NULL;
5089 : }
5090 :
5091 184 : *errorptr = NULL;
5092 184 : if (errorcodeptr != NULL) *errorcodeptr = ERR0;
5093 :
5094 : /* However, we can give a message for this error */
5095 :
5096 184 : if (erroroffset == NULL)
5097 : {
5098 0 : errorcode = ERR16;
5099 0 : goto PCRE_EARLY_ERROR_RETURN;
5100 : }
5101 :
5102 184 : *erroroffset = 0;
5103 :
5104 : /* Can't support UTF8 unless PCRE has been compiled to include the code. */
5105 :
5106 : #ifdef SUPPORT_UTF8
5107 184 : utf8 = (options & PCRE_UTF8) != 0;
5108 184 : if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
5109 : (*erroroffset = _pcre_valid_utf8((uschar *)pattern, -1)) >= 0)
5110 : {
5111 0 : errorcode = ERR44;
5112 0 : goto PCRE_UTF8_ERROR_RETURN;
5113 : }
5114 : #else
5115 : if ((options & PCRE_UTF8) != 0)
5116 : {
5117 : errorcode = ERR32;
5118 : goto PCRE_EARLY_ERROR_RETURN;
5119 : }
5120 : #endif
5121 :
5122 184 : if ((options & ~PUBLIC_OPTIONS) != 0)
5123 : {
5124 0 : errorcode = ERR17;
5125 0 : goto PCRE_EARLY_ERROR_RETURN;
5126 : }
5127 :
5128 : /* Set up pointers to the individual character tables */
5129 :
5130 184 : if (tables == NULL) tables = _pcre_default_tables;
5131 184 : cd->lcc = tables + lcc_offset;
5132 184 : cd->fcc = tables + fcc_offset;
5133 184 : cd->cbits = tables + cbits_offset;
5134 184 : cd->ctypes = tables + ctypes_offset;
5135 :
5136 : /* Handle different types of newline. The three bits give seven cases. The
5137 : current code allows for fixed one- or two-byte sequences, plus "any". */
5138 :
5139 184 : switch (options & (PCRE_NEWLINE_CRLF | PCRE_NEWLINE_ANY))
5140 : {
5141 184 : case 0: newline = NEWLINE; break; /* Compile-time default */
5142 0 : case PCRE_NEWLINE_CR: newline = '\r'; break;
5143 0 : case PCRE_NEWLINE_LF: newline = '\n'; break;
5144 : case PCRE_NEWLINE_CR+
5145 0 : PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;
5146 0 : case PCRE_NEWLINE_ANY: newline = -1; break;
5147 0 : default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;
5148 : }
5149 :
5150 184 : if (newline < 0)
5151 : {
5152 0 : cd->nltype = NLTYPE_ANY;
5153 : }
5154 : else
5155 : {
5156 184 : cd->nltype = NLTYPE_FIXED;
5157 184 : if (newline > 255)
5158 : {
5159 0 : cd->nllen = 2;
5160 0 : cd->nl[0] = (newline >> 8) & 255;
5161 0 : cd->nl[1] = newline & 255;
5162 : }
5163 : else
5164 : {
5165 184 : cd->nllen = 1;
5166 184 : cd->nl[0] = newline;
5167 : }
5168 : }
5169 :
5170 : /* Maximum back reference and backref bitmap. The bitmap records up to 31 back
5171 : references to help in deciding whether (.*) can be treated as anchored or not.
5172 : */
5173 :
5174 184 : cd->top_backref = 0;
5175 184 : cd->backref_map = 0;
5176 :
5177 : /* Reflect pattern for debugging output */
5178 :
5179 : DPRINTF(("------------------------------------------------------------------\n"));
5180 : DPRINTF(("%s\n", pattern));
5181 :
5182 : /* Pretend to compile the pattern while actually just accumulating the length
5183 : of memory required. This behaviour is triggered by passing a non-NULL final
5184 : argument to compile_regex(). We pass a block of workspace (cworkspace) for it
5185 : to compile parts of the pattern into; the compiled code is discarded when it is
5186 : no longer needed, so hopefully this workspace will never overflow, though there
5187 : is a test for its doing so. */
5188 :
5189 184 : cd->bracount = 0;
5190 184 : cd->names_found = 0;
5191 184 : cd->name_entry_size = 0;
5192 184 : cd->name_table = NULL;
5193 184 : cd->start_workspace = cworkspace;
5194 184 : cd->start_code = cworkspace;
5195 184 : cd->hwm = cworkspace;
5196 184 : cd->start_pattern = (const uschar *)pattern;
5197 184 : cd->end_pattern = (const uschar *)(pattern + strlen(pattern));
5198 184 : cd->req_varyopt = 0;
5199 184 : cd->nopartial = FALSE;
5200 184 : cd->external_options = options;
5201 :
5202 : /* Now do the pre-compile. On error, errorcode will be set non-zero, so we
5203 : don't need to look at the result of the function here. The initial options have
5204 : been put into the cd block so that they can be changed if an option setting is
5205 : found within the regex right at the beginning. Bringing initial option settings
5206 : outside can help speed up starting point checks. */
5207 :
5208 184 : code = cworkspace;
5209 184 : *code = OP_BRA;
5210 184 : (void)compile_regex(cd->external_options, cd->external_options & PCRE_IMS,
5211 : &code, &ptr, &errorcode, FALSE, 0, &firstbyte, &reqbyte, NULL, cd, &length);
5212 184 : if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;
5213 :
5214 : DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
5215 : cd->hwm - cworkspace));
5216 :
5217 184 : if (length > MAX_PATTERN_SIZE)
5218 : {
5219 0 : errorcode = ERR20;
5220 0 : goto PCRE_EARLY_ERROR_RETURN;
5221 : }
5222 :
5223 : /* Compute the size of data block needed and get it, either from malloc or
5224 : externally provided function. Integer overflow should no longer be possible
5225 : because nowadays we limit the maximum value of cd->names_found and
5226 : cd->name_entry_size. */
5227 :
5228 184 : size = length + sizeof(real_pcre) + cd->names_found * (cd->name_entry_size + 3);
5229 184 : re = (real_pcre *)(pcre_malloc)(size);
5230 :
5231 184 : if (re == NULL)
5232 : {
5233 0 : errorcode = ERR21;
5234 0 : goto PCRE_EARLY_ERROR_RETURN;
5235 : }
5236 :
5237 : /* Put in the magic number, and save the sizes, initial options, and character
5238 : table pointer. NULL is used for the default character tables. The nullpad field
5239 : is at the end; it's there to help in the case when a regex compiled on a system
5240 : with 4-byte pointers is run on another with 8-byte pointers. */
5241 :
5242 184 : re->magic_number = MAGIC_NUMBER;
5243 184 : re->size = size;
5244 184 : re->options = cd->external_options;
5245 184 : re->dummy1 = 0;
5246 184 : re->first_byte = 0;
5247 184 : re->req_byte = 0;
5248 184 : re->name_table_offset = sizeof(real_pcre);
5249 184 : re->name_entry_size = cd->name_entry_size;
5250 184 : re->name_count = cd->names_found;
5251 184 : re->ref_count = 0;
5252 184 : re->tables = (tables == _pcre_default_tables)? NULL : tables;
5253 184 : re->nullpad = NULL;
5254 :
5255 : /* The starting points of the name/number translation table and of the code are
5256 : passed around in the compile data block. The start/end pattern and initial
5257 : options are already set from the pre-compile phase, as is the name_entry_size
5258 : field. Reset the bracket count and the names_found field. Also reset the hwm
5259 : field; this time it's used for remembering forward references to subpatterns.
5260 : */
5261 :
5262 184 : cd->bracount = 0;
5263 184 : cd->names_found = 0;
5264 184 : cd->name_table = (uschar *)re + re->name_table_offset;
5265 184 : codestart = cd->name_table + re->name_entry_size * re->name_count;
5266 184 : cd->start_code = codestart;
5267 184 : cd->hwm = cworkspace;
5268 184 : cd->req_varyopt = 0;
5269 184 : cd->nopartial = FALSE;
5270 :
5271 : /* Set up a starting, non-extracting bracket, then compile the expression. On
5272 : error, errorcode will be set non-zero, so we don't need to look at the result
5273 : of the function here. */
5274 :
5275 184 : ptr = (const uschar *)pattern;
5276 184 : code = (uschar *)codestart;
5277 184 : *code = OP_BRA;
5278 184 : (void)compile_regex(re->options, re->options & PCRE_IMS, &code, &ptr,
5279 : &errorcode, FALSE, 0, &firstbyte, &reqbyte, NULL, cd, NULL);
5280 184 : re->top_bracket = cd->bracount;
5281 184 : re->top_backref = cd->top_backref;
5282 :
5283 184 : if (cd->nopartial) re->options |= PCRE_NOPARTIAL;
5284 :
5285 : /* If not reached end of pattern on success, there's an excess bracket. */
5286 :
5287 184 : if (errorcode == 0 && *ptr != 0) errorcode = ERR22;
5288 :
5289 : /* Fill in the terminating state and check for disastrous overflow, but
5290 : if debugging, leave the test till after things are printed out. */
5291 :
5292 184 : *code++ = OP_END;
5293 :
5294 : #ifndef DEBUG
5295 184 : if (code - codestart > length) errorcode = ERR23;
5296 : #endif
5297 :
5298 : /* Fill in any forward references that are required. */
5299 :
5300 368 : while (errorcode == 0 && cd->hwm > cworkspace)
5301 : {
5302 : int offset, recno;
5303 : const uschar *groupptr;
5304 0 : cd->hwm -= LINK_SIZE;
5305 0 : offset = GET(cd->hwm, 0);
5306 0 : recno = GET(codestart, offset);
5307 0 : groupptr = find_bracket(codestart, (re->options & PCRE_UTF8) != 0, recno);
5308 0 : if (groupptr == NULL) errorcode = ERR53;
5309 0 : else PUT(((uschar *)codestart), offset, groupptr - codestart);
5310 : }
5311 :
5312 : /* Give an error if there's back reference to a non-existent capturing
5313 : subpattern. */
5314 :
5315 184 : if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;
5316 :
5317 : /* Failed to compile, or error while post-processing */
5318 :
5319 184 : if (errorcode != 0)
5320 : {
5321 0 : (pcre_free)(re);
5322 0 : PCRE_EARLY_ERROR_RETURN:
5323 0 : *erroroffset = ptr - (const uschar *)pattern;
5324 : #ifdef SUPPORT_UTF8
5325 0 : PCRE_UTF8_ERROR_RETURN:
5326 : #endif
5327 0 : *errorptr = error_texts[errorcode];
5328 0 : if (errorcodeptr != NULL) *errorcodeptr = errorcode;
5329 0 : return NULL;
5330 : }
5331 :
5332 : /* If the anchored option was not passed, set the flag if we can determine that
5333 : the pattern is anchored by virtue of ^ characters or \A or anything else (such
5334 : as starting with .* when DOTALL is set).
5335 :
5336 : Otherwise, if we know what the first byte has to be, save it, because that
5337 : speeds up unanchored matches no end. If not, see if we can set the
5338 : PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
5339 : start with ^. and also when all branches start with .* for non-DOTALL matches.
5340 : */
5341 :
5342 184 : if ((re->options & PCRE_ANCHORED) == 0)
5343 : {
5344 184 : int temp_options = re->options; /* May get changed during these scans */
5345 184 : if (is_anchored(codestart, &temp_options, 0, cd->backref_map))
5346 182 : re->options |= PCRE_ANCHORED;
5347 : else
5348 : {
5349 2 : if (firstbyte < 0)
5350 1 : firstbyte = find_firstassertedchar(codestart, &temp_options, FALSE);
5351 2 : if (firstbyte >= 0) /* Remove caseless flag for non-caseable chars */
5352 : {
5353 1 : int ch = firstbyte & 255;
5354 1 : re->first_byte = ((firstbyte & REQ_CASELESS) != 0 &&
5355 : cd->fcc[ch] == ch)? ch : firstbyte;
5356 1 : re->options |= PCRE_FIRSTSET;
5357 : }
5358 1 : else if (is_startline(codestart, 0, cd->backref_map))
5359 0 : re->options |= PCRE_STARTLINE;
5360 : }
5361 : }
5362 :
5363 : /* For an anchored pattern, we use the "required byte" only if it follows a
5364 : variable length item in the regex. Remove the caseless flag for non-caseable
5365 : bytes. */
5366 :
5367 184 : if (reqbyte >= 0 &&
5368 : ((re->options & PCRE_ANCHORED) == 0 || (reqbyte & REQ_VARY) != 0))
5369 : {
5370 107 : int ch = reqbyte & 255;
5371 107 : re->req_byte = ((reqbyte & REQ_CASELESS) != 0 &&
5372 : cd->fcc[ch] == ch)? (reqbyte & ~REQ_CASELESS) : reqbyte;
5373 107 : re->options |= PCRE_REQCHSET;
5374 : }
5375 :
5376 : /* Print out the compiled data if debugging is enabled. This is never the
5377 : case when building a production library. */
5378 :
5379 : #ifdef DEBUG
5380 :
5381 : printf("Length = %d top_bracket = %d top_backref = %d\n",
5382 : length, re->top_bracket, re->top_backref);
5383 :
5384 : if (re->options != 0)
5385 : {
5386 : printf("%s%s%s%s%s%s%s%s%s\n",
5387 : ((re->options & PCRE_NOPARTIAL) != 0)? "nopartial " : "",
5388 : ((re->options & PCRE_ANCHORED) != 0)? "anchored " : "",
5389 : ((re->options & PCRE_CASELESS) != 0)? "caseless " : "",
5390 : ((re->options & PCRE_EXTENDED) != 0)? "extended " : "",
5391 : ((re->options & PCRE_MULTILINE) != 0)? "multiline " : "",
5392 : ((re->options & PCRE_DOTALL) != 0)? "dotall " : "",
5393 : ((re->options & PCRE_DOLLAR_ENDONLY) != 0)? "endonly " : "",
5394 : ((re->options & PCRE_EXTRA) != 0)? "extra " : "",
5395 : ((re->options & PCRE_UNGREEDY) != 0)? "ungreedy " : "");
5396 : }
5397 :
5398 : if ((re->options & PCRE_FIRSTSET) != 0)
5399 : {
5400 : int ch = re->first_byte & 255;
5401 : const char *caseless = ((re->first_byte & REQ_CASELESS) == 0)?
5402 : "" : " (caseless)";
5403 : if (isprint(ch)) printf("First char = %c%s\n", ch, caseless);
5404 : else printf("First char = \\x%02x%s\n", ch, caseless);
5405 : }
5406 :
5407 : if ((re->options & PCRE_REQCHSET) != 0)
5408 : {
5409 : int ch = re->req_byte & 255;
5410 : const char *caseless = ((re->req_byte & REQ_CASELESS) == 0)?
5411 : "" : " (caseless)";
5412 : if (isprint(ch)) printf("Req char = %c%s\n", ch, caseless);
5413 : else printf("Req char = \\x%02x%s\n", ch, caseless);
5414 : }
5415 :
5416 : pcre_printint(re, stdout);
5417 :
5418 : /* This check is done here in the debugging case so that the code that
5419 : was compiled can be seen. */
5420 :
5421 : if (code - codestart > length)
5422 : {
5423 : (pcre_free)(re);
5424 : *errorptr = error_texts[ERR23];
5425 : *erroroffset = ptr - (uschar *)pattern;
5426 : if (errorcodeptr != NULL) *errorcodeptr = ERR23;
5427 : return NULL;
5428 : }
5429 : #endif /* DEBUG */
5430 :
5431 184 : return (pcre *)re;
5432 : }
5433 :
5434 : /* End of pcre_compile.c */
|
