Annotation of embedaddon/php/ext/pcre/pcrelib/pcre_compile.c, revision 1.1.1.1
1.1 misho 1: /*************************************************
2: * Perl-Compatible Regular Expressions *
3: *************************************************/
4:
5: /* PCRE is a library of functions to support regular expressions whose syntax
6: and semantics are as close as possible to those of the Perl 5 language.
7:
8: Written by Philip Hazel
9: Copyright (c) 1997-2010 University of Cambridge
10:
11: -----------------------------------------------------------------------------
12: Redistribution and use in source and binary forms, with or without
13: modification, are permitted provided that the following conditions are met:
14:
15: * Redistributions of source code must retain the above copyright notice,
16: this list of conditions and the following disclaimer.
17:
18: * Redistributions in binary form must reproduce the above copyright
19: notice, this list of conditions and the following disclaimer in the
20: documentation and/or other materials provided with the distribution.
21:
22: * Neither the name of the University of Cambridge nor the names of its
23: contributors may be used to endorse or promote products derived from
24: this software without specific prior written permission.
25:
26: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36: POSSIBILITY OF SUCH DAMAGE.
37: -----------------------------------------------------------------------------
38: */
39:
40:
41: /* This module contains the external function pcre_compile(), along with
42: supporting internal functions that are not used by other modules. */
43:
44:
45: #include "config.h"
46:
47: #define NLBLOCK cd /* Block containing newline information */
48: #define PSSTART start_pattern /* Field containing processed string start */
49: #define PSEND end_pattern /* Field containing processed string end */
50:
51: #include "pcre_internal.h"
52:
53:
54: /* When PCRE_DEBUG is defined, we need the pcre_printint() function, which is
55: also used by pcretest. PCRE_DEBUG is not defined when building a production
56: library. */
57:
58: #ifdef PCRE_DEBUG
59: #include "pcre_printint.src"
60: #endif
61:
62:
63: /* Macro for setting individual bits in class bitmaps. */
64:
65: #define SETBIT(a,b) a[b/8] |= (1 << (b%8))
66:
67: /* Maximum length value to check against when making sure that the integer that
68: holds the compiled pattern length does not overflow. We make it a bit less than
69: INT_MAX to allow for adding in group terminating bytes, so that we don't have
70: to check them every time. */
71:
72: #define OFLOW_MAX (INT_MAX - 20)
73:
74:
75: /*************************************************
76: * Code parameters and static tables *
77: *************************************************/
78:
79: /* This value specifies the size of stack workspace that is used during the
80: first pre-compile phase that determines how much memory is required. The regex
81: is partly compiled into this space, but the compiled parts are discarded as
82: soon as they can be, so that hopefully there will never be an overrun. The code
83: does, however, check for an overrun. The largest amount I've seen used is 218,
84: so this number is very generous.
85:
86: The same workspace is used during the second, actual compile phase for
87: remembering forward references to groups so that they can be filled in at the
88: end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE
89: is 4 there is plenty of room. */
90:
91: #define COMPILE_WORK_SIZE (4096)
92:
93: /* The overrun tests check for a slightly smaller size so that they detect the
94: overrun before it actually does run off the end of the data block. */
95:
96: #define WORK_SIZE_CHECK (COMPILE_WORK_SIZE - 100)
97:
98:
99: /* Table for handling escaped characters in the range '0'-'z'. Positive returns
100: are simple data values; negative values are for special things like \d and so
101: on. Zero means further processing is needed (for things like \x), or the escape
102: is invalid. */
103:
104: #ifndef EBCDIC
105:
106: /* This is the "normal" table for ASCII systems or for EBCDIC systems running
107: in UTF-8 mode. */
108:
109: static const short int escapes[] = {
110: 0, 0,
111: 0, 0,
112: 0, 0,
113: 0, 0,
114: 0, 0,
115: CHAR_COLON, CHAR_SEMICOLON,
116: CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN,
117: CHAR_GREATER_THAN_SIGN, CHAR_QUESTION_MARK,
118: CHAR_COMMERCIAL_AT, -ESC_A,
119: -ESC_B, -ESC_C,
120: -ESC_D, -ESC_E,
121: 0, -ESC_G,
122: -ESC_H, 0,
123: 0, -ESC_K,
124: 0, 0,
125: -ESC_N, 0,
126: -ESC_P, -ESC_Q,
127: -ESC_R, -ESC_S,
128: 0, 0,
129: -ESC_V, -ESC_W,
130: -ESC_X, 0,
131: -ESC_Z, CHAR_LEFT_SQUARE_BRACKET,
132: CHAR_BACKSLASH, CHAR_RIGHT_SQUARE_BRACKET,
133: CHAR_CIRCUMFLEX_ACCENT, CHAR_UNDERSCORE,
134: CHAR_GRAVE_ACCENT, 7,
135: -ESC_b, 0,
136: -ESC_d, ESC_e,
137: ESC_f, 0,
138: -ESC_h, 0,
139: 0, -ESC_k,
140: 0, 0,
141: ESC_n, 0,
142: -ESC_p, 0,
143: ESC_r, -ESC_s,
144: ESC_tee, 0,
145: -ESC_v, -ESC_w,
146: 0, 0,
147: -ESC_z
148: };
149:
150: #else
151:
152: /* This is the "abnormal" table for EBCDIC systems without UTF-8 support. */
153:
154: static const short int escapes[] = {
155: /* 48 */ 0, 0, 0, '.', '<', '(', '+', '|',
156: /* 50 */ '&', 0, 0, 0, 0, 0, 0, 0,
157: /* 58 */ 0, 0, '!', '$', '*', ')', ';', '~',
158: /* 60 */ '-', '/', 0, 0, 0, 0, 0, 0,
159: /* 68 */ 0, 0, '|', ',', '%', '_', '>', '?',
160: /* 70 */ 0, 0, 0, 0, 0, 0, 0, 0,
161: /* 78 */ 0, '`', ':', '#', '@', '\'', '=', '"',
162: /* 80 */ 0, 7, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0,
163: /* 88 */-ESC_h, 0, 0, '{', 0, 0, 0, 0,
164: /* 90 */ 0, 0, -ESC_k, 'l', 0, ESC_n, 0, -ESC_p,
165: /* 98 */ 0, ESC_r, 0, '}', 0, 0, 0, 0,
166: /* A0 */ 0, '~', -ESC_s, ESC_tee, 0,-ESC_v, -ESC_w, 0,
167: /* A8 */ 0,-ESC_z, 0, 0, 0, '[', 0, 0,
168: /* B0 */ 0, 0, 0, 0, 0, 0, 0, 0,
169: /* B8 */ 0, 0, 0, 0, 0, ']', '=', '-',
170: /* C0 */ '{',-ESC_A, -ESC_B, -ESC_C, -ESC_D,-ESC_E, 0, -ESC_G,
171: /* C8 */-ESC_H, 0, 0, 0, 0, 0, 0, 0,
172: /* D0 */ '}', 0, -ESC_K, 0, 0,-ESC_N, 0, -ESC_P,
173: /* D8 */-ESC_Q,-ESC_R, 0, 0, 0, 0, 0, 0,
174: /* E0 */ '\\', 0, -ESC_S, 0, 0,-ESC_V, -ESC_W, -ESC_X,
175: /* E8 */ 0,-ESC_Z, 0, 0, 0, 0, 0, 0,
176: /* F0 */ 0, 0, 0, 0, 0, 0, 0, 0,
177: /* F8 */ 0, 0, 0, 0, 0, 0, 0, 0
178: };
179: #endif
180:
181:
182: /* Table of special "verbs" like (*PRUNE). This is a short table, so it is
183: searched linearly. Put all the names into a single string, in order to reduce
184: the number of relocations when a shared library is dynamically linked. The
185: string is built from string macros so that it works in UTF-8 mode on EBCDIC
186: platforms. */
187:
188: typedef struct verbitem {
189: int len; /* Length of verb name */
190: int op; /* Op when no arg, or -1 if arg mandatory */
191: int op_arg; /* Op when arg present, or -1 if not allowed */
192: } verbitem;
193:
194: static const char verbnames[] =
195: "\0" /* Empty name is a shorthand for MARK */
196: STRING_MARK0
197: STRING_ACCEPT0
198: STRING_COMMIT0
199: STRING_F0
200: STRING_FAIL0
201: STRING_PRUNE0
202: STRING_SKIP0
203: STRING_THEN;
204:
205: static const verbitem verbs[] = {
206: { 0, -1, OP_MARK },
207: { 4, -1, OP_MARK },
208: { 6, OP_ACCEPT, -1 },
209: { 6, OP_COMMIT, -1 },
210: { 1, OP_FAIL, -1 },
211: { 4, OP_FAIL, -1 },
212: { 5, OP_PRUNE, OP_PRUNE_ARG },
213: { 4, OP_SKIP, OP_SKIP_ARG },
214: { 4, OP_THEN, OP_THEN_ARG }
215: };
216:
217: static const int verbcount = sizeof(verbs)/sizeof(verbitem);
218:
219:
220: /* Tables of names of POSIX character classes and their lengths. The names are
221: now all in a single string, to reduce the number of relocations when a shared
222: library is dynamically loaded. The list of lengths is terminated by a zero
223: length entry. The first three must be alpha, lower, upper, as this is assumed
224: for handling case independence. */
225:
226: static const char posix_names[] =
227: STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0
228: STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0
229: STRING_graph0 STRING_print0 STRING_punct0 STRING_space0
230: STRING_word0 STRING_xdigit;
231:
232: static const uschar posix_name_lengths[] = {
233: 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
234:
235: /* Table of class bit maps for each POSIX class. Each class is formed from a
236: base map, with an optional addition or removal of another map. Then, for some
237: classes, there is some additional tweaking: for [:blank:] the vertical space
238: characters are removed, and for [:alpha:] and [:alnum:] the underscore
239: character is removed. The triples in the table consist of the base map offset,
240: second map offset or -1 if no second map, and a non-negative value for map
241: addition or a negative value for map subtraction (if there are two maps). The
242: absolute value of the third field has these meanings: 0 => no tweaking, 1 =>
243: remove vertical space characters, 2 => remove underscore. */
244:
245: static const int posix_class_maps[] = {
246: cbit_word, cbit_digit, -2, /* alpha */
247: cbit_lower, -1, 0, /* lower */
248: cbit_upper, -1, 0, /* upper */
249: cbit_word, -1, 2, /* alnum - word without underscore */
250: cbit_print, cbit_cntrl, 0, /* ascii */
251: cbit_space, -1, 1, /* blank - a GNU extension */
252: cbit_cntrl, -1, 0, /* cntrl */
253: cbit_digit, -1, 0, /* digit */
254: cbit_graph, -1, 0, /* graph */
255: cbit_print, -1, 0, /* print */
256: cbit_punct, -1, 0, /* punct */
257: cbit_space, -1, 0, /* space */
258: cbit_word, -1, 0, /* word - a Perl extension */
259: cbit_xdigit,-1, 0 /* xdigit */
260: };
261:
262: /* Table of substitutes for \d etc when PCRE_UCP is set. The POSIX class
263: substitutes must be in the order of the names, defined above, and there are
264: both positive and negative cases. NULL means no substitute. */
265:
266: #ifdef SUPPORT_UCP
267: static const uschar *substitutes[] = {
268: (uschar *)"\\P{Nd}", /* \D */
269: (uschar *)"\\p{Nd}", /* \d */
270: (uschar *)"\\P{Xsp}", /* \S */ /* NOTE: Xsp is Perl space */
271: (uschar *)"\\p{Xsp}", /* \s */
272: (uschar *)"\\P{Xwd}", /* \W */
273: (uschar *)"\\p{Xwd}" /* \w */
274: };
275:
276: static const uschar *posix_substitutes[] = {
277: (uschar *)"\\p{L}", /* alpha */
278: (uschar *)"\\p{Ll}", /* lower */
279: (uschar *)"\\p{Lu}", /* upper */
280: (uschar *)"\\p{Xan}", /* alnum */
281: NULL, /* ascii */
282: (uschar *)"\\h", /* blank */
283: NULL, /* cntrl */
284: (uschar *)"\\p{Nd}", /* digit */
285: NULL, /* graph */
286: NULL, /* print */
287: NULL, /* punct */
288: (uschar *)"\\p{Xps}", /* space */ /* NOTE: Xps is POSIX space */
289: (uschar *)"\\p{Xwd}", /* word */
290: NULL, /* xdigit */
291: /* Negated cases */
292: (uschar *)"\\P{L}", /* ^alpha */
293: (uschar *)"\\P{Ll}", /* ^lower */
294: (uschar *)"\\P{Lu}", /* ^upper */
295: (uschar *)"\\P{Xan}", /* ^alnum */
296: NULL, /* ^ascii */
297: (uschar *)"\\H", /* ^blank */
298: NULL, /* ^cntrl */
299: (uschar *)"\\P{Nd}", /* ^digit */
300: NULL, /* ^graph */
301: NULL, /* ^print */
302: NULL, /* ^punct */
303: (uschar *)"\\P{Xps}", /* ^space */ /* NOTE: Xps is POSIX space */
304: (uschar *)"\\P{Xwd}", /* ^word */
305: NULL /* ^xdigit */
306: };
307: #define POSIX_SUBSIZE (sizeof(posix_substitutes)/sizeof(uschar *))
308: #endif
309:
310: #define STRING(a) # a
311: #define XSTRING(s) STRING(s)
312:
313: /* The texts of compile-time error messages. These are "char *" because they
314: are passed to the outside world. Do not ever re-use any error number, because
315: they are documented. Always add a new error instead. Messages marked DEAD below
316: are no longer used. This used to be a table of strings, but in order to reduce
317: the number of relocations needed when a shared library is loaded dynamically,
318: it is now one long string. We cannot use a table of offsets, because the
319: lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we
320: simply count through to the one we want - this isn't a performance issue
321: because these strings are used only when there is a compilation error.
322:
323: Each substring ends with \0 to insert a null character. This includes the final
324: substring, so that the whole string ends with \0\0, which can be detected when
325: counting through. */
326:
327: static const char error_texts[] =
328: "no error\0"
329: "\\ at end of pattern\0"
330: "\\c at end of pattern\0"
331: "unrecognized character follows \\\0"
332: "numbers out of order in {} quantifier\0"
333: /* 5 */
334: "number too big in {} quantifier\0"
335: "missing terminating ] for character class\0"
336: "invalid escape sequence in character class\0"
337: "range out of order in character class\0"
338: "nothing to repeat\0"
339: /* 10 */
340: "operand of unlimited repeat could match the empty string\0" /** DEAD **/
341: "internal error: unexpected repeat\0"
342: "unrecognized character after (? or (?-\0"
343: "POSIX named classes are supported only within a class\0"
344: "missing )\0"
345: /* 15 */
346: "reference to non-existent subpattern\0"
347: "erroffset passed as NULL\0"
348: "unknown option bit(s) set\0"
349: "missing ) after comment\0"
350: "parentheses nested too deeply\0" /** DEAD **/
351: /* 20 */
352: "regular expression is too large\0"
353: "failed to get memory\0"
354: "unmatched parentheses\0"
355: "internal error: code overflow\0"
356: "unrecognized character after (?<\0"
357: /* 25 */
358: "lookbehind assertion is not fixed length\0"
359: "malformed number or name after (?(\0"
360: "conditional group contains more than two branches\0"
361: "assertion expected after (?(\0"
362: "(?R or (?[+-]digits must be followed by )\0"
363: /* 30 */
364: "unknown POSIX class name\0"
365: "POSIX collating elements are not supported\0"
366: "this version of PCRE is not compiled with PCRE_UTF8 support\0"
367: "spare error\0" /** DEAD **/
368: "character value in \\x{...} sequence is too large\0"
369: /* 35 */
370: "invalid condition (?(0)\0"
371: "\\C not allowed in lookbehind assertion\0"
372: "PCRE does not support \\L, \\l, \\N{name}, \\U, or \\u\0"
373: "number after (?C is > 255\0"
374: "closing ) for (?C expected\0"
375: /* 40 */
376: "recursive call could loop indefinitely\0"
377: "unrecognized character after (?P\0"
378: "syntax error in subpattern name (missing terminator)\0"
379: "two named subpatterns have the same name\0"
380: "invalid UTF-8 string\0"
381: /* 45 */
382: "support for \\P, \\p, and \\X has not been compiled\0"
383: "malformed \\P or \\p sequence\0"
384: "unknown property name after \\P or \\p\0"
385: "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)\0"
386: "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")\0"
387: /* 50 */
388: "repeated subpattern is too long\0" /** DEAD **/
389: "octal value is greater than \\377 (not in UTF-8 mode)\0"
390: "internal error: overran compiling workspace\0"
391: "internal error: previously-checked referenced subpattern not found\0"
392: "DEFINE group contains more than one branch\0"
393: /* 55 */
394: "repeating a DEFINE group is not allowed\0"
395: "inconsistent NEWLINE options\0"
396: "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
397: "a numbered reference must not be zero\0"
398: "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0"
399: /* 60 */
400: "(*VERB) not recognized\0"
401: "number is too big\0"
402: "subpattern name expected\0"
403: "digit expected after (?+\0"
404: "] is an invalid data character in JavaScript compatibility mode\0"
405: /* 65 */
406: "different names for subpatterns of the same number are not allowed\0"
407: "(*MARK) must have an argument\0"
408: "this version of PCRE is not compiled with PCRE_UCP support\0"
409: "\\c must be followed by an ASCII character\0"
410: ;
411:
412: /* Table to identify digits and hex digits. This is used when compiling
413: patterns. Note that the tables in chartables are dependent on the locale, and
414: may mark arbitrary characters as digits - but the PCRE compiling code expects
415: to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
416: a private table here. It costs 256 bytes, but it is a lot faster than doing
417: character value tests (at least in some simple cases I timed), and in some
418: applications one wants PCRE to compile efficiently as well as match
419: efficiently.
420:
421: For convenience, we use the same bit definitions as in chartables:
422:
423: 0x04 decimal digit
424: 0x08 hexadecimal digit
425:
426: Then we can use ctype_digit and ctype_xdigit in the code. */
427:
428: #ifndef EBCDIC
429:
430: /* This is the "normal" case, for ASCII systems, and EBCDIC systems running in
431: UTF-8 mode. */
432:
433: static const unsigned char digitab[] =
434: {
435: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */
436: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */
437: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */
438: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
439: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - ' */
440: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ( - / */
441: 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 */
442: 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /* 8 - ? */
443: 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* @ - G */
444: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H - O */
445: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* P - W */
446: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* X - _ */
447: 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* ` - g */
448: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h - o */
449: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* p - w */
450: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* x -127 */
451: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
452: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
453: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
454: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
455: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
456: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
457: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
458: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
459: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
460: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
461: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
462: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
463: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
464: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
465: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
466: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
467:
468: #else
469:
470: /* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */
471:
472: static const unsigned char digitab[] =
473: {
474: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 0 */
475: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */
476: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 10 */
477: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
478: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 32- 39 20 */
479: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */
480: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 30 */
481: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */
482: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 40 */
483: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 72- | */
484: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 50 */
485: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 88- 95 */
486: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 60 */
487: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ? */
488: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
489: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */
490: 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g 80 */
491: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */
492: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p 90 */
493: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */
494: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x A0 */
495: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */
496: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 B0 */
497: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
498: 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* { - G C0 */
499: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */
500: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* } - P D0 */
501: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */
502: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* \ - X E0 */
503: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */
504: 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 F0 */
505: 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */
506:
507: static const unsigned char ebcdic_chartab[] = { /* chartable partial dup */
508: 0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 0- 7 */
509: 0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /* 8- 15 */
510: 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 16- 23 */
511: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
512: 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 32- 39 */
513: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */
514: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 */
515: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */
516: 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 */
517: 0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /* 72- | */
518: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 */
519: 0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /* 88- 95 */
520: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 */
521: 0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ? */
522: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
523: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */
524: 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g */
525: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */
526: 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p */
527: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */
528: 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x */
529: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */
530: 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 */
531: 0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
532: 0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* { - G */
533: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */
534: 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* } - P */
535: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */
536: 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* \ - X */
537: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */
538: 0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */
539: 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */
540: #endif
541:
542:
543: /* Definition to allow mutual recursion */
544:
545: static BOOL
546: compile_regex(int, int, uschar **, const uschar **, int *, BOOL, BOOL, int,
547: int *, int *, branch_chain *, compile_data *, int *);
548:
549:
550:
551: /*************************************************
552: * Find an error text *
553: *************************************************/
554:
555: /* The error texts are now all in one long string, to save on relocations. As
556: some of the text is of unknown length, we can't use a table of offsets.
557: Instead, just count through the strings. This is not a performance issue
558: because it happens only when there has been a compilation error.
559:
560: Argument: the error number
561: Returns: pointer to the error string
562: */
563:
564: static const char *
565: find_error_text(int n)
566: {
567: const char *s = error_texts;
568: for (; n > 0; n--)
569: {
570: while (*s++ != 0) {};
571: if (*s == 0) return "Error text not found (please report)";
572: }
573: return s;
574: }
575:
576:
577: /*************************************************
578: * Handle escapes *
579: *************************************************/
580:
581: /* This function is called when a \ has been encountered. It either returns a
582: positive value for a simple escape such as \n, or a negative value which
583: encodes one of the more complicated things such as \d. A backreference to group
584: n is returned as -(ESC_REF + n); ESC_REF is the highest ESC_xxx macro. When
585: UTF-8 is enabled, a positive value greater than 255 may be returned. On entry,
586: ptr is pointing at the \. On exit, it is on the final character of the escape
587: sequence.
588:
589: Arguments:
590: ptrptr points to the pattern position pointer
591: errorcodeptr points to the errorcode variable
592: bracount number of previous extracting brackets
593: options the options bits
594: isclass TRUE if inside a character class
595:
596: Returns: zero or positive => a data character
597: negative => a special escape sequence
598: on error, errorcodeptr is set
599: */
600:
601: static int
602: check_escape(const uschar **ptrptr, int *errorcodeptr, int bracount,
603: int options, BOOL isclass)
604: {
605: BOOL utf8 = (options & PCRE_UTF8) != 0;
606: const uschar *ptr = *ptrptr + 1;
607: int c, i;
608:
609: GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */
610: ptr--; /* Set pointer back to the last byte */
611:
612: /* If backslash is at the end of the pattern, it's an error. */
613:
614: if (c == 0) *errorcodeptr = ERR1;
615:
616: /* Non-alphanumerics are literals. For digits or letters, do an initial lookup
617: in a table. A non-zero result is something that can be returned immediately.
618: Otherwise further processing may be required. */
619:
620: #ifndef EBCDIC /* ASCII/UTF-8 coding */
621: else if (c < CHAR_0 || c > CHAR_z) {} /* Not alphanumeric */
622: else if ((i = escapes[c - CHAR_0]) != 0) c = i;
623:
624: #else /* EBCDIC coding */
625: else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {} /* Not alphanumeric */
626: else if ((i = escapes[c - 0x48]) != 0) c = i;
627: #endif
628:
629: /* Escapes that need further processing, or are illegal. */
630:
631: else
632: {
633: const uschar *oldptr;
634: BOOL braced, negated;
635:
636: switch (c)
637: {
638: /* A number of Perl escapes are not handled by PCRE. We give an explicit
639: error. */
640:
641: case CHAR_l:
642: case CHAR_L:
643: case CHAR_u:
644: case CHAR_U:
645: *errorcodeptr = ERR37;
646: break;
647:
648: /* \g must be followed by one of a number of specific things:
649:
650: (1) A number, either plain or braced. If positive, it is an absolute
651: backreference. If negative, it is a relative backreference. This is a Perl
652: 5.10 feature.
653:
654: (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
655: is part of Perl's movement towards a unified syntax for back references. As
656: this is synonymous with \k{name}, we fudge it up by pretending it really
657: was \k.
658:
659: (3) For Oniguruma compatibility we also support \g followed by a name or a
660: number either in angle brackets or in single quotes. However, these are
661: (possibly recursive) subroutine calls, _not_ backreferences. Just return
662: the -ESC_g code (cf \k). */
663:
664: case CHAR_g:
665: if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)
666: {
667: c = -ESC_g;
668: break;
669: }
670:
671: /* Handle the Perl-compatible cases */
672:
673: if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
674: {
675: const uschar *p;
676: for (p = ptr+2; *p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
677: if (*p != CHAR_MINUS && (digitab[*p] & ctype_digit) == 0) break;
678: if (*p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET)
679: {
680: c = -ESC_k;
681: break;
682: }
683: braced = TRUE;
684: ptr++;
685: }
686: else braced = FALSE;
687:
688: if (ptr[1] == CHAR_MINUS)
689: {
690: negated = TRUE;
691: ptr++;
692: }
693: else negated = FALSE;
694:
695: c = 0;
696: while ((digitab[ptr[1]] & ctype_digit) != 0)
697: c = c * 10 + *(++ptr) - CHAR_0;
698:
699: if (c < 0) /* Integer overflow */
700: {
701: *errorcodeptr = ERR61;
702: break;
703: }
704:
705: if (braced && *(++ptr) != CHAR_RIGHT_CURLY_BRACKET)
706: {
707: *errorcodeptr = ERR57;
708: break;
709: }
710:
711: if (c == 0)
712: {
713: *errorcodeptr = ERR58;
714: break;
715: }
716:
717: if (negated)
718: {
719: if (c > bracount)
720: {
721: *errorcodeptr = ERR15;
722: break;
723: }
724: c = bracount - (c - 1);
725: }
726:
727: c = -(ESC_REF + c);
728: break;
729:
730: /* The handling of escape sequences consisting of a string of digits
731: starting with one that is not zero is not straightforward. By experiment,
732: the way Perl works seems to be as follows:
733:
734: Outside a character class, the digits are read as a decimal number. If the
735: number is less than 10, or if there are that many previous extracting
736: left brackets, then it is a back reference. Otherwise, up to three octal
737: digits are read to form an escaped byte. Thus \123 is likely to be octal
738: 123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
739: value is greater than 377, the least significant 8 bits are taken. Inside a
740: character class, \ followed by a digit is always an octal number. */
741:
742: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:
743: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
744:
745: if (!isclass)
746: {
747: oldptr = ptr;
748: c -= CHAR_0;
749: while ((digitab[ptr[1]] & ctype_digit) != 0)
750: c = c * 10 + *(++ptr) - CHAR_0;
751: if (c < 0) /* Integer overflow */
752: {
753: *errorcodeptr = ERR61;
754: break;
755: }
756: if (c < 10 || c <= bracount)
757: {
758: c = -(ESC_REF + c);
759: break;
760: }
761: ptr = oldptr; /* Put the pointer back and fall through */
762: }
763:
764: /* Handle an octal number following \. If the first digit is 8 or 9, Perl
765: generates a binary zero byte and treats the digit as a following literal.
766: Thus we have to pull back the pointer by one. */
767:
768: if ((c = *ptr) >= CHAR_8)
769: {
770: ptr--;
771: c = 0;
772: break;
773: }
774:
775: /* \0 always starts an octal number, but we may drop through to here with a
776: larger first octal digit. The original code used just to take the least
777: significant 8 bits of octal numbers (I think this is what early Perls used
778: to do). Nowadays we allow for larger numbers in UTF-8 mode, but no more
779: than 3 octal digits. */
780:
781: case CHAR_0:
782: c -= CHAR_0;
783: while(i++ < 2 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)
784: c = c * 8 + *(++ptr) - CHAR_0;
785: if (!utf8 && c > 255) *errorcodeptr = ERR51;
786: break;
787:
788: /* \x is complicated. \x{ddd} is a character number which can be greater
789: than 0xff in utf8 mode, but only if the ddd are hex digits. If not, { is
790: treated as a data character. */
791:
792: case CHAR_x:
793: if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
794: {
795: const uschar *pt = ptr + 2;
796: int count = 0;
797:
798: c = 0;
799: while ((digitab[*pt] & ctype_xdigit) != 0)
800: {
801: register int cc = *pt++;
802: if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */
803: count++;
804:
805: #ifndef EBCDIC /* ASCII/UTF-8 coding */
806: if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */
807: c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
808: #else /* EBCDIC coding */
809: if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */
810: c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
811: #endif
812: }
813:
814: if (*pt == CHAR_RIGHT_CURLY_BRACKET)
815: {
816: if (c < 0 || count > (utf8? 8 : 2)) *errorcodeptr = ERR34;
817: ptr = pt;
818: break;
819: }
820:
821: /* If the sequence of hex digits does not end with '}', then we don't
822: recognize this construct; fall through to the normal \x handling. */
823: }
824:
825: /* Read just a single-byte hex-defined char */
826:
827: c = 0;
828: while (i++ < 2 && (digitab[ptr[1]] & ctype_xdigit) != 0)
829: {
830: int cc; /* Some compilers don't like */
831: cc = *(++ptr); /* ++ in initializers */
832: #ifndef EBCDIC /* ASCII/UTF-8 coding */
833: if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */
834: c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
835: #else /* EBCDIC coding */
836: if (cc <= CHAR_z) cc += 64; /* Convert to upper case */
837: c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
838: #endif
839: }
840: break;
841:
842: /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
843: An error is given if the byte following \c is not an ASCII character. This
844: coding is ASCII-specific, but then the whole concept of \cx is
845: ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
846:
847: case CHAR_c:
848: c = *(++ptr);
849: if (c == 0)
850: {
851: *errorcodeptr = ERR2;
852: break;
853: }
854: #ifndef EBCDIC /* ASCII/UTF-8 coding */
855: if (c > 127) /* Excludes all non-ASCII in either mode */
856: {
857: *errorcodeptr = ERR68;
858: break;
859: }
860: if (c >= CHAR_a && c <= CHAR_z) c -= 32;
861: c ^= 0x40;
862: #else /* EBCDIC coding */
863: if (c >= CHAR_a && c <= CHAR_z) c += 64;
864: c ^= 0xC0;
865: #endif
866: break;
867:
868: /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
869: other alphanumeric following \ is an error if PCRE_EXTRA was set;
870: otherwise, for Perl compatibility, it is a literal. This code looks a bit
871: odd, but there used to be some cases other than the default, and there may
872: be again in future, so I haven't "optimized" it. */
873:
874: default:
875: if ((options & PCRE_EXTRA) != 0) switch(c)
876: {
877: default:
878: *errorcodeptr = ERR3;
879: break;
880: }
881: break;
882: }
883: }
884:
885: /* Perl supports \N{name} for character names, as well as plain \N for "not
886: newline". PCRE does not support \N{name}. */
887:
888: if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET)
889: *errorcodeptr = ERR37;
890:
891: /* If PCRE_UCP is set, we change the values for \d etc. */
892:
893: if ((options & PCRE_UCP) != 0 && c <= -ESC_D && c >= -ESC_w)
894: c -= (ESC_DU - ESC_D);
895:
896: /* Set the pointer to the final character before returning. */
897:
898: *ptrptr = ptr;
899: return c;
900: }
901:
902:
903:
904: #ifdef SUPPORT_UCP
905: /*************************************************
906: * Handle \P and \p *
907: *************************************************/
908:
909: /* This function is called after \P or \p has been encountered, provided that
910: PCRE is compiled with support for Unicode properties. On entry, ptrptr is
911: pointing at the P or p. On exit, it is pointing at the final character of the
912: escape sequence.
913:
914: Argument:
915: ptrptr points to the pattern position pointer
916: negptr points to a boolean that is set TRUE for negation else FALSE
917: dptr points to an int that is set to the detailed property value
918: errorcodeptr points to the error code variable
919:
920: Returns: type value from ucp_type_table, or -1 for an invalid type
921: */
922:
923: static int
924: get_ucp(const uschar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr)
925: {
926: int c, i, bot, top;
927: const uschar *ptr = *ptrptr;
928: char name[32];
929:
930: c = *(++ptr);
931: if (c == 0) goto ERROR_RETURN;
932:
933: *negptr = FALSE;
934:
935: /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
936: negation. */
937:
938: if (c == CHAR_LEFT_CURLY_BRACKET)
939: {
940: if (ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
941: {
942: *negptr = TRUE;
943: ptr++;
944: }
945: for (i = 0; i < (int)sizeof(name) - 1; i++)
946: {
947: c = *(++ptr);
948: if (c == 0) goto ERROR_RETURN;
949: if (c == CHAR_RIGHT_CURLY_BRACKET) break;
950: name[i] = c;
951: }
952: if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;
953: name[i] = 0;
954: }
955:
956: /* Otherwise there is just one following character */
957:
958: else
959: {
960: name[0] = c;
961: name[1] = 0;
962: }
963:
964: *ptrptr = ptr;
965:
966: /* Search for a recognized property name using binary chop */
967:
968: bot = 0;
969: top = _pcre_utt_size;
970:
971: while (bot < top)
972: {
973: i = (bot + top) >> 1;
974: c = strcmp(name, _pcre_utt_names + _pcre_utt[i].name_offset);
975: if (c == 0)
976: {
977: *dptr = _pcre_utt[i].value;
978: return _pcre_utt[i].type;
979: }
980: if (c > 0) bot = i + 1; else top = i;
981: }
982:
983: *errorcodeptr = ERR47;
984: *ptrptr = ptr;
985: return -1;
986:
987: ERROR_RETURN:
988: *errorcodeptr = ERR46;
989: *ptrptr = ptr;
990: return -1;
991: }
992: #endif
993:
994:
995:
996:
997: /*************************************************
998: * Check for counted repeat *
999: *************************************************/
1000:
1001: /* This function is called when a '{' is encountered in a place where it might
1002: start a quantifier. It looks ahead to see if it really is a quantifier or not.
1003: It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
1004: where the ddds are digits.
1005:
1006: Arguments:
1007: p pointer to the first char after '{'
1008:
1009: Returns: TRUE or FALSE
1010: */
1011:
1012: static BOOL
1013: is_counted_repeat(const uschar *p)
1014: {
1015: if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
1016: while ((digitab[*p] & ctype_digit) != 0) p++;
1017: if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
1018:
1019: if (*p++ != CHAR_COMMA) return FALSE;
1020: if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
1021:
1022: if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
1023: while ((digitab[*p] & ctype_digit) != 0) p++;
1024:
1025: return (*p == CHAR_RIGHT_CURLY_BRACKET);
1026: }
1027:
1028:
1029:
1030: /*************************************************
1031: * Read repeat counts *
1032: *************************************************/
1033:
1034: /* Read an item of the form {n,m} and return the values. This is called only
1035: after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
1036: so the syntax is guaranteed to be correct, but we need to check the values.
1037:
1038: Arguments:
1039: p pointer to first char after '{'
1040: minp pointer to int for min
1041: maxp pointer to int for max
1042: returned as -1 if no max
1043: errorcodeptr points to error code variable
1044:
1045: Returns: pointer to '}' on success;
1046: current ptr on error, with errorcodeptr set non-zero
1047: */
1048:
1049: static const uschar *
1050: read_repeat_counts(const uschar *p, int *minp, int *maxp, int *errorcodeptr)
1051: {
1052: int min = 0;
1053: int max = -1;
1054:
1055: /* Read the minimum value and do a paranoid check: a negative value indicates
1056: an integer overflow. */
1057:
1058: while ((digitab[*p] & ctype_digit) != 0) min = min * 10 + *p++ - CHAR_0;
1059: if (min < 0 || min > 65535)
1060: {
1061: *errorcodeptr = ERR5;
1062: return p;
1063: }
1064:
1065: /* Read the maximum value if there is one, and again do a paranoid on its size.
1066: Also, max must not be less than min. */
1067:
1068: if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else
1069: {
1070: if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)
1071: {
1072: max = 0;
1073: while((digitab[*p] & ctype_digit) != 0) max = max * 10 + *p++ - CHAR_0;
1074: if (max < 0 || max > 65535)
1075: {
1076: *errorcodeptr = ERR5;
1077: return p;
1078: }
1079: if (max < min)
1080: {
1081: *errorcodeptr = ERR4;
1082: return p;
1083: }
1084: }
1085: }
1086:
1087: /* Fill in the required variables, and pass back the pointer to the terminating
1088: '}'. */
1089:
1090: *minp = min;
1091: *maxp = max;
1092: return p;
1093: }
1094:
1095:
1096:
1097: /*************************************************
1098: * Subroutine for finding forward reference *
1099: *************************************************/
1100:
1101: /* This recursive function is called only from find_parens() below. The
1102: top-level call starts at the beginning of the pattern. All other calls must
1103: start at a parenthesis. It scans along a pattern's text looking for capturing
1104: subpatterns, and counting them. If it finds a named pattern that matches the
1105: name it is given, it returns its number. Alternatively, if the name is NULL, it
1106: returns when it reaches a given numbered subpattern. Recursion is used to keep
1107: track of subpatterns that reset the capturing group numbers - the (?| feature.
1108:
1109: This function was originally called only from the second pass, in which we know
1110: that if (?< or (?' or (?P< is encountered, the name will be correctly
1111: terminated because that is checked in the first pass. There is now one call to
1112: this function in the first pass, to check for a recursive back reference by
1113: name (so that we can make the whole group atomic). In this case, we need check
1114: only up to the current position in the pattern, and that is still OK because
1115: and previous occurrences will have been checked. To make this work, the test
1116: for "end of pattern" is a check against cd->end_pattern in the main loop,
1117: instead of looking for a binary zero. This means that the special first-pass
1118: call can adjust cd->end_pattern temporarily. (Checks for binary zero while
1119: processing items within the loop are OK, because afterwards the main loop will
1120: terminate.)
1121:
1122: Arguments:
1123: ptrptr address of the current character pointer (updated)
1124: cd compile background data
1125: name name to seek, or NULL if seeking a numbered subpattern
1126: lorn name length, or subpattern number if name is NULL
1127: xmode TRUE if we are in /x mode
1128: utf8 TRUE if we are in UTF-8 mode
1129: count pointer to the current capturing subpattern number (updated)
1130:
1131: Returns: the number of the named subpattern, or -1 if not found
1132: */
1133:
1134: static int
1135: find_parens_sub(uschar **ptrptr, compile_data *cd, const uschar *name, int lorn,
1136: BOOL xmode, BOOL utf8, int *count)
1137: {
1138: uschar *ptr = *ptrptr;
1139: int start_count = *count;
1140: int hwm_count = start_count;
1141: BOOL dup_parens = FALSE;
1142:
1143: /* If the first character is a parenthesis, check on the type of group we are
1144: dealing with. The very first call may not start with a parenthesis. */
1145:
1146: if (ptr[0] == CHAR_LEFT_PARENTHESIS)
1147: {
1148: /* Handle specials such as (*SKIP) or (*UTF8) etc. */
1149:
1150: if (ptr[1] == CHAR_ASTERISK) ptr += 2;
1151:
1152: /* Handle a normal, unnamed capturing parenthesis. */
1153:
1154: else if (ptr[1] != CHAR_QUESTION_MARK)
1155: {
1156: *count += 1;
1157: if (name == NULL && *count == lorn) return *count;
1158: ptr++;
1159: }
1160:
1161: /* All cases now have (? at the start. Remember when we are in a group
1162: where the parenthesis numbers are duplicated. */
1163:
1164: else if (ptr[2] == CHAR_VERTICAL_LINE)
1165: {
1166: ptr += 3;
1167: dup_parens = TRUE;
1168: }
1169:
1170: /* Handle comments; all characters are allowed until a ket is reached. */
1171:
1172: else if (ptr[2] == CHAR_NUMBER_SIGN)
1173: {
1174: for (ptr += 3; *ptr != 0; ptr++) if (*ptr == CHAR_RIGHT_PARENTHESIS) break;
1175: goto FAIL_EXIT;
1176: }
1177:
1178: /* Handle a condition. If it is an assertion, just carry on so that it
1179: is processed as normal. If not, skip to the closing parenthesis of the
1180: condition (there can't be any nested parens). */
1181:
1182: else if (ptr[2] == CHAR_LEFT_PARENTHESIS)
1183: {
1184: ptr += 2;
1185: if (ptr[1] != CHAR_QUESTION_MARK)
1186: {
1187: while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
1188: if (*ptr != 0) ptr++;
1189: }
1190: }
1191:
1192: /* Start with (? but not a condition. */
1193:
1194: else
1195: {
1196: ptr += 2;
1197: if (*ptr == CHAR_P) ptr++; /* Allow optional P */
1198:
1199: /* We have to disambiguate (?<! and (?<= from (?<name> for named groups */
1200:
1201: if ((*ptr == CHAR_LESS_THAN_SIGN && ptr[1] != CHAR_EXCLAMATION_MARK &&
1202: ptr[1] != CHAR_EQUALS_SIGN) || *ptr == CHAR_APOSTROPHE)
1203: {
1204: int term;
1205: const uschar *thisname;
1206: *count += 1;
1207: if (name == NULL && *count == lorn) return *count;
1208: term = *ptr++;
1209: if (term == CHAR_LESS_THAN_SIGN) term = CHAR_GREATER_THAN_SIGN;
1210: thisname = ptr;
1211: while (*ptr != term) ptr++;
1212: if (name != NULL && lorn == ptr - thisname &&
1213: strncmp((const char *)name, (const char *)thisname, lorn) == 0)
1214: return *count;
1215: term++;
1216: }
1217: }
1218: }
1219:
1220: /* Past any initial parenthesis handling, scan for parentheses or vertical
1221: bars. Stop if we get to cd->end_pattern. Note that this is important for the
1222: first-pass call when this value is temporarily adjusted to stop at the current
1223: position. So DO NOT change this to a test for binary zero. */
1224:
1225: for (; ptr < cd->end_pattern; ptr++)
1226: {
1227: /* Skip over backslashed characters and also entire \Q...\E */
1228:
1229: if (*ptr == CHAR_BACKSLASH)
1230: {
1231: if (*(++ptr) == 0) goto FAIL_EXIT;
1232: if (*ptr == CHAR_Q) for (;;)
1233: {
1234: while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
1235: if (*ptr == 0) goto FAIL_EXIT;
1236: if (*(++ptr) == CHAR_E) break;
1237: }
1238: continue;
1239: }
1240:
1241: /* Skip over character classes; this logic must be similar to the way they
1242: are handled for real. If the first character is '^', skip it. Also, if the
1243: first few characters (either before or after ^) are \Q\E or \E we skip them
1244: too. This makes for compatibility with Perl. Note the use of STR macros to
1245: encode "Q\\E" so that it works in UTF-8 on EBCDIC platforms. */
1246:
1247: if (*ptr == CHAR_LEFT_SQUARE_BRACKET)
1248: {
1249: BOOL negate_class = FALSE;
1250: for (;;)
1251: {
1252: if (ptr[1] == CHAR_BACKSLASH)
1253: {
1254: if (ptr[2] == CHAR_E)
1255: ptr+= 2;
1256: else if (strncmp((const char *)ptr+2,
1257: STR_Q STR_BACKSLASH STR_E, 3) == 0)
1258: ptr += 4;
1259: else
1260: break;
1261: }
1262: else if (!negate_class && ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
1263: {
1264: negate_class = TRUE;
1265: ptr++;
1266: }
1267: else break;
1268: }
1269:
1270: /* If the next character is ']', it is a data character that must be
1271: skipped, except in JavaScript compatibility mode. */
1272:
1273: if (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET &&
1274: (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)
1275: ptr++;
1276:
1277: while (*(++ptr) != CHAR_RIGHT_SQUARE_BRACKET)
1278: {
1279: if (*ptr == 0) return -1;
1280: if (*ptr == CHAR_BACKSLASH)
1281: {
1282: if (*(++ptr) == 0) goto FAIL_EXIT;
1283: if (*ptr == CHAR_Q) for (;;)
1284: {
1285: while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
1286: if (*ptr == 0) goto FAIL_EXIT;
1287: if (*(++ptr) == CHAR_E) break;
1288: }
1289: continue;
1290: }
1291: }
1292: continue;
1293: }
1294:
1295: /* Skip comments in /x mode */
1296:
1297: if (xmode && *ptr == CHAR_NUMBER_SIGN)
1298: {
1299: ptr++;
1300: while (*ptr != 0)
1301: {
1302: if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
1303: ptr++;
1304: #ifdef SUPPORT_UTF8
1305: if (utf8) while ((*ptr & 0xc0) == 0x80) ptr++;
1306: #endif
1307: }
1308: if (*ptr == 0) goto FAIL_EXIT;
1309: continue;
1310: }
1311:
1312: /* Check for the special metacharacters */
1313:
1314: if (*ptr == CHAR_LEFT_PARENTHESIS)
1315: {
1316: int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf8, count);
1317: if (rc > 0) return rc;
1318: if (*ptr == 0) goto FAIL_EXIT;
1319: }
1320:
1321: else if (*ptr == CHAR_RIGHT_PARENTHESIS)
1322: {
1323: if (dup_parens && *count < hwm_count) *count = hwm_count;
1324: goto FAIL_EXIT;
1325: }
1326:
1327: else if (*ptr == CHAR_VERTICAL_LINE && dup_parens)
1328: {
1329: if (*count > hwm_count) hwm_count = *count;
1330: *count = start_count;
1331: }
1332: }
1333:
1334: FAIL_EXIT:
1335: *ptrptr = ptr;
1336: return -1;
1337: }
1338:
1339:
1340:
1341:
1342: /*************************************************
1343: * Find forward referenced subpattern *
1344: *************************************************/
1345:
1346: /* This function scans along a pattern's text looking for capturing
1347: subpatterns, and counting them. If it finds a named pattern that matches the
1348: name it is given, it returns its number. Alternatively, if the name is NULL, it
1349: returns when it reaches a given numbered subpattern. This is used for forward
1350: references to subpatterns. We used to be able to start this scan from the
1351: current compiling point, using the current count value from cd->bracount, and
1352: do it all in a single loop, but the addition of the possibility of duplicate
1353: subpattern numbers means that we have to scan from the very start, in order to
1354: take account of such duplicates, and to use a recursive function to keep track
1355: of the different types of group.
1356:
1357: Arguments:
1358: cd compile background data
1359: name name to seek, or NULL if seeking a numbered subpattern
1360: lorn name length, or subpattern number if name is NULL
1361: xmode TRUE if we are in /x mode
1362: utf8 TRUE if we are in UTF-8 mode
1363:
1364: Returns: the number of the found subpattern, or -1 if not found
1365: */
1366:
1367: static int
1368: find_parens(compile_data *cd, const uschar *name, int lorn, BOOL xmode,
1369: BOOL utf8)
1370: {
1371: uschar *ptr = (uschar *)cd->start_pattern;
1372: int count = 0;
1373: int rc;
1374:
1375: /* If the pattern does not start with an opening parenthesis, the first call
1376: to find_parens_sub() will scan right to the end (if necessary). However, if it
1377: does start with a parenthesis, find_parens_sub() will return when it hits the
1378: matching closing parens. That is why we have to have a loop. */
1379:
1380: for (;;)
1381: {
1382: rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf8, &count);
1383: if (rc > 0 || *ptr++ == 0) break;
1384: }
1385:
1386: return rc;
1387: }
1388:
1389:
1390:
1391:
1392: /*************************************************
1393: * Find first significant op code *
1394: *************************************************/
1395:
1396: /* This is called by several functions that scan a compiled expression looking
1397: for a fixed first character, or an anchoring op code etc. It skips over things
1398: that do not influence this. For some calls, a change of option is important.
1399: For some calls, it makes sense to skip negative forward and all backward
1400: assertions, and also the \b assertion; for others it does not.
1401:
1402: Arguments:
1403: code pointer to the start of the group
1404: options pointer to external options
1405: optbit the option bit whose changing is significant, or
1406: zero if none are
1407: skipassert TRUE if certain assertions are to be skipped
1408:
1409: Returns: pointer to the first significant opcode
1410: */
1411:
1412: static const uschar*
1413: first_significant_code(const uschar *code, int *options, int optbit,
1414: BOOL skipassert)
1415: {
1416: for (;;)
1417: {
1418: switch ((int)*code)
1419: {
1420: case OP_OPT:
1421: if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))
1422: *options = (int)code[1];
1423: code += 2;
1424: break;
1425:
1426: case OP_ASSERT_NOT:
1427: case OP_ASSERTBACK:
1428: case OP_ASSERTBACK_NOT:
1429: if (!skipassert) return code;
1430: do code += GET(code, 1); while (*code == OP_ALT);
1431: code += _pcre_OP_lengths[*code];
1432: break;
1433:
1434: case OP_WORD_BOUNDARY:
1435: case OP_NOT_WORD_BOUNDARY:
1436: if (!skipassert) return code;
1437: /* Fall through */
1438:
1439: case OP_CALLOUT:
1440: case OP_CREF:
1441: case OP_NCREF:
1442: case OP_RREF:
1443: case OP_NRREF:
1444: case OP_DEF:
1445: code += _pcre_OP_lengths[*code];
1446: break;
1447:
1448: default:
1449: return code;
1450: }
1451: }
1452: /* Control never reaches here */
1453: }
1454:
1455:
1456:
1457:
1458: /*************************************************
1459: * Find the fixed length of a branch *
1460: *************************************************/
1461:
1462: /* Scan a branch and compute the fixed length of subject that will match it,
1463: if the length is fixed. This is needed for dealing with backward assertions.
1464: In UTF8 mode, the result is in characters rather than bytes. The branch is
1465: temporarily terminated with OP_END when this function is called.
1466:
1467: This function is called when a backward assertion is encountered, so that if it
1468: fails, the error message can point to the correct place in the pattern.
1469: However, we cannot do this when the assertion contains subroutine calls,
1470: because they can be forward references. We solve this by remembering this case
1471: and doing the check at the end; a flag specifies which mode we are running in.
1472:
1473: Arguments:
1474: code points to the start of the pattern (the bracket)
1475: options the compiling options
1476: atend TRUE if called when the pattern is complete
1477: cd the "compile data" structure
1478:
1479: Returns: the fixed length,
1480: or -1 if there is no fixed length,
1481: or -2 if \C was encountered
1482: or -3 if an OP_RECURSE item was encountered and atend is FALSE
1483: */
1484:
1485: static int
1486: find_fixedlength(uschar *code, int options, BOOL atend, compile_data *cd)
1487: {
1488: int length = -1;
1489:
1490: register int branchlength = 0;
1491: register uschar *cc = code + 1 + LINK_SIZE;
1492:
1493: /* Scan along the opcodes for this branch. If we get to the end of the
1494: branch, check the length against that of the other branches. */
1495:
1496: for (;;)
1497: {
1498: int d;
1499: uschar *ce, *cs;
1500: register int op = *cc;
1501: switch (op)
1502: {
1503: case OP_CBRA:
1504: case OP_BRA:
1505: case OP_ONCE:
1506: case OP_COND:
1507: d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), options, atend, cd);
1508: if (d < 0) return d;
1509: branchlength += d;
1510: do cc += GET(cc, 1); while (*cc == OP_ALT);
1511: cc += 1 + LINK_SIZE;
1512: break;
1513:
1514: /* Reached end of a branch; if it's a ket it is the end of a nested
1515: call. If it's ALT it is an alternation in a nested call. If it is
1516: END it's the end of the outer call. All can be handled by the same code. */
1517:
1518: case OP_ALT:
1519: case OP_KET:
1520: case OP_KETRMAX:
1521: case OP_KETRMIN:
1522: case OP_END:
1523: if (length < 0) length = branchlength;
1524: else if (length != branchlength) return -1;
1525: if (*cc != OP_ALT) return length;
1526: cc += 1 + LINK_SIZE;
1527: branchlength = 0;
1528: break;
1529:
1530: /* A true recursion implies not fixed length, but a subroutine call may
1531: be OK. If the subroutine is a forward reference, we can't deal with
1532: it until the end of the pattern, so return -3. */
1533:
1534: case OP_RECURSE:
1535: if (!atend) return -3;
1536: cs = ce = (uschar *)cd->start_code + GET(cc, 1); /* Start subpattern */
1537: do ce += GET(ce, 1); while (*ce == OP_ALT); /* End subpattern */
1538: if (cc > cs && cc < ce) return -1; /* Recursion */
1539: d = find_fixedlength(cs + 2, options, atend, cd);
1540: if (d < 0) return d;
1541: branchlength += d;
1542: cc += 1 + LINK_SIZE;
1543: break;
1544:
1545: /* Skip over assertive subpatterns */
1546:
1547: case OP_ASSERT:
1548: case OP_ASSERT_NOT:
1549: case OP_ASSERTBACK:
1550: case OP_ASSERTBACK_NOT:
1551: do cc += GET(cc, 1); while (*cc == OP_ALT);
1552: /* Fall through */
1553:
1554: /* Skip over things that don't match chars */
1555:
1556: case OP_REVERSE:
1557: case OP_CREF:
1558: case OP_NCREF:
1559: case OP_RREF:
1560: case OP_NRREF:
1561: case OP_DEF:
1562: case OP_OPT:
1563: case OP_CALLOUT:
1564: case OP_SOD:
1565: case OP_SOM:
1566: case OP_SET_SOM:
1567: case OP_EOD:
1568: case OP_EODN:
1569: case OP_CIRC:
1570: case OP_DOLL:
1571: case OP_NOT_WORD_BOUNDARY:
1572: case OP_WORD_BOUNDARY:
1573: cc += _pcre_OP_lengths[*cc];
1574: break;
1575:
1576: /* Handle literal characters */
1577:
1578: case OP_CHAR:
1579: case OP_CHARNC:
1580: case OP_NOT:
1581: branchlength++;
1582: cc += 2;
1583: #ifdef SUPPORT_UTF8
1584: if ((options & PCRE_UTF8) != 0 && cc[-1] >= 0xc0)
1585: cc += _pcre_utf8_table4[cc[-1] & 0x3f];
1586: #endif
1587: break;
1588:
1589: /* Handle exact repetitions. The count is already in characters, but we
1590: need to skip over a multibyte character in UTF8 mode. */
1591:
1592: case OP_EXACT:
1593: branchlength += GET2(cc,1);
1594: cc += 4;
1595: #ifdef SUPPORT_UTF8
1596: if ((options & PCRE_UTF8) != 0 && cc[-1] >= 0xc0)
1597: cc += _pcre_utf8_table4[cc[-1] & 0x3f];
1598: #endif
1599: break;
1600:
1601: case OP_TYPEEXACT:
1602: branchlength += GET2(cc,1);
1603: if (cc[3] == OP_PROP || cc[3] == OP_NOTPROP) cc += 2;
1604: cc += 4;
1605: break;
1606:
1607: /* Handle single-char matchers */
1608:
1609: case OP_PROP:
1610: case OP_NOTPROP:
1611: cc += 2;
1612: /* Fall through */
1613:
1614: case OP_NOT_DIGIT:
1615: case OP_DIGIT:
1616: case OP_NOT_WHITESPACE:
1617: case OP_WHITESPACE:
1618: case OP_NOT_WORDCHAR:
1619: case OP_WORDCHAR:
1620: case OP_ANY:
1621: case OP_ALLANY:
1622: branchlength++;
1623: cc++;
1624: break;
1625:
1626: /* The single-byte matcher isn't allowed */
1627:
1628: case OP_ANYBYTE:
1629: return -2;
1630:
1631: /* Check a class for variable quantification */
1632:
1633: #ifdef SUPPORT_UTF8
1634: case OP_XCLASS:
1635: cc += GET(cc, 1) - 33;
1636: /* Fall through */
1637: #endif
1638:
1639: case OP_CLASS:
1640: case OP_NCLASS:
1641: cc += 33;
1642:
1643: switch (*cc)
1644: {
1645: case OP_CRSTAR:
1646: case OP_CRMINSTAR:
1647: case OP_CRQUERY:
1648: case OP_CRMINQUERY:
1649: return -1;
1650:
1651: case OP_CRRANGE:
1652: case OP_CRMINRANGE:
1653: if (GET2(cc,1) != GET2(cc,3)) return -1;
1654: branchlength += GET2(cc,1);
1655: cc += 5;
1656: break;
1657:
1658: default:
1659: branchlength++;
1660: }
1661: break;
1662:
1663: /* Anything else is variable length */
1664:
1665: default:
1666: return -1;
1667: }
1668: }
1669: /* Control never gets here */
1670: }
1671:
1672:
1673:
1674:
1675: /*************************************************
1676: * Scan compiled regex for specific bracket *
1677: *************************************************/
1678:
1679: /* This little function scans through a compiled pattern until it finds a
1680: capturing bracket with the given number, or, if the number is negative, an
1681: instance of OP_REVERSE for a lookbehind. The function is global in the C sense
1682: so that it can be called from pcre_study() when finding the minimum matching
1683: length.
1684:
1685: Arguments:
1686: code points to start of expression
1687: utf8 TRUE in UTF-8 mode
1688: number the required bracket number or negative to find a lookbehind
1689:
1690: Returns: pointer to the opcode for the bracket, or NULL if not found
1691: */
1692:
1693: const uschar *
1694: _pcre_find_bracket(const uschar *code, BOOL utf8, int number)
1695: {
1696: for (;;)
1697: {
1698: register int c = *code;
1699: if (c == OP_END) return NULL;
1700:
1701: /* XCLASS is used for classes that cannot be represented just by a bit
1702: map. This includes negated single high-valued characters. The length in
1703: the table is zero; the actual length is stored in the compiled code. */
1704:
1705: if (c == OP_XCLASS) code += GET(code, 1);
1706:
1707: /* Handle recursion */
1708:
1709: else if (c == OP_REVERSE)
1710: {
1711: if (number < 0) return (uschar *)code;
1712: code += _pcre_OP_lengths[c];
1713: }
1714:
1715: /* Handle capturing bracket */
1716:
1717: else if (c == OP_CBRA)
1718: {
1719: int n = GET2(code, 1+LINK_SIZE);
1720: if (n == number) return (uschar *)code;
1721: code += _pcre_OP_lengths[c];
1722: }
1723:
1724: /* Otherwise, we can get the item's length from the table, except that for
1725: repeated character types, we have to test for \p and \P, which have an extra
1726: two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
1727: must add in its length. */
1728:
1729: else
1730: {
1731: switch(c)
1732: {
1733: case OP_TYPESTAR:
1734: case OP_TYPEMINSTAR:
1735: case OP_TYPEPLUS:
1736: case OP_TYPEMINPLUS:
1737: case OP_TYPEQUERY:
1738: case OP_TYPEMINQUERY:
1739: case OP_TYPEPOSSTAR:
1740: case OP_TYPEPOSPLUS:
1741: case OP_TYPEPOSQUERY:
1742: if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
1743: break;
1744:
1745: case OP_TYPEUPTO:
1746: case OP_TYPEMINUPTO:
1747: case OP_TYPEEXACT:
1748: case OP_TYPEPOSUPTO:
1749: if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
1750: break;
1751:
1752: case OP_MARK:
1753: case OP_PRUNE_ARG:
1754: case OP_SKIP_ARG:
1755: code += code[1];
1756: break;
1757:
1758: case OP_THEN_ARG:
1759: code += code[1+LINK_SIZE];
1760: break;
1761: }
1762:
1763: /* Add in the fixed length from the table */
1764:
1765: code += _pcre_OP_lengths[c];
1766:
1767: /* In UTF-8 mode, opcodes that are followed by a character may be followed by
1768: a multi-byte character. The length in the table is a minimum, so we have to
1769: arrange to skip the extra bytes. */
1770:
1771: #ifdef SUPPORT_UTF8
1772: if (utf8) switch(c)
1773: {
1774: case OP_CHAR:
1775: case OP_CHARNC:
1776: case OP_EXACT:
1777: case OP_UPTO:
1778: case OP_MINUPTO:
1779: case OP_POSUPTO:
1780: case OP_STAR:
1781: case OP_MINSTAR:
1782: case OP_POSSTAR:
1783: case OP_PLUS:
1784: case OP_MINPLUS:
1785: case OP_POSPLUS:
1786: case OP_QUERY:
1787: case OP_MINQUERY:
1788: case OP_POSQUERY:
1789: if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
1790: break;
1791: }
1792: #else
1793: (void)(utf8); /* Keep compiler happy by referencing function argument */
1794: #endif
1795: }
1796: }
1797: }
1798:
1799:
1800:
1801: /*************************************************
1802: * Scan compiled regex for recursion reference *
1803: *************************************************/
1804:
1805: /* This little function scans through a compiled pattern until it finds an
1806: instance of OP_RECURSE.
1807:
1808: Arguments:
1809: code points to start of expression
1810: utf8 TRUE in UTF-8 mode
1811:
1812: Returns: pointer to the opcode for OP_RECURSE, or NULL if not found
1813: */
1814:
1815: static const uschar *
1816: find_recurse(const uschar *code, BOOL utf8)
1817: {
1818: for (;;)
1819: {
1820: register int c = *code;
1821: if (c == OP_END) return NULL;
1822: if (c == OP_RECURSE) return code;
1823:
1824: /* XCLASS is used for classes that cannot be represented just by a bit
1825: map. This includes negated single high-valued characters. The length in
1826: the table is zero; the actual length is stored in the compiled code. */
1827:
1828: if (c == OP_XCLASS) code += GET(code, 1);
1829:
1830: /* Otherwise, we can get the item's length from the table, except that for
1831: repeated character types, we have to test for \p and \P, which have an extra
1832: two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
1833: must add in its length. */
1834:
1835: else
1836: {
1837: switch(c)
1838: {
1839: case OP_TYPESTAR:
1840: case OP_TYPEMINSTAR:
1841: case OP_TYPEPLUS:
1842: case OP_TYPEMINPLUS:
1843: case OP_TYPEQUERY:
1844: case OP_TYPEMINQUERY:
1845: case OP_TYPEPOSSTAR:
1846: case OP_TYPEPOSPLUS:
1847: case OP_TYPEPOSQUERY:
1848: if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
1849: break;
1850:
1851: case OP_TYPEPOSUPTO:
1852: case OP_TYPEUPTO:
1853: case OP_TYPEMINUPTO:
1854: case OP_TYPEEXACT:
1855: if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
1856: break;
1857:
1858: case OP_MARK:
1859: case OP_PRUNE_ARG:
1860: case OP_SKIP_ARG:
1861: code += code[1];
1862: break;
1863:
1864: case OP_THEN_ARG:
1865: code += code[1+LINK_SIZE];
1866: break;
1867: }
1868:
1869: /* Add in the fixed length from the table */
1870:
1871: code += _pcre_OP_lengths[c];
1872:
1873: /* In UTF-8 mode, opcodes that are followed by a character may be followed
1874: by a multi-byte character. The length in the table is a minimum, so we have
1875: to arrange to skip the extra bytes. */
1876:
1877: #ifdef SUPPORT_UTF8
1878: if (utf8) switch(c)
1879: {
1880: case OP_CHAR:
1881: case OP_CHARNC:
1882: case OP_EXACT:
1883: case OP_UPTO:
1884: case OP_MINUPTO:
1885: case OP_POSUPTO:
1886: case OP_STAR:
1887: case OP_MINSTAR:
1888: case OP_POSSTAR:
1889: case OP_PLUS:
1890: case OP_MINPLUS:
1891: case OP_POSPLUS:
1892: case OP_QUERY:
1893: case OP_MINQUERY:
1894: case OP_POSQUERY:
1895: if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
1896: break;
1897: }
1898: #else
1899: (void)(utf8); /* Keep compiler happy by referencing function argument */
1900: #endif
1901: }
1902: }
1903: }
1904:
1905:
1906:
1907: /*************************************************
1908: * Scan compiled branch for non-emptiness *
1909: *************************************************/
1910:
1911: /* This function scans through a branch of a compiled pattern to see whether it
1912: can match the empty string or not. It is called from could_be_empty()
1913: below and from compile_branch() when checking for an unlimited repeat of a
1914: group that can match nothing. Note that first_significant_code() skips over
1915: backward and negative forward assertions when its final argument is TRUE. If we
1916: hit an unclosed bracket, we return "empty" - this means we've struck an inner
1917: bracket whose current branch will already have been scanned.
1918:
1919: Arguments:
1920: code points to start of search
1921: endcode points to where to stop
1922: utf8 TRUE if in UTF8 mode
1923: cd contains pointers to tables etc.
1924:
1925: Returns: TRUE if what is matched could be empty
1926: */
1927:
1928: static BOOL
1929: could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8,
1930: compile_data *cd)
1931: {
1932: register int c;
1933: for (code = first_significant_code(code + _pcre_OP_lengths[*code], NULL, 0, TRUE);
1934: code < endcode;
1935: code = first_significant_code(code + _pcre_OP_lengths[c], NULL, 0, TRUE))
1936: {
1937: const uschar *ccode;
1938:
1939: c = *code;
1940:
1941: /* Skip over forward assertions; the other assertions are skipped by
1942: first_significant_code() with a TRUE final argument. */
1943:
1944: if (c == OP_ASSERT)
1945: {
1946: do code += GET(code, 1); while (*code == OP_ALT);
1947: c = *code;
1948: continue;
1949: }
1950:
1951: /* Groups with zero repeats can of course be empty; skip them. */
1952:
1953: if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO)
1954: {
1955: code += _pcre_OP_lengths[c];
1956: do code += GET(code, 1); while (*code == OP_ALT);
1957: c = *code;
1958: continue;
1959: }
1960:
1961: /* For a recursion/subroutine call, if its end has been reached, which
1962: implies a subroutine call, we can scan it. */
1963:
1964: if (c == OP_RECURSE)
1965: {
1966: BOOL empty_branch = FALSE;
1967: const uschar *scode = cd->start_code + GET(code, 1);
1968: if (GET(scode, 1) == 0) return TRUE; /* Unclosed */
1969: do
1970: {
1971: if (could_be_empty_branch(scode, endcode, utf8, cd))
1972: {
1973: empty_branch = TRUE;
1974: break;
1975: }
1976: scode += GET(scode, 1);
1977: }
1978: while (*scode == OP_ALT);
1979: if (!empty_branch) return FALSE; /* All branches are non-empty */
1980: continue;
1981: }
1982:
1983: /* For other groups, scan the branches. */
1984:
1985: if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE || c == OP_COND)
1986: {
1987: BOOL empty_branch;
1988: if (GET(code, 1) == 0) return TRUE; /* Hit unclosed bracket */
1989:
1990: /* If a conditional group has only one branch, there is a second, implied,
1991: empty branch, so just skip over the conditional, because it could be empty.
1992: Otherwise, scan the individual branches of the group. */
1993:
1994: if (c == OP_COND && code[GET(code, 1)] != OP_ALT)
1995: code += GET(code, 1);
1996: else
1997: {
1998: empty_branch = FALSE;
1999: do
2000: {
2001: if (!empty_branch && could_be_empty_branch(code, endcode, utf8, cd))
2002: empty_branch = TRUE;
2003: code += GET(code, 1);
2004: }
2005: while (*code == OP_ALT);
2006: if (!empty_branch) return FALSE; /* All branches are non-empty */
2007: }
2008:
2009: c = *code;
2010: continue;
2011: }
2012:
2013: /* Handle the other opcodes */
2014:
2015: switch (c)
2016: {
2017: /* Check for quantifiers after a class. XCLASS is used for classes that
2018: cannot be represented just by a bit map. This includes negated single
2019: high-valued characters. The length in _pcre_OP_lengths[] is zero; the
2020: actual length is stored in the compiled code, so we must update "code"
2021: here. */
2022:
2023: #ifdef SUPPORT_UTF8
2024: case OP_XCLASS:
2025: ccode = code += GET(code, 1);
2026: goto CHECK_CLASS_REPEAT;
2027: #endif
2028:
2029: case OP_CLASS:
2030: case OP_NCLASS:
2031: ccode = code + 33;
2032:
2033: #ifdef SUPPORT_UTF8
2034: CHECK_CLASS_REPEAT:
2035: #endif
2036:
2037: switch (*ccode)
2038: {
2039: case OP_CRSTAR: /* These could be empty; continue */
2040: case OP_CRMINSTAR:
2041: case OP_CRQUERY:
2042: case OP_CRMINQUERY:
2043: break;
2044:
2045: default: /* Non-repeat => class must match */
2046: case OP_CRPLUS: /* These repeats aren't empty */
2047: case OP_CRMINPLUS:
2048: return FALSE;
2049:
2050: case OP_CRRANGE:
2051: case OP_CRMINRANGE:
2052: if (GET2(ccode, 1) > 0) return FALSE; /* Minimum > 0 */
2053: break;
2054: }
2055: break;
2056:
2057: /* Opcodes that must match a character */
2058:
2059: case OP_PROP:
2060: case OP_NOTPROP:
2061: case OP_EXTUNI:
2062: case OP_NOT_DIGIT:
2063: case OP_DIGIT:
2064: case OP_NOT_WHITESPACE:
2065: case OP_WHITESPACE:
2066: case OP_NOT_WORDCHAR:
2067: case OP_WORDCHAR:
2068: case OP_ANY:
2069: case OP_ALLANY:
2070: case OP_ANYBYTE:
2071: case OP_CHAR:
2072: case OP_CHARNC:
2073: case OP_NOT:
2074: case OP_PLUS:
2075: case OP_MINPLUS:
2076: case OP_POSPLUS:
2077: case OP_EXACT:
2078: case OP_NOTPLUS:
2079: case OP_NOTMINPLUS:
2080: case OP_NOTPOSPLUS:
2081: case OP_NOTEXACT:
2082: case OP_TYPEPLUS:
2083: case OP_TYPEMINPLUS:
2084: case OP_TYPEPOSPLUS:
2085: case OP_TYPEEXACT:
2086: return FALSE;
2087:
2088: /* These are going to continue, as they may be empty, but we have to
2089: fudge the length for the \p and \P cases. */
2090:
2091: case OP_TYPESTAR:
2092: case OP_TYPEMINSTAR:
2093: case OP_TYPEPOSSTAR:
2094: case OP_TYPEQUERY:
2095: case OP_TYPEMINQUERY:
2096: case OP_TYPEPOSQUERY:
2097: if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2098: break;
2099:
2100: /* Same for these */
2101:
2102: case OP_TYPEUPTO:
2103: case OP_TYPEMINUPTO:
2104: case OP_TYPEPOSUPTO:
2105: if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
2106: break;
2107:
2108: /* End of branch */
2109:
2110: case OP_KET:
2111: case OP_KETRMAX:
2112: case OP_KETRMIN:
2113: case OP_ALT:
2114: return TRUE;
2115:
2116: /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
2117: MINUPTO, and POSUPTO may be followed by a multibyte character */
2118:
2119: #ifdef SUPPORT_UTF8
2120: case OP_STAR:
2121: case OP_MINSTAR:
2122: case OP_POSSTAR:
2123: case OP_QUERY:
2124: case OP_MINQUERY:
2125: case OP_POSQUERY:
2126: if (utf8 && code[1] >= 0xc0) code += _pcre_utf8_table4[code[1] & 0x3f];
2127: break;
2128:
2129: case OP_UPTO:
2130: case OP_MINUPTO:
2131: case OP_POSUPTO:
2132: if (utf8 && code[3] >= 0xc0) code += _pcre_utf8_table4[code[3] & 0x3f];
2133: break;
2134: #endif
2135:
2136: /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument
2137: string. */
2138:
2139: case OP_MARK:
2140: case OP_PRUNE_ARG:
2141: case OP_SKIP_ARG:
2142: code += code[1];
2143: break;
2144:
2145: case OP_THEN_ARG:
2146: code += code[1+LINK_SIZE];
2147: break;
2148:
2149: /* None of the remaining opcodes are required to match a character. */
2150:
2151: default:
2152: break;
2153: }
2154: }
2155:
2156: return TRUE;
2157: }
2158:
2159:
2160:
2161: /*************************************************
2162: * Scan compiled regex for non-emptiness *
2163: *************************************************/
2164:
2165: /* This function is called to check for left recursive calls. We want to check
2166: the current branch of the current pattern to see if it could match the empty
2167: string. If it could, we must look outwards for branches at other levels,
2168: stopping when we pass beyond the bracket which is the subject of the recursion.
2169:
2170: Arguments:
2171: code points to start of the recursion
2172: endcode points to where to stop (current RECURSE item)
2173: bcptr points to the chain of current (unclosed) branch starts
2174: utf8 TRUE if in UTF-8 mode
2175: cd pointers to tables etc
2176:
2177: Returns: TRUE if what is matched could be empty
2178: */
2179:
2180: static BOOL
2181: could_be_empty(const uschar *code, const uschar *endcode, branch_chain *bcptr,
2182: BOOL utf8, compile_data *cd)
2183: {
2184: while (bcptr != NULL && bcptr->current_branch >= code)
2185: {
2186: if (!could_be_empty_branch(bcptr->current_branch, endcode, utf8, cd))
2187: return FALSE;
2188: bcptr = bcptr->outer;
2189: }
2190: return TRUE;
2191: }
2192:
2193:
2194:
2195: /*************************************************
2196: * Check for POSIX class syntax *
2197: *************************************************/
2198:
2199: /* This function is called when the sequence "[:" or "[." or "[=" is
2200: encountered in a character class. It checks whether this is followed by a
2201: sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
2202: reach an unescaped ']' without the special preceding character, return FALSE.
2203:
2204: Originally, this function only recognized a sequence of letters between the
2205: terminators, but it seems that Perl recognizes any sequence of characters,
2206: though of course unknown POSIX names are subsequently rejected. Perl gives an
2207: "Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
2208: didn't consider this to be a POSIX class. Likewise for [:1234:].
2209:
2210: The problem in trying to be exactly like Perl is in the handling of escapes. We
2211: have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
2212: class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
2213: below handles the special case of \], but does not try to do any other escape
2214: processing. This makes it different from Perl for cases such as [:l\ower:]
2215: where Perl recognizes it as the POSIX class "lower" but PCRE does not recognize
2216: "l\ower". This is a lesser evil that not diagnosing bad classes when Perl does,
2217: I think.
2218:
2219: Arguments:
2220: ptr pointer to the initial [
2221: endptr where to return the end pointer
2222:
2223: Returns: TRUE or FALSE
2224: */
2225:
2226: static BOOL
2227: check_posix_syntax(const uschar *ptr, const uschar **endptr)
2228: {
2229: int terminator; /* Don't combine these lines; the Solaris cc */
2230: terminator = *(++ptr); /* compiler warns about "non-constant" initializer. */
2231: for (++ptr; *ptr != 0; ptr++)
2232: {
2233: if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET) ptr++; else
2234: {
2235: if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
2236: if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
2237: {
2238: *endptr = ptr;
2239: return TRUE;
2240: }
2241: }
2242: }
2243: return FALSE;
2244: }
2245:
2246:
2247:
2248:
2249: /*************************************************
2250: * Check POSIX class name *
2251: *************************************************/
2252:
2253: /* This function is called to check the name given in a POSIX-style class entry
2254: such as [:alnum:].
2255:
2256: Arguments:
2257: ptr points to the first letter
2258: len the length of the name
2259:
2260: Returns: a value representing the name, or -1 if unknown
2261: */
2262:
2263: static int
2264: check_posix_name(const uschar *ptr, int len)
2265: {
2266: const char *pn = posix_names;
2267: register int yield = 0;
2268: while (posix_name_lengths[yield] != 0)
2269: {
2270: if (len == posix_name_lengths[yield] &&
2271: strncmp((const char *)ptr, pn, len) == 0) return yield;
2272: pn += posix_name_lengths[yield] + 1;
2273: yield++;
2274: }
2275: return -1;
2276: }
2277:
2278:
2279: /*************************************************
2280: * Adjust OP_RECURSE items in repeated group *
2281: *************************************************/
2282:
2283: /* OP_RECURSE items contain an offset from the start of the regex to the group
2284: that is referenced. This means that groups can be replicated for fixed
2285: repetition simply by copying (because the recursion is allowed to refer to
2286: earlier groups that are outside the current group). However, when a group is
2287: optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is
2288: inserted before it, after it has been compiled. This means that any OP_RECURSE
2289: items within it that refer to the group itself or any contained groups have to
2290: have their offsets adjusted. That one of the jobs of this function. Before it
2291: is called, the partially compiled regex must be temporarily terminated with
2292: OP_END.
2293:
2294: This function has been extended with the possibility of forward references for
2295: recursions and subroutine calls. It must also check the list of such references
2296: for the group we are dealing with. If it finds that one of the recursions in
2297: the current group is on this list, it adjusts the offset in the list, not the
2298: value in the reference (which is a group number).
2299:
2300: Arguments:
2301: group points to the start of the group
2302: adjust the amount by which the group is to be moved
2303: utf8 TRUE in UTF-8 mode
2304: cd contains pointers to tables etc.
2305: save_hwm the hwm forward reference pointer at the start of the group
2306:
2307: Returns: nothing
2308: */
2309:
2310: static void
2311: adjust_recurse(uschar *group, int adjust, BOOL utf8, compile_data *cd,
2312: uschar *save_hwm)
2313: {
2314: uschar *ptr = group;
2315:
2316: while ((ptr = (uschar *)find_recurse(ptr, utf8)) != NULL)
2317: {
2318: int offset;
2319: uschar *hc;
2320:
2321: /* See if this recursion is on the forward reference list. If so, adjust the
2322: reference. */
2323:
2324: for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)
2325: {
2326: offset = GET(hc, 0);
2327: if (cd->start_code + offset == ptr + 1)
2328: {
2329: PUT(hc, 0, offset + adjust);
2330: break;
2331: }
2332: }
2333:
2334: /* Otherwise, adjust the recursion offset if it's after the start of this
2335: group. */
2336:
2337: if (hc >= cd->hwm)
2338: {
2339: offset = GET(ptr, 1);
2340: if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
2341: }
2342:
2343: ptr += 1 + LINK_SIZE;
2344: }
2345: }
2346:
2347:
2348:
2349: /*************************************************
2350: * Insert an automatic callout point *
2351: *************************************************/
2352:
2353: /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
2354: callout points before each pattern item.
2355:
2356: Arguments:
2357: code current code pointer
2358: ptr current pattern pointer
2359: cd pointers to tables etc
2360:
2361: Returns: new code pointer
2362: */
2363:
2364: static uschar *
2365: auto_callout(uschar *code, const uschar *ptr, compile_data *cd)
2366: {
2367: *code++ = OP_CALLOUT;
2368: *code++ = 255;
2369: PUT(code, 0, (int)(ptr - cd->start_pattern)); /* Pattern offset */
2370: PUT(code, LINK_SIZE, 0); /* Default length */
2371: return code + 2*LINK_SIZE;
2372: }
2373:
2374:
2375:
2376: /*************************************************
2377: * Complete a callout item *
2378: *************************************************/
2379:
2380: /* A callout item contains the length of the next item in the pattern, which
2381: we can't fill in till after we have reached the relevant point. This is used
2382: for both automatic and manual callouts.
2383:
2384: Arguments:
2385: previous_callout points to previous callout item
2386: ptr current pattern pointer
2387: cd pointers to tables etc
2388:
2389: Returns: nothing
2390: */
2391:
2392: static void
2393: complete_callout(uschar *previous_callout, const uschar *ptr, compile_data *cd)
2394: {
2395: int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));
2396: PUT(previous_callout, 2 + LINK_SIZE, length);
2397: }
2398:
2399:
2400:
2401: #ifdef SUPPORT_UCP
2402: /*************************************************
2403: * Get othercase range *
2404: *************************************************/
2405:
2406: /* This function is passed the start and end of a class range, in UTF-8 mode
2407: with UCP support. It searches up the characters, looking for internal ranges of
2408: characters in the "other" case. Each call returns the next one, updating the
2409: start address.
2410:
2411: Arguments:
2412: cptr points to starting character value; updated
2413: d end value
2414: ocptr where to put start of othercase range
2415: odptr where to put end of othercase range
2416:
2417: Yield: TRUE when range returned; FALSE when no more
2418: */
2419:
2420: static BOOL
2421: get_othercase_range(unsigned int *cptr, unsigned int d, unsigned int *ocptr,
2422: unsigned int *odptr)
2423: {
2424: unsigned int c, othercase, next;
2425:
2426: for (c = *cptr; c <= d; c++)
2427: { if ((othercase = UCD_OTHERCASE(c)) != c) break; }
2428:
2429: if (c > d) return FALSE;
2430:
2431: *ocptr = othercase;
2432: next = othercase + 1;
2433:
2434: for (++c; c <= d; c++)
2435: {
2436: if (UCD_OTHERCASE(c) != next) break;
2437: next++;
2438: }
2439:
2440: *odptr = next - 1;
2441: *cptr = c;
2442:
2443: return TRUE;
2444: }
2445:
2446:
2447:
2448: /*************************************************
2449: * Check a character and a property *
2450: *************************************************/
2451:
2452: /* This function is called by check_auto_possessive() when a property item
2453: is adjacent to a fixed character.
2454:
2455: Arguments:
2456: c the character
2457: ptype the property type
2458: pdata the data for the type
2459: negated TRUE if it's a negated property (\P or \p{^)
2460:
2461: Returns: TRUE if auto-possessifying is OK
2462: */
2463:
2464: static BOOL
2465: check_char_prop(int c, int ptype, int pdata, BOOL negated)
2466: {
2467: const ucd_record *prop = GET_UCD(c);
2468: switch(ptype)
2469: {
2470: case PT_LAMP:
2471: return (prop->chartype == ucp_Lu ||
2472: prop->chartype == ucp_Ll ||
2473: prop->chartype == ucp_Lt) == negated;
2474:
2475: case PT_GC:
2476: return (pdata == _pcre_ucp_gentype[prop->chartype]) == negated;
2477:
2478: case PT_PC:
2479: return (pdata == prop->chartype) == negated;
2480:
2481: case PT_SC:
2482: return (pdata == prop->script) == negated;
2483:
2484: /* These are specials */
2485:
2486: case PT_ALNUM:
2487: return (_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2488: _pcre_ucp_gentype[prop->chartype] == ucp_N) == negated;
2489:
2490: case PT_SPACE: /* Perl space */
2491: return (_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2492: c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2493: == negated;
2494:
2495: case PT_PXSPACE: /* POSIX space */
2496: return (_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2497: c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2498: c == CHAR_FF || c == CHAR_CR)
2499: == negated;
2500:
2501: case PT_WORD:
2502: return (_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2503: _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2504: c == CHAR_UNDERSCORE) == negated;
2505: }
2506: return FALSE;
2507: }
2508: #endif /* SUPPORT_UCP */
2509:
2510:
2511:
2512: /*************************************************
2513: * Check if auto-possessifying is possible *
2514: *************************************************/
2515:
2516: /* This function is called for unlimited repeats of certain items, to see
2517: whether the next thing could possibly match the repeated item. If not, it makes
2518: sense to automatically possessify the repeated item.
2519:
2520: Arguments:
2521: previous pointer to the repeated opcode
2522: utf8 TRUE in UTF-8 mode
2523: ptr next character in pattern
2524: options options bits
2525: cd contains pointers to tables etc.
2526:
2527: Returns: TRUE if possessifying is wanted
2528: */
2529:
2530: static BOOL
2531: check_auto_possessive(const uschar *previous, BOOL utf8, const uschar *ptr,
2532: int options, compile_data *cd)
2533: {
2534: int c, next;
2535: int op_code = *previous++;
2536:
2537: /* Skip whitespace and comments in extended mode */
2538:
2539: if ((options & PCRE_EXTENDED) != 0)
2540: {
2541: for (;;)
2542: {
2543: while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
2544: if (*ptr == CHAR_NUMBER_SIGN)
2545: {
2546: ptr++;
2547: while (*ptr != 0)
2548: {
2549: if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
2550: ptr++;
2551: #ifdef SUPPORT_UTF8
2552: if (utf8) while ((*ptr & 0xc0) == 0x80) ptr++;
2553: #endif
2554: }
2555: }
2556: else break;
2557: }
2558: }
2559:
2560: /* If the next item is one that we can handle, get its value. A non-negative
2561: value is a character, a negative value is an escape value. */
2562:
2563: if (*ptr == CHAR_BACKSLASH)
2564: {
2565: int temperrorcode = 0;
2566: next = check_escape(&ptr, &temperrorcode, cd->bracount, options, FALSE);
2567: if (temperrorcode != 0) return FALSE;
2568: ptr++; /* Point after the escape sequence */
2569: }
2570:
2571: else if ((cd->ctypes[*ptr] & ctype_meta) == 0)
2572: {
2573: #ifdef SUPPORT_UTF8
2574: if (utf8) { GETCHARINC(next, ptr); } else
2575: #endif
2576: next = *ptr++;
2577: }
2578:
2579: else return FALSE;
2580:
2581: /* Skip whitespace and comments in extended mode */
2582:
2583: if ((options & PCRE_EXTENDED) != 0)
2584: {
2585: for (;;)
2586: {
2587: while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
2588: if (*ptr == CHAR_NUMBER_SIGN)
2589: {
2590: ptr++;
2591: while (*ptr != 0)
2592: {
2593: if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
2594: ptr++;
2595: #ifdef SUPPORT_UTF8
2596: if (utf8) while ((*ptr & 0xc0) == 0x80) ptr++;
2597: #endif
2598: }
2599: }
2600: else break;
2601: }
2602: }
2603:
2604: /* If the next thing is itself optional, we have to give up. */
2605:
2606: if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
2607: strncmp((char *)ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
2608: return FALSE;
2609:
2610: /* Now compare the next item with the previous opcode. First, handle cases when
2611: the next item is a character. */
2612:
2613: if (next >= 0) switch(op_code)
2614: {
2615: case OP_CHAR:
2616: #ifdef SUPPORT_UTF8
2617: GETCHARTEST(c, previous);
2618: #else
2619: c = *previous;
2620: #endif
2621: return c != next;
2622:
2623: /* For CHARNC (caseless character) we must check the other case. If we have
2624: Unicode property support, we can use it to test the other case of
2625: high-valued characters. */
2626:
2627: case OP_CHARNC:
2628: #ifdef SUPPORT_UTF8
2629: GETCHARTEST(c, previous);
2630: #else
2631: c = *previous;
2632: #endif
2633: if (c == next) return FALSE;
2634: #ifdef SUPPORT_UTF8
2635: if (utf8)
2636: {
2637: unsigned int othercase;
2638: if (next < 128) othercase = cd->fcc[next]; else
2639: #ifdef SUPPORT_UCP
2640: othercase = UCD_OTHERCASE((unsigned int)next);
2641: #else
2642: othercase = NOTACHAR;
2643: #endif
2644: return (unsigned int)c != othercase;
2645: }
2646: else
2647: #endif /* SUPPORT_UTF8 */
2648: return (c != cd->fcc[next]); /* Non-UTF-8 mode */
2649:
2650: /* For OP_NOT, its data is always a single-byte character. */
2651:
2652: case OP_NOT:
2653: if ((c = *previous) == next) return TRUE;
2654: if ((options & PCRE_CASELESS) == 0) return FALSE;
2655: #ifdef SUPPORT_UTF8
2656: if (utf8)
2657: {
2658: unsigned int othercase;
2659: if (next < 128) othercase = cd->fcc[next]; else
2660: #ifdef SUPPORT_UCP
2661: othercase = UCD_OTHERCASE(next);
2662: #else
2663: othercase = NOTACHAR;
2664: #endif
2665: return (unsigned int)c == othercase;
2666: }
2667: else
2668: #endif /* SUPPORT_UTF8 */
2669: return (c == cd->fcc[next]); /* Non-UTF-8 mode */
2670:
2671: /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not* set.
2672: When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
2673:
2674: case OP_DIGIT:
2675: return next > 127 || (cd->ctypes[next] & ctype_digit) == 0;
2676:
2677: case OP_NOT_DIGIT:
2678: return next <= 127 && (cd->ctypes[next] & ctype_digit) != 0;
2679:
2680: case OP_WHITESPACE:
2681: return next > 127 || (cd->ctypes[next] & ctype_space) == 0;
2682:
2683: case OP_NOT_WHITESPACE:
2684: return next <= 127 && (cd->ctypes[next] & ctype_space) != 0;
2685:
2686: case OP_WORDCHAR:
2687: return next > 127 || (cd->ctypes[next] & ctype_word) == 0;
2688:
2689: case OP_NOT_WORDCHAR:
2690: return next <= 127 && (cd->ctypes[next] & ctype_word) != 0;
2691:
2692: case OP_HSPACE:
2693: case OP_NOT_HSPACE:
2694: switch(next)
2695: {
2696: case 0x09:
2697: case 0x20:
2698: case 0xa0:
2699: case 0x1680:
2700: case 0x180e:
2701: case 0x2000:
2702: case 0x2001:
2703: case 0x2002:
2704: case 0x2003:
2705: case 0x2004:
2706: case 0x2005:
2707: case 0x2006:
2708: case 0x2007:
2709: case 0x2008:
2710: case 0x2009:
2711: case 0x200A:
2712: case 0x202f:
2713: case 0x205f:
2714: case 0x3000:
2715: return op_code == OP_NOT_HSPACE;
2716: default:
2717: return op_code != OP_NOT_HSPACE;
2718: }
2719:
2720: case OP_ANYNL:
2721: case OP_VSPACE:
2722: case OP_NOT_VSPACE:
2723: switch(next)
2724: {
2725: case 0x0a:
2726: case 0x0b:
2727: case 0x0c:
2728: case 0x0d:
2729: case 0x85:
2730: case 0x2028:
2731: case 0x2029:
2732: return op_code == OP_NOT_VSPACE;
2733: default:
2734: return op_code != OP_NOT_VSPACE;
2735: }
2736:
2737: #ifdef SUPPORT_UCP
2738: case OP_PROP:
2739: return check_char_prop(next, previous[0], previous[1], FALSE);
2740:
2741: case OP_NOTPROP:
2742: return check_char_prop(next, previous[0], previous[1], TRUE);
2743: #endif
2744:
2745: default:
2746: return FALSE;
2747: }
2748:
2749:
2750: /* Handle the case when the next item is \d, \s, etc. Note that when PCRE_UCP
2751: is set, \d turns into ESC_du rather than ESC_d, etc., so ESC_d etc. are
2752: generated only when PCRE_UCP is *not* set, that is, when only ASCII
2753: characteristics are recognized. Similarly, the opcodes OP_DIGIT etc. are
2754: replaced by OP_PROP codes when PCRE_UCP is set. */
2755:
2756: switch(op_code)
2757: {
2758: case OP_CHAR:
2759: case OP_CHARNC:
2760: #ifdef SUPPORT_UTF8
2761: GETCHARTEST(c, previous);
2762: #else
2763: c = *previous;
2764: #endif
2765: switch(-next)
2766: {
2767: case ESC_d:
2768: return c > 127 || (cd->ctypes[c] & ctype_digit) == 0;
2769:
2770: case ESC_D:
2771: return c <= 127 && (cd->ctypes[c] & ctype_digit) != 0;
2772:
2773: case ESC_s:
2774: return c > 127 || (cd->ctypes[c] & ctype_space) == 0;
2775:
2776: case ESC_S:
2777: return c <= 127 && (cd->ctypes[c] & ctype_space) != 0;
2778:
2779: case ESC_w:
2780: return c > 127 || (cd->ctypes[c] & ctype_word) == 0;
2781:
2782: case ESC_W:
2783: return c <= 127 && (cd->ctypes[c] & ctype_word) != 0;
2784:
2785: case ESC_h:
2786: case ESC_H:
2787: switch(c)
2788: {
2789: case 0x09:
2790: case 0x20:
2791: case 0xa0:
2792: case 0x1680:
2793: case 0x180e:
2794: case 0x2000:
2795: case 0x2001:
2796: case 0x2002:
2797: case 0x2003:
2798: case 0x2004:
2799: case 0x2005:
2800: case 0x2006:
2801: case 0x2007:
2802: case 0x2008:
2803: case 0x2009:
2804: case 0x200A:
2805: case 0x202f:
2806: case 0x205f:
2807: case 0x3000:
2808: return -next != ESC_h;
2809: default:
2810: return -next == ESC_h;
2811: }
2812:
2813: case ESC_v:
2814: case ESC_V:
2815: switch(c)
2816: {
2817: case 0x0a:
2818: case 0x0b:
2819: case 0x0c:
2820: case 0x0d:
2821: case 0x85:
2822: case 0x2028:
2823: case 0x2029:
2824: return -next != ESC_v;
2825: default:
2826: return -next == ESC_v;
2827: }
2828:
2829: /* When PCRE_UCP is set, these values get generated for \d etc. Find
2830: their substitutions and process them. The result will always be either
2831: -ESC_p or -ESC_P. Then fall through to process those values. */
2832:
2833: #ifdef SUPPORT_UCP
2834: case ESC_du:
2835: case ESC_DU:
2836: case ESC_wu:
2837: case ESC_WU:
2838: case ESC_su:
2839: case ESC_SU:
2840: {
2841: int temperrorcode = 0;
2842: ptr = substitutes[-next - ESC_DU];
2843: next = check_escape(&ptr, &temperrorcode, 0, options, FALSE);
2844: if (temperrorcode != 0) return FALSE;
2845: ptr++; /* For compatibility */
2846: }
2847: /* Fall through */
2848:
2849: case ESC_p:
2850: case ESC_P:
2851: {
2852: int ptype, pdata, errorcodeptr;
2853: BOOL negated;
2854:
2855: ptr--; /* Make ptr point at the p or P */
2856: ptype = get_ucp(&ptr, &negated, &pdata, &errorcodeptr);
2857: if (ptype < 0) return FALSE;
2858: ptr++; /* Point past the final curly ket */
2859:
2860: /* If the property item is optional, we have to give up. (When generated
2861: from \d etc by PCRE_UCP, this test will have been applied much earlier,
2862: to the original \d etc. At this point, ptr will point to a zero byte. */
2863:
2864: if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
2865: strncmp((char *)ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
2866: return FALSE;
2867:
2868: /* Do the property check. */
2869:
2870: return check_char_prop(c, ptype, pdata, (next == -ESC_P) != negated);
2871: }
2872: #endif
2873:
2874: default:
2875: return FALSE;
2876: }
2877:
2878: /* In principle, support for Unicode properties should be integrated here as
2879: well. It means re-organizing the above code so as to get hold of the property
2880: values before switching on the op-code. However, I wonder how many patterns
2881: combine ASCII \d etc with Unicode properties? (Note that if PCRE_UCP is set,
2882: these op-codes are never generated.) */
2883:
2884: case OP_DIGIT:
2885: return next == -ESC_D || next == -ESC_s || next == -ESC_W ||
2886: next == -ESC_h || next == -ESC_v || next == -ESC_R;
2887:
2888: case OP_NOT_DIGIT:
2889: return next == -ESC_d;
2890:
2891: case OP_WHITESPACE:
2892: return next == -ESC_S || next == -ESC_d || next == -ESC_w || next == -ESC_R;
2893:
2894: case OP_NOT_WHITESPACE:
2895: return next == -ESC_s || next == -ESC_h || next == -ESC_v;
2896:
2897: case OP_HSPACE:
2898: return next == -ESC_S || next == -ESC_H || next == -ESC_d ||
2899: next == -ESC_w || next == -ESC_v || next == -ESC_R;
2900:
2901: case OP_NOT_HSPACE:
2902: return next == -ESC_h;
2903:
2904: /* Can't have \S in here because VT matches \S (Perl anomaly) */
2905: case OP_ANYNL:
2906: case OP_VSPACE:
2907: return next == -ESC_V || next == -ESC_d || next == -ESC_w;
2908:
2909: case OP_NOT_VSPACE:
2910: return next == -ESC_v || next == -ESC_R;
2911:
2912: case OP_WORDCHAR:
2913: return next == -ESC_W || next == -ESC_s || next == -ESC_h ||
2914: next == -ESC_v || next == -ESC_R;
2915:
2916: case OP_NOT_WORDCHAR:
2917: return next == -ESC_w || next == -ESC_d;
2918:
2919: default:
2920: return FALSE;
2921: }
2922:
2923: /* Control does not reach here */
2924: }
2925:
2926:
2927:
2928: /*************************************************
2929: * Compile one branch *
2930: *************************************************/
2931:
2932: /* Scan the pattern, compiling it into the a vector. If the options are
2933: changed during the branch, the pointer is used to change the external options
2934: bits. This function is used during the pre-compile phase when we are trying
2935: to find out the amount of memory needed, as well as during the real compile
2936: phase. The value of lengthptr distinguishes the two phases.
2937:
2938: Arguments:
2939: optionsptr pointer to the option bits
2940: codeptr points to the pointer to the current code point
2941: ptrptr points to the current pattern pointer
2942: errorcodeptr points to error code variable
2943: firstbyteptr set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
2944: reqbyteptr set to the last literal character required, else < 0
2945: bcptr points to current branch chain
2946: cd contains pointers to tables etc.
2947: lengthptr NULL during the real compile phase
2948: points to length accumulator during pre-compile phase
2949:
2950: Returns: TRUE on success
2951: FALSE, with *errorcodeptr set non-zero on error
2952: */
2953:
2954: static BOOL
2955: compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,
2956: int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
2957: compile_data *cd, int *lengthptr)
2958: {
2959: int repeat_type, op_type;
2960: int repeat_min = 0, repeat_max = 0; /* To please picky compilers */
2961: int bravalue = 0;
2962: int greedy_default, greedy_non_default;
2963: int firstbyte, reqbyte;
2964: int zeroreqbyte, zerofirstbyte;
2965: int req_caseopt, reqvary, tempreqvary;
2966: int options = *optionsptr;
2967: int after_manual_callout = 0;
2968: int length_prevgroup = 0;
2969: register int c;
2970: register uschar *code = *codeptr;
2971: uschar *last_code = code;
2972: uschar *orig_code = code;
2973: uschar *tempcode;
2974: BOOL inescq = FALSE;
2975: BOOL groupsetfirstbyte = FALSE;
2976: const uschar *ptr = *ptrptr;
2977: const uschar *tempptr;
2978: const uschar *nestptr = NULL;
2979: uschar *previous = NULL;
2980: uschar *previous_callout = NULL;
2981: uschar *save_hwm = NULL;
2982: uschar classbits[32];
2983:
2984: #ifdef SUPPORT_UTF8
2985: BOOL class_utf8;
2986: BOOL utf8 = (options & PCRE_UTF8) != 0;
2987: uschar *class_utf8data;
2988: uschar *class_utf8data_base;
2989: uschar utf8_char[6];
2990: #else
2991: BOOL utf8 = FALSE;
2992: uschar *utf8_char = NULL;
2993: #endif
2994:
2995: #ifdef PCRE_DEBUG
2996: if (lengthptr != NULL) DPRINTF((">> start branch\n"));
2997: #endif
2998:
2999: /* Set up the default and non-default settings for greediness */
3000:
3001: greedy_default = ((options & PCRE_UNGREEDY) != 0);
3002: greedy_non_default = greedy_default ^ 1;
3003:
3004: /* Initialize no first byte, no required byte. REQ_UNSET means "no char
3005: matching encountered yet". It gets changed to REQ_NONE if we hit something that
3006: matches a non-fixed char first char; reqbyte just remains unset if we never
3007: find one.
3008:
3009: When we hit a repeat whose minimum is zero, we may have to adjust these values
3010: to take the zero repeat into account. This is implemented by setting them to
3011: zerofirstbyte and zeroreqbyte when such a repeat is encountered. The individual
3012: item types that can be repeated set these backoff variables appropriately. */
3013:
3014: firstbyte = reqbyte = zerofirstbyte = zeroreqbyte = REQ_UNSET;
3015:
3016: /* The variable req_caseopt contains either the REQ_CASELESS value or zero,
3017: according to the current setting of the caseless flag. REQ_CASELESS is a bit
3018: value > 255. It is added into the firstbyte or reqbyte variables to record the
3019: case status of the value. This is used only for ASCII characters. */
3020:
3021: req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
3022:
3023: /* Switch on next character until the end of the branch */
3024:
3025: for (;; ptr++)
3026: {
3027: BOOL negate_class;
3028: BOOL should_flip_negation;
3029: BOOL possessive_quantifier;
3030: BOOL is_quantifier;
3031: BOOL is_recurse;
3032: BOOL reset_bracount;
3033: int class_charcount;
3034: int class_lastchar;
3035: int newoptions;
3036: int recno;
3037: int refsign;
3038: int skipbytes;
3039: int subreqbyte;
3040: int subfirstbyte;
3041: int terminator;
3042: int mclength;
3043: uschar mcbuffer[8];
3044:
3045: /* Get next byte in the pattern */
3046:
3047: c = *ptr;
3048:
3049: /* If we are at the end of a nested substitution, revert to the outer level
3050: string. Nesting only happens one level deep. */
3051:
3052: if (c == 0 && nestptr != NULL)
3053: {
3054: ptr = nestptr;
3055: nestptr = NULL;
3056: c = *ptr;
3057: }
3058:
3059: /* If we are in the pre-compile phase, accumulate the length used for the
3060: previous cycle of this loop. */
3061:
3062: if (lengthptr != NULL)
3063: {
3064: #ifdef PCRE_DEBUG
3065: if (code > cd->hwm) cd->hwm = code; /* High water info */
3066: #endif
3067: if (code > cd->start_workspace + WORK_SIZE_CHECK) /* Check for overrun */
3068: {
3069: *errorcodeptr = ERR52;
3070: goto FAILED;
3071: }
3072:
3073: /* There is at least one situation where code goes backwards: this is the
3074: case of a zero quantifier after a class (e.g. [ab]{0}). At compile time,
3075: the class is simply eliminated. However, it is created first, so we have to
3076: allow memory for it. Therefore, don't ever reduce the length at this point.
3077: */
3078:
3079: if (code < last_code) code = last_code;
3080:
3081: /* Paranoid check for integer overflow */
3082:
3083: if (OFLOW_MAX - *lengthptr < code - last_code)
3084: {
3085: *errorcodeptr = ERR20;
3086: goto FAILED;
3087: }
3088:
3089: *lengthptr += (int)(code - last_code);
3090: DPRINTF(("length=%d added %d c=%c\n", *lengthptr, code - last_code, c));
3091:
3092: /* If "previous" is set and it is not at the start of the work space, move
3093: it back to there, in order to avoid filling up the work space. Otherwise,
3094: if "previous" is NULL, reset the current code pointer to the start. */
3095:
3096: if (previous != NULL)
3097: {
3098: if (previous > orig_code)
3099: {
3100: memmove(orig_code, previous, code - previous);
3101: code -= previous - orig_code;
3102: previous = orig_code;
3103: }
3104: }
3105: else code = orig_code;
3106:
3107: /* Remember where this code item starts so we can pick up the length
3108: next time round. */
3109:
3110: last_code = code;
3111: }
3112:
3113: /* In the real compile phase, just check the workspace used by the forward
3114: reference list. */
3115:
3116: else if (cd->hwm > cd->start_workspace + WORK_SIZE_CHECK)
3117: {
3118: *errorcodeptr = ERR52;
3119: goto FAILED;
3120: }
3121:
3122: /* If in \Q...\E, check for the end; if not, we have a literal */
3123:
3124: if (inescq && c != 0)
3125: {
3126: if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)
3127: {
3128: inescq = FALSE;
3129: ptr++;
3130: continue;
3131: }
3132: else
3133: {
3134: if (previous_callout != NULL)
3135: {
3136: if (lengthptr == NULL) /* Don't attempt in pre-compile phase */
3137: complete_callout(previous_callout, ptr, cd);
3138: previous_callout = NULL;
3139: }
3140: if ((options & PCRE_AUTO_CALLOUT) != 0)
3141: {
3142: previous_callout = code;
3143: code = auto_callout(code, ptr, cd);
3144: }
3145: goto NORMAL_CHAR;
3146: }
3147: }
3148:
3149: /* Fill in length of a previous callout, except when the next thing is
3150: a quantifier. */
3151:
3152: is_quantifier =
3153: c == CHAR_ASTERISK || c == CHAR_PLUS || c == CHAR_QUESTION_MARK ||
3154: (c == CHAR_LEFT_CURLY_BRACKET && is_counted_repeat(ptr+1));
3155:
3156: if (!is_quantifier && previous_callout != NULL &&
3157: after_manual_callout-- <= 0)
3158: {
3159: if (lengthptr == NULL) /* Don't attempt in pre-compile phase */
3160: complete_callout(previous_callout, ptr, cd);
3161: previous_callout = NULL;
3162: }
3163:
3164: /* In extended mode, skip white space and comments */
3165:
3166: if ((options & PCRE_EXTENDED) != 0)
3167: {
3168: if ((cd->ctypes[c] & ctype_space) != 0) continue;
3169: if (c == CHAR_NUMBER_SIGN)
3170: {
3171: ptr++;
3172: while (*ptr != 0)
3173: {
3174: if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
3175: ptr++;
3176: #ifdef SUPPORT_UTF8
3177: if (utf8) while ((*ptr & 0xc0) == 0x80) ptr++;
3178: #endif
3179: }
3180: if (*ptr != 0) continue;
3181:
3182: /* Else fall through to handle end of string */
3183: c = 0;
3184: }
3185: }
3186:
3187: /* No auto callout for quantifiers. */
3188:
3189: if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier)
3190: {
3191: previous_callout = code;
3192: code = auto_callout(code, ptr, cd);
3193: }
3194:
3195: switch(c)
3196: {
3197: /* ===================================================================*/
3198: case 0: /* The branch terminates at string end */
3199: case CHAR_VERTICAL_LINE: /* or | or ) */
3200: case CHAR_RIGHT_PARENTHESIS:
3201: *firstbyteptr = firstbyte;
3202: *reqbyteptr = reqbyte;
3203: *codeptr = code;
3204: *ptrptr = ptr;
3205: if (lengthptr != NULL)
3206: {
3207: if (OFLOW_MAX - *lengthptr < code - last_code)
3208: {
3209: *errorcodeptr = ERR20;
3210: goto FAILED;
3211: }
3212: *lengthptr += (int)(code - last_code); /* To include callout length */
3213: DPRINTF((">> end branch\n"));
3214: }
3215: return TRUE;
3216:
3217:
3218: /* ===================================================================*/
3219: /* Handle single-character metacharacters. In multiline mode, ^ disables
3220: the setting of any following char as a first character. */
3221:
3222: case CHAR_CIRCUMFLEX_ACCENT:
3223: if ((options & PCRE_MULTILINE) != 0)
3224: {
3225: if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
3226: }
3227: previous = NULL;
3228: *code++ = OP_CIRC;
3229: break;
3230:
3231: case CHAR_DOLLAR_SIGN:
3232: previous = NULL;
3233: *code++ = OP_DOLL;
3234: break;
3235:
3236: /* There can never be a first char if '.' is first, whatever happens about
3237: repeats. The value of reqbyte doesn't change either. */
3238:
3239: case CHAR_DOT:
3240: if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
3241: zerofirstbyte = firstbyte;
3242: zeroreqbyte = reqbyte;
3243: previous = code;
3244: *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;
3245: break;
3246:
3247:
3248: /* ===================================================================*/
3249: /* Character classes. If the included characters are all < 256, we build a
3250: 32-byte bitmap of the permitted characters, except in the special case
3251: where there is only one such character. For negated classes, we build the
3252: map as usual, then invert it at the end. However, we use a different opcode
3253: so that data characters > 255 can be handled correctly.
3254:
3255: If the class contains characters outside the 0-255 range, a different
3256: opcode is compiled. It may optionally have a bit map for characters < 256,
3257: but those above are are explicitly listed afterwards. A flag byte tells
3258: whether the bitmap is present, and whether this is a negated class or not.
3259:
3260: In JavaScript compatibility mode, an isolated ']' causes an error. In
3261: default (Perl) mode, it is treated as a data character. */
3262:
3263: case CHAR_RIGHT_SQUARE_BRACKET:
3264: if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
3265: {
3266: *errorcodeptr = ERR64;
3267: goto FAILED;
3268: }
3269: goto NORMAL_CHAR;
3270:
3271: case CHAR_LEFT_SQUARE_BRACKET:
3272: previous = code;
3273:
3274: /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
3275: they are encountered at the top level, so we'll do that too. */
3276:
3277: if ((ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
3278: ptr[1] == CHAR_EQUALS_SIGN) &&
3279: check_posix_syntax(ptr, &tempptr))
3280: {
3281: *errorcodeptr = (ptr[1] == CHAR_COLON)? ERR13 : ERR31;
3282: goto FAILED;
3283: }
3284:
3285: /* If the first character is '^', set the negation flag and skip it. Also,
3286: if the first few characters (either before or after ^) are \Q\E or \E we
3287: skip them too. This makes for compatibility with Perl. */
3288:
3289: negate_class = FALSE;
3290: for (;;)
3291: {
3292: c = *(++ptr);
3293: if (c == CHAR_BACKSLASH)
3294: {
3295: if (ptr[1] == CHAR_E)
3296: ptr++;
3297: else if (strncmp((const char *)ptr+1,
3298: STR_Q STR_BACKSLASH STR_E, 3) == 0)
3299: ptr += 3;
3300: else
3301: break;
3302: }
3303: else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)
3304: negate_class = TRUE;
3305: else break;
3306: }
3307:
3308: /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,
3309: an initial ']' is taken as a data character -- the code below handles
3310: that. In JS mode, [] must always fail, so generate OP_FAIL, whereas
3311: [^] must match any character, so generate OP_ALLANY. */
3312:
3313: if (c == CHAR_RIGHT_SQUARE_BRACKET &&
3314: (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
3315: {
3316: *code++ = negate_class? OP_ALLANY : OP_FAIL;
3317: if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
3318: zerofirstbyte = firstbyte;
3319: break;
3320: }
3321:
3322: /* If a class contains a negative special such as \S, we need to flip the
3323: negation flag at the end, so that support for characters > 255 works
3324: correctly (they are all included in the class). */
3325:
3326: should_flip_negation = FALSE;
3327:
3328: /* Keep a count of chars with values < 256 so that we can optimize the case
3329: of just a single character (as long as it's < 256). However, For higher
3330: valued UTF-8 characters, we don't yet do any optimization. */
3331:
3332: class_charcount = 0;
3333: class_lastchar = -1;
3334:
3335: /* Initialize the 32-char bit map to all zeros. We build the map in a
3336: temporary bit of memory, in case the class contains only 1 character (less
3337: than 256), because in that case the compiled code doesn't use the bit map.
3338: */
3339:
3340: memset(classbits, 0, 32 * sizeof(uschar));
3341:
3342: #ifdef SUPPORT_UTF8
3343: class_utf8 = FALSE; /* No chars >= 256 */
3344: class_utf8data = code + LINK_SIZE + 2; /* For UTF-8 items */
3345: class_utf8data_base = class_utf8data; /* For resetting in pass 1 */
3346: #endif
3347:
3348: /* Process characters until ] is reached. By writing this as a "do" it
3349: means that an initial ] is taken as a data character. At the start of the
3350: loop, c contains the first byte of the character. */
3351:
3352: if (c != 0) do
3353: {
3354: const uschar *oldptr;
3355:
3356: #ifdef SUPPORT_UTF8
3357: if (utf8 && c > 127)
3358: { /* Braces are required because the */
3359: GETCHARLEN(c, ptr, ptr); /* macro generates multiple statements */
3360: }
3361:
3362: /* In the pre-compile phase, accumulate the length of any UTF-8 extra
3363: data and reset the pointer. This is so that very large classes that
3364: contain a zillion UTF-8 characters no longer overwrite the work space
3365: (which is on the stack). */
3366:
3367: if (lengthptr != NULL)
3368: {
3369: *lengthptr += class_utf8data - class_utf8data_base;
3370: class_utf8data = class_utf8data_base;
3371: }
3372:
3373: #endif
3374:
3375: /* Inside \Q...\E everything is literal except \E */
3376:
3377: if (inescq)
3378: {
3379: if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E) /* If we are at \E */
3380: {
3381: inescq = FALSE; /* Reset literal state */
3382: ptr++; /* Skip the 'E' */
3383: continue; /* Carry on with next */
3384: }
3385: goto CHECK_RANGE; /* Could be range if \E follows */
3386: }
3387:
3388: /* Handle POSIX class names. Perl allows a negation extension of the
3389: form [:^name:]. A square bracket that doesn't match the syntax is
3390: treated as a literal. We also recognize the POSIX constructions
3391: [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
3392: 5.6 and 5.8 do. */
3393:
3394: if (c == CHAR_LEFT_SQUARE_BRACKET &&
3395: (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
3396: ptr[1] == CHAR_EQUALS_SIGN) && check_posix_syntax(ptr, &tempptr))
3397: {
3398: BOOL local_negate = FALSE;
3399: int posix_class, taboffset, tabopt;
3400: register const uschar *cbits = cd->cbits;
3401: uschar pbits[32];
3402:
3403: if (ptr[1] != CHAR_COLON)
3404: {
3405: *errorcodeptr = ERR31;
3406: goto FAILED;
3407: }
3408:
3409: ptr += 2;
3410: if (*ptr == CHAR_CIRCUMFLEX_ACCENT)
3411: {
3412: local_negate = TRUE;
3413: should_flip_negation = TRUE; /* Note negative special */
3414: ptr++;
3415: }
3416:
3417: posix_class = check_posix_name(ptr, (int)(tempptr - ptr));
3418: if (posix_class < 0)
3419: {
3420: *errorcodeptr = ERR30;
3421: goto FAILED;
3422: }
3423:
3424: /* If matching is caseless, upper and lower are converted to
3425: alpha. This relies on the fact that the class table starts with
3426: alpha, lower, upper as the first 3 entries. */
3427:
3428: if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
3429: posix_class = 0;
3430:
3431: /* When PCRE_UCP is set, some of the POSIX classes are converted to
3432: different escape sequences that use Unicode properties. */
3433:
3434: #ifdef SUPPORT_UCP
3435: if ((options & PCRE_UCP) != 0)
3436: {
3437: int pc = posix_class + ((local_negate)? POSIX_SUBSIZE/2 : 0);
3438: if (posix_substitutes[pc] != NULL)
3439: {
3440: nestptr = tempptr + 1;
3441: ptr = posix_substitutes[pc] - 1;
3442: continue;
3443: }
3444: }
3445: #endif
3446: /* In the non-UCP case, we build the bit map for the POSIX class in a
3447: chunk of local store because we may be adding and subtracting from it,
3448: and we don't want to subtract bits that may be in the main map already.
3449: At the end we or the result into the bit map that is being built. */
3450:
3451: posix_class *= 3;
3452:
3453: /* Copy in the first table (always present) */
3454:
3455: memcpy(pbits, cbits + posix_class_maps[posix_class],
3456: 32 * sizeof(uschar));
3457:
3458: /* If there is a second table, add or remove it as required. */
3459:
3460: taboffset = posix_class_maps[posix_class + 1];
3461: tabopt = posix_class_maps[posix_class + 2];
3462:
3463: if (taboffset >= 0)
3464: {
3465: if (tabopt >= 0)
3466: for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];
3467: else
3468: for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];
3469: }
3470:
3471: /* Not see if we need to remove any special characters. An option
3472: value of 1 removes vertical space and 2 removes underscore. */
3473:
3474: if (tabopt < 0) tabopt = -tabopt;
3475: if (tabopt == 1) pbits[1] &= ~0x3c;
3476: else if (tabopt == 2) pbits[11] &= 0x7f;
3477:
3478: /* Add the POSIX table or its complement into the main table that is
3479: being built and we are done. */
3480:
3481: if (local_negate)
3482: for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];
3483: else
3484: for (c = 0; c < 32; c++) classbits[c] |= pbits[c];
3485:
3486: ptr = tempptr + 1;
3487: class_charcount = 10; /* Set > 1; assumes more than 1 per class */
3488: continue; /* End of POSIX syntax handling */
3489: }
3490:
3491: /* Backslash may introduce a single character, or it may introduce one
3492: of the specials, which just set a flag. The sequence \b is a special
3493: case. Inside a class (and only there) it is treated as backspace. We
3494: assume that other escapes have more than one character in them, so set
3495: class_charcount bigger than one. Unrecognized escapes fall through and
3496: are either treated as literal characters (by default), or are faulted if
3497: PCRE_EXTRA is set. */
3498:
3499: if (c == CHAR_BACKSLASH)
3500: {
3501: c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
3502: if (*errorcodeptr != 0) goto FAILED;
3503:
3504: if (-c == ESC_b) c = CHAR_BS; /* \b is backspace in a class */
3505: else if (-c == ESC_Q) /* Handle start of quoted string */
3506: {
3507: if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
3508: {
3509: ptr += 2; /* avoid empty string */
3510: }
3511: else inescq = TRUE;
3512: continue;
3513: }
3514: else if (-c == ESC_E) continue; /* Ignore orphan \E */
3515:
3516: if (c < 0)
3517: {
3518: register const uschar *cbits = cd->cbits;
3519: class_charcount += 2; /* Greater than 1 is what matters */
3520:
3521: switch (-c)
3522: {
3523: #ifdef SUPPORT_UCP
3524: case ESC_du: /* These are the values given for \d etc */
3525: case ESC_DU: /* when PCRE_UCP is set. We replace the */
3526: case ESC_wu: /* escape sequence with an appropriate \p */
3527: case ESC_WU: /* or \P to test Unicode properties instead */
3528: case ESC_su: /* of the default ASCII testing. */
3529: case ESC_SU:
3530: nestptr = ptr;
3531: ptr = substitutes[-c - ESC_DU] - 1; /* Just before substitute */
3532: class_charcount -= 2; /* Undo! */
3533: continue;
3534: #endif
3535: case ESC_d:
3536: for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];
3537: continue;
3538:
3539: case ESC_D:
3540: should_flip_negation = TRUE;
3541: for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
3542: continue;
3543:
3544: case ESC_w:
3545: for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];
3546: continue;
3547:
3548: case ESC_W:
3549: should_flip_negation = TRUE;
3550: for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
3551: continue;
3552:
3553: /* Perl 5.004 onwards omits VT from \s, but we must preserve it
3554: if it was previously set by something earlier in the character
3555: class. */
3556:
3557: case ESC_s:
3558: classbits[0] |= cbits[cbit_space];
3559: classbits[1] |= cbits[cbit_space+1] & ~0x08;
3560: for (c = 2; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
3561: continue;
3562:
3563: case ESC_S:
3564: should_flip_negation = TRUE;
3565: for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
3566: classbits[1] |= 0x08; /* Perl 5.004 onwards omits VT from \s */
3567: continue;
3568:
3569: case ESC_h:
3570: SETBIT(classbits, 0x09); /* VT */
3571: SETBIT(classbits, 0x20); /* SPACE */
3572: SETBIT(classbits, 0xa0); /* NSBP */
3573: #ifdef SUPPORT_UTF8
3574: if (utf8)
3575: {
3576: class_utf8 = TRUE;
3577: *class_utf8data++ = XCL_SINGLE;
3578: class_utf8data += _pcre_ord2utf8(0x1680, class_utf8data);
3579: *class_utf8data++ = XCL_SINGLE;
3580: class_utf8data += _pcre_ord2utf8(0x180e, class_utf8data);
3581: *class_utf8data++ = XCL_RANGE;
3582: class_utf8data += _pcre_ord2utf8(0x2000, class_utf8data);
3583: class_utf8data += _pcre_ord2utf8(0x200A, class_utf8data);
3584: *class_utf8data++ = XCL_SINGLE;
3585: class_utf8data += _pcre_ord2utf8(0x202f, class_utf8data);
3586: *class_utf8data++ = XCL_SINGLE;
3587: class_utf8data += _pcre_ord2utf8(0x205f, class_utf8data);
3588: *class_utf8data++ = XCL_SINGLE;
3589: class_utf8data += _pcre_ord2utf8(0x3000, class_utf8data);
3590: }
3591: #endif
3592: continue;
3593:
3594: case ESC_H:
3595: for (c = 0; c < 32; c++)
3596: {
3597: int x = 0xff;
3598: switch (c)
3599: {
3600: case 0x09/8: x ^= 1 << (0x09%8); break;
3601: case 0x20/8: x ^= 1 << (0x20%8); break;
3602: case 0xa0/8: x ^= 1 << (0xa0%8); break;
3603: default: break;
3604: }
3605: classbits[c] |= x;
3606: }
3607:
3608: #ifdef SUPPORT_UTF8
3609: if (utf8)
3610: {
3611: class_utf8 = TRUE;
3612: *class_utf8data++ = XCL_RANGE;
3613: class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
3614: class_utf8data += _pcre_ord2utf8(0x167f, class_utf8data);
3615: *class_utf8data++ = XCL_RANGE;
3616: class_utf8data += _pcre_ord2utf8(0x1681, class_utf8data);
3617: class_utf8data += _pcre_ord2utf8(0x180d, class_utf8data);
3618: *class_utf8data++ = XCL_RANGE;
3619: class_utf8data += _pcre_ord2utf8(0x180f, class_utf8data);
3620: class_utf8data += _pcre_ord2utf8(0x1fff, class_utf8data);
3621: *class_utf8data++ = XCL_RANGE;
3622: class_utf8data += _pcre_ord2utf8(0x200B, class_utf8data);
3623: class_utf8data += _pcre_ord2utf8(0x202e, class_utf8data);
3624: *class_utf8data++ = XCL_RANGE;
3625: class_utf8data += _pcre_ord2utf8(0x2030, class_utf8data);
3626: class_utf8data += _pcre_ord2utf8(0x205e, class_utf8data);
3627: *class_utf8data++ = XCL_RANGE;
3628: class_utf8data += _pcre_ord2utf8(0x2060, class_utf8data);
3629: class_utf8data += _pcre_ord2utf8(0x2fff, class_utf8data);
3630: *class_utf8data++ = XCL_RANGE;
3631: class_utf8data += _pcre_ord2utf8(0x3001, class_utf8data);
3632: class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
3633: }
3634: #endif
3635: continue;
3636:
3637: case ESC_v:
3638: SETBIT(classbits, 0x0a); /* LF */
3639: SETBIT(classbits, 0x0b); /* VT */
3640: SETBIT(classbits, 0x0c); /* FF */
3641: SETBIT(classbits, 0x0d); /* CR */
3642: SETBIT(classbits, 0x85); /* NEL */
3643: #ifdef SUPPORT_UTF8
3644: if (utf8)
3645: {
3646: class_utf8 = TRUE;
3647: *class_utf8data++ = XCL_RANGE;
3648: class_utf8data += _pcre_ord2utf8(0x2028, class_utf8data);
3649: class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
3650: }
3651: #endif
3652: continue;
3653:
3654: case ESC_V:
3655: for (c = 0; c < 32; c++)
3656: {
3657: int x = 0xff;
3658: switch (c)
3659: {
3660: case 0x0a/8: x ^= 1 << (0x0a%8);
3661: x ^= 1 << (0x0b%8);
3662: x ^= 1 << (0x0c%8);
3663: x ^= 1 << (0x0d%8);
3664: break;
3665: case 0x85/8: x ^= 1 << (0x85%8); break;
3666: default: break;
3667: }
3668: classbits[c] |= x;
3669: }
3670:
3671: #ifdef SUPPORT_UTF8
3672: if (utf8)
3673: {
3674: class_utf8 = TRUE;
3675: *class_utf8data++ = XCL_RANGE;
3676: class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
3677: class_utf8data += _pcre_ord2utf8(0x2027, class_utf8data);
3678: *class_utf8data++ = XCL_RANGE;
3679: class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
3680: class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
3681: }
3682: #endif
3683: continue;
3684:
3685: #ifdef SUPPORT_UCP
3686: case ESC_p:
3687: case ESC_P:
3688: {
3689: BOOL negated;
3690: int pdata;
3691: int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
3692: if (ptype < 0) goto FAILED;
3693: class_utf8 = TRUE;
3694: *class_utf8data++ = ((-c == ESC_p) != negated)?
3695: XCL_PROP : XCL_NOTPROP;
3696: *class_utf8data++ = ptype;
3697: *class_utf8data++ = pdata;
3698: class_charcount -= 2; /* Not a < 256 character */
3699: continue;
3700: }
3701: #endif
3702: /* Unrecognized escapes are faulted if PCRE is running in its
3703: strict mode. By default, for compatibility with Perl, they are
3704: treated as literals. */
3705:
3706: default:
3707: if ((options & PCRE_EXTRA) != 0)
3708: {
3709: *errorcodeptr = ERR7;
3710: goto FAILED;
3711: }
3712: class_charcount -= 2; /* Undo the default count from above */
3713: c = *ptr; /* Get the final character and fall through */
3714: break;
3715: }
3716: }
3717:
3718: /* Fall through if we have a single character (c >= 0). This may be
3719: greater than 256 in UTF-8 mode. */
3720:
3721: } /* End of backslash handling */
3722:
3723: /* A single character may be followed by '-' to form a range. However,
3724: Perl does not permit ']' to be the end of the range. A '-' character
3725: at the end is treated as a literal. Perl ignores orphaned \E sequences
3726: entirely. The code for handling \Q and \E is messy. */
3727:
3728: CHECK_RANGE:
3729: while (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
3730: {
3731: inescq = FALSE;
3732: ptr += 2;
3733: }
3734:
3735: oldptr = ptr;
3736:
3737: /* Remember \r or \n */
3738:
3739: if (c == CHAR_CR || c == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
3740:
3741: /* Check for range */
3742:
3743: if (!inescq && ptr[1] == CHAR_MINUS)
3744: {
3745: int d;
3746: ptr += 2;
3747: while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E) ptr += 2;
3748:
3749: /* If we hit \Q (not followed by \E) at this point, go into escaped
3750: mode. */
3751:
3752: while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_Q)
3753: {
3754: ptr += 2;
3755: if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E)
3756: { ptr += 2; continue; }
3757: inescq = TRUE;
3758: break;
3759: }
3760:
3761: if (*ptr == 0 || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))
3762: {
3763: ptr = oldptr;
3764: goto LONE_SINGLE_CHARACTER;
3765: }
3766:
3767: #ifdef SUPPORT_UTF8
3768: if (utf8)
3769: { /* Braces are required because the */
3770: GETCHARLEN(d, ptr, ptr); /* macro generates multiple statements */
3771: }
3772: else
3773: #endif
3774: d = *ptr; /* Not UTF-8 mode */
3775:
3776: /* The second part of a range can be a single-character escape, but
3777: not any of the other escapes. Perl 5.6 treats a hyphen as a literal
3778: in such circumstances. */
3779:
3780: if (!inescq && d == CHAR_BACKSLASH)
3781: {
3782: d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
3783: if (*errorcodeptr != 0) goto FAILED;
3784:
3785: /* \b is backspace; any other special means the '-' was literal */
3786:
3787: if (d < 0)
3788: {
3789: if (d == -ESC_b) d = CHAR_BS; else
3790: {
3791: ptr = oldptr;
3792: goto LONE_SINGLE_CHARACTER; /* A few lines below */
3793: }
3794: }
3795: }
3796:
3797: /* Check that the two values are in the correct order. Optimize
3798: one-character ranges */
3799:
3800: if (d < c)
3801: {
3802: *errorcodeptr = ERR8;
3803: goto FAILED;
3804: }
3805:
3806: if (d == c) goto LONE_SINGLE_CHARACTER; /* A few lines below */
3807:
3808: /* Remember \r or \n */
3809:
3810: if (d == CHAR_CR || d == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
3811:
3812: /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
3813: matching, we have to use an XCLASS with extra data items. Caseless
3814: matching for characters > 127 is available only if UCP support is
3815: available. */
3816:
3817: #ifdef SUPPORT_UTF8
3818: if (utf8 && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
3819: {
3820: class_utf8 = TRUE;
3821:
3822: /* With UCP support, we can find the other case equivalents of
3823: the relevant characters. There may be several ranges. Optimize how
3824: they fit with the basic range. */
3825:
3826: #ifdef SUPPORT_UCP
3827: if ((options & PCRE_CASELESS) != 0)
3828: {
3829: unsigned int occ, ocd;
3830: unsigned int cc = c;
3831: unsigned int origd = d;
3832: while (get_othercase_range(&cc, origd, &occ, &ocd))
3833: {
3834: if (occ >= (unsigned int)c &&
3835: ocd <= (unsigned int)d)
3836: continue; /* Skip embedded ranges */
3837:
3838: if (occ < (unsigned int)c &&
3839: ocd >= (unsigned int)c - 1) /* Extend the basic range */
3840: { /* if there is overlap, */
3841: c = occ; /* noting that if occ < c */
3842: continue; /* we can't have ocd > d */
3843: } /* because a subrange is */
3844: if (ocd > (unsigned int)d &&
3845: occ <= (unsigned int)d + 1) /* always shorter than */
3846: { /* the basic range. */
3847: d = ocd;
3848: continue;
3849: }
3850:
3851: if (occ == ocd)
3852: {
3853: *class_utf8data++ = XCL_SINGLE;
3854: }
3855: else
3856: {
3857: *class_utf8data++ = XCL_RANGE;
3858: class_utf8data += _pcre_ord2utf8(occ, class_utf8data);
3859: }
3860: class_utf8data += _pcre_ord2utf8(ocd, class_utf8data);
3861: }
3862: }
3863: #endif /* SUPPORT_UCP */
3864:
3865: /* Now record the original range, possibly modified for UCP caseless
3866: overlapping ranges. */
3867:
3868: *class_utf8data++ = XCL_RANGE;
3869: class_utf8data += _pcre_ord2utf8(c, class_utf8data);
3870: class_utf8data += _pcre_ord2utf8(d, class_utf8data);
3871:
3872: /* With UCP support, we are done. Without UCP support, there is no
3873: caseless matching for UTF-8 characters > 127; we can use the bit map
3874: for the smaller ones. */
3875:
3876: #ifdef SUPPORT_UCP
3877: continue; /* With next character in the class */
3878: #else
3879: if ((options & PCRE_CASELESS) == 0 || c > 127) continue;
3880:
3881: /* Adjust upper limit and fall through to set up the map */
3882:
3883: d = 127;
3884:
3885: #endif /* SUPPORT_UCP */
3886: }
3887: #endif /* SUPPORT_UTF8 */
3888:
3889: /* We use the bit map for all cases when not in UTF-8 mode; else
3890: ranges that lie entirely within 0-127 when there is UCP support; else
3891: for partial ranges without UCP support. */
3892:
3893: class_charcount += d - c + 1;
3894: class_lastchar = d;
3895:
3896: /* We can save a bit of time by skipping this in the pre-compile. */
3897:
3898: if (lengthptr == NULL) for (; c <= d; c++)
3899: {
3900: classbits[c/8] |= (1 << (c&7));
3901: if ((options & PCRE_CASELESS) != 0)
3902: {
3903: int uc = cd->fcc[c]; /* flip case */
3904: classbits[uc/8] |= (1 << (uc&7));
3905: }
3906: }
3907:
3908: continue; /* Go get the next char in the class */
3909: }
3910:
3911: /* Handle a lone single character - we can get here for a normal
3912: non-escape char, or after \ that introduces a single character or for an
3913: apparent range that isn't. */
3914:
3915: LONE_SINGLE_CHARACTER:
3916:
3917: /* Handle a character that cannot go in the bit map */
3918:
3919: #ifdef SUPPORT_UTF8
3920: if (utf8 && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
3921: {
3922: class_utf8 = TRUE;
3923: *class_utf8data++ = XCL_SINGLE;
3924: class_utf8data += _pcre_ord2utf8(c, class_utf8data);
3925:
3926: #ifdef SUPPORT_UCP
3927: if ((options & PCRE_CASELESS) != 0)
3928: {
3929: unsigned int othercase;
3930: if ((othercase = UCD_OTHERCASE(c)) != c)
3931: {
3932: *class_utf8data++ = XCL_SINGLE;
3933: class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
3934: }
3935: }
3936: #endif /* SUPPORT_UCP */
3937:
3938: }
3939: else
3940: #endif /* SUPPORT_UTF8 */
3941:
3942: /* Handle a single-byte character */
3943: {
3944: classbits[c/8] |= (1 << (c&7));
3945: if ((options & PCRE_CASELESS) != 0)
3946: {
3947: c = cd->fcc[c]; /* flip case */
3948: classbits[c/8] |= (1 << (c&7));
3949: }
3950: class_charcount++;
3951: class_lastchar = c;
3952: }
3953: }
3954:
3955: /* Loop until ']' reached. This "while" is the end of the "do" far above.
3956: If we are at the end of an internal nested string, revert to the outer
3957: string. */
3958:
3959: while (((c = *(++ptr)) != 0 ||
3960: (nestptr != NULL &&
3961: (ptr = nestptr, nestptr = NULL, c = *(++ptr)) != 0)) &&
3962: (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));
3963:
3964: /* Check for missing terminating ']' */
3965:
3966: if (c == 0)
3967: {
3968: *errorcodeptr = ERR6;
3969: goto FAILED;
3970: }
3971:
3972: /* If class_charcount is 1, we saw precisely one character whose value is
3973: less than 256. As long as there were no characters >= 128 and there was no
3974: use of \p or \P, in other words, no use of any XCLASS features, we can
3975: optimize.
3976:
3977: In UTF-8 mode, we can optimize the negative case only if there were no
3978: characters >= 128 because OP_NOT and the related opcodes like OP_NOTSTAR
3979: operate on single-bytes only. This is an historical hangover. Maybe one day
3980: we can tidy these opcodes to handle multi-byte characters.
3981:
3982: The optimization throws away the bit map. We turn the item into a
3983: 1-character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
3984: that OP_NOT does not support multibyte characters. In the positive case, it
3985: can cause firstbyte to be set. Otherwise, there can be no first char if
3986: this item is first, whatever repeat count may follow. In the case of
3987: reqbyte, save the previous value for reinstating. */
3988:
3989: #ifdef SUPPORT_UTF8
3990: if (class_charcount == 1 && !class_utf8 &&
3991: (!utf8 || !negate_class || class_lastchar < 128))
3992: #else
3993: if (class_charcount == 1)
3994: #endif
3995: {
3996: zeroreqbyte = reqbyte;
3997:
3998: /* The OP_NOT opcode works on one-byte characters only. */
3999:
4000: if (negate_class)
4001: {
4002: if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
4003: zerofirstbyte = firstbyte;
4004: *code++ = OP_NOT;
4005: *code++ = class_lastchar;
4006: break;
4007: }
4008:
4009: /* For a single, positive character, get the value into mcbuffer, and
4010: then we can handle this with the normal one-character code. */
4011:
4012: #ifdef SUPPORT_UTF8
4013: if (utf8 && class_lastchar > 127)
4014: mclength = _pcre_ord2utf8(class_lastchar, mcbuffer);
4015: else
4016: #endif
4017: {
4018: mcbuffer[0] = class_lastchar;
4019: mclength = 1;
4020: }
4021: goto ONE_CHAR;
4022: } /* End of 1-char optimization */
4023:
4024: /* The general case - not the one-char optimization. If this is the first
4025: thing in the branch, there can be no first char setting, whatever the
4026: repeat count. Any reqbyte setting must remain unchanged after any kind of
4027: repeat. */
4028:
4029: if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
4030: zerofirstbyte = firstbyte;
4031: zeroreqbyte = reqbyte;
4032:
4033: /* If there are characters with values > 255, we have to compile an
4034: extended class, with its own opcode, unless there was a negated special
4035: such as \S in the class, and PCRE_UCP is not set, because in that case all
4036: characters > 255 are in the class, so any that were explicitly given as
4037: well can be ignored. If (when there are explicit characters > 255 that must
4038: be listed) there are no characters < 256, we can omit the bitmap in the
4039: actual compiled code. */
4040:
4041: #ifdef SUPPORT_UTF8
4042: if (class_utf8 && (!should_flip_negation || (options & PCRE_UCP) != 0))
4043: {
4044: *class_utf8data++ = XCL_END; /* Marks the end of extra data */
4045: *code++ = OP_XCLASS;
4046: code += LINK_SIZE;
4047: *code = negate_class? XCL_NOT : 0;
4048:
4049: /* If the map is required, move up the extra data to make room for it;
4050: otherwise just move the code pointer to the end of the extra data. */
4051:
4052: if (class_charcount > 0)
4053: {
4054: *code++ |= XCL_MAP;
4055: memmove(code + 32, code, class_utf8data - code);
4056: memcpy(code, classbits, 32);
4057: code = class_utf8data + 32;
4058: }
4059: else code = class_utf8data;
4060:
4061: /* Now fill in the complete length of the item */
4062:
4063: PUT(previous, 1, code - previous);
4064: break; /* End of class handling */
4065: }
4066: #endif
4067:
4068: /* If there are no characters > 255, or they are all to be included or
4069: excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the
4070: whole class was negated and whether there were negative specials such as \S
4071: (non-UCP) in the class. Then copy the 32-byte map into the code vector,
4072: negating it if necessary. */
4073:
4074: *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
4075: if (negate_class)
4076: {
4077: if (lengthptr == NULL) /* Save time in the pre-compile phase */
4078: for (c = 0; c < 32; c++) code[c] = ~classbits[c];
4079: }
4080: else
4081: {
4082: memcpy(code, classbits, 32);
4083: }
4084: code += 32;
4085: break;
4086:
4087:
4088: /* ===================================================================*/
4089: /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
4090: has been tested above. */
4091:
4092: case CHAR_LEFT_CURLY_BRACKET:
4093: if (!is_quantifier) goto NORMAL_CHAR;
4094: ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);
4095: if (*errorcodeptr != 0) goto FAILED;
4096: goto REPEAT;
4097:
4098: case CHAR_ASTERISK:
4099: repeat_min = 0;
4100: repeat_max = -1;
4101: goto REPEAT;
4102:
4103: case CHAR_PLUS:
4104: repeat_min = 1;
4105: repeat_max = -1;
4106: goto REPEAT;
4107:
4108: case CHAR_QUESTION_MARK:
4109: repeat_min = 0;
4110: repeat_max = 1;
4111:
4112: REPEAT:
4113: if (previous == NULL)
4114: {
4115: *errorcodeptr = ERR9;
4116: goto FAILED;
4117: }
4118:
4119: if (repeat_min == 0)
4120: {
4121: firstbyte = zerofirstbyte; /* Adjust for zero repeat */
4122: reqbyte = zeroreqbyte; /* Ditto */
4123: }
4124:
4125: /* Remember whether this is a variable length repeat */
4126:
4127: reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;
4128:
4129: op_type = 0; /* Default single-char op codes */
4130: possessive_quantifier = FALSE; /* Default not possessive quantifier */
4131:
4132: /* Save start of previous item, in case we have to move it up to make space
4133: for an inserted OP_ONCE for the additional '+' extension. */
4134:
4135: tempcode = previous;
4136:
4137: /* If the next character is '+', we have a possessive quantifier. This
4138: implies greediness, whatever the setting of the PCRE_UNGREEDY option.
4139: If the next character is '?' this is a minimizing repeat, by default,
4140: but if PCRE_UNGREEDY is set, it works the other way round. We change the
4141: repeat type to the non-default. */
4142:
4143: if (ptr[1] == CHAR_PLUS)
4144: {
4145: repeat_type = 0; /* Force greedy */
4146: possessive_quantifier = TRUE;
4147: ptr++;
4148: }
4149: else if (ptr[1] == CHAR_QUESTION_MARK)
4150: {
4151: repeat_type = greedy_non_default;
4152: ptr++;
4153: }
4154: else repeat_type = greedy_default;
4155:
4156: /* If previous was a character match, abolish the item and generate a
4157: repeat item instead. If a char item has a minumum of more than one, ensure
4158: that it is set in reqbyte - it might not be if a sequence such as x{3} is
4159: the first thing in a branch because the x will have gone into firstbyte
4160: instead. */
4161:
4162: if (*previous == OP_CHAR || *previous == OP_CHARNC)
4163: {
4164: /* Deal with UTF-8 characters that take up more than one byte. It's
4165: easier to write this out separately than try to macrify it. Use c to
4166: hold the length of the character in bytes, plus 0x80 to flag that it's a
4167: length rather than a small character. */
4168:
4169: #ifdef SUPPORT_UTF8
4170: if (utf8 && (code[-1] & 0x80) != 0)
4171: {
4172: uschar *lastchar = code - 1;
4173: while((*lastchar & 0xc0) == 0x80) lastchar--;
4174: c = code - lastchar; /* Length of UTF-8 character */
4175: memcpy(utf8_char, lastchar, c); /* Save the char */
4176: c |= 0x80; /* Flag c as a length */
4177: }
4178: else
4179: #endif
4180:
4181: /* Handle the case of a single byte - either with no UTF8 support, or
4182: with UTF-8 disabled, or for a UTF-8 character < 128. */
4183:
4184: {
4185: c = code[-1];
4186: if (repeat_min > 1) reqbyte = c | req_caseopt | cd->req_varyopt;
4187: }
4188:
4189: /* If the repetition is unlimited, it pays to see if the next thing on
4190: the line is something that cannot possibly match this character. If so,
4191: automatically possessifying this item gains some performance in the case
4192: where the match fails. */
4193:
4194: if (!possessive_quantifier &&
4195: repeat_max < 0 &&
4196: check_auto_possessive(previous, utf8, ptr + 1, options, cd))
4197: {
4198: repeat_type = 0; /* Force greedy */
4199: possessive_quantifier = TRUE;
4200: }
4201:
4202: goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */
4203: }
4204:
4205: /* If previous was a single negated character ([^a] or similar), we use
4206: one of the special opcodes, replacing it. The code is shared with single-
4207: character repeats by setting opt_type to add a suitable offset into
4208: repeat_type. We can also test for auto-possessification. OP_NOT is
4209: currently used only for single-byte chars. */
4210:
4211: else if (*previous == OP_NOT)
4212: {
4213: op_type = OP_NOTSTAR - OP_STAR; /* Use "not" opcodes */
4214: c = previous[1];
4215: if (!possessive_quantifier &&
4216: repeat_max < 0 &&
4217: check_auto_possessive(previous, utf8, ptr + 1, options, cd))
4218: {
4219: repeat_type = 0; /* Force greedy */
4220: possessive_quantifier = TRUE;
4221: }
4222: goto OUTPUT_SINGLE_REPEAT;
4223: }
4224:
4225: /* If previous was a character type match (\d or similar), abolish it and
4226: create a suitable repeat item. The code is shared with single-character
4227: repeats by setting op_type to add a suitable offset into repeat_type. Note
4228: the the Unicode property types will be present only when SUPPORT_UCP is
4229: defined, but we don't wrap the little bits of code here because it just
4230: makes it horribly messy. */
4231:
4232: else if (*previous < OP_EODN)
4233: {
4234: uschar *oldcode;
4235: int prop_type, prop_value;
4236: op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */
4237: c = *previous;
4238:
4239: if (!possessive_quantifier &&
4240: repeat_max < 0 &&
4241: check_auto_possessive(previous, utf8, ptr + 1, options, cd))
4242: {
4243: repeat_type = 0; /* Force greedy */
4244: possessive_quantifier = TRUE;
4245: }
4246:
4247: OUTPUT_SINGLE_REPEAT:
4248: if (*previous == OP_PROP || *previous == OP_NOTPROP)
4249: {
4250: prop_type = previous[1];
4251: prop_value = previous[2];
4252: }
4253: else prop_type = prop_value = -1;
4254:
4255: oldcode = code;
4256: code = previous; /* Usually overwrite previous item */
4257:
4258: /* If the maximum is zero then the minimum must also be zero; Perl allows
4259: this case, so we do too - by simply omitting the item altogether. */
4260:
4261: if (repeat_max == 0) goto END_REPEAT;
4262:
4263: /*--------------------------------------------------------------------*/
4264: /* This code is obsolete from release 8.00; the restriction was finally
4265: removed: */
4266:
4267: /* All real repeats make it impossible to handle partial matching (maybe
4268: one day we will be able to remove this restriction). */
4269:
4270: /* if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL; */
4271: /*--------------------------------------------------------------------*/
4272:
4273: /* Combine the op_type with the repeat_type */
4274:
4275: repeat_type += op_type;
4276:
4277: /* A minimum of zero is handled either as the special case * or ?, or as
4278: an UPTO, with the maximum given. */
4279:
4280: if (repeat_min == 0)
4281: {
4282: if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
4283: else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
4284: else
4285: {
4286: *code++ = OP_UPTO + repeat_type;
4287: PUT2INC(code, 0, repeat_max);
4288: }
4289: }
4290:
4291: /* A repeat minimum of 1 is optimized into some special cases. If the
4292: maximum is unlimited, we use OP_PLUS. Otherwise, the original item is
4293: left in place and, if the maximum is greater than 1, we use OP_UPTO with
4294: one less than the maximum. */
4295:
4296: else if (repeat_min == 1)
4297: {
4298: if (repeat_max == -1)
4299: *code++ = OP_PLUS + repeat_type;
4300: else
4301: {
4302: code = oldcode; /* leave previous item in place */
4303: if (repeat_max == 1) goto END_REPEAT;
4304: *code++ = OP_UPTO + repeat_type;
4305: PUT2INC(code, 0, repeat_max - 1);
4306: }
4307: }
4308:
4309: /* The case {n,n} is just an EXACT, while the general case {n,m} is
4310: handled as an EXACT followed by an UPTO. */
4311:
4312: else
4313: {
4314: *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */
4315: PUT2INC(code, 0, repeat_min);
4316:
4317: /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
4318: we have to insert the character for the previous code. For a repeated
4319: Unicode property match, there are two extra bytes that define the
4320: required property. In UTF-8 mode, long characters have their length in
4321: c, with the 0x80 bit as a flag. */
4322:
4323: if (repeat_max < 0)
4324: {
4325: #ifdef SUPPORT_UTF8
4326: if (utf8 && c >= 128)
4327: {
4328: memcpy(code, utf8_char, c & 7);
4329: code += c & 7;
4330: }
4331: else
4332: #endif
4333: {
4334: *code++ = c;
4335: if (prop_type >= 0)
4336: {
4337: *code++ = prop_type;
4338: *code++ = prop_value;
4339: }
4340: }
4341: *code++ = OP_STAR + repeat_type;
4342: }
4343:
4344: /* Else insert an UPTO if the max is greater than the min, again
4345: preceded by the character, for the previously inserted code. If the
4346: UPTO is just for 1 instance, we can use QUERY instead. */
4347:
4348: else if (repeat_max != repeat_min)
4349: {
4350: #ifdef SUPPORT_UTF8
4351: if (utf8 && c >= 128)
4352: {
4353: memcpy(code, utf8_char, c & 7);
4354: code += c & 7;
4355: }
4356: else
4357: #endif
4358: *code++ = c;
4359: if (prop_type >= 0)
4360: {
4361: *code++ = prop_type;
4362: *code++ = prop_value;
4363: }
4364: repeat_max -= repeat_min;
4365:
4366: if (repeat_max == 1)
4367: {
4368: *code++ = OP_QUERY + repeat_type;
4369: }
4370: else
4371: {
4372: *code++ = OP_UPTO + repeat_type;
4373: PUT2INC(code, 0, repeat_max);
4374: }
4375: }
4376: }
4377:
4378: /* The character or character type itself comes last in all cases. */
4379:
4380: #ifdef SUPPORT_UTF8
4381: if (utf8 && c >= 128)
4382: {
4383: memcpy(code, utf8_char, c & 7);
4384: code += c & 7;
4385: }
4386: else
4387: #endif
4388: *code++ = c;
4389:
4390: /* For a repeated Unicode property match, there are two extra bytes that
4391: define the required property. */
4392:
4393: #ifdef SUPPORT_UCP
4394: if (prop_type >= 0)
4395: {
4396: *code++ = prop_type;
4397: *code++ = prop_value;
4398: }
4399: #endif
4400: }
4401:
4402: /* If previous was a character class or a back reference, we put the repeat
4403: stuff after it, but just skip the item if the repeat was {0,0}. */
4404:
4405: else if (*previous == OP_CLASS ||
4406: *previous == OP_NCLASS ||
4407: #ifdef SUPPORT_UTF8
4408: *previous == OP_XCLASS ||
4409: #endif
4410: *previous == OP_REF)
4411: {
4412: if (repeat_max == 0)
4413: {
4414: code = previous;
4415: goto END_REPEAT;
4416: }
4417:
4418: /*--------------------------------------------------------------------*/
4419: /* This code is obsolete from release 8.00; the restriction was finally
4420: removed: */
4421:
4422: /* All real repeats make it impossible to handle partial matching (maybe
4423: one day we will be able to remove this restriction). */
4424:
4425: /* if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL; */
4426: /*--------------------------------------------------------------------*/
4427:
4428: if (repeat_min == 0 && repeat_max == -1)
4429: *code++ = OP_CRSTAR + repeat_type;
4430: else if (repeat_min == 1 && repeat_max == -1)
4431: *code++ = OP_CRPLUS + repeat_type;
4432: else if (repeat_min == 0 && repeat_max == 1)
4433: *code++ = OP_CRQUERY + repeat_type;
4434: else
4435: {
4436: *code++ = OP_CRRANGE + repeat_type;
4437: PUT2INC(code, 0, repeat_min);
4438: if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */
4439: PUT2INC(code, 0, repeat_max);
4440: }
4441: }
4442:
4443: /* If previous was a bracket group, we may have to replicate it in certain
4444: cases. */
4445:
4446: else if (*previous == OP_BRA || *previous == OP_CBRA ||
4447: *previous == OP_ONCE || *previous == OP_COND)
4448: {
4449: register int i;
4450: int ketoffset = 0;
4451: int len = (int)(code - previous);
4452: uschar *bralink = NULL;
4453:
4454: /* Repeating a DEFINE group is pointless */
4455:
4456: if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)
4457: {
4458: *errorcodeptr = ERR55;
4459: goto FAILED;
4460: }
4461:
4462: /* If the maximum repeat count is unlimited, find the end of the bracket
4463: by scanning through from the start, and compute the offset back to it
4464: from the current code pointer. There may be an OP_OPT setting following
4465: the final KET, so we can't find the end just by going back from the code
4466: pointer. */
4467:
4468: if (repeat_max == -1)
4469: {
4470: register uschar *ket = previous;
4471: do ket += GET(ket, 1); while (*ket != OP_KET);
4472: ketoffset = (int)(code - ket);
4473: }
4474:
4475: /* The case of a zero minimum is special because of the need to stick
4476: OP_BRAZERO in front of it, and because the group appears once in the
4477: data, whereas in other cases it appears the minimum number of times. For
4478: this reason, it is simplest to treat this case separately, as otherwise
4479: the code gets far too messy. There are several special subcases when the
4480: minimum is zero. */
4481:
4482: if (repeat_min == 0)
4483: {
4484: /* If the maximum is also zero, we used to just omit the group from the
4485: output altogether, like this:
4486:
4487: ** if (repeat_max == 0)
4488: ** {
4489: ** code = previous;
4490: ** goto END_REPEAT;
4491: ** }
4492:
4493: However, that fails when a group is referenced as a subroutine from
4494: elsewhere in the pattern, so now we stick in OP_SKIPZERO in front of it
4495: so that it is skipped on execution. As we don't have a list of which
4496: groups are referenced, we cannot do this selectively.
4497:
4498: If the maximum is 1 or unlimited, we just have to stick in the BRAZERO
4499: and do no more at this point. However, we do need to adjust any
4500: OP_RECURSE calls inside the group that refer to the group itself or any
4501: internal or forward referenced group, because the offset is from the
4502: start of the whole regex. Temporarily terminate the pattern while doing
4503: this. */
4504:
4505: if (repeat_max <= 1) /* Covers 0, 1, and unlimited */
4506: {
4507: *code = OP_END;
4508: adjust_recurse(previous, 1, utf8, cd, save_hwm);
4509: memmove(previous+1, previous, len);
4510: code++;
4511: if (repeat_max == 0)
4512: {
4513: *previous++ = OP_SKIPZERO;
4514: goto END_REPEAT;
4515: }
4516: *previous++ = OP_BRAZERO + repeat_type;
4517: }
4518:
4519: /* If the maximum is greater than 1 and limited, we have to replicate
4520: in a nested fashion, sticking OP_BRAZERO before each set of brackets.
4521: The first one has to be handled carefully because it's the original
4522: copy, which has to be moved up. The remainder can be handled by code
4523: that is common with the non-zero minimum case below. We have to
4524: adjust the value or repeat_max, since one less copy is required. Once
4525: again, we may have to adjust any OP_RECURSE calls inside the group. */
4526:
4527: else
4528: {
4529: int offset;
4530: *code = OP_END;
4531: adjust_recurse(previous, 2 + LINK_SIZE, utf8, cd, save_hwm);
4532: memmove(previous + 2 + LINK_SIZE, previous, len);
4533: code += 2 + LINK_SIZE;
4534: *previous++ = OP_BRAZERO + repeat_type;
4535: *previous++ = OP_BRA;
4536:
4537: /* We chain together the bracket offset fields that have to be
4538: filled in later when the ends of the brackets are reached. */
4539:
4540: offset = (bralink == NULL)? 0 : (int)(previous - bralink);
4541: bralink = previous;
4542: PUTINC(previous, 0, offset);
4543: }
4544:
4545: repeat_max--;
4546: }
4547:
4548: /* If the minimum is greater than zero, replicate the group as many
4549: times as necessary, and adjust the maximum to the number of subsequent
4550: copies that we need. If we set a first char from the group, and didn't
4551: set a required char, copy the latter from the former. If there are any
4552: forward reference subroutine calls in the group, there will be entries on
4553: the workspace list; replicate these with an appropriate increment. */
4554:
4555: else
4556: {
4557: if (repeat_min > 1)
4558: {
4559: /* In the pre-compile phase, we don't actually do the replication. We
4560: just adjust the length as if we had. Do some paranoid checks for
4561: potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit
4562: integer type when available, otherwise double. */
4563:
4564: if (lengthptr != NULL)
4565: {
4566: int delta = (repeat_min - 1)*length_prevgroup;
4567: if ((INT64_OR_DOUBLE)(repeat_min - 1)*
4568: (INT64_OR_DOUBLE)length_prevgroup >
4569: (INT64_OR_DOUBLE)INT_MAX ||
4570: OFLOW_MAX - *lengthptr < delta)
4571: {
4572: *errorcodeptr = ERR20;
4573: goto FAILED;
4574: }
4575: *lengthptr += delta;
4576: }
4577:
4578: /* This is compiling for real */
4579:
4580: else
4581: {
4582: if (groupsetfirstbyte && reqbyte < 0) reqbyte = firstbyte;
4583: for (i = 1; i < repeat_min; i++)
4584: {
4585: uschar *hc;
4586: uschar *this_hwm = cd->hwm;
4587: memcpy(code, previous, len);
4588: for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
4589: {
4590: PUT(cd->hwm, 0, GET(hc, 0) + len);
4591: cd->hwm += LINK_SIZE;
4592: }
4593: save_hwm = this_hwm;
4594: code += len;
4595: }
4596: }
4597: }
4598:
4599: if (repeat_max > 0) repeat_max -= repeat_min;
4600: }
4601:
4602: /* This code is common to both the zero and non-zero minimum cases. If
4603: the maximum is limited, it replicates the group in a nested fashion,
4604: remembering the bracket starts on a stack. In the case of a zero minimum,
4605: the first one was set up above. In all cases the repeat_max now specifies
4606: the number of additional copies needed. Again, we must remember to
4607: replicate entries on the forward reference list. */
4608:
4609: if (repeat_max >= 0)
4610: {
4611: /* In the pre-compile phase, we don't actually do the replication. We
4612: just adjust the length as if we had. For each repetition we must add 1
4613: to the length for BRAZERO and for all but the last repetition we must
4614: add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
4615: paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is
4616: a 64-bit integer type when available, otherwise double. */
4617:
4618: if (lengthptr != NULL && repeat_max > 0)
4619: {
4620: int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
4621: 2 - 2*LINK_SIZE; /* Last one doesn't nest */
4622: if ((INT64_OR_DOUBLE)repeat_max *
4623: (INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
4624: > (INT64_OR_DOUBLE)INT_MAX ||
4625: OFLOW_MAX - *lengthptr < delta)
4626: {
4627: *errorcodeptr = ERR20;
4628: goto FAILED;
4629: }
4630: *lengthptr += delta;
4631: }
4632:
4633: /* This is compiling for real */
4634:
4635: else for (i = repeat_max - 1; i >= 0; i--)
4636: {
4637: uschar *hc;
4638: uschar *this_hwm = cd->hwm;
4639:
4640: *code++ = OP_BRAZERO + repeat_type;
4641:
4642: /* All but the final copy start a new nesting, maintaining the
4643: chain of brackets outstanding. */
4644:
4645: if (i != 0)
4646: {
4647: int offset;
4648: *code++ = OP_BRA;
4649: offset = (bralink == NULL)? 0 : (int)(code - bralink);
4650: bralink = code;
4651: PUTINC(code, 0, offset);
4652: }
4653:
4654: memcpy(code, previous, len);
4655: for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
4656: {
4657: PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));
4658: cd->hwm += LINK_SIZE;
4659: }
4660: save_hwm = this_hwm;
4661: code += len;
4662: }
4663:
4664: /* Now chain through the pending brackets, and fill in their length
4665: fields (which are holding the chain links pro tem). */
4666:
4667: while (bralink != NULL)
4668: {
4669: int oldlinkoffset;
4670: int offset = (int)(code - bralink + 1);
4671: uschar *bra = code - offset;
4672: oldlinkoffset = GET(bra, 1);
4673: bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
4674: *code++ = OP_KET;
4675: PUTINC(code, 0, offset);
4676: PUT(bra, 1, offset);
4677: }
4678: }
4679:
4680: /* If the maximum is unlimited, set a repeater in the final copy. We
4681: can't just offset backwards from the current code point, because we
4682: don't know if there's been an options resetting after the ket. The
4683: correct offset was computed above.
4684:
4685: Then, when we are doing the actual compile phase, check to see whether
4686: this group is a non-atomic one that could match an empty string. If so,
4687: convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
4688: that runtime checking can be done. [This check is also applied to
4689: atomic groups at runtime, but in a different way.] */
4690:
4691: else
4692: {
4693: uschar *ketcode = code - ketoffset;
4694: uschar *bracode = ketcode - GET(ketcode, 1);
4695: *ketcode = OP_KETRMAX + repeat_type;
4696: if (lengthptr == NULL && *bracode != OP_ONCE)
4697: {
4698: uschar *scode = bracode;
4699: do
4700: {
4701: if (could_be_empty_branch(scode, ketcode, utf8, cd))
4702: {
4703: *bracode += OP_SBRA - OP_BRA;
4704: break;
4705: }
4706: scode += GET(scode, 1);
4707: }
4708: while (*scode == OP_ALT);
4709: }
4710: }
4711: }
4712:
4713: /* If previous is OP_FAIL, it was generated by an empty class [] in
4714: JavaScript mode. The other ways in which OP_FAIL can be generated, that is
4715: by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"
4716: error above. We can just ignore the repeat in JS case. */
4717:
4718: else if (*previous == OP_FAIL) goto END_REPEAT;
4719:
4720: /* Else there's some kind of shambles */
4721:
4722: else
4723: {
4724: *errorcodeptr = ERR11;
4725: goto FAILED;
4726: }
4727:
4728: /* If the character following a repeat is '+', or if certain optimization
4729: tests above succeeded, possessive_quantifier is TRUE. For some of the
4730: simpler opcodes, there is an special alternative opcode for this. For
4731: anything else, we wrap the entire repeated item inside OP_ONCE brackets.
4732: The '+' notation is just syntactic sugar, taken from Sun's Java package,
4733: but the special opcodes can optimize it a bit. The repeated item starts at
4734: tempcode, not at previous, which might be the first part of a string whose
4735: (former) last char we repeated.
4736:
4737: Possessifying an 'exact' quantifier has no effect, so we can ignore it. But
4738: an 'upto' may follow. We skip over an 'exact' item, and then test the
4739: length of what remains before proceeding. */
4740:
4741: if (possessive_quantifier)
4742: {
4743: int len;
4744:
4745: if (*tempcode == OP_TYPEEXACT)
4746: tempcode += _pcre_OP_lengths[*tempcode] +
4747: ((tempcode[3] == OP_PROP || tempcode[3] == OP_NOTPROP)? 2 : 0);
4748:
4749: else if (*tempcode == OP_EXACT || *tempcode == OP_NOTEXACT)
4750: {
4751: tempcode += _pcre_OP_lengths[*tempcode];
4752: #ifdef SUPPORT_UTF8
4753: if (utf8 && tempcode[-1] >= 0xc0)
4754: tempcode += _pcre_utf8_table4[tempcode[-1] & 0x3f];
4755: #endif
4756: }
4757:
4758: len = (int)(code - tempcode);
4759: if (len > 0) switch (*tempcode)
4760: {
4761: case OP_STAR: *tempcode = OP_POSSTAR; break;
4762: case OP_PLUS: *tempcode = OP_POSPLUS; break;
4763: case OP_QUERY: *tempcode = OP_POSQUERY; break;
4764: case OP_UPTO: *tempcode = OP_POSUPTO; break;
4765:
4766: case OP_TYPESTAR: *tempcode = OP_TYPEPOSSTAR; break;
4767: case OP_TYPEPLUS: *tempcode = OP_TYPEPOSPLUS; break;
4768: case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;
4769: case OP_TYPEUPTO: *tempcode = OP_TYPEPOSUPTO; break;
4770:
4771: case OP_NOTSTAR: *tempcode = OP_NOTPOSSTAR; break;
4772: case OP_NOTPLUS: *tempcode = OP_NOTPOSPLUS; break;
4773: case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;
4774: case OP_NOTUPTO: *tempcode = OP_NOTPOSUPTO; break;
4775:
4776: /* Because we are moving code along, we must ensure that any
4777: pending recursive references are updated. */
4778:
4779: default:
4780: *code = OP_END;
4781: adjust_recurse(tempcode, 1 + LINK_SIZE, utf8, cd, save_hwm);
4782: memmove(tempcode + 1+LINK_SIZE, tempcode, len);
4783: code += 1 + LINK_SIZE;
4784: len += 1 + LINK_SIZE;
4785: tempcode[0] = OP_ONCE;
4786: *code++ = OP_KET;
4787: PUTINC(code, 0, len);
4788: PUT(tempcode, 1, len);
4789: break;
4790: }
4791: }
4792:
4793: /* In all case we no longer have a previous item. We also set the
4794: "follows varying string" flag for subsequently encountered reqbytes if
4795: it isn't already set and we have just passed a varying length item. */
4796:
4797: END_REPEAT:
4798: previous = NULL;
4799: cd->req_varyopt |= reqvary;
4800: break;
4801:
4802:
4803: /* ===================================================================*/
4804: /* Start of nested parenthesized sub-expression, or comment or lookahead or
4805: lookbehind or option setting or condition or all the other extended
4806: parenthesis forms. */
4807:
4808: case CHAR_LEFT_PARENTHESIS:
4809: newoptions = options;
4810: skipbytes = 0;
4811: bravalue = OP_CBRA;
4812: save_hwm = cd->hwm;
4813: reset_bracount = FALSE;
4814:
4815: /* First deal with various "verbs" that can be introduced by '*'. */
4816:
4817: if (*(++ptr) == CHAR_ASTERISK &&
4818: ((cd->ctypes[ptr[1]] & ctype_letter) != 0 || ptr[1] == ':'))
4819: {
4820: int i, namelen;
4821: int arglen = 0;
4822: const char *vn = verbnames;
4823: const uschar *name = ptr + 1;
4824: const uschar *arg = NULL;
4825: previous = NULL;
4826: while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
4827: namelen = (int)(ptr - name);
4828:
4829: if (*ptr == CHAR_COLON)
4830: {
4831: arg = ++ptr;
4832: while ((cd->ctypes[*ptr] & (ctype_letter|ctype_digit)) != 0
4833: || *ptr == '_') ptr++;
4834: arglen = (int)(ptr - arg);
4835: }
4836:
4837: if (*ptr != CHAR_RIGHT_PARENTHESIS)
4838: {
4839: *errorcodeptr = ERR60;
4840: goto FAILED;
4841: }
4842:
4843: /* Scan the table of verb names */
4844:
4845: for (i = 0; i < verbcount; i++)
4846: {
4847: if (namelen == verbs[i].len &&
4848: strncmp((char *)name, vn, namelen) == 0)
4849: {
4850: /* Check for open captures before ACCEPT */
4851:
4852: if (verbs[i].op == OP_ACCEPT)
4853: {
4854: open_capitem *oc;
4855: cd->had_accept = TRUE;
4856: for (oc = cd->open_caps; oc != NULL; oc = oc->next)
4857: {
4858: *code++ = OP_CLOSE;
4859: PUT2INC(code, 0, oc->number);
4860: }
4861: }
4862:
4863: /* Handle the cases with/without an argument */
4864:
4865: if (arglen == 0)
4866: {
4867: if (verbs[i].op < 0) /* Argument is mandatory */
4868: {
4869: *errorcodeptr = ERR66;
4870: goto FAILED;
4871: }
4872: *code = verbs[i].op;
4873: if (*code++ == OP_THEN)
4874: {
4875: PUT(code, 0, code - bcptr->current_branch - 1);
4876: code += LINK_SIZE;
4877: }
4878: }
4879:
4880: else
4881: {
4882: if (verbs[i].op_arg < 0) /* Argument is forbidden */
4883: {
4884: *errorcodeptr = ERR59;
4885: goto FAILED;
4886: }
4887: *code = verbs[i].op_arg;
4888: if (*code++ == OP_THEN_ARG)
4889: {
4890: PUT(code, 0, code - bcptr->current_branch - 1);
4891: code += LINK_SIZE;
4892: }
4893: *code++ = arglen;
4894: memcpy(code, arg, arglen);
4895: code += arglen;
4896: *code++ = 0;
4897: }
4898:
4899: break; /* Found verb, exit loop */
4900: }
4901:
4902: vn += verbs[i].len + 1;
4903: }
4904:
4905: if (i < verbcount) continue; /* Successfully handled a verb */
4906: *errorcodeptr = ERR60; /* Verb not recognized */
4907: goto FAILED;
4908: }
4909:
4910: /* Deal with the extended parentheses; all are introduced by '?', and the
4911: appearance of any of them means that this is not a capturing group. */
4912:
4913: else if (*ptr == CHAR_QUESTION_MARK)
4914: {
4915: int i, set, unset, namelen;
4916: int *optset;
4917: const uschar *name;
4918: uschar *slot;
4919:
4920: switch (*(++ptr))
4921: {
4922: case CHAR_NUMBER_SIGN: /* Comment; skip to ket */
4923: ptr++;
4924: while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
4925: if (*ptr == 0)
4926: {
4927: *errorcodeptr = ERR18;
4928: goto FAILED;
4929: }
4930: continue;
4931:
4932:
4933: /* ------------------------------------------------------------ */
4934: case CHAR_VERTICAL_LINE: /* Reset capture count for each branch */
4935: reset_bracount = TRUE;
4936: /* Fall through */
4937:
4938: /* ------------------------------------------------------------ */
4939: case CHAR_COLON: /* Non-capturing bracket */
4940: bravalue = OP_BRA;
4941: ptr++;
4942: break;
4943:
4944:
4945: /* ------------------------------------------------------------ */
4946: case CHAR_LEFT_PARENTHESIS:
4947: bravalue = OP_COND; /* Conditional group */
4948:
4949: /* A condition can be an assertion, a number (referring to a numbered
4950: group), a name (referring to a named group), or 'R', referring to
4951: recursion. R<digits> and R&name are also permitted for recursion tests.
4952:
4953: There are several syntaxes for testing a named group: (?(name)) is used
4954: by Python; Perl 5.10 onwards uses (?(<name>) or (?('name')).
4955:
4956: There are two unfortunate ambiguities, caused by history. (a) 'R' can
4957: be the recursive thing or the name 'R' (and similarly for 'R' followed
4958: by digits), and (b) a number could be a name that consists of digits.
4959: In both cases, we look for a name first; if not found, we try the other
4960: cases. */
4961:
4962: /* For conditions that are assertions, check the syntax, and then exit
4963: the switch. This will take control down to where bracketed groups,
4964: including assertions, are processed. */
4965:
4966: if (ptr[1] == CHAR_QUESTION_MARK && (ptr[2] == CHAR_EQUALS_SIGN ||
4967: ptr[2] == CHAR_EXCLAMATION_MARK || ptr[2] == CHAR_LESS_THAN_SIGN))
4968: break;
4969:
4970: /* Most other conditions use OP_CREF (a couple change to OP_RREF
4971: below), and all need to skip 3 bytes at the start of the group. */
4972:
4973: code[1+LINK_SIZE] = OP_CREF;
4974: skipbytes = 3;
4975: refsign = -1;
4976:
4977: /* Check for a test for recursion in a named group. */
4978:
4979: if (ptr[1] == CHAR_R && ptr[2] == CHAR_AMPERSAND)
4980: {
4981: terminator = -1;
4982: ptr += 2;
4983: code[1+LINK_SIZE] = OP_RREF; /* Change the type of test */
4984: }
4985:
4986: /* Check for a test for a named group's having been set, using the Perl
4987: syntax (?(<name>) or (?('name') */
4988:
4989: else if (ptr[1] == CHAR_LESS_THAN_SIGN)
4990: {
4991: terminator = CHAR_GREATER_THAN_SIGN;
4992: ptr++;
4993: }
4994: else if (ptr[1] == CHAR_APOSTROPHE)
4995: {
4996: terminator = CHAR_APOSTROPHE;
4997: ptr++;
4998: }
4999: else
5000: {
5001: terminator = 0;
5002: if (ptr[1] == CHAR_MINUS || ptr[1] == CHAR_PLUS) refsign = *(++ptr);
5003: }
5004:
5005: /* We now expect to read a name; any thing else is an error */
5006:
5007: if ((cd->ctypes[ptr[1]] & ctype_word) == 0)
5008: {
5009: ptr += 1; /* To get the right offset */
5010: *errorcodeptr = ERR28;
5011: goto FAILED;
5012: }
5013:
5014: /* Read the name, but also get it as a number if it's all digits */
5015:
5016: recno = 0;
5017: name = ++ptr;
5018: while ((cd->ctypes[*ptr] & ctype_word) != 0)
5019: {
5020: if (recno >= 0)
5021: recno = ((digitab[*ptr] & ctype_digit) != 0)?
5022: recno * 10 + *ptr - CHAR_0 : -1;
5023: ptr++;
5024: }
5025: namelen = (int)(ptr - name);
5026:
5027: if ((terminator > 0 && *ptr++ != terminator) ||
5028: *ptr++ != CHAR_RIGHT_PARENTHESIS)
5029: {
5030: ptr--; /* Error offset */
5031: *errorcodeptr = ERR26;
5032: goto FAILED;
5033: }
5034:
5035: /* Do no further checking in the pre-compile phase. */
5036:
5037: if (lengthptr != NULL) break;
5038:
5039: /* In the real compile we do the work of looking for the actual
5040: reference. If the string started with "+" or "-" we require the rest to
5041: be digits, in which case recno will be set. */
5042:
5043: if (refsign > 0)
5044: {
5045: if (recno <= 0)
5046: {
5047: *errorcodeptr = ERR58;
5048: goto FAILED;
5049: }
5050: recno = (refsign == CHAR_MINUS)?
5051: cd->bracount - recno + 1 : recno +cd->bracount;
5052: if (recno <= 0 || recno > cd->final_bracount)
5053: {
5054: *errorcodeptr = ERR15;
5055: goto FAILED;
5056: }
5057: PUT2(code, 2+LINK_SIZE, recno);
5058: break;
5059: }
5060:
5061: /* Otherwise (did not start with "+" or "-"), start by looking for the
5062: name. If we find a name, add one to the opcode to change OP_CREF or
5063: OP_RREF into OP_NCREF or OP_NRREF. These behave exactly the same,
5064: except they record that the reference was originally to a name. The
5065: information is used to check duplicate names. */
5066:
5067: slot = cd->name_table;
5068: for (i = 0; i < cd->names_found; i++)
5069: {
5070: if (strncmp((char *)name, (char *)slot+2, namelen) == 0) break;
5071: slot += cd->name_entry_size;
5072: }
5073:
5074: /* Found a previous named subpattern */
5075:
5076: if (i < cd->names_found)
5077: {
5078: recno = GET2(slot, 0);
5079: PUT2(code, 2+LINK_SIZE, recno);
5080: code[1+LINK_SIZE]++;
5081: }
5082:
5083: /* Search the pattern for a forward reference */
5084:
5085: else if ((i = find_parens(cd, name, namelen,
5086: (options & PCRE_EXTENDED) != 0, utf8)) > 0)
5087: {
5088: PUT2(code, 2+LINK_SIZE, i);
5089: code[1+LINK_SIZE]++;
5090: }
5091:
5092: /* If terminator == 0 it means that the name followed directly after
5093: the opening parenthesis [e.g. (?(abc)...] and in this case there are
5094: some further alternatives to try. For the cases where terminator != 0
5095: [things like (?(<name>... or (?('name')... or (?(R&name)... ] we have
5096: now checked all the possibilities, so give an error. */
5097:
5098: else if (terminator != 0)
5099: {
5100: *errorcodeptr = ERR15;
5101: goto FAILED;
5102: }
5103:
5104: /* Check for (?(R) for recursion. Allow digits after R to specify a
5105: specific group number. */
5106:
5107: else if (*name == CHAR_R)
5108: {
5109: recno = 0;
5110: for (i = 1; i < namelen; i++)
5111: {
5112: if ((digitab[name[i]] & ctype_digit) == 0)
5113: {
5114: *errorcodeptr = ERR15;
5115: goto FAILED;
5116: }
5117: recno = recno * 10 + name[i] - CHAR_0;
5118: }
5119: if (recno == 0) recno = RREF_ANY;
5120: code[1+LINK_SIZE] = OP_RREF; /* Change test type */
5121: PUT2(code, 2+LINK_SIZE, recno);
5122: }
5123:
5124: /* Similarly, check for the (?(DEFINE) "condition", which is always
5125: false. */
5126:
5127: else if (namelen == 6 && strncmp((char *)name, STRING_DEFINE, 6) == 0)
5128: {
5129: code[1+LINK_SIZE] = OP_DEF;
5130: skipbytes = 1;
5131: }
5132:
5133: /* Check for the "name" actually being a subpattern number. We are
5134: in the second pass here, so final_bracount is set. */
5135:
5136: else if (recno > 0 && recno <= cd->final_bracount)
5137: {
5138: PUT2(code, 2+LINK_SIZE, recno);
5139: }
5140:
5141: /* Either an unidentified subpattern, or a reference to (?(0) */
5142:
5143: else
5144: {
5145: *errorcodeptr = (recno == 0)? ERR35: ERR15;
5146: goto FAILED;
5147: }
5148: break;
5149:
5150:
5151: /* ------------------------------------------------------------ */
5152: case CHAR_EQUALS_SIGN: /* Positive lookahead */
5153: bravalue = OP_ASSERT;
5154: ptr++;
5155: break;
5156:
5157:
5158: /* ------------------------------------------------------------ */
5159: case CHAR_EXCLAMATION_MARK: /* Negative lookahead */
5160: ptr++;
5161: if (*ptr == CHAR_RIGHT_PARENTHESIS) /* Optimize (?!) */
5162: {
5163: *code++ = OP_FAIL;
5164: previous = NULL;
5165: continue;
5166: }
5167: bravalue = OP_ASSERT_NOT;
5168: break;
5169:
5170:
5171: /* ------------------------------------------------------------ */
5172: case CHAR_LESS_THAN_SIGN: /* Lookbehind or named define */
5173: switch (ptr[1])
5174: {
5175: case CHAR_EQUALS_SIGN: /* Positive lookbehind */
5176: bravalue = OP_ASSERTBACK;
5177: ptr += 2;
5178: break;
5179:
5180: case CHAR_EXCLAMATION_MARK: /* Negative lookbehind */
5181: bravalue = OP_ASSERTBACK_NOT;
5182: ptr += 2;
5183: break;
5184:
5185: default: /* Could be name define, else bad */
5186: if ((cd->ctypes[ptr[1]] & ctype_word) != 0) goto DEFINE_NAME;
5187: ptr++; /* Correct offset for error */
5188: *errorcodeptr = ERR24;
5189: goto FAILED;
5190: }
5191: break;
5192:
5193:
5194: /* ------------------------------------------------------------ */
5195: case CHAR_GREATER_THAN_SIGN: /* One-time brackets */
5196: bravalue = OP_ONCE;
5197: ptr++;
5198: break;
5199:
5200:
5201: /* ------------------------------------------------------------ */
5202: case CHAR_C: /* Callout - may be followed by digits; */
5203: previous_callout = code; /* Save for later completion */
5204: after_manual_callout = 1; /* Skip one item before completing */
5205: *code++ = OP_CALLOUT;
5206: {
5207: int n = 0;
5208: while ((digitab[*(++ptr)] & ctype_digit) != 0)
5209: n = n * 10 + *ptr - CHAR_0;
5210: if (*ptr != CHAR_RIGHT_PARENTHESIS)
5211: {
5212: *errorcodeptr = ERR39;
5213: goto FAILED;
5214: }
5215: if (n > 255)
5216: {
5217: *errorcodeptr = ERR38;
5218: goto FAILED;
5219: }
5220: *code++ = n;
5221: PUT(code, 0, (int)(ptr - cd->start_pattern + 1)); /* Pattern offset */
5222: PUT(code, LINK_SIZE, 0); /* Default length */
5223: code += 2 * LINK_SIZE;
5224: }
5225: previous = NULL;
5226: continue;
5227:
5228:
5229: /* ------------------------------------------------------------ */
5230: case CHAR_P: /* Python-style named subpattern handling */
5231: if (*(++ptr) == CHAR_EQUALS_SIGN ||
5232: *ptr == CHAR_GREATER_THAN_SIGN) /* Reference or recursion */
5233: {
5234: is_recurse = *ptr == CHAR_GREATER_THAN_SIGN;
5235: terminator = CHAR_RIGHT_PARENTHESIS;
5236: goto NAMED_REF_OR_RECURSE;
5237: }
5238: else if (*ptr != CHAR_LESS_THAN_SIGN) /* Test for Python-style defn */
5239: {
5240: *errorcodeptr = ERR41;
5241: goto FAILED;
5242: }
5243: /* Fall through to handle (?P< as (?< is handled */
5244:
5245:
5246: /* ------------------------------------------------------------ */
5247: DEFINE_NAME: /* Come here from (?< handling */
5248: case CHAR_APOSTROPHE:
5249: {
5250: terminator = (*ptr == CHAR_LESS_THAN_SIGN)?
5251: CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
5252: name = ++ptr;
5253:
5254: while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
5255: namelen = (int)(ptr - name);
5256:
5257: /* In the pre-compile phase, just do a syntax check. */
5258:
5259: if (lengthptr != NULL)
5260: {
5261: if (*ptr != terminator)
5262: {
5263: *errorcodeptr = ERR42;
5264: goto FAILED;
5265: }
5266: if (cd->names_found >= MAX_NAME_COUNT)
5267: {
5268: *errorcodeptr = ERR49;
5269: goto FAILED;
5270: }
5271: if (namelen + 3 > cd->name_entry_size)
5272: {
5273: cd->name_entry_size = namelen + 3;
5274: if (namelen > MAX_NAME_SIZE)
5275: {
5276: *errorcodeptr = ERR48;
5277: goto FAILED;
5278: }
5279: }
5280: }
5281:
5282: /* In the real compile, create the entry in the table, maintaining
5283: alphabetical order. Duplicate names for different numbers are
5284: permitted only if PCRE_DUPNAMES is set. Duplicate names for the same
5285: number are always OK. (An existing number can be re-used if (?|
5286: appears in the pattern.) In either event, a duplicate name results in
5287: a duplicate entry in the table, even if the number is the same. This
5288: is because the number of names, and hence the table size, is computed
5289: in the pre-compile, and it affects various numbers and pointers which
5290: would all have to be modified, and the compiled code moved down, if
5291: duplicates with the same number were omitted from the table. This
5292: doesn't seem worth the hassle. However, *different* names for the
5293: same number are not permitted. */
5294:
5295: else
5296: {
5297: BOOL dupname = FALSE;
5298: slot = cd->name_table;
5299:
5300: for (i = 0; i < cd->names_found; i++)
5301: {
5302: int crc = memcmp(name, slot+2, namelen);
5303: if (crc == 0)
5304: {
5305: if (slot[2+namelen] == 0)
5306: {
5307: if (GET2(slot, 0) != cd->bracount + 1 &&
5308: (options & PCRE_DUPNAMES) == 0)
5309: {
5310: *errorcodeptr = ERR43;
5311: goto FAILED;
5312: }
5313: else dupname = TRUE;
5314: }
5315: else crc = -1; /* Current name is a substring */
5316: }
5317:
5318: /* Make space in the table and break the loop for an earlier
5319: name. For a duplicate or later name, carry on. We do this for
5320: duplicates so that in the simple case (when ?(| is not used) they
5321: are in order of their numbers. */
5322:
5323: if (crc < 0)
5324: {
5325: memmove(slot + cd->name_entry_size, slot,
5326: (cd->names_found - i) * cd->name_entry_size);
5327: break;
5328: }
5329:
5330: /* Continue the loop for a later or duplicate name */
5331:
5332: slot += cd->name_entry_size;
5333: }
5334:
5335: /* For non-duplicate names, check for a duplicate number before
5336: adding the new name. */
5337:
5338: if (!dupname)
5339: {
5340: uschar *cslot = cd->name_table;
5341: for (i = 0; i < cd->names_found; i++)
5342: {
5343: if (cslot != slot)
5344: {
5345: if (GET2(cslot, 0) == cd->bracount + 1)
5346: {
5347: *errorcodeptr = ERR65;
5348: goto FAILED;
5349: }
5350: }
5351: else i--;
5352: cslot += cd->name_entry_size;
5353: }
5354: }
5355:
5356: PUT2(slot, 0, cd->bracount + 1);
5357: memcpy(slot + 2, name, namelen);
5358: slot[2+namelen] = 0;
5359: }
5360: }
5361:
5362: /* In both pre-compile and compile, count the number of names we've
5363: encountered. */
5364:
5365: cd->names_found++;
5366: ptr++; /* Move past > or ' */
5367: goto NUMBERED_GROUP;
5368:
5369:
5370: /* ------------------------------------------------------------ */
5371: case CHAR_AMPERSAND: /* Perl recursion/subroutine syntax */
5372: terminator = CHAR_RIGHT_PARENTHESIS;
5373: is_recurse = TRUE;
5374: /* Fall through */
5375:
5376: /* We come here from the Python syntax above that handles both
5377: references (?P=name) and recursion (?P>name), as well as falling
5378: through from the Perl recursion syntax (?&name). We also come here from
5379: the Perl \k<name> or \k'name' back reference syntax and the \k{name}
5380: .NET syntax, and the Oniguruma \g<...> and \g'...' subroutine syntax. */
5381:
5382: NAMED_REF_OR_RECURSE:
5383: name = ++ptr;
5384: while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
5385: namelen = (int)(ptr - name);
5386:
5387: /* In the pre-compile phase, do a syntax check. We used to just set
5388: a dummy reference number, because it was not used in the first pass.
5389: However, with the change of recursive back references to be atomic,
5390: we have to look for the number so that this state can be identified, as
5391: otherwise the incorrect length is computed. If it's not a backwards
5392: reference, the dummy number will do. */
5393:
5394: if (lengthptr != NULL)
5395: {
5396: const uschar *temp;
5397:
5398: if (namelen == 0)
5399: {
5400: *errorcodeptr = ERR62;
5401: goto FAILED;
5402: }
5403: if (*ptr != terminator)
5404: {
5405: *errorcodeptr = ERR42;
5406: goto FAILED;
5407: }
5408: if (namelen > MAX_NAME_SIZE)
5409: {
5410: *errorcodeptr = ERR48;
5411: goto FAILED;
5412: }
5413:
5414: /* The name table does not exist in the first pass, so we cannot
5415: do a simple search as in the code below. Instead, we have to scan the
5416: pattern to find the number. It is important that we scan it only as
5417: far as we have got because the syntax of named subpatterns has not
5418: been checked for the rest of the pattern, and find_parens() assumes
5419: correct syntax. In any case, it's a waste of resources to scan
5420: further. We stop the scan at the current point by temporarily
5421: adjusting the value of cd->endpattern. */
5422:
5423: temp = cd->end_pattern;
5424: cd->end_pattern = ptr;
5425: recno = find_parens(cd, name, namelen,
5426: (options & PCRE_EXTENDED) != 0, utf8);
5427: cd->end_pattern = temp;
5428: if (recno < 0) recno = 0; /* Forward ref; set dummy number */
5429: }
5430:
5431: /* In the real compile, seek the name in the table. We check the name
5432: first, and then check that we have reached the end of the name in the
5433: table. That way, if the name that is longer than any in the table,
5434: the comparison will fail without reading beyond the table entry. */
5435:
5436: else
5437: {
5438: slot = cd->name_table;
5439: for (i = 0; i < cd->names_found; i++)
5440: {
5441: if (strncmp((char *)name, (char *)slot+2, namelen) == 0 &&
5442: slot[2+namelen] == 0)
5443: break;
5444: slot += cd->name_entry_size;
5445: }
5446:
5447: if (i < cd->names_found) /* Back reference */
5448: {
5449: recno = GET2(slot, 0);
5450: }
5451: else if ((recno = /* Forward back reference */
5452: find_parens(cd, name, namelen,
5453: (options & PCRE_EXTENDED) != 0, utf8)) <= 0)
5454: {
5455: *errorcodeptr = ERR15;
5456: goto FAILED;
5457: }
5458: }
5459:
5460: /* In both phases, we can now go to the code than handles numerical
5461: recursion or backreferences. */
5462:
5463: if (is_recurse) goto HANDLE_RECURSION;
5464: else goto HANDLE_REFERENCE;
5465:
5466:
5467: /* ------------------------------------------------------------ */
5468: case CHAR_R: /* Recursion */
5469: ptr++; /* Same as (?0) */
5470: /* Fall through */
5471:
5472:
5473: /* ------------------------------------------------------------ */
5474: case CHAR_MINUS: case CHAR_PLUS: /* Recursion or subroutine */
5475: case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:
5476: case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
5477: {
5478: const uschar *called;
5479: terminator = CHAR_RIGHT_PARENTHESIS;
5480:
5481: /* Come here from the \g<...> and \g'...' code (Oniguruma
5482: compatibility). However, the syntax has been checked to ensure that
5483: the ... are a (signed) number, so that neither ERR63 nor ERR29 will
5484: be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
5485: ever be taken. */
5486:
5487: HANDLE_NUMERICAL_RECURSION:
5488:
5489: if ((refsign = *ptr) == CHAR_PLUS)
5490: {
5491: ptr++;
5492: if ((digitab[*ptr] & ctype_digit) == 0)
5493: {
5494: *errorcodeptr = ERR63;
5495: goto FAILED;
5496: }
5497: }
5498: else if (refsign == CHAR_MINUS)
5499: {
5500: if ((digitab[ptr[1]] & ctype_digit) == 0)
5501: goto OTHER_CHAR_AFTER_QUERY;
5502: ptr++;
5503: }
5504:
5505: recno = 0;
5506: while((digitab[*ptr] & ctype_digit) != 0)
5507: recno = recno * 10 + *ptr++ - CHAR_0;
5508:
5509: if (*ptr != terminator)
5510: {
5511: *errorcodeptr = ERR29;
5512: goto FAILED;
5513: }
5514:
5515: if (refsign == CHAR_MINUS)
5516: {
5517: if (recno == 0)
5518: {
5519: *errorcodeptr = ERR58;
5520: goto FAILED;
5521: }
5522: recno = cd->bracount - recno + 1;
5523: if (recno <= 0)
5524: {
5525: *errorcodeptr = ERR15;
5526: goto FAILED;
5527: }
5528: }
5529: else if (refsign == CHAR_PLUS)
5530: {
5531: if (recno == 0)
5532: {
5533: *errorcodeptr = ERR58;
5534: goto FAILED;
5535: }
5536: recno += cd->bracount;
5537: }
5538:
5539: /* Come here from code above that handles a named recursion */
5540:
5541: HANDLE_RECURSION:
5542:
5543: previous = code;
5544: called = cd->start_code;
5545:
5546: /* When we are actually compiling, find the bracket that is being
5547: referenced. Temporarily end the regex in case it doesn't exist before
5548: this point. If we end up with a forward reference, first check that
5549: the bracket does occur later so we can give the error (and position)
5550: now. Then remember this forward reference in the workspace so it can
5551: be filled in at the end. */
5552:
5553: if (lengthptr == NULL)
5554: {
5555: *code = OP_END;
5556: if (recno != 0)
5557: called = _pcre_find_bracket(cd->start_code, utf8, recno);
5558:
5559: /* Forward reference */
5560:
5561: if (called == NULL)
5562: {
5563: if (find_parens(cd, NULL, recno,
5564: (options & PCRE_EXTENDED) != 0, utf8) < 0)
5565: {
5566: *errorcodeptr = ERR15;
5567: goto FAILED;
5568: }
5569:
5570: /* Fudge the value of "called" so that when it is inserted as an
5571: offset below, what it actually inserted is the reference number
5572: of the group. */
5573:
5574: called = cd->start_code + recno;
5575: PUTINC(cd->hwm, 0, (int)(code + 2 + LINK_SIZE - cd->start_code));
5576: }
5577:
5578: /* If not a forward reference, and the subpattern is still open,
5579: this is a recursive call. We check to see if this is a left
5580: recursion that could loop for ever, and diagnose that case. */
5581:
5582: else if (GET(called, 1) == 0 &&
5583: could_be_empty(called, code, bcptr, utf8, cd))
5584: {
5585: *errorcodeptr = ERR40;
5586: goto FAILED;
5587: }
5588: }
5589:
5590: /* Insert the recursion/subroutine item, automatically wrapped inside
5591: "once" brackets. Set up a "previous group" length so that a
5592: subsequent quantifier will work. */
5593:
5594: *code = OP_ONCE;
5595: PUT(code, 1, 2 + 2*LINK_SIZE);
5596: code += 1 + LINK_SIZE;
5597:
5598: *code = OP_RECURSE;
5599: PUT(code, 1, (int)(called - cd->start_code));
5600: code += 1 + LINK_SIZE;
5601:
5602: *code = OP_KET;
5603: PUT(code, 1, 2 + 2*LINK_SIZE);
5604: code += 1 + LINK_SIZE;
5605:
5606: length_prevgroup = 3 + 3*LINK_SIZE;
5607: }
5608:
5609: /* Can't determine a first byte now */
5610:
5611: if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
5612: continue;
5613:
5614:
5615: /* ------------------------------------------------------------ */
5616: default: /* Other characters: check option setting */
5617: OTHER_CHAR_AFTER_QUERY:
5618: set = unset = 0;
5619: optset = &set;
5620:
5621: while (*ptr != CHAR_RIGHT_PARENTHESIS && *ptr != CHAR_COLON)
5622: {
5623: switch (*ptr++)
5624: {
5625: case CHAR_MINUS: optset = &unset; break;
5626:
5627: case CHAR_J: /* Record that it changed in the external options */
5628: *optset |= PCRE_DUPNAMES;
5629: cd->external_flags |= PCRE_JCHANGED;
5630: break;
5631:
5632: case CHAR_i: *optset |= PCRE_CASELESS; break;
5633: case CHAR_m: *optset |= PCRE_MULTILINE; break;
5634: case CHAR_s: *optset |= PCRE_DOTALL; break;
5635: case CHAR_x: *optset |= PCRE_EXTENDED; break;
5636: case CHAR_U: *optset |= PCRE_UNGREEDY; break;
5637: case CHAR_X: *optset |= PCRE_EXTRA; break;
5638:
5639: default: *errorcodeptr = ERR12;
5640: ptr--; /* Correct the offset */
5641: goto FAILED;
5642: }
5643: }
5644:
5645: /* Set up the changed option bits, but don't change anything yet. */
5646:
5647: newoptions = (options | set) & (~unset);
5648:
5649: /* If the options ended with ')' this is not the start of a nested
5650: group with option changes, so the options change at this level. If this
5651: item is right at the start of the pattern, the options can be
5652: abstracted and made external in the pre-compile phase, and ignored in
5653: the compile phase. This can be helpful when matching -- for instance in
5654: caseless checking of required bytes.
5655:
5656: If the code pointer is not (cd->start_code + 1 + LINK_SIZE), we are
5657: definitely *not* at the start of the pattern because something has been
5658: compiled. In the pre-compile phase, however, the code pointer can have
5659: that value after the start, because it gets reset as code is discarded
5660: during the pre-compile. However, this can happen only at top level - if
5661: we are within parentheses, the starting BRA will still be present. At
5662: any parenthesis level, the length value can be used to test if anything
5663: has been compiled at that level. Thus, a test for both these conditions
5664: is necessary to ensure we correctly detect the start of the pattern in
5665: both phases.
5666:
5667: If we are not at the pattern start, compile code to change the ims
5668: options if this setting actually changes any of them, and reset the
5669: greedy defaults and the case value for firstbyte and reqbyte. */
5670:
5671: if (*ptr == CHAR_RIGHT_PARENTHESIS)
5672: {
5673: if (code == cd->start_code + 1 + LINK_SIZE &&
5674: (lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))
5675: {
5676: cd->external_options = newoptions;
5677: }
5678: else
5679: {
5680: if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))
5681: {
5682: *code++ = OP_OPT;
5683: *code++ = newoptions & PCRE_IMS;
5684: }
5685: greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
5686: greedy_non_default = greedy_default ^ 1;
5687: req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
5688: }
5689:
5690: /* Change options at this level, and pass them back for use
5691: in subsequent branches. When not at the start of the pattern, this
5692: information is also necessary so that a resetting item can be
5693: compiled at the end of a group (if we are in a group). */
5694:
5695: *optionsptr = options = newoptions;
5696: previous = NULL; /* This item can't be repeated */
5697: continue; /* It is complete */
5698: }
5699:
5700: /* If the options ended with ':' we are heading into a nested group
5701: with possible change of options. Such groups are non-capturing and are
5702: not assertions of any kind. All we need to do is skip over the ':';
5703: the newoptions value is handled below. */
5704:
5705: bravalue = OP_BRA;
5706: ptr++;
5707: } /* End of switch for character following (? */
5708: } /* End of (? handling */
5709:
5710: /* Opening parenthesis not followed by '*' or '?'. If PCRE_NO_AUTO_CAPTURE
5711: is set, all unadorned brackets become non-capturing and behave like (?:...)
5712: brackets. */
5713:
5714: else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)
5715: {
5716: bravalue = OP_BRA;
5717: }
5718:
5719: /* Else we have a capturing group. */
5720:
5721: else
5722: {
5723: NUMBERED_GROUP:
5724: cd->bracount += 1;
5725: PUT2(code, 1+LINK_SIZE, cd->bracount);
5726: skipbytes = 2;
5727: }
5728:
5729: /* Process nested bracketed regex. Assertions may not be repeated, but
5730: other kinds can be. All their opcodes are >= OP_ONCE. We copy code into a
5731: non-register variable in order to be able to pass its address because some
5732: compilers complain otherwise. Pass in a new setting for the ims options if
5733: they have changed. */
5734:
5735: previous = (bravalue >= OP_ONCE)? code : NULL;
5736: *code = bravalue;
5737: tempcode = code;
5738: tempreqvary = cd->req_varyopt; /* Save value before bracket */
5739: length_prevgroup = 0; /* Initialize for pre-compile phase */
5740:
5741: if (!compile_regex(
5742: newoptions, /* The complete new option state */
5743: options & PCRE_IMS, /* The previous ims option state */
5744: &tempcode, /* Where to put code (updated) */
5745: &ptr, /* Input pointer (updated) */
5746: errorcodeptr, /* Where to put an error message */
5747: (bravalue == OP_ASSERTBACK ||
5748: bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
5749: reset_bracount, /* True if (?| group */
5750: skipbytes, /* Skip over bracket number */
5751: &subfirstbyte, /* For possible first char */
5752: &subreqbyte, /* For possible last char */
5753: bcptr, /* Current branch chain */
5754: cd, /* Tables block */
5755: (lengthptr == NULL)? NULL : /* Actual compile phase */
5756: &length_prevgroup /* Pre-compile phase */
5757: ))
5758: goto FAILED;
5759:
5760: /* At the end of compiling, code is still pointing to the start of the
5761: group, while tempcode has been updated to point past the end of the group
5762: and any option resetting that may follow it. The pattern pointer (ptr)
5763: is on the bracket. */
5764:
5765: /* If this is a conditional bracket, check that there are no more than
5766: two branches in the group, or just one if it's a DEFINE group. We do this
5767: in the real compile phase, not in the pre-pass, where the whole group may
5768: not be available. */
5769:
5770: if (bravalue == OP_COND && lengthptr == NULL)
5771: {
5772: uschar *tc = code;
5773: int condcount = 0;
5774:
5775: do {
5776: condcount++;
5777: tc += GET(tc,1);
5778: }
5779: while (*tc != OP_KET);
5780:
5781: /* A DEFINE group is never obeyed inline (the "condition" is always
5782: false). It must have only one branch. */
5783:
5784: if (code[LINK_SIZE+1] == OP_DEF)
5785: {
5786: if (condcount > 1)
5787: {
5788: *errorcodeptr = ERR54;
5789: goto FAILED;
5790: }
5791: bravalue = OP_DEF; /* Just a flag to suppress char handling below */
5792: }
5793:
5794: /* A "normal" conditional group. If there is just one branch, we must not
5795: make use of its firstbyte or reqbyte, because this is equivalent to an
5796: empty second branch. */
5797:
5798: else
5799: {
5800: if (condcount > 2)
5801: {
5802: *errorcodeptr = ERR27;
5803: goto FAILED;
5804: }
5805: if (condcount == 1) subfirstbyte = subreqbyte = REQ_NONE;
5806: }
5807: }
5808:
5809: /* Error if hit end of pattern */
5810:
5811: if (*ptr != CHAR_RIGHT_PARENTHESIS)
5812: {
5813: *errorcodeptr = ERR14;
5814: goto FAILED;
5815: }
5816:
5817: /* In the pre-compile phase, update the length by the length of the group,
5818: less the brackets at either end. Then reduce the compiled code to just a
5819: set of non-capturing brackets so that it doesn't use much memory if it is
5820: duplicated by a quantifier.*/
5821:
5822: if (lengthptr != NULL)
5823: {
5824: if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)
5825: {
5826: *errorcodeptr = ERR20;
5827: goto FAILED;
5828: }
5829: *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;
5830: *code++ = OP_BRA;
5831: PUTINC(code, 0, 1 + LINK_SIZE);
5832: *code++ = OP_KET;
5833: PUTINC(code, 0, 1 + LINK_SIZE);
5834: break; /* No need to waste time with special character handling */
5835: }
5836:
5837: /* Otherwise update the main code pointer to the end of the group. */
5838:
5839: code = tempcode;
5840:
5841: /* For a DEFINE group, required and first character settings are not
5842: relevant. */
5843:
5844: if (bravalue == OP_DEF) break;
5845:
5846: /* Handle updating of the required and first characters for other types of
5847: group. Update for normal brackets of all kinds, and conditions with two
5848: branches (see code above). If the bracket is followed by a quantifier with
5849: zero repeat, we have to back off. Hence the definition of zeroreqbyte and
5850: zerofirstbyte outside the main loop so that they can be accessed for the
5851: back off. */
5852:
5853: zeroreqbyte = reqbyte;
5854: zerofirstbyte = firstbyte;
5855: groupsetfirstbyte = FALSE;
5856:
5857: if (bravalue >= OP_ONCE)
5858: {
5859: /* If we have not yet set a firstbyte in this branch, take it from the
5860: subpattern, remembering that it was set here so that a repeat of more
5861: than one can replicate it as reqbyte if necessary. If the subpattern has
5862: no firstbyte, set "none" for the whole branch. In both cases, a zero
5863: repeat forces firstbyte to "none". */
5864:
5865: if (firstbyte == REQ_UNSET)
5866: {
5867: if (subfirstbyte >= 0)
5868: {
5869: firstbyte = subfirstbyte;
5870: groupsetfirstbyte = TRUE;
5871: }
5872: else firstbyte = REQ_NONE;
5873: zerofirstbyte = REQ_NONE;
5874: }
5875:
5876: /* If firstbyte was previously set, convert the subpattern's firstbyte
5877: into reqbyte if there wasn't one, using the vary flag that was in
5878: existence beforehand. */
5879:
5880: else if (subfirstbyte >= 0 && subreqbyte < 0)
5881: subreqbyte = subfirstbyte | tempreqvary;
5882:
5883: /* If the subpattern set a required byte (or set a first byte that isn't
5884: really the first byte - see above), set it. */
5885:
5886: if (subreqbyte >= 0) reqbyte = subreqbyte;
5887: }
5888:
5889: /* For a forward assertion, we take the reqbyte, if set. This can be
5890: helpful if the pattern that follows the assertion doesn't set a different
5891: char. For example, it's useful for /(?=abcde).+/. We can't set firstbyte
5892: for an assertion, however because it leads to incorrect effect for patterns
5893: such as /(?=a)a.+/ when the "real" "a" would then become a reqbyte instead
5894: of a firstbyte. This is overcome by a scan at the end if there's no
5895: firstbyte, looking for an asserted first char. */
5896:
5897: else if (bravalue == OP_ASSERT && subreqbyte >= 0) reqbyte = subreqbyte;
5898: break; /* End of processing '(' */
5899:
5900:
5901: /* ===================================================================*/
5902: /* Handle metasequences introduced by \. For ones like \d, the ESC_ values
5903: are arranged to be the negation of the corresponding OP_values in the
5904: default case when PCRE_UCP is not set. For the back references, the values
5905: are ESC_REF plus the reference number. Only back references and those types
5906: that consume a character may be repeated. We can test for values between
5907: ESC_b and ESC_Z for the latter; this may have to change if any new ones are
5908: ever created. */
5909:
5910: case CHAR_BACKSLASH:
5911: tempptr = ptr;
5912: c = check_escape(&ptr, errorcodeptr, cd->bracount, options, FALSE);
5913: if (*errorcodeptr != 0) goto FAILED;
5914:
5915: if (c < 0)
5916: {
5917: if (-c == ESC_Q) /* Handle start of quoted string */
5918: {
5919: if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
5920: ptr += 2; /* avoid empty string */
5921: else inescq = TRUE;
5922: continue;
5923: }
5924:
5925: if (-c == ESC_E) continue; /* Perl ignores an orphan \E */
5926:
5927: /* For metasequences that actually match a character, we disable the
5928: setting of a first character if it hasn't already been set. */
5929:
5930: if (firstbyte == REQ_UNSET && -c > ESC_b && -c < ESC_Z)
5931: firstbyte = REQ_NONE;
5932:
5933: /* Set values to reset to if this is followed by a zero repeat. */
5934:
5935: zerofirstbyte = firstbyte;
5936: zeroreqbyte = reqbyte;
5937:
5938: /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'
5939: is a subroutine call by number (Oniguruma syntax). In fact, the value
5940: -ESC_g is returned only for these cases. So we don't need to check for <
5941: or ' if the value is -ESC_g. For the Perl syntax \g{n} the value is
5942: -ESC_REF+n, and for the Perl syntax \g{name} the result is -ESC_k (as
5943: that is a synonym for a named back reference). */
5944:
5945: if (-c == ESC_g)
5946: {
5947: const uschar *p;
5948: save_hwm = cd->hwm; /* Normally this is set when '(' is read */
5949: terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
5950: CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
5951:
5952: /* These two statements stop the compiler for warning about possibly
5953: unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In
5954: fact, because we actually check for a number below, the paths that
5955: would actually be in error are never taken. */
5956:
5957: skipbytes = 0;
5958: reset_bracount = FALSE;
5959:
5960: /* Test for a name */
5961:
5962: if (ptr[1] != CHAR_PLUS && ptr[1] != CHAR_MINUS)
5963: {
5964: BOOL isnumber = TRUE;
5965: for (p = ptr + 1; *p != 0 && *p != terminator; p++)
5966: {
5967: if ((cd->ctypes[*p] & ctype_digit) == 0) isnumber = FALSE;
5968: if ((cd->ctypes[*p] & ctype_word) == 0) break;
5969: }
5970: if (*p != terminator)
5971: {
5972: *errorcodeptr = ERR57;
5973: break;
5974: }
5975: if (isnumber)
5976: {
5977: ptr++;
5978: goto HANDLE_NUMERICAL_RECURSION;
5979: }
5980: is_recurse = TRUE;
5981: goto NAMED_REF_OR_RECURSE;
5982: }
5983:
5984: /* Test a signed number in angle brackets or quotes. */
5985:
5986: p = ptr + 2;
5987: while ((digitab[*p] & ctype_digit) != 0) p++;
5988: if (*p != terminator)
5989: {
5990: *errorcodeptr = ERR57;
5991: break;
5992: }
5993: ptr++;
5994: goto HANDLE_NUMERICAL_RECURSION;
5995: }
5996:
5997: /* \k<name> or \k'name' is a back reference by name (Perl syntax).
5998: We also support \k{name} (.NET syntax) */
5999:
6000: if (-c == ESC_k && (ptr[1] == CHAR_LESS_THAN_SIGN ||
6001: ptr[1] == CHAR_APOSTROPHE || ptr[1] == CHAR_LEFT_CURLY_BRACKET))
6002: {
6003: is_recurse = FALSE;
6004: terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
6005: CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
6006: CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;
6007: goto NAMED_REF_OR_RECURSE;
6008: }
6009:
6010: /* Back references are handled specially; must disable firstbyte if
6011: not set to cope with cases like (?=(\w+))\1: which would otherwise set
6012: ':' later. */
6013:
6014: if (-c >= ESC_REF)
6015: {
6016: open_capitem *oc;
6017: recno = -c - ESC_REF;
6018:
6019: HANDLE_REFERENCE: /* Come here from named backref handling */
6020: if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
6021: previous = code;
6022: *code++ = OP_REF;
6023: PUT2INC(code, 0, recno);
6024: cd->backref_map |= (recno < 32)? (1 << recno) : 1;
6025: if (recno > cd->top_backref) cd->top_backref = recno;
6026:
6027: /* Check to see if this back reference is recursive, that it, it
6028: is inside the group that it references. A flag is set so that the
6029: group can be made atomic. */
6030:
6031: for (oc = cd->open_caps; oc != NULL; oc = oc->next)
6032: {
6033: if (oc->number == recno)
6034: {
6035: oc->flag = TRUE;
6036: break;
6037: }
6038: }
6039: }
6040:
6041: /* So are Unicode property matches, if supported. */
6042:
6043: #ifdef SUPPORT_UCP
6044: else if (-c == ESC_P || -c == ESC_p)
6045: {
6046: BOOL negated;
6047: int pdata;
6048: int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
6049: if (ptype < 0) goto FAILED;
6050: previous = code;
6051: *code++ = ((-c == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
6052: *code++ = ptype;
6053: *code++ = pdata;
6054: }
6055: #else
6056:
6057: /* If Unicode properties are not supported, \X, \P, and \p are not
6058: allowed. */
6059:
6060: else if (-c == ESC_X || -c == ESC_P || -c == ESC_p)
6061: {
6062: *errorcodeptr = ERR45;
6063: goto FAILED;
6064: }
6065: #endif
6066:
6067: /* For the rest (including \X when Unicode properties are supported), we
6068: can obtain the OP value by negating the escape value in the default
6069: situation when PCRE_UCP is not set. When it *is* set, we substitute
6070: Unicode property tests. */
6071:
6072: else
6073: {
6074: #ifdef SUPPORT_UCP
6075: if (-c >= ESC_DU && -c <= ESC_wu)
6076: {
6077: nestptr = ptr + 1; /* Where to resume */
6078: ptr = substitutes[-c - ESC_DU] - 1; /* Just before substitute */
6079: }
6080: else
6081: #endif
6082: {
6083: previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
6084: *code++ = -c;
6085: }
6086: }
6087: continue;
6088: }
6089:
6090: /* We have a data character whose value is in c. In UTF-8 mode it may have
6091: a value > 127. We set its representation in the length/buffer, and then
6092: handle it as a data character. */
6093:
6094: #ifdef SUPPORT_UTF8
6095: if (utf8 && c > 127)
6096: mclength = _pcre_ord2utf8(c, mcbuffer);
6097: else
6098: #endif
6099:
6100: {
6101: mcbuffer[0] = c;
6102: mclength = 1;
6103: }
6104: goto ONE_CHAR;
6105:
6106:
6107: /* ===================================================================*/
6108: /* Handle a literal character. It is guaranteed not to be whitespace or #
6109: when the extended flag is set. If we are in UTF-8 mode, it may be a
6110: multi-byte literal character. */
6111:
6112: default:
6113: NORMAL_CHAR:
6114: mclength = 1;
6115: mcbuffer[0] = c;
6116:
6117: #ifdef SUPPORT_UTF8
6118: if (utf8 && c >= 0xc0)
6119: {
6120: while ((ptr[1] & 0xc0) == 0x80)
6121: mcbuffer[mclength++] = *(++ptr);
6122: }
6123: #endif
6124:
6125: /* At this point we have the character's bytes in mcbuffer, and the length
6126: in mclength. When not in UTF-8 mode, the length is always 1. */
6127:
6128: ONE_CHAR:
6129: previous = code;
6130: *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARNC : OP_CHAR;
6131: for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
6132:
6133: /* Remember if \r or \n were seen */
6134:
6135: if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)
6136: cd->external_flags |= PCRE_HASCRORLF;
6137:
6138: /* Set the first and required bytes appropriately. If no previous first
6139: byte, set it from this character, but revert to none on a zero repeat.
6140: Otherwise, leave the firstbyte value alone, and don't change it on a zero
6141: repeat. */
6142:
6143: if (firstbyte == REQ_UNSET)
6144: {
6145: zerofirstbyte = REQ_NONE;
6146: zeroreqbyte = reqbyte;
6147:
6148: /* If the character is more than one byte long, we can set firstbyte
6149: only if it is not to be matched caselessly. */
6150:
6151: if (mclength == 1 || req_caseopt == 0)
6152: {
6153: firstbyte = mcbuffer[0] | req_caseopt;
6154: if (mclength != 1) reqbyte = code[-1] | cd->req_varyopt;
6155: }
6156: else firstbyte = reqbyte = REQ_NONE;
6157: }
6158:
6159: /* firstbyte was previously set; we can set reqbyte only the length is
6160: 1 or the matching is caseful. */
6161:
6162: else
6163: {
6164: zerofirstbyte = firstbyte;
6165: zeroreqbyte = reqbyte;
6166: if (mclength == 1 || req_caseopt == 0)
6167: reqbyte = code[-1] | req_caseopt | cd->req_varyopt;
6168: }
6169:
6170: break; /* End of literal character handling */
6171: }
6172: } /* end of big loop */
6173:
6174:
6175: /* Control never reaches here by falling through, only by a goto for all the
6176: error states. Pass back the position in the pattern so that it can be displayed
6177: to the user for diagnosing the error. */
6178:
6179: FAILED:
6180: *ptrptr = ptr;
6181: return FALSE;
6182: }
6183:
6184:
6185:
6186:
6187: /*************************************************
6188: * Compile sequence of alternatives *
6189: *************************************************/
6190:
6191: /* On entry, ptr is pointing past the bracket character, but on return it
6192: points to the closing bracket, or vertical bar, or end of string. The code
6193: variable is pointing at the byte into which the BRA operator has been stored.
6194: If the ims options are changed at the start (for a (?ims: group) or during any
6195: branch, we need to insert an OP_OPT item at the start of every following branch
6196: to ensure they get set correctly at run time, and also pass the new options
6197: into every subsequent branch compile.
6198:
6199: This function is used during the pre-compile phase when we are trying to find
6200: out the amount of memory needed, as well as during the real compile phase. The
6201: value of lengthptr distinguishes the two phases.
6202:
6203: Arguments:
6204: options option bits, including any changes for this subpattern
6205: oldims previous settings of ims option bits
6206: codeptr -> the address of the current code pointer
6207: ptrptr -> the address of the current pattern pointer
6208: errorcodeptr -> pointer to error code variable
6209: lookbehind TRUE if this is a lookbehind assertion
6210: reset_bracount TRUE to reset the count for each branch
6211: skipbytes skip this many bytes at start (for brackets and OP_COND)
6212: firstbyteptr place to put the first required character, or a negative number
6213: reqbyteptr place to put the last required character, or a negative number
6214: bcptr pointer to the chain of currently open branches
6215: cd points to the data block with tables pointers etc.
6216: lengthptr NULL during the real compile phase
6217: points to length accumulator during pre-compile phase
6218:
6219: Returns: TRUE on success
6220: */
6221:
6222: static BOOL
6223: compile_regex(int options, int oldims, uschar **codeptr, const uschar **ptrptr,
6224: int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
6225: int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr, compile_data *cd,
6226: int *lengthptr)
6227: {
6228: const uschar *ptr = *ptrptr;
6229: uschar *code = *codeptr;
6230: uschar *last_branch = code;
6231: uschar *start_bracket = code;
6232: uschar *reverse_count = NULL;
6233: open_capitem capitem;
6234: int capnumber = 0;
6235: int firstbyte, reqbyte;
6236: int branchfirstbyte, branchreqbyte;
6237: int length;
6238: int orig_bracount;
6239: int max_bracount;
6240: int old_external_options = cd->external_options;
6241: branch_chain bc;
6242:
6243: bc.outer = bcptr;
6244: bc.current_branch = code;
6245:
6246: firstbyte = reqbyte = REQ_UNSET;
6247:
6248: /* Accumulate the length for use in the pre-compile phase. Start with the
6249: length of the BRA and KET and any extra bytes that are required at the
6250: beginning. We accumulate in a local variable to save frequent testing of
6251: lenthptr for NULL. We cannot do this by looking at the value of code at the
6252: start and end of each alternative, because compiled items are discarded during
6253: the pre-compile phase so that the work space is not exceeded. */
6254:
6255: length = 2 + 2*LINK_SIZE + skipbytes;
6256:
6257: /* WARNING: If the above line is changed for any reason, you must also change
6258: the code that abstracts option settings at the start of the pattern and makes
6259: them global. It tests the value of length for (2 + 2*LINK_SIZE) in the
6260: pre-compile phase to find out whether anything has yet been compiled or not. */
6261:
6262: /* If this is a capturing subpattern, add to the chain of open capturing items
6263: so that we can detect them if (*ACCEPT) is encountered. This is also used to
6264: detect groups that contain recursive back references to themselves. */
6265:
6266: if (*code == OP_CBRA)
6267: {
6268: capnumber = GET2(code, 1 + LINK_SIZE);
6269: capitem.number = capnumber;
6270: capitem.next = cd->open_caps;
6271: capitem.flag = FALSE;
6272: cd->open_caps = &capitem;
6273: }
6274:
6275: /* Offset is set zero to mark that this bracket is still open */
6276:
6277: PUT(code, 1, 0);
6278: code += 1 + LINK_SIZE + skipbytes;
6279:
6280: /* Loop for each alternative branch */
6281:
6282: orig_bracount = max_bracount = cd->bracount;
6283: for (;;)
6284: {
6285: /* For a (?| group, reset the capturing bracket count so that each branch
6286: uses the same numbers. */
6287:
6288: if (reset_bracount) cd->bracount = orig_bracount;
6289:
6290: /* Handle a change of ims options at the start of the branch */
6291:
6292: if ((options & PCRE_IMS) != oldims)
6293: {
6294: *code++ = OP_OPT;
6295: *code++ = options & PCRE_IMS;
6296: length += 2;
6297: }
6298:
6299: /* Set up dummy OP_REVERSE if lookbehind assertion */
6300:
6301: if (lookbehind)
6302: {
6303: *code++ = OP_REVERSE;
6304: reverse_count = code;
6305: PUTINC(code, 0, 0);
6306: length += 1 + LINK_SIZE;
6307: }
6308:
6309: /* Now compile the branch; in the pre-compile phase its length gets added
6310: into the length. */
6311:
6312: if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,
6313: &branchreqbyte, &bc, cd, (lengthptr == NULL)? NULL : &length))
6314: {
6315: *ptrptr = ptr;
6316: return FALSE;
6317: }
6318:
6319: /* If the external options have changed during this branch, it means that we
6320: are at the top level, and a leading option setting has been encountered. We
6321: need to re-set the original option values to take account of this so that,
6322: during the pre-compile phase, we know to allow for a re-set at the start of
6323: subsequent branches. */
6324:
6325: if (old_external_options != cd->external_options)
6326: oldims = cd->external_options & PCRE_IMS;
6327:
6328: /* Keep the highest bracket count in case (?| was used and some branch
6329: has fewer than the rest. */
6330:
6331: if (cd->bracount > max_bracount) max_bracount = cd->bracount;
6332:
6333: /* In the real compile phase, there is some post-processing to be done. */
6334:
6335: if (lengthptr == NULL)
6336: {
6337: /* If this is the first branch, the firstbyte and reqbyte values for the
6338: branch become the values for the regex. */
6339:
6340: if (*last_branch != OP_ALT)
6341: {
6342: firstbyte = branchfirstbyte;
6343: reqbyte = branchreqbyte;
6344: }
6345:
6346: /* If this is not the first branch, the first char and reqbyte have to
6347: match the values from all the previous branches, except that if the
6348: previous value for reqbyte didn't have REQ_VARY set, it can still match,
6349: and we set REQ_VARY for the regex. */
6350:
6351: else
6352: {
6353: /* If we previously had a firstbyte, but it doesn't match the new branch,
6354: we have to abandon the firstbyte for the regex, but if there was
6355: previously no reqbyte, it takes on the value of the old firstbyte. */
6356:
6357: if (firstbyte >= 0 && firstbyte != branchfirstbyte)
6358: {
6359: if (reqbyte < 0) reqbyte = firstbyte;
6360: firstbyte = REQ_NONE;
6361: }
6362:
6363: /* If we (now or from before) have no firstbyte, a firstbyte from the
6364: branch becomes a reqbyte if there isn't a branch reqbyte. */
6365:
6366: if (firstbyte < 0 && branchfirstbyte >= 0 && branchreqbyte < 0)
6367: branchreqbyte = branchfirstbyte;
6368:
6369: /* Now ensure that the reqbytes match */
6370:
6371: if ((reqbyte & ~REQ_VARY) != (branchreqbyte & ~REQ_VARY))
6372: reqbyte = REQ_NONE;
6373: else reqbyte |= branchreqbyte; /* To "or" REQ_VARY */
6374: }
6375:
6376: /* If lookbehind, check that this branch matches a fixed-length string, and
6377: put the length into the OP_REVERSE item. Temporarily mark the end of the
6378: branch with OP_END. If the branch contains OP_RECURSE, the result is -3
6379: because there may be forward references that we can't check here. Set a
6380: flag to cause another lookbehind check at the end. Why not do it all at the
6381: end? Because common, erroneous checks are picked up here and the offset of
6382: the problem can be shown. */
6383:
6384: if (lookbehind)
6385: {
6386: int fixed_length;
6387: *code = OP_END;
6388: fixed_length = find_fixedlength(last_branch, options, FALSE, cd);
6389: DPRINTF(("fixed length = %d\n", fixed_length));
6390: if (fixed_length == -3)
6391: {
6392: cd->check_lookbehind = TRUE;
6393: }
6394: else if (fixed_length < 0)
6395: {
6396: *errorcodeptr = (fixed_length == -2)? ERR36 : ERR25;
6397: *ptrptr = ptr;
6398: return FALSE;
6399: }
6400: else { PUT(reverse_count, 0, fixed_length); }
6401: }
6402: }
6403:
6404: /* Reached end of expression, either ')' or end of pattern. In the real
6405: compile phase, go back through the alternative branches and reverse the chain
6406: of offsets, with the field in the BRA item now becoming an offset to the
6407: first alternative. If there are no alternatives, it points to the end of the
6408: group. The length in the terminating ket is always the length of the whole
6409: bracketed item. If any of the ims options were changed inside the group,
6410: compile a resetting op-code following, except at the very end of the pattern.
6411: Return leaving the pointer at the terminating char. */
6412:
6413: if (*ptr != CHAR_VERTICAL_LINE)
6414: {
6415: if (lengthptr == NULL)
6416: {
6417: int branch_length = (int)(code - last_branch);
6418: do
6419: {
6420: int prev_length = GET(last_branch, 1);
6421: PUT(last_branch, 1, branch_length);
6422: branch_length = prev_length;
6423: last_branch -= branch_length;
6424: }
6425: while (branch_length > 0);
6426: }
6427:
6428: /* Fill in the ket */
6429:
6430: *code = OP_KET;
6431: PUT(code, 1, (int)(code - start_bracket));
6432: code += 1 + LINK_SIZE;
6433:
6434: /* If it was a capturing subpattern, check to see if it contained any
6435: recursive back references. If so, we must wrap it in atomic brackets.
6436: In any event, remove the block from the chain. */
6437:
6438: if (capnumber > 0)
6439: {
6440: if (cd->open_caps->flag)
6441: {
6442: memmove(start_bracket + 1 + LINK_SIZE, start_bracket,
6443: code - start_bracket);
6444: *start_bracket = OP_ONCE;
6445: code += 1 + LINK_SIZE;
6446: PUT(start_bracket, 1, (int)(code - start_bracket));
6447: *code = OP_KET;
6448: PUT(code, 1, (int)(code - start_bracket));
6449: code += 1 + LINK_SIZE;
6450: length += 2 + 2*LINK_SIZE;
6451: }
6452: cd->open_caps = cd->open_caps->next;
6453: }
6454:
6455: /* Reset options if needed. */
6456:
6457: if ((options & PCRE_IMS) != oldims && *ptr == CHAR_RIGHT_PARENTHESIS)
6458: {
6459: *code++ = OP_OPT;
6460: *code++ = oldims;
6461: length += 2;
6462: }
6463:
6464: /* Retain the highest bracket number, in case resetting was used. */
6465:
6466: cd->bracount = max_bracount;
6467:
6468: /* Set values to pass back */
6469:
6470: *codeptr = code;
6471: *ptrptr = ptr;
6472: *firstbyteptr = firstbyte;
6473: *reqbyteptr = reqbyte;
6474: if (lengthptr != NULL)
6475: {
6476: if (OFLOW_MAX - *lengthptr < length)
6477: {
6478: *errorcodeptr = ERR20;
6479: return FALSE;
6480: }
6481: *lengthptr += length;
6482: }
6483: return TRUE;
6484: }
6485:
6486: /* Another branch follows. In the pre-compile phase, we can move the code
6487: pointer back to where it was for the start of the first branch. (That is,
6488: pretend that each branch is the only one.)
6489:
6490: In the real compile phase, insert an ALT node. Its length field points back
6491: to the previous branch while the bracket remains open. At the end the chain
6492: is reversed. It's done like this so that the start of the bracket has a
6493: zero offset until it is closed, making it possible to detect recursion. */
6494:
6495: if (lengthptr != NULL)
6496: {
6497: code = *codeptr + 1 + LINK_SIZE + skipbytes;
6498: length += 1 + LINK_SIZE;
6499: }
6500: else
6501: {
6502: *code = OP_ALT;
6503: PUT(code, 1, (int)(code - last_branch));
6504: bc.current_branch = last_branch = code;
6505: code += 1 + LINK_SIZE;
6506: }
6507:
6508: ptr++;
6509: }
6510: /* Control never reaches here */
6511: }
6512:
6513:
6514:
6515:
6516: /*************************************************
6517: * Check for anchored expression *
6518: *************************************************/
6519:
6520: /* Try to find out if this is an anchored regular expression. Consider each
6521: alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
6522: all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
6523: it's anchored. However, if this is a multiline pattern, then only OP_SOD
6524: counts, since OP_CIRC can match in the middle.
6525:
6526: We can also consider a regex to be anchored if OP_SOM starts all its branches.
6527: This is the code for \G, which means "match at start of match position, taking
6528: into account the match offset".
6529:
6530: A branch is also implicitly anchored if it starts with .* and DOTALL is set,
6531: because that will try the rest of the pattern at all possible matching points,
6532: so there is no point trying again.... er ....
6533:
6534: .... except when the .* appears inside capturing parentheses, and there is a
6535: subsequent back reference to those parentheses. We haven't enough information
6536: to catch that case precisely.
6537:
6538: At first, the best we could do was to detect when .* was in capturing brackets
6539: and the highest back reference was greater than or equal to that level.
6540: However, by keeping a bitmap of the first 31 back references, we can catch some
6541: of the more common cases more precisely.
6542:
6543: Arguments:
6544: code points to start of expression (the bracket)
6545: options points to the options setting
6546: bracket_map a bitmap of which brackets we are inside while testing; this
6547: handles up to substring 31; after that we just have to take
6548: the less precise approach
6549: backref_map the back reference bitmap
6550:
6551: Returns: TRUE or FALSE
6552: */
6553:
6554: static BOOL
6555: is_anchored(register const uschar *code, int *options, unsigned int bracket_map,
6556: unsigned int backref_map)
6557: {
6558: do {
6559: const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
6560: options, PCRE_MULTILINE, FALSE);
6561: register int op = *scode;
6562:
6563: /* Non-capturing brackets */
6564:
6565: if (op == OP_BRA)
6566: {
6567: if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
6568: }
6569:
6570: /* Capturing brackets */
6571:
6572: else if (op == OP_CBRA)
6573: {
6574: int n = GET2(scode, 1+LINK_SIZE);
6575: int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
6576: if (!is_anchored(scode, options, new_map, backref_map)) return FALSE;
6577: }
6578:
6579: /* Other brackets */
6580:
6581: else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
6582: {
6583: if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
6584: }
6585:
6586: /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and
6587: it isn't in brackets that are or may be referenced. */
6588:
6589: else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
6590: op == OP_TYPEPOSSTAR))
6591: {
6592: if (scode[1] != OP_ALLANY || (bracket_map & backref_map) != 0)
6593: return FALSE;
6594: }
6595:
6596: /* Check for explicit anchoring */
6597:
6598: else if (op != OP_SOD && op != OP_SOM &&
6599: ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
6600: return FALSE;
6601: code += GET(code, 1);
6602: }
6603: while (*code == OP_ALT); /* Loop for each alternative */
6604: return TRUE;
6605: }
6606:
6607:
6608:
6609: /*************************************************
6610: * Check for starting with ^ or .* *
6611: *************************************************/
6612:
6613: /* This is called to find out if every branch starts with ^ or .* so that
6614: "first char" processing can be done to speed things up in multiline
6615: matching and for non-DOTALL patterns that start with .* (which must start at
6616: the beginning or after \n). As in the case of is_anchored() (see above), we
6617: have to take account of back references to capturing brackets that contain .*
6618: because in that case we can't make the assumption.
6619:
6620: Arguments:
6621: code points to start of expression (the bracket)
6622: bracket_map a bitmap of which brackets we are inside while testing; this
6623: handles up to substring 31; after that we just have to take
6624: the less precise approach
6625: backref_map the back reference bitmap
6626:
6627: Returns: TRUE or FALSE
6628: */
6629:
6630: static BOOL
6631: is_startline(const uschar *code, unsigned int bracket_map,
6632: unsigned int backref_map)
6633: {
6634: do {
6635: const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
6636: NULL, 0, FALSE);
6637: register int op = *scode;
6638:
6639: /* If we are at the start of a conditional assertion group, *both* the
6640: conditional assertion *and* what follows the condition must satisfy the test
6641: for start of line. Other kinds of condition fail. Note that there may be an
6642: auto-callout at the start of a condition. */
6643:
6644: if (op == OP_COND)
6645: {
6646: scode += 1 + LINK_SIZE;
6647: if (*scode == OP_CALLOUT) scode += _pcre_OP_lengths[OP_CALLOUT];
6648: switch (*scode)
6649: {
6650: case OP_CREF:
6651: case OP_NCREF:
6652: case OP_RREF:
6653: case OP_NRREF:
6654: case OP_DEF:
6655: return FALSE;
6656:
6657: default: /* Assertion */
6658: if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
6659: do scode += GET(scode, 1); while (*scode == OP_ALT);
6660: scode += 1 + LINK_SIZE;
6661: break;
6662: }
6663: scode = first_significant_code(scode, NULL, 0, FALSE);
6664: op = *scode;
6665: }
6666:
6667: /* Non-capturing brackets */
6668:
6669: if (op == OP_BRA)
6670: {
6671: if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
6672: }
6673:
6674: /* Capturing brackets */
6675:
6676: else if (op == OP_CBRA)
6677: {
6678: int n = GET2(scode, 1+LINK_SIZE);
6679: int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
6680: if (!is_startline(scode, new_map, backref_map)) return FALSE;
6681: }
6682:
6683: /* Other brackets */
6684:
6685: else if (op == OP_ASSERT || op == OP_ONCE)
6686: {
6687: if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
6688: }
6689:
6690: /* .* means "start at start or after \n" if it isn't in brackets that
6691: may be referenced. */
6692:
6693: else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)
6694: {
6695: if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
6696: }
6697:
6698: /* Check for explicit circumflex */
6699:
6700: else if (op != OP_CIRC) return FALSE;
6701:
6702: /* Move on to the next alternative */
6703:
6704: code += GET(code, 1);
6705: }
6706: while (*code == OP_ALT); /* Loop for each alternative */
6707: return TRUE;
6708: }
6709:
6710:
6711:
6712: /*************************************************
6713: * Check for asserted fixed first char *
6714: *************************************************/
6715:
6716: /* During compilation, the "first char" settings from forward assertions are
6717: discarded, because they can cause conflicts with actual literals that follow.
6718: However, if we end up without a first char setting for an unanchored pattern,
6719: it is worth scanning the regex to see if there is an initial asserted first
6720: char. If all branches start with the same asserted char, or with a bracket all
6721: of whose alternatives start with the same asserted char (recurse ad lib), then
6722: we return that char, otherwise -1.
6723:
6724: Arguments:
6725: code points to start of expression (the bracket)
6726: options pointer to the options (used to check casing changes)
6727: inassert TRUE if in an assertion
6728:
6729: Returns: -1 or the fixed first char
6730: */
6731:
6732: static int
6733: find_firstassertedchar(const uschar *code, int *options, BOOL inassert)
6734: {
6735: register int c = -1;
6736: do {
6737: int d;
6738: const uschar *scode =
6739: first_significant_code(code + 1+LINK_SIZE, options, PCRE_CASELESS, TRUE);
6740: register int op = *scode;
6741:
6742: switch(op)
6743: {
6744: default:
6745: return -1;
6746:
6747: case OP_BRA:
6748: case OP_CBRA:
6749: case OP_ASSERT:
6750: case OP_ONCE:
6751: case OP_COND:
6752: if ((d = find_firstassertedchar(scode, options, op == OP_ASSERT)) < 0)
6753: return -1;
6754: if (c < 0) c = d; else if (c != d) return -1;
6755: break;
6756:
6757: case OP_EXACT: /* Fall through */
6758: scode += 2;
6759:
6760: case OP_CHAR:
6761: case OP_CHARNC:
6762: case OP_PLUS:
6763: case OP_MINPLUS:
6764: case OP_POSPLUS:
6765: if (!inassert) return -1;
6766: if (c < 0)
6767: {
6768: c = scode[1];
6769: if ((*options & PCRE_CASELESS) != 0) c |= REQ_CASELESS;
6770: }
6771: else if (c != scode[1]) return -1;
6772: break;
6773: }
6774:
6775: code += GET(code, 1);
6776: }
6777: while (*code == OP_ALT);
6778: return c;
6779: }
6780:
6781:
6782:
6783: /*************************************************
6784: * Compile a Regular Expression *
6785: *************************************************/
6786:
6787: /* This function takes a string and returns a pointer to a block of store
6788: holding a compiled version of the expression. The original API for this
6789: function had no error code return variable; it is retained for backwards
6790: compatibility. The new function is given a new name.
6791:
6792: Arguments:
6793: pattern the regular expression
6794: options various option bits
6795: errorcodeptr pointer to error code variable (pcre_compile2() only)
6796: can be NULL if you don't want a code value
6797: errorptr pointer to pointer to error text
6798: erroroffset ptr offset in pattern where error was detected
6799: tables pointer to character tables or NULL
6800:
6801: Returns: pointer to compiled data block, or NULL on error,
6802: with errorptr and erroroffset set
6803: */
6804:
6805: PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
6806: pcre_compile(const char *pattern, int options, const char **errorptr,
6807: int *erroroffset, const unsigned char *tables)
6808: {
6809: return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
6810: }
6811:
6812:
6813: PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
6814: pcre_compile2(const char *pattern, int options, int *errorcodeptr,
6815: const char **errorptr, int *erroroffset, const unsigned char *tables)
6816: {
6817: real_pcre *re;
6818: int length = 1; /* For final END opcode */
6819: int firstbyte, reqbyte, newline;
6820: int errorcode = 0;
6821: int skipatstart = 0;
6822: BOOL utf8;
6823: size_t size;
6824: uschar *code;
6825: const uschar *codestart;
6826: const uschar *ptr;
6827: compile_data compile_block;
6828: compile_data *cd = &compile_block;
6829:
6830: /* This space is used for "compiling" into during the first phase, when we are
6831: computing the amount of memory that is needed. Compiled items are thrown away
6832: as soon as possible, so that a fairly large buffer should be sufficient for
6833: this purpose. The same space is used in the second phase for remembering where
6834: to fill in forward references to subpatterns. */
6835:
6836: uschar cworkspace[COMPILE_WORK_SIZE];
6837:
6838: /* Set this early so that early errors get offset 0. */
6839:
6840: ptr = (const uschar *)pattern;
6841:
6842: /* We can't pass back an error message if errorptr is NULL; I guess the best we
6843: can do is just return NULL, but we can set a code value if there is a code
6844: pointer. */
6845:
6846: if (errorptr == NULL)
6847: {
6848: if (errorcodeptr != NULL) *errorcodeptr = 99;
6849: return NULL;
6850: }
6851:
6852: *errorptr = NULL;
6853: if (errorcodeptr != NULL) *errorcodeptr = ERR0;
6854:
6855: /* However, we can give a message for this error */
6856:
6857: if (erroroffset == NULL)
6858: {
6859: errorcode = ERR16;
6860: goto PCRE_EARLY_ERROR_RETURN2;
6861: }
6862:
6863: *erroroffset = 0;
6864:
6865: /* Set up pointers to the individual character tables */
6866:
6867: if (tables == NULL) tables = _pcre_default_tables;
6868: cd->lcc = tables + lcc_offset;
6869: cd->fcc = tables + fcc_offset;
6870: cd->cbits = tables + cbits_offset;
6871: cd->ctypes = tables + ctypes_offset;
6872:
6873: /* Check that all undefined public option bits are zero */
6874:
6875: if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0)
6876: {
6877: errorcode = ERR17;
6878: goto PCRE_EARLY_ERROR_RETURN;
6879: }
6880:
6881: /* Check for global one-time settings at the start of the pattern, and remember
6882: the offset for later. */
6883:
6884: while (ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&
6885: ptr[skipatstart+1] == CHAR_ASTERISK)
6886: {
6887: int newnl = 0;
6888: int newbsr = 0;
6889:
6890: if (strncmp((char *)(ptr+skipatstart+2), STRING_UTF8_RIGHTPAR, 5) == 0)
6891: { skipatstart += 7; options |= PCRE_UTF8; continue; }
6892: else if (strncmp((char *)(ptr+skipatstart+2), STRING_UCP_RIGHTPAR, 4) == 0)
6893: { skipatstart += 6; options |= PCRE_UCP; continue; }
6894: else if (strncmp((char *)(ptr+skipatstart+2), STRING_NO_START_OPT_RIGHTPAR, 13) == 0)
6895: { skipatstart += 15; options |= PCRE_NO_START_OPTIMIZE; continue; }
6896:
6897: if (strncmp((char *)(ptr+skipatstart+2), STRING_CR_RIGHTPAR, 3) == 0)
6898: { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }
6899: else if (strncmp((char *)(ptr+skipatstart+2), STRING_LF_RIGHTPAR, 3) == 0)
6900: { skipatstart += 5; newnl = PCRE_NEWLINE_LF; }
6901: else if (strncmp((char *)(ptr+skipatstart+2), STRING_CRLF_RIGHTPAR, 5) == 0)
6902: { skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }
6903: else if (strncmp((char *)(ptr+skipatstart+2), STRING_ANY_RIGHTPAR, 4) == 0)
6904: { skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }
6905: else if (strncmp((char *)(ptr+skipatstart+2), STRING_ANYCRLF_RIGHTPAR, 8) == 0)
6906: { skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }
6907:
6908: else if (strncmp((char *)(ptr+skipatstart+2), STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)
6909: { skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }
6910: else if (strncmp((char *)(ptr+skipatstart+2), STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)
6911: { skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }
6912:
6913: if (newnl != 0)
6914: options = (options & ~PCRE_NEWLINE_BITS) | newnl;
6915: else if (newbsr != 0)
6916: options = (options & ~(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) | newbsr;
6917: else break;
6918: }
6919:
6920: utf8 = (options & PCRE_UTF8) != 0;
6921:
6922: /* Can't support UTF8 unless PCRE has been compiled to include the code. */
6923:
6924: #ifdef SUPPORT_UTF8
6925: if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
6926: (*erroroffset = _pcre_valid_utf8((USPTR)pattern, -1)) >= 0)
6927: {
6928: errorcode = ERR44;
6929: goto PCRE_EARLY_ERROR_RETURN2;
6930: }
6931: #else
6932: if (utf8)
6933: {
6934: errorcode = ERR32;
6935: goto PCRE_EARLY_ERROR_RETURN;
6936: }
6937: #endif
6938:
6939: /* Can't support UCP unless PCRE has been compiled to include the code. */
6940:
6941: #ifndef SUPPORT_UCP
6942: if ((options & PCRE_UCP) != 0)
6943: {
6944: errorcode = ERR67;
6945: goto PCRE_EARLY_ERROR_RETURN;
6946: }
6947: #endif
6948:
6949: /* Check validity of \R options. */
6950:
6951: switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
6952: {
6953: case 0:
6954: case PCRE_BSR_ANYCRLF:
6955: case PCRE_BSR_UNICODE:
6956: break;
6957: default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;
6958: }
6959:
6960: /* Handle different types of newline. The three bits give seven cases. The
6961: current code allows for fixed one- or two-byte sequences, plus "any" and
6962: "anycrlf". */
6963:
6964: switch (options & PCRE_NEWLINE_BITS)
6965: {
6966: case 0: newline = NEWLINE; break; /* Build-time default */
6967: case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
6968: case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
6969: case PCRE_NEWLINE_CR+
6970: PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
6971: case PCRE_NEWLINE_ANY: newline = -1; break;
6972: case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
6973: default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;
6974: }
6975:
6976: if (newline == -2)
6977: {
6978: cd->nltype = NLTYPE_ANYCRLF;
6979: }
6980: else if (newline < 0)
6981: {
6982: cd->nltype = NLTYPE_ANY;
6983: }
6984: else
6985: {
6986: cd->nltype = NLTYPE_FIXED;
6987: if (newline > 255)
6988: {
6989: cd->nllen = 2;
6990: cd->nl[0] = (newline >> 8) & 255;
6991: cd->nl[1] = newline & 255;
6992: }
6993: else
6994: {
6995: cd->nllen = 1;
6996: cd->nl[0] = newline;
6997: }
6998: }
6999:
7000: /* Maximum back reference and backref bitmap. The bitmap records up to 31 back
7001: references to help in deciding whether (.*) can be treated as anchored or not.
7002: */
7003:
7004: cd->top_backref = 0;
7005: cd->backref_map = 0;
7006:
7007: /* Reflect pattern for debugging output */
7008:
7009: DPRINTF(("------------------------------------------------------------------\n"));
7010: DPRINTF(("%s\n", pattern));
7011:
7012: /* Pretend to compile the pattern while actually just accumulating the length
7013: of memory required. This behaviour is triggered by passing a non-NULL final
7014: argument to compile_regex(). We pass a block of workspace (cworkspace) for it
7015: to compile parts of the pattern into; the compiled code is discarded when it is
7016: no longer needed, so hopefully this workspace will never overflow, though there
7017: is a test for its doing so. */
7018:
7019: cd->bracount = cd->final_bracount = 0;
7020: cd->names_found = 0;
7021: cd->name_entry_size = 0;
7022: cd->name_table = NULL;
7023: cd->start_workspace = cworkspace;
7024: cd->start_code = cworkspace;
7025: cd->hwm = cworkspace;
7026: cd->start_pattern = (const uschar *)pattern;
7027: cd->end_pattern = (const uschar *)(pattern + strlen(pattern));
7028: cd->req_varyopt = 0;
7029: cd->external_options = options;
7030: cd->external_flags = 0;
7031: cd->open_caps = NULL;
7032:
7033: /* Now do the pre-compile. On error, errorcode will be set non-zero, so we
7034: don't need to look at the result of the function here. The initial options have
7035: been put into the cd block so that they can be changed if an option setting is
7036: found within the regex right at the beginning. Bringing initial option settings
7037: outside can help speed up starting point checks. */
7038:
7039: ptr += skipatstart;
7040: code = cworkspace;
7041: *code = OP_BRA;
7042: (void)compile_regex(cd->external_options, cd->external_options & PCRE_IMS,
7043: &code, &ptr, &errorcode, FALSE, FALSE, 0, &firstbyte, &reqbyte, NULL, cd,
7044: &length);
7045: if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;
7046:
7047: DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
7048: cd->hwm - cworkspace));
7049:
7050: if (length > MAX_PATTERN_SIZE)
7051: {
7052: errorcode = ERR20;
7053: goto PCRE_EARLY_ERROR_RETURN;
7054: }
7055:
7056: /* Compute the size of data block needed and get it, either from malloc or
7057: externally provided function. Integer overflow should no longer be possible
7058: because nowadays we limit the maximum value of cd->names_found and
7059: cd->name_entry_size. */
7060:
7061: size = length + sizeof(real_pcre) + cd->names_found * (cd->name_entry_size + 3);
7062: re = (real_pcre *)(pcre_malloc)(size);
7063:
7064: if (re == NULL)
7065: {
7066: errorcode = ERR21;
7067: goto PCRE_EARLY_ERROR_RETURN;
7068: }
7069:
7070: /* Put in the magic number, and save the sizes, initial options, internal
7071: flags, and character table pointer. NULL is used for the default character
7072: tables. The nullpad field is at the end; it's there to help in the case when a
7073: regex compiled on a system with 4-byte pointers is run on another with 8-byte
7074: pointers. */
7075:
7076: re->magic_number = MAGIC_NUMBER;
7077: re->size = (int)size;
7078: re->options = cd->external_options;
7079: re->flags = cd->external_flags;
7080: re->dummy1 = 0;
7081: re->first_byte = 0;
7082: re->req_byte = 0;
7083: re->name_table_offset = sizeof(real_pcre);
7084: re->name_entry_size = cd->name_entry_size;
7085: re->name_count = cd->names_found;
7086: re->ref_count = 0;
7087: re->tables = (tables == _pcre_default_tables)? NULL : tables;
7088: re->nullpad = NULL;
7089:
7090: /* The starting points of the name/number translation table and of the code are
7091: passed around in the compile data block. The start/end pattern and initial
7092: options are already set from the pre-compile phase, as is the name_entry_size
7093: field. Reset the bracket count and the names_found field. Also reset the hwm
7094: field; this time it's used for remembering forward references to subpatterns.
7095: */
7096:
7097: cd->final_bracount = cd->bracount; /* Save for checking forward references */
7098: cd->bracount = 0;
7099: cd->names_found = 0;
7100: cd->name_table = (uschar *)re + re->name_table_offset;
7101: codestart = cd->name_table + re->name_entry_size * re->name_count;
7102: cd->start_code = codestart;
7103: cd->hwm = cworkspace;
7104: cd->req_varyopt = 0;
7105: cd->had_accept = FALSE;
7106: cd->check_lookbehind = FALSE;
7107: cd->open_caps = NULL;
7108:
7109: /* Set up a starting, non-extracting bracket, then compile the expression. On
7110: error, errorcode will be set non-zero, so we don't need to look at the result
7111: of the function here. */
7112:
7113: ptr = (const uschar *)pattern + skipatstart;
7114: code = (uschar *)codestart;
7115: *code = OP_BRA;
7116: (void)compile_regex(re->options, re->options & PCRE_IMS, &code, &ptr,
7117: &errorcode, FALSE, FALSE, 0, &firstbyte, &reqbyte, NULL, cd, NULL);
7118: re->top_bracket = cd->bracount;
7119: re->top_backref = cd->top_backref;
7120: re->flags = cd->external_flags;
7121:
7122: if (cd->had_accept) reqbyte = -1; /* Must disable after (*ACCEPT) */
7123:
7124: /* If not reached end of pattern on success, there's an excess bracket. */
7125:
7126: if (errorcode == 0 && *ptr != 0) errorcode = ERR22;
7127:
7128: /* Fill in the terminating state and check for disastrous overflow, but
7129: if debugging, leave the test till after things are printed out. */
7130:
7131: *code++ = OP_END;
7132:
7133: #ifndef PCRE_DEBUG
7134: if (code - codestart > length) errorcode = ERR23;
7135: #endif
7136:
7137: /* Fill in any forward references that are required. */
7138:
7139: while (errorcode == 0 && cd->hwm > cworkspace)
7140: {
7141: int offset, recno;
7142: const uschar *groupptr;
7143: cd->hwm -= LINK_SIZE;
7144: offset = GET(cd->hwm, 0);
7145: recno = GET(codestart, offset);
7146: groupptr = _pcre_find_bracket(codestart, utf8, recno);
7147: if (groupptr == NULL) errorcode = ERR53;
7148: else PUT(((uschar *)codestart), offset, (int)(groupptr - codestart));
7149: }
7150:
7151: /* Give an error if there's back reference to a non-existent capturing
7152: subpattern. */
7153:
7154: if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;
7155:
7156: /* If there were any lookbehind assertions that contained OP_RECURSE
7157: (recursions or subroutine calls), a flag is set for them to be checked here,
7158: because they may contain forward references. Actual recursions can't be fixed
7159: length, but subroutine calls can. It is done like this so that those without
7160: OP_RECURSE that are not fixed length get a diagnosic with a useful offset. The
7161: exceptional ones forgo this. We scan the pattern to check that they are fixed
7162: length, and set their lengths. */
7163:
7164: if (cd->check_lookbehind)
7165: {
7166: uschar *cc = (uschar *)codestart;
7167:
7168: /* Loop, searching for OP_REVERSE items, and process those that do not have
7169: their length set. (Actually, it will also re-process any that have a length
7170: of zero, but that is a pathological case, and it does no harm.) When we find
7171: one, we temporarily terminate the branch it is in while we scan it. */
7172:
7173: for (cc = (uschar *)_pcre_find_bracket(codestart, utf8, -1);
7174: cc != NULL;
7175: cc = (uschar *)_pcre_find_bracket(cc, utf8, -1))
7176: {
7177: if (GET(cc, 1) == 0)
7178: {
7179: int fixed_length;
7180: uschar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
7181: int end_op = *be;
7182: *be = OP_END;
7183: fixed_length = find_fixedlength(cc, re->options, TRUE, cd);
7184: *be = end_op;
7185: DPRINTF(("fixed length = %d\n", fixed_length));
7186: if (fixed_length < 0)
7187: {
7188: errorcode = (fixed_length == -2)? ERR36 : ERR25;
7189: break;
7190: }
7191: PUT(cc, 1, fixed_length);
7192: }
7193: cc += 1 + LINK_SIZE;
7194: }
7195: }
7196:
7197: /* Failed to compile, or error while post-processing */
7198:
7199: if (errorcode != 0)
7200: {
7201: (pcre_free)(re);
7202: PCRE_EARLY_ERROR_RETURN:
7203: *erroroffset = (int)(ptr - (const uschar *)pattern);
7204: PCRE_EARLY_ERROR_RETURN2:
7205: *errorptr = find_error_text(errorcode);
7206: if (errorcodeptr != NULL) *errorcodeptr = errorcode;
7207: return NULL;
7208: }
7209:
7210: /* If the anchored option was not passed, set the flag if we can determine that
7211: the pattern is anchored by virtue of ^ characters or \A or anything else (such
7212: as starting with .* when DOTALL is set).
7213:
7214: Otherwise, if we know what the first byte has to be, save it, because that
7215: speeds up unanchored matches no end. If not, see if we can set the
7216: PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
7217: start with ^. and also when all branches start with .* for non-DOTALL matches.
7218: */
7219:
7220: if ((re->options & PCRE_ANCHORED) == 0)
7221: {
7222: int temp_options = re->options; /* May get changed during these scans */
7223: if (is_anchored(codestart, &temp_options, 0, cd->backref_map))
7224: re->options |= PCRE_ANCHORED;
7225: else
7226: {
7227: if (firstbyte < 0)
7228: firstbyte = find_firstassertedchar(codestart, &temp_options, FALSE);
7229: if (firstbyte >= 0) /* Remove caseless flag for non-caseable chars */
7230: {
7231: int ch = firstbyte & 255;
7232: re->first_byte = ((firstbyte & REQ_CASELESS) != 0 &&
7233: cd->fcc[ch] == ch)? ch : firstbyte;
7234: re->flags |= PCRE_FIRSTSET;
7235: }
7236: else if (is_startline(codestart, 0, cd->backref_map))
7237: re->flags |= PCRE_STARTLINE;
7238: }
7239: }
7240:
7241: /* For an anchored pattern, we use the "required byte" only if it follows a
7242: variable length item in the regex. Remove the caseless flag for non-caseable
7243: bytes. */
7244:
7245: if (reqbyte >= 0 &&
7246: ((re->options & PCRE_ANCHORED) == 0 || (reqbyte & REQ_VARY) != 0))
7247: {
7248: int ch = reqbyte & 255;
7249: re->req_byte = ((reqbyte & REQ_CASELESS) != 0 &&
7250: cd->fcc[ch] == ch)? (reqbyte & ~REQ_CASELESS) : reqbyte;
7251: re->flags |= PCRE_REQCHSET;
7252: }
7253:
7254: /* Print out the compiled data if debugging is enabled. This is never the
7255: case when building a production library. */
7256:
7257: #ifdef PCRE_DEBUG
7258: printf("Length = %d top_bracket = %d top_backref = %d\n",
7259: length, re->top_bracket, re->top_backref);
7260:
7261: printf("Options=%08x\n", re->options);
7262:
7263: if ((re->flags & PCRE_FIRSTSET) != 0)
7264: {
7265: int ch = re->first_byte & 255;
7266: const char *caseless = ((re->first_byte & REQ_CASELESS) == 0)?
7267: "" : " (caseless)";
7268: if (isprint(ch)) printf("First char = %c%s\n", ch, caseless);
7269: else printf("First char = \\x%02x%s\n", ch, caseless);
7270: }
7271:
7272: if ((re->flags & PCRE_REQCHSET) != 0)
7273: {
7274: int ch = re->req_byte & 255;
7275: const char *caseless = ((re->req_byte & REQ_CASELESS) == 0)?
7276: "" : " (caseless)";
7277: if (isprint(ch)) printf("Req char = %c%s\n", ch, caseless);
7278: else printf("Req char = \\x%02x%s\n", ch, caseless);
7279: }
7280:
7281: pcre_printint(re, stdout, TRUE);
7282:
7283: /* This check is done here in the debugging case so that the code that
7284: was compiled can be seen. */
7285:
7286: if (code - codestart > length)
7287: {
7288: (pcre_free)(re);
7289: *errorptr = find_error_text(ERR23);
7290: *erroroffset = ptr - (uschar *)pattern;
7291: if (errorcodeptr != NULL) *errorcodeptr = ERR23;
7292: return NULL;
7293: }
7294: #endif /* PCRE_DEBUG */
7295:
7296: return (pcre *)re;
7297: }
7298:
7299: /* End of pcre_compile.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre_compile.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / pcre / pcrelib