/[pcre]/code/trunk/pcre_compile.c
ViewVC logotype

Contents of /code/trunk/pcre_compile.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 335 - (hide annotations) (download)
Sat Apr 12 14:36:14 2008 UTC (6 years, 6 months ago) by ph10
File MIME type: text/plain
File size: 200753 byte(s)
Do not discard subpatterns with {0} quantifiers, as they may be called as 
subroutines.

1 nigel 77 /*************************************************
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 ph10 305 Copyright (c) 1997-2008 University of Cambridge
10 nigel 77
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 ph10 200 #ifdef HAVE_CONFIG_H
46 ph10 236 #include "config.h"
47 ph10 200 #endif
48 ph10 199
49 nigel 93 #define NLBLOCK cd /* Block containing newline information */
50     #define PSSTART start_pattern /* Field containing processed string start */
51     #define PSEND end_pattern /* Field containing processed string end */
52    
53 nigel 77 #include "pcre_internal.h"
54    
55    
56 nigel 85 /* When DEBUG is defined, we need the pcre_printint() function, which is also
57     used by pcretest. DEBUG is not defined when building a production library. */
58    
59     #ifdef DEBUG
60     #include "pcre_printint.src"
61     #endif
62    
63    
64 ph10 178 /* Macro for setting individual bits in class bitmaps. */
65    
66     #define SETBIT(a,b) a[b/8] |= (1 << (b%8))
67    
68 ph10 202 /* Maximum length value to check against when making sure that the integer that
69     holds the compiled pattern length does not overflow. We make it a bit less than
70     INT_MAX to allow for adding in group terminating bytes, so that we don't have
71     to check them every time. */
72 ph10 178
73 ph10 202 #define OFLOW_MAX (INT_MAX - 20)
74    
75    
76 nigel 77 /*************************************************
77     * Code parameters and static tables *
78     *************************************************/
79    
80 nigel 93 /* This value specifies the size of stack workspace that is used during the
81     first pre-compile phase that determines how much memory is required. The regex
82     is partly compiled into this space, but the compiled parts are discarded as
83     soon as they can be, so that hopefully there will never be an overrun. The code
84     does, however, check for an overrun. The largest amount I've seen used is 218,
85     so this number is very generous.
86 nigel 77
87 nigel 93 The same workspace is used during the second, actual compile phase for
88     remembering forward references to groups so that they can be filled in at the
89     end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE
90     is 4 there is plenty of room. */
91 nigel 77
92 nigel 93 #define COMPILE_WORK_SIZE (4096)
93 nigel 77
94 nigel 93
95 nigel 77 /* Table for handling escaped characters in the range '0'-'z'. Positive returns
96     are simple data values; negative values are for special things like \d and so
97     on. Zero means further processing is needed (for things like \x), or the escape
98     is invalid. */
99    
100 ph10 97 #ifndef EBCDIC /* This is the "normal" table for ASCII systems */
101 nigel 77 static const short int escapes[] = {
102     0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 7 */
103     0, 0, ':', ';', '<', '=', '>', '?', /* 8 - ? */
104     '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E, 0, -ESC_G, /* @ - G */
105 ph10 178 -ESC_H, 0, 0, -ESC_K, 0, 0, 0, 0, /* H - O */
106     -ESC_P, -ESC_Q, -ESC_R, -ESC_S, 0, 0, -ESC_V, -ESC_W, /* P - W */
107 nigel 77 -ESC_X, 0, -ESC_Z, '[', '\\', ']', '^', '_', /* X - _ */
108     '`', 7, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0, /* ` - g */
109 ph10 178 -ESC_h, 0, 0, -ESC_k, 0, 0, ESC_n, 0, /* h - o */
110     -ESC_p, 0, ESC_r, -ESC_s, ESC_tee, 0, -ESC_v, -ESC_w, /* p - w */
111 nigel 77 0, 0, -ESC_z /* x - z */
112     };
113    
114 ph10 97 #else /* This is the "abnormal" table for EBCDIC systems */
115 nigel 77 static const short int escapes[] = {
116     /* 48 */ 0, 0, 0, '.', '<', '(', '+', '|',
117     /* 50 */ '&', 0, 0, 0, 0, 0, 0, 0,
118     /* 58 */ 0, 0, '!', '$', '*', ')', ';', '~',
119     /* 60 */ '-', '/', 0, 0, 0, 0, 0, 0,
120     /* 68 */ 0, 0, '|', ',', '%', '_', '>', '?',
121     /* 70 */ 0, 0, 0, 0, 0, 0, 0, 0,
122     /* 78 */ 0, '`', ':', '#', '@', '\'', '=', '"',
123     /* 80 */ 0, 7, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0,
124 ph10 178 /* 88 */-ESC_h, 0, 0, '{', 0, 0, 0, 0,
125 nigel 93 /* 90 */ 0, 0, -ESC_k, 'l', 0, ESC_n, 0, -ESC_p,
126 nigel 77 /* 98 */ 0, ESC_r, 0, '}', 0, 0, 0, 0,
127 ph10 178 /* A0 */ 0, '~', -ESC_s, ESC_tee, 0,-ESC_v, -ESC_w, 0,
128 nigel 77 /* A8 */ 0,-ESC_z, 0, 0, 0, '[', 0, 0,
129     /* B0 */ 0, 0, 0, 0, 0, 0, 0, 0,
130     /* B8 */ 0, 0, 0, 0, 0, ']', '=', '-',
131     /* C0 */ '{',-ESC_A, -ESC_B, -ESC_C, -ESC_D,-ESC_E, 0, -ESC_G,
132 ph10 178 /* C8 */-ESC_H, 0, 0, 0, 0, 0, 0, 0,
133 ph10 195 /* D0 */ '}', 0, -ESC_K, 0, 0, 0, 0, -ESC_P,
134 nigel 93 /* D8 */-ESC_Q,-ESC_R, 0, 0, 0, 0, 0, 0,
135 ph10 178 /* E0 */ '\\', 0, -ESC_S, 0, 0,-ESC_V, -ESC_W, -ESC_X,
136 nigel 77 /* E8 */ 0,-ESC_Z, 0, 0, 0, 0, 0, 0,
137     /* F0 */ 0, 0, 0, 0, 0, 0, 0, 0,
138     /* F8 */ 0, 0, 0, 0, 0, 0, 0, 0
139     };
140     #endif
141    
142    
143 ph10 243 /* Table of special "verbs" like (*PRUNE). This is a short table, so it is
144     searched linearly. Put all the names into a single string, in order to reduce
145 ph10 240 the number of relocations when a shared library is dynamically linked. */
146 ph10 210
147     typedef struct verbitem {
148     int len;
149     int op;
150 ph10 211 } verbitem;
151 ph10 210
152 ph10 240 static const char verbnames[] =
153 ph10 243 "ACCEPT\0"
154     "COMMIT\0"
155     "F\0"
156     "FAIL\0"
157     "PRUNE\0"
158     "SKIP\0"
159     "THEN";
160 ph10 240
161 ph10 327 static const verbitem verbs[] = {
162 ph10 240 { 6, OP_ACCEPT },
163     { 6, OP_COMMIT },
164     { 1, OP_FAIL },
165     { 4, OP_FAIL },
166     { 5, OP_PRUNE },
167     { 4, OP_SKIP },
168     { 4, OP_THEN }
169 ph10 210 };
170    
171 ph10 327 static const int verbcount = sizeof(verbs)/sizeof(verbitem);
172 ph10 210
173    
174 ph10 243 /* Tables of names of POSIX character classes and their lengths. The names are
175     now all in a single string, to reduce the number of relocations when a shared
176 ph10 240 library is dynamically loaded. The list of lengths is terminated by a zero
177     length entry. The first three must be alpha, lower, upper, as this is assumed
178     for handling case independence. */
179 nigel 77
180 ph10 240 static const char posix_names[] =
181 ph10 243 "alpha\0" "lower\0" "upper\0" "alnum\0" "ascii\0" "blank\0"
182     "cntrl\0" "digit\0" "graph\0" "print\0" "punct\0" "space\0"
183 ph10 240 "word\0" "xdigit";
184 nigel 77
185     static const uschar posix_name_lengths[] = {
186     5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
187    
188 nigel 87 /* Table of class bit maps for each POSIX class. Each class is formed from a
189     base map, with an optional addition or removal of another map. Then, for some
190     classes, there is some additional tweaking: for [:blank:] the vertical space
191     characters are removed, and for [:alpha:] and [:alnum:] the underscore
192     character is removed. The triples in the table consist of the base map offset,
193     second map offset or -1 if no second map, and a non-negative value for map
194     addition or a negative value for map subtraction (if there are two maps). The
195     absolute value of the third field has these meanings: 0 => no tweaking, 1 =>
196     remove vertical space characters, 2 => remove underscore. */
197 nigel 77
198     static const int posix_class_maps[] = {
199 nigel 87 cbit_word, cbit_digit, -2, /* alpha */
200     cbit_lower, -1, 0, /* lower */
201     cbit_upper, -1, 0, /* upper */
202     cbit_word, -1, 2, /* alnum - word without underscore */
203     cbit_print, cbit_cntrl, 0, /* ascii */
204     cbit_space, -1, 1, /* blank - a GNU extension */
205     cbit_cntrl, -1, 0, /* cntrl */
206     cbit_digit, -1, 0, /* digit */
207     cbit_graph, -1, 0, /* graph */
208     cbit_print, -1, 0, /* print */
209     cbit_punct, -1, 0, /* punct */
210     cbit_space, -1, 0, /* space */
211     cbit_word, -1, 0, /* word - a Perl extension */
212     cbit_xdigit,-1, 0 /* xdigit */
213 nigel 77 };
214    
215    
216 nigel 93 #define STRING(a) # a
217     #define XSTRING(s) STRING(s)
218    
219 nigel 77 /* The texts of compile-time error messages. These are "char *" because they
220 nigel 93 are passed to the outside world. Do not ever re-use any error number, because
221     they are documented. Always add a new error instead. Messages marked DEAD below
222 ph10 243 are no longer used. This used to be a table of strings, but in order to reduce
223     the number of relocations needed when a shared library is loaded dynamically,
224     it is now one long string. We cannot use a table of offsets, because the
225     lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we
226     simply count through to the one we want - this isn't a performance issue
227 ph10 240 because these strings are used only when there is a compilation error. */
228 nigel 77
229 ph10 240 static const char error_texts[] =
230     "no error\0"
231     "\\ at end of pattern\0"
232     "\\c at end of pattern\0"
233     "unrecognized character follows \\\0"
234     "numbers out of order in {} quantifier\0"
235 nigel 77 /* 5 */
236 ph10 240 "number too big in {} quantifier\0"
237     "missing terminating ] for character class\0"
238     "invalid escape sequence in character class\0"
239     "range out of order in character class\0"
240     "nothing to repeat\0"
241 nigel 77 /* 10 */
242 ph10 240 "operand of unlimited repeat could match the empty string\0" /** DEAD **/
243     "internal error: unexpected repeat\0"
244 ph10 269 "unrecognized character after (? or (?-\0"
245 ph10 240 "POSIX named classes are supported only within a class\0"
246     "missing )\0"
247 nigel 77 /* 15 */
248 ph10 240 "reference to non-existent subpattern\0"
249     "erroffset passed as NULL\0"
250     "unknown option bit(s) set\0"
251     "missing ) after comment\0"
252     "parentheses nested too deeply\0" /** DEAD **/
253 nigel 77 /* 20 */
254 ph10 240 "regular expression is too large\0"
255     "failed to get memory\0"
256     "unmatched parentheses\0"
257     "internal error: code overflow\0"
258     "unrecognized character after (?<\0"
259 nigel 77 /* 25 */
260 ph10 240 "lookbehind assertion is not fixed length\0"
261     "malformed number or name after (?(\0"
262     "conditional group contains more than two branches\0"
263     "assertion expected after (?(\0"
264     "(?R or (?[+-]digits must be followed by )\0"
265 nigel 77 /* 30 */
266 ph10 240 "unknown POSIX class name\0"
267     "POSIX collating elements are not supported\0"
268     "this version of PCRE is not compiled with PCRE_UTF8 support\0"
269     "spare error\0" /** DEAD **/
270     "character value in \\x{...} sequence is too large\0"
271 nigel 77 /* 35 */
272 ph10 240 "invalid condition (?(0)\0"
273     "\\C not allowed in lookbehind assertion\0"
274     "PCRE does not support \\L, \\l, \\N, \\U, or \\u\0"
275     "number after (?C is > 255\0"
276     "closing ) for (?C expected\0"
277 nigel 77 /* 40 */
278 ph10 240 "recursive call could loop indefinitely\0"
279     "unrecognized character after (?P\0"
280     "syntax error in subpattern name (missing terminator)\0"
281     "two named subpatterns have the same name\0"
282     "invalid UTF-8 string\0"
283 nigel 77 /* 45 */
284 ph10 240 "support for \\P, \\p, and \\X has not been compiled\0"
285     "malformed \\P or \\p sequence\0"
286     "unknown property name after \\P or \\p\0"
287     "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)\0"
288     "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")\0"
289 nigel 91 /* 50 */
290 ph10 240 "repeated subpattern is too long\0" /** DEAD **/
291     "octal value is greater than \\377 (not in UTF-8 mode)\0"
292     "internal error: overran compiling workspace\0"
293     "internal error: previously-checked referenced subpattern not found\0"
294     "DEFINE group contains more than one branch\0"
295 nigel 93 /* 55 */
296 ph10 240 "repeating a DEFINE group is not allowed\0"
297     "inconsistent NEWLINE options\0"
298 ph10 333 "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
299     "a numbered reference must not be zero\0"
300 ph10 240 "(*VERB) with an argument is not supported\0"
301 ph10 211 /* 60 */
302 ph10 240 "(*VERB) not recognized\0"
303 ph10 268 "number is too big\0"
304 ph10 272 "subpattern name expected\0"
305 ph10 269 "digit expected after (?+";
306 nigel 77
307    
308     /* Table to identify digits and hex digits. This is used when compiling
309     patterns. Note that the tables in chartables are dependent on the locale, and
310     may mark arbitrary characters as digits - but the PCRE compiling code expects
311     to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
312     a private table here. It costs 256 bytes, but it is a lot faster than doing
313     character value tests (at least in some simple cases I timed), and in some
314     applications one wants PCRE to compile efficiently as well as match
315     efficiently.
316    
317     For convenience, we use the same bit definitions as in chartables:
318    
319     0x04 decimal digit
320     0x08 hexadecimal digit
321    
322     Then we can use ctype_digit and ctype_xdigit in the code. */
323    
324 ph10 97 #ifndef EBCDIC /* This is the "normal" case, for ASCII systems */
325 nigel 77 static const unsigned char digitab[] =
326     {
327     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */
328     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */
329     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */
330     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
331     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - ' */
332     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ( - / */
333     0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 */
334     0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /* 8 - ? */
335     0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* @ - G */
336     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H - O */
337     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* P - W */
338     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* X - _ */
339     0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* ` - g */
340     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h - o */
341     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* p - w */
342     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* x -127 */
343     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
344     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
345     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
346     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
347     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
348     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
349     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
350     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
351     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
352     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
353     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
354     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
355     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
356     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
357     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
358     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
359    
360 ph10 97 #else /* This is the "abnormal" case, for EBCDIC systems */
361 nigel 77 static const unsigned char digitab[] =
362     {
363     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 0 */
364     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */
365     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 10 */
366     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
367     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 32- 39 20 */
368     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */
369     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 30 */
370     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */
371     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 40 */
372     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 72- | */
373     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 50 */
374 ph10 97 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 88- 95 */
375 nigel 77 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 60 */
376     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ? */
377     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
378     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */
379     0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g 80 */
380     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */
381     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p 90 */
382     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */
383     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x A0 */
384     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */
385     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 B0 */
386     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
387     0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* { - G C0 */
388     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */
389     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* } - P D0 */
390     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */
391     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* \ - X E0 */
392     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */
393     0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 F0 */
394     0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */
395    
396     static const unsigned char ebcdic_chartab[] = { /* chartable partial dup */
397     0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 0- 7 */
398     0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /* 8- 15 */
399     0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 16- 23 */
400     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
401     0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 32- 39 */
402     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */
403     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 */
404     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */
405     0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 */
406     0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /* 72- | */
407     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 */
408 ph10 97 0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /* 88- 95 */
409 nigel 77 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 */
410     0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ? */
411     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
412     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */
413     0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g */
414     0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */
415     0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p */
416     0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */
417     0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x */
418     0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */
419     0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 */
420     0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
421     0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* { - G */
422     0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */
423     0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* } - P */
424     0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */
425     0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* \ - X */
426     0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */
427     0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */
428     0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */
429     #endif
430    
431    
432     /* Definition to allow mutual recursion */
433    
434     static BOOL
435 ph10 180 compile_regex(int, int, uschar **, const uschar **, int *, BOOL, BOOL, int,
436 ph10 175 int *, int *, branch_chain *, compile_data *, int *);
437 nigel 77
438    
439    
440     /*************************************************
441 ph10 240 * Find an error text *
442     *************************************************/
443    
444 ph10 243 /* The error texts are now all in one long string, to save on relocations. As
445     some of the text is of unknown length, we can't use a table of offsets.
446     Instead, just count through the strings. This is not a performance issue
447 ph10 240 because it happens only when there has been a compilation error.
448    
449     Argument: the error number
450     Returns: pointer to the error string
451     */
452    
453     static const char *
454     find_error_text(int n)
455     {
456     const char *s = error_texts;
457 ph10 243 for (; n > 0; n--) while (*s++ != 0);
458 ph10 240 return s;
459     }
460    
461    
462     /*************************************************
463 nigel 77 * Handle escapes *
464     *************************************************/
465    
466     /* This function is called when a \ has been encountered. It either returns a
467     positive value for a simple escape such as \n, or a negative value which
468 nigel 93 encodes one of the more complicated things such as \d. A backreference to group
469     n is returned as -(ESC_REF + n); ESC_REF is the highest ESC_xxx macro. When
470     UTF-8 is enabled, a positive value greater than 255 may be returned. On entry,
471     ptr is pointing at the \. On exit, it is on the final character of the escape
472     sequence.
473 nigel 77
474     Arguments:
475     ptrptr points to the pattern position pointer
476     errorcodeptr points to the errorcode variable
477     bracount number of previous extracting brackets
478     options the options bits
479     isclass TRUE if inside a character class
480    
481     Returns: zero or positive => a data character
482     negative => a special escape sequence
483 ph10 213 on error, errorcodeptr is set
484 nigel 77 */
485    
486     static int
487     check_escape(const uschar **ptrptr, int *errorcodeptr, int bracount,
488     int options, BOOL isclass)
489     {
490 nigel 87 BOOL utf8 = (options & PCRE_UTF8) != 0;
491     const uschar *ptr = *ptrptr + 1;
492 nigel 77 int c, i;
493    
494 nigel 87 GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */
495     ptr--; /* Set pointer back to the last byte */
496    
497 nigel 77 /* If backslash is at the end of the pattern, it's an error. */
498    
499     if (c == 0) *errorcodeptr = ERR1;
500    
501 ph10 274 /* Non-alphanumerics are literals. For digits or letters, do an initial lookup
502     in a table. A non-zero result is something that can be returned immediately.
503 nigel 77 Otherwise further processing may be required. */
504    
505 ph10 97 #ifndef EBCDIC /* ASCII coding */
506 ph10 274 else if (c < '0' || c > 'z') {} /* Not alphanumeric */
507 nigel 77 else if ((i = escapes[c - '0']) != 0) c = i;
508    
509 ph10 97 #else /* EBCDIC coding */
510 ph10 274 else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {} /* Not alphanumeric */
511 nigel 77 else if ((i = escapes[c - 0x48]) != 0) c = i;
512     #endif
513    
514     /* Escapes that need further processing, or are illegal. */
515    
516     else
517     {
518     const uschar *oldptr;
519 nigel 93 BOOL braced, negated;
520    
521 nigel 77 switch (c)
522     {
523     /* A number of Perl escapes are not handled by PCRE. We give an explicit
524     error. */
525    
526     case 'l':
527     case 'L':
528     case 'N':
529     case 'u':
530     case 'U':
531     *errorcodeptr = ERR37;
532     break;
533    
534 ph10 333 /* \g must be followed by one of a number of specific things:
535    
536     (1) A number, either plain or braced. If positive, it is an absolute
537     backreference. If negative, it is a relative backreference. This is a Perl
538     5.10 feature.
539    
540     (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
541     is part of Perl's movement towards a unified syntax for back references. As
542     this is synonymous with \k{name}, we fudge it up by pretending it really
543     was \k.
544    
545     (3) For Oniguruma compatibility we also support \g followed by a name or a
546     number either in angle brackets or in single quotes. However, these are
547     (possibly recursive) subroutine calls, _not_ backreferences. Just return
548     the -ESC_g code (cf \k). */
549 nigel 93
550     case 'g':
551 ph10 333 if (ptr[1] == '<' || ptr[1] == '\'')
552     {
553     c = -ESC_g;
554     break;
555     }
556    
557     /* Handle the Perl-compatible cases */
558    
559 nigel 93 if (ptr[1] == '{')
560     {
561 ph10 171 const uschar *p;
562     for (p = ptr+2; *p != 0 && *p != '}'; p++)
563     if (*p != '-' && (digitab[*p] & ctype_digit) == 0) break;
564 ph10 172 if (*p != 0 && *p != '}')
565 ph10 171 {
566     c = -ESC_k;
567     break;
568 ph10 172 }
569 nigel 93 braced = TRUE;
570     ptr++;
571     }
572     else braced = FALSE;
573    
574     if (ptr[1] == '-')
575     {
576     negated = TRUE;
577     ptr++;
578     }
579     else negated = FALSE;
580    
581     c = 0;
582     while ((digitab[ptr[1]] & ctype_digit) != 0)
583     c = c * 10 + *(++ptr) - '0';
584 ph10 220
585 ph10 333 if (c < 0) /* Integer overflow */
586 ph10 213 {
587     *errorcodeptr = ERR61;
588     break;
589 ph10 220 }
590 ph10 333
591     if (braced && *(++ptr) != '}')
592 nigel 93 {
593     *errorcodeptr = ERR57;
594 ph10 213 break;
595 nigel 93 }
596 ph10 333
597     if (c == 0)
598     {
599     *errorcodeptr = ERR58;
600     break;
601     }
602 nigel 93
603     if (negated)
604     {
605     if (c > bracount)
606     {
607     *errorcodeptr = ERR15;
608 ph10 213 break;
609 nigel 93 }
610     c = bracount - (c - 1);
611     }
612    
613     c = -(ESC_REF + c);
614     break;
615    
616 nigel 77 /* The handling of escape sequences consisting of a string of digits
617     starting with one that is not zero is not straightforward. By experiment,
618     the way Perl works seems to be as follows:
619    
620     Outside a character class, the digits are read as a decimal number. If the
621     number is less than 10, or if there are that many previous extracting
622     left brackets, then it is a back reference. Otherwise, up to three octal
623     digits are read to form an escaped byte. Thus \123 is likely to be octal
624     123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
625     value is greater than 377, the least significant 8 bits are taken. Inside a
626     character class, \ followed by a digit is always an octal number. */
627    
628     case '1': case '2': case '3': case '4': case '5':
629     case '6': case '7': case '8': case '9':
630    
631     if (!isclass)
632     {
633     oldptr = ptr;
634     c -= '0';
635     while ((digitab[ptr[1]] & ctype_digit) != 0)
636     c = c * 10 + *(++ptr) - '0';
637 ph10 333 if (c < 0) /* Integer overflow */
638 ph10 213 {
639     *errorcodeptr = ERR61;
640 ph10 220 break;
641     }
642 nigel 77 if (c < 10 || c <= bracount)
643     {
644     c = -(ESC_REF + c);
645     break;
646     }
647     ptr = oldptr; /* Put the pointer back and fall through */
648     }
649    
650     /* Handle an octal number following \. If the first digit is 8 or 9, Perl
651     generates a binary zero byte and treats the digit as a following literal.
652     Thus we have to pull back the pointer by one. */
653    
654     if ((c = *ptr) >= '8')
655     {
656     ptr--;
657     c = 0;
658     break;
659     }
660    
661     /* \0 always starts an octal number, but we may drop through to here with a
662 nigel 91 larger first octal digit. The original code used just to take the least
663     significant 8 bits of octal numbers (I think this is what early Perls used
664     to do). Nowadays we allow for larger numbers in UTF-8 mode, but no more
665     than 3 octal digits. */
666 nigel 77
667     case '0':
668     c -= '0';
669     while(i++ < 2 && ptr[1] >= '0' && ptr[1] <= '7')
670     c = c * 8 + *(++ptr) - '0';
671 nigel 91 if (!utf8 && c > 255) *errorcodeptr = ERR51;
672 nigel 77 break;
673    
674 nigel 87 /* \x is complicated. \x{ddd} is a character number which can be greater
675     than 0xff in utf8 mode, but only if the ddd are hex digits. If not, { is
676     treated as a data character. */
677 nigel 77
678     case 'x':
679 nigel 87 if (ptr[1] == '{')
680 nigel 77 {
681     const uschar *pt = ptr + 2;
682 nigel 87 int count = 0;
683    
684 nigel 77 c = 0;
685     while ((digitab[*pt] & ctype_xdigit) != 0)
686     {
687 nigel 87 register int cc = *pt++;
688     if (c == 0 && cc == '0') continue; /* Leading zeroes */
689 nigel 77 count++;
690 nigel 87
691 ph10 97 #ifndef EBCDIC /* ASCII coding */
692 nigel 77 if (cc >= 'a') cc -= 32; /* Convert to upper case */
693 nigel 87 c = (c << 4) + cc - ((cc < 'A')? '0' : ('A' - 10));
694 ph10 97 #else /* EBCDIC coding */
695 nigel 77 if (cc >= 'a' && cc <= 'z') cc += 64; /* Convert to upper case */
696 nigel 87 c = (c << 4) + cc - ((cc >= '0')? '0' : ('A' - 10));
697 nigel 77 #endif
698     }
699 nigel 87
700 nigel 77 if (*pt == '}')
701     {
702 nigel 87 if (c < 0 || count > (utf8? 8 : 2)) *errorcodeptr = ERR34;
703 nigel 77 ptr = pt;
704     break;
705     }
706 nigel 87
707 nigel 77 /* If the sequence of hex digits does not end with '}', then we don't
708     recognize this construct; fall through to the normal \x handling. */
709     }
710    
711 nigel 87 /* Read just a single-byte hex-defined char */
712 nigel 77
713     c = 0;
714     while (i++ < 2 && (digitab[ptr[1]] & ctype_xdigit) != 0)
715     {
716     int cc; /* Some compilers don't like ++ */
717     cc = *(++ptr); /* in initializers */
718 ph10 97 #ifndef EBCDIC /* ASCII coding */
719 nigel 77 if (cc >= 'a') cc -= 32; /* Convert to upper case */
720     c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
721 ph10 97 #else /* EBCDIC coding */
722 nigel 77 if (cc <= 'z') cc += 64; /* Convert to upper case */
723     c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
724     #endif
725     }
726     break;
727    
728 nigel 93 /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
729     This coding is ASCII-specific, but then the whole concept of \cx is
730     ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
731 nigel 77
732     case 'c':
733     c = *(++ptr);
734     if (c == 0)
735     {
736     *errorcodeptr = ERR2;
737 ph10 213 break;
738 nigel 77 }
739    
740 ph10 97 #ifndef EBCDIC /* ASCII coding */
741 nigel 77 if (c >= 'a' && c <= 'z') c -= 32;
742     c ^= 0x40;
743 ph10 97 #else /* EBCDIC coding */
744 nigel 77 if (c >= 'a' && c <= 'z') c += 64;
745     c ^= 0xC0;
746     #endif
747     break;
748    
749     /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
750 ph10 274 other alphanumeric following \ is an error if PCRE_EXTRA was set;
751     otherwise, for Perl compatibility, it is a literal. This code looks a bit
752     odd, but there used to be some cases other than the default, and there may
753     be again in future, so I haven't "optimized" it. */
754 nigel 77
755     default:
756     if ((options & PCRE_EXTRA) != 0) switch(c)
757     {
758     default:
759     *errorcodeptr = ERR3;
760     break;
761     }
762     break;
763     }
764     }
765    
766     *ptrptr = ptr;
767     return c;
768     }
769    
770    
771    
772     #ifdef SUPPORT_UCP
773     /*************************************************
774     * Handle \P and \p *
775     *************************************************/
776    
777     /* This function is called after \P or \p has been encountered, provided that
778     PCRE is compiled with support for Unicode properties. On entry, ptrptr is
779     pointing at the P or p. On exit, it is pointing at the final character of the
780     escape sequence.
781    
782     Argument:
783     ptrptr points to the pattern position pointer
784     negptr points to a boolean that is set TRUE for negation else FALSE
785 nigel 87 dptr points to an int that is set to the detailed property value
786 nigel 77 errorcodeptr points to the error code variable
787    
788 nigel 87 Returns: type value from ucp_type_table, or -1 for an invalid type
789 nigel 77 */
790    
791     static int
792 nigel 87 get_ucp(const uschar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr)
793 nigel 77 {
794     int c, i, bot, top;
795     const uschar *ptr = *ptrptr;
796 nigel 87 char name[32];
797 nigel 77
798     c = *(++ptr);
799     if (c == 0) goto ERROR_RETURN;
800    
801     *negptr = FALSE;
802    
803 nigel 87 /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
804     negation. */
805 nigel 77
806     if (c == '{')
807     {
808     if (ptr[1] == '^')
809     {
810     *negptr = TRUE;
811     ptr++;
812     }
813 ph10 199 for (i = 0; i < (int)sizeof(name) - 1; i++)
814 nigel 77 {
815     c = *(++ptr);
816     if (c == 0) goto ERROR_RETURN;
817     if (c == '}') break;
818     name[i] = c;
819     }
820 nigel 87 if (c !='}') goto ERROR_RETURN;
821 nigel 77 name[i] = 0;
822     }
823    
824     /* Otherwise there is just one following character */
825    
826     else
827     {
828     name[0] = c;
829     name[1] = 0;
830     }
831    
832     *ptrptr = ptr;
833    
834     /* Search for a recognized property name using binary chop */
835    
836     bot = 0;
837     top = _pcre_utt_size;
838    
839     while (bot < top)
840     {
841 nigel 87 i = (bot + top) >> 1;
842 ph10 240 c = strcmp(name, _pcre_utt_names + _pcre_utt[i].name_offset);
843 nigel 87 if (c == 0)
844     {
845     *dptr = _pcre_utt[i].value;
846     return _pcre_utt[i].type;
847     }
848 nigel 77 if (c > 0) bot = i + 1; else top = i;
849     }
850    
851     *errorcodeptr = ERR47;
852     *ptrptr = ptr;
853     return -1;
854    
855     ERROR_RETURN:
856     *errorcodeptr = ERR46;
857     *ptrptr = ptr;
858     return -1;
859     }
860     #endif
861    
862    
863    
864    
865     /*************************************************
866     * Check for counted repeat *
867     *************************************************/
868    
869     /* This function is called when a '{' is encountered in a place where it might
870     start a quantifier. It looks ahead to see if it really is a quantifier or not.
871     It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
872     where the ddds are digits.
873    
874     Arguments:
875     p pointer to the first char after '{'
876    
877     Returns: TRUE or FALSE
878     */
879    
880     static BOOL
881     is_counted_repeat(const uschar *p)
882     {
883     if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
884     while ((digitab[*p] & ctype_digit) != 0) p++;
885     if (*p == '}') return TRUE;
886    
887     if (*p++ != ',') return FALSE;
888     if (*p == '}') return TRUE;
889    
890     if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
891     while ((digitab[*p] & ctype_digit) != 0) p++;
892    
893     return (*p == '}');
894     }
895    
896    
897    
898     /*************************************************
899     * Read repeat counts *
900     *************************************************/
901    
902     /* Read an item of the form {n,m} and return the values. This is called only
903     after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
904     so the syntax is guaranteed to be correct, but we need to check the values.
905    
906     Arguments:
907     p pointer to first char after '{'
908     minp pointer to int for min
909     maxp pointer to int for max
910     returned as -1 if no max
911     errorcodeptr points to error code variable
912    
913     Returns: pointer to '}' on success;
914     current ptr on error, with errorcodeptr set non-zero
915     */
916    
917     static const uschar *
918     read_repeat_counts(const uschar *p, int *minp, int *maxp, int *errorcodeptr)
919     {
920     int min = 0;
921     int max = -1;
922    
923 nigel 81 /* Read the minimum value and do a paranoid check: a negative value indicates
924     an integer overflow. */
925    
926 nigel 77 while ((digitab[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
927 nigel 81 if (min < 0 || min > 65535)
928     {
929     *errorcodeptr = ERR5;
930     return p;
931     }
932 nigel 77
933 nigel 81 /* Read the maximum value if there is one, and again do a paranoid on its size.
934     Also, max must not be less than min. */
935    
936 nigel 77 if (*p == '}') max = min; else
937     {
938     if (*(++p) != '}')
939     {
940     max = 0;
941     while((digitab[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
942 nigel 81 if (max < 0 || max > 65535)
943     {
944     *errorcodeptr = ERR5;
945     return p;
946     }
947 nigel 77 if (max < min)
948     {
949     *errorcodeptr = ERR4;
950     return p;
951     }
952     }
953     }
954    
955 nigel 81 /* Fill in the required variables, and pass back the pointer to the terminating
956     '}'. */
957 nigel 77
958 nigel 81 *minp = min;
959     *maxp = max;
960 nigel 77 return p;
961     }
962    
963    
964    
965     /*************************************************
966 nigel 93 * Find forward referenced subpattern *
967 nigel 91 *************************************************/
968    
969 nigel 93 /* This function scans along a pattern's text looking for capturing
970     subpatterns, and counting them. If it finds a named pattern that matches the
971     name it is given, it returns its number. Alternatively, if the name is NULL, it
972     returns when it reaches a given numbered subpattern. This is used for forward
973     references to subpatterns. We know that if (?P< is encountered, the name will
974     be terminated by '>' because that is checked in the first pass.
975 nigel 91
976     Arguments:
977 nigel 93 ptr current position in the pattern
978     count current count of capturing parens so far encountered
979     name name to seek, or NULL if seeking a numbered subpattern
980     lorn name length, or subpattern number if name is NULL
981     xmode TRUE if we are in /x mode
982 nigel 91
983     Returns: the number of the named subpattern, or -1 if not found
984     */
985    
986     static int
987 nigel 93 find_parens(const uschar *ptr, int count, const uschar *name, int lorn,
988     BOOL xmode)
989 nigel 91 {
990     const uschar *thisname;
991 nigel 93
992 nigel 91 for (; *ptr != 0; ptr++)
993     {
994 nigel 93 int term;
995    
996     /* Skip over backslashed characters and also entire \Q...\E */
997    
998     if (*ptr == '\\')
999     {
1000     if (*(++ptr) == 0) return -1;
1001     if (*ptr == 'Q') for (;;)
1002     {
1003     while (*(++ptr) != 0 && *ptr != '\\');
1004     if (*ptr == 0) return -1;
1005     if (*(++ptr) == 'E') break;
1006     }
1007     continue;
1008     }
1009    
1010     /* Skip over character classes */
1011    
1012     if (*ptr == '[')
1013     {
1014     while (*(++ptr) != ']')
1015     {
1016 ph10 220 if (*ptr == 0) return -1;
1017 nigel 93 if (*ptr == '\\')
1018     {
1019     if (*(++ptr) == 0) return -1;
1020     if (*ptr == 'Q') for (;;)
1021     {
1022     while (*(++ptr) != 0 && *ptr != '\\');
1023     if (*ptr == 0) return -1;
1024     if (*(++ptr) == 'E') break;
1025     }
1026     continue;
1027     }
1028     }
1029     continue;
1030     }
1031    
1032     /* Skip comments in /x mode */
1033    
1034     if (xmode && *ptr == '#')
1035     {
1036     while (*(++ptr) != 0 && *ptr != '\n');
1037     if (*ptr == 0) return -1;
1038     continue;
1039     }
1040    
1041     /* An opening parens must now be a real metacharacter */
1042    
1043 nigel 91 if (*ptr != '(') continue;
1044 ph10 210 if (ptr[1] != '?' && ptr[1] != '*')
1045 nigel 93 {
1046     count++;
1047     if (name == NULL && count == lorn) return count;
1048     continue;
1049     }
1050    
1051     ptr += 2;
1052     if (*ptr == 'P') ptr++; /* Allow optional P */
1053    
1054     /* We have to disambiguate (?<! and (?<= from (?<name> */
1055    
1056     if ((*ptr != '<' || ptr[1] == '!' || ptr[1] == '=') &&
1057     *ptr != '\'')
1058     continue;
1059    
1060 nigel 91 count++;
1061 nigel 93
1062     if (name == NULL && count == lorn) return count;
1063     term = *ptr++;
1064     if (term == '<') term = '>';
1065 nigel 91 thisname = ptr;
1066 nigel 93 while (*ptr != term) ptr++;
1067     if (name != NULL && lorn == ptr - thisname &&
1068     strncmp((const char *)name, (const char *)thisname, lorn) == 0)
1069 nigel 91 return count;
1070     }
1071 nigel 93
1072 nigel 91 return -1;
1073     }
1074    
1075    
1076    
1077     /*************************************************
1078 nigel 77 * Find first significant op code *
1079     *************************************************/
1080    
1081     /* This is called by several functions that scan a compiled expression looking
1082     for a fixed first character, or an anchoring op code etc. It skips over things
1083     that do not influence this. For some calls, a change of option is important.
1084     For some calls, it makes sense to skip negative forward and all backward
1085     assertions, and also the \b assertion; for others it does not.
1086    
1087     Arguments:
1088     code pointer to the start of the group
1089     options pointer to external options
1090     optbit the option bit whose changing is significant, or
1091     zero if none are
1092     skipassert TRUE if certain assertions are to be skipped
1093    
1094     Returns: pointer to the first significant opcode
1095     */
1096    
1097     static const uschar*
1098     first_significant_code(const uschar *code, int *options, int optbit,
1099     BOOL skipassert)
1100     {
1101     for (;;)
1102     {
1103     switch ((int)*code)
1104     {
1105     case OP_OPT:
1106     if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))
1107     *options = (int)code[1];
1108     code += 2;
1109     break;
1110    
1111     case OP_ASSERT_NOT:
1112     case OP_ASSERTBACK:
1113     case OP_ASSERTBACK_NOT:
1114     if (!skipassert) return code;
1115     do code += GET(code, 1); while (*code == OP_ALT);
1116     code += _pcre_OP_lengths[*code];
1117     break;
1118    
1119     case OP_WORD_BOUNDARY:
1120     case OP_NOT_WORD_BOUNDARY:
1121     if (!skipassert) return code;
1122     /* Fall through */
1123    
1124     case OP_CALLOUT:
1125     case OP_CREF:
1126 nigel 93 case OP_RREF:
1127     case OP_DEF:
1128 nigel 77 code += _pcre_OP_lengths[*code];
1129     break;
1130    
1131     default:
1132     return code;
1133     }
1134     }
1135     /* Control never reaches here */
1136     }
1137    
1138    
1139    
1140    
1141     /*************************************************
1142     * Find the fixed length of a pattern *
1143     *************************************************/
1144    
1145     /* Scan a pattern and compute the fixed length of subject that will match it,
1146     if the length is fixed. This is needed for dealing with backward assertions.
1147     In UTF8 mode, the result is in characters rather than bytes.
1148    
1149     Arguments:
1150     code points to the start of the pattern (the bracket)
1151     options the compiling options
1152    
1153     Returns: the fixed length, or -1 if there is no fixed length,
1154     or -2 if \C was encountered
1155     */
1156    
1157     static int
1158     find_fixedlength(uschar *code, int options)
1159     {
1160     int length = -1;
1161    
1162     register int branchlength = 0;
1163     register uschar *cc = code + 1 + LINK_SIZE;
1164    
1165     /* Scan along the opcodes for this branch. If we get to the end of the
1166     branch, check the length against that of the other branches. */
1167    
1168     for (;;)
1169     {
1170     int d;
1171     register int op = *cc;
1172     switch (op)
1173     {
1174 nigel 93 case OP_CBRA:
1175 nigel 77 case OP_BRA:
1176     case OP_ONCE:
1177     case OP_COND:
1178 nigel 93 d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), options);
1179 nigel 77 if (d < 0) return d;
1180     branchlength += d;
1181     do cc += GET(cc, 1); while (*cc == OP_ALT);
1182     cc += 1 + LINK_SIZE;
1183     break;
1184    
1185     /* Reached end of a branch; if it's a ket it is the end of a nested
1186     call. If it's ALT it is an alternation in a nested call. If it is
1187     END it's the end of the outer call. All can be handled by the same code. */
1188    
1189     case OP_ALT:
1190     case OP_KET:
1191     case OP_KETRMAX:
1192     case OP_KETRMIN:
1193     case OP_END:
1194     if (length < 0) length = branchlength;
1195     else if (length != branchlength) return -1;
1196     if (*cc != OP_ALT) return length;
1197     cc += 1 + LINK_SIZE;
1198     branchlength = 0;
1199     break;
1200    
1201     /* Skip over assertive subpatterns */
1202    
1203     case OP_ASSERT:
1204     case OP_ASSERT_NOT:
1205     case OP_ASSERTBACK:
1206     case OP_ASSERTBACK_NOT:
1207     do cc += GET(cc, 1); while (*cc == OP_ALT);
1208     /* Fall through */
1209    
1210     /* Skip over things that don't match chars */
1211    
1212     case OP_REVERSE:
1213     case OP_CREF:
1214 nigel 93 case OP_RREF:
1215     case OP_DEF:
1216 nigel 77 case OP_OPT:
1217     case OP_CALLOUT:
1218     case OP_SOD:
1219     case OP_SOM:
1220     case OP_EOD:
1221     case OP_EODN:
1222     case OP_CIRC:
1223     case OP_DOLL:
1224     case OP_NOT_WORD_BOUNDARY:
1225     case OP_WORD_BOUNDARY:
1226     cc += _pcre_OP_lengths[*cc];
1227     break;
1228    
1229     /* Handle literal characters */
1230    
1231     case OP_CHAR:
1232     case OP_CHARNC:
1233 nigel 91 case OP_NOT:
1234 nigel 77 branchlength++;
1235     cc += 2;
1236     #ifdef SUPPORT_UTF8
1237     if ((options & PCRE_UTF8) != 0)
1238     {
1239     while ((*cc & 0xc0) == 0x80) cc++;
1240     }
1241     #endif
1242     break;
1243    
1244     /* Handle exact repetitions. The count is already in characters, but we
1245     need to skip over a multibyte character in UTF8 mode. */
1246    
1247     case OP_EXACT:
1248     branchlength += GET2(cc,1);
1249     cc += 4;
1250     #ifdef SUPPORT_UTF8
1251     if ((options & PCRE_UTF8) != 0)
1252     {
1253     while((*cc & 0x80) == 0x80) cc++;
1254     }
1255     #endif
1256     break;
1257    
1258     case OP_TYPEEXACT:
1259     branchlength += GET2(cc,1);
1260 ph10 220 if (cc[3] == OP_PROP || cc[3] == OP_NOTPROP) cc += 2;
1261 nigel 77 cc += 4;
1262     break;
1263    
1264     /* Handle single-char matchers */
1265    
1266     case OP_PROP:
1267     case OP_NOTPROP:
1268 nigel 87 cc += 2;
1269 nigel 77 /* Fall through */
1270    
1271     case OP_NOT_DIGIT:
1272     case OP_DIGIT:
1273     case OP_NOT_WHITESPACE:
1274     case OP_WHITESPACE:
1275     case OP_NOT_WORDCHAR:
1276     case OP_WORDCHAR:
1277     case OP_ANY:
1278     branchlength++;
1279     cc++;
1280     break;
1281    
1282     /* The single-byte matcher isn't allowed */
1283    
1284     case OP_ANYBYTE:
1285     return -2;
1286    
1287     /* Check a class for variable quantification */
1288    
1289     #ifdef SUPPORT_UTF8
1290     case OP_XCLASS:
1291     cc += GET(cc, 1) - 33;
1292     /* Fall through */
1293     #endif
1294    
1295     case OP_CLASS:
1296     case OP_NCLASS:
1297     cc += 33;
1298    
1299     switch (*cc)
1300     {
1301     case OP_CRSTAR:
1302     case OP_CRMINSTAR:
1303     case OP_CRQUERY:
1304     case OP_CRMINQUERY:
1305     return -1;
1306    
1307     case OP_CRRANGE:
1308     case OP_CRMINRANGE:
1309     if (GET2(cc,1) != GET2(cc,3)) return -1;
1310     branchlength += GET2(cc,1);
1311     cc += 5;
1312     break;
1313    
1314     default:
1315     branchlength++;
1316     }
1317     break;
1318    
1319     /* Anything else is variable length */
1320    
1321     default:
1322     return -1;
1323     }
1324     }
1325     /* Control never gets here */
1326     }
1327    
1328    
1329    
1330    
1331     /*************************************************
1332     * Scan compiled regex for numbered bracket *
1333     *************************************************/
1334    
1335     /* This little function scans through a compiled pattern until it finds a
1336     capturing bracket with the given number.
1337    
1338     Arguments:
1339     code points to start of expression
1340     utf8 TRUE in UTF-8 mode
1341     number the required bracket number
1342    
1343     Returns: pointer to the opcode for the bracket, or NULL if not found
1344     */
1345    
1346     static const uschar *
1347     find_bracket(const uschar *code, BOOL utf8, int number)
1348     {
1349     for (;;)
1350     {
1351     register int c = *code;
1352     if (c == OP_END) return NULL;
1353 nigel 91
1354     /* XCLASS is used for classes that cannot be represented just by a bit
1355     map. This includes negated single high-valued characters. The length in
1356     the table is zero; the actual length is stored in the compiled code. */
1357    
1358     if (c == OP_XCLASS) code += GET(code, 1);
1359    
1360 nigel 93 /* Handle capturing bracket */
1361 nigel 91
1362 nigel 93 else if (c == OP_CBRA)
1363 nigel 77 {
1364 nigel 93 int n = GET2(code, 1+LINK_SIZE);
1365 nigel 77 if (n == number) return (uschar *)code;
1366 nigel 93 code += _pcre_OP_lengths[c];
1367 nigel 77 }
1368 nigel 91
1369 ph10 220 /* Otherwise, we can get the item's length from the table, except that for
1370     repeated character types, we have to test for \p and \P, which have an extra
1371 ph10 218 two bytes of parameters. */
1372 nigel 91
1373 nigel 77 else
1374     {
1375 ph10 218 switch(c)
1376     {
1377     case OP_TYPESTAR:
1378     case OP_TYPEMINSTAR:
1379     case OP_TYPEPLUS:
1380     case OP_TYPEMINPLUS:
1381     case OP_TYPEQUERY:
1382     case OP_TYPEMINQUERY:
1383     case OP_TYPEPOSSTAR:
1384     case OP_TYPEPOSPLUS:
1385     case OP_TYPEPOSQUERY:
1386     if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
1387 ph10 220 break;
1388 ph10 221
1389     case OP_TYPEUPTO:
1390     case OP_TYPEMINUPTO:
1391     case OP_TYPEEXACT:
1392     case OP_TYPEPOSUPTO:
1393     if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
1394     break;
1395 ph10 220 }
1396    
1397 ph10 218 /* Add in the fixed length from the table */
1398 ph10 220
1399 nigel 77 code += _pcre_OP_lengths[c];
1400 ph10 220
1401 ph10 218 /* In UTF-8 mode, opcodes that are followed by a character may be followed by
1402     a multi-byte character. The length in the table is a minimum, so we have to
1403     arrange to skip the extra bytes. */
1404 ph10 220
1405 ph10 107 #ifdef SUPPORT_UTF8
1406 nigel 77 if (utf8) switch(c)
1407     {
1408     case OP_CHAR:
1409     case OP_CHARNC:
1410     case OP_EXACT:
1411     case OP_UPTO:
1412     case OP_MINUPTO:
1413 nigel 93 case OP_POSUPTO:
1414 nigel 77 case OP_STAR:
1415     case OP_MINSTAR:
1416 nigel 93 case OP_POSSTAR:
1417 nigel 77 case OP_PLUS:
1418     case OP_MINPLUS:
1419 nigel 93 case OP_POSPLUS:
1420 nigel 77 case OP_QUERY:
1421     case OP_MINQUERY:
1422 nigel 93 case OP_POSQUERY:
1423     if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
1424 nigel 77 break;
1425     }
1426 ph10 111 #endif
1427 nigel 77 }
1428     }
1429     }
1430    
1431    
1432    
1433     /*************************************************
1434     * Scan compiled regex for recursion reference *
1435     *************************************************/
1436    
1437     /* This little function scans through a compiled pattern until it finds an
1438     instance of OP_RECURSE.
1439    
1440     Arguments:
1441     code points to start of expression
1442     utf8 TRUE in UTF-8 mode
1443    
1444     Returns: pointer to the opcode for OP_RECURSE, or NULL if not found
1445     */
1446    
1447     static const uschar *
1448     find_recurse(const uschar *code, BOOL utf8)
1449     {
1450     for (;;)
1451     {
1452     register int c = *code;
1453     if (c == OP_END) return NULL;
1454 nigel 91 if (c == OP_RECURSE) return code;
1455 ph10 220
1456 nigel 91 /* XCLASS is used for classes that cannot be represented just by a bit
1457     map. This includes negated single high-valued characters. The length in
1458     the table is zero; the actual length is stored in the compiled code. */
1459    
1460     if (c == OP_XCLASS) code += GET(code, 1);
1461    
1462 ph10 220 /* Otherwise, we can get the item's length from the table, except that for
1463     repeated character types, we have to test for \p and \P, which have an extra
1464 ph10 218 two bytes of parameters. */
1465 nigel 91
1466 nigel 77 else
1467     {
1468 ph10 218 switch(c)
1469     {
1470     case OP_TYPESTAR:
1471     case OP_TYPEMINSTAR:
1472     case OP_TYPEPLUS:
1473     case OP_TYPEMINPLUS:
1474     case OP_TYPEQUERY:
1475     case OP_TYPEMINQUERY:
1476     case OP_TYPEPOSSTAR:
1477     case OP_TYPEPOSPLUS:
1478     case OP_TYPEPOSQUERY:
1479     if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
1480 ph10 220 break;
1481 ph10 221
1482     case OP_TYPEPOSUPTO:
1483     case OP_TYPEUPTO:
1484     case OP_TYPEMINUPTO:
1485     case OP_TYPEEXACT:
1486     if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
1487     break;
1488 ph10 220 }
1489    
1490 ph10 218 /* Add in the fixed length from the table */
1491    
1492 nigel 77 code += _pcre_OP_lengths[c];
1493 ph10 220
1494 ph10 218 /* In UTF-8 mode, opcodes that are followed by a character may be followed
1495     by a multi-byte character. The length in the table is a minimum, so we have
1496     to arrange to skip the extra bytes. */
1497 ph10 220
1498 ph10 107 #ifdef SUPPORT_UTF8
1499 nigel 77 if (utf8) switch(c)
1500     {
1501     case OP_CHAR:
1502     case OP_CHARNC:
1503     case OP_EXACT:
1504     case OP_UPTO:
1505     case OP_MINUPTO:
1506 nigel 93 case OP_POSUPTO:
1507 nigel 77 case OP_STAR:
1508     case OP_MINSTAR:
1509 nigel 93 case OP_POSSTAR:
1510 nigel 77 case OP_PLUS:
1511     case OP_MINPLUS:
1512 nigel 93 case OP_POSPLUS:
1513 nigel 77 case OP_QUERY:
1514     case OP_MINQUERY:
1515 nigel 93 case OP_POSQUERY:
1516     if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
1517 nigel 77 break;
1518     }
1519 ph10 111 #endif
1520 nigel 77 }
1521     }
1522     }
1523    
1524    
1525    
1526     /*************************************************
1527     * Scan compiled branch for non-emptiness *
1528     *************************************************/
1529    
1530     /* This function scans through a branch of a compiled pattern to see whether it
1531 nigel 93 can match the empty string or not. It is called from could_be_empty()
1532     below and from compile_branch() when checking for an unlimited repeat of a
1533     group that can match nothing. Note that first_significant_code() skips over
1534 ph10 282 backward and negative forward assertions when its final argument is TRUE. If we
1535     hit an unclosed bracket, we return "empty" - this means we've struck an inner
1536     bracket whose current branch will already have been scanned.
1537 nigel 77
1538     Arguments:
1539     code points to start of search
1540     endcode points to where to stop
1541     utf8 TRUE if in UTF8 mode
1542    
1543     Returns: TRUE if what is matched could be empty
1544     */
1545    
1546     static BOOL
1547     could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8)
1548     {
1549     register int c;
1550 nigel 93 for (code = first_significant_code(code + _pcre_OP_lengths[*code], NULL, 0, TRUE);
1551 nigel 77 code < endcode;
1552     code = first_significant_code(code + _pcre_OP_lengths[c], NULL, 0, TRUE))
1553     {
1554     const uschar *ccode;
1555    
1556     c = *code;
1557 ph10 286
1558     /* Skip over forward assertions; the other assertions are skipped by
1559 ph10 282 first_significant_code() with a TRUE final argument. */
1560 ph10 286
1561 ph10 282 if (c == OP_ASSERT)
1562 ph10 286 {
1563 ph10 282 do code += GET(code, 1); while (*code == OP_ALT);
1564     c = *code;
1565     continue;
1566 ph10 286 }
1567 ph10 172
1568 ph10 170 /* Groups with zero repeats can of course be empty; skip them. */
1569 nigel 77
1570 ph10 335 if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO)
1571 ph10 170 {
1572 ph10 172 code += _pcre_OP_lengths[c];
1573 ph10 170 do code += GET(code, 1); while (*code == OP_ALT);
1574     c = *code;
1575     continue;
1576     }
1577    
1578     /* For other groups, scan the branches. */
1579 ph10 172
1580 ph10 206 if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE || c == OP_COND)
1581 nigel 77 {
1582     BOOL empty_branch;
1583     if (GET(code, 1) == 0) return TRUE; /* Hit unclosed bracket */
1584    
1585     /* Scan a closed bracket */
1586    
1587     empty_branch = FALSE;
1588     do
1589     {
1590     if (!empty_branch && could_be_empty_branch(code, endcode, utf8))
1591     empty_branch = TRUE;
1592     code += GET(code, 1);
1593     }
1594     while (*code == OP_ALT);
1595     if (!empty_branch) return FALSE; /* All branches are non-empty */
1596 ph10 172 c = *code;
1597 nigel 93 continue;
1598 nigel 77 }
1599    
1600 nigel 93 /* Handle the other opcodes */
1601    
1602     switch (c)
1603 nigel 77 {
1604 ph10 216 /* Check for quantifiers after a class. XCLASS is used for classes that
1605     cannot be represented just by a bit map. This includes negated single
1606     high-valued characters. The length in _pcre_OP_lengths[] is zero; the
1607 ph10 220 actual length is stored in the compiled code, so we must update "code"
1608 ph10 216 here. */
1609 nigel 77
1610     #ifdef SUPPORT_UTF8
1611     case OP_XCLASS:
1612 ph10 216 ccode = code += GET(code, 1);
1613 nigel 77 goto CHECK_CLASS_REPEAT;
1614     #endif
1615    
1616     case OP_CLASS:
1617     case OP_NCLASS:
1618     ccode = code + 33;
1619    
1620     #ifdef SUPPORT_UTF8
1621     CHECK_CLASS_REPEAT:
1622     #endif
1623    
1624     switch (*ccode)
1625     {
1626     case OP_CRSTAR: /* These could be empty; continue */
1627     case OP_CRMINSTAR:
1628     case OP_CRQUERY:
1629     case OP_CRMINQUERY:
1630     break;
1631    
1632     default: /* Non-repeat => class must match */
1633     case OP_CRPLUS: /* These repeats aren't empty */
1634     case OP_CRMINPLUS:
1635     return FALSE;
1636    
1637     case OP_CRRANGE:
1638     case OP_CRMINRANGE:
1639     if (GET2(ccode, 1) > 0) return FALSE; /* Minimum > 0 */
1640     break;
1641     }
1642     break;
1643    
1644     /* Opcodes that must match a character */
1645    
1646     case OP_PROP:
1647     case OP_NOTPROP:
1648     case OP_EXTUNI:
1649     case OP_NOT_DIGIT:
1650     case OP_DIGIT:
1651     case OP_NOT_WHITESPACE:
1652     case OP_WHITESPACE:
1653     case OP_NOT_WORDCHAR:
1654     case OP_WORDCHAR:
1655     case OP_ANY:
1656     case OP_ANYBYTE:
1657     case OP_CHAR:
1658     case OP_CHARNC:
1659     case OP_NOT:
1660     case OP_PLUS:
1661     case OP_MINPLUS:
1662 nigel 93 case OP_POSPLUS:
1663 nigel 77 case OP_EXACT:
1664     case OP_NOTPLUS:
1665     case OP_NOTMINPLUS:
1666 nigel 93 case OP_NOTPOSPLUS:
1667 nigel 77 case OP_NOTEXACT:
1668     case OP_TYPEPLUS:
1669     case OP_TYPEMINPLUS:
1670 nigel 93 case OP_TYPEPOSPLUS:
1671 nigel 77 case OP_TYPEEXACT:
1672     return FALSE;
1673 ph10 227
1674     /* These are going to continue, as they may be empty, but we have to
1675     fudge the length for the \p and \P cases. */
1676    
1677 ph10 224 case OP_TYPESTAR:
1678     case OP_TYPEMINSTAR:
1679     case OP_TYPEPOSSTAR:
1680     case OP_TYPEQUERY:
1681     case OP_TYPEMINQUERY:
1682     case OP_TYPEPOSQUERY:
1683     if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
1684 ph10 227 break;
1685    
1686 ph10 224 /* Same for these */
1687 ph10 227
1688 ph10 224 case OP_TYPEUPTO:
1689     case OP_TYPEMINUPTO:
1690     case OP_TYPEPOSUPTO:
1691     if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
1692     break;
1693 nigel 77
1694     /* End of branch */
1695    
1696     case OP_KET:
1697     case OP_KETRMAX:
1698     case OP_KETRMIN:
1699     case OP_ALT:
1700     return TRUE;
1701    
1702 nigel 93 /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
1703     MINUPTO, and POSUPTO may be followed by a multibyte character */
1704 nigel 77
1705     #ifdef SUPPORT_UTF8
1706     case OP_STAR:
1707     case OP_MINSTAR:
1708 nigel 93 case OP_POSSTAR:
1709 nigel 77 case OP_QUERY:
1710     case OP_MINQUERY:
1711 nigel 93 case OP_POSQUERY:
1712 nigel 77 case OP_UPTO:
1713     case OP_MINUPTO:
1714 nigel 93 case OP_POSUPTO:
1715 nigel 77 if (utf8) while ((code[2] & 0xc0) == 0x80) code++;
1716     break;
1717     #endif
1718     }
1719     }
1720    
1721     return TRUE;
1722     }
1723    
1724    
1725    
1726     /*************************************************
1727     * Scan compiled regex for non-emptiness *
1728     *************************************************/
1729    
1730     /* This function is called to check for left recursive calls. We want to check
1731     the current branch of the current pattern to see if it could match the empty
1732     string. If it could, we must look outwards for branches at other levels,
1733     stopping when we pass beyond the bracket which is the subject of the recursion.
1734    
1735     Arguments:
1736     code points to start of the recursion
1737     endcode points to where to stop (current RECURSE item)
1738     bcptr points to the chain of current (unclosed) branch starts
1739     utf8 TRUE if in UTF-8 mode
1740    
1741     Returns: TRUE if what is matched could be empty
1742     */
1743    
1744     static BOOL
1745     could_be_empty(const uschar *code, const uschar *endcode, branch_chain *bcptr,
1746     BOOL utf8)
1747     {
1748     while (bcptr != NULL && bcptr->current >= code)
1749     {
1750     if (!could_be_empty_branch(bcptr->current, endcode, utf8)) return FALSE;
1751     bcptr = bcptr->outer;
1752     }
1753     return TRUE;
1754     }
1755    
1756    
1757    
1758     /*************************************************
1759     * Check for POSIX class syntax *
1760     *************************************************/
1761    
1762     /* This function is called when the sequence "[:" or "[." or "[=" is
1763 ph10 295 encountered in a character class. It checks whether this is followed by a
1764 ph10 298 sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
1765 ph10 295 reach an unescaped ']' without the special preceding character, return FALSE.
1766 nigel 77
1767 ph10 298 Originally, this function only recognized a sequence of letters between the
1768     terminators, but it seems that Perl recognizes any sequence of characters,
1769     though of course unknown POSIX names are subsequently rejected. Perl gives an
1770     "Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
1771     didn't consider this to be a POSIX class. Likewise for [:1234:].
1772 ph10 295
1773 ph10 298 The problem in trying to be exactly like Perl is in the handling of escapes. We
1774     have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
1775     class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
1776     below handles the special case of \], but does not try to do any other escape
1777     processing. This makes it different from Perl for cases such as [:l\ower:]
1778 ph10 295 where Perl recognizes it as the POSIX class "lower" but PCRE does not recognize
1779 ph10 298 "l\ower". This is a lesser evil that not diagnosing bad classes when Perl does,
1780 ph10 295 I think.
1781    
1782     Arguments:
1783 nigel 77 ptr pointer to the initial [
1784     endptr where to return the end pointer
1785    
1786     Returns: TRUE or FALSE
1787     */
1788    
1789     static BOOL
1790 ph10 295 check_posix_syntax(const uschar *ptr, const uschar **endptr)
1791 nigel 77 {
1792     int terminator; /* Don't combine these lines; the Solaris cc */
1793     terminator = *(++ptr); /* compiler warns about "non-constant" initializer. */
1794 ph10 295 for (++ptr; *ptr != 0; ptr++)
1795 nigel 77 {
1796 ph10 295 if (*ptr == '\\' && ptr[1] == ']') ptr++; else
1797 ph10 298 {
1798     if (*ptr == ']') return FALSE;
1799 ph10 295 if (*ptr == terminator && ptr[1] == ']')
1800     {
1801     *endptr = ptr;
1802     return TRUE;
1803 ph10 298 }
1804     }
1805     }
1806 nigel 77 return FALSE;
1807     }
1808    
1809    
1810    
1811    
1812     /*************************************************
1813     * Check POSIX class name *
1814     *************************************************/
1815    
1816     /* This function is called to check the name given in a POSIX-style class entry
1817     such as [:alnum:].
1818    
1819     Arguments:
1820     ptr points to the first letter
1821     len the length of the name
1822    
1823     Returns: a value representing the name, or -1 if unknown
1824     */
1825    
1826     static int
1827     check_posix_name(const uschar *ptr, int len)
1828     {
1829 ph10 240 const char *pn = posix_names;
1830 nigel 77 register int yield = 0;
1831     while (posix_name_lengths[yield] != 0)
1832     {
1833     if (len == posix_name_lengths[yield] &&
1834 ph10 240 strncmp((const char *)ptr, pn, len) == 0) return yield;
1835 ph10 243 pn += posix_name_lengths[yield] + 1;
1836 nigel 77 yield++;
1837     }
1838     return -1;
1839     }
1840    
1841    
1842     /*************************************************
1843     * Adjust OP_RECURSE items in repeated group *
1844     *************************************************/
1845    
1846     /* OP_RECURSE items contain an offset from the start of the regex to the group
1847     that is referenced. This means that groups can be replicated for fixed
1848     repetition simply by copying (because the recursion is allowed to refer to
1849     earlier groups that are outside the current group). However, when a group is
1850 ph10 335 optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is
1851     inserted before it, after it has been compiled. This means that any OP_RECURSE
1852     items within it that refer to the group itself or any contained groups have to
1853     have their offsets adjusted. That one of the jobs of this function. Before it
1854     is called, the partially compiled regex must be temporarily terminated with
1855     OP_END.
1856 nigel 77
1857 nigel 93 This function has been extended with the possibility of forward references for
1858     recursions and subroutine calls. It must also check the list of such references
1859     for the group we are dealing with. If it finds that one of the recursions in
1860     the current group is on this list, it adjusts the offset in the list, not the
1861     value in the reference (which is a group number).
1862    
1863 nigel 77 Arguments:
1864     group points to the start of the group
1865     adjust the amount by which the group is to be moved
1866     utf8 TRUE in UTF-8 mode
1867     cd contains pointers to tables etc.
1868 nigel 93 save_hwm the hwm forward reference pointer at the start of the group
1869 nigel 77
1870     Returns: nothing
1871     */
1872    
1873     static void
1874 nigel 93 adjust_recurse(uschar *group, int adjust, BOOL utf8, compile_data *cd,
1875     uschar *save_hwm)
1876 nigel 77 {
1877     uschar *ptr = group;
1878 ph10 224
1879 nigel 77 while ((ptr = (uschar *)find_recurse(ptr, utf8)) != NULL)
1880     {
1881 nigel 93 int offset;
1882     uschar *hc;
1883    
1884     /* See if this recursion is on the forward reference list. If so, adjust the
1885     reference. */
1886 ph10 334
1887 nigel 93 for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)
1888     {
1889     offset = GET(hc, 0);
1890     if (cd->start_code + offset == ptr + 1)
1891     {
1892     PUT(hc, 0, offset + adjust);
1893     break;
1894     }
1895     }
1896    
1897     /* Otherwise, adjust the recursion offset if it's after the start of this
1898     group. */
1899    
1900     if (hc >= cd->hwm)
1901     {
1902     offset = GET(ptr, 1);
1903     if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
1904     }
1905    
1906 nigel 77 ptr += 1 + LINK_SIZE;
1907     }
1908     }
1909    
1910    
1911    
1912     /*************************************************
1913     * Insert an automatic callout point *
1914     *************************************************/
1915    
1916     /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
1917     callout points before each pattern item.
1918    
1919     Arguments:
1920     code current code pointer
1921     ptr current pattern pointer
1922     cd pointers to tables etc
1923    
1924     Returns: new code pointer
1925     */
1926    
1927     static uschar *
1928     auto_callout(uschar *code, const uschar *ptr, compile_data *cd)
1929     {
1930     *code++ = OP_CALLOUT;
1931     *code++ = 255;
1932     PUT(code, 0, ptr - cd->start_pattern); /* Pattern offset */
1933     PUT(code, LINK_SIZE, 0); /* Default length */
1934     return code + 2*LINK_SIZE;
1935     }
1936    
1937    
1938    
1939     /*************************************************
1940     * Complete a callout item *
1941     *************************************************/
1942    
1943     /* A callout item contains the length of the next item in the pattern, which
1944     we can't fill in till after we have reached the relevant point. This is used
1945     for both automatic and manual callouts.
1946    
1947     Arguments:
1948     previous_callout points to previous callout item
1949     ptr current pattern pointer
1950     cd pointers to tables etc
1951    
1952     Returns: nothing
1953     */
1954    
1955     static void
1956     complete_callout(uschar *previous_callout, const uschar *ptr, compile_data *cd)
1957     {
1958     int length = ptr - cd->start_pattern - GET(previous_callout, 2);
1959     PUT(previous_callout, 2 + LINK_SIZE, length);
1960     }
1961    
1962    
1963    
1964     #ifdef SUPPORT_UCP
1965     /*************************************************
1966     * Get othercase range *
1967     *************************************************/
1968    
1969     /* This function is passed the start and end of a class range, in UTF-8 mode
1970     with UCP support. It searches up the characters, looking for internal ranges of
1971     characters in the "other" case. Each call returns the next one, updating the
1972     start address.
1973    
1974     Arguments:
1975     cptr points to starting character value; updated
1976     d end value
1977     ocptr where to put start of othercase range
1978     odptr where to put end of othercase range
1979    
1980     Yield: TRUE when range returned; FALSE when no more
1981     */
1982    
1983     static BOOL
1984 nigel 93 get_othercase_range(unsigned int *cptr, unsigned int d, unsigned int *ocptr,
1985     unsigned int *odptr)
1986 nigel 77 {
1987 nigel 93 unsigned int c, othercase, next;
1988 nigel 77
1989     for (c = *cptr; c <= d; c++)
1990 nigel 93 { if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR) break; }
1991 nigel 77
1992     if (c > d) return FALSE;
1993    
1994     *ocptr = othercase;
1995     next = othercase + 1;
1996    
1997     for (++c; c <= d; c++)
1998     {
1999 nigel 87 if (_pcre_ucp_othercase(c) != next) break;
2000 nigel 77 next++;
2001     }
2002    
2003     *odptr = next - 1;
2004     *cptr = c;
2005    
2006     return TRUE;
2007     }
2008     #endif /* SUPPORT_UCP */
2009    
2010    
2011 nigel 93
2012 nigel 77 /*************************************************
2013 nigel 93 * Check if auto-possessifying is possible *
2014     *************************************************/
2015    
2016     /* This function is called for unlimited repeats of certain items, to see
2017     whether the next thing could possibly match the repeated item. If not, it makes
2018     sense to automatically possessify the repeated item.
2019    
2020     Arguments:
2021     op_code the repeated op code
2022     this data for this item, depends on the opcode
2023     utf8 TRUE in UTF-8 mode
2024     utf8_char used for utf8 character bytes, NULL if not relevant
2025     ptr next character in pattern
2026     options options bits
2027     cd contains pointers to tables etc.
2028    
2029     Returns: TRUE if possessifying is wanted
2030     */
2031    
2032     static BOOL
2033     check_auto_possessive(int op_code, int item, BOOL utf8, uschar *utf8_char,
2034     const uschar *ptr, int options, compile_data *cd)
2035     {
2036     int next;
2037    
2038     /* Skip whitespace and comments in extended mode */
2039    
2040     if ((options & PCRE_EXTENDED) != 0)
2041     {
2042     for (;;)
2043     {
2044     while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
2045     if (*ptr == '#')
2046     {
2047     while (*(++ptr) != 0)
2048     if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
2049     }
2050     else break;
2051     }
2052     }
2053    
2054     /* If the next item is one that we can handle, get its value. A non-negative
2055     value is a character, a negative value is an escape value. */
2056    
2057     if (*ptr == '\\')
2058     {
2059     int temperrorcode = 0;
2060     next = check_escape(&ptr, &temperrorcode, cd->bracount, options, FALSE);
2061     if (temperrorcode != 0) return FALSE;
2062     ptr++; /* Point after the escape sequence */
2063     }
2064    
2065     else if ((cd->ctypes[*ptr] & ctype_meta) == 0)
2066     {
2067     #ifdef SUPPORT_UTF8
2068     if (utf8) { GETCHARINC(next, ptr); } else
2069     #endif
2070     next = *ptr++;
2071     }
2072    
2073     else return FALSE;
2074    
2075     /* Skip whitespace and comments in extended mode */
2076    
2077     if ((options & PCRE_EXTENDED) != 0)
2078     {
2079     for (;;)
2080     {
2081     while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
2082     if (*ptr == '#')
2083     {
2084     while (*(++ptr) != 0)
2085     if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
2086     }
2087     else break;
2088     }
2089     }
2090    
2091     /* If the next thing is itself optional, we have to give up. */
2092    
2093     if (*ptr == '*' || *ptr == '?' || strncmp((char *)ptr, "{0,", 3) == 0)
2094     return FALSE;
2095    
2096     /* Now compare the next item with the previous opcode. If the previous is a
2097     positive single character match, "item" either contains the character or, if
2098     "item" is greater than 127 in utf8 mode, the character's bytes are in
2099     utf8_char. */
2100    
2101    
2102     /* Handle cases when the next item is a character. */
2103    
2104     if (next >= 0) switch(op_code)
2105     {
2106     case OP_CHAR:
2107     #ifdef SUPPORT_UTF8
2108     if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
2109     #endif
2110     return item != next;
2111    
2112     /* For CHARNC (caseless character) we must check the other case. If we have
2113     Unicode property support, we can use it to test the other case of
2114     high-valued characters. */
2115    
2116     case OP_CHARNC:
2117     #ifdef SUPPORT_UTF8
2118     if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
2119     #endif
2120     if (item == next) return FALSE;
2121     #ifdef SUPPORT_UTF8
2122     if (utf8)
2123     {
2124     unsigned int othercase;
2125     if (next < 128) othercase = cd->fcc[next]; else
2126     #ifdef SUPPORT_UCP
2127     othercase = _pcre_ucp_othercase((unsigned int)next);
2128     #else
2129     othercase = NOTACHAR;
2130     #endif
2131     return (unsigned int)item != othercase;
2132     }
2133     else
2134     #endif /* SUPPORT_UTF8 */
2135     return (item != cd->fcc[next]); /* Non-UTF-8 mode */
2136    
2137     /* For OP_NOT, "item" must be a single-byte character. */
2138    
2139     case OP_NOT:
2140     if (item == next) return TRUE;
2141     if ((options & PCRE_CASELESS) == 0) return FALSE;
2142     #ifdef SUPPORT_UTF8
2143     if (utf8)
2144     {
2145     unsigned int othercase;
2146     if (next < 128) othercase = cd->fcc[next]; else
2147     #ifdef SUPPORT_UCP
2148     othercase = _pcre_ucp_othercase(next);
2149     #else
2150     othercase = NOTACHAR;
2151     #endif
2152     return (unsigned int)item == othercase;
2153     }
2154     else
2155     #endif /* SUPPORT_UTF8 */
2156     return (item == cd->fcc[next]); /* Non-UTF-8 mode */
2157    
2158     case OP_DIGIT:
2159     return next > 127 || (cd->ctypes[next] & ctype_digit) == 0;
2160    
2161     case OP_NOT_DIGIT:
2162     return next <= 127 && (cd->ctypes[next] & ctype_digit) != 0;
2163    
2164     case OP_WHITESPACE:
2165     return next > 127 || (cd->ctypes[next] & ctype_space) == 0;
2166    
2167     case OP_NOT_WHITESPACE:
2168     return next <= 127 && (cd->ctypes[next] & ctype_space) != 0;
2169    
2170     case OP_WORDCHAR:
2171     return next > 127 || (cd->ctypes[next] & ctype_word) == 0;
2172    
2173     case OP_NOT_WORDCHAR:
2174     return next <= 127 && (cd->ctypes[next] & ctype_word) != 0;
2175    
2176 ph10 180 case OP_HSPACE:
2177     case OP_NOT_HSPACE:
2178     switch(next)
2179     {
2180     case 0x09:
2181     case 0x20:
2182     case 0xa0:
2183     case 0x1680:
2184     case 0x180e:
2185     case 0x2000:
2186     case 0x2001:
2187     case 0x2002:
2188     case 0x2003:
2189     case 0x2004:
2190     case 0x2005:
2191     case 0x2006:
2192     case 0x2007:
2193     case 0x2008:
2194     case 0x2009:
2195     case 0x200A:
2196     case 0x202f:
2197     case 0x205f:
2198     case 0x3000:
2199     return op_code != OP_HSPACE;
2200     default:
2201     return op_code == OP_HSPACE;
2202     }
2203    
2204     case OP_VSPACE:
2205     case OP_NOT_VSPACE:
2206     switch(next)
2207     {
2208     case 0x0a:
2209     case 0x0b:
2210     case 0x0c:
2211     case 0x0d:
2212     case 0x85:
2213     case 0x2028:
2214     case 0x2029:
2215     return op_code != OP_VSPACE;
2216     default:
2217     return op_code == OP_VSPACE;
2218     }
2219    
2220 nigel 93 default:
2221     return FALSE;
2222     }
2223    
2224    
2225     /* Handle the case when the next item is \d, \s, etc. */
2226    
2227     switch(op_code)
2228     {
2229     case OP_CHAR:
2230     case OP_CHARNC:
2231     #ifdef SUPPORT_UTF8
2232     if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
2233     #endif
2234     switch(-next)
2235     {
2236     case ESC_d:
2237     return item > 127 || (cd->ctypes[item] & ctype_digit) == 0;
2238    
2239     case ESC_D:
2240     return item <= 127 && (cd->ctypes[item] & ctype_digit) != 0;
2241    
2242     case ESC_s:
2243     return item > 127 || (cd->ctypes[item] & ctype_space) == 0;
2244    
2245     case ESC_S:
2246     return item <= 127 && (cd->ctypes[item] & ctype_space) != 0;
2247    
2248     case ESC_w:
2249     return item > 127 || (cd->ctypes[item] & ctype_word) == 0;
2250    
2251     case ESC_W:
2252     return item <= 127 && (cd->ctypes[item] & ctype_word) != 0;
2253 ph10 182
2254 ph10 180 case ESC_h:
2255     case ESC_H:
2256     switch(item)
2257     {
2258     case 0x09:
2259     case 0x20:
2260     case 0xa0:
2261     case 0x1680:
2262     case 0x180e:
2263     case 0x2000:
2264     case 0x2001:
2265     case 0x2002:
2266     case 0x2003:
2267     case 0x2004:
2268     case 0x2005:
2269     case 0x2006:
2270     case 0x2007:
2271     case 0x2008:
2272     case 0x2009:
2273     case 0x200A:
2274     case 0x202f:
2275     case 0x205f:
2276     case 0x3000:
2277     return -next != ESC_h;
2278     default:
2279     return -next == ESC_h;
2280 ph10 182 }
2281    
2282 ph10 180 case ESC_v:
2283     case ESC_V:
2284     switch(item)
2285     {
2286     case 0x0a:
2287     case 0x0b:
2288     case 0x0c:
2289     case 0x0d:
2290     case 0x85:
2291     case 0x2028:
2292     case 0x2029:
2293     return -next != ESC_v;
2294     default:
2295     return -next == ESC_v;
2296 ph10 182 }
2297 nigel 93
2298     default:
2299     return FALSE;
2300     }
2301    
2302     case OP_DIGIT:
2303 ph10 180 return next == -ESC_D || next == -ESC_s || next == -ESC_W ||
2304     next == -ESC_h || next == -ESC_v;
2305 nigel 93
2306     case OP_NOT_DIGIT:
2307     return next == -ESC_d;
2308    
2309     case OP_WHITESPACE:
2310     return next == -ESC_S || next == -ESC_d || next == -ESC_w;
2311    
2312     case OP_NOT_WHITESPACE:
2313 ph10 180 return next == -ESC_s || next == -ESC_h || next == -ESC_v;
2314 nigel 93
2315 ph10 180 case OP_HSPACE:
2316     return next == -ESC_S || next == -ESC_H || next == -ESC_d || next == -ESC_w;
2317    
2318     case OP_NOT_HSPACE:
2319     return next == -ESC_h;
2320 ph10 182
2321 ph10 180 /* Can't have \S in here because VT matches \S (Perl anomaly) */
2322 ph10 182 case OP_VSPACE:
2323 ph10 180 return next == -ESC_V || next == -ESC_d || next == -ESC_w;
2324    
2325     case OP_NOT_VSPACE:
2326 ph10 182 return next == -ESC_v;
2327 ph10 180
2328 nigel 93 case OP_WORDCHAR:
2329 ph10 180 return next == -ESC_W || next == -ESC_s || next == -ESC_h || next == -ESC_v;
2330 nigel 93
2331     case OP_NOT_WORDCHAR:
2332     return next == -ESC_w || next == -ESC_d;
2333 ph10 182
2334 nigel 93 default:
2335     return FALSE;
2336     }
2337    
2338     /* Control does not reach here */
2339     }
2340    
2341    
2342    
2343     /*************************************************
2344 nigel 77 * Compile one branch *
2345     *************************************************/
2346    
2347 nigel 93 /* Scan the pattern, compiling it into the a vector. If the options are
2348 nigel 77 changed during the branch, the pointer is used to change the external options
2349 nigel 93 bits. This function is used during the pre-compile phase when we are trying
2350     to find out the amount of memory needed, as well as during the real compile
2351     phase. The value of lengthptr distinguishes the two phases.
2352 nigel 77
2353     Arguments:
2354     optionsptr pointer to the option bits
2355     codeptr points to the pointer to the current code point
2356     ptrptr points to the current pattern pointer
2357     errorcodeptr points to error code variable
2358     firstbyteptr set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
2359     reqbyteptr set to the last literal character required, else < 0
2360     bcptr points to current branch chain
2361     cd contains pointers to tables etc.
2362 nigel 93 lengthptr NULL during the real compile phase
2363     points to length accumulator during pre-compile phase
2364 nigel 77
2365     Returns: TRUE on success
2366     FALSE, with *errorcodeptr set non-zero on error
2367     */
2368    
2369     static BOOL
2370 nigel 93 compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,
2371     int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
2372     compile_data *cd, int *lengthptr)
2373 nigel 77 {
2374     int repeat_type, op_type;
2375     int repeat_min = 0, repeat_max = 0; /* To please picky compilers */
2376     int bravalue = 0;
2377     int greedy_default, greedy_non_default;
2378     int firstbyte, reqbyte;
2379     int zeroreqbyte, zerofirstbyte;
2380     int req_caseopt, reqvary, tempreqvary;
2381     int options = *optionsptr;
2382     int after_manual_callout = 0;
2383 nigel 93 int length_prevgroup = 0;
2384 nigel 77 register int c;
2385     register uschar *code = *codeptr;
2386 nigel 93 uschar *last_code = code;
2387     uschar *orig_code = code;
2388 nigel 77 uschar *tempcode;
2389     BOOL inescq = FALSE;
2390     BOOL groupsetfirstbyte = FALSE;
2391     const uschar *ptr = *ptrptr;
2392     const uschar *tempptr;
2393     uschar *previous = NULL;
2394     uschar *previous_callout = NULL;
2395 nigel 93 uschar *save_hwm = NULL;
2396 nigel 77 uschar classbits[32];
2397    
2398     #ifdef SUPPORT_UTF8
2399     BOOL class_utf8;
2400     BOOL utf8 = (options & PCRE_UTF8) != 0;
2401     uschar *class_utf8data;
2402 ph10 300 uschar *class_utf8data_base;
2403 nigel 77 uschar utf8_char[6];
2404     #else
2405     BOOL utf8 = FALSE;
2406 nigel 93 uschar *utf8_char = NULL;
2407 nigel 77 #endif
2408    
2409 nigel 93 #ifdef DEBUG
2410     if (lengthptr != NULL) DPRINTF((">> start branch\n"));
2411     #endif
2412    
2413 nigel 77 /* Set up the default and non-default settings for greediness */
2414    
2415     greedy_default = ((options & PCRE_UNGREEDY) != 0);
2416     greedy_non_default = greedy_default ^ 1;
2417    
2418     /* Initialize no first byte, no required byte. REQ_UNSET means "no char
2419     matching encountered yet". It gets changed to REQ_NONE if we hit something that
2420     matches a non-fixed char first char; reqbyte just remains unset if we never
2421     find one.
2422    
2423     When we hit a repeat whose minimum is zero, we may have to adjust these values
2424     to take the zero repeat into account. This is implemented by setting them to
2425     zerofirstbyte and zeroreqbyte when such a repeat is encountered. The individual
2426     item types that can be repeated set these backoff variables appropriately. */
2427    
2428     firstbyte = reqbyte = zerofirstbyte = zeroreqbyte = REQ_UNSET;
2429    
2430     /* The variable req_caseopt contains either the REQ_CASELESS value or zero,
2431     according to the current setting of the caseless flag. REQ_CASELESS is a bit
2432     value > 255. It is added into the firstbyte or reqbyte variables to record the
2433     case status of the value. This is used only for ASCII characters. */
2434    
2435     req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
2436    
2437     /* Switch on next character until the end of the branch */
2438    
2439     for (;; ptr++)
2440     {
2441     BOOL negate_class;
2442 ph10 286 BOOL should_flip_negation;
2443 nigel 77 BOOL possessive_quantifier;
2444     BOOL is_quantifier;
2445 nigel 93 BOOL is_recurse;
2446 ph10 180 BOOL reset_bracount;
2447 nigel 77 int class_charcount;
2448     int class_lastchar;
2449     int newoptions;
2450     int recno;
2451 ph10 172 int refsign;
2452 nigel 77 int skipbytes;
2453     int subreqbyte;
2454     int subfirstbyte;
2455 nigel 93 int terminator;
2456 nigel 77 int mclength;
2457     uschar mcbuffer[8];
2458    
2459 nigel 93 /* Get next byte in the pattern */
2460 nigel 77
2461     c = *ptr;
2462 ph10 334
2463 nigel 93 /* If we are in the pre-compile phase, accumulate the length used for the
2464     previous cycle of this loop. */
2465    
2466     if (lengthptr != NULL)
2467     {
2468     #ifdef DEBUG
2469     if (code > cd->hwm) cd->hwm = code; /* High water info */
2470     #endif
2471     if (code > cd->start_workspace + COMPILE_WORK_SIZE) /* Check for overrun */
2472     {
2473     *errorcodeptr = ERR52;
2474     goto FAILED;
2475     }
2476    
2477     /* There is at least one situation where code goes backwards: this is the
2478     case of a zero quantifier after a class (e.g. [ab]{0}). At compile time,
2479     the class is simply eliminated. However, it is created first, so we have to
2480     allow memory for it. Therefore, don't ever reduce the length at this point.
2481     */
2482    
2483     if (code < last_code) code = last_code;
2484 ph10 202
2485     /* Paranoid check for integer overflow */
2486    
2487     if (OFLOW_MAX - *lengthptr < code - last_code)
2488     {
2489     *errorcodeptr = ERR20;
2490     goto FAILED;
2491     }
2492    
2493 nigel 93 *lengthptr += code - last_code;
2494     DPRINTF(("length=%d added %d c=%c\n", *lengthptr, code - last_code, c));
2495    
2496     /* If "previous" is set and it is not at the start of the work space, move
2497     it back to there, in order to avoid filling up the work space. Otherwise,
2498     if "previous" is NULL, reset the current code pointer to the start. */
2499    
2500     if (previous != NULL)
2501     {
2502     if (previous > orig_code)
2503     {
2504     memmove(orig_code, previous, code - previous);
2505     code -= previous - orig_code;
2506     previous = orig_code;
2507     }
2508     }
2509     else code = orig_code;
2510    
2511     /* Remember where this code item starts so we can pick up the length
2512     next time round. */
2513    
2514     last_code = code;
2515     }
2516    
2517     /* In the real compile phase, just check the workspace used by the forward
2518     reference list. */
2519    
2520     else if (cd->hwm > cd->start_workspace + COMPILE_WORK_SIZE)
2521     {
2522     *errorcodeptr = ERR52;
2523     goto FAILED;
2524     }
2525    
2526 nigel 77 /* If in \Q...\E, check for the end; if not, we have a literal */
2527    
2528     if (inescq && c != 0)
2529     {
2530     if (c == '\\' && ptr[1] == 'E')
2531     {
2532     inescq = FALSE;
2533     ptr++;
2534     continue;
2535     }
2536     else
2537     {
2538     if (previous_callout != NULL)
2539     {
2540 nigel 93 if (lengthptr == NULL) /* Don't attempt in pre-compile phase */
2541     complete_callout(previous_callout, ptr, cd);
2542 nigel 77 previous_callout = NULL;
2543     }
2544     if ((options & PCRE_AUTO_CALLOUT) != 0)
2545     {
2546     previous_callout = code;
2547     code = auto_callout(code, ptr, cd);
2548     }
2549     goto NORMAL_CHAR;
2550     }
2551     }
2552    
2553     /* Fill in length of a previous callout, except when the next thing is
2554     a quantifier. */
2555    
2556     is_quantifier = c == '*' || c == '+' || c == '?' ||
2557     (c == '{' && is_counted_repeat(ptr+1));
2558    
2559     if (!is_quantifier && previous_callout != NULL &&
2560     after_manual_callout-- <= 0)
2561     {
2562 nigel 93 if (lengthptr == NULL) /* Don't attempt in pre-compile phase */
2563     complete_callout(previous_callout, ptr, cd);
2564 nigel 77 previous_callout = NULL;
2565     }
2566    
2567     /* In extended mode, skip white space and comments */
2568    
2569     if ((options & PCRE_EXTENDED) != 0)
2570     {
2571     if ((cd->ctypes[c] & ctype_space) != 0) continue;
2572     if (c == '#')
2573     {
2574 nigel 93 while (*(++ptr) != 0)
2575 nigel 91 {
2576 nigel 93 if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
2577 nigel 91 }
2578 nigel 93 if (*ptr != 0) continue;
2579    
2580 nigel 91 /* Else fall through to handle end of string */
2581     c = 0;
2582 nigel 77 }
2583     }
2584    
2585     /* No auto callout for quantifiers. */
2586    
2587     if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier)
2588     {
2589     previous_callout = code;
2590     code = auto_callout(code, ptr, cd);
2591     }
2592    
2593     switch(c)
2594     {
2595 nigel 93 /* ===================================================================*/
2596     case 0: /* The branch terminates at string end */
2597     case '|': /* or | or ) */
2598 nigel 77 case ')':
2599     *firstbyteptr = firstbyte;
2600     *reqbyteptr = reqbyte;
2601     *codeptr = code;
2602     *ptrptr = ptr;
2603 nigel 93 if (lengthptr != NULL)
2604     {
2605 ph10 202 if (OFLOW_MAX - *lengthptr < code - last_code)
2606     {
2607     *errorcodeptr = ERR20;
2608     goto FAILED;
2609     }
2610 nigel 93 *lengthptr += code - last_code; /* To include callout length */
2611     DPRINTF((">> end branch\n"));
2612     }
2613 nigel 77 return TRUE;
2614    
2615 nigel 93
2616     /* ===================================================================*/
2617 nigel 77 /* Handle single-character metacharacters. In multiline mode, ^ disables
2618     the setting of any following char as a first character. */
2619    
2620     case '^':
2621     if ((options & PCRE_MULTILINE) != 0)
2622     {
2623     if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2624     }
2625     previous = NULL;
2626     *code++ = OP_CIRC;
2627     break;
2628    
2629     case '$':
2630     previous = NULL;
2631     *code++ = OP_DOLL;
2632     break;
2633    
2634     /* There can never be a first char if '.' is first, whatever happens about
2635     repeats. The value of reqbyte doesn't change either. */
2636    
2637     case '.':
2638     if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2639     zerofirstbyte = firstbyte;
2640     zeroreqbyte = reqbyte;
2641     previous = code;
2642     *code++ = OP_ANY;
2643     break;
2644    
2645 nigel 93
2646     /* ===================================================================*/
2647 nigel 87 /* Character classes. If the included characters are all < 256, we build a
2648     32-byte bitmap of the permitted characters, except in the special case
2649     where there is only one such character. For negated classes, we build the
2650     map as usual, then invert it at the end. However, we use a different opcode
2651     so that data characters > 255 can be handled correctly.
2652 nigel 77
2653     If the class contains characters outside the 0-255 range, a different
2654     opcode is compiled. It may optionally have a bit map for characters < 256,
2655     but those above are are explicitly listed afterwards. A flag byte tells
2656     whether the bitmap is present, and whether this is a negated class or not.
2657     */
2658    
2659     case '[':
2660     previous = code;
2661    
2662     /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
2663     they are encountered at the top level, so we'll do that too. */
2664    
2665     if ((ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
2666 ph10 295 check_posix_syntax(ptr, &tempptr))
2667 nigel 77 {
2668     *errorcodeptr = (ptr[1] == ':')? ERR13 : ERR31;
2669     goto FAILED;
2670     }
2671    
2672 ph10 205 /* If the first character is '^', set the negation flag and skip it. Also,
2673 ph10 208 if the first few characters (either before or after ^) are \Q\E or \E we
2674 ph10 205 skip them too. This makes for compatibility with Perl. */
2675 ph10 208
2676 ph10 205 negate_class = FALSE;
2677     for (;;)
2678 nigel 77 {
2679     c = *(++ptr);
2680 ph10 205 if (c == '\\')
2681     {
2682 ph10 208 if (ptr[1] == 'E') ptr++;
2683 ph10 205 else if (strncmp((const char *)ptr+1, "Q\\E", 3) == 0) ptr += 3;
2684 ph10 208 else break;
2685 ph10 205 }
2686     else if (!negate_class && c == '^')
2687     negate_class = TRUE;
2688     else break;
2689 ph10 208 }
2690 nigel 77
2691 ph10 286 /* If a class contains a negative special such as \S, we need to flip the
2692     negation flag at the end, so that support for characters > 255 works
2693 ph10 264 correctly (they are all included in the class). */
2694    
2695     should_flip_negation = FALSE;
2696    
2697 nigel 77 /* Keep a count of chars with values < 256 so that we can optimize the case
2698 nigel 93 of just a single character (as long as it's < 256). However, For higher
2699     valued UTF-8 characters, we don't yet do any optimization. */
2700 nigel 77
2701     class_charcount = 0;
2702     class_lastchar = -1;
2703    
2704 nigel 93 /* Initialize the 32-char bit map to all zeros. We build the map in a
2705     temporary bit of memory, in case the class contains only 1 character (less
2706     than 256), because in that case the compiled code doesn't use the bit map.
2707     */
2708    
2709     memset(classbits, 0, 32 * sizeof(uschar));
2710    
2711 nigel 77 #ifdef SUPPORT_UTF8
2712     class_utf8 = FALSE; /* No chars >= 256 */
2713 nigel 93 class_utf8data = code + LINK_SIZE + 2; /* For UTF-8 items */
2714 ph10 309 class_utf8data_base = class_utf8data; /* For resetting in pass 1 */
2715 nigel 77 #endif
2716    
2717     /* Process characters until ] is reached. By writing this as a "do" it
2718 nigel 93 means that an initial ] is taken as a data character. At the start of the
2719     loop, c contains the first byte of the character. */
2720 nigel 77
2721 nigel 93 if (c != 0) do
2722 nigel 77 {
2723 nigel 93 const uschar *oldptr;
2724    
2725 nigel 77 #ifdef SUPPORT_UTF8
2726     if (utf8 && c > 127)
2727     { /* Braces are required because the */
2728     GETCHARLEN(c, ptr, ptr); /* macro generates multiple statements */
2729     }
2730 ph10 309
2731 ph10 300 /* In the pre-compile phase, accumulate the length of any UTF-8 extra
2732 ph10 309 data and reset the pointer. This is so that very large classes that
2733 ph10 300 contain a zillion UTF-8 characters no longer overwrite the work space
2734 ph10 309 (which is on the stack). */
2735    
2736 ph10 300 if (lengthptr != NULL)
2737     {
2738     *lengthptr += class_utf8data - class_utf8data_base;
2739 ph10 309 class_utf8data = class_utf8data_base;
2740     }
2741    
2742 nigel 77 #endif
2743    
2744     /* Inside \Q...\E everything is literal except \E */
2745    
2746     if (inescq)
2747     {
2748 nigel 93 if (c == '\\' && ptr[1] == 'E') /* If we are at \E */
2749 nigel 77 {
2750 nigel 93 inescq = FALSE; /* Reset literal state */
2751     ptr++; /* Skip the 'E' */
2752     continue; /* Carry on with next */
2753 nigel 77 }
2754 nigel 93 goto CHECK_RANGE; /* Could be range if \E follows */
2755 nigel 77 }
2756    
2757     /* Handle POSIX class names. Perl allows a negation extension of the
2758     form [:^name:]. A square bracket that doesn't match the syntax is
2759     treated as a literal. We also recognize the POSIX constructions
2760     [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
2761     5.6 and 5.8 do. */
2762    
2763     if (c == '[' &&
2764     (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
2765 ph10 295 check_posix_syntax(ptr, &tempptr))
2766 nigel 77 {
2767     BOOL local_negate = FALSE;
2768 nigel 87 int posix_class, taboffset, tabopt;
2769 nigel 77 register const uschar *cbits = cd->cbits;
2770 nigel 87 uschar pbits[32];
2771 nigel 77
2772     if (ptr[1] != ':')
2773     {
2774     *errorcodeptr = ERR31;
2775     goto FAILED;
2776     }
2777    
2778     ptr += 2;
2779     if (*ptr == '^')
2780     {
2781     local_negate = TRUE;
2782 ph10 286 should_flip_negation = TRUE; /* Note negative special */
2783 nigel 77 ptr++;
2784     }
2785    
2786     posix_class = check_posix_name(ptr, tempptr - ptr);
2787     if (posix_class < 0)
2788     {
2789     *errorcodeptr = ERR30;
2790     goto FAILED;
2791     }
2792    
2793     /* If matching is caseless, upper and lower are converted to
2794     alpha. This relies on the fact that the class table starts with
2795     alpha, lower, upper as the first 3 entries. */
2796    
2797     if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
2798     posix_class = 0;
2799    
2800 nigel 87 /* We build the bit map for the POSIX class in a chunk of local store
2801     because we may be adding and subtracting from it, and we don't want to
2802     subtract bits that may be in the main map already. At the end we or the
2803     result into the bit map that is being built. */
2804 nigel 77
2805     posix_class *= 3;
2806 nigel 87
2807     /* Copy in the first table (always present) */
2808    
2809     memcpy(pbits, cbits + posix_class_maps[posix_class],
2810     32 * sizeof(uschar));
2811    
2812     /* If there is a second table, add or remove it as required. */
2813    
2814     taboffset = posix_class_maps[posix_class + 1];
2815     tabopt = posix_class_maps[posix_class + 2];
2816    
2817     if (taboffset >= 0)
2818 nigel 77 {
2819 nigel 87 if (tabopt >= 0)
2820     for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];
2821 nigel 77 else
2822 nigel 87 for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];
2823 nigel 77 }
2824    
2825 nigel 87 /* Not see if we need to remove any special characters. An option
2826     value of 1 removes vertical space and 2 removes underscore. */
2827    
2828     if (tabopt < 0) tabopt = -tabopt;
2829     if (tabopt == 1) pbits[1] &= ~0x3c;
2830     else if (tabopt == 2) pbits[11] &= 0x7f;
2831    
2832     /* Add the POSIX table or its complement into the main table that is
2833     being built and we are done. */
2834    
2835     if (local_negate)
2836     for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];
2837     else
2838     for (c = 0; c < 32; c++) classbits[c] |= pbits[c];
2839    
2840 nigel 77 ptr = tempptr + 1;
2841     class_charcount = 10; /* Set > 1; assumes more than 1 per class */
2842     continue; /* End of POSIX syntax handling */
2843     }
2844    
2845     /* Backslash may introduce a single character, or it may introduce one
2846 nigel 93 of the specials, which just set a flag. The sequence \b is a special
2847     case. Inside a class (and only there) it is treated as backspace.
2848     Elsewhere it marks a word boundary. Other escapes have preset maps ready
2849 ph10 205 to 'or' into the one we are building. We assume they have more than one
2850 nigel 77 character in them, so set class_charcount bigger than one. */
2851    
2852     if (c == '\\')
2853     {
2854 nigel 93 c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
2855     if (*errorcodeptr != 0) goto FAILED;
2856 nigel 77
2857 ph10 275 if (-c == ESC_b) c = '\b'; /* \b is backspace in a class */
2858 nigel 77 else if (-c == ESC_X) c = 'X'; /* \X is literal X in a class */
2859 nigel 93 else if (-c == ESC_R) c = 'R'; /* \R is literal R in a class */
2860 nigel 77 else if (-c == ESC_Q) /* Handle start of quoted string */
2861     {
2862     if (ptr[1] == '\\' && ptr[2] == 'E')
2863     {
2864     ptr += 2; /* avoid empty string */
2865     }
2866     else inescq = TRUE;
2867     continue;
2868     }
2869 ph10 220 else if (-c == ESC_E) continue; /* Ignore orphan \E */
2870 nigel 77
2871     if (c < 0)
2872     {
2873     register const uschar *cbits = cd->cbits;
2874     class_charcount += 2; /* Greater than 1 is what matters */
2875 nigel 93
2876     /* Save time by not doing this in the pre-compile phase. */
2877    
2878     if (lengthptr == NULL) switch (-c)
2879 nigel 77 {
2880     case ESC_d:
2881     for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];
2882     continue;
2883    
2884     case ESC_D:
2885 ph10 286 should_flip_negation = TRUE;
2886 nigel 77 for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
2887     continue;
2888    
2889     case ESC_w:
2890     for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];
2891     continue;
2892    
2893     case ESC_W:
2894 ph10 286 should_flip_negation = TRUE;
2895 nigel 77 for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
2896     continue;
2897    
2898     case ESC_s:
2899     for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
2900     classbits[1] &= ~0x08; /* Perl 5.004 onwards omits VT from \s */
2901     continue;
2902    
2903     case ESC_S:
2904 ph10 286 should_flip_negation = TRUE;
2905 nigel 77 for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
2906     classbits[1] |= 0x08; /* Perl 5.004 onwards omits VT from \s */
2907     continue;
2908    
2909 nigel 93 default: /* Not recognized; fall through */
2910     break; /* Need "default" setting to stop compiler warning. */
2911     }
2912    
2913     /* In the pre-compile phase, just do the recognition. */
2914    
2915     else if (c == -ESC_d || c == -ESC_D || c == -ESC_w ||
2916     c == -ESC_W || c == -ESC_s || c == -ESC_S) continue;
2917 ph10 180
2918 ph10 178 /* We need to deal with \H, \h, \V, and \v in both phases because
2919     they use extra memory. */
2920 ph10 180
2921 ph10 178 if (-c == ESC_h)
2922     {
2923     SETBIT(classbits, 0x09); /* VT */
2924     SETBIT(classbits, 0x20); /* SPACE */
2925 ph10 180 SETBIT(classbits, 0xa0); /* NSBP */
2926 ph10 178 #ifdef SUPPORT_UTF8
2927     if (utf8)
2928 ph10 180 {
2929 ph10 178 class_utf8 = TRUE;
2930     *class_utf8data++ = XCL_SINGLE;
2931 ph10 180 class_utf8data += _pcre_ord2utf8(0x1680, class_utf8data);
2932 ph10 178 *class_utf8data++ = XCL_SINGLE;
2933 ph10 180 class_utf8data += _pcre_ord2utf8(0x180e, class_utf8data);
2934     *class_utf8data++ = XCL_RANGE;
2935     class_utf8data += _pcre_ord2utf8(0x2000, class_utf8data);
2936     class_utf8data += _pcre_ord2utf8(0x200A, class_utf8data);
2937 ph10 178 *class_utf8data++ = XCL_SINGLE;
2938 ph10 180 class_utf8data += _pcre_ord2utf8(0x202f, class_utf8data);
2939 ph10 178 *class_utf8data++ = XCL_SINGLE;
2940 ph10 180 class_utf8data += _pcre_ord2utf8(0x205f, class_utf8data);
2941 ph10 178 *class_utf8data++ = XCL_SINGLE;
2942 ph10 180 class_utf8data += _pcre_ord2utf8(0x3000, class_utf8data);
2943     }
2944     #endif
2945     continue;
2946     }
2947 nigel 93
2948 ph10 178 if (-c == ESC_H)
2949     {
2950     for (c = 0; c < 32; c++)
2951     {
2952     int x = 0xff;
2953     switch (c)
2954 ph10 180 {
2955 ph10 178 case 0x09/8: x ^= 1 << (0x09%8); break;
2956     case 0x20/8: x ^= 1 << (0x20%8); break;
2957     case 0xa0/8: x ^= 1 << (0xa0%8); break;
2958     default: break;
2959     }
2960     classbits[c] |= x;
2961 ph10 180 }
2962    
2963 ph10 178 #ifdef SUPPORT_UTF8
2964     if (utf8)
2965 ph10 180 {
2966 ph10 178 class_utf8 = TRUE;
2967 ph10 180 *class_utf8data++ = XCL_RANGE;
2968     class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
2969     class_utf8data += _pcre_ord2utf8(0x167f, class_utf8data);
2970     *class_utf8data++ = XCL_RANGE;
2971     class_utf8data += _pcre_ord2utf8(0x1681, class_utf8data);
2972     class_utf8data += _pcre_ord2utf8(0x180d, class_utf8data);
2973     *class_utf8data++ = XCL_RANGE;
2974     class_utf8data += _pcre_ord2utf8(0x180f, class_utf8data);
2975     class_utf8data += _pcre_ord2utf8(0x1fff, class_utf8data);
2976     *class_utf8data++ = XCL_RANGE;
2977     class_utf8data += _pcre_ord2utf8(0x200B, class_utf8data);
2978     class_utf8data += _pcre_ord2utf8(0x202e, class_utf8data);
2979     *class_utf8data++ = XCL_RANGE;
2980     class_utf8data += _pcre_ord2utf8(0x2030, class_utf8data);
2981     class_utf8data += _pcre_ord2utf8(0x205e, class_utf8data);
2982     *class_utf8data++ = XCL_RANGE;
2983     class_utf8data += _pcre_ord2utf8(0x2060, class_utf8data);
2984     class_utf8data += _pcre_ord2utf8(0x2fff, class_utf8data);
2985     *class_utf8data++ = XCL_RANGE;
2986     class_utf8data += _pcre_ord2utf8(0x3001, class_utf8data);
2987     class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
2988     }
2989     #endif
2990     continue;
2991     }
2992 ph10 178
2993     if (-c == ESC_v)
2994     {
2995     SETBIT(classbits, 0x0a); /* LF */
2996     SETBIT(classbits, 0x0b); /* VT */
2997 ph10 180 SETBIT(classbits, 0x0c); /* FF */
2998     SETBIT(classbits, 0x0d); /* CR */
2999     SETBIT(classbits, 0x85); /* NEL */
3000 ph10 178 #ifdef SUPPORT_UTF8
3001     if (utf8)
3002 ph10 180 {
3003 ph10 178 class_utf8 = TRUE;
3004 ph10 180 *class_utf8data++ = XCL_RANGE;
3005     class_utf8data += _pcre_ord2utf8(0x2028, class_utf8data);
3006     class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
3007     }
3008     #endif
3009     continue;
3010     }
3011 ph10 178
3012     if (-c == ESC_V)
3013     {
3014     for (c = 0; c < 32; c++)
3015     {
3016     int x = 0xff;
3017     switch (c)
3018 ph10 180 {
3019 ph10 178 case 0x0a/8: x ^= 1 << (0x0a%8);
3020     x ^= 1 << (0x0b%8);
3021     x ^= 1 << (0x0c%8);
3022 ph10 180 x ^= 1 << (0x0d%8);
3023 ph10 178 break;
3024     case 0x85/8: x ^= 1 << (0x85%8); break;
3025     default: break;
3026     }
3027     classbits[c] |= x;
3028 ph10 180 }
3029    
3030 ph10 178 #ifdef SUPPORT_UTF8
3031     if (utf8)
3032 ph10 180 {
3033 ph10 178 class_utf8 = TRUE;
3034 ph10 180 *class_utf8data++ = XCL_RANGE;
3035     class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
3036     class_utf8data += _pcre_ord2utf8(0x2027, class_utf8data);
3037     *class_utf8data++ = XCL_RANGE;
3038     class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
3039     class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
3040     }
3041     #endif
3042     continue;
3043     }
3044 ph10 178
3045 nigel 93 /* We need to deal with \P and \p in both phases. */
3046    
3047 nigel 77 #ifdef SUPPORT_UCP
3048 nigel 93 if (-c == ESC_p || -c == ESC_P)
3049     {
3050     BOOL negated;
3051     int pdata;
3052     int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
3053     if (ptype < 0) goto FAILED;
3054     class_utf8 = TRUE;
3055     *class_utf8data++ = ((-c == ESC_p) != negated)?
3056     XCL_PROP : XCL_NOTPROP;
3057     *class_utf8data++ = ptype;
3058     *class_utf8data++ = pdata;
3059     class_charcount -= 2; /* Not a < 256 character */
3060 nigel 77 continue;
3061 nigel 93 }
3062 nigel 77 #endif
3063 nigel 93 /* Unrecognized escapes are faulted if PCRE is running in its
3064     strict mode. By default, for compatibility with Perl, they are
3065     treated as literals. */
3066 nigel 77
3067 nigel 93 if ((options & PCRE_EXTRA) != 0)
3068     {
3069     *errorcodeptr = ERR7;
3070     goto FAILED;
3071     }
3072 nigel 77
3073 nigel 93 class_charcount -= 2; /* Undo the default count from above */
3074     c = *ptr; /* Get the final character and fall through */
3075 nigel 77 }
3076    
3077     /* Fall through if we have a single character (c >= 0). This may be
3078 nigel 93 greater than 256 in UTF-8 mode. */
3079 nigel 77
3080     } /* End of backslash handling */
3081    
3082     /* A single character may be followed by '-' to form a range. However,
3083     Perl does not permit ']' to be the end of the range. A '-' character
3084 nigel 93 at the end is treated as a literal. Perl ignores orphaned \E sequences
3085     entirely. The code for handling \Q and \E is messy. */
3086 nigel 77
3087 nigel 93 CHECK_RANGE:
3088     while (ptr[1] == '\\' && ptr[2] == 'E')
3089 nigel 77 {
3090 nigel 93 inescq = FALSE;
3091     ptr += 2;
3092     }
3093    
3094     oldptr = ptr;
3095 ph10 231
3096 ph10 230 /* Remember \r or \n */
3097 ph10 231
3098     if (c == '\r' || c == '\n') cd->external_flags |= PCRE_HASCRORLF;
3099    
3100 ph10 230 /* Check for range */
3101 nigel 93
3102     if (!inescq && ptr[1] == '-')
3103     {
3104 nigel 77 int d;
3105     ptr += 2;
3106 nigel 93 while (*ptr == '\\' && ptr[1] == 'E') ptr += 2;
3107 nigel 77
3108 nigel 93 /* If we hit \Q (not followed by \E) at this point, go into escaped
3109     mode. */
3110    
3111     while (*ptr == '\\' && ptr[1] == 'Q')
3112     {
3113     ptr += 2;
3114     if (*ptr == '\\' && ptr[1] == 'E') { ptr += 2; continue; }
3115     inescq = TRUE;
3116     break;
3117     }
3118    
3119     if (*ptr == 0 || (!inescq && *ptr == ']'))
3120     {
3121     ptr = oldptr;
3122     goto LONE_SINGLE_CHARACTER;
3123     }
3124    
3125 nigel 77 #ifdef SUPPORT_UTF8
3126     if (utf8)
3127     { /* Braces are required because the */
3128     GETCHARLEN(d, ptr, ptr); /* macro generates multiple statements */
3129     }
3130     else
3131     #endif
3132     d = *ptr; /* Not UTF-8 mode */
3133    
3134     /* The second part of a range can be a single-character escape, but
3135     not any of the other escapes. Perl 5.6 treats a hyphen as a literal
3136     in such circumstances. */
3137    
3138 nigel 93 if (!inescq && d == '\\')
3139 nigel 77 {
3140 nigel 93 d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
3141     if (*errorcodeptr != 0) goto FAILED;
3142 nigel 77
3143 ph10 275 /* \b is backspace; \X is literal X; \R is literal R; any other
3144 nigel 93 special means the '-' was literal */
3145 nigel 77
3146     if (d < 0)
3147     {
3148     if (d == -ESC_b) d = '\b';
3149 nigel 93 else if (d == -ESC_X) d = 'X';
3150     else if (d == -ESC_R) d = 'R'; else
3151 nigel 77 {
3152 nigel 93 ptr = oldptr;
3153 nigel 77 goto LONE_SINGLE_CHARACTER; /* A few lines below */
3154     }
3155     }
3156     }
3157    
3158 nigel 93 /* Check that the two values are in the correct order. Optimize
3159     one-character ranges */
3160 nigel 77
3161 nigel 93 if (d < c)
3162     {
3163     *errorcodeptr = ERR8;
3164     goto FAILED;
3165     }
3166    
3167 nigel 77 if (d == c) goto LONE_SINGLE_CHARACTER; /* A few lines below */
3168    
3169 ph10 230 /* Remember \r or \n */
3170 ph10 231
3171     if (d == '\r' || d == '\n') cd->external_flags |= PCRE_HASCRORLF;
3172    
3173 nigel 77 /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
3174     matching, we have to use an XCLASS with extra data items. Caseless
3175     matching for characters > 127 is available only if UCP support is
3176     available. */
3177    
3178     #ifdef SUPPORT_UTF8
3179     if (utf8 && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
3180     {
3181     class_utf8 = TRUE;
3182    
3183     /* With UCP support, we can find the other case equivalents of
3184     the relevant characters. There may be several ranges. Optimize how
3185     they fit with the basic range. */
3186    
3187     #ifdef SUPPORT_UCP
3188     if ((options & PCRE_CASELESS) != 0)
3189     {
3190 nigel 93 unsigned int occ, ocd;
3191     unsigned int cc = c;
3192     unsigned int origd = d;
3193 nigel 77 while (get_othercase_range(&cc, origd, &occ, &ocd))
3194     {
3195 ph10 180 if (occ >= (unsigned int)c &&
3196     ocd <= (unsigned int)d)
3197 ph10 176 continue; /* Skip embedded ranges */
3198 nigel 77
3199 ph10 180 if (occ < (unsigned int)c &&
3200 ph10 176 ocd >= (unsigned int)c - 1) /* Extend the basic range */
3201 nigel 77 { /* if there is overlap, */
3202     c = occ; /* noting that if occ < c */
3203     continue; /* we can't have ocd > d */
3204     } /* because a subrange is */
3205 ph10 180 if (ocd > (unsigned int)d &&
3206 ph10 176 occ <= (unsigned int)d + 1) /* always shorter than */
3207 nigel 77 { /* the basic range. */
3208     d = ocd;
3209     continue;
3210     }
3211    
3212     if (occ == ocd)
3213     {
3214     *class_utf8data++ = XCL_SINGLE;
3215     }
3216     else
3217     {
3218     *class_utf8data++ = XCL_RANGE;
3219     class_utf8data += _pcre_ord2utf8(occ, class_utf8data);
3220     }
3221     class_utf8data += _pcre_ord2utf8(ocd, class_utf8data);
3222     }
3223     }
3224     #endif /* SUPPORT_UCP */
3225    
3226     /* Now record the original range, possibly modified for UCP caseless
3227     overlapping ranges. */
3228    
3229     *class_utf8data++ = XCL_RANGE;
3230     class_utf8data += _pcre_ord2utf8(c, class_utf8data);
3231     class_utf8data += _pcre_ord2utf8(d, class_utf8data);
3232    
3233     /* With UCP support, we are done. Without UCP support, there is no
3234     caseless matching for UTF-8 characters > 127; we can use the bit map
3235     for the smaller ones. */
3236    
3237     #ifdef SUPPORT_UCP
3238     continue; /* With next character in the class */
3239     #else
3240     if ((options & PCRE_CASELESS) == 0 || c > 127) continue;
3241    
3242     /* Adjust upper limit and fall through to set up the map */
3243    
3244     d = 127;
3245    
3246     #endif /* SUPPORT_UCP */
3247     }
3248     #endif /* SUPPORT_UTF8 */
3249    
3250     /* We use the bit map for all cases when not in UTF-8 mode; else
3251     ranges that lie entirely within 0-127 when there is UCP support; else
3252     for partial ranges without UCP support. */
3253    
3254 nigel 93 class_charcount += d - c + 1;
3255     class_lastchar = d;
3256    
3257     /* We can save a bit of time by skipping this in the pre-compile. */
3258    
3259     if (lengthptr == NULL) for (; c <= d; c++)
3260 nigel 77 {
3261     classbits[c/8] |= (1 << (c&7));
3262     if ((options & PCRE_CASELESS) != 0)
3263     {
3264     int uc = cd->fcc[c]; /* flip case */
3265     classbits[uc/8] |= (1 << (uc&7));
3266     }
3267     }
3268    
3269     continue; /* Go get the next char in the class */
3270     }
3271    
3272     /* Handle a lone single character - we can get here for a normal
3273     non-escape char, or after \ that introduces a single character or for an
3274     apparent range that isn't. */
3275    
3276     LONE_SINGLE_CHARACTER:
3277 ph10 231
3278 nigel 77 /* Handle a character that cannot go in the bit map */
3279    
3280     #ifdef SUPPORT_UTF8
3281     if (utf8 && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
3282     {
3283     class_utf8 = TRUE;
3284     *class_utf8data++ = XCL_SINGLE;
3285     class_utf8data += _pcre_ord2utf8(c, class_utf8data);
3286    
3287     #ifdef SUPPORT_UCP
3288     if ((options & PCRE_CASELESS) != 0)
3289     {
3290 nigel 93 unsigned int othercase;
3291     if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR)
3292 nigel 77 {
3293     *class_utf8data++ = XCL_SINGLE;
3294     class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
3295     }
3296     }
3297     #endif /* SUPPORT_UCP */
3298    
3299     }
3300     else
3301     #endif /* SUPPORT_UTF8 */
3302    
3303     /* Handle a single-byte character */
3304     {
3305     classbits[c/8] |= (1 << (c&7));
3306     if ((options & PCRE_CASELESS) != 0)
3307     {
3308     c = cd->fcc[c]; /* flip case */
3309     classbits[c/8] |= (1 << (c&7));
3310     }
3311     class_charcount++;
3312     class_lastchar = c;
3313     }
3314     }
3315    
3316 nigel 93 /* Loop until ']' reached. This "while" is the end of the "do" above. */
3317 nigel 77
3318 nigel 93 while ((c = *(++ptr)) != 0 && (c != ']' || inescq));
3319 nigel 77
3320 nigel 93 if (c == 0) /* Missing terminating ']' */
3321     {
3322     *errorcodeptr = ERR6;
3323     goto FAILED;
3324     }
3325 ph10 231
3326    
3327 ph10 230 /* This code has been disabled because it would mean that \s counts as
3328     an explicit \r or \n reference, and that's not really what is wanted. Now
3329     we set the flag only if there is a literal "\r" or "\n" in the class. */
3330 ph10 227
3331 ph10 230 #if 0
3332 ph10 226 /* Remember whether \r or \n are in this class */
3333 ph10 227
3334 ph10 226 if (negate_class)
3335     {
3336 ph10 230 if ((classbits[1] & 0x24) != 0x24) cd->external_flags |= PCRE_HASCRORLF;
3337 ph10 226 }
3338     else
3339     {
3340 ph10 230 if ((classbits[1] & 0x24) != 0) cd->external_flags |= PCRE_HASCRORLF;
3341 ph10 227 }
3342 ph10 230 #endif
3343 ph10 227
3344 ph10 231
3345 nigel 77 /* If class_charcount is 1, we saw precisely one character whose value is
3346 ph10 227 less than 256. As long as there were no characters >= 128 and there was no
3347     use of \p or \P, in other words, no use of any XCLASS features, we can
3348     optimize.
3349    
3350 ph10 223 In UTF-8 mode, we can optimize the negative case only if there were no
3351     characters >= 128 because OP_NOT and the related opcodes like OP_NOTSTAR
3352     operate on single-bytes only. This is an historical hangover. Maybe one day
3353     we can tidy these opcodes to handle multi-byte characters.
3354 nigel 77
3355     The optimization throws away the bit map. We turn the item into a
3356     1-character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
3357     that OP_NOT does not support multibyte characters. In the positive case, it
3358     can cause firstbyte to be set. Otherwise, there can be no first char if
3359     this item is first, whatever repeat count may follow. In the case of
3360     reqbyte, save the previous value for reinstating. */
3361    
3362     #ifdef SUPPORT_UTF8
3363 ph10 227 if (class_charcount == 1 && !class_utf8 &&
3364 ph10 223 (!utf8 || !negate_class || class_lastchar < 128))
3365 nigel 77 #else
3366     if (class_charcount == 1)
3367     #endif
3368     {
3369     zeroreqbyte = reqbyte;
3370    
3371     /* The OP_NOT opcode works on one-byte characters only. */
3372    
3373     if (negate_class)
3374     {
3375     if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
3376     zerofirstbyte = firstbyte;
3377     *code++ = OP_NOT;
3378     *code++ = class_lastchar;
3379     break;
3380     }
3381    
3382     /* For a single, positive character, get the value into mcbuffer, and
3383     then we can handle this with the normal one-character code. */
3384    
3385     #ifdef SUPPORT_UTF8
3386     if (utf8 && class_lastchar > 127)
3387     mclength = _pcre_ord2utf8(class_lastchar, mcbuffer);
3388     else
3389     #endif
3390     {
3391     mcbuffer[0] = class_lastchar;
3392     mclength = 1;
3393     }
3394     goto ONE_CHAR;
3395     } /* End of 1-char optimization */
3396    
3397     /* The general case - not the one-char optimization. If this is the first
3398     thing in the branch, there can be no first char setting, whatever the
3399     repeat count. Any reqbyte setting must remain unchanged after any kind of
3400     repeat. */
3401    
3402     if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
3403     zerofirstbyte = firstbyte;
3404     zeroreqbyte = reqbyte;
3405    
3406     /* If there are characters with values > 255, we have to compile an
3407 ph10 286 extended class, with its own opcode, unless there was a negated special
3408     such as \S in the class, because in that case all characters > 255 are in
3409     the class, so any that were explicitly given as well can be ignored. If
3410 ph10 264 (when there are explicit characters > 255 that must be listed) there are no
3411     characters < 256, we can omit the bitmap in the actual compiled code. */
3412 nigel 77
3413     #ifdef SUPPORT_UTF8
3414 ph10 264 if (class_utf8 && !should_flip_negation)
3415 nigel 77 {
3416     *class_utf8data++ = XCL_END; /* Marks the end of extra data */
3417     *code++ = OP_XCLASS;
3418     code += LINK_SIZE;
3419     *code = negate_class? XCL_NOT : 0;
3420    
3421 nigel 93 /* If the map is required, move up the extra data to make room for it;
3422     otherwise just move the code pointer to the end of the extra data. */
3423 nigel 77
3424     if (class_charcount > 0)
3425     {
3426     *code++ |= XCL_MAP;
3427 nigel 93 memmove(code + 32, code, class_utf8data - code);
3428 nigel 77 memcpy(code, classbits, 32);
3429 nigel 93 code = class_utf8data + 32;
3430 nigel 77 }
3431 nigel 93 else code = class_utf8data;
3432 nigel 77
3433     /* Now fill in the complete length of the item */
3434    
3435     PUT(previous, 1, code - previous);
3436     break; /* End of class handling */
3437     }
3438     #endif
3439    
3440 ph10 286 /* If there are no characters > 255, set the opcode to OP_CLASS or
3441     OP_NCLASS, depending on whether the whole class was negated and whether
3442     there were negative specials such as \S in the class. Then copy the 32-byte
3443 ph10 264 map into the code vector, negating it if necessary. */
3444 ph10 286
3445 ph10 264 *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
3446 nigel 77 if (negate_class)
3447     {
3448 nigel 93 if (lengthptr == NULL) /* Save time in the pre-compile phase */
3449     for (c = 0; c < 32; c++) code[c] = ~classbits[c];
3450 nigel 77 }
3451     else
3452     {
3453     memcpy(code, classbits, 32);
3454     }
3455     code += 32;
3456     break;
3457    
3458 nigel 93
3459     /* ===================================================================*/
3460 nigel 77 /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
3461     has been tested above. */
3462    
3463     case '{':
3464     if (!is_quantifier) goto NORMAL_CHAR;
3465     ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);
3466     if (*errorcodeptr != 0) goto FAILED;
3467     goto REPEAT;
3468    
3469     case '*':
3470     repeat_min = 0;
3471     repeat_max = -1;
3472     goto REPEAT;
3473    
3474     case '+':
3475     repeat_min = 1;
3476     repeat_max = -1;
3477     goto REPEAT;
3478    
3479     case '?':
3480     repeat_min = 0;
3481     repeat_max = 1;
3482    
3483     REPEAT:
3484     if (previous == NULL)
3485     {
3486     *errorcodeptr = ERR9;
3487     goto FAILED;
3488     }
3489    
3490     if (repeat_min == 0)
3491     {
3492     firstbyte = zerofirstbyte; /* Adjust for zero repeat */
3493     reqbyte = zeroreqbyte; /* Ditto */
3494     }
3495    
3496     /* Remember whether this is a variable length repeat */
3497    
3498     reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;
3499    
3500     op_type = 0; /* Default single-char op codes */
3501     possessive_quantifier = FALSE; /* Default not possessive quantifier */
3502    
3503     /* Save start of previous item, in case we have to move it up to make space
3504     for an inserted OP_ONCE for the additional '+' extension. */
3505    
3506     tempcode = previous;
3507    
3508     /* If the next character is '+', we have a possessive quantifier. This
3509     implies greediness, whatever the setting of the PCRE_UNGREEDY option.
3510     If the next character is '?' this is a minimizing repeat, by default,
3511     but if PCRE_UNGREEDY is set, it works the other way round. We change the
3512     repeat type to the non-default. */
3513    
3514     if (ptr[1] == '+')
3515     {
3516     repeat_type = 0; /* Force greedy */
3517     possessive_quantifier = TRUE;
3518     ptr++;
3519     }
3520     else if (ptr[1] == '?')
3521     {
3522     repeat_type = greedy_non_default;
3523     ptr++;
3524     }
3525     else repeat_type = greedy_default;
3526    
3527     /* If previous was a character match, abolish the item and generate a
3528     repeat item instead. If a char item has a minumum of more than one, ensure
3529     that it is set in reqbyte - it might not be if a sequence such as x{3} is
3530     the first thing in a branch because the x will have gone into firstbyte
3531     instead. */
3532    
3533     if (*previous == OP_CHAR || *previous == OP_CHARNC)
3534     {
3535     /* Deal with UTF-8 characters that take up more than one byte. It's
3536     easier to write this out separately than try to macrify it. Use c to
3537     hold the length of the character in bytes, plus 0x80 to flag that it's a
3538     length rather than a small character. */
3539    
3540     #ifdef SUPPORT_UTF8
3541     if (utf8 && (code[-1] & 0x80) != 0)
3542     {
3543     uschar *lastchar = code - 1;
3544     while((*lastchar & 0xc0) == 0x80) lastchar--;
3545     c = code - lastchar; /* Length of UTF-8 character */
3546     memcpy(utf8_char, lastchar, c); /* Save the char */
3547     c |= 0x80; /* Flag c as a length */
3548     }
3549     else
3550     #endif
3551    
3552     /* Handle the case of a single byte - either with no UTF8 support, or
3553     with UTF-8 disabled, or for a UTF-8 character < 128. */
3554    
3555     {
3556     c = code[-1];
3557     if (repeat_min > 1) reqbyte = c | req_caseopt | cd->req_varyopt;
3558     }
3559    
3560 nigel 93 /* If the repetition is unlimited, it pays to see if the next thing on
3561     the line is something that cannot possibly match this character. If so,
3562     automatically possessifying this item gains some performance in the case
3563     where the match fails. */
3564    
3565     if (!possessive_quantifier &&
3566     repeat_max < 0 &&
3567     check_auto_possessive(*previous, c, utf8, utf8_char, ptr + 1,
3568     options, cd))
3569     {
3570     repeat_type = 0; /* Force greedy */
3571     possessive_quantifier = TRUE;
3572     }
3573    
3574 nigel 77 goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */
3575     }
3576    
3577     /* If previous was a single negated character ([^a] or similar), we use
3578     one of the special opcodes, replacing it. The code is shared with single-
3579     character repeats by setting opt_type to add a suitable offset into
3580 nigel 93 repeat_type. We can also test for auto-possessification. OP_NOT is
3581     currently used only for single-byte chars. */
3582 nigel 77
3583     else if (*previous == OP_NOT)
3584     {
3585     op_type = OP_NOTSTAR - OP_STAR; /* Use "not" opcodes */
3586     c = previous[1];
3587 nigel 93 if (!possessive_quantifier &&
3588     repeat_max < 0 &&
3589     check_auto_possessive(OP_NOT, c, utf8, NULL, ptr + 1, options, cd))
3590     {
3591     repeat_type = 0; /* Force greedy */
3592     possessive_quantifier = TRUE;
3593     }
3594 nigel 77 goto OUTPUT_SINGLE_REPEAT;
3595     }
3596    
3597     /* If previous was a character type match (\d or similar), abolish it and
3598     create a suitable repeat item. The code is shared with single-character
3599     repeats by setting op_type to add a suitable offset into repeat_type. Note
3600     the the Unicode property types will be present only when SUPPORT_UCP is
3601     defined, but we don't wrap the little bits of code here because it just
3602     makes it horribly messy. */
3603    
3604     else if (*previous < OP_EODN)
3605     {
3606     uschar *oldcode;
3607 nigel 87 int prop_type, prop_value;
3608 nigel 77 op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */
3609     c = *previous;
3610    
3611 nigel 93 if (!possessive_quantifier &&
3612     repeat_max < 0 &&
3613     check_auto_possessive(c, 0, utf8, NULL, ptr + 1, options, cd))
3614     {
3615     repeat_type = 0; /* Force greedy */
3616     possessive_quantifier = TRUE;
3617     }
3618    
3619 nigel 77 OUTPUT_SINGLE_REPEAT:
3620 nigel 87 if (*previous == OP_PROP || *previous == OP_NOTPROP)
3621     {
3622     prop_type = previous[1];
3623     prop_value = previous[2];
3624     }
3625     else prop_type = prop_value = -1;
3626 nigel 77
3627     oldcode = code;
3628     code = previous; /* Usually overwrite previous item */
3629    
3630     /* If the maximum is zero then the minimum must also be zero; Perl allows
3631     this case, so we do too - by simply omitting the item altogether. */
3632    
3633     if (repeat_max == 0) goto END_REPEAT;
3634    
3635     /* All real repeats make it impossible to handle partial matching (maybe
3636     one day we will be able to remove this restriction). */
3637    
3638 ph10 230 if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL;
3639 nigel 77
3640     /* Combine the op_type with the repeat_type */
3641    
3642     repeat_type += op_type;
3643    
3644     /* A minimum of zero is handled either as the special case * or ?, or as
3645     an UPTO, with the maximum given. */
3646    
3647     if (repeat_min == 0)
3648     {
3649     if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
3650     else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
3651     else
3652     {
3653     *code++ = OP_UPTO + repeat_type;
3654     PUT2INC(code, 0, repeat_max);
3655     }
3656     }
3657    
3658     /* A repeat minimum of 1 is optimized into some special cases. If the
3659 nigel 93 maximum is unlimited, we use OP_PLUS. Otherwise, the original item is
3660 nigel 77 left in place and, if the maximum is greater than 1, we use OP_UPTO with
3661     one less than the maximum. */
3662    
3663     else if (repeat_min == 1)
3664     {
3665     if (repeat_max == -1)
3666     *code++ = OP_PLUS + repeat_type;
3667     else
3668     {
3669     code = oldcode; /* leave previous item in place */
3670     if (repeat_max == 1) goto END_REPEAT;
3671     *code++ = OP_UPTO + repeat_type;
3672     PUT2INC(code, 0, repeat_max - 1);
3673     }
3674     }
3675    
3676     /* The case {n,n} is just an EXACT, while the general case {n,m} is
3677     handled as an EXACT followed by an UPTO. */
3678    
3679     else
3680     {
3681     *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */
3682     PUT2INC(code, 0, repeat_min);
3683    
3684     /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
3685     we have to insert the character for the previous code. For a repeated
3686 nigel 87 Unicode property match, there are two extra bytes that define the
3687 nigel 77 required property. In UTF-8 mode, long characters have their length in
3688     c, with the 0x80 bit as a flag. */
3689    
3690     if (repeat_max < 0)
3691     {
3692     #ifdef SUPPORT_UTF8
3693     if (utf8 && c >= 128)
3694     {
3695     memcpy(code, utf8_char, c & 7);
3696     code += c & 7;
3697     }
3698     else
3699     #endif
3700     {
3701     *code++ = c;
3702 nigel 87 if (prop_type >= 0)
3703     {
3704     *code++ = prop_type;
3705     *code++ = prop_value;
3706     }
3707 nigel 77 }
3708     *code++ = OP_STAR + repeat_type;
3709     }
3710    
3711     /* Else insert an UPTO if the max is greater than the min, again
3712 nigel 93 preceded by the character, for the previously inserted code. If the
3713     UPTO is just for 1 instance, we can use QUERY instead. */
3714 nigel 77
3715     else if (repeat_max != repeat_min)
3716     {
3717     #ifdef SUPPORT_UTF8
3718     if (utf8 && c >= 128)
3719     {
3720     memcpy(code, utf8_char, c & 7);
3721     code += c & 7;
3722     }
3723     else
3724     #endif
3725     *code++ = c;
3726 nigel 87 if (prop_type >= 0)
3727     {
3728     *code++ = prop_type;
3729     *code++ = prop_value;
3730     }
3731 nigel 77 repeat_max -= repeat_min;
3732 nigel 93
3733     if (repeat_max == 1)
3734     {
3735     *code++ = OP_QUERY + repeat_type;
3736     }
3737     else
3738     {
3739     *code++ = OP_UPTO + repeat_type;
3740     PUT2INC(code, 0, repeat_max);
3741     }
3742 nigel 77 }
3743     }
3744    
3745     /* The character or character type itself comes last in all cases. */
3746    
3747     #ifdef SUPPORT_UTF8
3748     if (utf8 && c >= 128)
3749     {
3750     memcpy(code, utf8_char, c & 7);
3751     code += c & 7;
3752     }
3753     else
3754     #endif
3755     *code++ = c;
3756    
3757 nigel 87 /* For a repeated Unicode property match, there are two extra bytes that
3758     define the required property. */
3759 nigel 77
3760     #ifdef SUPPORT_UCP
3761 nigel 87 if (prop_type >= 0)
3762     {
3763     *code++ = prop_type;
3764     *code++ = prop_value;
3765     }
3766 nigel 77 #endif
3767     }
3768    
3769     /* If previous was a character class or a back reference, we put the repeat
3770     stuff after it, but just skip the item if the repeat was {0,0}. */
3771    
3772     else if (*previous == OP_CLASS ||
3773     *previous == OP_NCLASS ||
3774     #ifdef SUPPORT_UTF8
3775     *previous == OP_XCLASS ||
3776     #endif
3777     *previous == OP_REF)
3778     {
3779     if (repeat_max == 0)
3780     {
3781     code = previous;
3782     goto END_REPEAT;
3783     }
3784    
3785     /* All real repeats make it impossible to handle partial matching (maybe
3786     one day we will be able to remove this restriction). */
3787    
3788 ph10 230 if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL;
3789 nigel 77
3790     if (repeat_min == 0 && repeat_max == -1)
3791     *code++ = OP_CRSTAR + repeat_type;
3792     else if (repeat_min == 1 && repeat_max == -1)
3793     *code++ = OP_CRPLUS + repeat_type;
3794     else if (repeat_min == 0 && repeat_max == 1)
3795     *code++ = OP_CRQUERY + repeat_type;
3796     else
3797     {
3798     *code++ = OP_CRRANGE + repeat_type;
3799     PUT2INC(code, 0, repeat_min);
3800     if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */
3801     PUT2INC(code, 0, repeat_max);
3802     }
3803     }
3804    
3805     /* If previous was a bracket group, we may have to replicate it in certain
3806     cases. */
3807    
3808 nigel 93 else if (*previous == OP_BRA || *previous == OP_CBRA ||
3809     *previous == OP_ONCE || *previous == OP_COND)
3810 nigel 77 {
3811     register int i;
3812     int ketoffset = 0;
3813     int len = code - previous;
3814     uschar *bralink = NULL;
3815    
3816 nigel 93 /* Repeating a DEFINE group is pointless */
3817    
3818     if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)
3819     {
3820     *errorcodeptr = ERR55;
3821     goto FAILED;
3822     }
3823    
3824 nigel 77 /* If the maximum repeat count is unlimited, find the end of the bracket
3825     by scanning through from the start, and compute the offset back to it
3826     from the current code pointer. There may be an OP_OPT setting following
3827     the final KET, so we can't find the end just by going back from the code
3828     pointer. */
3829    
3830     if (repeat_max == -1)
3831     {
3832     register uschar *ket = previous;
3833     do ket += GET(ket, 1); while (*ket != OP_KET);
3834     ketoffset = code - ket;
3835     }
3836    
3837     /* The case of a zero minimum is special because of the need to stick
3838     OP_BRAZERO in front of it, and because the group appears once in the
3839     data, whereas in other cases it appears the minimum number of times. For
3840     this reason, it is simplest to treat this case separately, as otherwise
3841     the code gets far too messy. There are several special subcases when the
3842     minimum is zero. */
3843    
3844     if (repeat_min == 0)
3845     {
3846 ph10 335 /* If the maximum is also zero, we used to just omit the group from the
3847     output altogether, like this:
3848 nigel 77
3849 ph10 335 ** if (repeat_max == 0)
3850     ** {
3851     ** code = previous;
3852     ** goto END_REPEAT;
3853     ** }
3854    
3855     However, that fails when a group is referenced as a subroutine from
3856     elsewhere in the pattern, so now we stick in OP_SKIPZERO in front of it
3857     so that it is skipped on execution. As we don't have a list of which
3858     groups are referenced, we cannot do this selectively.
3859 nigel 77
3860 ph10 335 If the maximum is 1 or unlimited, we just have to stick in the BRAZERO
3861     and do no more at this point. However, we do need to adjust any
3862     OP_RECURSE calls inside the group that refer to the group itself or any
3863     internal or forward referenced group, because the offset is from the
3864     start of the whole regex. Temporarily terminate the pattern while doing
3865     this. */
3866 nigel 77
3867 ph10 335 if (repeat_max <= 1) /* Covers 0, 1, and unlimited */
3868 nigel 77 {
3869     *code = OP_END;
3870 nigel 93 adjust_recurse(previous, 1, utf8, cd, save_hwm);
3871 nigel 77 memmove(previous+1, previous, len);
3872     code++;
3873 ph10 335 if (repeat_max == 0)
3874     {
3875     *previous++ = OP_SKIPZERO;
3876     goto END_REPEAT;
3877     }
3878 nigel 77 *previous++ = OP_BRAZERO + repeat_type;
3879     }
3880    
3881     /* If the maximum is greater than 1 and limited, we have to replicate
3882     in a nested fashion, sticking OP_BRAZERO before each set of brackets.
3883     The first one has to be handled carefully because it's the original
3884     copy, which has to be moved up. The remainder can be handled by code
3885     that is common with the non-zero minimum case below. We have to
3886     adjust the value or repeat_max, since one less copy is required. Once
3887     again, we may have to adjust any OP_RECURSE calls inside the group. */
3888    
3889     else
3890     {
3891     int offset;
3892     *code = OP_END;
3893 nigel 93 adjust_recurse(previous, 2 + LINK_SIZE, utf8, cd, save_hwm);
3894 nigel 77 memmove(previous + 2 + LINK_SIZE, previous, len);
3895     code += 2 + LINK_SIZE;
3896     *previous++ = OP_BRAZERO + repeat_type;
3897     *previous++ = OP_BRA;
3898    
3899     /* We chain together the bracket offset fields that have to be
3900     filled in later when the ends of the brackets are reached. */
3901    
3902     offset = (bralink == NULL)? 0 : previous - bralink;
3903     bralink = previous;
3904     PUTINC(previous, 0, offset);
3905     }
3906    
3907     repeat_max--;
3908     }
3909    
3910     /* If the minimum is greater than zero, replicate the group as many
3911     times as necessary, and adjust the maximum to the number of subsequent
3912     copies that we need. If we set a first char from the group, and didn't
3913 nigel 93 set a required char, copy the latter from the former. If there are any
3914     forward reference subroutine calls in the group, there will be entries on
3915     the workspace list; replicate these with an appropriate increment. */
3916 nigel 77
3917     else
3918     {
3919     if (repeat_min > 1)
3920     {
3921 nigel 93 /* In the pre-compile phase, we don't actually do the replication. We
3922 ph10 202 just adjust the length as if we had. Do some paranoid checks for
3923     potential integer overflow. */
3924 nigel 93
3925     if (lengthptr != NULL)
3926 ph10 202 {
3927     int delta = (repeat_min - 1)*length_prevgroup;
3928     if ((double)(repeat_min - 1)*(double)length_prevgroup >
3929     (double)INT_MAX ||
3930     OFLOW_MAX - *lengthptr < delta)
3931     {
3932     *errorcodeptr = ERR20;
3933     goto FAILED;
3934     }
3935     *lengthptr += delta;
3936     }
3937 nigel 93
3938     /* This is compiling for real */
3939    
3940     else
3941 nigel 77 {
3942 nigel 93 if (groupsetfirstbyte && reqbyte < 0) reqbyte = firstbyte;
3943     for (i = 1; i < repeat_min; i++)
3944     {
3945     uschar *hc;
3946     uschar *this_hwm = cd->hwm;
3947     memcpy(code, previous, len);
3948     for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
3949     {
3950     PUT(cd->hwm, 0, GET(hc, 0) + len);
3951     cd->hwm += LINK_SIZE;
3952     }
3953     save_hwm = this_hwm;
3954     code += len;
3955     }
3956 nigel 77 }
3957     }
3958 nigel 93
3959 nigel 77 if (repeat_max > 0) repeat_max -= repeat_min;
3960     }
3961    
3962     /* This code is common to both the zero and non-zero minimum cases. If
3963     the maximum is limited, it replicates the group in a nested fashion,
3964     remembering the bracket starts on a stack. In the case of a zero minimum,
3965     the first one was set up above. In all cases the repeat_max now specifies
3966 nigel 93 the number of additional copies needed. Again, we must remember to
3967     replicate entries on the forward reference list. */
3968 nigel 77
3969     if (repeat_max >= 0)
3970     {
3971 nigel 93 /* In the pre-compile phase, we don't actually do the replication. We
3972     just adjust the length as if we had. For each repetition we must add 1
3973     to the length for BRAZERO and for all but the last repetition we must
3974 ph10 202 add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
3975     paranoid checks to avoid integer overflow. */
3976 nigel 93
3977     if (lengthptr != NULL && repeat_max > 0)
3978 ph10 202 {
3979     int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
3980     2 - 2*LINK_SIZE; /* Last one doesn't nest */
3981     if ((double)repeat_max *
3982     (double)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
3983     > (double)INT_MAX ||
3984     OFLOW_MAX - *lengthptr < delta)
3985     {
3986     *errorcodeptr = ERR20;
3987     goto FAILED;
3988     }
3989     *lengthptr += delta;
3990     }
3991 nigel 93
3992     /* This is compiling for real */
3993    
3994     else for (i = repeat_max - 1; i >= 0; i--)
3995 nigel 77 {
3996 nigel 93 uschar *hc;
3997     uschar *this_hwm = cd->hwm;
3998    
3999 nigel 77 *code++ = OP_BRAZERO + repeat_type;
4000    
4001     /* All but the final copy start a new nesting, maintaining the
4002     chain of brackets outstanding. */
4003    
4004     if (i != 0)
4005     {
4006     int offset;
4007     *code++ = OP_BRA;
4008     offset = (bralink == NULL)? 0 : code - bralink;
4009     bralink = code;
4010     PUTINC(code, 0, offset);
4011     }
4012    
4013     memcpy(code, previous, len);
4014 nigel 93 for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
4015     {
4016     PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));
4017     cd->hwm += LINK_SIZE;
4018     }
4019     save_hwm = this_hwm;
4020 nigel 77 code += len;
4021     }
4022    
4023     /* Now chain through the pending brackets, and fill in their length
4024     fields (which are holding the chain links pro tem). */
4025    
4026     while (bralink != NULL)
4027     {
4028     int oldlinkoffset;
4029     int offset = code - bralink + 1;
4030     uschar *bra = code - offset;
4031     oldlinkoffset = GET(bra, 1);
4032     bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
4033     *code++ = OP_KET;
4034     PUTINC(code, 0, offset);
4035     PUT(bra, 1, offset);
4036     }
4037     }
4038    
4039     /* If the maximum is unlimited, set a repeater in the final copy. We
4040     can't just offset backwards from the current code point, because we
4041     don't know if there's been an options resetting after the ket. The
4042 nigel 93 correct offset was computed above.
4043 nigel 77
4044 nigel 93 Then, when we are doing the actual compile phase, check to see whether
4045     this group is a non-atomic one that could match an empty string. If so,
4046     convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
4047     that runtime checking can be done. [This check is also applied to
4048     atomic groups at runtime, but in a different way.] */
4049    
4050     else
4051     {
4052     uschar *ketcode = code - ketoffset;
4053     uschar *bracode = ketcode - GET(ketcode, 1);
4054     *ketcode = OP_KETRMAX + repeat_type;
4055     if (lengthptr == NULL && *bracode != OP_ONCE)
4056     {
4057     uschar *scode = bracode;
4058     do
4059     {
4060     if (could_be_empty_branch(scode, ketcode, utf8))
4061     {
4062     *bracode += OP_SBRA - OP_BRA;
4063     break;
4064     }
4065     scode += GET(scode, 1);
4066     }
4067     while (*scode == OP_ALT);
4068     }
4069     }
4070 nigel 77 }
4071    
4072     /* Else there's some kind of shambles */
4073    
4074     else
4075     {
4076     *errorcodeptr = ERR11;
4077     goto FAILED;
4078     }
4079    
4080