Annotation of win32/pcre/pcre_compile.c, revision 1.9
1.1 misha 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
1.9 ! moko 9: Copyright (c) 1997-2018 University of Cambridge
1.1 misha 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: #ifdef HAVE_CONFIG_H
46: #include "config.h"
47: #endif
48:
49: #define NLBLOCK cd /* Block containing newline information */
1.8 moko 50: #define PSSTART start_pattern /* Field containing pattern start */
51: #define PSEND end_pattern /* Field containing pattern end */
1.1 misha 52:
53: #include "pcre_internal.h"
54:
55:
1.7 misha 56: /* When PCRE_DEBUG is defined, we need the pcre(16|32)_printint() function, which
1.6 misha 57: is also used by pcretest. PCRE_DEBUG is not defined when building a production
58: library. We do not need to select pcre16_printint.c specially, because the
59: COMPILE_PCREx macro will already be appropriately set. */
1.1 misha 60:
1.4 misha 61: #ifdef PCRE_DEBUG
1.6 misha 62: /* pcre_printint.c should not include any headers */
63: #define PCRE_INCLUDED
64: #include "pcre_printint.c"
65: #undef PCRE_INCLUDED
1.1 misha 66: #endif
67:
68:
69: /* Macro for setting individual bits in class bitmaps. */
70:
1.7 misha 71: #define SETBIT(a,b) a[(b)/8] |= (1 << ((b)&7))
1.1 misha 72:
73: /* Maximum length value to check against when making sure that the integer that
74: holds the compiled pattern length does not overflow. We make it a bit less than
75: INT_MAX to allow for adding in group terminating bytes, so that we don't have
76: to check them every time. */
77:
78: #define OFLOW_MAX (INT_MAX - 20)
79:
1.7 misha 80: /* Definitions to allow mutual recursion */
81:
82: static int
83: add_list_to_class(pcre_uint8 *, pcre_uchar **, int, compile_data *,
84: const pcre_uint32 *, unsigned int);
85:
86: static BOOL
87: compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,
88: pcre_uint32 *, pcre_int32 *, pcre_uint32 *, pcre_int32 *, branch_chain *,
89: compile_data *, int *);
90:
91:
1.1 misha 92:
93: /*************************************************
94: * Code parameters and static tables *
95: *************************************************/
96:
97: /* This value specifies the size of stack workspace that is used during the
98: first pre-compile phase that determines how much memory is required. The regex
99: is partly compiled into this space, but the compiled parts are discarded as
100: soon as they can be, so that hopefully there will never be an overrun. The code
101: does, however, check for an overrun. The largest amount I've seen used is 218,
102: so this number is very generous.
103:
104: The same workspace is used during the second, actual compile phase for
105: remembering forward references to groups so that they can be filled in at the
106: end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE
1.6 misha 107: is 4 there is plenty of room for most patterns. However, the memory can get
108: filled up by repetitions of forward references, for example patterns like
109: /(?1){0,1999}(b)/, and one user did hit the limit. The code has been changed so
110: that the workspace is expanded using malloc() in this situation. The value
111: below is therefore a minimum, and we put a maximum on it for safety. The
112: minimum is now also defined in terms of LINK_SIZE so that the use of malloc()
113: kicks in at the same number of forward references in all cases. */
1.1 misha 114:
1.6 misha 115: #define COMPILE_WORK_SIZE (2048*LINK_SIZE)
116: #define COMPILE_WORK_SIZE_MAX (100*COMPILE_WORK_SIZE)
1.1 misha 117:
1.8 moko 118: /* This value determines the size of the initial vector that is used for
119: remembering named groups during the pre-compile. It is allocated on the stack,
120: but if it is too small, it is expanded using malloc(), in a similar way to the
121: workspace. The value is the number of slots in the list. */
122:
123: #define NAMED_GROUP_LIST_SIZE 20
124:
1.4 misha 125: /* The overrun tests check for a slightly smaller size so that they detect the
126: overrun before it actually does run off the end of the data block. */
127:
1.6 misha 128: #define WORK_SIZE_SAFETY_MARGIN (100)
1.4 misha 129:
1.6 misha 130: /* Private flags added to firstchar and reqchar. */
131:
1.7 misha 132: #define REQ_CASELESS (1 << 0) /* Indicates caselessness */
133: #define REQ_VARY (1 << 1) /* Reqchar followed non-literal item */
134: /* Negative values for the firstchar and reqchar flags */
135: #define REQ_UNSET (-2)
136: #define REQ_NONE (-1)
1.6 misha 137:
138: /* Repeated character flags. */
139:
140: #define UTF_LENGTH 0x10000000l /* The char contains its length. */
1.1 misha 141:
142: /* Table for handling escaped characters in the range '0'-'z'. Positive returns
143: are simple data values; negative values are for special things like \d and so
144: on. Zero means further processing is needed (for things like \x), or the escape
145: is invalid. */
146:
1.3 misha 147: #ifndef EBCDIC
148:
149: /* This is the "normal" table for ASCII systems or for EBCDIC systems running
150: in UTF-8 mode. */
151:
1.1 misha 152: static const short int escapes[] = {
1.3 misha 153: 0, 0,
154: 0, 0,
155: 0, 0,
156: 0, 0,
157: 0, 0,
158: CHAR_COLON, CHAR_SEMICOLON,
159: CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN,
160: CHAR_GREATER_THAN_SIGN, CHAR_QUESTION_MARK,
161: CHAR_COMMERCIAL_AT, -ESC_A,
162: -ESC_B, -ESC_C,
163: -ESC_D, -ESC_E,
164: 0, -ESC_G,
165: -ESC_H, 0,
166: 0, -ESC_K,
167: 0, 0,
1.4 misha 168: -ESC_N, 0,
1.3 misha 169: -ESC_P, -ESC_Q,
170: -ESC_R, -ESC_S,
171: 0, 0,
172: -ESC_V, -ESC_W,
173: -ESC_X, 0,
174: -ESC_Z, CHAR_LEFT_SQUARE_BRACKET,
175: CHAR_BACKSLASH, CHAR_RIGHT_SQUARE_BRACKET,
176: CHAR_CIRCUMFLEX_ACCENT, CHAR_UNDERSCORE,
1.9 ! moko 177: CHAR_GRAVE_ACCENT, ESC_a,
1.3 misha 178: -ESC_b, 0,
179: -ESC_d, ESC_e,
180: ESC_f, 0,
181: -ESC_h, 0,
182: 0, -ESC_k,
183: 0, 0,
184: ESC_n, 0,
185: -ESC_p, 0,
186: ESC_r, -ESC_s,
187: ESC_tee, 0,
188: -ESC_v, -ESC_w,
189: 0, 0,
190: -ESC_z
1.1 misha 191: };
192:
1.3 misha 193: #else
194:
195: /* This is the "abnormal" table for EBCDIC systems without UTF-8 support. */
196:
1.1 misha 197: static const short int escapes[] = {
198: /* 48 */ 0, 0, 0, '.', '<', '(', '+', '|',
199: /* 50 */ '&', 0, 0, 0, 0, 0, 0, 0,
200: /* 58 */ 0, 0, '!', '$', '*', ')', ';', '~',
201: /* 60 */ '-', '/', 0, 0, 0, 0, 0, 0,
202: /* 68 */ 0, 0, '|', ',', '%', '_', '>', '?',
203: /* 70 */ 0, 0, 0, 0, 0, 0, 0, 0,
204: /* 78 */ 0, '`', ':', '#', '@', '\'', '=', '"',
1.9 ! moko 205: /* 80 */ 0, ESC_a, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0,
1.1 misha 206: /* 88 */-ESC_h, 0, 0, '{', 0, 0, 0, 0,
1.9 ! moko 207: /* 90 */ 0, 0, -ESC_k, 0, 0, ESC_n, 0, -ESC_p,
1.1 misha 208: /* 98 */ 0, ESC_r, 0, '}', 0, 0, 0, 0,
209: /* A0 */ 0, '~', -ESC_s, ESC_tee, 0,-ESC_v, -ESC_w, 0,
210: /* A8 */ 0,-ESC_z, 0, 0, 0, '[', 0, 0,
211: /* B0 */ 0, 0, 0, 0, 0, 0, 0, 0,
212: /* B8 */ 0, 0, 0, 0, 0, ']', '=', '-',
213: /* C0 */ '{',-ESC_A, -ESC_B, -ESC_C, -ESC_D,-ESC_E, 0, -ESC_G,
214: /* C8 */-ESC_H, 0, 0, 0, 0, 0, 0, 0,
1.4 misha 215: /* D0 */ '}', 0, -ESC_K, 0, 0,-ESC_N, 0, -ESC_P,
1.1 misha 216: /* D8 */-ESC_Q,-ESC_R, 0, 0, 0, 0, 0, 0,
217: /* E0 */ '\\', 0, -ESC_S, 0, 0,-ESC_V, -ESC_W, -ESC_X,
218: /* E8 */ 0,-ESC_Z, 0, 0, 0, 0, 0, 0,
219: /* F0 */ 0, 0, 0, 0, 0, 0, 0, 0,
220: /* F8 */ 0, 0, 0, 0, 0, 0, 0, 0
221: };
1.9 ! moko 222:
! 223: /* We also need a table of characters that may follow \c in an EBCDIC
! 224: environment for characters 0-31. */
! 225:
! 226: static unsigned char ebcdic_escape_c[] = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
! 227:
1.1 misha 228: #endif
229:
230:
231: /* Table of special "verbs" like (*PRUNE). This is a short table, so it is
232: searched linearly. Put all the names into a single string, in order to reduce
1.3 misha 233: the number of relocations when a shared library is dynamically linked. The
234: string is built from string macros so that it works in UTF-8 mode on EBCDIC
235: platforms. */
1.1 misha 236:
237: typedef struct verbitem {
1.4 misha 238: int len; /* Length of verb name */
239: int op; /* Op when no arg, or -1 if arg mandatory */
240: int op_arg; /* Op when arg present, or -1 if not allowed */
1.1 misha 241: } verbitem;
242:
243: static const char verbnames[] =
1.4 misha 244: "\0" /* Empty name is a shorthand for MARK */
245: STRING_MARK0
1.3 misha 246: STRING_ACCEPT0
247: STRING_COMMIT0
248: STRING_F0
249: STRING_FAIL0
250: STRING_PRUNE0
251: STRING_SKIP0
252: STRING_THEN;
1.1 misha 253:
254: static const verbitem verbs[] = {
1.4 misha 255: { 0, -1, OP_MARK },
256: { 4, -1, OP_MARK },
257: { 6, OP_ACCEPT, -1 },
258: { 6, OP_COMMIT, -1 },
259: { 1, OP_FAIL, -1 },
260: { 4, OP_FAIL, -1 },
261: { 5, OP_PRUNE, OP_PRUNE_ARG },
262: { 4, OP_SKIP, OP_SKIP_ARG },
263: { 4, OP_THEN, OP_THEN_ARG }
1.1 misha 264: };
265:
266: static const int verbcount = sizeof(verbs)/sizeof(verbitem);
267:
268:
1.8 moko 269: /* Substitutes for [[:<:]] and [[:>:]], which mean start and end of word in
270: another regex library. */
271:
272: static const pcre_uchar sub_start_of_word[] = {
273: CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,
274: CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w, CHAR_RIGHT_PARENTHESIS, '\0' };
275:
276: static const pcre_uchar sub_end_of_word[] = {
277: CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,
278: CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w,
279: CHAR_RIGHT_PARENTHESIS, '\0' };
280:
281:
1.1 misha 282: /* Tables of names of POSIX character classes and their lengths. The names are
283: now all in a single string, to reduce the number of relocations when a shared
284: library is dynamically loaded. The list of lengths is terminated by a zero
285: length entry. The first three must be alpha, lower, upper, as this is assumed
1.8 moko 286: for handling case independence. The indices for graph, print, and punct are
287: needed, so identify them. */
1.1 misha 288:
289: static const char posix_names[] =
1.3 misha 290: STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0
291: STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0
292: STRING_graph0 STRING_print0 STRING_punct0 STRING_space0
293: STRING_word0 STRING_xdigit;
1.1 misha 294:
1.6 misha 295: static const pcre_uint8 posix_name_lengths[] = {
1.1 misha 296: 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
297:
1.8 moko 298: #define PC_GRAPH 8
299: #define PC_PRINT 9
300: #define PC_PUNCT 10
301:
302:
1.1 misha 303: /* Table of class bit maps for each POSIX class. Each class is formed from a
304: base map, with an optional addition or removal of another map. Then, for some
305: classes, there is some additional tweaking: for [:blank:] the vertical space
306: characters are removed, and for [:alpha:] and [:alnum:] the underscore
307: character is removed. The triples in the table consist of the base map offset,
308: second map offset or -1 if no second map, and a non-negative value for map
309: addition or a negative value for map subtraction (if there are two maps). The
310: absolute value of the third field has these meanings: 0 => no tweaking, 1 =>
311: remove vertical space characters, 2 => remove underscore. */
312:
313: static const int posix_class_maps[] = {
314: cbit_word, cbit_digit, -2, /* alpha */
315: cbit_lower, -1, 0, /* lower */
316: cbit_upper, -1, 0, /* upper */
317: cbit_word, -1, 2, /* alnum - word without underscore */
318: cbit_print, cbit_cntrl, 0, /* ascii */
319: cbit_space, -1, 1, /* blank - a GNU extension */
320: cbit_cntrl, -1, 0, /* cntrl */
321: cbit_digit, -1, 0, /* digit */
322: cbit_graph, -1, 0, /* graph */
323: cbit_print, -1, 0, /* print */
324: cbit_punct, -1, 0, /* punct */
325: cbit_space, -1, 0, /* space */
326: cbit_word, -1, 0, /* word - a Perl extension */
327: cbit_xdigit,-1, 0 /* xdigit */
328: };
329:
1.8 moko 330: /* Table of substitutes for \d etc when PCRE_UCP is set. They are replaced by
331: Unicode property escapes. */
1.4 misha 332:
333: #ifdef SUPPORT_UCP
1.6 misha 334: static const pcre_uchar string_PNd[] = {
335: CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
336: CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
337: static const pcre_uchar string_pNd[] = {
338: CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
339: CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
340: static const pcre_uchar string_PXsp[] = {
341: CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
342: CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };
343: static const pcre_uchar string_pXsp[] = {
344: CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
345: CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };
346: static const pcre_uchar string_PXwd[] = {
347: CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
348: CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
349: static const pcre_uchar string_pXwd[] = {
350: CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
351: CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
352:
353: static const pcre_uchar *substitutes[] = {
354: string_PNd, /* \D */
355: string_pNd, /* \d */
1.8 moko 356: string_PXsp, /* \S */ /* Xsp is Perl space, but from 8.34, Perl */
357: string_pXsp, /* \s */ /* space and POSIX space are the same. */
1.6 misha 358: string_PXwd, /* \W */
359: string_pXwd /* \w */
1.4 misha 360: };
361:
1.8 moko 362: /* The POSIX class substitutes must be in the order of the POSIX class names,
363: defined above, and there are both positive and negative cases. NULL means no
364: general substitute of a Unicode property escape (\p or \P). However, for some
365: POSIX classes (e.g. graph, print, punct) a special property code is compiled
366: directly. */
367:
1.6 misha 368: static const pcre_uchar string_pL[] = {
369: CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
370: CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };
371: static const pcre_uchar string_pLl[] = {
372: CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
373: CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };
374: static const pcre_uchar string_pLu[] = {
375: CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
376: CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };
377: static const pcre_uchar string_pXan[] = {
378: CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
379: CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };
380: static const pcre_uchar string_h[] = {
381: CHAR_BACKSLASH, CHAR_h, '\0' };
382: static const pcre_uchar string_pXps[] = {
383: CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
384: CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };
385: static const pcre_uchar string_PL[] = {
386: CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
387: CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };
388: static const pcre_uchar string_PLl[] = {
389: CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
390: CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };
391: static const pcre_uchar string_PLu[] = {
392: CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
393: CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };
394: static const pcre_uchar string_PXan[] = {
395: CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
396: CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };
397: static const pcre_uchar string_H[] = {
398: CHAR_BACKSLASH, CHAR_H, '\0' };
399: static const pcre_uchar string_PXps[] = {
400: CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
401: CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };
402:
403: static const pcre_uchar *posix_substitutes[] = {
404: string_pL, /* alpha */
405: string_pLl, /* lower */
406: string_pLu, /* upper */
407: string_pXan, /* alnum */
408: NULL, /* ascii */
409: string_h, /* blank */
410: NULL, /* cntrl */
411: string_pNd, /* digit */
412: NULL, /* graph */
413: NULL, /* print */
414: NULL, /* punct */
1.8 moko 415: string_pXps, /* space */ /* Xps is POSIX space, but from 8.34 */
416: string_pXwd, /* word */ /* Perl and POSIX space are the same */
1.6 misha 417: NULL, /* xdigit */
1.4 misha 418: /* Negated cases */
1.6 misha 419: string_PL, /* ^alpha */
420: string_PLl, /* ^lower */
421: string_PLu, /* ^upper */
422: string_PXan, /* ^alnum */
423: NULL, /* ^ascii */
424: string_H, /* ^blank */
425: NULL, /* ^cntrl */
426: string_PNd, /* ^digit */
427: NULL, /* ^graph */
428: NULL, /* ^print */
429: NULL, /* ^punct */
1.8 moko 430: string_PXps, /* ^space */ /* Xps is POSIX space, but from 8.34 */
431: string_PXwd, /* ^word */ /* Perl and POSIX space are the same */
1.6 misha 432: NULL /* ^xdigit */
1.4 misha 433: };
1.6 misha 434: #define POSIX_SUBSIZE (sizeof(posix_substitutes) / sizeof(pcre_uchar *))
1.4 misha 435: #endif
1.1 misha 436:
437: #define STRING(a) # a
438: #define XSTRING(s) STRING(s)
439:
440: /* The texts of compile-time error messages. These are "char *" because they
441: are passed to the outside world. Do not ever re-use any error number, because
442: they are documented. Always add a new error instead. Messages marked DEAD below
443: are no longer used. This used to be a table of strings, but in order to reduce
444: the number of relocations needed when a shared library is loaded dynamically,
445: it is now one long string. We cannot use a table of offsets, because the
446: lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we
447: simply count through to the one we want - this isn't a performance issue
1.4 misha 448: because these strings are used only when there is a compilation error.
449:
450: Each substring ends with \0 to insert a null character. This includes the final
451: substring, so that the whole string ends with \0\0, which can be detected when
452: counting through. */
1.1 misha 453:
454: static const char error_texts[] =
455: "no error\0"
456: "\\ at end of pattern\0"
457: "\\c at end of pattern\0"
458: "unrecognized character follows \\\0"
459: "numbers out of order in {} quantifier\0"
460: /* 5 */
461: "number too big in {} quantifier\0"
462: "missing terminating ] for character class\0"
463: "invalid escape sequence in character class\0"
464: "range out of order in character class\0"
465: "nothing to repeat\0"
466: /* 10 */
1.9 ! moko 467: "internal error: invalid forward reference offset\0"
1.1 misha 468: "internal error: unexpected repeat\0"
469: "unrecognized character after (? or (?-\0"
470: "POSIX named classes are supported only within a class\0"
471: "missing )\0"
472: /* 15 */
473: "reference to non-existent subpattern\0"
474: "erroffset passed as NULL\0"
475: "unknown option bit(s) set\0"
476: "missing ) after comment\0"
477: "parentheses nested too deeply\0" /** DEAD **/
478: /* 20 */
479: "regular expression is too large\0"
480: "failed to get memory\0"
481: "unmatched parentheses\0"
482: "internal error: code overflow\0"
483: "unrecognized character after (?<\0"
484: /* 25 */
485: "lookbehind assertion is not fixed length\0"
486: "malformed number or name after (?(\0"
487: "conditional group contains more than two branches\0"
1.9 ! moko 488: "assertion expected after (?( or (?(?C)\0"
1.1 misha 489: "(?R or (?[+-]digits must be followed by )\0"
490: /* 30 */
491: "unknown POSIX class name\0"
492: "POSIX collating elements are not supported\0"
1.6 misha 493: "this version of PCRE is compiled without UTF support\0"
1.1 misha 494: "spare error\0" /** DEAD **/
1.8 moko 495: "character value in \\x{} or \\o{} is too large\0"
1.1 misha 496: /* 35 */
497: "invalid condition (?(0)\0"
498: "\\C not allowed in lookbehind assertion\0"
1.4 misha 499: "PCRE does not support \\L, \\l, \\N{name}, \\U, or \\u\0"
1.1 misha 500: "number after (?C is > 255\0"
501: "closing ) for (?C expected\0"
502: /* 40 */
503: "recursive call could loop indefinitely\0"
504: "unrecognized character after (?P\0"
505: "syntax error in subpattern name (missing terminator)\0"
506: "two named subpatterns have the same name\0"
507: "invalid UTF-8 string\0"
508: /* 45 */
509: "support for \\P, \\p, and \\X has not been compiled\0"
510: "malformed \\P or \\p sequence\0"
511: "unknown property name after \\P or \\p\0"
512: "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)\0"
513: "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")\0"
514: /* 50 */
515: "repeated subpattern is too long\0" /** DEAD **/
1.6 misha 516: "octal value is greater than \\377 in 8-bit non-UTF-8 mode\0"
1.1 misha 517: "internal error: overran compiling workspace\0"
518: "internal error: previously-checked referenced subpattern not found\0"
519: "DEFINE group contains more than one branch\0"
520: /* 55 */
1.6 misha 521: "repeating a DEFINE group is not allowed\0" /** DEAD **/
1.1 misha 522: "inconsistent NEWLINE options\0"
523: "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
524: "a numbered reference must not be zero\0"
1.4 misha 525: "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0"
1.1 misha 526: /* 60 */
1.7 misha 527: "(*VERB) not recognized or malformed\0"
1.1 misha 528: "number is too big\0"
529: "subpattern name expected\0"
530: "digit expected after (?+\0"
1.4 misha 531: "] is an invalid data character in JavaScript compatibility mode\0"
532: /* 65 */
533: "different names for subpatterns of the same number are not allowed\0"
534: "(*MARK) must have an argument\0"
1.6 misha 535: "this version of PCRE is not compiled with Unicode property support\0"
1.9 ! moko 536: #ifndef EBCDIC
1.5 misha 537: "\\c must be followed by an ASCII character\0"
1.9 ! moko 538: #else
! 539: "\\c must be followed by a letter or one of [\\]^_?\0"
! 540: #endif
1.6 misha 541: "\\k is not followed by a braced, angle-bracketed, or quoted name\0"
542: /* 70 */
543: "internal error: unknown opcode in find_fixedlength()\0"
544: "\\N is not supported in a class\0"
545: "too many forward references\0"
546: "disallowed Unicode code point (>= 0xd800 && <= 0xdfff)\0"
547: "invalid UTF-16 string\0"
1.7 misha 548: /* 75 */
549: "name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)\0"
550: "character value in \\u.... sequence is too large\0"
551: "invalid UTF-32 string\0"
552: "setting UTF is disabled by the application\0"
1.8 moko 553: "non-hex character in \\x{} (closing brace missing?)\0"
554: /* 80 */
555: "non-octal character in \\o{} (closing brace missing?)\0"
556: "missing opening brace after \\o\0"
557: "parentheses are too deeply nested\0"
558: "invalid range in character class\0"
559: "group name must start with a non-digit\0"
560: /* 85 */
561: "parentheses are too deeply nested (stack check)\0"
562: "digits missing in \\x{} or \\o{}\0"
1.9 ! moko 563: "regular expression is too complicated\0"
1.4 misha 564: ;
1.1 misha 565:
566: /* Table to identify digits and hex digits. This is used when compiling
567: patterns. Note that the tables in chartables are dependent on the locale, and
568: may mark arbitrary characters as digits - but the PCRE compiling code expects
569: to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
570: a private table here. It costs 256 bytes, but it is a lot faster than doing
571: character value tests (at least in some simple cases I timed), and in some
572: applications one wants PCRE to compile efficiently as well as match
573: efficiently.
574:
575: For convenience, we use the same bit definitions as in chartables:
576:
577: 0x04 decimal digit
578: 0x08 hexadecimal digit
579:
580: Then we can use ctype_digit and ctype_xdigit in the code. */
581:
1.6 misha 582: /* Using a simple comparison for decimal numbers rather than a memory read
583: is much faster, and the resulting code is simpler (the compiler turns it
584: into a subtraction and unsigned comparison). */
585:
586: #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9)
587:
1.3 misha 588: #ifndef EBCDIC
589:
590: /* This is the "normal" case, for ASCII systems, and EBCDIC systems running in
591: UTF-8 mode. */
592:
1.6 misha 593: static const pcre_uint8 digitab[] =
1.1 misha 594: {
595: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */
596: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */
597: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */
598: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
599: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - ' */
600: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ( - / */
601: 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 */
602: 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /* 8 - ? */
603: 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* @ - G */
604: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H - O */
605: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* P - W */
606: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* X - _ */
607: 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* ` - g */
608: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h - o */
609: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* p - w */
610: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* x -127 */
611: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
612: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
613: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
614: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
615: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
616: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
617: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
618: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
619: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
620: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
621: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
622: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
623: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
624: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
625: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
626: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
627:
1.3 misha 628: #else
629:
630: /* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */
631:
1.6 misha 632: static const pcre_uint8 digitab[] =
1.1 misha 633: {
634: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 0 */
635: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */
636: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 10 */
637: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
638: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 32- 39 20 */
639: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */
640: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 30 */
641: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */
642: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 40 */
643: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 72- | */
644: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 50 */
645: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 88- 95 */
646: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 60 */
647: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ? */
648: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
649: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */
650: 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g 80 */
651: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */
652: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p 90 */
653: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */
654: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x A0 */
655: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */
656: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 B0 */
657: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
658: 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* { - G C0 */
659: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */
660: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* } - P D0 */
661: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */
662: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* \ - X E0 */
663: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */
664: 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 F0 */
665: 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */
666:
1.6 misha 667: static const pcre_uint8 ebcdic_chartab[] = { /* chartable partial dup */
1.1 misha 668: 0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 0- 7 */
669: 0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /* 8- 15 */
670: 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 16- 23 */
671: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */
672: 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 32- 39 */
673: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */
674: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 */
675: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */
676: 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 */
677: 0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /* 72- | */
678: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 */
679: 0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /* 88- 95 */
680: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 */
681: 0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ? */
682: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
683: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */
684: 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g */
685: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */
686: 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p */
687: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */
688: 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x */
689: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */
690: 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 */
691: 0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
692: 0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* { - G */
693: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */
694: 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* } - P */
695: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */
696: 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* \ - X */
697: 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */
698: 0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */
699: 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */
700: #endif
701:
702:
1.8 moko 703: /* This table is used to check whether auto-possessification is possible
704: between adjacent character-type opcodes. The left-hand (repeated) opcode is
705: used to select the row, and the right-hand opcode is use to select the column.
706: A value of 1 means that auto-possessification is OK. For example, the second
707: value in the first row means that \D+\d can be turned into \D++\d.
708:
709: The Unicode property types (\P and \p) have to be present to fill out the table
710: because of what their opcode values are, but the table values should always be
711: zero because property types are handled separately in the code. The last four
712: columns apply to items that cannot be repeated, so there is no need to have
713: rows for them. Note that OP_DIGIT etc. are generated only when PCRE_UCP is
714: *not* set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
715:
716: #define APTROWS (LAST_AUTOTAB_LEFT_OP - FIRST_AUTOTAB_OP + 1)
717: #define APTCOLS (LAST_AUTOTAB_RIGHT_OP - FIRST_AUTOTAB_OP + 1)
718:
719: static const pcre_uint8 autoposstab[APTROWS][APTCOLS] = {
720: /* \D \d \S \s \W \w . .+ \C \P \p \R \H \h \V \v \X \Z \z $ $M */
721: { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \D */
722: { 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \d */
723: { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \S */
724: { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \s */
725: { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \W */
726: { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \w */
727: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* . */
728: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* .+ */
729: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \C */
730: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* \P */
731: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* \p */
732: { 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }, /* \R */
733: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }, /* \H */
734: { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0 }, /* \h */
735: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0 }, /* \V */
736: { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0 }, /* \v */
737: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 } /* \X */
738: };
739:
740:
741: /* This table is used to check whether auto-possessification is possible
742: between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP). The
743: left-hand (repeated) opcode is used to select the row, and the right-hand
744: opcode is used to select the column. The values are as follows:
745:
746: 0 Always return FALSE (never auto-possessify)
747: 1 Character groups are distinct (possessify if both are OP_PROP)
748: 2 Check character categories in the same group (general or particular)
749: 3 TRUE if the two opcodes are not the same (PROP vs NOTPROP)
750:
751: 4 Check left general category vs right particular category
752: 5 Check right general category vs left particular category
753:
754: 6 Left alphanum vs right general category
755: 7 Left space vs right general category
756: 8 Left word vs right general category
757:
758: 9 Right alphanum vs left general category
759: 10 Right space vs left general category
760: 11 Right word vs left general category
761:
762: 12 Left alphanum vs right particular category
763: 13 Left space vs right particular category
764: 14 Left word vs right particular category
765:
766: 15 Right alphanum vs left particular category
767: 16 Right space vs left particular category
768: 17 Right word vs left particular category
769: */
770:
771: static const pcre_uint8 propposstab[PT_TABSIZE][PT_TABSIZE] = {
772: /* ANY LAMP GC PC SC ALNUM SPACE PXSPACE WORD CLIST UCNC */
773: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* PT_ANY */
774: { 0, 3, 0, 0, 0, 3, 1, 1, 0, 0, 0 }, /* PT_LAMP */
775: { 0, 0, 2, 4, 0, 9, 10, 10, 11, 0, 0 }, /* PT_GC */
776: { 0, 0, 5, 2, 0, 15, 16, 16, 17, 0, 0 }, /* PT_PC */
777: { 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0 }, /* PT_SC */
778: { 0, 3, 6, 12, 0, 3, 1, 1, 0, 0, 0 }, /* PT_ALNUM */
779: { 0, 1, 7, 13, 0, 1, 3, 3, 1, 0, 0 }, /* PT_SPACE */
780: { 0, 1, 7, 13, 0, 1, 3, 3, 1, 0, 0 }, /* PT_PXSPACE */
781: { 0, 0, 8, 14, 0, 0, 1, 1, 3, 0, 0 }, /* PT_WORD */
782: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* PT_CLIST */
783: { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3 } /* PT_UCNC */
784: };
785:
786: /* This table is used to check whether auto-possessification is possible
787: between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP) when one
788: specifies a general category and the other specifies a particular category. The
789: row is selected by the general category and the column by the particular
790: category. The value is 1 if the particular category is not part of the general
791: category. */
792:
793: static const pcre_uint8 catposstab[7][30] = {
794: /* Cc Cf Cn Co Cs Ll Lm Lo Lt Lu Mc Me Mn Nd Nl No Pc Pd Pe Pf Pi Po Ps Sc Sk Sm So Zl Zp Zs */
795: { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* C */
796: { 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* L */
797: { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* M */
798: { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* N */
799: { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 }, /* P */
800: { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 }, /* S */
801: { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 } /* Z */
802: };
803:
804: /* This table is used when checking ALNUM, (PX)SPACE, SPACE, and WORD against
805: a general or particular category. The properties in each row are those
806: that apply to the character set in question. Duplication means that a little
807: unnecessary work is done when checking, but this keeps things much simpler
808: because they can all use the same code. For more details see the comment where
809: this table is used.
810:
811: Note: SPACE and PXSPACE used to be different because Perl excluded VT from
812: "space", but from Perl 5.18 it's included, so both categories are treated the
813: same here. */
814:
815: static const pcre_uint8 posspropstab[3][4] = {
816: { ucp_L, ucp_N, ucp_N, ucp_Nl }, /* ALNUM, 3rd and 4th values redundant */
817: { ucp_Z, ucp_Z, ucp_C, ucp_Cc }, /* SPACE and PXSPACE, 2nd value redundant */
818: { ucp_L, ucp_N, ucp_P, ucp_Po } /* WORD */
819: };
820:
821: /* This table is used when converting repeating opcodes into possessified
822: versions as a result of an explicit possessive quantifier such as ++. A zero
823: value means there is no possessified version - in those cases the item in
824: question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT
825: because all relevant opcodes are less than that. */
826:
827: static const pcre_uint8 opcode_possessify[] = {
828: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 15 */
829: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16 - 31 */
830:
831: 0, /* NOTI */
832: OP_POSSTAR, 0, /* STAR, MINSTAR */
833: OP_POSPLUS, 0, /* PLUS, MINPLUS */
834: OP_POSQUERY, 0, /* QUERY, MINQUERY */
835: OP_POSUPTO, 0, /* UPTO, MINUPTO */
836: 0, /* EXACT */
837: 0, 0, 0, 0, /* POS{STAR,PLUS,QUERY,UPTO} */
838:
839: OP_POSSTARI, 0, /* STARI, MINSTARI */
840: OP_POSPLUSI, 0, /* PLUSI, MINPLUSI */
841: OP_POSQUERYI, 0, /* QUERYI, MINQUERYI */
842: OP_POSUPTOI, 0, /* UPTOI, MINUPTOI */
843: 0, /* EXACTI */
844: 0, 0, 0, 0, /* POS{STARI,PLUSI,QUERYI,UPTOI} */
845:
846: OP_NOTPOSSTAR, 0, /* NOTSTAR, NOTMINSTAR */
847: OP_NOTPOSPLUS, 0, /* NOTPLUS, NOTMINPLUS */
848: OP_NOTPOSQUERY, 0, /* NOTQUERY, NOTMINQUERY */
849: OP_NOTPOSUPTO, 0, /* NOTUPTO, NOTMINUPTO */
850: 0, /* NOTEXACT */
851: 0, 0, 0, 0, /* NOTPOS{STAR,PLUS,QUERY,UPTO} */
852:
853: OP_NOTPOSSTARI, 0, /* NOTSTARI, NOTMINSTARI */
854: OP_NOTPOSPLUSI, 0, /* NOTPLUSI, NOTMINPLUSI */
855: OP_NOTPOSQUERYI, 0, /* NOTQUERYI, NOTMINQUERYI */
856: OP_NOTPOSUPTOI, 0, /* NOTUPTOI, NOTMINUPTOI */
857: 0, /* NOTEXACTI */
858: 0, 0, 0, 0, /* NOTPOS{STARI,PLUSI,QUERYI,UPTOI} */
859:
860: OP_TYPEPOSSTAR, 0, /* TYPESTAR, TYPEMINSTAR */
861: OP_TYPEPOSPLUS, 0, /* TYPEPLUS, TYPEMINPLUS */
862: OP_TYPEPOSQUERY, 0, /* TYPEQUERY, TYPEMINQUERY */
863: OP_TYPEPOSUPTO, 0, /* TYPEUPTO, TYPEMINUPTO */
864: 0, /* TYPEEXACT */
865: 0, 0, 0, 0, /* TYPEPOS{STAR,PLUS,QUERY,UPTO} */
866:
867: OP_CRPOSSTAR, 0, /* CRSTAR, CRMINSTAR */
868: OP_CRPOSPLUS, 0, /* CRPLUS, CRMINPLUS */
869: OP_CRPOSQUERY, 0, /* CRQUERY, CRMINQUERY */
870: OP_CRPOSRANGE, 0, /* CRRANGE, CRMINRANGE */
871: 0, 0, 0, 0, /* CRPOS{STAR,PLUS,QUERY,RANGE} */
872:
873: 0, 0, 0, /* CLASS, NCLASS, XCLASS */
874: 0, 0, /* REF, REFI */
875: 0, 0, /* DNREF, DNREFI */
876: 0, 0 /* RECURSE, CALLOUT */
877: };
878:
879:
1.1 misha 880:
881: /*************************************************
882: * Find an error text *
883: *************************************************/
884:
885: /* The error texts are now all in one long string, to save on relocations. As
886: some of the text is of unknown length, we can't use a table of offsets.
887: Instead, just count through the strings. This is not a performance issue
888: because it happens only when there has been a compilation error.
889:
890: Argument: the error number
891: Returns: pointer to the error string
892: */
893:
894: static const char *
895: find_error_text(int n)
896: {
897: const char *s = error_texts;
1.4 misha 898: for (; n > 0; n--)
899: {
1.7 misha 900: while (*s++ != CHAR_NULL) {};
901: if (*s == CHAR_NULL) return "Error text not found (please report)";
1.4 misha 902: }
1.1 misha 903: return s;
904: }
905:
906:
1.8 moko 907:
1.1 misha 908: /*************************************************
1.6 misha 909: * Expand the workspace *
910: *************************************************/
911:
912: /* This function is called during the second compiling phase, if the number of
913: forward references fills the existing workspace, which is originally a block on
914: the stack. A larger block is obtained from malloc() unless the ultimate limit
915: has been reached or the increase will be rather small.
916:
917: Argument: pointer to the compile data block
918: Returns: 0 if all went well, else an error number
919: */
920:
921: static int
922: expand_workspace(compile_data *cd)
923: {
924: pcre_uchar *newspace;
925: int newsize = cd->workspace_size * 2;
926:
927: if (newsize > COMPILE_WORK_SIZE_MAX) newsize = COMPILE_WORK_SIZE_MAX;
928: if (cd->workspace_size >= COMPILE_WORK_SIZE_MAX ||
929: newsize - cd->workspace_size < WORK_SIZE_SAFETY_MARGIN)
930: return ERR72;
931:
932: newspace = (PUBL(malloc))(IN_UCHARS(newsize));
933: if (newspace == NULL) return ERR21;
934: memcpy(newspace, cd->start_workspace, cd->workspace_size * sizeof(pcre_uchar));
935: cd->hwm = (pcre_uchar *)newspace + (cd->hwm - cd->start_workspace);
936: if (cd->workspace_size > COMPILE_WORK_SIZE)
937: (PUBL(free))((void *)cd->start_workspace);
938: cd->start_workspace = newspace;
939: cd->workspace_size = newsize;
940: return 0;
941: }
942:
943:
944:
945: /*************************************************
946: * Check for counted repeat *
947: *************************************************/
948:
949: /* This function is called when a '{' is encountered in a place where it might
950: start a quantifier. It looks ahead to see if it really is a quantifier or not.
951: It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
952: where the ddds are digits.
953:
954: Arguments:
955: p pointer to the first char after '{'
956:
957: Returns: TRUE or FALSE
958: */
959:
960: static BOOL
961: is_counted_repeat(const pcre_uchar *p)
962: {
963: if (!IS_DIGIT(*p)) return FALSE;
964: p++;
965: while (IS_DIGIT(*p)) p++;
966: if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
967:
968: if (*p++ != CHAR_COMMA) return FALSE;
969: if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
970:
971: if (!IS_DIGIT(*p)) return FALSE;
972: p++;
973: while (IS_DIGIT(*p)) p++;
974:
975: return (*p == CHAR_RIGHT_CURLY_BRACKET);
976: }
977:
978:
979:
980: /*************************************************
1.1 misha 981: * Handle escapes *
982: *************************************************/
983:
984: /* This function is called when a \ has been encountered. It either returns a
1.8 moko 985: positive value for a simple escape such as \n, or 0 for a data character which
986: will be placed in chptr. A backreference to group n is returned as negative n.
987: When UTF-8 is enabled, a positive value greater than 255 may be returned in
988: chptr. On entry, ptr is pointing at the \. On exit, it is on the final
989: character of the escape sequence.
1.1 misha 990:
991: Arguments:
992: ptrptr points to the pattern position pointer
1.8 moko 993: chptr points to a returned data character
1.1 misha 994: errorcodeptr points to the errorcode variable
995: bracount number of previous extracting brackets
996: options the options bits
997: isclass TRUE if inside a character class
998:
1.7 misha 999: Returns: zero => a data character
1000: positive => a special escape sequence
1001: negative => a back reference
1.1 misha 1002: on error, errorcodeptr is set
1003: */
1004:
1005: static int
1.7 misha 1006: check_escape(const pcre_uchar **ptrptr, pcre_uint32 *chptr, int *errorcodeptr,
1007: int bracount, int options, BOOL isclass)
1.1 misha 1008: {
1.6 misha 1009: /* PCRE_UTF16 has the same value as PCRE_UTF8. */
1010: BOOL utf = (options & PCRE_UTF8) != 0;
1011: const pcre_uchar *ptr = *ptrptr + 1;
1.7 misha 1012: pcre_uint32 c;
1013: int escape = 0;
1.6 misha 1014: int i;
1.1 misha 1015:
1016: GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */
1017: ptr--; /* Set pointer back to the last byte */
1018:
1019: /* If backslash is at the end of the pattern, it's an error. */
1020:
1.7 misha 1021: if (c == CHAR_NULL) *errorcodeptr = ERR1;
1.1 misha 1022:
1023: /* Non-alphanumerics are literals. For digits or letters, do an initial lookup
1024: in a table. A non-zero result is something that can be returned immediately.
1025: Otherwise further processing may be required. */
1026:
1.3 misha 1027: #ifndef EBCDIC /* ASCII/UTF-8 coding */
1.6 misha 1028: /* Not alphanumeric */
1029: else if (c < CHAR_0 || c > CHAR_z) {}
1.7 misha 1030: else if ((i = escapes[c - CHAR_0]) != 0)
1031: { if (i > 0) c = (pcre_uint32)i; else escape = -i; }
1.1 misha 1032:
1033: #else /* EBCDIC coding */
1.6 misha 1034: /* Not alphanumeric */
1.7 misha 1035: else if (c < CHAR_a || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}
1036: else if ((i = escapes[c - 0x48]) != 0) { if (i > 0) c = (pcre_uint32)i; else escape = -i; }
1.1 misha 1037: #endif
1038:
1039: /* Escapes that need further processing, or are illegal. */
1040:
1041: else
1042: {
1.6 misha 1043: const pcre_uchar *oldptr;
1.7 misha 1044: BOOL braced, negated, overflow;
1045: int s;
1.1 misha 1046:
1047: switch (c)
1048: {
1049: /* A number of Perl escapes are not handled by PCRE. We give an explicit
1050: error. */
1051:
1.3 misha 1052: case CHAR_l:
1053: case CHAR_L:
1.6 misha 1054: *errorcodeptr = ERR37;
1055: break;
1056:
1.3 misha 1057: case CHAR_u:
1.6 misha 1058: if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
1059: {
1060: /* In JavaScript, \u must be followed by four hexadecimal numbers.
1061: Otherwise it is a lowercase u letter. */
1062: if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0
1063: && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0
1064: && MAX_255(ptr[3]) && (digitab[ptr[3]] & ctype_xdigit) != 0
1065: && MAX_255(ptr[4]) && (digitab[ptr[4]] & ctype_xdigit) != 0)
1066: {
1067: c = 0;
1068: for (i = 0; i < 4; ++i)
1069: {
1.7 misha 1070: register pcre_uint32 cc = *(++ptr);
1.6 misha 1071: #ifndef EBCDIC /* ASCII/UTF-8 coding */
1072: if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */
1073: c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
1074: #else /* EBCDIC coding */
1075: if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */
1076: c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
1077: #endif
1078: }
1.7 misha 1079:
1080: #if defined COMPILE_PCRE8
1081: if (c > (utf ? 0x10ffffU : 0xffU))
1082: #elif defined COMPILE_PCRE16
1083: if (c > (utf ? 0x10ffffU : 0xffffU))
1084: #elif defined COMPILE_PCRE32
1085: if (utf && c > 0x10ffffU)
1086: #endif
1087: {
1088: *errorcodeptr = ERR76;
1089: }
1090: else if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
1.6 misha 1091: }
1092: }
1093: else
1094: *errorcodeptr = ERR37;
1095: break;
1096:
1.3 misha 1097: case CHAR_U:
1.6 misha 1098: /* In JavaScript, \U is an uppercase U letter. */
1099: if ((options & PCRE_JAVASCRIPT_COMPAT) == 0) *errorcodeptr = ERR37;
1.1 misha 1100: break;
1101:
1.6 misha 1102: /* In a character class, \g is just a literal "g". Outside a character
1103: class, \g must be followed by one of a number of specific things:
1.1 misha 1104:
1105: (1) A number, either plain or braced. If positive, it is an absolute
1106: backreference. If negative, it is a relative backreference. This is a Perl
1107: 5.10 feature.
1108:
1109: (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
1110: is part of Perl's movement towards a unified syntax for back references. As
1111: this is synonymous with \k{name}, we fudge it up by pretending it really
1112: was \k.
1113:
1114: (3) For Oniguruma compatibility we also support \g followed by a name or a
1115: number either in angle brackets or in single quotes. However, these are
1116: (possibly recursive) subroutine calls, _not_ backreferences. Just return
1.7 misha 1117: the ESC_g code (cf \k). */
1.1 misha 1118:
1.3 misha 1119: case CHAR_g:
1.6 misha 1120: if (isclass) break;
1.3 misha 1121: if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)
1.1 misha 1122: {
1.7 misha 1123: escape = ESC_g;
1.1 misha 1124: break;
1125: }
1126:
1127: /* Handle the Perl-compatible cases */
1128:
1.3 misha 1129: if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
1.1 misha 1130: {
1.6 misha 1131: const pcre_uchar *p;
1.7 misha 1132: for (p = ptr+2; *p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
1.6 misha 1133: if (*p != CHAR_MINUS && !IS_DIGIT(*p)) break;
1.7 misha 1134: if (*p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET)
1.1 misha 1135: {
1.7 misha 1136: escape = ESC_k;
1.1 misha 1137: break;
1138: }
1139: braced = TRUE;
1140: ptr++;
1141: }
1142: else braced = FALSE;
1143:
1.3 misha 1144: if (ptr[1] == CHAR_MINUS)
1.1 misha 1145: {
1146: negated = TRUE;
1147: ptr++;
1148: }
1149: else negated = FALSE;
1150:
1.6 misha 1151: /* The integer range is limited by the machine's int representation. */
1.7 misha 1152: s = 0;
1153: overflow = FALSE;
1.6 misha 1154: while (IS_DIGIT(ptr[1]))
1155: {
1.7 misha 1156: if (s > INT_MAX / 10 - 1) /* Integer overflow */
1.6 misha 1157: {
1.7 misha 1158: overflow = TRUE;
1.6 misha 1159: break;
1160: }
1.7 misha 1161: s = s * 10 + (int)(*(++ptr) - CHAR_0);
1.6 misha 1162: }
1.7 misha 1163: if (overflow) /* Integer overflow */
1.1 misha 1164: {
1.6 misha 1165: while (IS_DIGIT(ptr[1]))
1166: ptr++;
1.1 misha 1167: *errorcodeptr = ERR61;
1168: break;
1169: }
1170:
1.3 misha 1171: if (braced && *(++ptr) != CHAR_RIGHT_CURLY_BRACKET)
1.1 misha 1172: {
1173: *errorcodeptr = ERR57;
1174: break;
1175: }
1176:
1.7 misha 1177: if (s == 0)
1.1 misha 1178: {
1179: *errorcodeptr = ERR58;
1180: break;
1181: }
1182:
1183: if (negated)
1184: {
1.7 misha 1185: if (s > bracount)
1.1 misha 1186: {
1187: *errorcodeptr = ERR15;
1188: break;
1189: }
1.7 misha 1190: s = bracount - (s - 1);
1.1 misha 1191: }
1192:
1.7 misha 1193: escape = -s;
1.1 misha 1194: break;
1195:
1196: /* The handling of escape sequences consisting of a string of digits
1.8 moko 1197: starting with one that is not zero is not straightforward. Perl has changed
1198: over the years. Nowadays \g{} for backreferences and \o{} for octal are
1199: recommended to avoid the ambiguities in the old syntax.
1.1 misha 1200:
1201: Outside a character class, the digits are read as a decimal number. If the
1.8 moko 1202: number is less than 8 (used to be 10), or if there are that many previous
1203: extracting left brackets, then it is a back reference. Otherwise, up to
1204: three octal digits are read to form an escaped byte. Thus \123 is likely to
1205: be octal 123 (cf \0123, which is octal 012 followed by the literal 3). If
1206: the octal value is greater than 377, the least significant 8 bits are
1207: taken. \8 and \9 are treated as the literal characters 8 and 9.
1208:
1209: Inside a character class, \ followed by a digit is always either a literal
1210: 8 or 9 or an octal number. */
1.1 misha 1211:
1.3 misha 1212: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:
1213: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
1.1 misha 1214:
1215: if (!isclass)
1216: {
1217: oldptr = ptr;
1.6 misha 1218: /* The integer range is limited by the machine's int representation. */
1.7 misha 1219: s = (int)(c -CHAR_0);
1220: overflow = FALSE;
1.6 misha 1221: while (IS_DIGIT(ptr[1]))
1222: {
1.7 misha 1223: if (s > INT_MAX / 10 - 1) /* Integer overflow */
1.6 misha 1224: {
1.7 misha 1225: overflow = TRUE;
1.6 misha 1226: break;
1227: }
1.7 misha 1228: s = s * 10 + (int)(*(++ptr) - CHAR_0);
1.6 misha 1229: }
1.7 misha 1230: if (overflow) /* Integer overflow */
1.1 misha 1231: {
1.6 misha 1232: while (IS_DIGIT(ptr[1]))
1233: ptr++;
1.1 misha 1234: *errorcodeptr = ERR61;
1235: break;
1236: }
1.8 moko 1237: if (s < 8 || s <= bracount) /* Check for back reference */
1.1 misha 1238: {
1.7 misha 1239: escape = -s;
1.1 misha 1240: break;
1241: }
1242: ptr = oldptr; /* Put the pointer back and fall through */
1243: }
1244:
1.8 moko 1245: /* Handle a digit following \ when the number is not a back reference. If
1246: the first digit is 8 or 9, Perl used to generate a binary zero byte and
1247: then treat the digit as a following literal. At least by Perl 5.18 this
1248: changed so as not to insert the binary zero. */
1249:
1250: if ((c = *ptr) >= CHAR_8) break;
1.1 misha 1251:
1.8 moko 1252: /* Fall through with a digit less than 8 */
1.1 misha 1253:
1254: /* \0 always starts an octal number, but we may drop through to here with a
1255: larger first octal digit. The original code used just to take the least
1256: significant 8 bits of octal numbers (I think this is what early Perls used
1.6 misha 1257: to do). Nowadays we allow for larger numbers in UTF-8 mode and 16-bit mode,
1258: but no more than 3 octal digits. */
1.1 misha 1259:
1.3 misha 1260: case CHAR_0:
1261: c -= CHAR_0;
1262: while(i++ < 2 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)
1263: c = c * 8 + *(++ptr) - CHAR_0;
1.6 misha 1264: #ifdef COMPILE_PCRE8
1265: if (!utf && c > 0xff) *errorcodeptr = ERR51;
1266: #endif
1.1 misha 1267: break;
1268:
1.8 moko 1269: /* \o is a relatively new Perl feature, supporting a more general way of
1270: specifying character codes in octal. The only supported form is \o{ddd}. */
1271:
1272: case CHAR_o:
1273: if (ptr[1] != CHAR_LEFT_CURLY_BRACKET) *errorcodeptr = ERR81; else
1274: if (ptr[2] == CHAR_RIGHT_CURLY_BRACKET) *errorcodeptr = ERR86; else
1275: {
1276: ptr += 2;
1277: c = 0;
1278: overflow = FALSE;
1279: while (*ptr >= CHAR_0 && *ptr <= CHAR_7)
1280: {
1281: register pcre_uint32 cc = *ptr++;
1282: if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */
1283: #ifdef COMPILE_PCRE32
1284: if (c >= 0x20000000l) { overflow = TRUE; break; }
1285: #endif
1286: c = (c << 3) + cc - CHAR_0 ;
1287: #if defined COMPILE_PCRE8
1288: if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
1289: #elif defined COMPILE_PCRE16
1290: if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
1291: #elif defined COMPILE_PCRE32
1292: if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
1293: #endif
1294: }
1295: if (overflow)
1296: {
1297: while (*ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++;
1298: *errorcodeptr = ERR34;
1299: }
1300: else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
1301: {
1302: if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
1303: }
1304: else *errorcodeptr = ERR80;
1305: }
1306: break;
1307:
1308: /* \x is complicated. In JavaScript, \x must be followed by two hexadecimal
1309: numbers. Otherwise it is a lowercase x letter. */
1.1 misha 1310:
1.3 misha 1311: case CHAR_x:
1.6 misha 1312: if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
1313: {
1314: if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0
1315: && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0)
1316: {
1317: c = 0;
1318: for (i = 0; i < 2; ++i)
1319: {
1.7 misha 1320: register pcre_uint32 cc = *(++ptr);
1.6 misha 1321: #ifndef EBCDIC /* ASCII/UTF-8 coding */
1322: if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */
1323: c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
1324: #else /* EBCDIC coding */
1325: if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */
1326: c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
1327: #endif
1328: }
1329: }
1.8 moko 1330: } /* End JavaScript handling */
1331:
1332: /* Handle \x in Perl's style. \x{ddd} is a character number which can be
1333: greater than 0xff in utf or non-8bit mode, but only if the ddd are hex
1334: digits. If not, { used to be treated as a data character. However, Perl
1335: seems to read hex digits up to the first non-such, and ignore the rest, so
1336: that, for example \x{zz} matches a binary zero. This seems crazy, so PCRE
1337: now gives an error. */
1.6 misha 1338:
1.8 moko 1339: else
1.1 misha 1340: {
1.8 moko 1341: if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
1.1 misha 1342: {
1.8 moko 1343: ptr += 2;
1344: if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
1345: {
1346: *errorcodeptr = ERR86;
1347: break;
1348: }
1349: c = 0;
1350: overflow = FALSE;
1351: while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0)
1352: {
1353: register pcre_uint32 cc = *ptr++;
1354: if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */
1.1 misha 1355:
1.7 misha 1356: #ifdef COMPILE_PCRE32
1.8 moko 1357: if (c >= 0x10000000l) { overflow = TRUE; break; }
1.7 misha 1358: #endif
1359:
1.3 misha 1360: #ifndef EBCDIC /* ASCII/UTF-8 coding */
1.8 moko 1361: if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */
1362: c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
1.1 misha 1363: #else /* EBCDIC coding */
1.8 moko 1364: if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */
1365: c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
1.1 misha 1366: #endif
1.6 misha 1367:
1.7 misha 1368: #if defined COMPILE_PCRE8
1.8 moko 1369: if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
1.7 misha 1370: #elif defined COMPILE_PCRE16
1.8 moko 1371: if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
1.7 misha 1372: #elif defined COMPILE_PCRE32
1.8 moko 1373: if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
1.6 misha 1374: #endif
1.8 moko 1375: }
1376:
1377: if (overflow)
1378: {
1379: while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0) ptr++;
1380: *errorcodeptr = ERR34;
1381: }
1.6 misha 1382:
1.8 moko 1383: else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
1384: {
1385: if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
1386: }
1.1 misha 1387:
1.8 moko 1388: /* If the sequence of hex digits does not end with '}', give an error.
1389: We used just to recognize this construct and fall through to the normal
1390: \x handling, but nowadays Perl gives an error, which seems much more
1391: sensible, so we do too. */
1.1 misha 1392:
1.8 moko 1393: else *errorcodeptr = ERR79;
1394: } /* End of \x{} processing */
1.1 misha 1395:
1.8 moko 1396: /* Read a single-byte hex-defined char (up to two hex digits after \x) */
1.1 misha 1397:
1.8 moko 1398: else
1399: {
1400: c = 0;
1401: while (i++ < 2 && MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0)
1402: {
1403: pcre_uint32 cc; /* Some compilers don't like */
1404: cc = *(++ptr); /* ++ in initializers */
1.3 misha 1405: #ifndef EBCDIC /* ASCII/UTF-8 coding */
1.8 moko 1406: if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */
1407: c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
1.1 misha 1408: #else /* EBCDIC coding */
1.8 moko 1409: if (cc <= CHAR_z) cc += 64; /* Convert to upper case */
1410: c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
1.1 misha 1411: #endif
1.8 moko 1412: }
1413: } /* End of \xdd handling */
1414: } /* End of Perl-style \x handling */
1.1 misha 1415: break;
1416:
1417: /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
1.5 misha 1418: An error is given if the byte following \c is not an ASCII character. This
1419: coding is ASCII-specific, but then the whole concept of \cx is
1.1 misha 1420: ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
1421:
1.3 misha 1422: case CHAR_c:
1.1 misha 1423: c = *(++ptr);
1.7 misha 1424: if (c == CHAR_NULL)
1.1 misha 1425: {
1426: *errorcodeptr = ERR2;
1427: break;
1428: }
1.5 misha 1429: #ifndef EBCDIC /* ASCII/UTF-8 coding */
1430: if (c > 127) /* Excludes all non-ASCII in either mode */
1431: {
1432: *errorcodeptr = ERR68;
1433: break;
1434: }
1.3 misha 1435: if (c >= CHAR_a && c <= CHAR_z) c -= 32;
1.1 misha 1436: c ^= 0x40;
1.5 misha 1437: #else /* EBCDIC coding */
1.3 misha 1438: if (c >= CHAR_a && c <= CHAR_z) c += 64;
1.9 ! moko 1439: if (c == CHAR_QUESTION_MARK)
! 1440: c = ('\\' == 188 && '`' == 74)? 0x5f : 0xff;
! 1441: else
! 1442: {
! 1443: for (i = 0; i < 32; i++)
! 1444: {
! 1445: if (c == ebcdic_escape_c[i]) break;
! 1446: }
! 1447: if (i < 32) c = i; else *errorcodeptr = ERR68;
! 1448: }
1.1 misha 1449: #endif
1450: break;
1451:
1452: /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
1453: other alphanumeric following \ is an error if PCRE_EXTRA was set;
1454: otherwise, for Perl compatibility, it is a literal. This code looks a bit
1455: odd, but there used to be some cases other than the default, and there may
1456: be again in future, so I haven't "optimized" it. */
1457:
1458: default:
1459: if ((options & PCRE_EXTRA) != 0) switch(c)
1460: {
1461: default:
1462: *errorcodeptr = ERR3;
1463: break;
1464: }
1465: break;
1466: }
1467: }
1468:
1.4 misha 1469: /* Perl supports \N{name} for character names, as well as plain \N for "not
1.6 misha 1470: newline". PCRE does not support \N{name}. However, it does support
1471: quantification such as \N{2,3}. */
1.4 misha 1472:
1.7 misha 1473: if (escape == ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&
1.6 misha 1474: !is_counted_repeat(ptr+2))
1.4 misha 1475: *errorcodeptr = ERR37;
1476:
1477: /* If PCRE_UCP is set, we change the values for \d etc. */
1478:
1.7 misha 1479: if ((options & PCRE_UCP) != 0 && escape >= ESC_D && escape <= ESC_w)
1480: escape += (ESC_DU - ESC_D);
1.4 misha 1481:
1482: /* Set the pointer to the final character before returning. */
1483:
1.1 misha 1484: *ptrptr = ptr;
1.7 misha 1485: *chptr = c;
1486: return escape;
1.1 misha 1487: }
1488:
1.8 moko 1489:
1490:
1.1 misha 1491: #ifdef SUPPORT_UCP
1492: /*************************************************
1493: * Handle \P and \p *
1494: *************************************************/
1495:
1496: /* This function is called after \P or \p has been encountered, provided that
1497: PCRE is compiled with support for Unicode properties. On entry, ptrptr is
1498: pointing at the P or p. On exit, it is pointing at the final character of the
1499: escape sequence.
1500:
1501: Argument:
1502: ptrptr points to the pattern position pointer
1503: negptr points to a boolean that is set TRUE for negation else FALSE
1.7 misha 1504: ptypeptr points to an unsigned int that is set to the type value
1505: pdataptr points to an unsigned int that is set to the detailed property value
1.1 misha 1506: errorcodeptr points to the error code variable
1507:
1.7 misha 1508: Returns: TRUE if the type value was found, or FALSE for an invalid type
1.1 misha 1509: */
1510:
1.7 misha 1511: static BOOL
1512: get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, unsigned int *ptypeptr,
1513: unsigned int *pdataptr, int *errorcodeptr)
1.1 misha 1514: {
1.7 misha 1515: pcre_uchar c;
1516: int i, bot, top;
1.6 misha 1517: const pcre_uchar *ptr = *ptrptr;
1518: pcre_uchar name[32];
1.1 misha 1519:
1520: c = *(++ptr);
1.7 misha 1521: if (c == CHAR_NULL) goto ERROR_RETURN;
1.1 misha 1522:
1523: *negptr = FALSE;
1524:
1525: /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
1526: negation. */
1527:
1.3 misha 1528: if (c == CHAR_LEFT_CURLY_BRACKET)
1.1 misha 1529: {
1.3 misha 1530: if (ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
1.1 misha 1531: {
1532: *negptr = TRUE;
1533: ptr++;
1534: }
1.6 misha 1535: for (i = 0; i < (int)(sizeof(name) / sizeof(pcre_uchar)) - 1; i++)
1.1 misha 1536: {
1537: c = *(++ptr);
1.7 misha 1538: if (c == CHAR_NULL) goto ERROR_RETURN;
1.3 misha 1539: if (c == CHAR_RIGHT_CURLY_BRACKET) break;
1.1 misha 1540: name[i] = c;
1541: }
1.3 misha 1542: if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;
1.1 misha 1543: name[i] = 0;
1544: }
1545:
1546: /* Otherwise there is just one following character */
1547:
1548: else
1549: {
1550: name[0] = c;
1551: name[1] = 0;
1552: }
1553:
1554: *ptrptr = ptr;
1555:
1556: /* Search for a recognized property name using binary chop */
1557:
1558: bot = 0;
1.6 misha 1559: top = PRIV(utt_size);
1.1 misha 1560:
1561: while (bot < top)
1562: {
1.7 misha 1563: int r;
1.1 misha 1564: i = (bot + top) >> 1;
1.7 misha 1565: r = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);
1566: if (r == 0)
1.1 misha 1567: {
1.7 misha 1568: *ptypeptr = PRIV(utt)[i].type;
1569: *pdataptr = PRIV(utt)[i].value;
1570: return TRUE;
1.1 misha 1571: }
1.7 misha 1572: if (r > 0) bot = i + 1; else top = i;
1.1 misha 1573: }
1574:
1575: *errorcodeptr = ERR47;
1576: *ptrptr = ptr;
1.7 misha 1577: return FALSE;
1.1 misha 1578:
1579: ERROR_RETURN:
1580: *errorcodeptr = ERR46;
1581: *ptrptr = ptr;
1.7 misha 1582: return FALSE;
1.1 misha 1583: }
1584: #endif
1585:
1586:
1587:
1588: /*************************************************
1589: * Read repeat counts *
1590: *************************************************/
1591:
1592: /* Read an item of the form {n,m} and return the values. This is called only
1593: after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
1594: so the syntax is guaranteed to be correct, but we need to check the values.
1595:
1596: Arguments:
1597: p pointer to first char after '{'
1598: minp pointer to int for min
1599: maxp pointer to int for max
1600: returned as -1 if no max
1601: errorcodeptr points to error code variable
1602:
1603: Returns: pointer to '}' on success;
1604: current ptr on error, with errorcodeptr set non-zero
1605: */
1606:
1.6 misha 1607: static const pcre_uchar *
1608: read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, int *errorcodeptr)
1.1 misha 1609: {
1610: int min = 0;
1611: int max = -1;
1612:
1.8 moko 1613: while (IS_DIGIT(*p))
1.1 misha 1614: {
1.8 moko 1615: min = min * 10 + (int)(*p++ - CHAR_0);
1616: if (min > 65535)
1617: {
1618: *errorcodeptr = ERR5;
1619: return p;
1620: }
1.1 misha 1621: }
1622:
1.3 misha 1623: if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else
1.1 misha 1624: {
1.3 misha 1625: if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)
1.1 misha 1626: {
1627: max = 0;
1.8 moko 1628: while(IS_DIGIT(*p))
1.1 misha 1629: {
1.8 moko 1630: max = max * 10 + (int)(*p++ - CHAR_0);
1631: if (max > 65535)
1632: {
1633: *errorcodeptr = ERR5;
1634: return p;
1635: }
1.1 misha 1636: }
1637: if (max < min)
1638: {
1639: *errorcodeptr = ERR4;
1640: return p;
1641: }
1642: }
1643: }
1644:
1645: *minp = min;
1646: *maxp = max;
1647: return p;
1648: }
1649:
1650:
1651:
1652: /*************************************************
1653: * Find first significant op code *
1654: *************************************************/
1655:
1656: /* This is called by several functions that scan a compiled expression looking
1657: for a fixed first character, or an anchoring op code etc. It skips over things
1.6 misha 1658: that do not influence this. For some calls, it makes sense to skip negative
1659: forward and all backward assertions, and also the \b assertion; for others it
1660: does not.
1.1 misha 1661:
1662: Arguments:
1663: code pointer to the start of the group
1664: skipassert TRUE if certain assertions are to be skipped
1665:
1666: Returns: pointer to the first significant opcode
1667: */
1668:
1.6 misha 1669: static const pcre_uchar*
1670: first_significant_code(const pcre_uchar *code, BOOL skipassert)
1.1 misha 1671: {
1672: for (;;)
1673: {
1674: switch ((int)*code)
1675: {
1676: case OP_ASSERT_NOT:
1677: case OP_ASSERTBACK:
1678: case OP_ASSERTBACK_NOT:
1679: if (!skipassert) return code;
1680: do code += GET(code, 1); while (*code == OP_ALT);
1.6 misha 1681: code += PRIV(OP_lengths)[*code];
1.1 misha 1682: break;
1683:
1684: case OP_WORD_BOUNDARY:
1685: case OP_NOT_WORD_BOUNDARY:
1686: if (!skipassert) return code;
1687: /* Fall through */
1688:
1689: case OP_CALLOUT:
1690: case OP_CREF:
1.8 moko 1691: case OP_DNCREF:
1.1 misha 1692: case OP_RREF:
1.8 moko 1693: case OP_DNRREF:
1.1 misha 1694: case OP_DEF:
1.6 misha 1695: code += PRIV(OP_lengths)[*code];
1.1 misha 1696: break;
1697:
1698: default:
1699: return code;
1700: }
1701: }
1702: /* Control never reaches here */
1703: }
1704:
1705:
1706:
1707: /*************************************************
1.4 misha 1708: * Find the fixed length of a branch *
1.1 misha 1709: *************************************************/
1710:
1.4 misha 1711: /* Scan a branch and compute the fixed length of subject that will match it,
1.1 misha 1712: if the length is fixed. This is needed for dealing with backward assertions.
1.4 misha 1713: In UTF8 mode, the result is in characters rather than bytes. The branch is
1714: temporarily terminated with OP_END when this function is called.
1715:
1716: This function is called when a backward assertion is encountered, so that if it
1717: fails, the error message can point to the correct place in the pattern.
1718: However, we cannot do this when the assertion contains subroutine calls,
1719: because they can be forward references. We solve this by remembering this case
1720: and doing the check at the end; a flag specifies which mode we are running in.
1.1 misha 1721:
1722: Arguments:
1723: code points to the start of the pattern (the bracket)
1.7 misha 1724: utf TRUE in UTF-8 / UTF-16 / UTF-32 mode
1.4 misha 1725: atend TRUE if called when the pattern is complete
1726: cd the "compile data" structure
1.8 moko 1727: recurses chain of recurse_check to catch mutual recursion
1.1 misha 1728:
1.4 misha 1729: Returns: the fixed length,
1730: or -1 if there is no fixed length,
1.6 misha 1731: or -2 if \C was encountered (in UTF-8 mode only)
1.4 misha 1732: or -3 if an OP_RECURSE item was encountered and atend is FALSE
1.6 misha 1733: or -4 if an unknown opcode was encountered (internal error)
1.1 misha 1734: */
1735:
1736: static int
1.8 moko 1737: find_fixedlength(pcre_uchar *code, BOOL utf, BOOL atend, compile_data *cd,
1738: recurse_check *recurses)
1.1 misha 1739: {
1740: int length = -1;
1.8 moko 1741: recurse_check this_recurse;
1.1 misha 1742: register int branchlength = 0;
1.6 misha 1743: register pcre_uchar *cc = code + 1 + LINK_SIZE;
1.1 misha 1744:
1745: /* Scan along the opcodes for this branch. If we get to the end of the
1746: branch, check the length against that of the other branches. */
1747:
1748: for (;;)
1749: {
1750: int d;
1.6 misha 1751: pcre_uchar *ce, *cs;
1.7 misha 1752: register pcre_uchar op = *cc;
1.6 misha 1753:
1.1 misha 1754: switch (op)
1755: {
1.6 misha 1756: /* We only need to continue for OP_CBRA (normal capturing bracket) and
1757: OP_BRA (normal non-capturing bracket) because the other variants of these
1758: opcodes are all concerned with unlimited repeated groups, which of course
1759: are not of fixed length. */
1760:
1.1 misha 1761: case OP_CBRA:
1762: case OP_BRA:
1763: case OP_ONCE:
1.6 misha 1764: case OP_ONCE_NC:
1.1 misha 1765: case OP_COND:
1.8 moko 1766: d = find_fixedlength(cc + ((op == OP_CBRA)? IMM2_SIZE : 0), utf, atend, cd,
1767: recurses);
1.1 misha 1768: if (d < 0) return d;
1769: branchlength += d;
1770: do cc += GET(cc, 1); while (*cc == OP_ALT);
1771: cc += 1 + LINK_SIZE;
1772: break;
1773:
1.6 misha 1774: /* Reached end of a branch; if it's a ket it is the end of a nested call.
1775: If it's ALT it is an alternation in a nested call. An ACCEPT is effectively
1776: an ALT. If it is END it's the end of the outer call. All can be handled by
1777: the same code. Note that we must not include the OP_KETRxxx opcodes here,
1778: because they all imply an unlimited repeat. */
1.1 misha 1779:
1780: case OP_ALT:
1781: case OP_KET:
1782: case OP_END:
1.6 misha 1783: case OP_ACCEPT:
1784: case OP_ASSERT_ACCEPT:
1.1 misha 1785: if (length < 0) length = branchlength;
1786: else if (length != branchlength) return -1;
1787: if (*cc != OP_ALT) return length;
1788: cc += 1 + LINK_SIZE;
1789: branchlength = 0;
1790: break;
1791:
1.4 misha 1792: /* A true recursion implies not fixed length, but a subroutine call may
1793: be OK. If the subroutine is a forward reference, we can't deal with
1794: it until the end of the pattern, so return -3. */
1795:
1796: case OP_RECURSE:
1797: if (!atend) return -3;
1.6 misha 1798: cs = ce = (pcre_uchar *)cd->start_code + GET(cc, 1); /* Start subpattern */
1799: do ce += GET(ce, 1); while (*ce == OP_ALT); /* End subpattern */
1800: if (cc > cs && cc < ce) return -1; /* Recursion */
1.8 moko 1801: else /* Check for mutual recursion */
1802: {
1803: recurse_check *r = recurses;
1804: for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;
1805: if (r != NULL) return -1; /* Mutual recursion */
1806: }
1807: this_recurse.prev = recurses;
1808: this_recurse.group = cs;
1809: d = find_fixedlength(cs + IMM2_SIZE, utf, atend, cd, &this_recurse);
1.4 misha 1810: if (d < 0) return d;
1811: branchlength += d;
1812: cc += 1 + LINK_SIZE;
1813: break;
1814:
1.1 misha 1815: /* Skip over assertive subpatterns */
1816:
1817: case OP_ASSERT:
1818: case OP_ASSERT_NOT:
1819: case OP_ASSERTBACK:
1820: case OP_ASSERTBACK_NOT:
1821: do cc += GET(cc, 1); while (*cc == OP_ALT);
1.9 ! moko 1822: cc += 1 + LINK_SIZE;
1.6 misha 1823: break;
1.1 misha 1824:
1825: /* Skip over things that don't match chars */
1826:
1.6 misha 1827: case OP_MARK:
1828: case OP_PRUNE_ARG:
1829: case OP_SKIP_ARG:
1830: case OP_THEN_ARG:
1831: cc += cc[1] + PRIV(OP_lengths)[*cc];
1832: break;
1833:
1834: case OP_CALLOUT:
1835: case OP_CIRC:
1836: case OP_CIRCM:
1837: case OP_CLOSE:
1838: case OP_COMMIT:
1.1 misha 1839: case OP_CREF:
1.6 misha 1840: case OP_DEF:
1.8 moko 1841: case OP_DNCREF:
1842: case OP_DNRREF:
1.6 misha 1843: case OP_DOLL:
1844: case OP_DOLLM:
1845: case OP_EOD:
1846: case OP_EODN:
1847: case OP_FAIL:
1848: case OP_NOT_WORD_BOUNDARY:
1849: case OP_PRUNE:
1850: case OP_REVERSE:
1.1 misha 1851: case OP_RREF:
1.6 misha 1852: case OP_SET_SOM:
1853: case OP_SKIP:
1.1 misha 1854: case OP_SOD:
1855: case OP_SOM:
1.6 misha 1856: case OP_THEN:
1.1 misha 1857: case OP_WORD_BOUNDARY:
1.6 misha 1858: cc += PRIV(OP_lengths)[*cc];
1.1 misha 1859: break;
1860:
1861: /* Handle literal characters */
1862:
1863: case OP_CHAR:
1.6 misha 1864: case OP_CHARI:
1.1 misha 1865: case OP_NOT:
1.6 misha 1866: case OP_NOTI:
1.1 misha 1867: branchlength++;
1868: cc += 2;
1.6 misha 1869: #ifdef SUPPORT_UTF
1870: if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1.1 misha 1871: #endif
1872: break;
1873:
1874: /* Handle exact repetitions. The count is already in characters, but we
1875: need to skip over a multibyte character in UTF8 mode. */
1876:
1877: case OP_EXACT:
1.6 misha 1878: case OP_EXACTI:
1879: case OP_NOTEXACT:
1880: case OP_NOTEXACTI:
1.7 misha 1881: branchlength += (int)GET2(cc,1);
1.6 misha 1882: cc += 2 + IMM2_SIZE;
1883: #ifdef SUPPORT_UTF
1884: if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1.1 misha 1885: #endif
1886: break;
1887:
1888: case OP_TYPEEXACT:
1889: branchlength += GET2(cc,1);
1.7 misha 1890: if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP)
1891: cc += 2;
1.6 misha 1892: cc += 1 + IMM2_SIZE + 1;
1.1 misha 1893: break;
1894:
1895: /* Handle single-char matchers */
1896:
1897: case OP_PROP:
1898: case OP_NOTPROP:
1899: cc += 2;
1900: /* Fall through */
1901:
1.6 misha 1902: case OP_HSPACE:
1903: case OP_VSPACE:
1904: case OP_NOT_HSPACE:
1905: case OP_NOT_VSPACE:
1.1 misha 1906: case OP_NOT_DIGIT:
1907: case OP_DIGIT:
1908: case OP_NOT_WHITESPACE:
1909: case OP_WHITESPACE:
1910: case OP_NOT_WORDCHAR:
1911: case OP_WORDCHAR:
1912: case OP_ANY:
1913: case OP_ALLANY:
1914: branchlength++;
1915: cc++;
1916: break;
1917:
1.6 misha 1918: /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode;
1919: otherwise \C is coded as OP_ALLANY. */
1.1 misha 1920:
1921: case OP_ANYBYTE:
1922: return -2;
1923:
1924: /* Check a class for variable quantification */
1925:
1926: case OP_CLASS:
1927: case OP_NCLASS:
1.7 misha 1928: #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
1929: case OP_XCLASS:
1930: /* The original code caused an unsigned overflow in 64 bit systems,
1931: so now we use a conditional statement. */
1932: if (op == OP_XCLASS)
1933: cc += GET(cc, 1);
1934: else
1935: cc += PRIV(OP_lengths)[OP_CLASS];
1936: #else
1.6 misha 1937: cc += PRIV(OP_lengths)[OP_CLASS];
1.7 misha 1938: #endif
1.1 misha 1939:
1940: switch (*cc)
1941: {
1.8 moko 1942: case OP_CRSTAR:
1943: case OP_CRMINSTAR:
1.6 misha 1944: case OP_CRPLUS:
1945: case OP_CRMINPLUS:
1.1 misha 1946: case OP_CRQUERY:
1947: case OP_CRMINQUERY:
1.8 moko 1948: case OP_CRPOSSTAR:
1949: case OP_CRPOSPLUS:
1950: case OP_CRPOSQUERY:
1.1 misha 1951: return -1;
1952:
1953: case OP_CRRANGE:
1954: case OP_CRMINRANGE:
1.8 moko 1955: case OP_CRPOSRANGE:
1.6 misha 1956: if (GET2(cc,1) != GET2(cc,1+IMM2_SIZE)) return -1;
1.7 misha 1957: branchlength += (int)GET2(cc,1);
1.6 misha 1958: cc += 1 + 2 * IMM2_SIZE;
1.1 misha 1959: break;
1960:
1961: default:
1962: branchlength++;
1963: }
1964: break;
1965:
1966: /* Anything else is variable length */
1967:
1.6 misha 1968: case OP_ANYNL:
1969: case OP_BRAMINZERO:
1970: case OP_BRAPOS:
1971: case OP_BRAPOSZERO:
1972: case OP_BRAZERO:
1973: case OP_CBRAPOS:
1974: case OP_EXTUNI:
1975: case OP_KETRMAX:
1976: case OP_KETRMIN:
1977: case OP_KETRPOS:
1978: case OP_MINPLUS:
1979: case OP_MINPLUSI:
1980: case OP_MINQUERY:
1981: case OP_MINQUERYI:
1982: case OP_MINSTAR:
1983: case OP_MINSTARI:
1984: case OP_MINUPTO:
1985: case OP_MINUPTOI:
1986: case OP_NOTMINPLUS:
1987: case OP_NOTMINPLUSI:
1988: case OP_NOTMINQUERY:
1989: case OP_NOTMINQUERYI:
1990: case OP_NOTMINSTAR:
1991: case OP_NOTMINSTARI:
1992: case OP_NOTMINUPTO:
1993: case OP_NOTMINUPTOI:
1994: case OP_NOTPLUS:
1995: case OP_NOTPLUSI:
1996: case OP_NOTPOSPLUS:
1997: case OP_NOTPOSPLUSI:
1998: case OP_NOTPOSQUERY:
1999: case OP_NOTPOSQUERYI:
2000: case OP_NOTPOSSTAR:
2001: case OP_NOTPOSSTARI:
2002: case OP_NOTPOSUPTO:
2003: case OP_NOTPOSUPTOI:
2004: case OP_NOTQUERY:
2005: case OP_NOTQUERYI:
2006: case OP_NOTSTAR:
2007: case OP_NOTSTARI:
2008: case OP_NOTUPTO:
2009: case OP_NOTUPTOI:
2010: case OP_PLUS:
2011: case OP_PLUSI:
2012: case OP_POSPLUS:
2013: case OP_POSPLUSI:
2014: case OP_POSQUERY:
2015: case OP_POSQUERYI:
2016: case OP_POSSTAR:
2017: case OP_POSSTARI:
2018: case OP_POSUPTO:
2019: case OP_POSUPTOI:
2020: case OP_QUERY:
2021: case OP_QUERYI:
2022: case OP_REF:
2023: case OP_REFI:
1.8 moko 2024: case OP_DNREF:
2025: case OP_DNREFI:
1.6 misha 2026: case OP_SBRA:
2027: case OP_SBRAPOS:
2028: case OP_SCBRA:
2029: case OP_SCBRAPOS:
2030: case OP_SCOND:
2031: case OP_SKIPZERO:
2032: case OP_STAR:
2033: case OP_STARI:
2034: case OP_TYPEMINPLUS:
2035: case OP_TYPEMINQUERY:
2036: case OP_TYPEMINSTAR:
2037: case OP_TYPEMINUPTO:
2038: case OP_TYPEPLUS:
2039: case OP_TYPEPOSPLUS:
2040: case OP_TYPEPOSQUERY:
2041: case OP_TYPEPOSSTAR:
2042: case OP_TYPEPOSUPTO:
2043: case OP_TYPEQUERY:
2044: case OP_TYPESTAR:
2045: case OP_TYPEUPTO:
2046: case OP_UPTO:
2047: case OP_UPTOI:
2048: return -1;
2049:
2050: /* Catch unrecognized opcodes so that when new ones are added they
2051: are not forgotten, as has happened in the past. */
2052:
1.1 misha 2053: default:
1.6 misha 2054: return -4;
1.1 misha 2055: }
2056: }
2057: /* Control never gets here */
2058: }
2059:
2060:
2061:
2062: /*************************************************
1.4 misha 2063: * Scan compiled regex for specific bracket *
1.1 misha 2064: *************************************************/
2065:
2066: /* This little function scans through a compiled pattern until it finds a
1.4 misha 2067: capturing bracket with the given number, or, if the number is negative, an
2068: instance of OP_REVERSE for a lookbehind. The function is global in the C sense
2069: so that it can be called from pcre_study() when finding the minimum matching
2070: length.
1.1 misha 2071:
2072: Arguments:
2073: code points to start of expression
1.7 misha 2074: utf TRUE in UTF-8 / UTF-16 / UTF-32 mode
1.4 misha 2075: number the required bracket number or negative to find a lookbehind
1.1 misha 2076:
2077: Returns: pointer to the opcode for the bracket, or NULL if not found
2078: */
2079:
1.6 misha 2080: const pcre_uchar *
2081: PRIV(find_bracket)(const pcre_uchar *code, BOOL utf, int number)
1.1 misha 2082: {
2083: for (;;)
2084: {
1.7 misha 2085: register pcre_uchar c = *code;
1.6 misha 2086:
1.1 misha 2087: if (c == OP_END) return NULL;
2088:
2089: /* XCLASS is used for classes that cannot be represented just by a bit
2090: map. This includes negated single high-valued characters. The length in
2091: the table is zero; the actual length is stored in the compiled code. */
2092:
2093: if (c == OP_XCLASS) code += GET(code, 1);
2094:
1.4 misha 2095: /* Handle recursion */
2096:
2097: else if (c == OP_REVERSE)
2098: {
1.6 misha 2099: if (number < 0) return (pcre_uchar *)code;
2100: code += PRIV(OP_lengths)[c];
1.4 misha 2101: }
2102:
1.1 misha 2103: /* Handle capturing bracket */
2104:
1.6 misha 2105: else if (c == OP_CBRA || c == OP_SCBRA ||
2106: c == OP_CBRAPOS || c == OP_SCBRAPOS)
1.1 misha 2107: {
1.7 misha 2108: int n = (int)GET2(code, 1+LINK_SIZE);
1.6 misha 2109: if (n == number) return (pcre_uchar *)code;
2110: code += PRIV(OP_lengths)[c];
1.1 misha 2111: }
2112:
2113: /* Otherwise, we can get the item's length from the table, except that for
2114: repeated character types, we have to test for \p and \P, which have an extra
1.4 misha 2115: two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
2116: must add in its length. */
1.1 misha 2117:
2118: else
2119: {
2120: switch(c)
2121: {
2122: case OP_TYPESTAR:
2123: case OP_TYPEMINSTAR:
2124: case OP_TYPEPLUS:
2125: case OP_TYPEMINPLUS:
2126: case OP_TYPEQUERY:
2127: case OP_TYPEMINQUERY:
2128: case OP_TYPEPOSSTAR:
2129: case OP_TYPEPOSPLUS:
2130: case OP_TYPEPOSQUERY:
2131: if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2132: break;
2133:
2134: case OP_TYPEUPTO:
2135: case OP_TYPEMINUPTO:
2136: case OP_TYPEEXACT:
2137: case OP_TYPEPOSUPTO:
1.7 misha 2138: if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2139: code += 2;
1.1 misha 2140: break;
1.4 misha 2141:
2142: case OP_MARK:
2143: case OP_PRUNE_ARG:
2144: case OP_SKIP_ARG:
2145: case OP_THEN_ARG:
1.6 misha 2146: code += code[1];
1.4 misha 2147: break;
1.1 misha 2148: }
2149:
2150: /* Add in the fixed length from the table */
2151:
1.6 misha 2152: code += PRIV(OP_lengths)[c];
1.1 misha 2153:
2154: /* In UTF-8 mode, opcodes that are followed by a character may be followed by
2155: a multi-byte character. The length in the table is a minimum, so we have to
2156: arrange to skip the extra bytes. */
2157:
1.7 misha 2158: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.6 misha 2159: if (utf) switch(c)
1.1 misha 2160: {
2161: case OP_CHAR:
1.6 misha 2162: case OP_CHARI:
1.8 moko 2163: case OP_NOT:
2164: case OP_NOTI:
1.1 misha 2165: case OP_EXACT:
1.6 misha 2166: case OP_EXACTI:
1.8 moko 2167: case OP_NOTEXACT:
2168: case OP_NOTEXACTI:
1.1 misha 2169: case OP_UPTO:
1.6 misha 2170: case OP_UPTOI:
1.8 moko 2171: case OP_NOTUPTO:
2172: case OP_NOTUPTOI:
1.1 misha 2173: case OP_MINUPTO:
1.6 misha 2174: case OP_MINUPTOI:
1.8 moko 2175: case OP_NOTMINUPTO:
2176: case OP_NOTMINUPTOI:
1.1 misha 2177: case OP_POSUPTO:
1.6 misha 2178: case OP_POSUPTOI:
1.8 moko 2179: case OP_NOTPOSUPTO:
2180: case OP_NOTPOSUPTOI:
1.1 misha 2181: case OP_STAR:
1.6 misha 2182: case OP_STARI:
1.8 moko 2183: case OP_NOTSTAR:
2184: case OP_NOTSTARI:
1.1 misha 2185: case OP_MINSTAR:
1.6 misha 2186: case OP_MINSTARI:
1.8 moko 2187: case OP_NOTMINSTAR:
2188: case OP_NOTMINSTARI:
1.1 misha 2189: case OP_POSSTAR:
1.6 misha 2190: case OP_POSSTARI:
1.8 moko 2191: case OP_NOTPOSSTAR:
2192: case OP_NOTPOSSTARI:
1.1 misha 2193: case OP_PLUS:
1.6 misha 2194: case OP_PLUSI:
1.8 moko 2195: case OP_NOTPLUS:
2196: case OP_NOTPLUSI:
1.1 misha 2197: case OP_MINPLUS:
1.6 misha 2198: case OP_MINPLUSI:
1.8 moko 2199: case OP_NOTMINPLUS:
2200: case OP_NOTMINPLUSI:
1.1 misha 2201: case OP_POSPLUS:
1.6 misha 2202: case OP_POSPLUSI:
1.8 moko 2203: case OP_NOTPOSPLUS:
2204: case OP_NOTPOSPLUSI:
1.1 misha 2205: case OP_QUERY:
1.6 misha 2206: case OP_QUERYI:
1.8 moko 2207: case OP_NOTQUERY:
2208: case OP_NOTQUERYI:
1.1 misha 2209: case OP_MINQUERY:
1.6 misha 2210: case OP_MINQUERYI:
1.8 moko 2211: case OP_NOTMINQUERY:
2212: case OP_NOTMINQUERYI:
1.1 misha 2213: case OP_POSQUERY:
1.6 misha 2214: case OP_POSQUERYI:
1.8 moko 2215: case OP_NOTPOSQUERY:
2216: case OP_NOTPOSQUERYI:
1.6 misha 2217: if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
1.1 misha 2218: break;
2219: }
1.2 misha 2220: #else
1.6 misha 2221: (void)(utf); /* Keep compiler happy by referencing function argument */
1.1 misha 2222: #endif
2223: }
2224: }
2225: }
2226:
2227:
2228:
2229: /*************************************************
2230: * Scan compiled regex for recursion reference *
2231: *************************************************/
2232:
2233: /* This little function scans through a compiled pattern until it finds an
2234: instance of OP_RECURSE.
2235:
2236: Arguments:
2237: code points to start of expression
1.7 misha 2238: utf TRUE in UTF-8 / UTF-16 / UTF-32 mode
1.1 misha 2239:
2240: Returns: pointer to the opcode for OP_RECURSE, or NULL if not found
2241: */
2242:
1.6 misha 2243: static const pcre_uchar *
2244: find_recurse(const pcre_uchar *code, BOOL utf)
1.1 misha 2245: {
2246: for (;;)
2247: {
1.7 misha 2248: register pcre_uchar c = *code;
1.1 misha 2249: if (c == OP_END) return NULL;
2250: if (c == OP_RECURSE) return code;
2251:
2252: /* XCLASS is used for classes that cannot be represented just by a bit
2253: map. This includes negated single high-valued characters. The length in
2254: the table is zero; the actual length is stored in the compiled code. */
2255:
2256: if (c == OP_XCLASS) code += GET(code, 1);
2257:
2258: /* Otherwise, we can get the item's length from the table, except that for
2259: repeated character types, we have to test for \p and \P, which have an extra
1.4 misha 2260: two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
2261: must add in its length. */
1.1 misha 2262:
2263: else
2264: {
2265: switch(c)
2266: {
2267: case OP_TYPESTAR:
2268: case OP_TYPEMINSTAR:
2269: case OP_TYPEPLUS:
2270: case OP_TYPEMINPLUS:
2271: case OP_TYPEQUERY:
2272: case OP_TYPEMINQUERY:
2273: case OP_TYPEPOSSTAR:
2274: case OP_TYPEPOSPLUS:
2275: case OP_TYPEPOSQUERY:
2276: if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2277: break;
2278:
2279: case OP_TYPEPOSUPTO:
2280: case OP_TYPEUPTO:
2281: case OP_TYPEMINUPTO:
2282: case OP_TYPEEXACT:
1.7 misha 2283: if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2284: code += 2;
1.1 misha 2285: break;
1.4 misha 2286:
2287: case OP_MARK:
2288: case OP_PRUNE_ARG:
2289: case OP_SKIP_ARG:
2290: case OP_THEN_ARG:
1.6 misha 2291: code += code[1];
1.4 misha 2292: break;
1.1 misha 2293: }
2294:
2295: /* Add in the fixed length from the table */
2296:
1.6 misha 2297: code += PRIV(OP_lengths)[c];
1.1 misha 2298:
2299: /* In UTF-8 mode, opcodes that are followed by a character may be followed
2300: by a multi-byte character. The length in the table is a minimum, so we have
2301: to arrange to skip the extra bytes. */
2302:
1.7 misha 2303: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.6 misha 2304: if (utf) switch(c)
1.1 misha 2305: {
2306: case OP_CHAR:
1.6 misha 2307: case OP_CHARI:
1.7 misha 2308: case OP_NOT:
2309: case OP_NOTI:
1.1 misha 2310: case OP_EXACT:
1.6 misha 2311: case OP_EXACTI:
1.7 misha 2312: case OP_NOTEXACT:
2313: case OP_NOTEXACTI:
1.1 misha 2314: case OP_UPTO:
1.6 misha 2315: case OP_UPTOI:
1.7 misha 2316: case OP_NOTUPTO:
2317: case OP_NOTUPTOI:
1.1 misha 2318: case OP_MINUPTO:
1.6 misha 2319: case OP_MINUPTOI:
1.7 misha 2320: case OP_NOTMINUPTO:
2321: case OP_NOTMINUPTOI:
1.1 misha 2322: case OP_POSUPTO:
1.6 misha 2323: case OP_POSUPTOI:
1.7 misha 2324: case OP_NOTPOSUPTO:
2325: case OP_NOTPOSUPTOI:
1.1 misha 2326: case OP_STAR:
1.6 misha 2327: case OP_STARI:
1.7 misha 2328: case OP_NOTSTAR:
2329: case OP_NOTSTARI:
1.1 misha 2330: case OP_MINSTAR:
1.6 misha 2331: case OP_MINSTARI:
1.7 misha 2332: case OP_NOTMINSTAR:
2333: case OP_NOTMINSTARI:
1.1 misha 2334: case OP_POSSTAR:
1.6 misha 2335: case OP_POSSTARI:
1.7 misha 2336: case OP_NOTPOSSTAR:
2337: case OP_NOTPOSSTARI:
1.1 misha 2338: case OP_PLUS:
1.6 misha 2339: case OP_PLUSI:
1.7 misha 2340: case OP_NOTPLUS:
2341: case OP_NOTPLUSI:
1.1 misha 2342: case OP_MINPLUS:
1.6 misha 2343: case OP_MINPLUSI:
1.7 misha 2344: case OP_NOTMINPLUS:
2345: case OP_NOTMINPLUSI:
1.1 misha 2346: case OP_POSPLUS:
1.6 misha 2347: case OP_POSPLUSI:
1.7 misha 2348: case OP_NOTPOSPLUS:
2349: case OP_NOTPOSPLUSI:
1.1 misha 2350: case OP_QUERY:
1.6 misha 2351: case OP_QUERYI:
1.7 misha 2352: case OP_NOTQUERY:
2353: case OP_NOTQUERYI:
1.1 misha 2354: case OP_MINQUERY:
1.6 misha 2355: case OP_MINQUERYI:
1.7 misha 2356: case OP_NOTMINQUERY:
2357: case OP_NOTMINQUERYI:
1.1 misha 2358: case OP_POSQUERY:
1.6 misha 2359: case OP_POSQUERYI:
1.7 misha 2360: case OP_NOTPOSQUERY:
2361: case OP_NOTPOSQUERYI:
1.6 misha 2362: if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
1.1 misha 2363: break;
2364: }
1.2 misha 2365: #else
1.6 misha 2366: (void)(utf); /* Keep compiler happy by referencing function argument */
1.1 misha 2367: #endif
2368: }
2369: }
2370: }
2371:
2372:
2373:
2374: /*************************************************
2375: * Scan compiled branch for non-emptiness *
2376: *************************************************/
2377:
2378: /* This function scans through a branch of a compiled pattern to see whether it
2379: can match the empty string or not. It is called from could_be_empty()
2380: below and from compile_branch() when checking for an unlimited repeat of a
2381: group that can match nothing. Note that first_significant_code() skips over
2382: backward and negative forward assertions when its final argument is TRUE. If we
2383: hit an unclosed bracket, we return "empty" - this means we've struck an inner
2384: bracket whose current branch will already have been scanned.
2385:
2386: Arguments:
2387: code points to start of search
2388: endcode points to where to stop
1.7 misha 2389: utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode
1.4 misha 2390: cd contains pointers to tables etc.
1.8 moko 2391: recurses chain of recurse_check to catch mutual recursion
1.1 misha 2392:
2393: Returns: TRUE if what is matched could be empty
2394: */
2395:
2396: static BOOL
1.6 misha 2397: could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,
1.8 moko 2398: BOOL utf, compile_data *cd, recurse_check *recurses)
1.1 misha 2399: {
1.7 misha 2400: register pcre_uchar c;
1.8 moko 2401: recurse_check this_recurse;
2402:
1.6 misha 2403: for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);
1.1 misha 2404: code < endcode;
1.6 misha 2405: code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))
1.1 misha 2406: {
1.6 misha 2407: const pcre_uchar *ccode;
1.1 misha 2408:
2409: c = *code;
2410:
2411: /* Skip over forward assertions; the other assertions are skipped by
2412: first_significant_code() with a TRUE final argument. */
2413:
2414: if (c == OP_ASSERT)
2415: {
2416: do code += GET(code, 1); while (*code == OP_ALT);
2417: c = *code;
2418: continue;
2419: }
2420:
1.6 misha 2421: /* For a recursion/subroutine call, if its end has been reached, which
2422: implies a backward reference subroutine call, we can scan it. If it's a
2423: forward reference subroutine call, we can't. To detect forward reference
2424: we have to scan up the list that is kept in the workspace. This function is
2425: called only when doing the real compile, not during the pre-compile that
2426: measures the size of the compiled pattern. */
1.1 misha 2427:
1.6 misha 2428: if (c == OP_RECURSE)
1.1 misha 2429: {
1.8 moko 2430: const pcre_uchar *scode = cd->start_code + GET(code, 1);
2431: const pcre_uchar *endgroup = scode;
1.6 misha 2432: BOOL empty_branch;
2433:
1.8 moko 2434: /* Test for forward reference or uncompleted reference. This is disabled
2435: when called to scan a completed pattern by setting cd->start_workspace to
2436: NULL. */
2437:
2438: if (cd->start_workspace != NULL)
2439: {
2440: const pcre_uchar *tcode;
2441: for (tcode = cd->start_workspace; tcode < cd->hwm; tcode += LINK_SIZE)
2442: if ((int)GET(tcode, 0) == (int)(code + 1 - cd->start_code)) return TRUE;
2443: if (GET(scode, 1) == 0) return TRUE; /* Unclosed */
2444: }
2445:
2446: /* If the reference is to a completed group, we need to detect whether this
2447: is a recursive call, as otherwise there will be an infinite loop. If it is
2448: a recursion, just skip over it. Simple recursions are easily detected. For
2449: mutual recursions we keep a chain on the stack. */
1.6 misha 2450:
1.8 moko 2451: do endgroup += GET(endgroup, 1); while (*endgroup == OP_ALT);
2452: if (code >= scode && code <= endgroup) continue; /* Simple recursion */
2453: else
2454: {
2455: recurse_check *r = recurses;
2456: for (r = recurses; r != NULL; r = r->prev)
2457: if (r->group == scode) break;
2458: if (r != NULL) continue; /* Mutual recursion */
2459: }
1.1 misha 2460:
1.8 moko 2461: /* Completed reference; scan the referenced group, remembering it on the
2462: stack chain to detect mutual recursions. */
1.4 misha 2463:
1.6 misha 2464: empty_branch = FALSE;
1.8 moko 2465: this_recurse.prev = recurses;
2466: this_recurse.group = scode;
1.6 misha 2467:
1.4 misha 2468: do
2469: {
1.8 moko 2470: if (could_be_empty_branch(scode, endcode, utf, cd, &this_recurse))
1.4 misha 2471: {
2472: empty_branch = TRUE;
2473: break;
2474: }
2475: scode += GET(scode, 1);
2476: }
2477: while (*scode == OP_ALT);
1.6 misha 2478:
1.4 misha 2479: if (!empty_branch) return FALSE; /* All branches are non-empty */
2480: continue;
2481: }
2482:
1.6 misha 2483: /* Groups with zero repeats can of course be empty; skip them. */
2484:
2485: if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO ||
2486: c == OP_BRAPOSZERO)
2487: {
2488: code += PRIV(OP_lengths)[c];
2489: do code += GET(code, 1); while (*code == OP_ALT);
2490: c = *code;
2491: continue;
2492: }
2493:
2494: /* A nested group that is already marked as "could be empty" can just be
2495: skipped. */
2496:
2497: if (c == OP_SBRA || c == OP_SBRAPOS ||
2498: c == OP_SCBRA || c == OP_SCBRAPOS)
2499: {
2500: do code += GET(code, 1); while (*code == OP_ALT);
2501: c = *code;
2502: continue;
2503: }
2504:
1.1 misha 2505: /* For other groups, scan the branches. */
2506:
1.6 misha 2507: if (c == OP_BRA || c == OP_BRAPOS ||
2508: c == OP_CBRA || c == OP_CBRAPOS ||
2509: c == OP_ONCE || c == OP_ONCE_NC ||
1.9 ! moko 2510: c == OP_COND || c == OP_SCOND)
1.1 misha 2511: {
2512: BOOL empty_branch;
2513: if (GET(code, 1) == 0) return TRUE; /* Hit unclosed bracket */
2514:
1.3 misha 2515: /* If a conditional group has only one branch, there is a second, implied,
2516: empty branch, so just skip over the conditional, because it could be empty.
2517: Otherwise, scan the individual branches of the group. */
1.1 misha 2518:
1.3 misha 2519: if (c == OP_COND && code[GET(code, 1)] != OP_ALT)
2520: code += GET(code, 1);
2521: else
1.1 misha 2522: {
1.3 misha 2523: empty_branch = FALSE;
2524: do
2525: {
1.8 moko 2526: if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd,
2527: recurses)) empty_branch = TRUE;
1.3 misha 2528: code += GET(code, 1);
2529: }
2530: while (*code == OP_ALT);
2531: if (!empty_branch) return FALSE; /* All branches are non-empty */
1.1 misha 2532: }
1.3 misha 2533:
1.1 misha 2534: c = *code;
2535: continue;
2536: }
2537:
2538: /* Handle the other opcodes */
2539:
2540: switch (c)
2541: {
2542: /* Check for quantifiers after a class. XCLASS is used for classes that
2543: cannot be represented just by a bit map. This includes negated single
1.6 misha 2544: high-valued characters. The length in PRIV(OP_lengths)[] is zero; the
1.1 misha 2545: actual length is stored in the compiled code, so we must update "code"
2546: here. */
2547:
1.6 misha 2548: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
1.1 misha 2549: case OP_XCLASS:
2550: ccode = code += GET(code, 1);
2551: goto CHECK_CLASS_REPEAT;
2552: #endif
2553:
2554: case OP_CLASS:
2555: case OP_NCLASS:
1.6 misha 2556: ccode = code + PRIV(OP_lengths)[OP_CLASS];
1.1 misha 2557:
1.6 misha 2558: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
1.1 misha 2559: CHECK_CLASS_REPEAT:
2560: #endif
2561:
2562: switch (*ccode)
2563: {
2564: case OP_CRSTAR: /* These could be empty; continue */
2565: case OP_CRMINSTAR:
2566: case OP_CRQUERY:
2567: case OP_CRMINQUERY:
1.8 moko 2568: case OP_CRPOSSTAR:
2569: case OP_CRPOSQUERY:
1.1 misha 2570: break;
2571:
2572: default: /* Non-repeat => class must match */
2573: case OP_CRPLUS: /* These repeats aren't empty */
2574: case OP_CRMINPLUS:
1.8 moko 2575: case OP_CRPOSPLUS:
1.1 misha 2576: return FALSE;
2577:
2578: case OP_CRRANGE:
2579: case OP_CRMINRANGE:
1.8 moko 2580: case OP_CRPOSRANGE:
1.1 misha 2581: if (GET2(ccode, 1) > 0) return FALSE; /* Minimum > 0 */
2582: break;
2583: }
2584: break;
2585:
2586: /* Opcodes that must match a character */
2587:
1.8 moko 2588: case OP_ANY:
2589: case OP_ALLANY:
2590: case OP_ANYBYTE:
2591:
1.1 misha 2592: case OP_PROP:
2593: case OP_NOTPROP:
1.8 moko 2594: case OP_ANYNL:
2595:
2596: case OP_NOT_HSPACE:
2597: case OP_HSPACE:
2598: case OP_NOT_VSPACE:
2599: case OP_VSPACE:
1.1 misha 2600: case OP_EXTUNI:
1.8 moko 2601:
1.1 misha 2602: case OP_NOT_DIGIT:
2603: case OP_DIGIT:
2604: case OP_NOT_WHITESPACE:
2605: case OP_WHITESPACE:
2606: case OP_NOT_WORDCHAR:
2607: case OP_WORDCHAR:
1.8 moko 2608:
1.1 misha 2609: case OP_CHAR:
1.6 misha 2610: case OP_CHARI:
1.1 misha 2611: case OP_NOT:
1.6 misha 2612: case OP_NOTI:
1.8 moko 2613:
1.1 misha 2614: case OP_PLUS:
1.8 moko 2615: case OP_PLUSI:
1.1 misha 2616: case OP_MINPLUS:
1.8 moko 2617: case OP_MINPLUSI:
2618:
1.1 misha 2619: case OP_NOTPLUS:
1.8 moko 2620: case OP_NOTPLUSI:
1.1 misha 2621: case OP_NOTMINPLUS:
1.8 moko 2622: case OP_NOTMINPLUSI:
2623:
2624: case OP_POSPLUS:
2625: case OP_POSPLUSI:
1.1 misha 2626: case OP_NOTPOSPLUS:
1.8 moko 2627: case OP_NOTPOSPLUSI:
2628:
2629: case OP_EXACT:
2630: case OP_EXACTI:
1.1 misha 2631: case OP_NOTEXACT:
1.8 moko 2632: case OP_NOTEXACTI:
2633:
1.1 misha 2634: case OP_TYPEPLUS:
2635: case OP_TYPEMINPLUS:
2636: case OP_TYPEPOSPLUS:
2637: case OP_TYPEEXACT:
1.8 moko 2638:
1.1 misha 2639: return FALSE;
2640:
2641: /* These are going to continue, as they may be empty, but we have to
2642: fudge the length for the \p and \P cases. */
2643:
2644: case OP_TYPESTAR:
2645: case OP_TYPEMINSTAR:
2646: case OP_TYPEPOSSTAR:
2647: case OP_TYPEQUERY:
2648: case OP_TYPEMINQUERY:
2649: case OP_TYPEPOSQUERY:
2650: if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2651: break;
2652:
2653: /* Same for these */
2654:
2655: case OP_TYPEUPTO:
2656: case OP_TYPEMINUPTO:
2657: case OP_TYPEPOSUPTO:
1.7 misha 2658: if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2659: code += 2;
1.1 misha 2660: break;
2661:
2662: /* End of branch */
2663:
2664: case OP_KET:
2665: case OP_KETRMAX:
2666: case OP_KETRMIN:
1.6 misha 2667: case OP_KETRPOS:
1.1 misha 2668: case OP_ALT:
2669: return TRUE;
2670:
2671: /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
1.8 moko 2672: MINUPTO, and POSUPTO and their caseless and negative versions may be
2673: followed by a multibyte character. */
1.1 misha 2674:
1.7 misha 2675: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.1 misha 2676: case OP_STAR:
1.6 misha 2677: case OP_STARI:
1.8 moko 2678: case OP_NOTSTAR:
2679: case OP_NOTSTARI:
2680:
1.1 misha 2681: case OP_MINSTAR:
1.6 misha 2682: case OP_MINSTARI:
1.8 moko 2683: case OP_NOTMINSTAR:
2684: case OP_NOTMINSTARI:
2685:
1.1 misha 2686: case OP_POSSTAR:
1.6 misha 2687: case OP_POSSTARI:
1.8 moko 2688: case OP_NOTPOSSTAR:
2689: case OP_NOTPOSSTARI:
2690:
1.1 misha 2691: case OP_QUERY:
1.6 misha 2692: case OP_QUERYI:
1.8 moko 2693: case OP_NOTQUERY:
2694: case OP_NOTQUERYI:
2695:
1.1 misha 2696: case OP_MINQUERY:
1.6 misha 2697: case OP_MINQUERYI:
1.8 moko 2698: case OP_NOTMINQUERY:
2699: case OP_NOTMINQUERYI:
2700:
1.1 misha 2701: case OP_POSQUERY:
1.6 misha 2702: case OP_POSQUERYI:
1.8 moko 2703: case OP_NOTPOSQUERY:
2704: case OP_NOTPOSQUERYI:
2705:
1.6 misha 2706: if (utf && HAS_EXTRALEN(code[1])) code += GET_EXTRALEN(code[1]);
1.4 misha 2707: break;
2708:
1.1 misha 2709: case OP_UPTO:
1.6 misha 2710: case OP_UPTOI:
1.8 moko 2711: case OP_NOTUPTO:
2712: case OP_NOTUPTOI:
2713:
1.1 misha 2714: case OP_MINUPTO:
1.6 misha 2715: case OP_MINUPTOI:
1.8 moko 2716: case OP_NOTMINUPTO:
2717: case OP_NOTMINUPTOI:
2718:
1.1 misha 2719: case OP_POSUPTO:
1.6 misha 2720: case OP_POSUPTOI:
1.8 moko 2721: case OP_NOTPOSUPTO:
2722: case OP_NOTPOSUPTOI:
2723:
1.6 misha 2724: if (utf && HAS_EXTRALEN(code[1 + IMM2_SIZE])) code += GET_EXTRALEN(code[1 + IMM2_SIZE]);
1.1 misha 2725: break;
2726: #endif
1.4 misha 2727:
2728: /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument
2729: string. */
2730:
2731: case OP_MARK:
2732: case OP_PRUNE_ARG:
2733: case OP_SKIP_ARG:
2734: case OP_THEN_ARG:
1.6 misha 2735: code += code[1];
1.4 misha 2736: break;
2737:
2738: /* None of the remaining opcodes are required to match a character. */
2739:
2740: default:
2741: break;
1.1 misha 2742: }
2743: }
2744:
2745: return TRUE;
2746: }
2747:
2748:
2749:
2750: /*************************************************
2751: * Scan compiled regex for non-emptiness *
2752: *************************************************/
2753:
2754: /* This function is called to check for left recursive calls. We want to check
2755: the current branch of the current pattern to see if it could match the empty
2756: string. If it could, we must look outwards for branches at other levels,
2757: stopping when we pass beyond the bracket which is the subject of the recursion.
1.6 misha 2758: This function is called only during the real compile, not during the
2759: pre-compile.
1.1 misha 2760:
2761: Arguments:
2762: code points to start of the recursion
2763: endcode points to where to stop (current RECURSE item)
2764: bcptr points to the chain of current (unclosed) branch starts
1.7 misha 2765: utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode
1.4 misha 2766: cd pointers to tables etc
1.1 misha 2767:
2768: Returns: TRUE if what is matched could be empty
2769: */
2770:
2771: static BOOL
1.6 misha 2772: could_be_empty(const pcre_uchar *code, const pcre_uchar *endcode,
2773: branch_chain *bcptr, BOOL utf, compile_data *cd)
1.1 misha 2774: {
1.4 misha 2775: while (bcptr != NULL && bcptr->current_branch >= code)
1.1 misha 2776: {
1.8 moko 2777: if (!could_be_empty_branch(bcptr->current_branch, endcode, utf, cd, NULL))
1.4 misha 2778: return FALSE;
1.1 misha 2779: bcptr = bcptr->outer;
2780: }
2781: return TRUE;
2782: }
2783:
2784:
2785:
2786: /*************************************************
1.8 moko 2787: * Base opcode of repeated opcodes *
1.1 misha 2788: *************************************************/
2789:
1.8 moko 2790: /* Returns the base opcode for repeated single character type opcodes. If the
2791: opcode is not a repeated character type, it returns with the original value.
2792:
2793: Arguments: c opcode
2794: Returns: base opcode for the type
2795: */
2796:
2797: static pcre_uchar
2798: get_repeat_base(pcre_uchar c)
2799: {
2800: return (c > OP_TYPEPOSUPTO)? c :
2801: (c >= OP_TYPESTAR)? OP_TYPESTAR :
2802: (c >= OP_NOTSTARI)? OP_NOTSTARI :
2803: (c >= OP_NOTSTAR)? OP_NOTSTAR :
2804: (c >= OP_STARI)? OP_STARI :
2805: OP_STAR;
2806: }
1.1 misha 2807:
2808:
2809:
1.8 moko 2810: #ifdef SUPPORT_UCP
2811: /*************************************************
2812: * Check a character and a property *
2813: *************************************************/
1.6 misha 2814:
1.8 moko 2815: /* This function is called by check_auto_possessive() when a property item
2816: is adjacent to a fixed character.
1.6 misha 2817:
1.1 misha 2818: Arguments:
1.8 moko 2819: c the character
2820: ptype the property type
2821: pdata the data for the type
2822: negated TRUE if it's a negated property (\P or \p{^)
1.1 misha 2823:
1.8 moko 2824: Returns: TRUE if auto-possessifying is OK
1.1 misha 2825: */
2826:
2827: static BOOL
1.8 moko 2828: check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata,
2829: BOOL negated)
1.1 misha 2830: {
1.8 moko 2831: const pcre_uint32 *p;
2832: const ucd_record *prop = GET_UCD(c);
2833:
2834: switch(ptype)
1.1 misha 2835: {
1.8 moko 2836: case PT_LAMP:
2837: return (prop->chartype == ucp_Lu ||
2838: prop->chartype == ucp_Ll ||
2839: prop->chartype == ucp_Lt) == negated;
2840:
2841: case PT_GC:
2842: return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;
2843:
2844: case PT_PC:
2845: return (pdata == prop->chartype) == negated;
2846:
2847: case PT_SC:
2848: return (pdata == prop->script) == negated;
2849:
2850: /* These are specials */
2851:
2852: case PT_ALNUM:
2853: return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2854: PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;
2855:
2856: /* Perl space used to exclude VT, but from Perl 5.18 it is included, which
2857: means that Perl space and POSIX space are now identical. PCRE was changed
2858: at release 8.34. */
2859:
2860: case PT_SPACE: /* Perl space */
2861: case PT_PXSPACE: /* POSIX space */
2862: switch(c)
2863: {
2864: HSPACE_CASES:
2865: VSPACE_CASES:
2866: return negated;
2867:
2868: default:
2869: return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated;
2870: }
2871: break; /* Control never reaches here */
2872:
2873: case PT_WORD:
2874: return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2875: PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
2876: c == CHAR_UNDERSCORE) == negated;
2877:
2878: case PT_CLIST:
2879: p = PRIV(ucd_caseless_sets) + prop->caseset;
2880: for (;;)
1.1 misha 2881: {
1.8 moko 2882: if (c < *p) return !negated;
2883: if (c == *p++) return negated;
1.1 misha 2884: }
1.8 moko 2885: break; /* Control never reaches here */
1.1 misha 2886: }
1.8 moko 2887:
1.1 misha 2888: return FALSE;
2889: }
1.8 moko 2890: #endif /* SUPPORT_UCP */
1.1 misha 2891:
2892:
2893:
2894: /*************************************************
1.8 moko 2895: * Fill the character property list *
1.1 misha 2896: *************************************************/
2897:
1.8 moko 2898: /* Checks whether the code points to an opcode that can take part in auto-
2899: possessification, and if so, fills a list with its properties.
1.1 misha 2900:
2901: Arguments:
1.8 moko 2902: code points to start of expression
2903: utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode
2904: fcc points to case-flipping table
2905: list points to output list
2906: list[0] will be filled with the opcode
2907: list[1] will be non-zero if this opcode
2908: can match an empty character string
2909: list[2..7] depends on the opcode
1.1 misha 2910:
1.8 moko 2911: Returns: points to the start of the next opcode if *code is accepted
2912: NULL if *code is not accepted
1.1 misha 2913: */
2914:
1.8 moko 2915: static const pcre_uchar *
2916: get_chr_property_list(const pcre_uchar *code, BOOL utf,
2917: const pcre_uint8 *fcc, pcre_uint32 *list)
1.1 misha 2918: {
1.8 moko 2919: pcre_uchar c = *code;
2920: pcre_uchar base;
2921: const pcre_uchar *end;
2922: pcre_uint32 chr;
2923:
2924: #ifdef SUPPORT_UCP
2925: pcre_uint32 *clist_dest;
2926: const pcre_uint32 *clist_src;
2927: #else
2928: utf = utf; /* Suppress "unused parameter" compiler warning */
2929: #endif
2930:
2931: list[0] = c;
2932: list[1] = FALSE;
2933: code++;
2934:
2935: if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
1.1 misha 2936: {
1.8 moko 2937: base = get_repeat_base(c);
2938: c -= (base - OP_STAR);
1.1 misha 2939:
1.8 moko 2940: if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO)
2941: code += IMM2_SIZE;
1.1 misha 2942:
1.8 moko 2943: list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT && c != OP_POSPLUS);
1.1 misha 2944:
1.8 moko 2945: switch(base)
2946: {
2947: case OP_STAR:
2948: list[0] = OP_CHAR;
2949: break;
1.1 misha 2950:
1.8 moko 2951: case OP_STARI:
2952: list[0] = OP_CHARI;
2953: break;
1.1 misha 2954:
1.8 moko 2955: case OP_NOTSTAR:
2956: list[0] = OP_NOT;
2957: break;
1.1 misha 2958:
1.8 moko 2959: case OP_NOTSTARI:
2960: list[0] = OP_NOTI;
2961: break;
1.1 misha 2962:
1.8 moko 2963: case OP_TYPESTAR:
2964: list[0] = *code;
2965: code++;
2966: break;
2967: }
2968: c = list[0];
2969: }
1.1 misha 2970:
1.8 moko 2971: switch(c)
1.1 misha 2972: {
1.8 moko 2973: case OP_NOT_DIGIT:
2974: case OP_DIGIT:
2975: case OP_NOT_WHITESPACE:
2976: case OP_WHITESPACE:
2977: case OP_NOT_WORDCHAR:
2978: case OP_WORDCHAR:
2979: case OP_ANY:
2980: case OP_ALLANY:
2981: case OP_ANYNL:
2982: case OP_NOT_HSPACE:
2983: case OP_HSPACE:
2984: case OP_NOT_VSPACE:
2985: case OP_VSPACE:
2986: case OP_EXTUNI:
2987: case OP_EODN:
2988: case OP_EOD:
2989: case OP_DOLL:
2990: case OP_DOLLM:
2991: return code;
2992:
2993: case OP_CHAR:
2994: case OP_NOT:
2995: GETCHARINCTEST(chr, code);
2996: list[2] = chr;
2997: list[3] = NOTACHAR;
2998: return code;
2999:
3000: case OP_CHARI:
3001: case OP_NOTI:
3002: list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT;
3003: GETCHARINCTEST(chr, code);
3004: list[2] = chr;
1.1 misha 3005:
1.8 moko 3006: #ifdef SUPPORT_UCP
3007: if (chr < 128 || (chr < 256 && !utf))
3008: list[3] = fcc[chr];
3009: else
3010: list[3] = UCD_OTHERCASE(chr);
3011: #elif defined SUPPORT_UTF || !defined COMPILE_PCRE8
3012: list[3] = (chr < 256) ? fcc[chr] : chr;
3013: #else
3014: list[3] = fcc[chr];
3015: #endif
1.1 misha 3016:
1.8 moko 3017: /* The othercase might be the same value. */
1.1 misha 3018:
1.8 moko 3019: if (chr == list[3])
3020: list[3] = NOTACHAR;
3021: else
3022: list[4] = NOTACHAR;
3023: return code;
1.1 misha 3024:
1.8 moko 3025: #ifdef SUPPORT_UCP
3026: case OP_PROP:
3027: case OP_NOTPROP:
3028: if (code[0] != PT_CLIST)
1.1 misha 3029: {
1.8 moko 3030: list[2] = code[0];
3031: list[3] = code[1];
3032: return code + 2;
1.1 misha 3033: }
3034:
1.8 moko 3035: /* Convert only if we have enough space. */
3036:
3037: clist_src = PRIV(ucd_caseless_sets) + code[1];
3038: clist_dest = list + 2;
3039: code += 2;
1.1 misha 3040:
1.8 moko 3041: do {
3042: if (clist_dest >= list + 8)
3043: {
3044: /* Early return if there is not enough space. This should never
3045: happen, since all clists are shorter than 5 character now. */
3046: list[2] = code[0];
3047: list[3] = code[1];
3048: return code;
3049: }
3050: *clist_dest++ = *clist_src;
3051: }
3052: while(*clist_src++ != NOTACHAR);
1.1 misha 3053:
1.8 moko 3054: /* All characters are stored. The terminating NOTACHAR
3055: is copied form the clist itself. */
1.1 misha 3056:
1.8 moko 3057: list[0] = (c == OP_PROP) ? OP_CHAR : OP_NOT;
3058: return code;
3059: #endif
1.1 misha 3060:
1.8 moko 3061: case OP_NCLASS:
3062: case OP_CLASS:
3063: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3064: case OP_XCLASS:
3065: if (c == OP_XCLASS)
3066: end = code + GET(code, 0) - 1;
3067: else
3068: #endif
3069: end = code + 32 / sizeof(pcre_uchar);
1.1 misha 3070:
1.8 moko 3071: switch(*end)
3072: {
3073: case OP_CRSTAR:
3074: case OP_CRMINSTAR:
3075: case OP_CRQUERY:
3076: case OP_CRMINQUERY:
3077: case OP_CRPOSSTAR:
3078: case OP_CRPOSQUERY:
3079: list[1] = TRUE;
3080: end++;
3081: break;
1.1 misha 3082:
1.8 moko 3083: case OP_CRPLUS:
3084: case OP_CRMINPLUS:
3085: case OP_CRPOSPLUS:
3086: end++;
3087: break;
1.1 misha 3088:
1.8 moko 3089: case OP_CRRANGE:
3090: case OP_CRMINRANGE:
3091: case OP_CRPOSRANGE:
3092: list[1] = (GET2(end, 1) == 0);
3093: end += 1 + 2 * IMM2_SIZE;
3094: break;
3095: }
3096: list[2] = (pcre_uint32)(end - code);
3097: return end;
3098: }
3099: return NULL; /* Opcode not accepted */
1.1 misha 3100: }
3101:
3102:
3103:
3104: /*************************************************
1.8 moko 3105: * Scan further character sets for match *
1.1 misha 3106: *************************************************/
3107:
1.8 moko 3108: /* Checks whether the base and the current opcode have a common character, in
3109: which case the base cannot be possessified.
1.1 misha 3110:
3111: Arguments:
1.8 moko 3112: code points to the byte code
3113: utf TRUE in UTF-8 / UTF-16 / UTF-32 mode
3114: cd static compile data
3115: base_list the data list of the base opcode
1.1 misha 3116:
1.8 moko 3117: Returns: TRUE if the auto-possessification is possible
1.1 misha 3118: */
3119:
1.8 moko 3120: static BOOL
3121: compare_opcodes(const pcre_uchar *code, BOOL utf, const compile_data *cd,
3122: const pcre_uint32 *base_list, const pcre_uchar *base_end, int *rec_limit)
1.1 misha 3123: {
1.8 moko 3124: pcre_uchar c;
3125: pcre_uint32 list[8];
3126: const pcre_uint32 *chr_ptr;
3127: const pcre_uint32 *ochr_ptr;
3128: const pcre_uint32 *list_ptr;
3129: const pcre_uchar *next_code;
3130: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3131: const pcre_uchar *xclass_flags;
3132: #endif
3133: const pcre_uint8 *class_bitset;
3134: const pcre_uint8 *set1, *set2, *set_end;
3135: pcre_uint32 chr;
3136: BOOL accepted, invert_bits;
3137: BOOL entered_a_group = FALSE;
3138:
3139: if (*rec_limit == 0) return FALSE;
3140: --(*rec_limit);
3141:
3142: /* Note: the base_list[1] contains whether the current opcode has greedy
3143: (represented by a non-zero value) quantifier. This is a different from
3144: other character type lists, which stores here that the character iterator
3145: matches to an empty string (also represented by a non-zero value). */
1.1 misha 3146:
1.8 moko 3147: for(;;)
3148: {
3149: /* All operations move the code pointer forward.
3150: Therefore infinite recursions are not possible. */
1.1 misha 3151:
1.8 moko 3152: c = *code;
1.1 misha 3153:
1.8 moko 3154: /* Skip over callouts */
1.1 misha 3155:
1.8 moko 3156: if (c == OP_CALLOUT)
3157: {
3158: code += PRIV(OP_lengths)[c];
3159: continue;
3160: }
1.1 misha 3161:
1.8 moko 3162: if (c == OP_ALT)
3163: {
3164: do code += GET(code, 1); while (*code == OP_ALT);
3165: c = *code;
3166: }
1.1 misha 3167:
1.8 moko 3168: switch(c)
3169: {
3170: case OP_END:
3171: case OP_KETRPOS:
3172: /* TRUE only in greedy case. The non-greedy case could be replaced by
3173: an OP_EXACT, but it is probably not worth it. (And note that OP_EXACT
3174: uses more memory, which we cannot get at this stage.) */
1.1 misha 3175:
1.8 moko 3176: return base_list[1] != 0;
1.7 misha 3177:
1.8 moko 3178: case OP_KET:
3179: /* If the bracket is capturing, and referenced by an OP_RECURSE, or
3180: it is an atomic sub-pattern (assert, once, etc.) the non-greedy case
3181: cannot be converted to a possessive form. */
3182:
3183: if (base_list[1] == 0) return FALSE;
3184:
3185: switch(*(code - GET(code, 1)))
3186: {
3187: case OP_ASSERT:
3188: case OP_ASSERT_NOT:
3189: case OP_ASSERTBACK:
3190: case OP_ASSERTBACK_NOT:
3191: case OP_ONCE:
3192: case OP_ONCE_NC:
3193: /* Atomic sub-patterns and assertions can always auto-possessify their
3194: last iterator. However, if the group was entered as a result of checking
3195: a previous iterator, this is not possible. */
1.1 misha 3196:
1.8 moko 3197: return !entered_a_group;
3198: }
1.1 misha 3199:
1.8 moko 3200: code += PRIV(OP_lengths)[c];
3201: continue;
1.1 misha 3202:
1.8 moko 3203: case OP_ONCE:
3204: case OP_ONCE_NC:
3205: case OP_BRA:
3206: case OP_CBRA:
3207: next_code = code + GET(code, 1);
3208: code += PRIV(OP_lengths)[c];
1.1 misha 3209:
1.8 moko 3210: while (*next_code == OP_ALT)
3211: {
3212: if (!compare_opcodes(code, utf, cd, base_list, base_end, rec_limit))
3213: return FALSE;
3214: code = next_code + 1 + LINK_SIZE;
3215: next_code += GET(next_code, 1);
3216: }
1.1 misha 3217:
1.8 moko 3218: entered_a_group = TRUE;
3219: continue;
1.4 misha 3220:
1.8 moko 3221: case OP_BRAZERO:
3222: case OP_BRAMINZERO:
1.4 misha 3223:
1.8 moko 3224: next_code = code + 1;
3225: if (*next_code != OP_BRA && *next_code != OP_CBRA
3226: && *next_code != OP_ONCE && *next_code != OP_ONCE_NC) return FALSE;
3227:
3228: do next_code += GET(next_code, 1); while (*next_code == OP_ALT);
3229:
3230: /* The bracket content will be checked by the
3231: OP_BRA/OP_CBRA case above. */
3232: next_code += 1 + LINK_SIZE;
3233: if (!compare_opcodes(next_code, utf, cd, base_list, base_end, rec_limit))
3234: return FALSE;
1.4 misha 3235:
1.8 moko 3236: code += PRIV(OP_lengths)[c];
3237: continue;
1.4 misha 3238:
1.8 moko 3239: default:
3240: break;
3241: }
1.4 misha 3242:
1.8 moko 3243: /* Check for a supported opcode, and load its properties. */
1.4 misha 3244:
1.8 moko 3245: code = get_chr_property_list(code, utf, cd->fcc, list);
3246: if (code == NULL) return FALSE; /* Unsupported */
1.4 misha 3247:
1.8 moko 3248: /* If either opcode is a small character list, set pointers for comparing
3249: characters from that list with another list, or with a property. */
1.7 misha 3250:
1.8 moko 3251: if (base_list[0] == OP_CHAR)
3252: {
3253: chr_ptr = base_list + 2;
3254: list_ptr = list;
3255: }
3256: else if (list[0] == OP_CHAR)
3257: {
3258: chr_ptr = list + 2;
3259: list_ptr = base_list;
3260: }
1.7 misha 3261:
1.8 moko 3262: /* Character bitsets can also be compared to certain opcodes. */
1.4 misha 3263:
1.8 moko 3264: else if (base_list[0] == OP_CLASS || list[0] == OP_CLASS
3265: #ifdef COMPILE_PCRE8
3266: /* In 8 bit, non-UTF mode, OP_CLASS and OP_NCLASS are the same. */
3267: || (!utf && (base_list[0] == OP_NCLASS || list[0] == OP_NCLASS))
3268: #endif
3269: )
3270: {
3271: #ifdef COMPILE_PCRE8
3272: if (base_list[0] == OP_CLASS || (!utf && base_list[0] == OP_NCLASS))
3273: #else
3274: if (base_list[0] == OP_CLASS)
3275: #endif
3276: {
3277: set1 = (pcre_uint8 *)(base_end - base_list[2]);
3278: list_ptr = list;
3279: }
3280: else
3281: {
3282: set1 = (pcre_uint8 *)(code - list[2]);
3283: list_ptr = base_list;
3284: }
1.4 misha 3285:
1.8 moko 3286: invert_bits = FALSE;
3287: switch(list_ptr[0])
3288: {
3289: case OP_CLASS:
3290: case OP_NCLASS:
3291: set2 = (pcre_uint8 *)
3292: ((list_ptr == list ? code : base_end) - list_ptr[2]);
3293: break;
1.4 misha 3294:
1.8 moko 3295: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3296: case OP_XCLASS:
3297: xclass_flags = (list_ptr == list ? code : base_end) - list_ptr[2] + LINK_SIZE;
3298: if ((*xclass_flags & XCL_HASPROP) != 0) return FALSE;
3299: if ((*xclass_flags & XCL_MAP) == 0)
3300: {
3301: /* No bits are set for characters < 256. */
1.9 ! moko 3302: if (list[1] == 0) return (*xclass_flags & XCL_NOT) == 0;
1.8 moko 3303: /* Might be an empty repeat. */
3304: continue;
3305: }
3306: set2 = (pcre_uint8 *)(xclass_flags + 1);
3307: break;
3308: #endif
1.4 misha 3309:
1.8 moko 3310: case OP_NOT_DIGIT:
3311: invert_bits = TRUE;
3312: /* Fall through */
3313: case OP_DIGIT:
3314: set2 = (pcre_uint8 *)(cd->cbits + cbit_digit);
3315: break;
1.4 misha 3316:
1.8 moko 3317: case OP_NOT_WHITESPACE:
3318: invert_bits = TRUE;
3319: /* Fall through */
3320: case OP_WHITESPACE:
3321: set2 = (pcre_uint8 *)(cd->cbits + cbit_space);
3322: break;
1.4 misha 3323:
1.8 moko 3324: case OP_NOT_WORDCHAR:
3325: invert_bits = TRUE;
3326: /* Fall through */
3327: case OP_WORDCHAR:
3328: set2 = (pcre_uint8 *)(cd->cbits + cbit_word);
3329: break;
1.4 misha 3330:
1.8 moko 3331: default:
3332: return FALSE;
3333: }
3334:
3335: /* Because the sets are unaligned, we need
3336: to perform byte comparison here. */
3337: set_end = set1 + 32;
3338: if (invert_bits)
3339: {
3340: do
3341: {
3342: if ((*set1++ & ~(*set2++)) != 0) return FALSE;
3343: }
3344: while (set1 < set_end);
3345: }
3346: else
3347: {
3348: do
3349: {
3350: if ((*set1++ & *set2++) != 0) return FALSE;
3351: }
3352: while (set1 < set_end);
3353: }
3354:
3355: if (list[1] == 0) return TRUE;
3356: /* Might be an empty repeat. */
3357: continue;
3358: }
3359:
3360: /* Some property combinations also acceptable. Unicode property opcodes are
3361: processed specially; the rest can be handled with a lookup table. */
3362:
3363: else
3364: {
3365: pcre_uint32 leftop, rightop;
1.4 misha 3366:
1.8 moko 3367: leftop = base_list[0];
3368: rightop = list[0];
1.7 misha 3369:
3370: #ifdef SUPPORT_UCP
1.8 moko 3371: accepted = FALSE; /* Always set in non-unicode case. */
3372: if (leftop == OP_PROP || leftop == OP_NOTPROP)
3373: {
3374: if (rightop == OP_EOD)
3375: accepted = TRUE;
3376: else if (rightop == OP_PROP || rightop == OP_NOTPROP)
3377: {
3378: int n;
3379: const pcre_uint8 *p;
3380: BOOL same = leftop == rightop;
3381: BOOL lisprop = leftop == OP_PROP;
3382: BOOL risprop = rightop == OP_PROP;
3383: BOOL bothprop = lisprop && risprop;
3384:
3385: /* There's a table that specifies how each combination is to be
3386: processed:
3387: 0 Always return FALSE (never auto-possessify)
3388: 1 Character groups are distinct (possessify if both are OP_PROP)
3389: 2 Check character categories in the same group (general or particular)
3390: 3 Return TRUE if the two opcodes are not the same
3391: ... see comments below
3392: */
3393:
3394: n = propposstab[base_list[2]][list[2]];
3395: switch(n)
3396: {
3397: case 0: break;
3398: case 1: accepted = bothprop; break;
3399: case 2: accepted = (base_list[3] == list[3]) != same; break;
3400: case 3: accepted = !same; break;
3401:
3402: case 4: /* Left general category, right particular category */
3403: accepted = risprop && catposstab[base_list[3]][list[3]] == same;
3404: break;
3405:
3406: case 5: /* Right general category, left particular category */
3407: accepted = lisprop && catposstab[list[3]][base_list[3]] == same;
3408: break;
3409:
3410: /* This code is logically tricky. Think hard before fiddling with it.
3411: The posspropstab table has four entries per row. Each row relates to
3412: one of PCRE's special properties such as ALNUM or SPACE or WORD.
3413: Only WORD actually needs all four entries, but using repeats for the
3414: others means they can all use the same code below.
3415:
3416: The first two entries in each row are Unicode general categories, and
3417: apply always, because all the characters they include are part of the
3418: PCRE character set. The third and fourth entries are a general and a
3419: particular category, respectively, that include one or more relevant
3420: characters. One or the other is used, depending on whether the check
3421: is for a general or a particular category. However, in both cases the
3422: category contains more characters than the specials that are defined
3423: for the property being tested against. Therefore, it cannot be used
3424: in a NOTPROP case.
3425:
3426: Example: the row for WORD contains ucp_L, ucp_N, ucp_P, ucp_Po.
3427: Underscore is covered by ucp_P or ucp_Po. */
3428:
3429: case 6: /* Left alphanum vs right general category */
3430: case 7: /* Left space vs right general category */
3431: case 8: /* Left word vs right general category */
3432: p = posspropstab[n-6];
3433: accepted = risprop && lisprop ==
3434: (list[3] != p[0] &&
3435: list[3] != p[1] &&
3436: (list[3] != p[2] || !lisprop));
3437: break;
3438:
3439: case 9: /* Right alphanum vs left general category */
3440: case 10: /* Right space vs left general category */
3441: case 11: /* Right word vs left general category */
3442: p = posspropstab[n-9];
3443: accepted = lisprop && risprop ==
3444: (base_list[3] != p[0] &&
3445: base_list[3] != p[1] &&
3446: (base_list[3] != p[2] || !risprop));
3447: break;
3448:
3449: case 12: /* Left alphanum vs right particular category */
3450: case 13: /* Left space vs right particular category */
3451: case 14: /* Left word vs right particular category */
3452: p = posspropstab[n-12];
3453: accepted = risprop && lisprop ==
3454: (catposstab[p[0]][list[3]] &&
3455: catposstab[p[1]][list[3]] &&
3456: (list[3] != p[3] || !lisprop));
3457: break;
3458:
3459: case 15: /* Right alphanum vs left particular category */
3460: case 16: /* Right space vs left particular category */
3461: case 17: /* Right word vs left particular category */
3462: p = posspropstab[n-15];
3463: accepted = lisprop && risprop ==
3464: (catposstab[p[0]][base_list[3]] &&
3465: catposstab[p[1]][base_list[3]] &&
3466: (base_list[3] != p[3] || !risprop));
3467: break;
3468: }
3469: }
3470: }
3471:
3472: else
3473: #endif /* SUPPORT_UCP */
3474:
3475: accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP &&
3476: rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP &&
3477: autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP];
3478:
3479: if (!accepted) return FALSE;
3480:
3481: if (list[1] == 0) return TRUE;
3482: /* Might be an empty repeat. */
3483: continue;
3484: }
3485:
3486: /* Control reaches here only if one of the items is a small character list.
3487: All characters are checked against the other side. */
3488:
3489: do
1.7 misha 3490: {
1.8 moko 3491: chr = *chr_ptr;
3492:
3493: switch(list_ptr[0])
3494: {
3495: case OP_CHAR:
3496: ochr_ptr = list_ptr + 2;
3497: do
3498: {
3499: if (chr == *ochr_ptr) return FALSE;
3500: ochr_ptr++;
3501: }
3502: while(*ochr_ptr != NOTACHAR);
3503: break;
3504:
3505: case OP_NOT:
3506: ochr_ptr = list_ptr + 2;
3507: do
3508: {
3509: if (chr == *ochr_ptr)
3510: break;
3511: ochr_ptr++;
3512: }
3513: while(*ochr_ptr != NOTACHAR);
3514: if (*ochr_ptr == NOTACHAR) return FALSE; /* Not found */
3515: break;
3516:
3517: /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not*
3518: set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
3519:
3520: case OP_DIGIT:
3521: if (chr < 256 && (cd->ctypes[chr] & ctype_digit) != 0) return FALSE;
3522: break;
3523:
3524: case OP_NOT_DIGIT:
3525: if (chr > 255 || (cd->ctypes[chr] & ctype_digit) == 0) return FALSE;
3526: break;
3527:
3528: case OP_WHITESPACE:
3529: if (chr < 256 && (cd->ctypes[chr] & ctype_space) != 0) return FALSE;
3530: break;
3531:
3532: case OP_NOT_WHITESPACE:
3533: if (chr > 255 || (cd->ctypes[chr] & ctype_space) == 0) return FALSE;
3534: break;
3535:
3536: case OP_WORDCHAR:
3537: if (chr < 255 && (cd->ctypes[chr] & ctype_word) != 0) return FALSE;
3538: break;
3539:
3540: case OP_NOT_WORDCHAR:
3541: if (chr > 255 || (cd->ctypes[chr] & ctype_word) == 0) return FALSE;
3542: break;
3543:
3544: case OP_HSPACE:
3545: switch(chr)
3546: {
3547: HSPACE_CASES: return FALSE;
3548: default: break;
3549: }
3550: break;
3551:
3552: case OP_NOT_HSPACE:
3553: switch(chr)
3554: {
3555: HSPACE_CASES: break;
3556: default: return FALSE;
3557: }
3558: break;
3559:
3560: case OP_ANYNL:
3561: case OP_VSPACE:
3562: switch(chr)
3563: {
3564: VSPACE_CASES: return FALSE;
3565: default: break;
3566: }
3567: break;
3568:
3569: case OP_NOT_VSPACE:
3570: switch(chr)
3571: {
3572: VSPACE_CASES: break;
3573: default: return FALSE;
3574: }
3575: break;
3576:
3577: case OP_DOLL:
3578: case OP_EODN:
3579: switch (chr)
3580: {
3581: case CHAR_CR:
3582: case CHAR_LF:
3583: case CHAR_VT:
3584: case CHAR_FF:
3585: case CHAR_NEL:
3586: #ifndef EBCDIC
3587: case 0x2028:
3588: case 0x2029:
3589: #endif /* Not EBCDIC */
3590: return FALSE;
3591: }
3592: break;
3593:
3594: case OP_EOD: /* Can always possessify before \z */
3595: break;
3596:
3597: #ifdef SUPPORT_UCP
3598: case OP_PROP:
3599: case OP_NOTPROP:
3600: if (!check_char_prop(chr, list_ptr[2], list_ptr[3],
3601: list_ptr[0] == OP_NOTPROP))
3602: return FALSE;
3603: break;
3604: #endif
3605:
3606: case OP_NCLASS:
3607: if (chr > 255) return FALSE;
3608: /* Fall through */
3609:
3610: case OP_CLASS:
3611: if (chr > 255) break;
3612: class_bitset = (pcre_uint8 *)
3613: ((list_ptr == list ? code : base_end) - list_ptr[2]);
3614: if ((class_bitset[chr >> 3] & (1 << (chr & 7))) != 0) return FALSE;
3615: break;
3616:
3617: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3618: case OP_XCLASS:
3619: if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) -
3620: list_ptr[2] + LINK_SIZE, utf)) return FALSE;
3621: break;
3622: #endif
3623:
3624: default:
3625: return FALSE;
3626: }
3627:
3628: chr_ptr++;
1.7 misha 3629: }
1.8 moko 3630: while(*chr_ptr != NOTACHAR);
3631:
3632: /* At least one character must be matched from this opcode. */
3633:
3634: if (list[1] == 0) return TRUE;
1.4 misha 3635: }
1.7 misha 3636:
1.8 moko 3637: /* Control never reaches here. There used to be a fail-save return FALSE; here,
3638: but some compilers complain about an unreachable statement. */
3639:
1.4 misha 3640: }
1.1 misha 3641:
3642:
3643:
3644: /*************************************************
1.8 moko 3645: * Scan compiled regex for auto-possession *
1.1 misha 3646: *************************************************/
3647:
1.8 moko 3648: /* Replaces single character iterations with their possessive alternatives
3649: if appropriate. This function modifies the compiled opcode!
1.1 misha 3650:
3651: Arguments:
1.8 moko 3652: code points to start of the byte code
3653: utf TRUE in UTF-8 / UTF-16 / UTF-32 mode
3654: cd static compile data
1.1 misha 3655:
1.8 moko 3656: Returns: nothing
1.1 misha 3657: */
3658:
1.8 moko 3659: static void
3660: auto_possessify(pcre_uchar *code, BOOL utf, const compile_data *cd)
1.1 misha 3661: {
1.8 moko 3662: register pcre_uchar c;
3663: const pcre_uchar *end;
3664: pcre_uchar *repeat_opcode;
3665: pcre_uint32 list[8];
3666: int rec_limit;
3667:
3668: for (;;)
3669: {
3670: c = *code;
3671:
3672: /* When a pattern with bad UTF-8 encoding is compiled with NO_UTF_CHECK,
3673: it may compile without complaining, but may get into a loop here if the code
3674: pointer points to a bad value. This is, of course a documentated possibility,
3675: when NO_UTF_CHECK is set, so it isn't a bug, but we can detect this case and
3676: just give up on this optimization. */
1.1 misha 3677:
1.8 moko 3678: if (c >= OP_TABLE_LENGTH) return;
1.1 misha 3679:
1.8 moko 3680: if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
1.1 misha 3681: {
1.8 moko 3682: c -= get_repeat_base(c) - OP_STAR;
3683: end = (c <= OP_MINUPTO) ?
3684: get_chr_property_list(code, utf, cd->fcc, list) : NULL;
3685: list[1] = c == OP_STAR || c == OP_PLUS || c == OP_QUERY || c == OP_UPTO;
3686:
3687: rec_limit = 1000;
3688: if (end != NULL && compare_opcodes(end, utf, cd, list, end, &rec_limit))
1.1 misha 3689: {
1.8 moko 3690: switch(c)
1.5 misha 3691: {
1.8 moko 3692: case OP_STAR:
3693: *code += OP_POSSTAR - OP_STAR;
3694: break;
3695:
3696: case OP_MINSTAR:
3697: *code += OP_POSSTAR - OP_MINSTAR;
3698: break;
3699:
3700: case OP_PLUS:
3701: *code += OP_POSPLUS - OP_PLUS;
3702: break;
3703:
3704: case OP_MINPLUS:
3705: *code += OP_POSPLUS - OP_MINPLUS;
3706: break;
3707:
3708: case OP_QUERY:
3709: *code += OP_POSQUERY - OP_QUERY;
3710: break;
3711:
3712: case OP_MINQUERY:
3713: *code += OP_POSQUERY - OP_MINQUERY;
3714: break;
3715:
3716: case OP_UPTO:
3717: *code += OP_POSUPTO - OP_UPTO;
3718: break;
3719:
3720: case OP_MINUPTO:
3721: *code += OP_POSUPTO - OP_MINUPTO;
3722: break;
1.5 misha 3723: }
1.1 misha 3724: }
1.8 moko 3725: c = *code;
1.1 misha 3726: }
1.8 moko 3727: else if (c == OP_CLASS || c == OP_NCLASS || c == OP_XCLASS)
3728: {
3729: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3730: if (c == OP_XCLASS)
3731: repeat_opcode = code + GET(code, 1);
3732: else
3733: #endif
3734: repeat_opcode = code + 1 + (32 / sizeof(pcre_uchar));
3735:
3736: c = *repeat_opcode;
3737: if (c >= OP_CRSTAR && c <= OP_CRMINRANGE)
3738: {
3739: /* end must not be NULL. */
3740: end = get_chr_property_list(code, utf, cd->fcc, list);
3741:
3742: list[1] = (c & 1) == 0;
1.1 misha 3743:
1.8 moko 3744: rec_limit = 1000;
3745: if (compare_opcodes(end, utf, cd, list, end, &rec_limit))
3746: {
3747: switch (c)
3748: {
3749: case OP_CRSTAR:
3750: case OP_CRMINSTAR:
3751: *repeat_opcode = OP_CRPOSSTAR;
3752: break;
1.1 misha 3753:
1.8 moko 3754: case OP_CRPLUS:
3755: case OP_CRMINPLUS:
3756: *repeat_opcode = OP_CRPOSPLUS;
3757: break;
1.1 misha 3758:
1.8 moko 3759: case OP_CRQUERY:
3760: case OP_CRMINQUERY:
3761: *repeat_opcode = OP_CRPOSQUERY;
3762: break;
1.1 misha 3763:
1.8 moko 3764: case OP_CRRANGE:
3765: case OP_CRMINRANGE:
3766: *repeat_opcode = OP_CRPOSRANGE;
3767: break;
3768: }
1.5 misha 3769: }
1.1 misha 3770: }
1.8 moko 3771: c = *code;
1.1 misha 3772: }
3773:
1.8 moko 3774: switch(c)
3775: {
3776: case OP_END:
3777: return;
1.1 misha 3778:
1.8 moko 3779: case OP_TYPESTAR:
3780: case OP_TYPEMINSTAR:
3781: case OP_TYPEPLUS:
3782: case OP_TYPEMINPLUS:
3783: case OP_TYPEQUERY:
3784: case OP_TYPEMINQUERY:
3785: case OP_TYPEPOSSTAR:
3786: case OP_TYPEPOSPLUS:
3787: case OP_TYPEPOSQUERY:
3788: if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
3789: break;
1.1 misha 3790:
1.8 moko 3791: case OP_TYPEUPTO:
3792: case OP_TYPEMINUPTO:
3793: case OP_TYPEEXACT:
3794: case OP_TYPEPOSUPTO:
3795: if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
3796: code += 2;
3797: break;
1.1 misha 3798:
1.8 moko 3799: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3800: case OP_XCLASS:
3801: code += GET(code, 1);
3802: break;
1.1 misha 3803: #endif
3804:
1.8 moko 3805: case OP_MARK:
3806: case OP_PRUNE_ARG:
3807: case OP_SKIP_ARG:
3808: case OP_THEN_ARG:
3809: code += code[1];
3810: break;
3811: }
3812:
3813: /* Add in the fixed length from the table */
3814:
3815: code += PRIV(OP_lengths)[c];
1.1 misha 3816:
1.8 moko 3817: /* In UTF-8 mode, opcodes that are followed by a character may be followed by
3818: a multi-byte character. The length in the table is a minimum, so we have to
3819: arrange to skip the extra bytes. */
1.7 misha 3820:
1.8 moko 3821: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
3822: if (utf) switch(c)
1.7 misha 3823: {
1.8 moko 3824: case OP_CHAR:
3825: case OP_CHARI:
3826: case OP_NOT:
3827: case OP_NOTI:
3828: case OP_STAR:
3829: case OP_MINSTAR:
3830: case OP_PLUS:
3831: case OP_MINPLUS:
3832: case OP_QUERY:
3833: case OP_MINQUERY:
3834: case OP_UPTO:
3835: case OP_MINUPTO:
3836: case OP_EXACT:
3837: case OP_POSSTAR:
3838: case OP_POSPLUS:
3839: case OP_POSQUERY:
3840: case OP_POSUPTO:
3841: case OP_STARI:
3842: case OP_MINSTARI:
3843: case OP_PLUSI:
3844: case OP_MINPLUSI:
3845: case OP_QUERYI:
3846: case OP_MINQUERYI:
3847: case OP_UPTOI:
3848: case OP_MINUPTOI:
3849: case OP_EXACTI:
3850: case OP_POSSTARI:
3851: case OP_POSPLUSI:
3852: case OP_POSQUERYI:
3853: case OP_POSUPTOI:
3854: case OP_NOTSTAR:
3855: case OP_NOTMINSTAR:
3856: case OP_NOTPLUS:
3857: case OP_NOTMINPLUS:
3858: case OP_NOTQUERY:
3859: case OP_NOTMINQUERY:
3860: case OP_NOTUPTO:
3861: case OP_NOTMINUPTO:
3862: case OP_NOTEXACT:
3863: case OP_NOTPOSSTAR:
3864: case OP_NOTPOSPLUS:
3865: case OP_NOTPOSQUERY:
3866: case OP_NOTPOSUPTO:
3867: case OP_NOTSTARI:
3868: case OP_NOTMINSTARI:
3869: case OP_NOTPLUSI:
3870: case OP_NOTMINPLUSI:
3871: case OP_NOTQUERYI:
3872: case OP_NOTMINQUERYI:
3873: case OP_NOTUPTOI:
3874: case OP_NOTMINUPTOI:
3875: case OP_NOTEXACTI:
3876: case OP_NOTPOSSTARI:
3877: case OP_NOTPOSPLUSI:
3878: case OP_NOTPOSQUERYI:
3879: case OP_NOTPOSUPTOI:
3880: if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
3881: break;
1.7 misha 3882: }
1.8 moko 3883: #else
3884: (void)(utf); /* Keep compiler happy by referencing function argument */
1.1 misha 3885: #endif
1.8 moko 3886: }
3887: }
3888:
3889:
1.7 misha 3890:
1.8 moko 3891: /*************************************************
3892: * Check for POSIX class syntax *
3893: *************************************************/
3894:
3895: /* This function is called when the sequence "[:" or "[." or "[=" is
3896: encountered in a character class. It checks whether this is followed by a
3897: sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
3898: reach an unescaped ']' without the special preceding character, return FALSE.
3899:
3900: Originally, this function only recognized a sequence of letters between the
3901: terminators, but it seems that Perl recognizes any sequence of characters,
3902: though of course unknown POSIX names are subsequently rejected. Perl gives an
3903: "Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
3904: didn't consider this to be a POSIX class. Likewise for [:1234:].
3905:
3906: The problem in trying to be exactly like Perl is in the handling of escapes. We
3907: have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
3908: class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
1.9 ! moko 3909: below handles the special cases \\ and \], but does not try to do any other
! 3910: escape processing. This makes it different from Perl for cases such as
! 3911: [:l\ower:] where Perl recognizes it as the POSIX class "lower" but PCRE does
! 3912: not recognize "l\ower". This is a lesser evil than not diagnosing bad classes
! 3913: when Perl does, I think.
1.7 misha 3914:
1.8 moko 3915: A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.
3916: It seems that the appearance of a nested POSIX class supersedes an apparent
3917: external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or
3918: a digit.
1.7 misha 3919:
1.8 moko 3920: In Perl, unescaped square brackets may also appear as part of class names. For
3921: example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for
3922: [:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not
3923: seem right at all. PCRE does not allow closing square brackets in POSIX class
3924: names.
3925:
3926: Arguments:
3927: ptr pointer to the initial [
3928: endptr where to return the end pointer
1.1 misha 3929:
1.8 moko 3930: Returns: TRUE or FALSE
3931: */
1.1 misha 3932:
1.8 moko 3933: static BOOL
3934: check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)
3935: {
3936: pcre_uchar terminator; /* Don't combine these lines; the Solaris cc */
3937: terminator = *(++ptr); /* compiler warns about "non-constant" initializer. */
3938: for (++ptr; *ptr != CHAR_NULL; ptr++)
3939: {
1.9 ! moko 3940: if (*ptr == CHAR_BACKSLASH &&
! 3941: (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET ||
! 3942: ptr[1] == CHAR_BACKSLASH))
1.8 moko 3943: ptr++;
1.9 ! moko 3944: else if ((*ptr == CHAR_LEFT_SQUARE_BRACKET && ptr[1] == terminator) ||
! 3945: *ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
! 3946: else if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
1.8 moko 3947: {
1.9 ! moko 3948: *endptr = ptr;
! 3949: return TRUE;
1.8 moko 3950: }
3951: }
3952: return FALSE;
3953: }
1.7 misha 3954:
1.4 misha 3955:
1.7 misha 3956:
1.1 misha 3957:
1.8 moko 3958: /*************************************************
3959: * Check POSIX class name *
3960: *************************************************/
1.1 misha 3961:
1.8 moko 3962: /* This function is called to check the name given in a POSIX-style class entry
3963: such as [:alnum:].
1.1 misha 3964:
1.8 moko 3965: Arguments:
3966: ptr points to the first letter
3967: len the length of the name
1.1 misha 3968:
1.8 moko 3969: Returns: a value representing the name, or -1 if unknown
3970: */
1.1 misha 3971:
1.8 moko 3972: static int
3973: check_posix_name(const pcre_uchar *ptr, int len)
3974: {
3975: const char *pn = posix_names;
3976: register int yield = 0;
3977: while (posix_name_lengths[yield] != 0)
3978: {
3979: if (len == posix_name_lengths[yield] &&
3980: STRNCMP_UC_C8(ptr, pn, (unsigned int)len) == 0) return yield;
3981: pn += posix_name_lengths[yield] + 1;
3982: yield++;
3983: }
3984: return -1;
3985: }
1.1 misha 3986:
3987:
1.8 moko 3988: /*************************************************
3989: * Adjust OP_RECURSE items in repeated group *
3990: *************************************************/
1.1 misha 3991:
1.8 moko 3992: /* OP_RECURSE items contain an offset from the start of the regex to the group
3993: that is referenced. This means that groups can be replicated for fixed
3994: repetition simply by copying (because the recursion is allowed to refer to
3995: earlier groups that are outside the current group). However, when a group is
3996: optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is
3997: inserted before it, after it has been compiled. This means that any OP_RECURSE
3998: items within it that refer to the group itself or any contained groups have to
3999: have their offsets adjusted. That one of the jobs of this function. Before it
4000: is called, the partially compiled regex must be temporarily terminated with
4001: OP_END.
1.1 misha 4002:
1.9 ! moko 4003: This function has been extended to cope with forward references for recursions
! 4004: and subroutine calls. It must check the list of such references for the
! 4005: group we are dealing with. If it finds that one of the recursions in the
! 4006: current group is on this list, it does not adjust the value in the reference
! 4007: (which is a group number). After the group has been scanned, all the offsets in
! 4008: the forward reference list for the group are adjusted.
1.4 misha 4009:
1.8 moko 4010: Arguments:
4011: group points to the start of the group
4012: adjust the amount by which the group is to be moved
4013: utf TRUE in UTF-8 / UTF-16 / UTF-32 mode
4014: cd contains pointers to tables etc.
4015: save_hwm_offset the hwm forward reference offset at the start of the group
1.4 misha 4016:
1.8 moko 4017: Returns: nothing
4018: */
1.1 misha 4019:
1.8 moko 4020: static void
4021: adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd,
4022: size_t save_hwm_offset)
4023: {
1.9 ! moko 4024: int offset;
! 4025: pcre_uchar *hc;
1.8 moko 4026: pcre_uchar *ptr = group;
1.1 misha 4027:
1.8 moko 4028: while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)
1.1 misha 4029: {
1.8 moko 4030: for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset; hc < cd->hwm;
4031: hc += LINK_SIZE)
1.1 misha 4032: {
1.8 moko 4033: offset = (int)GET(hc, 0);
1.9 ! moko 4034: if (cd->start_code + offset == ptr + 1) break;
1.8 moko 4035: }
1.1 misha 4036:
1.9 ! moko 4037: /* If we have not found this recursion on the forward reference list, adjust
! 4038: the recursion's offset if it's after the start of this group. */
1.1 misha 4039:
1.8 moko 4040: if (hc >= cd->hwm)
4041: {
4042: offset = (int)GET(ptr, 1);
4043: if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
4044: }
1.1 misha 4045:
1.8 moko 4046: ptr += 1 + LINK_SIZE;
4047: }
1.9 ! moko 4048:
! 4049: /* Now adjust all forward reference offsets for the group. */
! 4050:
! 4051: for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset; hc < cd->hwm;
! 4052: hc += LINK_SIZE)
! 4053: {
! 4054: offset = (int)GET(hc, 0);
! 4055: PUT(hc, 0, offset + adjust);
! 4056: }
1.8 moko 4057: }
1.1 misha 4058:
4059:
4060:
1.8 moko 4061: /*************************************************
4062: * Insert an automatic callout point *
4063: *************************************************/
1.7 misha 4064:
1.8 moko 4065: /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
4066: callout points before each pattern item.
1.1 misha 4067:
1.8 moko 4068: Arguments:
4069: code current code pointer
4070: ptr current pattern pointer
4071: cd pointers to tables etc
1.7 misha 4072:
1.8 moko 4073: Returns: new code pointer
4074: */
1.1 misha 4075:
1.8 moko 4076: static pcre_uchar *
4077: auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd)
4078: {
4079: *code++ = OP_CALLOUT;
4080: *code++ = 255;
4081: PUT(code, 0, (int)(ptr - cd->start_pattern)); /* Pattern offset */
4082: PUT(code, LINK_SIZE, 0); /* Default length */
4083: return code + 2 * LINK_SIZE;
4084: }
1.4 misha 4085:
4086:
4087:
1.8 moko 4088: /*************************************************
4089: * Complete a callout item *
4090: *************************************************/
1.4 misha 4091:
1.8 moko 4092: /* A callout item contains the length of the next item in the pattern, which
4093: we can't fill in till after we have reached the relevant point. This is used
4094: for both automatic and manual callouts.
1.4 misha 4095:
1.8 moko 4096: Arguments:
4097: previous_callout points to previous callout item
4098: ptr current pattern pointer
4099: cd pointers to tables etc
1.4 misha 4100:
1.8 moko 4101: Returns: nothing
4102: */
1.4 misha 4103:
1.8 moko 4104: static void
4105: complete_callout(pcre_uchar *previous_callout, const pcre_uchar *ptr, compile_data *cd)
4106: {
4107: int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));
4108: PUT(previous_callout, 2 + LINK_SIZE, length);
4109: }
1.4 misha 4110:
1.1 misha 4111:
1.4 misha 4112:
1.8 moko 4113: #ifdef SUPPORT_UCP
4114: /*************************************************
4115: * Get othercase range *
4116: *************************************************/
1.1 misha 4117:
1.8 moko 4118: /* This function is passed the start and end of a class range, in UTF-8 mode
4119: with UCP support. It searches up the characters, looking for ranges of
4120: characters in the "other" case. Each call returns the next one, updating the
4121: start address. A character with multiple other cases is returned on its own
4122: with a special return value.
1.1 misha 4123:
1.8 moko 4124: Arguments:
4125: cptr points to starting character value; updated
4126: d end value
4127: ocptr where to put start of othercase range
4128: odptr where to put end of othercase range
1.1 misha 4129:
1.8 moko 4130: Yield: -1 when no more
4131: 0 when a range is returned
4132: >0 the CASESET offset for char with multiple other cases
4133: in this case, ocptr contains the original
4134: */
1.1 misha 4135:
1.8 moko 4136: static int
4137: get_othercase_range(pcre_uint32 *cptr, pcre_uint32 d, pcre_uint32 *ocptr,
4138: pcre_uint32 *odptr)
4139: {
4140: pcre_uint32 c, othercase, next;
4141: unsigned int co;
1.1 misha 4142:
1.8 moko 4143: /* Find the first character that has an other case. If it has multiple other
4144: cases, return its case offset value. */
1.1 misha 4145:
1.8 moko 4146: for (c = *cptr; c <= d; c++)
4147: {
4148: if ((co = UCD_CASESET(c)) != 0)
4149: {
4150: *ocptr = c++; /* Character that has the set */
4151: *cptr = c; /* Rest of input range */
4152: return (int)co;
4153: }
4154: if ((othercase = UCD_OTHERCASE(c)) != c) break;
4155: }
1.1 misha 4156:
1.8 moko 4157: if (c > d) return -1; /* Reached end of range */
1.1 misha 4158:
1.8 moko 4159: /* Found a character that has a single other case. Search for the end of the
4160: range, which is either the end of the input range, or a character that has zero
4161: or more than one other cases. */
1.1 misha 4162:
1.8 moko 4163: *ocptr = othercase;
4164: next = othercase + 1;
1.1 misha 4165:
1.8 moko 4166: for (++c; c <= d; c++)
4167: {
4168: if ((co = UCD_CASESET(c)) != 0 || UCD_OTHERCASE(c) != next) break;
4169: next++;
1.1 misha 4170: }
4171:
1.8 moko 4172: *odptr = next - 1; /* End of othercase range */
4173: *cptr = c; /* Rest of input range */
4174: return 0;
1.1 misha 4175: }
1.8 moko 4176: #endif /* SUPPORT_UCP */
1.1 misha 4177:
4178:
4179:
4180: /*************************************************
1.7 misha 4181: * Add a character or range to a class *
4182: *************************************************/
4183:
4184: /* This function packages up the logic of adding a character or range of
4185: characters to a class. The character values in the arguments will be within the
4186: valid values for the current mode (8-bit, 16-bit, UTF, etc). This function is
4187: mutually recursive with the function immediately below.
4188:
4189: Arguments:
4190: classbits the bit map for characters < 256
4191: uchardptr points to the pointer for extra data
4192: options the options word
4193: cd contains pointers to tables etc.
4194: start start of range character
4195: end end of range character
4196:
4197: Returns: the number of < 256 characters added
4198: the pointer to extra data is updated
4199: */
4200:
4201: static int
4202: add_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,
4203: compile_data *cd, pcre_uint32 start, pcre_uint32 end)
4204: {
4205: pcre_uint32 c;
1.8 moko 4206: pcre_uint32 classbits_end = (end <= 0xff ? end : 0xff);
1.7 misha 4207: int n8 = 0;
4208:
4209: /* If caseless matching is required, scan the range and process alternate
4210: cases. In Unicode, there are 8-bit characters that have alternate cases that
4211: are greater than 255 and vice-versa. Sometimes we can just extend the original
4212: range. */
4213:
4214: if ((options & PCRE_CASELESS) != 0)
4215: {
4216: #ifdef SUPPORT_UCP
4217: if ((options & PCRE_UTF8) != 0)
4218: {
4219: int rc;
4220: pcre_uint32 oc, od;
4221:
4222: options &= ~PCRE_CASELESS; /* Remove for recursive calls */
4223: c = start;
4224:
4225: while ((rc = get_othercase_range(&c, end, &oc, &od)) >= 0)
4226: {
4227: /* Handle a single character that has more than one other case. */
4228:
4229: if (rc > 0) n8 += add_list_to_class(classbits, uchardptr, options, cd,
4230: PRIV(ucd_caseless_sets) + rc, oc);
4231:
4232: /* Do nothing if the other case range is within the original range. */
4233:
4234: else if (oc >= start && od <= end) continue;
4235:
4236: /* Extend the original range if there is overlap, noting that if oc < c, we
4237: can't have od > end because a subrange is always shorter than the basic
4238: range. Otherwise, use a recursive call to add the additional range. */
4239:
4240: else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */
1.8 moko 4241: else if (od > end && oc <= end + 1)
4242: {
4243: end = od; /* Extend upwards */
4244: if (end > classbits_end) classbits_end = (end <= 0xff ? end : 0xff);
4245: }
1.7 misha 4246: else n8 += add_to_class(classbits, uchardptr, options, cd, oc, od);
4247: }
4248: }
4249: else
4250: #endif /* SUPPORT_UCP */
4251:
4252: /* Not UTF-mode, or no UCP */
4253:
1.8 moko 4254: for (c = start; c <= classbits_end; c++)
1.7 misha 4255: {
4256: SETBIT(classbits, cd->fcc[c]);
4257: n8++;
4258: }
4259: }
4260:
4261: /* Now handle the original range. Adjust the final value according to the bit
4262: length - this means that the same lists of (e.g.) horizontal spaces can be used
4263: in all cases. */
4264:
4265: #if defined COMPILE_PCRE8
4266: #ifdef SUPPORT_UTF
4267: if ((options & PCRE_UTF8) == 0)
4268: #endif
4269: if (end > 0xff) end = 0xff;
4270:
4271: #elif defined COMPILE_PCRE16
4272: #ifdef SUPPORT_UTF
4273: if ((options & PCRE_UTF16) == 0)
4274: #endif
4275: if (end > 0xffff) end = 0xffff;
4276:
4277: #endif /* COMPILE_PCRE[8|16] */
4278:
1.8 moko 4279: /* Use the bitmap for characters < 256. Otherwise use extra data.*/
1.7 misha 4280:
1.8 moko 4281: for (c = start; c <= classbits_end; c++)
1.7 misha 4282: {
1.8 moko 4283: /* Regardless of start, c will always be <= 255. */
4284: SETBIT(classbits, c);
4285: n8++;
1.7 misha 4286: }
4287:
1.8 moko 4288: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
4289: if (start <= 0xff) start = 0xff + 1;
4290:
4291: if (end >= start)
1.7 misha 4292: {
4293: pcre_uchar *uchardata = *uchardptr;
4294: #ifdef SUPPORT_UTF
4295: if ((options & PCRE_UTF8) != 0) /* All UTFs use the same flag bit */
4296: {
4297: if (start < end)
4298: {
4299: *uchardata++ = XCL_RANGE;
4300: uchardata += PRIV(ord2utf)(start, uchardata);
4301: uchardata += PRIV(ord2utf)(end, uchardata);
4302: }
4303: else if (start == end)
4304: {
4305: *uchardata++ = XCL_SINGLE;
4306: uchardata += PRIV(ord2utf)(start, uchardata);
4307: }
4308: }
4309: else
4310: #endif /* SUPPORT_UTF */
4311:
4312: /* Without UTF support, character values are constrained by the bit length,
4313: and can only be > 256 for 16-bit and 32-bit libraries. */
4314:
4315: #ifdef COMPILE_PCRE8
4316: {}
4317: #else
4318: if (start < end)
4319: {
4320: *uchardata++ = XCL_RANGE;
4321: *uchardata++ = start;
4322: *uchardata++ = end;
4323: }
4324: else if (start == end)
4325: {
4326: *uchardata++ = XCL_SINGLE;
4327: *uchardata++ = start;
4328: }
4329: #endif
4330:
4331: *uchardptr = uchardata; /* Updata extra data pointer */
4332: }
1.8 moko 4333: #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
1.7 misha 4334:
4335: return n8; /* Number of 8-bit characters */
4336: }
4337:
4338:
4339:
4340:
4341: /*************************************************
4342: * Add a list of characters to a class *
4343: *************************************************/
4344:
4345: /* This function is used for adding a list of case-equivalent characters to a
4346: class, and also for adding a list of horizontal or vertical whitespace. If the
4347: list is in order (which it should be), ranges of characters are detected and
4348: handled appropriately. This function is mutually recursive with the function
4349: above.
4350:
4351: Arguments:
4352: classbits the bit map for characters < 256
4353: uchardptr points to the pointer for extra data
4354: options the options word
4355: cd contains pointers to tables etc.
4356: p points to row of 32-bit values, terminated by NOTACHAR
4357: except character to omit; this is used when adding lists of
4358: case-equivalent characters to avoid including the one we
4359: already know about
4360:
4361: Returns: the number of < 256 characters added
4362: the pointer to extra data is updated
4363: */
4364:
4365: static int
4366: add_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,
4367: compile_data *cd, const pcre_uint32 *p, unsigned int except)
4368: {
4369: int n8 = 0;
4370: while (p[0] < NOTACHAR)
4371: {
4372: int n = 0;
4373: if (p[0] != except)
4374: {
4375: while(p[n+1] == p[0] + n + 1) n++;
4376: n8 += add_to_class(classbits, uchardptr, options, cd, p[0], p[n]);
4377: }
4378: p += n + 1;
4379: }
4380: return n8;
4381: }
4382:
4383:
4384:
4385: /*************************************************
4386: * Add characters not in a list to a class *
4387: *************************************************/
4388:
4389: /* This function is used for adding the complement of a list of horizontal or
4390: vertical whitespace to a class. The list must be in order.
4391:
4392: Arguments:
4393: classbits the bit map for characters < 256
4394: uchardptr points to the pointer for extra data
4395: options the options word
4396: cd contains pointers to tables etc.
4397: p points to row of 32-bit values, terminated by NOTACHAR
4398:
4399: Returns: the number of < 256 characters added
4400: the pointer to extra data is updated
4401: */
4402:
4403: static int
4404: add_not_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr,
4405: int options, compile_data *cd, const pcre_uint32 *p)
4406: {
4407: BOOL utf = (options & PCRE_UTF8) != 0;
4408: int n8 = 0;
4409: if (p[0] > 0)
4410: n8 += add_to_class(classbits, uchardptr, options, cd, 0, p[0] - 1);
4411: while (p[0] < NOTACHAR)
4412: {
4413: while (p[1] == p[0] + 1) p++;
4414: n8 += add_to_class(classbits, uchardptr, options, cd, p[0] + 1,
4415: (p[1] == NOTACHAR) ? (utf ? 0x10ffffu : 0xffffffffu) : p[1] - 1);
4416: p++;
4417: }
4418: return n8;
4419: }
4420:
4421:
4422:
4423: /*************************************************
1.1 misha 4424: * Compile one branch *
4425: *************************************************/
4426:
4427: /* Scan the pattern, compiling it into the a vector. If the options are
4428: changed during the branch, the pointer is used to change the external options
4429: bits. This function is used during the pre-compile phase when we are trying
4430: to find out the amount of memory needed, as well as during the real compile
4431: phase. The value of lengthptr distinguishes the two phases.
4432:
4433: Arguments:
1.8 moko 4434: optionsptr pointer to the option bits
4435: codeptr points to the pointer to the current code point
4436: ptrptr points to the current pattern pointer
4437: errorcodeptr points to error code variable
4438: firstcharptr place to put the first required character
1.7 misha 4439: firstcharflagsptr place to put the first character flags, or a negative number
1.8 moko 4440: reqcharptr place to put the last required character
4441: reqcharflagsptr place to put the last required character flags, or a negative number
4442: bcptr points to current branch chain
4443: cond_depth conditional nesting depth
4444: cd contains pointers to tables etc.
4445: lengthptr NULL during the real compile phase
4446: points to length accumulator during pre-compile phase
1.1 misha 4447:
1.8 moko 4448: Returns: TRUE on success
4449: FALSE, with *errorcodeptr set non-zero on error
1.1 misha 4450: */
4451:
4452: static BOOL
1.6 misha 4453: compile_branch(int *optionsptr, pcre_uchar **codeptr,
1.7 misha 4454: const pcre_uchar **ptrptr, int *errorcodeptr,
4455: pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,
4456: pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,
4457: branch_chain *bcptr, int cond_depth,
1.1 misha 4458: compile_data *cd, int *lengthptr)
4459: {
4460: int repeat_type, op_type;
4461: int repeat_min = 0, repeat_max = 0; /* To please picky compilers */
4462: int bravalue = 0;
4463: int greedy_default, greedy_non_default;
1.7 misha 4464: pcre_uint32 firstchar, reqchar;
4465: pcre_int32 firstcharflags, reqcharflags;
4466: pcre_uint32 zeroreqchar, zerofirstchar;
4467: pcre_int32 zeroreqcharflags, zerofirstcharflags;
1.6 misha 4468: pcre_int32 req_caseopt, reqvary, tempreqvary;
4469: int options = *optionsptr; /* May change dynamically */
1.1 misha 4470: int after_manual_callout = 0;
4471: int length_prevgroup = 0;
1.7 misha 4472: register pcre_uint32 c;
4473: int escape;
1.6 misha 4474: register pcre_uchar *code = *codeptr;
4475: pcre_uchar *last_code = code;
4476: pcre_uchar *orig_code = code;
4477: pcre_uchar *tempcode;
1.1 misha 4478: BOOL inescq = FALSE;
1.6 misha 4479: BOOL groupsetfirstchar = FALSE;
4480: const pcre_uchar *ptr = *ptrptr;
4481: const pcre_uchar *tempptr;
4482: const pcre_uchar *nestptr = NULL;
4483: pcre_uchar *previous = NULL;
4484: pcre_uchar *previous_callout = NULL;
1.9 ! moko 4485: size_t item_hwm_offset = 0;
1.6 misha 4486: pcre_uint8 classbits[32];
4487:
4488: /* We can fish out the UTF-8 setting once and for all into a BOOL, but we
4489: must not do this for other options (e.g. PCRE_EXTENDED) because they may change
4490: dynamically as we process the pattern. */
4491:
4492: #ifdef SUPPORT_UTF
1.7 misha 4493: /* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */
1.6 misha 4494: BOOL utf = (options & PCRE_UTF8) != 0;
1.7 misha 4495: #ifndef COMPILE_PCRE32
1.6 misha 4496: pcre_uchar utf_chars[6];
1.7 misha 4497: #endif
1.1 misha 4498: #else
1.6 misha 4499: BOOL utf = FALSE;
4500: #endif
4501:
1.7 misha 4502: /* Helper variables for OP_XCLASS opcode (for characters > 255). We define
4503: class_uchardata always so that it can be passed to add_to_class() always,
4504: though it will not be used in non-UTF 8-bit cases. This avoids having to supply
4505: alternative calls for the different cases. */
1.6 misha 4506:
1.7 misha 4507: pcre_uchar *class_uchardata;
1.6 misha 4508: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
4509: BOOL xclass;
4510: pcre_uchar *class_uchardata_base;
1.1 misha 4511: #endif
4512:
1.4 misha 4513: #ifdef PCRE_DEBUG
1.1 misha 4514: if (lengthptr != NULL) DPRINTF((">> start branch\n"));
4515: #endif
4516:
4517: /* Set up the default and non-default settings for greediness */
4518:
4519: greedy_default = ((options & PCRE_UNGREEDY) != 0);
4520: greedy_non_default = greedy_default ^ 1;
4521:
4522: /* Initialize no first byte, no required byte. REQ_UNSET means "no char
4523: matching encountered yet". It gets changed to REQ_NONE if we hit something that
1.6 misha 4524: matches a non-fixed char first char; reqchar just remains unset if we never
1.1 misha 4525: find one.
4526:
4527: When we hit a repeat whose minimum is zero, we may have to adjust these values
4528: to take the zero repeat into account. This is implemented by setting them to
1.6 misha 4529: zerofirstbyte and zeroreqchar when such a repeat is encountered. The individual
1.1 misha 4530: item types that can be repeated set these backoff variables appropriately. */
4531:
1.7 misha 4532: firstchar = reqchar = zerofirstchar = zeroreqchar = 0;
4533: firstcharflags = reqcharflags = zerofirstcharflags = zeroreqcharflags = REQ_UNSET;
1.1 misha 4534:
1.6 misha 4535: /* The variable req_caseopt contains either the REQ_CASELESS value
4536: or zero, according to the current setting of the caseless flag. The
4537: REQ_CASELESS leaves the lower 28 bit empty. It is added into the
4538: firstchar or reqchar variables to record the case status of the
4539: value. This is used only for ASCII characters. */
1.1 misha 4540:
1.6 misha 4541: req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS:0;
1.1 misha 4542:
4543: /* Switch on next character until the end of the branch */
4544:
4545: for (;; ptr++)
4546: {
4547: BOOL negate_class;
4548: BOOL should_flip_negation;
4549: BOOL possessive_quantifier;
4550: BOOL is_quantifier;
4551: BOOL is_recurse;
4552: BOOL reset_bracount;
1.6 misha 4553: int class_has_8bitchar;
1.7 misha 4554: int class_one_char;
1.8 moko 4555: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
4556: BOOL xclass_has_prop;
4557: #endif
1.1 misha 4558: int newoptions;
4559: int recno;
4560: int refsign;
4561: int skipbytes;
1.7 misha 4562: pcre_uint32 subreqchar, subfirstchar;
4563: pcre_int32 subreqcharflags, subfirstcharflags;
1.1 misha 4564: int terminator;
1.7 misha 4565: unsigned int mclength;
4566: unsigned int tempbracount;
4567: pcre_uint32 ec;
1.6 misha 4568: pcre_uchar mcbuffer[8];
1.1 misha 4569:
1.9 ! moko 4570: /* Come here to restart the loop without advancing the pointer. */
! 4571:
! 4572: REDO_LOOP:
! 4573:
1.6 misha 4574: /* Get next character in the pattern */
1.1 misha 4575:
4576: c = *ptr;
4577:
1.4 misha 4578: /* If we are at the end of a nested substitution, revert to the outer level
4579: string. Nesting only happens one level deep. */
4580:
1.7 misha 4581: if (c == CHAR_NULL && nestptr != NULL)
1.4 misha 4582: {
4583: ptr = nestptr;
4584: nestptr = NULL;
4585: c = *ptr;
4586: }
4587:
1.1 misha 4588: /* If we are in the pre-compile phase, accumulate the length used for the
4589: previous cycle of this loop. */
4590:
4591: if (lengthptr != NULL)
4592: {
1.4 misha 4593: #ifdef PCRE_DEBUG
1.1 misha 4594: if (code > cd->hwm) cd->hwm = code; /* High water info */
4595: #endif
1.6 misha 4596: if (code > cd->start_workspace + cd->workspace_size -
4597: WORK_SIZE_SAFETY_MARGIN) /* Check for overrun */
1.1 misha 4598: {
1.9 ! moko 4599: *errorcodeptr = (code >= cd->start_workspace + cd->workspace_size)?
! 4600: ERR52 : ERR87;
1.1 misha 4601: goto FAILED;
4602: }
4603:
4604: /* There is at least one situation where code goes backwards: this is the
4605: case of a zero quantifier after a class (e.g. [ab]{0}). At compile time,
4606: the class is simply eliminated. However, it is created first, so we have to
4607: allow memory for it. Therefore, don't ever reduce the length at this point.
4608: */
4609:
4610: if (code < last_code) code = last_code;
4611:
4612: /* Paranoid check for integer overflow */
4613:
4614: if (OFLOW_MAX - *lengthptr < code - last_code)
4615: {
4616: *errorcodeptr = ERR20;
4617: goto FAILED;
4618: }
4619:
1.4 misha 4620: *lengthptr += (int)(code - last_code);
1.6 misha 4621: DPRINTF(("length=%d added %d c=%c (0x%x)\n", *lengthptr,
4622: (int)(code - last_code), c, c));
1.1 misha 4623:
4624: /* If "previous" is set and it is not at the start of the work space, move
4625: it back to there, in order to avoid filling up the work space. Otherwise,
4626: if "previous" is NULL, reset the current code pointer to the start. */
4627:
4628: if (previous != NULL)
4629: {
4630: if (previous > orig_code)
4631: {
1.6 misha 4632: memmove(orig_code, previous, IN_UCHARS(code - previous));
1.1 misha 4633: code -= previous - orig_code;
4634: previous = orig_code;
4635: }
4636: }
4637: else code = orig_code;
4638:
4639: /* Remember where this code item starts so we can pick up the length
4640: next time round. */
4641:
4642: last_code = code;
4643: }
4644:
4645: /* In the real compile phase, just check the workspace used by the forward
4646: reference list. */
4647:
1.9 ! moko 4648: else if (cd->hwm > cd->start_workspace + cd->workspace_size)
1.1 misha 4649: {
4650: *errorcodeptr = ERR52;
4651: goto FAILED;
4652: }
4653:
1.9 ! moko 4654: /* If in \Q...\E, check for the end; if not, we have a literal. Otherwise an
! 4655: isolated \E is ignored. */
1.1 misha 4656:
1.9 ! moko 4657: if (c != CHAR_NULL)
1.1 misha 4658: {
1.3 misha 4659: if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)
1.1 misha 4660: {
4661: inescq = FALSE;
4662: ptr++;
4663: continue;
4664: }
1.9 ! moko 4665: else if (inescq)
1.1 misha 4666: {
4667: if (previous_callout != NULL)
4668: {
4669: if (lengthptr == NULL) /* Don't attempt in pre-compile phase */
4670: complete_callout(previous_callout, ptr, cd);
4671: previous_callout = NULL;
4672: }
4673: if ((options & PCRE_AUTO_CALLOUT) != 0)
4674: {
4675: previous_callout = code;
4676: code = auto_callout(code, ptr, cd);
4677: }
4678: goto NORMAL_CHAR;
4679: }
1.9 ! moko 4680:
! 4681: /* Check for the start of a \Q...\E sequence. We must do this here rather
! 4682: than later in case it is immediately followed by \E, which turns it into a
! 4683: "do nothing" sequence. */
! 4684:
! 4685: if (c == CHAR_BACKSLASH && ptr[1] == CHAR_Q)
! 4686: {
! 4687: inescq = TRUE;
! 4688: ptr++;
! 4689: continue;
! 4690: }
1.1 misha 4691: }
4692:
1.9 ! moko 4693: /* In extended mode, skip white space and comments. */
1.1 misha 4694:
4695: if ((options & PCRE_EXTENDED) != 0)
4696: {
1.9 ! moko 4697: const pcre_uchar *wscptr = ptr;
! 4698: while (MAX_255(c) && (cd->ctypes[c] & ctype_space) != 0) c = *(++ptr);
! 4699: if (c == CHAR_NUMBER_SIGN)
1.1 misha 4700: {
1.5 misha 4701: ptr++;
1.7 misha 4702: while (*ptr != CHAR_NULL)
1.1 misha 4703: {
1.8 moko 4704: if (IS_NEWLINE(ptr)) /* For non-fixed-length newline cases, */
4705: { /* IS_NEWLINE sets cd->nllen. */
4706: ptr += cd->nllen;
4707: break;
4708: }
1.5 misha 4709: ptr++;
1.6 misha 4710: #ifdef SUPPORT_UTF
4711: if (utf) FORWARDCHAR(ptr);
1.5 misha 4712: #endif
1.1 misha 4713: }
1.8 moko 4714: }
1.9 ! moko 4715:
! 4716: /* If we skipped any characters, restart the loop. Otherwise, we didn't see
! 4717: a comment. */
! 4718:
! 4719: if (ptr > wscptr) goto REDO_LOOP;
! 4720: }
! 4721:
! 4722: /* Skip over (?# comments. We need to do this here because we want to know if
! 4723: the next thing is a quantifier, and these comments may come between an item
! 4724: and its quantifier. */
! 4725:
! 4726: if (c == CHAR_LEFT_PARENTHESIS && ptr[1] == CHAR_QUESTION_MARK &&
! 4727: ptr[2] == CHAR_NUMBER_SIGN)
! 4728: {
! 4729: ptr += 3;
! 4730: while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
! 4731: if (*ptr == CHAR_NULL)
! 4732: {
! 4733: *errorcodeptr = ERR18;
! 4734: goto FAILED;
! 4735: }
! 4736: continue;
1.8 moko 4737: }
4738:
4739: /* See if the next thing is a quantifier. */
4740:
4741: is_quantifier =
4742: c == CHAR_ASTERISK || c == CHAR_PLUS || c == CHAR_QUESTION_MARK ||
4743: (c == CHAR_LEFT_CURLY_BRACKET && is_counted_repeat(ptr+1));
1.1 misha 4744:
1.8 moko 4745: /* Fill in length of a previous callout, except when the next thing is a
4746: quantifier or when processing a property substitution string in UCP mode. */
4747:
4748: if (!is_quantifier && previous_callout != NULL && nestptr == NULL &&
4749: after_manual_callout-- <= 0)
4750: {
4751: if (lengthptr == NULL) /* Don't attempt in pre-compile phase */
4752: complete_callout(previous_callout, ptr, cd);
4753: previous_callout = NULL;
1.1 misha 4754: }
4755:
1.8 moko 4756: /* Create auto callout, except for quantifiers, or while processing property
4757: strings that are substituted for \w etc in UCP mode. */
1.1 misha 4758:
1.8 moko 4759: if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier && nestptr == NULL)
1.1 misha 4760: {
4761: previous_callout = code;
4762: code = auto_callout(code, ptr, cd);
4763: }
4764:
1.8 moko 4765: /* Process the next pattern item. */
4766:
1.1 misha 4767: switch(c)
4768: {
4769: /* ===================================================================*/
1.8 moko 4770: case CHAR_NULL: /* The branch terminates at string end */
1.3 misha 4771: case CHAR_VERTICAL_LINE: /* or | or ) */
4772: case CHAR_RIGHT_PARENTHESIS:
1.6 misha 4773: *firstcharptr = firstchar;
1.7 misha 4774: *firstcharflagsptr = firstcharflags;
1.6 misha 4775: *reqcharptr = reqchar;
1.7 misha 4776: *reqcharflagsptr = reqcharflags;
1.1 misha 4777: *codeptr = code;
4778: *ptrptr = ptr;
4779: if (lengthptr != NULL)
4780: {
4781: if (OFLOW_MAX - *lengthptr < code - last_code)
4782: {
4783: *errorcodeptr = ERR20;
4784: goto FAILED;
4785: }
1.4 misha 4786: *lengthptr += (int)(code - last_code); /* To include callout length */
1.1 misha 4787: DPRINTF((">> end branch\n"));
4788: }
4789: return TRUE;
4790:
4791:
4792: /* ===================================================================*/
4793: /* Handle single-character metacharacters. In multiline mode, ^ disables
4794: the setting of any following char as a first character. */
4795:
1.3 misha 4796: case CHAR_CIRCUMFLEX_ACCENT:
1.6 misha 4797: previous = NULL;
1.1 misha 4798: if ((options & PCRE_MULTILINE) != 0)
4799: {
1.8 moko 4800: if (firstcharflags == REQ_UNSET)
4801: zerofirstcharflags = firstcharflags = REQ_NONE;
1.6 misha 4802: *code++ = OP_CIRCM;
1.1 misha 4803: }
1.6 misha 4804: else *code++ = OP_CIRC;
1.1 misha 4805: break;
4806:
1.3 misha 4807: case CHAR_DOLLAR_SIGN:
1.1 misha 4808: previous = NULL;
1.6 misha 4809: *code++ = ((options & PCRE_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;
1.1 misha 4810: break;
4811:
4812: /* There can never be a first char if '.' is first, whatever happens about
1.6 misha 4813: repeats. The value of reqchar doesn't change either. */
1.1 misha 4814:
1.3 misha 4815: case CHAR_DOT:
1.7 misha 4816: if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
1.6 misha 4817: zerofirstchar = firstchar;
1.7 misha 4818: zerofirstcharflags = firstcharflags;
1.6 misha 4819: zeroreqchar = reqchar;
1.7 misha 4820: zeroreqcharflags = reqcharflags;
1.1 misha 4821: previous = code;
1.9 ! moko 4822: item_hwm_offset = cd->hwm - cd->start_workspace;
1.1 misha 4823: *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;
4824: break;
4825:
4826:
4827: /* ===================================================================*/
4828: /* Character classes. If the included characters are all < 256, we build a
4829: 32-byte bitmap of the permitted characters, except in the special case
4830: where there is only one such character. For negated classes, we build the
4831: map as usual, then invert it at the end. However, we use a different opcode
4832: so that data characters > 255 can be handled correctly.
4833:
4834: If the class contains characters outside the 0-255 range, a different
4835: opcode is compiled. It may optionally have a bit map for characters < 256,
4836: but those above are are explicitly listed afterwards. A flag byte tells
4837: whether the bitmap is present, and whether this is a negated class or not.
4838:
4839: In JavaScript compatibility mode, an isolated ']' causes an error. In
4840: default (Perl) mode, it is treated as a data character. */
4841:
1.3 misha 4842: case CHAR_RIGHT_SQUARE_BRACKET:
1.1 misha 4843: if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
4844: {
4845: *errorcodeptr = ERR64;
4846: goto FAILED;
4847: }
4848: goto NORMAL_CHAR;
4849:
1.8 moko 4850: /* In another (POSIX) regex library, the ugly syntax [[:<:]] and [[:>:]] is
4851: used for "start of word" and "end of word". As these are otherwise illegal
4852: sequences, we don't break anything by recognizing them. They are replaced
4853: by \b(?=\w) and \b(?<=\w) respectively. Sequences like [a[:<:]] are
4854: erroneous and are handled by the normal code below. */
4855:
1.3 misha 4856: case CHAR_LEFT_SQUARE_BRACKET:
1.8 moko 4857: if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_STARTWORD, 6) == 0)
4858: {
4859: nestptr = ptr + 7;
1.9 ! moko 4860: ptr = sub_start_of_word;
! 4861: goto REDO_LOOP;
1.8 moko 4862: }
4863:
4864: if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_ENDWORD, 6) == 0)
4865: {
4866: nestptr = ptr + 7;
1.9 ! moko 4867: ptr = sub_end_of_word;
! 4868: goto REDO_LOOP;
1.8 moko 4869: }
4870:
4871: /* Handle a real character class. */
4872:
1.1 misha 4873: previous = code;
1.9 ! moko 4874: item_hwm_offset = cd->hwm - cd->start_workspace;
1.1 misha 4875:
4876: /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
4877: they are encountered at the top level, so we'll do that too. */
4878:
1.3 misha 4879: if ((ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
4880: ptr[1] == CHAR_EQUALS_SIGN) &&
1.1 misha 4881: check_posix_syntax(ptr, &tempptr))
4882: {
1.3 misha 4883: *errorcodeptr = (ptr[1] == CHAR_COLON)? ERR13 : ERR31;
1.1 misha 4884: goto FAILED;
4885: }
4886:
4887: /* If the first character is '^', set the negation flag and skip it. Also,
4888: if the first few characters (either before or after ^) are \Q\E or \E we
4889: skip them too. This makes for compatibility with Perl. */
4890:
4891: negate_class = FALSE;
4892: for (;;)
4893: {
4894: c = *(++ptr);
1.3 misha 4895: if (c == CHAR_BACKSLASH)
1.1 misha 4896: {
1.3 misha 4897: if (ptr[1] == CHAR_E)
4898: ptr++;
1.6 misha 4899: else if (STRNCMP_UC_C8(ptr + 1, STR_Q STR_BACKSLASH STR_E, 3) == 0)
1.3 misha 4900: ptr += 3;
4901: else
4902: break;
1.1 misha 4903: }
1.3 misha 4904: else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)
1.1 misha 4905: negate_class = TRUE;
4906: else break;
4907: }
4908:
4909: /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,
4910: an initial ']' is taken as a data character -- the code below handles
4911: that. In JS mode, [] must always fail, so generate OP_FAIL, whereas
4912: [^] must match any character, so generate OP_ALLANY. */
4913:
1.3 misha 4914: if (c == CHAR_RIGHT_SQUARE_BRACKET &&
4915: (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
1.1 misha 4916: {
4917: *code++ = negate_class? OP_ALLANY : OP_FAIL;
1.7 misha 4918: if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
1.6 misha 4919: zerofirstchar = firstchar;
1.7 misha 4920: zerofirstcharflags = firstcharflags;
1.1 misha 4921: break;
4922: }
4923:
4924: /* If a class contains a negative special such as \S, we need to flip the
4925: negation flag at the end, so that support for characters > 255 works
4926: correctly (they are all included in the class). */
4927:
4928: should_flip_negation = FALSE;
4929:
1.8 moko 4930: /* Extended class (xclass) will be used when characters > 255
4931: might match. */
4932:
4933: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
4934: xclass = FALSE;
4935: class_uchardata = code + LINK_SIZE + 2; /* For XCLASS items */
4936: class_uchardata_base = class_uchardata; /* Save the start */
4937: #endif
4938:
1.7 misha 4939: /* For optimization purposes, we track some properties of the class:
4940: class_has_8bitchar will be non-zero if the class contains at least one <
4941: 256 character; class_one_char will be 1 if the class contains just one
1.8 moko 4942: character; xclass_has_prop will be TRUE if unicode property checks
4943: are present in the class. */
1.1 misha 4944:
1.6 misha 4945: class_has_8bitchar = 0;
1.7 misha 4946: class_one_char = 0;
1.8 moko 4947: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
4948: xclass_has_prop = FALSE;
4949: #endif
1.1 misha 4950:
4951: /* Initialize the 32-char bit map to all zeros. We build the map in a
1.7 misha 4952: temporary bit of memory, in case the class contains fewer than two
4953: 8-bit characters because in that case the compiled code doesn't use the bit
4954: map. */
1.1 misha 4955:
1.6 misha 4956: memset(classbits, 0, 32 * sizeof(pcre_uint8));
1.1 misha 4957:
4958: /* Process characters until ] is reached. By writing this as a "do" it
4959: means that an initial ] is taken as a data character. At the start of the
4960: loop, c contains the first byte of the character. */
4961:
1.7 misha 4962: if (c != CHAR_NULL) do
1.1 misha 4963: {
1.6 misha 4964: const pcre_uchar *oldptr;
1.1 misha 4965:
1.6 misha 4966: #ifdef SUPPORT_UTF
4967: if (utf && HAS_EXTRALEN(c))
1.1 misha 4968: { /* Braces are required because the */
4969: GETCHARLEN(c, ptr, ptr); /* macro generates multiple statements */
4970: }
1.6 misha 4971: #endif
1.1 misha 4972:
1.6 misha 4973: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
4974: /* In the pre-compile phase, accumulate the length of any extra
1.1 misha 4975: data and reset the pointer. This is so that very large classes that
1.6 misha 4976: contain a zillion > 255 characters no longer overwrite the work space
1.7 misha 4977: (which is on the stack). We have to remember that there was XCLASS data,
4978: however. */
1.1 misha 4979:
1.9 ! moko 4980: if (class_uchardata > class_uchardata_base) xclass = TRUE;
! 4981:
1.7 misha 4982: if (lengthptr != NULL && class_uchardata > class_uchardata_base)
1.1 misha 4983: {
1.8 moko 4984: *lengthptr += (int)(class_uchardata - class_uchardata_base);
1.6 misha 4985: class_uchardata = class_uchardata_base;
1.1 misha 4986: }
4987: #endif
4988:
4989: /* Inside \Q...\E everything is literal except \E */
4990:
4991: if (inescq)
4992: {
1.3 misha 4993: if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E) /* If we are at \E */
1.1 misha 4994: {
4995: inescq = FALSE; /* Reset literal state */
4996: ptr++; /* Skip the 'E' */
4997: continue; /* Carry on with next */
4998: }
4999: goto CHECK_RANGE; /* Could be range if \E follows */
5000: }
5001:
5002: /* Handle POSIX class names. Perl allows a negation extension of the
5003: form [:^name:]. A square bracket that doesn't match the syntax is
5004: treated as a literal. We also recognize the POSIX constructions
5005: [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
5006: 5.6 and 5.8 do. */
5007:
1.3 misha 5008: if (c == CHAR_LEFT_SQUARE_BRACKET &&
5009: (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
5010: ptr[1] == CHAR_EQUALS_SIGN) && check_posix_syntax(ptr, &tempptr))
1.1 misha 5011: {
5012: BOOL local_negate = FALSE;
5013: int posix_class, taboffset, tabopt;
1.6 misha 5014: register const pcre_uint8 *cbits = cd->cbits;
5015: pcre_uint8 pbits[32];
1.1 misha 5016:
1.3 misha 5017: if (ptr[1] != CHAR_COLON)
1.1 misha 5018: {
5019: *errorcodeptr = ERR31;
5020: goto FAILED;
5021: }
5022:
5023: ptr += 2;
1.3 misha 5024: if (*ptr == CHAR_CIRCUMFLEX_ACCENT)
1.1 misha 5025: {
5026: local_negate = TRUE;
5027: should_flip_negation = TRUE; /* Note negative special */
5028: ptr++;
5029: }
5030:
1.4 misha 5031: posix_class = check_posix_name(ptr, (int)(tempptr - ptr));
1.1 misha 5032: if (posix_class < 0)
5033: {
5034: *errorcodeptr = ERR30;
5035: goto FAILED;
5036: }
5037:
5038: /* If matching is caseless, upper and lower are converted to
5039: alpha. This relies on the fact that the class table starts with
5040: alpha, lower, upper as the first 3 entries. */
5041:
5042: if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
5043: posix_class = 0;
5044:
1.4 misha 5045: /* When PCRE_UCP is set, some of the POSIX classes are converted to
1.8 moko 5046: different escape sequences that use Unicode properties \p or \P. Others
5047: that are not available via \p or \P generate XCL_PROP/XCL_NOTPROP
5048: directly. */
1.4 misha 5049:
5050: #ifdef SUPPORT_UCP
5051: if ((options & PCRE_UCP) != 0)
5052: {
1.8 moko 5053: unsigned int ptype = 0;
1.4 misha 5054: int pc = posix_class + ((local_negate)? POSIX_SUBSIZE/2 : 0);
1.8 moko 5055:
5056: /* The posix_substitutes table specifies which POSIX classes can be
5057: converted to \p or \P items. */
5058:
1.4 misha 5059: if (posix_substitutes[pc] != NULL)
5060: {
5061: nestptr = tempptr + 1;
5062: ptr = posix_substitutes[pc] - 1;
5063: continue;
5064: }
1.8 moko 5065:
5066: /* There are three other classes that generate special property calls
5067: that are recognized only in an XCLASS. */
5068:
5069: else switch(posix_class)
5070: {
5071: case PC_GRAPH:
5072: ptype = PT_PXGRAPH;
5073: /* Fall through */
5074: case PC_PRINT:
5075: if (ptype == 0) ptype = PT_PXPRINT;
5076: /* Fall through */
5077: case PC_PUNCT:
5078: if (ptype == 0) ptype = PT_PXPUNCT;
5079: *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP;
5080: *class_uchardata++ = ptype;
5081: *class_uchardata++ = 0;
5082: xclass_has_prop = TRUE;
5083: ptr = tempptr + 1;
5084: continue;
5085:
1.9 ! moko 5086: /* For the other POSIX classes (ascii, cntrl, xdigit) we are going
! 5087: to fall through to the non-UCP case and build a bit map for
! 5088: characters with code points less than 256. If we are in a negated
! 5089: POSIX class, characters with code points greater than 255 must
! 5090: either all match or all not match. In the special case where we
! 5091: have not yet generated any xclass data, and this is the final item
! 5092: in the overall class, we need do nothing: later on, the opcode
! 5093: OP_NCLASS will be used to indicate that characters greater than 255
! 5094: are acceptable. If we have already seen an xclass item or one may
! 5095: follow (we have to assume that it might if this is not the end of
! 5096: the class), explicitly list all wide codepoints, which will then
! 5097: either not match or match, depending on whether the class is or is
! 5098: not negated. */
1.8 moko 5099:
5100: default:
1.9 ! moko 5101: if (local_negate &&
! 5102: (xclass || tempptr[2] != CHAR_RIGHT_SQUARE_BRACKET))
! 5103: {
! 5104: *class_uchardata++ = XCL_RANGE;
! 5105: class_uchardata += PRIV(ord2utf)(0x100, class_uchardata);
! 5106: class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);
! 5107: }
1.8 moko 5108: break;
5109: }
1.4 misha 5110: }
5111: #endif
1.8 moko 5112: /* In the non-UCP case, or when UCP makes no difference, we build the
5113: bit map for the POSIX class in a chunk of local store because we may be
5114: adding and subtracting from it, and we don't want to subtract bits that
5115: may be in the main map already. At the end we or the result into the
5116: bit map that is being built. */
1.1 misha 5117:
5118: posix_class *= 3;
5119:
5120: /* Copy in the first table (always present) */
5121:
5122: memcpy(pbits, cbits + posix_class_maps[posix_class],
1.6 misha 5123: 32 * sizeof(pcre_uint8));
1.1 misha 5124:
5125: /* If there is a second table, add or remove it as required. */
5126:
5127: taboffset = posix_class_maps[posix_class + 1];
5128: tabopt = posix_class_maps[posix_class + 2];
5129:
5130: if (taboffset >= 0)
5131: {
5132: if (tabopt >= 0)
5133: for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];
5134: else
5135: for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];
5136: }
5137:
1.7 misha 5138: /* Now see if we need to remove any special characters. An option
1.1 misha 5139: value of 1 removes vertical space and 2 removes underscore. */
5140:
5141: if (tabopt < 0) tabopt = -tabopt;
5142: if (tabopt == 1) pbits[1] &= ~0x3c;
5143: else if (tabopt == 2) pbits[11] &= 0x7f;
5144:
5145: /* Add the POSIX table or its complement into the main table that is
5146: being built and we are done. */
5147:
5148: if (local_negate)
5149: for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];
5150: else
5151: for (c = 0; c < 32; c++) classbits[c] |= pbits[c];
5152:
5153: ptr = tempptr + 1;
1.7 misha 5154: /* Every class contains at least one < 256 character. */
1.6 misha 5155: class_has_8bitchar = 1;
5156: /* Every class contains at least two characters. */
1.7 misha 5157: class_one_char = 2;
1.1 misha 5158: continue; /* End of POSIX syntax handling */
5159: }
5160:
5161: /* Backslash may introduce a single character, or it may introduce one
5162: of the specials, which just set a flag. The sequence \b is a special
1.4 misha 5163: case. Inside a class (and only there) it is treated as backspace. We
1.6 misha 5164: assume that other escapes have more than one character in them, so
1.7 misha 5165: speculatively set both class_has_8bitchar and class_one_char bigger
1.6 misha 5166: than one. Unrecognized escapes fall through and are either treated
5167: as literal characters (by default), or are faulted if
1.4 misha 5168: PCRE_EXTRA is set. */
1.1 misha 5169:
1.3 misha 5170: if (c == CHAR_BACKSLASH)
1.1 misha 5171: {
1.7 misha 5172: escape = check_escape(&ptr, &ec, errorcodeptr, cd->bracount, options,
5173: TRUE);
1.1 misha 5174: if (*errorcodeptr != 0) goto FAILED;
1.7 misha 5175: if (escape == 0) c = ec;
5176: else if (escape == ESC_b) c = CHAR_BS; /* \b is backspace in a class */
5177: else if (escape == ESC_N) /* \N is not supported in a class */
1.6 misha 5178: {
5179: *errorcodeptr = ERR71;
5180: goto FAILED;
5181: }
1.7 misha 5182: else if (escape == ESC_Q) /* Handle start of quoted string */
1.1 misha 5183: {
1.3 misha 5184: if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
1.1 misha 5185: {
5186: ptr += 2; /* avoid empty string */
5187: }
5188: else inescq = TRUE;
5189: continue;
5190: }
1.7 misha 5191: else if (escape == ESC_E) continue; /* Ignore orphan \E */
1.1 misha 5192:
1.7 misha 5193: else
1.1 misha 5194: {
1.6 misha 5195: register const pcre_uint8 *cbits = cd->cbits;
5196: /* Every class contains at least two < 256 characters. */
5197: class_has_8bitchar++;
5198: /* Every class contains at least two characters. */
1.7 misha 5199: class_one_char += 2;
1.1 misha 5200:
1.7 misha 5201: switch (escape)
1.1 misha 5202: {
1.4 misha 5203: #ifdef SUPPORT_UCP
5204: case ESC_du: /* These are the values given for \d etc */
5205: case ESC_DU: /* when PCRE_UCP is set. We replace the */
5206: case ESC_wu: /* escape sequence with an appropriate \p */
5207: case ESC_WU: /* or \P to test Unicode properties instead */
5208: case ESC_su: /* of the default ASCII testing. */
5209: case ESC_SU:
5210: nestptr = ptr;
1.7 misha 5211: ptr = substitutes[escape - ESC_DU] - 1; /* Just before substitute */
1.6 misha 5212: class_has_8bitchar--; /* Undo! */
1.4 misha 5213: continue;
5214: #endif
1.1 misha 5215: case ESC_d:
5216: for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];
5217: continue;
5218:
5219: case ESC_D:
5220: should_flip_negation = TRUE;
5221: for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
5222: continue;
5223:
5224: case ESC_w:
5225: for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];
5226: continue;
5227:
5228: case ESC_W:
5229: should_flip_negation = TRUE;
5230: for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
5231: continue;
5232:
1.8 moko 5233: /* Perl 5.004 onwards omitted VT from \s, but restored it at Perl
5234: 5.18. Before PCRE 8.34, we had to preserve the VT bit if it was
5235: previously set by something earlier in the character class.
5236: Luckily, the value of CHAR_VT is 0x0b in both ASCII and EBCDIC, so
5237: we could just adjust the appropriate bit. From PCRE 8.34 we no
5238: longer treat \s and \S specially. */
1.5 misha 5239:
1.1 misha 5240: case ESC_s:
1.8 moko 5241: for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
1.1 misha 5242: continue;
5243:
5244: case ESC_S:
5245: should_flip_negation = TRUE;
5246: for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
5247: continue;
5248:
1.7 misha 5249: /* The rest apply in both UCP and non-UCP cases. */
5250:
1.4 misha 5251: case ESC_h:
1.7 misha 5252: (void)add_list_to_class(classbits, &class_uchardata, options, cd,
5253: PRIV(hspace_list), NOTACHAR);
1.1 misha 5254: continue;
5255:
1.4 misha 5256: case ESC_H:
1.7 misha 5257: (void)add_not_list_to_class(classbits, &class_uchardata, options,
5258: cd, PRIV(hspace_list));
1.1 misha 5259: continue;
5260:
1.4 misha 5261: case ESC_v:
1.7 misha 5262: (void)add_list_to_class(classbits, &class_uchardata, options, cd,
5263: PRIV(vspace_list), NOTACHAR);
1.1 misha 5264: continue;
5265:
1.7 misha 5266: case ESC_V:
5267: (void)add_not_list_to_class(classbits, &class_uchardata, options,
5268: cd, PRIV(vspace_list));
1.1 misha 5269: continue;
5270:
1.4 misha 5271: case ESC_p:
5272: case ESC_P:
1.9 ! moko 5273: #ifdef SUPPORT_UCP
1.4 misha 5274: {
5275: BOOL negated;
1.7 misha 5276: unsigned int ptype = 0, pdata = 0;
5277: if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))
5278: goto FAILED;
5279: *class_uchardata++ = ((escape == ESC_p) != negated)?
1.4 misha 5280: XCL_PROP : XCL_NOTPROP;
1.6 misha 5281: *class_uchardata++ = ptype;
5282: *class_uchardata++ = pdata;
1.8 moko 5283: xclass_has_prop = TRUE;
1.6 misha 5284: class_has_8bitchar--; /* Undo! */
1.4 misha 5285: continue;
5286: }
1.9 ! moko 5287: #else
! 5288: *errorcodeptr = ERR45;
! 5289: goto FAILED;
1.1 misha 5290: #endif
1.4 misha 5291: /* Unrecognized escapes are faulted if PCRE is running in its
5292: strict mode. By default, for compatibility with Perl, they are
5293: treated as literals. */
1.1 misha 5294:
1.4 misha 5295: default:
5296: if ((options & PCRE_EXTRA) != 0)
5297: {
5298: *errorcodeptr = ERR7;
5299: goto FAILED;
5300: }
1.6 misha 5301: class_has_8bitchar--; /* Undo the speculative increase. */
1.7 misha 5302: class_one_char -= 2; /* Undo the speculative increase. */
1.6 misha 5303: c = *ptr; /* Get the final character and fall through */
1.4 misha 5304: break;
1.1 misha 5305: }
5306: }
5307:
1.7 misha 5308: /* Fall through if the escape just defined a single character (c >= 0).
5309: This may be greater than 256. */
5310:
5311: escape = 0;
1.1 misha 5312:
5313: } /* End of backslash handling */
5314:
1.7 misha 5315: /* A character may be followed by '-' to form a range. However, Perl does
5316: not permit ']' to be the end of the range. A '-' character at the end is
5317: treated as a literal. Perl ignores orphaned \E sequences entirely. The
5318: code for handling \Q and \E is messy. */
1.1 misha 5319:
5320: CHECK_RANGE:
1.3 misha 5321: while (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
1.1 misha 5322: {
5323: inescq = FALSE;
5324: ptr += 2;
5325: }
5326: oldptr = ptr;
5327:
1.7 misha 5328: /* Remember if \r or \n were explicitly used */
1.1 misha 5329:
1.3 misha 5330: if (c == CHAR_CR || c == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
1.1 misha 5331:
5332: /* Check for range */
5333:
1.3 misha 5334: if (!inescq && ptr[1] == CHAR_MINUS)
1.1 misha 5335: {
1.7 misha 5336: pcre_uint32 d;
1.1 misha 5337: ptr += 2;
1.3 misha 5338: while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E) ptr += 2;
1.1 misha 5339:
5340: /* If we hit \Q (not followed by \E) at this point, go into escaped
5341: mode. */
5342:
1.3 misha 5343: while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_Q)
1.1 misha 5344: {
5345: ptr += 2;
1.3 misha 5346: if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E)
5347: { ptr += 2; continue; }
1.1 misha 5348: inescq = TRUE;
5349: break;
5350: }
5351:
1.7 misha 5352: /* Minus (hyphen) at the end of a class is treated as a literal, so put
5353: back the pointer and jump to handle the character that preceded it. */
5354:
5355: if (*ptr == CHAR_NULL || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))
1.1 misha 5356: {
5357: ptr = oldptr;
1.7 misha 5358: goto CLASS_SINGLE_CHARACTER;
1.1 misha 5359: }
5360:
1.7 misha 5361: /* Otherwise, we have a potential range; pick up the next character */
5362:
1.6 misha 5363: #ifdef SUPPORT_UTF
5364: if (utf)
1.1 misha 5365: { /* Braces are required because the */
5366: GETCHARLEN(d, ptr, ptr); /* macro generates multiple statements */
5367: }
5368: else
5369: #endif
5370: d = *ptr; /* Not UTF-8 mode */
5371:
1.8 moko 5372: /* The second part of a range can be a single-character escape
5373: sequence, but not any of the other escapes. Perl treats a hyphen as a
5374: literal in such circumstances. However, in Perl's warning mode, a
5375: warning is given, so PCRE now faults it as it is almost certainly a
5376: mistake on the user's part. */
1.1 misha 5377:
1.8 moko 5378: if (!inescq)
1.1 misha 5379: {
1.8 moko 5380: if (d == CHAR_BACKSLASH)
5381: {
5382: int descape;
5383: descape = check_escape(&ptr, &d, errorcodeptr, cd->bracount, options, TRUE);
5384: if (*errorcodeptr != 0) goto FAILED;
1.1 misha 5385:
1.8 moko 5386: /* 0 means a character was put into d; \b is backspace; any other
5387: special causes an error. */
1.1 misha 5388:
1.8 moko 5389: if (descape != 0)
1.1 misha 5390: {
1.8 moko 5391: if (descape == ESC_b) d = CHAR_BS; else
5392: {
5393: *errorcodeptr = ERR83;
5394: goto FAILED;
5395: }
1.1 misha 5396: }
5397: }
1.8 moko 5398:
5399: /* A hyphen followed by a POSIX class is treated in the same way. */
5400:
5401: else if (d == CHAR_LEFT_SQUARE_BRACKET &&
5402: (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
5403: ptr[1] == CHAR_EQUALS_SIGN) &&
5404: check_posix_syntax(ptr, &tempptr))
5405: {
5406: *errorcodeptr = ERR83;
5407: goto FAILED;
5408: }
1.1 misha 5409: }
5410:
5411: /* Check that the two values are in the correct order. Optimize
1.7 misha 5412: one-character ranges. */
1.1 misha 5413:
5414: if (d < c)
5415: {
5416: *errorcodeptr = ERR8;
5417: goto FAILED;
5418: }
1.7 misha 5419: if (d == c) goto CLASS_SINGLE_CHARACTER; /* A few lines below */
1.1 misha 5420:
1.7 misha 5421: /* We have found a character range, so single character optimizations
5422: cannot be done anymore. Any value greater than 1 indicates that there
5423: is more than one character. */
1.1 misha 5424:
1.7 misha 5425: class_one_char = 2;
5426:
5427: /* Remember an explicit \r or \n, and add the range to the class. */
1.1 misha 5428:
1.3 misha 5429: if (d == CHAR_CR || d == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
1.1 misha 5430:
1.7 misha 5431: class_has_8bitchar +=
5432: add_to_class(classbits, &class_uchardata, options, cd, c, d);
1.1 misha 5433:
1.7 misha 5434: continue; /* Go get the next char in the class */
5435: }
1.1 misha 5436:
1.7 misha 5437: /* Handle a single character - we can get here for a normal non-escape
5438: char, or after \ that introduces a single character or for an apparent
5439: range that isn't. Only the value 1 matters for class_one_char, so don't
5440: increase it if it is already 2 or more ... just in case there's a class
5441: with a zillion characters in it. */
5442:
5443: CLASS_SINGLE_CHARACTER:
5444: if (class_one_char < 2) class_one_char++;
5445:
1.9 ! moko 5446: /* If xclass_has_prop is false and class_one_char is 1, we have the first
! 5447: single character in the class, and there have been no prior ranges, or
! 5448: XCLASS items generated by escapes. If this is the final character in the
! 5449: class, we can optimize by turning the item into a 1-character OP_CHAR[I]
! 5450: if it's positive, or OP_NOT[I] if it's negative. In the positive case, it
! 5451: can cause firstchar to be set. Otherwise, there can be no first char if
! 5452: this item is first, whatever repeat count may follow. In the case of
! 5453: reqchar, save the previous value for reinstating. */
1.1 misha 5454:
1.9 ! moko 5455: if (!inescq &&
! 5456: #ifdef SUPPORT_UCP
! 5457: !xclass_has_prop &&
! 5458: #endif
! 5459: class_one_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
1.7 misha 5460: {
5461: ptr++;
5462: zeroreqchar = reqchar;
5463: zeroreqcharflags = reqcharflags;
1.1 misha 5464:
1.7 misha 5465: if (negate_class)
5466: {
5467: #ifdef SUPPORT_UCP
5468: int d;
1.6 misha 5469: #endif
1.7 misha 5470: if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
5471: zerofirstchar = firstchar;
5472: zerofirstcharflags = firstcharflags;
1.1 misha 5473:
1.7 misha 5474: /* For caseless UTF-8 mode when UCP support is available, check
5475: whether this character has more than one other case. If so, generate
5476: a special OP_NOTPROP item instead of OP_NOTI. */
1.1 misha 5477:
5478: #ifdef SUPPORT_UCP
1.7 misha 5479: if (utf && (options & PCRE_CASELESS) != 0 &&
5480: (d = UCD_CASESET(c)) != 0)
1.6 misha 5481: {
1.7 misha 5482: *code++ = OP_NOTPROP;
5483: *code++ = PT_CLIST;
5484: *code++ = d;
1.6 misha 5485: }
5486: else
1.7 misha 5487: #endif
5488: /* Char has only one other case, or UCP not available */
1.1 misha 5489:
5490: {
1.7 misha 5491: *code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;
5492: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
5493: if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
5494: code += PRIV(ord2utf)(c, code);
5495: else
5496: #endif
5497: *code++ = c;
1.1 misha 5498: }
1.6 misha 5499:
1.7 misha 5500: /* We are finished with this character class */
1.6 misha 5501:
1.7 misha 5502: goto END_CLASS;
1.6 misha 5503: }
5504:
5505: /* For a single, positive character, get the value into mcbuffer, and
5506: then we can handle this with the normal one-character code. */
5507:
1.7 misha 5508: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.6 misha 5509: if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
5510: mclength = PRIV(ord2utf)(c, mcbuffer);
5511: else
5512: #endif
5513: {
5514: mcbuffer[0] = c;
5515: mclength = 1;
5516: }
5517: goto ONE_CHAR;
5518: } /* End of 1-char optimization */
5519:
1.7 misha 5520: /* There is more than one character in the class, or an XCLASS item
5521: has been generated. Add this character to the class. */
1.1 misha 5522:
1.7 misha 5523: class_has_8bitchar +=
5524: add_to_class(classbits, &class_uchardata, options, cd, c, c);
1.1 misha 5525: }
5526:
1.4 misha 5527: /* Loop until ']' reached. This "while" is the end of the "do" far above.
5528: If we are at the end of an internal nested string, revert to the outer
5529: string. */
5530:
1.7 misha 5531: while (((c = *(++ptr)) != CHAR_NULL ||
1.4 misha 5532: (nestptr != NULL &&
1.7 misha 5533: (ptr = nestptr, nestptr = NULL, c = *(++ptr)) != CHAR_NULL)) &&
1.4 misha 5534: (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));
1.1 misha 5535:
1.4 misha 5536: /* Check for missing terminating ']' */
1.1 misha 5537:
1.7 misha 5538: if (c == CHAR_NULL)
1.1 misha 5539: {
5540: *errorcodeptr = ERR6;
5541: goto FAILED;
5542: }
5543:
1.7 misha 5544: /* We will need an XCLASS if data has been placed in class_uchardata. In
5545: the second phase this is a sufficient test. However, in the pre-compile
5546: phase, class_uchardata gets emptied to prevent workspace overflow, so it
5547: only if the very last character in the class needs XCLASS will it contain
5548: anything at this point. For this reason, xclass gets set TRUE above when
5549: uchar_classdata is emptied, and that's why this code is the way it is here
5550: instead of just doing a test on class_uchardata below. */
5551:
5552: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
5553: if (class_uchardata > class_uchardata_base) xclass = TRUE;
5554: #endif
5555:
1.6 misha 5556: /* If this is the first thing in the branch, there can be no first char
5557: setting, whatever the repeat count. Any reqchar setting must remain
5558: unchanged after any kind of repeat. */
5559:
1.7 misha 5560: if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
1.6 misha 5561: zerofirstchar = firstchar;
1.7 misha 5562: zerofirstcharflags = firstcharflags;
1.6 misha 5563: zeroreqchar = reqchar;
1.7 misha 5564: zeroreqcharflags = reqcharflags;
1.1 misha 5565:
5566: /* If there are characters with values > 255, we have to compile an
5567: extended class, with its own opcode, unless there was a negated special
1.4 misha 5568: such as \S in the class, and PCRE_UCP is not set, because in that case all
5569: characters > 255 are in the class, so any that were explicitly given as
5570: well can be ignored. If (when there are explicit characters > 255 that must
5571: be listed) there are no characters < 256, we can omit the bitmap in the
5572: actual compiled code. */
1.1 misha 5573:
1.6 misha 5574: #ifdef SUPPORT_UTF
1.9 ! moko 5575: if (xclass && (xclass_has_prop || !should_flip_negation ||
! 5576: (options & PCRE_UCP) != 0))
1.6 misha 5577: #elif !defined COMPILE_PCRE8
1.9 ! moko 5578: if (xclass && (xclass_has_prop || !should_flip_negation))
1.6 misha 5579: #endif
5580: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
1.1 misha 5581: {
1.9 ! moko 5582: /* For non-UCP wide characters, in a non-negative class containing \S or
! 5583: similar (should_flip_negation is set), all characters greater than 255
! 5584: must be in the class. */
! 5585:
! 5586: if (
! 5587: #if defined COMPILE_PCRE8
! 5588: utf &&
! 5589: #endif
! 5590: should_flip_negation && !negate_class && (options & PCRE_UCP) == 0)
! 5591: {
! 5592: *class_uchardata++ = XCL_RANGE;
! 5593: if (utf) /* Will always be utf in the 8-bit library */
! 5594: {
! 5595: class_uchardata += PRIV(ord2utf)(0x100, class_uchardata);
! 5596: class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);
! 5597: }
! 5598: else /* Can only happen for the 16-bit & 32-bit libraries */
! 5599: {
! 5600: #if defined COMPILE_PCRE16
! 5601: *class_uchardata++ = 0x100;
! 5602: *class_uchardata++ = 0xffffu;
! 5603: #elif defined COMPILE_PCRE32
! 5604: *class_uchardata++ = 0x100;
! 5605: *class_uchardata++ = 0xffffffffu;
! 5606: #endif
! 5607: }
! 5608: }
! 5609:
1.6 misha 5610: *class_uchardata++ = XCL_END; /* Marks the end of extra data */
1.1 misha 5611: *code++ = OP_XCLASS;
5612: code += LINK_SIZE;
1.6 misha 5613: *code = negate_class? XCL_NOT:0;
1.8 moko 5614: if (xclass_has_prop) *code |= XCL_HASPROP;
1.1 misha 5615:
5616: /* If the map is required, move up the extra data to make room for it;
5617: otherwise just move the code pointer to the end of the extra data. */
5618:
1.6 misha 5619: if (class_has_8bitchar > 0)
1.1 misha 5620: {
5621: *code++ |= XCL_MAP;
1.6 misha 5622: memmove(code + (32 / sizeof(pcre_uchar)), code,
5623: IN_UCHARS(class_uchardata - code));
1.8 moko 5624: if (negate_class && !xclass_has_prop)
5625: for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];
1.1 misha 5626: memcpy(code, classbits, 32);
1.6 misha 5627: code = class_uchardata + (32 / sizeof(pcre_uchar));
1.1 misha 5628: }
1.6 misha 5629: else code = class_uchardata;
1.1 misha 5630:
5631: /* Now fill in the complete length of the item */
5632:
1.6 misha 5633: PUT(previous, 1, (int)(code - previous));
1.1 misha 5634: break; /* End of class handling */
5635: }
1.8 moko 5636:
5637: /* Even though any XCLASS list is now discarded, we must allow for
5638: its memory. */
5639:
5640: if (lengthptr != NULL)
5641: *lengthptr += (int)(class_uchardata - class_uchardata_base);
1.1 misha 5642: #endif
5643:
1.4 misha 5644: /* If there are no characters > 255, or they are all to be included or
5645: excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the
5646: whole class was negated and whether there were negative specials such as \S
5647: (non-UCP) in the class. Then copy the 32-byte map into the code vector,
5648: negating it if necessary. */
1.1 misha 5649:
5650: *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
1.6 misha 5651: if (lengthptr == NULL) /* Save time in the pre-compile phase */
1.1 misha 5652: {
1.6 misha 5653: if (negate_class)
5654: for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];
1.1 misha 5655: memcpy(code, classbits, 32);
5656: }
1.6 misha 5657: code += 32 / sizeof(pcre_uchar);
1.7 misha 5658:
5659: END_CLASS:
1.1 misha 5660: break;
5661:
5662:
5663: /* ===================================================================*/
5664: /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
5665: has been tested above. */
5666:
1.3 misha 5667: case CHAR_LEFT_CURLY_BRACKET:
1.1 misha 5668: if (!is_quantifier) goto NORMAL_CHAR;
5669: ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);
5670: if (*errorcodeptr != 0) goto FAILED;
5671: goto REPEAT;
5672:
1.3 misha 5673: case CHAR_ASTERISK:
1.1 misha 5674: repeat_min = 0;
5675: repeat_max = -1;
5676: goto REPEAT;
5677:
1.3 misha 5678: case CHAR_PLUS:
1.1 misha 5679: repeat_min = 1;
5680: repeat_max = -1;
5681: goto REPEAT;
5682:
1.3 misha 5683: case CHAR_QUESTION_MARK:
1.1 misha 5684: repeat_min = 0;
5685: repeat_max = 1;
5686:
5687: REPEAT:
5688: if (previous == NULL)
5689: {
5690: *errorcodeptr = ERR9;
5691: goto FAILED;
5692: }
5693:
5694: if (repeat_min == 0)
5695: {
1.6 misha 5696: firstchar = zerofirstchar; /* Adjust for zero repeat */
1.7 misha 5697: firstcharflags = zerofirstcharflags;
1.6 misha 5698: reqchar = zeroreqchar; /* Ditto */
1.7 misha 5699: reqcharflags = zeroreqcharflags;
1.1 misha 5700: }
5701:
5702: /* Remember whether this is a variable length repeat */
5703:
5704: reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;
5705:
5706: op_type = 0; /* Default single-char op codes */
5707: possessive_quantifier = FALSE; /* Default not possessive quantifier */
5708:
1.6 misha 5709: /* Save start of previous item, in case we have to move it up in order to
5710: insert something before it. */
1.1 misha 5711:
5712: tempcode = previous;
5713:
1.8 moko 5714: /* Before checking for a possessive quantifier, we must skip over
5715: whitespace and comments in extended mode because Perl allows white space at
5716: this point. */
5717:
5718: if ((options & PCRE_EXTENDED) != 0)
5719: {
5720: const pcre_uchar *p = ptr + 1;
5721: for (;;)
5722: {
5723: while (MAX_255(*p) && (cd->ctypes[*p] & ctype_space) != 0) p++;
5724: if (*p != CHAR_NUMBER_SIGN) break;
5725: p++;
5726: while (*p != CHAR_NULL)
5727: {
5728: if (IS_NEWLINE(p)) /* For non-fixed-length newline cases, */
5729: { /* IS_NEWLINE sets cd->nllen. */
5730: p += cd->nllen;
5731: break;
5732: }
5733: p++;
5734: #ifdef SUPPORT_UTF
5735: if (utf) FORWARDCHAR(p);
5736: #endif
5737: } /* Loop for comment characters */
5738: } /* Loop for multiple comments */
5739: ptr = p - 1; /* Character before the next significant one. */
5740: }
5741:
1.9 ! moko 5742: /* We also need to skip over (?# comments, which are not dependent on
! 5743: extended mode. */
! 5744:
! 5745: if (ptr[1] == CHAR_LEFT_PARENTHESIS && ptr[2] == CHAR_QUESTION_MARK &&
! 5746: ptr[3] == CHAR_NUMBER_SIGN)
! 5747: {
! 5748: ptr += 4;
! 5749: while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
! 5750: if (*ptr == CHAR_NULL)
! 5751: {
! 5752: *errorcodeptr = ERR18;
! 5753: goto FAILED;
! 5754: }
! 5755: }
! 5756:
1.1 misha 5757: /* If the next character is '+', we have a possessive quantifier. This
5758: implies greediness, whatever the setting of the PCRE_UNGREEDY option.
5759: If the next character is '?' this is a minimizing repeat, by default,
5760: but if PCRE_UNGREEDY is set, it works the other way round. We change the
5761: repeat type to the non-default. */
5762:
1.3 misha 5763: if (ptr[1] == CHAR_PLUS)
1.1 misha 5764: {
5765: repeat_type = 0; /* Force greedy */
5766: possessive_quantifier = TRUE;
5767: ptr++;
5768: }
1.3 misha 5769: else if (ptr[1] == CHAR_QUESTION_MARK)
1.1 misha 5770: {
5771: repeat_type = greedy_non_default;
5772: ptr++;
5773: }
5774: else repeat_type = greedy_default;
5775:
1.6 misha 5776: /* If previous was a recursion call, wrap it in atomic brackets so that
5777: previous becomes the atomic group. All recursions were so wrapped in the
5778: past, but it no longer happens for non-repeated recursions. In fact, the
5779: repeated ones could be re-implemented independently so as not to need this,
5780: but for the moment we rely on the code for repeating groups. */
5781:
5782: if (*previous == OP_RECURSE)
5783: {
5784: memmove(previous + 1 + LINK_SIZE, previous, IN_UCHARS(1 + LINK_SIZE));
5785: *previous = OP_ONCE;
5786: PUT(previous, 1, 2 + 2*LINK_SIZE);
5787: previous[2 + 2*LINK_SIZE] = OP_KET;
5788: PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);
5789: code += 2 + 2 * LINK_SIZE;
5790: length_prevgroup = 3 + 3*LINK_SIZE;
5791:
5792: /* When actually compiling, we need to check whether this was a forward
5793: reference, and if so, adjust the offset. */
5794:
5795: if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)
5796: {
5797: int offset = GET(cd->hwm, -LINK_SIZE);
5798: if (offset == previous + 1 - cd->start_code)
5799: PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);
5800: }
5801: }
5802:
5803: /* Now handle repetition for the different types of item. */
5804:
1.7 misha 5805: /* If previous was a character or negated character match, abolish the item
5806: and generate a repeat item instead. If a char item has a minimum of more
5807: than one, ensure that it is set in reqchar - it might not be if a sequence
5808: such as x{3} is the first thing in a branch because the x will have gone
5809: into firstchar instead. */
5810:
5811: if (*previous == OP_CHAR || *previous == OP_CHARI
5812: || *previous == OP_NOT || *previous == OP_NOTI)
5813: {
5814: switch (*previous)
5815: {
5816: default: /* Make compiler happy. */
5817: case OP_CHAR: op_type = OP_STAR - OP_STAR; break;
5818: case OP_CHARI: op_type = OP_STARI - OP_STAR; break;
5819: case OP_NOT: op_type = OP_NOTSTAR - OP_STAR; break;
5820: case OP_NOTI: op_type = OP_NOTSTARI - OP_STAR; break;
5821: }
1.6 misha 5822:
5823: /* Deal with UTF characters that take up more than one character. It's
1.1 misha 5824: easier to write this out separately than try to macrify it. Use c to
1.6 misha 5825: hold the length of the character in bytes, plus UTF_LENGTH to flag that
5826: it's a length rather than a small character. */
1.1 misha 5827:
1.7 misha 5828: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.6 misha 5829: if (utf && NOT_FIRSTCHAR(code[-1]))
1.1 misha 5830: {
1.6 misha 5831: pcre_uchar *lastchar = code - 1;
5832: BACKCHAR(lastchar);
5833: c = (int)(code - lastchar); /* Length of UTF-8 character */
5834: memcpy(utf_chars, lastchar, IN_UCHARS(c)); /* Save the char */
5835: c |= UTF_LENGTH; /* Flag c as a length */
1.1 misha 5836: }
5837: else
1.6 misha 5838: #endif /* SUPPORT_UTF */
1.1 misha 5839:
1.6 misha 5840: /* Handle the case of a single charater - either with no UTF support, or
5841: with UTF disabled, or for a single character UTF character. */
1.1 misha 5842: {
5843: c = code[-1];
1.7 misha 5844: if (*previous <= OP_CHARI && repeat_min > 1)
5845: {
5846: reqchar = c;
5847: reqcharflags = req_caseopt | cd->req_varyopt;
5848: }
1.1 misha 5849: }
5850:
5851: goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */
5852: }
5853:
5854: /* If previous was a character type match (\d or similar), abolish it and
5855: create a suitable repeat item. The code is shared with single-character
5856: repeats by setting op_type to add a suitable offset into repeat_type. Note
5857: the the Unicode property types will be present only when SUPPORT_UCP is
5858: defined, but we don't wrap the little bits of code here because it just
5859: makes it horribly messy. */
5860:
5861: else if (*previous < OP_EODN)
5862: {
1.6 misha 5863: pcre_uchar *oldcode;
1.1 misha 5864: int prop_type, prop_value;
5865: op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */
5866: c = *previous;
5867:
5868: OUTPUT_SINGLE_REPEAT:
5869: if (*previous == OP_PROP || *previous == OP_NOTPROP)
5870: {
5871: prop_type = previous[1];
5872: prop_value = previous[2];
5873: }
5874: else prop_type = prop_value = -1;
5875:
5876: oldcode = code;
5877: code = previous; /* Usually overwrite previous item */
5878:
5879: /* If the maximum is zero then the minimum must also be zero; Perl allows
5880: this case, so we do too - by simply omitting the item altogether. */
5881:
5882: if (repeat_max == 0) goto END_REPEAT;
5883:
5884: /* Combine the op_type with the repeat_type */
5885:
5886: repeat_type += op_type;
5887:
5888: /* A minimum of zero is handled either as the special case * or ?, or as
5889: an UPTO, with the maximum given. */
5890:
5891: if (repeat_min == 0)
5892: {
5893: if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
5894: else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
5895: else
5896: {
5897: *code++ = OP_UPTO + repeat_type;
5898: PUT2INC(code, 0, repeat_max);
5899: }
5900: }
5901:
5902: /* A repeat minimum of 1 is optimized into some special cases. If the
5903: maximum is unlimited, we use OP_PLUS. Otherwise, the original item is
5904: left in place and, if the maximum is greater than 1, we use OP_UPTO with
5905: one less than the maximum. */
5906:
5907: else if (repeat_min == 1)
5908: {
5909: if (repeat_max == -1)
5910: *code++ = OP_PLUS + repeat_type;
5911: else
5912: {
5913: code = oldcode; /* leave previous item in place */
5914: if (repeat_max == 1) goto END_REPEAT;
5915: *code++ = OP_UPTO + repeat_type;
5916: PUT2INC(code, 0, repeat_max - 1);
5917: }
5918: }
5919:
5920: /* The case {n,n} is just an EXACT, while the general case {n,m} is
5921: handled as an EXACT followed by an UPTO. */
5922:
5923: else
5924: {
5925: *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */
5926: PUT2INC(code, 0, repeat_min);
5927:
5928: /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
5929: we have to insert the character for the previous code. For a repeated
5930: Unicode property match, there are two extra bytes that define the
5931: required property. In UTF-8 mode, long characters have their length in
1.6 misha 5932: c, with the UTF_LENGTH bit as a flag. */
1.1 misha 5933:
5934: if (repeat_max < 0)
5935: {
1.7 misha 5936: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.6 misha 5937: if (utf && (c & UTF_LENGTH) != 0)
1.1 misha 5938: {
1.6 misha 5939: memcpy(code, utf_chars, IN_UCHARS(c & 7));
1.1 misha 5940: code += c & 7;
5941: }
5942: else
5943: #endif
5944: {
5945: *code++ = c;
5946: if (prop_type >= 0)
5947: {
5948: *code++ = prop_type;
5949: *code++ = prop_value;
5950: }
5951: }
5952: *code++ = OP_STAR + repeat_type;
5953: }
5954:
5955: /* Else insert an UPTO if the max is greater than the min, again
5956: preceded by the character, for the previously inserted code. If the
5957: UPTO is just for 1 instance, we can use QUERY instead. */
5958:
5959: else if (repeat_max != repeat_min)
5960: {
1.7 misha 5961: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.6 misha 5962: if (utf && (c & UTF_LENGTH) != 0)
1.1 misha 5963: {
1.6 misha 5964: memcpy(code, utf_chars, IN_UCHARS(c & 7));
1.1 misha 5965: code += c & 7;
5966: }
5967: else
5968: #endif
5969: *code++ = c;
5970: if (prop_type >= 0)
5971: {
5972: *code++ = prop_type;
5973: *code++ = prop_value;
5974: }
5975: repeat_max -= repeat_min;
5976:
5977: if (repeat_max == 1)
5978: {
5979: *code++ = OP_QUERY + repeat_type;
5980: }
5981: else
5982: {
5983: *code++ = OP_UPTO + repeat_type;
5984: PUT2INC(code, 0, repeat_max);
5985: }
5986: }
5987: }
5988:
5989: /* The character or character type itself comes last in all cases. */
5990:
1.7 misha 5991: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.6 misha 5992: if (utf && (c & UTF_LENGTH) != 0)
1.1 misha 5993: {
1.6 misha 5994: memcpy(code, utf_chars, IN_UCHARS(c & 7));
1.1 misha 5995: code += c & 7;
5996: }
5997: else
5998: #endif
5999: *code++ = c;
6000:
6001: /* For a repeated Unicode property match, there are two extra bytes that
6002: define the required property. */
6003:
6004: #ifdef SUPPORT_UCP
6005: if (prop_type >= 0)
6006: {
6007: *code++ = prop_type;
6008: *code++ = prop_value;
6009: }
6010: #endif
6011: }
6012:
6013: /* If previous was a character class or a back reference, we put the repeat
6014: stuff after it, but just skip the item if the repeat was {0,0}. */
6015:
1.8 moko 6016: else if (*previous == OP_CLASS || *previous == OP_NCLASS ||
1.6 misha 6017: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
1.1 misha 6018: *previous == OP_XCLASS ||
6019: #endif
1.8 moko 6020: *previous == OP_REF || *previous == OP_REFI ||
6021: *previous == OP_DNREF || *previous == OP_DNREFI)
1.1 misha 6022: {
6023: if (repeat_max == 0)
6024: {
6025: code = previous;
6026: goto END_REPEAT;
6027: }
6028:
6029: if (repeat_min == 0 && repeat_max == -1)
6030: *code++ = OP_CRSTAR + repeat_type;
6031: else if (repeat_min == 1 && repeat_max == -1)
6032: *code++ = OP_CRPLUS + repeat_type;
6033: else if (repeat_min == 0 && repeat_max == 1)
6034: *code++ = OP_CRQUERY + repeat_type;
6035: else
6036: {
6037: *code++ = OP_CRRANGE + repeat_type;
6038: PUT2INC(code, 0, repeat_min);
6039: if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */
6040: PUT2INC(code, 0, repeat_max);
6041: }
6042: }
6043:
6044: /* If previous was a bracket group, we may have to replicate it in certain
1.6 misha 6045: cases. Note that at this point we can encounter only the "basic" bracket
6046: opcodes such as BRA and CBRA, as this is the place where they get converted
6047: into the more special varieties such as BRAPOS and SBRA. A test for >=
6048: OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK,
1.8 moko 6049: ASSERTBACK_NOT, ONCE, ONCE_NC, BRA, BRAPOS, CBRA, CBRAPOS, and COND.
6050: Originally, PCRE did not allow repetition of assertions, but now it does,
6051: for Perl compatibility. */
1.1 misha 6052:
1.6 misha 6053: else if (*previous >= OP_ASSERT && *previous <= OP_COND)
1.1 misha 6054: {
6055: register int i;
1.4 misha 6056: int len = (int)(code - previous);
1.9 ! moko 6057: size_t base_hwm_offset = item_hwm_offset;
1.6 misha 6058: pcre_uchar *bralink = NULL;
6059: pcre_uchar *brazeroptr = NULL;
1.1 misha 6060:
1.6 misha 6061: /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so
6062: we just ignore the repeat. */
1.1 misha 6063:
6064: if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)
1.6 misha 6065: goto END_REPEAT;
6066:
6067: /* There is no sense in actually repeating assertions. The only potential
6068: use of repetition is in cases when the assertion is optional. Therefore,
6069: if the minimum is greater than zero, just ignore the repeat. If the
1.8 moko 6070: maximum is not zero or one, set it to 1. */
1.6 misha 6071:
6072: if (*previous < OP_ONCE) /* Assertion */
1.1 misha 6073: {
1.6 misha 6074: if (repeat_min > 0) goto END_REPEAT;
6075: if (repeat_max < 0 || repeat_max > 1) repeat_max = 1;
1.1 misha 6076: }
6077:
6078: /* The case of a zero minimum is special because of the need to stick
6079: OP_BRAZERO in front of it, and because the group appears once in the
6080: data, whereas in other cases it appears the minimum number of times. For
6081: this reason, it is simplest to treat this case separately, as otherwise
6082: the code gets far too messy. There are several special subcases when the
6083: minimum is zero. */
6084:
6085: if (repeat_min == 0)
6086: {
6087: /* If the maximum is also zero, we used to just omit the group from the
6088: output altogether, like this:
6089:
6090: ** if (repeat_max == 0)
6091: ** {
6092: ** code = previous;
6093: ** goto END_REPEAT;
6094: ** }
6095:
1.6 misha 6096: However, that fails when a group or a subgroup within it is referenced
6097: as a subroutine from elsewhere in the pattern, so now we stick in
6098: OP_SKIPZERO in front of it so that it is skipped on execution. As we
6099: don't have a list of which groups are referenced, we cannot do this
6100: selectively.
1.1 misha 6101:
6102: If the maximum is 1 or unlimited, we just have to stick in the BRAZERO
6103: and do no more at this point. However, we do need to adjust any
6104: OP_RECURSE calls inside the group that refer to the group itself or any
6105: internal or forward referenced group, because the offset is from the
6106: start of the whole regex. Temporarily terminate the pattern while doing
6107: this. */
6108:
6109: if (repeat_max <= 1) /* Covers 0, 1, and unlimited */
6110: {
6111: *code = OP_END;
1.9 ! moko 6112: adjust_recurse(previous, 1, utf, cd, item_hwm_offset);
1.6 misha 6113: memmove(previous + 1, previous, IN_UCHARS(len));
1.1 misha 6114: code++;
6115: if (repeat_max == 0)
6116: {
6117: *previous++ = OP_SKIPZERO;
6118: goto END_REPEAT;
6119: }
1.6 misha 6120: brazeroptr = previous; /* Save for possessive optimizing */
1.1 misha 6121: *previous++ = OP_BRAZERO + repeat_type;
6122: }
6123:
6124: /* If the maximum is greater than 1 and limited, we have to replicate
6125: in a nested fashion, sticking OP_BRAZERO before each set of brackets.
6126: The first one has to be handled carefully because it's the original
6127: copy, which has to be moved up. The remainder can be handled by code
6128: that is common with the non-zero minimum case below. We have to
6129: adjust the value or repeat_max, since one less copy is required. Once
6130: again, we may have to adjust any OP_RECURSE calls inside the group. */
6131:
6132: else
6133: {
6134: int offset;
6135: *code = OP_END;
1.9 ! moko 6136: adjust_recurse(previous, 2 + LINK_SIZE, utf, cd, item_hwm_offset);
1.6 misha 6137: memmove(previous + 2 + LINK_SIZE, previous, IN_UCHARS(len));
1.1 misha 6138: code += 2 + LINK_SIZE;
6139: *previous++ = OP_BRAZERO + repeat_type;
6140: *previous++ = OP_BRA;
6141:
6142: /* We chain together the bracket offset fields that have to be
6143: filled in later when the ends of the brackets are reached. */
6144:
1.4 misha 6145: offset = (bralink == NULL)? 0 : (int)(previous - bralink);
1.1 misha 6146: bralink = previous;
6147: PUTINC(previous, 0, offset);
6148: }
6149:
6150: repeat_max--;
6151: }
6152:
6153: /* If the minimum is greater than zero, replicate the group as many
6154: times as necessary, and adjust the maximum to the number of subsequent
6155: copies that we need. If we set a first char from the group, and didn't
6156: set a required char, copy the latter from the former. If there are any
6157: forward reference subroutine calls in the group, there will be entries on
6158: the workspace list; replicate these with an appropriate increment. */
6159:
6160: else
6161: {
6162: if (repeat_min > 1)
6163: {
6164: /* In the pre-compile phase, we don't actually do the replication. We
6165: just adjust the length as if we had. Do some paranoid checks for
1.4 misha 6166: potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit
6167: integer type when available, otherwise double. */
1.1 misha 6168:
6169: if (lengthptr != NULL)
6170: {
6171: int delta = (repeat_min - 1)*length_prevgroup;
1.4 misha 6172: if ((INT64_OR_DOUBLE)(repeat_min - 1)*
6173: (INT64_OR_DOUBLE)length_prevgroup >
6174: (INT64_OR_DOUBLE)INT_MAX ||
1.1 misha 6175: OFLOW_MAX - *lengthptr < delta)
6176: {
6177: *errorcodeptr = ERR20;
6178: goto FAILED;
6179: }
6180: *lengthptr += delta;
6181: }
6182:
1.6 misha 6183: /* This is compiling for real. If there is a set first byte for
6184: the group, and we have not yet set a "required byte", set it. Make
6185: sure there is enough workspace for copying forward references before
6186: doing the copy. */
1.1 misha 6187:
6188: else
6189: {
1.7 misha 6190: if (groupsetfirstchar && reqcharflags < 0)
6191: {
6192: reqchar = firstchar;
6193: reqcharflags = firstcharflags;
6194: }
1.6 misha 6195:
1.1 misha 6196: for (i = 1; i < repeat_min; i++)
6197: {
1.6 misha 6198: pcre_uchar *hc;
1.8 moko 6199: size_t this_hwm_offset = cd->hwm - cd->start_workspace;
1.6 misha 6200: memcpy(code, previous, IN_UCHARS(len));
6201:
6202: while (cd->hwm > cd->start_workspace + cd->workspace_size -
1.8 moko 6203: WORK_SIZE_SAFETY_MARGIN -
6204: (this_hwm_offset - base_hwm_offset))
1.6 misha 6205: {
6206: *errorcodeptr = expand_workspace(cd);
6207: if (*errorcodeptr != 0) goto FAILED;
6208: }
6209:
1.8 moko 6210: for (hc = (pcre_uchar *)cd->start_workspace + base_hwm_offset;
6211: hc < (pcre_uchar *)cd->start_workspace + this_hwm_offset;
6212: hc += LINK_SIZE)
1.1 misha 6213: {
6214: PUT(cd->hwm, 0, GET(hc, 0) + len);
6215: cd->hwm += LINK_SIZE;
6216: }
1.8 moko 6217: base_hwm_offset = this_hwm_offset;
1.1 misha 6218: code += len;
6219: }
6220: }
6221: }
6222:
6223: if (repeat_max > 0) repeat_max -= repeat_min;
6224: }
6225:
6226: /* This code is common to both the zero and non-zero minimum cases. If
6227: the maximum is limited, it replicates the group in a nested fashion,
6228: remembering the bracket starts on a stack. In the case of a zero minimum,
6229: the first one was set up above. In all cases the repeat_max now specifies
6230: the number of additional copies needed. Again, we must remember to
6231: replicate entries on the forward reference list. */
6232:
6233: if (repeat_max >= 0)
6234: {
6235: /* In the pre-compile phase, we don't actually do the replication. We
6236: just adjust the length as if we had. For each repetition we must add 1
6237: to the length for BRAZERO and for all but the last repetition we must
6238: add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
1.4 misha 6239: paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is
6240: a 64-bit integer type when available, otherwise double. */
1.1 misha 6241:
6242: if (lengthptr != NULL && repeat_max > 0)
6243: {
6244: int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
6245: 2 - 2*LINK_SIZE; /* Last one doesn't nest */
1.4 misha 6246: if ((INT64_OR_DOUBLE)repeat_max *
6247: (INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
6248: > (INT64_OR_DOUBLE)INT_MAX ||
1.1 misha 6249: OFLOW_MAX - *lengthptr < delta)
6250: {
6251: *errorcodeptr = ERR20;
6252: goto FAILED;
6253: }
6254: *lengthptr += delta;
6255: }
6256:
6257: /* This is compiling for real */
6258:
6259: else for (i = repeat_max - 1; i >= 0; i--)
6260: {
1.6 misha 6261: pcre_uchar *hc;
1.8 moko 6262: size_t this_hwm_offset = cd->hwm - cd->start_workspace;
1.1 misha 6263:
6264: *code++ = OP_BRAZERO + repeat_type;
6265:
6266: /* All but the final copy start a new nesting, maintaining the
6267: chain of brackets outstanding. */
6268:
6269: if (i != 0)
6270: {
6271: int offset;
6272: *code++ = OP_BRA;
1.4 misha 6273: offset = (bralink == NULL)? 0 : (int)(code - bralink);
1.1 misha 6274: bralink = code;
6275: PUTINC(code, 0, offset);
6276: }
6277:
1.6 misha 6278: memcpy(code, previous, IN_UCHARS(len));
6279:
6280: /* Ensure there is enough workspace for forward references before
6281: copying them. */
6282:
6283: while (cd->hwm > cd->start_workspace + cd->workspace_size -
1.8 moko 6284: WORK_SIZE_SAFETY_MARGIN -
6285: (this_hwm_offset - base_hwm_offset))
1.6 misha 6286: {
6287: *errorcodeptr = expand_workspace(cd);
6288: if (*errorcodeptr != 0) goto FAILED;
6289: }
6290:
1.8 moko 6291: for (hc = (pcre_uchar *)cd->start_workspace + base_hwm_offset;
6292: hc < (pcre_uchar *)cd->start_workspace + this_hwm_offset;
6293: hc += LINK_SIZE)
1.1 misha 6294: {
6295: PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));
6296: cd->hwm += LINK_SIZE;
6297: }
1.8 moko 6298: base_hwm_offset = this_hwm_offset;
1.1 misha 6299: code += len;
6300: }
6301:
6302: /* Now chain through the pending brackets, and fill in their length
6303: fields (which are holding the chain links pro tem). */
6304:
6305: while (bralink != NULL)
6306: {
6307: int oldlinkoffset;
1.4 misha 6308: int offset = (int)(code - bralink + 1);
1.6 misha 6309: pcre_uchar *bra = code - offset;
1.1 misha 6310: oldlinkoffset = GET(bra, 1);
6311: bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
6312: *code++ = OP_KET;
6313: PUTINC(code, 0, offset);
6314: PUT(bra, 1, offset);
6315: }
6316: }
6317:
1.6 misha 6318: /* If the maximum is unlimited, set a repeater in the final copy. For
6319: ONCE brackets, that's all we need to do. However, possessively repeated
6320: ONCE brackets can be converted into non-capturing brackets, as the
6321: behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
6322: deal with possessive ONCEs specially.
1.1 misha 6323:
1.6 misha 6324: Otherwise, when we are doing the actual compile phase, check to see
6325: whether this group is one that could match an empty string. If so,
1.1 misha 6326: convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
1.6 misha 6327: that runtime checking can be done. [This check is also applied to ONCE
6328: groups at runtime, but in a different way.]
6329:
6330: Then, if the quantifier was possessive and the bracket is not a
6331: conditional, we convert the BRA code to the POS form, and the KET code to
6332: KETRPOS. (It turns out to be convenient at runtime to detect this kind of
6333: subpattern at both the start and at the end.) The use of special opcodes
6334: makes it possible to reduce greatly the stack usage in pcre_exec(). If
6335: the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO.
6336:
6337: Then, if the minimum number of matches is 1 or 0, cancel the possessive
6338: flag so that the default action below, of wrapping everything inside
6339: atomic brackets, does not happen. When the minimum is greater than 1,
6340: there will be earlier copies of the group, and so we still have to wrap
6341: the whole thing. */
1.1 misha 6342:
6343: else
6344: {
1.6 misha 6345: pcre_uchar *ketcode = code - 1 - LINK_SIZE;
6346: pcre_uchar *bracode = ketcode - GET(ketcode, 1);
6347:
6348: /* Convert possessive ONCE brackets to non-capturing */
6349:
6350: if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) &&
6351: possessive_quantifier) *bracode = OP_BRA;
6352:
6353: /* For non-possessive ONCE brackets, all we need to do is to
6354: set the KET. */
6355:
6356: if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC)
6357: *ketcode = OP_KETRMAX + repeat_type;
6358:
6359: /* Handle non-ONCE brackets and possessive ONCEs (which have been
6360: converted to non-capturing above). */
6361:
6362: else
1.1 misha 6363: {
1.6 misha 6364: /* In the compile phase, check for empty string matching. */
6365:
6366: if (lengthptr == NULL)
1.1 misha 6367: {
1.6 misha 6368: pcre_uchar *scode = bracode;
6369: do
1.1 misha 6370: {
1.8 moko 6371: if (could_be_empty_branch(scode, ketcode, utf, cd, NULL))
1.6 misha 6372: {
6373: *bracode += OP_SBRA - OP_BRA;
6374: break;
6375: }
6376: scode += GET(scode, 1);
6377: }
6378: while (*scode == OP_ALT);
6379: }
6380:
1.9 ! moko 6381: /* A conditional group with only one branch has an implicit empty
! 6382: alternative branch. */
! 6383:
! 6384: if (*bracode == OP_COND && bracode[GET(bracode,1)] != OP_ALT)
! 6385: *bracode = OP_SCOND;
! 6386:
1.6 misha 6387: /* Handle possessive quantifiers. */
6388:
6389: if (possessive_quantifier)
6390: {
6391: /* For COND brackets, we wrap the whole thing in a possessively
6392: repeated non-capturing bracket, because we have not invented POS
6393: versions of the COND opcodes. Because we are moving code along, we
6394: must ensure that any pending recursive references are updated. */
6395:
6396: if (*bracode == OP_COND || *bracode == OP_SCOND)
6397: {
6398: int nlen = (int)(code - bracode);
6399: *code = OP_END;
1.9 ! moko 6400: adjust_recurse(bracode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);
1.6 misha 6401: memmove(bracode + 1 + LINK_SIZE, bracode, IN_UCHARS(nlen));
6402: code += 1 + LINK_SIZE;
6403: nlen += 1 + LINK_SIZE;
1.9 ! moko 6404: *bracode = (*bracode == OP_COND)? OP_BRAPOS : OP_SBRAPOS;
1.6 misha 6405: *code++ = OP_KETRPOS;
6406: PUTINC(code, 0, nlen);
6407: PUT(bracode, 1, nlen);
6408: }
6409:
6410: /* For non-COND brackets, we modify the BRA code and use KETRPOS. */
6411:
6412: else
6413: {
6414: *bracode += 1; /* Switch to xxxPOS opcodes */
6415: *ketcode = OP_KETRPOS;
1.1 misha 6416: }
1.6 misha 6417:
6418: /* If the minimum is zero, mark it as possessive, then unset the
6419: possessive flag when the minimum is 0 or 1. */
6420:
6421: if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;
6422: if (repeat_min < 2) possessive_quantifier = FALSE;
1.1 misha 6423: }
1.6 misha 6424:
6425: /* Non-possessive quantifier */
6426:
6427: else *ketcode = OP_KETRMAX + repeat_type;
1.1 misha 6428: }
6429: }
6430: }
6431:
6432: /* If previous is OP_FAIL, it was generated by an empty class [] in
6433: JavaScript mode. The other ways in which OP_FAIL can be generated, that is
6434: by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"
6435: error above. We can just ignore the repeat in JS case. */
6436:
6437: else if (*previous == OP_FAIL) goto END_REPEAT;
6438:
6439: /* Else there's some kind of shambles */
6440:
6441: else
6442: {
6443: *errorcodeptr = ERR11;
6444: goto FAILED;
6445: }
6446:
1.8 moko 6447: /* If the character following a repeat is '+', possessive_quantifier is
6448: TRUE. For some opcodes, there are special alternative opcodes for this
6449: case. For anything else, we wrap the entire repeated item inside OP_ONCE
6450: brackets. Logically, the '+' notation is just syntactic sugar, taken from
6451: Sun's Java package, but the special opcodes can optimize it.
1.6 misha 6452:
6453: Some (but not all) possessively repeated subpatterns have already been
6454: completely handled in the code just above. For them, possessive_quantifier
1.8 moko 6455: is always FALSE at this stage. Note that the repeated item starts at
6456: tempcode, not at previous, which might be the first part of a string whose
6457: (former) last char we repeated. */
6458:
6459: if (possessive_quantifier)
6460: {
6461: int len;
6462:
6463: /* Possessifying an EXACT quantifier has no effect, so we can ignore it.
6464: However, QUERY, STAR, or UPTO may follow (for quantifiers such as {5,6},
6465: {5,}, or {5,10}). We skip over an EXACT item; if the length of what
6466: remains is greater than zero, there's a further opcode that can be
6467: handled. If not, do nothing, leaving the EXACT alone. */
6468:
6469: switch(*tempcode)
6470: {
6471: case OP_TYPEEXACT:
6472: tempcode += PRIV(OP_lengths)[*tempcode] +
6473: ((tempcode[1 + IMM2_SIZE] == OP_PROP
6474: || tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);
6475: break;
6476:
6477: /* CHAR opcodes are used for exacts whose count is 1. */
6478:
6479: case OP_CHAR:
6480: case OP_CHARI:
6481: case OP_NOT:
6482: case OP_NOTI:
6483: case OP_EXACT:
6484: case OP_EXACTI:
6485: case OP_NOTEXACT:
6486: case OP_NOTEXACTI:
6487: tempcode += PRIV(OP_lengths)[*tempcode];
6488: #ifdef SUPPORT_UTF
6489: if (utf && HAS_EXTRALEN(tempcode[-1]))
6490: tempcode += GET_EXTRALEN(tempcode[-1]);
6491: #endif
6492: break;
6493:
6494: /* For the class opcodes, the repeat operator appears at the end;
6495: adjust tempcode to point to it. */
6496:
6497: case OP_CLASS:
6498: case OP_NCLASS:
6499: tempcode += 1 + 32/sizeof(pcre_uchar);
6500: break;
6501:
6502: #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
6503: case OP_XCLASS:
6504: tempcode += GET(tempcode, 1);
6505: break;
6506: #endif
6507: }
6508:
6509: /* If tempcode is equal to code (which points to the end of the repeated
6510: item), it means we have skipped an EXACT item but there is no following
6511: QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In
6512: all other cases, tempcode will be pointing to the repeat opcode, and will
6513: be less than code, so the value of len will be greater than 0. */
6514:
6515: len = (int)(code - tempcode);
6516: if (len > 0)
6517: {
6518: unsigned int repcode = *tempcode;
1.6 misha 6519:
1.8 moko 6520: /* There is a table for possessifying opcodes, all of which are less
6521: than OP_CALLOUT. A zero entry means there is no possessified version.
6522: */
1.1 misha 6523:
1.8 moko 6524: if (repcode < OP_CALLOUT && opcode_possessify[repcode] > 0)
6525: *tempcode = opcode_possessify[repcode];
1.1 misha 6526:
1.8 moko 6527: /* For opcode without a special possessified version, wrap the item in
6528: ONCE brackets. Because we are moving code along, we must ensure that any
6529: pending recursive references are updated. */
1.4 misha 6530:
1.8 moko 6531: else
6532: {
6533: *code = OP_END;
1.9 ! moko 6534: adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);
1.8 moko 6535: memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));
6536: code += 1 + LINK_SIZE;
6537: len += 1 + LINK_SIZE;
6538: tempcode[0] = OP_ONCE;
6539: *code++ = OP_KET;
6540: PUTINC(code, 0, len);
6541: PUT(tempcode, 1, len);
6542: }
1.4 misha 6543: }
6544:
1.8 moko 6545: #ifdef NEVER
1.1 misha 6546: if (len > 0) switch (*tempcode)
6547: {
6548: case OP_STAR: *tempcode = OP_POSSTAR; break;
6549: case OP_PLUS: *tempcode = OP_POSPLUS; break;
6550: case OP_QUERY: *tempcode = OP_POSQUERY; break;
6551: case OP_UPTO: *tempcode = OP_POSUPTO; break;
6552:
1.6 misha 6553: case OP_STARI: *tempcode = OP_POSSTARI; break;
6554: case OP_PLUSI: *tempcode = OP_POSPLUSI; break;
6555: case OP_QUERYI: *tempcode = OP_POSQUERYI; break;
6556: case OP_UPTOI: *tempcode = OP_POSUPTOI; break;
1.1 misha 6557:
6558: case OP_NOTSTAR: *tempcode = OP_NOTPOSSTAR; break;
6559: case OP_NOTPLUS: *tempcode = OP_NOTPOSPLUS; break;
6560: case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;
6561: case OP_NOTUPTO: *tempcode = OP_NOTPOSUPTO; break;
6562:
1.6 misha 6563: case OP_NOTSTARI: *tempcode = OP_NOTPOSSTARI; break;
6564: case OP_NOTPLUSI: *tempcode = OP_NOTPOSPLUSI; break;
6565: case OP_NOTQUERYI: *tempcode = OP_NOTPOSQUERYI; break;
6566: case OP_NOTUPTOI: *tempcode = OP_NOTPOSUPTOI; break;
6567:
6568: case OP_TYPESTAR: *tempcode = OP_TYPEPOSSTAR; break;
6569: case OP_TYPEPLUS: *tempcode = OP_TYPEPOSPLUS; break;
6570: case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;
6571: case OP_TYPEUPTO: *tempcode = OP_TYPEPOSUPTO; break;
6572:
1.8 moko 6573: case OP_CRSTAR: *tempcode = OP_CRPOSSTAR; break;
6574: case OP_CRPLUS: *tempcode = OP_CRPOSPLUS; break;
6575: case OP_CRQUERY: *tempcode = OP_CRPOSQUERY; break;
6576: case OP_CRRANGE: *tempcode = OP_CRPOSRANGE; break;
6577:
1.4 misha 6578: /* Because we are moving code along, we must ensure that any
6579: pending recursive references are updated. */
6580:
1.1 misha 6581: default:
1.4 misha 6582: *code = OP_END;
1.9 ! moko 6583: adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);
1.6 misha 6584: memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));
1.1 misha 6585: code += 1 + LINK_SIZE;
6586: len += 1 + LINK_SIZE;
6587: tempcode[0] = OP_ONCE;
6588: *code++ = OP_KET;
6589: PUTINC(code, 0, len);
6590: PUT(tempcode, 1, len);
6591: break;
6592: }
1.8 moko 6593: #endif
1.1 misha 6594: }
6595:
6596: /* In all case we no longer have a previous item. We also set the
1.6 misha 6597: "follows varying string" flag for subsequently encountered reqchars if
1.1 misha 6598: it isn't already set and we have just passed a varying length item. */
6599:
6600: END_REPEAT:
6601: previous = NULL;
6602: cd->req_varyopt |= reqvary;
6603: break;
6604:
6605:
6606: /* ===================================================================*/
6607: /* Start of nested parenthesized sub-expression, or comment or lookahead or
6608: lookbehind or option setting or condition or all the other extended
6609: parenthesis forms. */
6610:
1.3 misha 6611: case CHAR_LEFT_PARENTHESIS:
1.8 moko 6612: ptr++;
6613:
6614: /* Now deal with various "verbs" that can be introduced by '*'. */
1.1 misha 6615:
1.6 misha 6616: if (ptr[0] == CHAR_ASTERISK && (ptr[1] == ':'
6617: || (MAX_255(ptr[1]) && ((cd->ctypes[ptr[1]] & ctype_letter) != 0))))
1.1 misha 6618: {
6619: int i, namelen;
1.4 misha 6620: int arglen = 0;
1.1 misha 6621: const char *vn = verbnames;
1.6 misha 6622: const pcre_uchar *name = ptr + 1;
6623: const pcre_uchar *arg = NULL;
1.1 misha 6624: previous = NULL;
1.6 misha 6625: ptr++;
6626: while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;
1.4 misha 6627: namelen = (int)(ptr - name);
6628:
1.6 misha 6629: /* It appears that Perl allows any characters whatsoever, other than
6630: a closing parenthesis, to appear in arguments, so we no longer insist on
6631: letters, digits, and underscores. */
6632:
1.3 misha 6633: if (*ptr == CHAR_COLON)
1.1 misha 6634: {
1.4 misha 6635: arg = ++ptr;
1.7 misha 6636: while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
1.4 misha 6637: arglen = (int)(ptr - arg);
1.7 misha 6638: if ((unsigned int)arglen > MAX_MARK)
6639: {
6640: *errorcodeptr = ERR75;
6641: goto FAILED;
6642: }
1.1 misha 6643: }
1.4 misha 6644:
1.3 misha 6645: if (*ptr != CHAR_RIGHT_PARENTHESIS)
1.1 misha 6646: {
6647: *errorcodeptr = ERR60;
6648: goto FAILED;
6649: }
1.4 misha 6650:
6651: /* Scan the table of verb names */
6652:
1.1 misha 6653: for (i = 0; i < verbcount; i++)
6654: {
6655: if (namelen == verbs[i].len &&
1.6 misha 6656: STRNCMP_UC_C8(name, vn, namelen) == 0)
1.1 misha 6657: {
1.7 misha 6658: int setverb;
6659:
1.6 misha 6660: /* Check for open captures before ACCEPT and convert it to
6661: ASSERT_ACCEPT if in an assertion. */
1.4 misha 6662:
6663: if (verbs[i].op == OP_ACCEPT)
6664: {
6665: open_capitem *oc;
1.6 misha 6666: if (arglen != 0)
6667: {
6668: *errorcodeptr = ERR59;
6669: goto FAILED;
6670: }
1.4 misha 6671: cd->had_accept = TRUE;
6672: for (oc = cd->open_caps; oc != NULL; oc = oc->next)
6673: {
1.9 ! moko 6674: if (lengthptr != NULL)
! 6675: {
! 6676: #ifdef COMPILE_PCRE8
! 6677: *lengthptr += 1 + IMM2_SIZE;
! 6678: #elif defined COMPILE_PCRE16
! 6679: *lengthptr += 2 + IMM2_SIZE;
! 6680: #elif defined COMPILE_PCRE32
! 6681: *lengthptr += 4 + IMM2_SIZE;
! 6682: #endif
! 6683: }
! 6684: else
! 6685: {
! 6686: *code++ = OP_CLOSE;
! 6687: PUT2INC(code, 0, oc->number);
! 6688: }
1.4 misha 6689: }
1.7 misha 6690: setverb = *code++ =
6691: (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
1.6 misha 6692:
6693: /* Do not set firstchar after *ACCEPT */
1.7 misha 6694: if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
1.4 misha 6695: }
6696:
1.6 misha 6697: /* Handle other cases with/without an argument */
1.4 misha 6698:
1.6 misha 6699: else if (arglen == 0)
1.4 misha 6700: {
6701: if (verbs[i].op < 0) /* Argument is mandatory */
6702: {
6703: *errorcodeptr = ERR66;
6704: goto FAILED;
6705: }
1.7 misha 6706: setverb = *code++ = verbs[i].op;
1.4 misha 6707: }
6708:
6709: else
6710: {
6711: if (verbs[i].op_arg < 0) /* Argument is forbidden */
6712: {
6713: *errorcodeptr = ERR59;
6714: goto FAILED;
6715: }
1.7 misha 6716: setverb = *code++ = verbs[i].op_arg;
1.9 ! moko 6717: if (lengthptr != NULL) /* In pass 1 just add in the length */
! 6718: { /* to avoid potential workspace */
! 6719: *lengthptr += arglen; /* overflow. */
! 6720: *code++ = 0;
! 6721: }
! 6722: else
! 6723: {
! 6724: *code++ = arglen;
! 6725: memcpy(code, arg, IN_UCHARS(arglen));
! 6726: code += arglen;
! 6727: }
1.4 misha 6728: *code++ = 0;
6729: }
6730:
1.7 misha 6731: switch (setverb)
6732: {
6733: case OP_THEN:
6734: case OP_THEN_ARG:
6735: cd->external_flags |= PCRE_HASTHEN;
6736: break;
6737:
6738: case OP_PRUNE:
6739: case OP_PRUNE_ARG:
6740: case OP_SKIP:
6741: case OP_SKIP_ARG:
6742: cd->had_pruneorskip = TRUE;
6743: break;
6744: }
6745:
1.4 misha 6746: break; /* Found verb, exit loop */
1.1 misha 6747: }
1.4 misha 6748:
1.1 misha 6749: vn += verbs[i].len + 1;
6750: }
1.4 misha 6751:
6752: if (i < verbcount) continue; /* Successfully handled a verb */
6753: *errorcodeptr = ERR60; /* Verb not recognized */
1.1 misha 6754: goto FAILED;
6755: }
6756:
1.8 moko 6757: /* Initialize for "real" parentheses */
6758:
6759: newoptions = options;
6760: skipbytes = 0;
6761: bravalue = OP_CBRA;
1.9 ! moko 6762: item_hwm_offset = cd->hwm - cd->start_workspace;
1.8 moko 6763: reset_bracount = FALSE;
6764:
1.1 misha 6765: /* Deal with the extended parentheses; all are introduced by '?', and the
6766: appearance of any of them means that this is not a capturing group. */
6767:
1.8 moko 6768: if (*ptr == CHAR_QUESTION_MARK)
1.1 misha 6769: {
6770: int i, set, unset, namelen;
6771: int *optset;
1.6 misha 6772: const pcre_uchar *name;
6773: pcre_uchar *slot;
1.1 misha 6774:
6775: switch (*(++ptr))
6776: {
6777: /* ------------------------------------------------------------ */
1.3 misha 6778: case CHAR_VERTICAL_LINE: /* Reset capture count for each branch */
1.1 misha 6779: reset_bracount = TRUE;
1.9 ! moko 6780: cd->dupgroups = TRUE; /* Record (?| encountered */
1.1 misha 6781: /* Fall through */
6782:
6783: /* ------------------------------------------------------------ */
1.3 misha 6784: case CHAR_COLON: /* Non-capturing bracket */
1.1 misha 6785: bravalue = OP_BRA;
6786: ptr++;
6787: break;
6788:
6789:
6790: /* ------------------------------------------------------------ */
1.3 misha 6791: case CHAR_LEFT_PARENTHESIS:
1.1 misha 6792: bravalue = OP_COND; /* Conditional group */
1.7 misha 6793: tempptr = ptr;
1.1 misha 6794:
6795: /* A condition can be an assertion, a number (referring to a numbered
1.8 moko 6796: group's having been set), a name (referring to a named group), or 'R',
6797: referring to recursion. R<digits> and R&name are also permitted for
6798: recursion tests.
6799:
6800: There are ways of testing a named group: (?(name)) is used by Python;
6801: Perl 5.10 onwards uses (?(<name>) or (?('name')).
6802:
6803: There is one unfortunate ambiguity, caused by history. 'R' can be the
6804: recursive thing or the name 'R' (and similarly for 'R' followed by
6805: digits). We look for a name first; if not found, we try the other case.
1.7 misha 6806:
6807: For compatibility with auto-callouts, we allow a callout to be
6808: specified before a condition that is an assertion. First, check for the
6809: syntax of a callout; if found, adjust the temporary pointer that is
6810: used to check for an assertion condition. That's all that is needed! */
6811:
6812: if (ptr[1] == CHAR_QUESTION_MARK && ptr[2] == CHAR_C)
6813: {
6814: for (i = 3;; i++) if (!IS_DIGIT(ptr[i])) break;
6815: if (ptr[i] == CHAR_RIGHT_PARENTHESIS)
6816: tempptr += i + 1;
1.9 ! moko 6817:
! 6818: /* tempptr should now be pointing to the opening parenthesis of the
! 6819: assertion condition. */
! 6820:
! 6821: if (*tempptr != CHAR_LEFT_PARENTHESIS)
! 6822: {
! 6823: *errorcodeptr = ERR28;
! 6824: goto FAILED;
! 6825: }
1.7 misha 6826: }
1.1 misha 6827:
6828: /* For conditions that are assertions, check the syntax, and then exit
6829: the switch. This will take control down to where bracketed groups,
6830: including assertions, are processed. */
6831:
1.7 misha 6832: if (tempptr[1] == CHAR_QUESTION_MARK &&
6833: (tempptr[2] == CHAR_EQUALS_SIGN ||
6834: tempptr[2] == CHAR_EXCLAMATION_MARK ||
1.8 moko 6835: (tempptr[2] == CHAR_LESS_THAN_SIGN &&
6836: (tempptr[3] == CHAR_EQUALS_SIGN ||
6837: tempptr[3] == CHAR_EXCLAMATION_MARK))))
6838: {
6839: cd->iscondassert = TRUE;
1.1 misha 6840: break;
1.8 moko 6841: }
1.1 misha 6842:
1.8 moko 6843: /* Other conditions use OP_CREF/OP_DNCREF/OP_RREF/OP_DNRREF, and all
6844: need to skip at least 1+IMM2_SIZE bytes at the start of the group. */
1.1 misha 6845:
6846: code[1+LINK_SIZE] = OP_CREF;
1.6 misha 6847: skipbytes = 1+IMM2_SIZE;
1.8 moko 6848: refsign = -1; /* => not a number */
6849: namelen = -1; /* => not a name; must set to avoid warning */
6850: name = NULL; /* Always set to avoid warning */
6851: recno = 0; /* Always set to avoid warning */
1.1 misha 6852:
6853: /* Check for a test for recursion in a named group. */
6854:
1.8 moko 6855: ptr++;
6856: if (*ptr == CHAR_R && ptr[1] == CHAR_AMPERSAND)
1.1 misha 6857: {
6858: terminator = -1;
6859: ptr += 2;
6860: code[1+LINK_SIZE] = OP_RREF; /* Change the type of test */
6861: }
6862:
6863: /* Check for a test for a named group's having been set, using the Perl
1.8 moko 6864: syntax (?(<name>) or (?('name'), and also allow for the original PCRE
6865: syntax of (?(name) or for (?(+n), (?(-n), and just (?(n). */
1.1 misha 6866:
1.8 moko 6867: else if (*ptr == CHAR_LESS_THAN_SIGN)
1.1 misha 6868: {
1.3 misha 6869: terminator = CHAR_GREATER_THAN_SIGN;
1.1 misha 6870: ptr++;
6871: }
1.8 moko 6872: else if (*ptr == CHAR_APOSTROPHE)
1.1 misha 6873: {
1.3 misha 6874: terminator = CHAR_APOSTROPHE;
1.1 misha 6875: ptr++;
6876: }
6877: else
6878: {
1.7 misha 6879: terminator = CHAR_NULL;
1.8 moko 6880: if (*ptr == CHAR_MINUS || *ptr == CHAR_PLUS) refsign = *ptr++;
6881: else if (IS_DIGIT(*ptr)) refsign = 0;
1.1 misha 6882: }
6883:
1.8 moko 6884: /* Handle a number */
1.1 misha 6885:
1.8 moko 6886: if (refsign >= 0)
1.1 misha 6887: {
1.8 moko 6888: while (IS_DIGIT(*ptr))
6889: {
1.9 ! moko 6890: if (recno > INT_MAX / 10 - 1) /* Integer overflow */
! 6891: {
! 6892: while (IS_DIGIT(*ptr)) ptr++;
! 6893: *errorcodeptr = ERR61;
! 6894: goto FAILED;
! 6895: }
1.8 moko 6896: recno = recno * 10 + (int)(*ptr - CHAR_0);
6897: ptr++;
6898: }
1.1 misha 6899: }
6900:
1.8 moko 6901: /* Otherwise we expect to read a name; anything else is an error. When
6902: a name is one of a number of duplicates, a different opcode is used and
6903: it needs more memory. Unfortunately we cannot tell whether a name is a
6904: duplicate in the first pass, so we have to allow for more memory. */
1.1 misha 6905:
1.8 moko 6906: else
1.1 misha 6907: {
1.8 moko 6908: if (IS_DIGIT(*ptr))
6909: {
6910: *errorcodeptr = ERR84;
6911: goto FAILED;
6912: }
6913: if (!MAX_255(*ptr) || (cd->ctypes[*ptr] & ctype_word) == 0)
6914: {
6915: *errorcodeptr = ERR28; /* Assertion expected */
6916: goto FAILED;
6917: }
6918: name = ptr++;
6919: while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0)
6920: {
6921: ptr++;
6922: }
6923: namelen = (int)(ptr - name);
1.9 ! moko 6924: if (lengthptr != NULL) skipbytes += IMM2_SIZE;
1.1 misha 6925: }
1.8 moko 6926:
6927: /* Check the terminator */
1.1 misha 6928:
1.7 misha 6929: if ((terminator > 0 && *ptr++ != (pcre_uchar)terminator) ||
1.3 misha 6930: *ptr++ != CHAR_RIGHT_PARENTHESIS)
1.1 misha 6931: {
1.8 moko 6932: ptr--; /* Error offset */
6933: *errorcodeptr = ERR26; /* Malformed number or name */
1.1 misha 6934: goto FAILED;
6935: }
6936:
6937: /* Do no further checking in the pre-compile phase. */
6938:
6939: if (lengthptr != NULL) break;
6940:
6941: /* In the real compile we do the work of looking for the actual
1.8 moko 6942: reference. If refsign is not negative, it means we have a number in
6943: recno. */
1.1 misha 6944:
1.8 moko 6945: if (refsign >= 0)
1.1 misha 6946: {
6947: if (recno <= 0)
6948: {
1.8 moko 6949: *errorcodeptr = ERR35;
1.1 misha 6950: goto FAILED;
6951: }
1.8 moko 6952: if (refsign != 0) recno = (refsign == CHAR_MINUS)?
6953: cd->bracount - recno + 1 : recno + cd->bracount;
1.1 misha 6954: if (recno <= 0 || recno > cd->final_bracount)
6955: {
6956: *errorcodeptr = ERR15;
6957: goto FAILED;
6958: }
6959: PUT2(code, 2+LINK_SIZE, recno);
1.8 moko 6960: if (recno > cd->top_backref) cd->top_backref = recno;
1.1 misha 6961: break;
6962: }
6963:
1.8 moko 6964: /* Otherwise look for the name. */
1.1 misha 6965:
6966: slot = cd->name_table;
6967: for (i = 0; i < cd->names_found; i++)
6968: {
1.9 ! moko 6969: if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&
! 6970: slot[IMM2_SIZE+namelen] == 0) break;
1.1 misha 6971: slot += cd->name_entry_size;
6972: }
6973:
1.8 moko 6974: /* Found the named subpattern. If the name is duplicated, add one to
6975: the opcode to change CREF/RREF into DNCREF/DNRREF and insert
6976: appropriate data values. Otherwise, just insert the unique subpattern
6977: number. */
1.1 misha 6978:
6979: if (i < cd->names_found)
6980: {
1.8 moko 6981: int offset = i++;
6982: int count = 1;
6983: recno = GET2(slot, 0); /* Number from first found */
6984: if (recno > cd->top_backref) cd->top_backref = recno;
6985: for (; i < cd->names_found; i++)
6986: {
6987: slot += cd->name_entry_size;
6988: if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) != 0 ||
6989: (slot+IMM2_SIZE)[namelen] != 0) break;
6990: count++;
6991: }
1.1 misha 6992:
1.8 moko 6993: if (count > 1)
6994: {
6995: PUT2(code, 2+LINK_SIZE, offset);
6996: PUT2(code, 2+LINK_SIZE+IMM2_SIZE, count);
6997: skipbytes += IMM2_SIZE;
6998: code[1+LINK_SIZE]++;
6999: }
7000: else /* Not a duplicated name */
7001: {
7002: PUT2(code, 2+LINK_SIZE, recno);
7003: }
1.1 misha 7004: }
7005:
1.7 misha 7006: /* If terminator == CHAR_NULL it means that the name followed directly
7007: after the opening parenthesis [e.g. (?(abc)...] and in this case there
7008: are some further alternatives to try. For the cases where terminator !=
1.8 moko 7009: CHAR_NULL [things like (?(<name>... or (?('name')... or (?(R&name)... ]
7010: we have now checked all the possibilities, so give an error. */
1.1 misha 7011:
1.7 misha 7012: else if (terminator != CHAR_NULL)
1.1 misha 7013: {
7014: *errorcodeptr = ERR15;
7015: goto FAILED;
7016: }
7017:
7018: /* Check for (?(R) for recursion. Allow digits after R to specify a
7019: specific group number. */
7020:
1.3 misha 7021: else if (*name == CHAR_R)
1.1 misha 7022: {
7023: recno = 0;
7024: for (i = 1; i < namelen; i++)
7025: {
1.6 misha 7026: if (!IS_DIGIT(name[i]))
1.1 misha 7027: {
7028: *errorcodeptr = ERR15;
7029: goto FAILED;
7030: }
1.9 ! moko 7031: if (recno > INT_MAX / 10 - 1) /* Integer overflow */
! 7032: {
! 7033: *errorcodeptr = ERR61;
! 7034: goto FAILED;
! 7035: }
1.3 misha 7036: recno = recno * 10 + name[i] - CHAR_0;
1.1 misha 7037: }
7038: if (recno == 0) recno = RREF_ANY;
7039: code[1+LINK_SIZE] = OP_RREF; /* Change test type */
7040: PUT2(code, 2+LINK_SIZE, recno);
7041: }
7042:
7043: /* Similarly, check for the (?(DEFINE) "condition", which is always
7044: false. */
7045:
1.6 misha 7046: else if (namelen == 6 && STRNCMP_UC_C8(name, STRING_DEFINE, 6) == 0)
1.1 misha 7047: {
7048: code[1+LINK_SIZE] = OP_DEF;
7049: skipbytes = 1;
7050: }
7051:
1.8 moko 7052: /* Reference to an unidentified subpattern. */
1.1 misha 7053:
7054: else
7055: {
1.8 moko 7056: *errorcodeptr = ERR15;
1.1 misha 7057: goto FAILED;
7058: }
7059: break;
7060:
7061:
7062: /* ------------------------------------------------------------ */
1.3 misha 7063: case CHAR_EQUALS_SIGN: /* Positive lookahead */
1.1 misha 7064: bravalue = OP_ASSERT;
1.6 misha 7065: cd->assert_depth += 1;
1.1 misha 7066: ptr++;
7067: break;
7068:
1.8 moko 7069: /* Optimize (?!) to (*FAIL) unless it is quantified - which is a weird
7070: thing to do, but Perl allows all assertions to be quantified, and when
7071: they contain capturing parentheses there may be a potential use for
7072: this feature. Not that that applies to a quantified (?!) but we allow
7073: it for uniformity. */
1.1 misha 7074:
7075: /* ------------------------------------------------------------ */
1.3 misha 7076: case CHAR_EXCLAMATION_MARK: /* Negative lookahead */
1.1 misha 7077: ptr++;
1.8 moko 7078: if (*ptr == CHAR_RIGHT_PARENTHESIS && ptr[1] != CHAR_ASTERISK &&
7079: ptr[1] != CHAR_PLUS && ptr[1] != CHAR_QUESTION_MARK &&
7080: (ptr[1] != CHAR_LEFT_CURLY_BRACKET || !is_counted_repeat(ptr+2)))
1.1 misha 7081: {
7082: *code++ = OP_FAIL;
7083: previous = NULL;
7084: continue;
7085: }
7086: bravalue = OP_ASSERT_NOT;
1.6 misha 7087: cd->assert_depth += 1;
1.1 misha 7088: break;
7089:
7090:
7091: /* ------------------------------------------------------------ */
1.3 misha 7092: case CHAR_LESS_THAN_SIGN: /* Lookbehind or named define */
1.1 misha 7093: switch (ptr[1])
7094: {
1.3 misha 7095: case CHAR_EQUALS_SIGN: /* Positive lookbehind */
1.1 misha 7096: bravalue = OP_ASSERTBACK;
1.6 misha 7097: cd->assert_depth += 1;
1.1 misha 7098: ptr += 2;
7099: break;
7100:
1.3 misha 7101: case CHAR_EXCLAMATION_MARK: /* Negative lookbehind */
1.1 misha 7102: bravalue = OP_ASSERTBACK_NOT;
1.6 misha 7103: cd->assert_depth += 1;
1.1 misha 7104: ptr += 2;
7105: break;
7106:
7107: default: /* Could be name define, else bad */
1.6 misha 7108: if (MAX_255(ptr[1]) && (cd->ctypes[ptr[1]] & ctype_word) != 0)
7109: goto DEFINE_NAME;
1.1 misha 7110: ptr++; /* Correct offset for error */
7111: *errorcodeptr = ERR24;
7112: goto FAILED;
7113: }
7114: break;
7115:
7116:
7117: /* ------------------------------------------------------------ */
1.3 misha 7118: case CHAR_GREATER_THAN_SIGN: /* One-time brackets */
1.1 misha 7119: bravalue = OP_ONCE;
7120: ptr++;
7121: break;
7122:
7123:
7124: /* ------------------------------------------------------------ */
1.3 misha 7125: case CHAR_C: /* Callout - may be followed by digits; */
1.6 misha 7126: previous_callout = code; /* Save for later completion */
7127: after_manual_callout = 1; /* Skip one item before completing */
1.1 misha 7128: *code++ = OP_CALLOUT;
7129: {
7130: int n = 0;
1.6 misha 7131: ptr++;
7132: while(IS_DIGIT(*ptr))
7133: n = n * 10 + *ptr++ - CHAR_0;
1.3 misha 7134: if (*ptr != CHAR_RIGHT_PARENTHESIS)
1.1 misha 7135: {
7136: *errorcodeptr = ERR39;
7137: goto FAILED;
7138: }
7139: if (n > 255)
7140: {
7141: *errorcodeptr = ERR38;
7142: goto FAILED;
7143: }
7144: *code++ = n;
1.4 misha 7145: PUT(code, 0, (int)(ptr - cd->start_pattern + 1)); /* Pattern offset */
7146: PUT(code, LINK_SIZE, 0); /* Default length */
1.1 misha 7147: code += 2 * LINK_SIZE;
7148: }
7149: previous = NULL;
7150: continue;
7151:
7152:
7153: /* ------------------------------------------------------------ */
1.3 misha 7154: case CHAR_P: /* Python-style named subpattern handling */
7155: if (*(++ptr) == CHAR_EQUALS_SIGN ||
7156: *ptr == CHAR_GREATER_THAN_SIGN) /* Reference or recursion */
1.1 misha 7157: {
1.3 misha 7158: is_recurse = *ptr == CHAR_GREATER_THAN_SIGN;
7159: terminator = CHAR_RIGHT_PARENTHESIS;
1.1 misha 7160: goto NAMED_REF_OR_RECURSE;
7161: }
1.3 misha 7162: else if (*ptr != CHAR_LESS_THAN_SIGN) /* Test for Python-style defn */
1.1 misha 7163: {
7164: *errorcodeptr = ERR41;
7165: goto FAILED;
7166: }
7167: /* Fall through to handle (?P< as (?< is handled */
7168:
7169:
7170: /* ------------------------------------------------------------ */
7171: DEFINE_NAME: /* Come here from (?< handling */
1.3 misha 7172: case CHAR_APOSTROPHE:
1.8 moko 7173: terminator = (*ptr == CHAR_LESS_THAN_SIGN)?
7174: CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
7175: name = ++ptr;
7176: if (IS_DIGIT(*ptr))
7177: {
7178: *errorcodeptr = ERR84; /* Group name must start with non-digit */
7179: goto FAILED;
7180: }
7181: while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
7182: namelen = (int)(ptr - name);
7183:
7184: /* In the pre-compile phase, do a syntax check, remember the longest
7185: name, and then remember the group in a vector, expanding it if
7186: necessary. Duplicates for the same number are skipped; other duplicates
7187: are checked for validity. In the actual compile, there is nothing to
7188: do. */
7189:
7190: if (lengthptr != NULL)
1.1 misha 7191: {
1.8 moko 7192: named_group *ng;
7193: pcre_uint32 number = cd->bracount + 1;
1.1 misha 7194:
1.8 moko 7195: if (*ptr != (pcre_uchar)terminator)
7196: {
7197: *errorcodeptr = ERR42;
7198: goto FAILED;
7199: }
1.1 misha 7200:
1.8 moko 7201: if (cd->names_found >= MAX_NAME_COUNT)
7202: {
7203: *errorcodeptr = ERR49;
7204: goto FAILED;
7205: }
1.1 misha 7206:
1.8 moko 7207: if (namelen + IMM2_SIZE + 1 > cd->name_entry_size)
1.1 misha 7208: {
1.8 moko 7209: cd->name_entry_size = namelen + IMM2_SIZE + 1;
7210: if (namelen > MAX_NAME_SIZE)
1.1 misha 7211: {
1.8 moko 7212: *errorcodeptr = ERR48;
1.1 misha 7213: goto FAILED;
7214: }
1.8 moko 7215: }
7216:
7217: /* Scan the list to check for duplicates. For duplicate names, if the
7218: number is the same, break the loop, which causes the name to be
7219: discarded; otherwise, if DUPNAMES is not set, give an error.
7220: If it is set, allow the name with a different number, but continue
7221: scanning in case this is a duplicate with the same number. For
7222: non-duplicate names, give an error if the number is duplicated. */
7223:
7224: ng = cd->named_groups;
7225: for (i = 0; i < cd->names_found; i++, ng++)
7226: {
7227: if (namelen == ng->length &&
7228: STRNCMP_UC_UC(name, ng->name, namelen) == 0)
1.1 misha 7229: {
1.8 moko 7230: if (ng->number == number) break;
7231: if ((options & PCRE_DUPNAMES) == 0)
1.1 misha 7232: {
1.8 moko 7233: *errorcodeptr = ERR43;
1.1 misha 7234: goto FAILED;
7235: }
1.8 moko 7236: cd->dupnames = TRUE; /* Duplicate names exist */
7237: }
7238: else if (ng->number == number)
7239: {
7240: *errorcodeptr = ERR65;
7241: goto FAILED;
1.1 misha 7242: }
7243: }
7244:
1.8 moko 7245: if (i >= cd->names_found) /* Not a duplicate with same number */
1.1 misha 7246: {
1.8 moko 7247: /* Increase the list size if necessary */
1.4 misha 7248:
1.8 moko 7249: if (cd->names_found >= cd->named_group_list_size)
1.1 misha 7250: {
1.8 moko 7251: int newsize = cd->named_group_list_size * 2;
7252: named_group *newspace = (PUBL(malloc))
7253: (newsize * sizeof(named_group));
1.4 misha 7254:
1.8 moko 7255: if (newspace == NULL)
1.1 misha 7256: {
1.8 moko 7257: *errorcodeptr = ERR21;
7258: goto FAILED;
1.1 misha 7259: }
1.4 misha 7260:
1.8 moko 7261: memcpy(newspace, cd->named_groups,
7262: cd->named_group_list_size * sizeof(named_group));
7263: if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE)
7264: (PUBL(free))((void *)cd->named_groups);
7265: cd->named_groups = newspace;
7266: cd->named_group_list_size = newsize;
1.4 misha 7267: }
7268:
1.8 moko 7269: cd->named_groups[cd->names_found].name = name;
7270: cd->named_groups[cd->names_found].length = namelen;
7271: cd->named_groups[cd->names_found].number = number;
7272: cd->names_found++;
1.1 misha 7273: }
7274: }
7275:
1.8 moko 7276: ptr++; /* Move past > or ' in both passes. */
1.1 misha 7277: goto NUMBERED_GROUP;
7278:
7279:
7280: /* ------------------------------------------------------------ */
1.3 misha 7281: case CHAR_AMPERSAND: /* Perl recursion/subroutine syntax */
7282: terminator = CHAR_RIGHT_PARENTHESIS;
1.1 misha 7283: is_recurse = TRUE;
7284: /* Fall through */
7285:
7286: /* We come here from the Python syntax above that handles both
7287: references (?P=name) and recursion (?P>name), as well as falling
7288: through from the Perl recursion syntax (?&name). We also come here from
7289: the Perl \k<name> or \k'name' back reference syntax and the \k{name}
7290: .NET syntax, and the Oniguruma \g<...> and \g'...' subroutine syntax. */
7291:
7292: NAMED_REF_OR_RECURSE:
7293: name = ++ptr;
1.8 moko 7294: if (IS_DIGIT(*ptr))
7295: {
7296: *errorcodeptr = ERR84; /* Group name must start with non-digit */
7297: goto FAILED;
7298: }
1.6 misha 7299: while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
1.4 misha 7300: namelen = (int)(ptr - name);
1.1 misha 7301:
1.5 misha 7302: /* In the pre-compile phase, do a syntax check. We used to just set
7303: a dummy reference number, because it was not used in the first pass.
7304: However, with the change of recursive back references to be atomic,
7305: we have to look for the number so that this state can be identified, as
7306: otherwise the incorrect length is computed. If it's not a backwards
7307: reference, the dummy number will do. */
1.1 misha 7308:
7309: if (lengthptr != NULL)
7310: {
1.8 moko 7311: named_group *ng;
1.9 ! moko 7312: recno = 0;
1.5 misha 7313:
1.1 misha 7314: if (namelen == 0)
7315: {
7316: *errorcodeptr = ERR62;
7317: goto FAILED;
7318: }
1.7 misha 7319: if (*ptr != (pcre_uchar)terminator)
1.1 misha 7320: {
7321: *errorcodeptr = ERR42;
7322: goto FAILED;
7323: }
7324: if (namelen > MAX_NAME_SIZE)
7325: {
7326: *errorcodeptr = ERR48;
7327: goto FAILED;
7328: }
1.5 misha 7329:
1.8 moko 7330: /* Count named back references. */
7331:
7332: if (!is_recurse) cd->namedrefcount++;
7333:
7334: /* We have to allow for a named reference to a duplicated name (this
7335: cannot be determined until the second pass). This needs an extra
7336: 16-bit data item. */
7337:
7338: *lengthptr += IMM2_SIZE;
1.9 ! moko 7339:
! 7340: /* If this is a forward reference and we are within a (?|...) group,
! 7341: the reference may end up as the number of a group which we are
! 7342: currently inside, that is, it could be a recursive reference. In the
! 7343: real compile this will be picked up and the reference wrapped with
! 7344: OP_ONCE to make it atomic, so we must space in case this occurs. */
! 7345:
! 7346: /* In fact, this can happen for a non-forward reference because
! 7347: another group with the same number might be created later. This
! 7348: issue is fixed "properly" in PCRE2. As PCRE1 is now in maintenance
! 7349: only mode, we finesse the bug by allowing more memory always. */
! 7350:
! 7351: *lengthptr += 4 + 4*LINK_SIZE;
! 7352:
! 7353: /* It is even worse than that. The current reference may be to an
! 7354: existing named group with a different number (so apparently not
! 7355: recursive) but which later on is also attached to a group with the
! 7356: current number. This can only happen if $(| has been previous
! 7357: encountered. In that case, we allow yet more memory, just in case.
! 7358: (Again, this is fixed "properly" in PCRE2. */
! 7359:
! 7360: if (cd->dupgroups) *lengthptr += 4 + 4*LINK_SIZE;
! 7361:
! 7362: /* Otherwise, check for recursion here. The name table does not exist
! 7363: in the first pass; instead we must scan the list of names encountered
! 7364: so far in order to get the number. If the name is not found, leave
! 7365: the value of recno as 0 for a forward reference. */
! 7366:
! 7367: /* This patch (removing "else") fixes a problem when a reference is
! 7368: to multiple identically named nested groups from within the nest.
! 7369: Once again, it is not the "proper" fix, and it results in an
! 7370: over-allocation of memory. */
! 7371:
! 7372: /* else */
! 7373: {
! 7374: ng = cd->named_groups;
! 7375: for (i = 0; i < cd->names_found; i++, ng++)
! 7376: {
! 7377: if (namelen == ng->length &&
! 7378: STRNCMP_UC_UC(name, ng->name, namelen) == 0)
! 7379: {
! 7380: open_capitem *oc;
! 7381: recno = ng->number;
! 7382: if (is_recurse) break;
! 7383: for (oc = cd->open_caps; oc != NULL; oc = oc->next)
! 7384: {
! 7385: if (oc->number == recno)
! 7386: {
! 7387: oc->flag = TRUE;
! 7388: break;
! 7389: }
! 7390: }
! 7391: }
! 7392: }
! 7393: }
1.1 misha 7394: }
7395:
1.8 moko 7396: /* In the real compile, search the name table. We check the name
1.1 misha 7397: first, and then check that we have reached the end of the name in the
1.8 moko 7398: table. That way, if the name is longer than any in the table, the
7399: comparison will fail without reading beyond the table entry. */
1.1 misha 7400:
7401: else
7402: {
7403: slot = cd->name_table;
7404: for (i = 0; i < cd->names_found; i++)
7405: {
1.6 misha 7406: if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&
7407: slot[IMM2_SIZE+namelen] == 0)
1.1 misha 7408: break;
7409: slot += cd->name_entry_size;
7410: }
7411:
1.8 moko 7412: if (i < cd->names_found)
1.1 misha 7413: {
7414: recno = GET2(slot, 0);
7415: }
1.8 moko 7416: else
1.1 misha 7417: {
7418: *errorcodeptr = ERR15;
7419: goto FAILED;
7420: }
7421: }
7422:
1.8 moko 7423: /* In both phases, for recursions, we can now go to the code than
7424: handles numerical recursion. */
1.1 misha 7425:
7426: if (is_recurse) goto HANDLE_RECURSION;
1.8 moko 7427:
7428: /* In the second pass we must see if the name is duplicated. If so, we
7429: generate a different opcode. */
7430:
7431: if (lengthptr == NULL && cd->dupnames)
7432: {
7433: int count = 1;
7434: unsigned int index = i;
7435: pcre_uchar *cslot = slot + cd->name_entry_size;
7436:
7437: for (i++; i < cd->names_found; i++)
7438: {
7439: if (STRCMP_UC_UC(slot + IMM2_SIZE, cslot + IMM2_SIZE) != 0) break;
7440: count++;
7441: cslot += cd->name_entry_size;
7442: }
7443:
7444: if (count > 1)
7445: {
7446: if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
7447: previous = code;
1.9 ! moko 7448: item_hwm_offset = cd->hwm - cd->start_workspace;
1.8 moko 7449: *code++ = ((options & PCRE_CASELESS) != 0)? OP_DNREFI : OP_DNREF;
7450: PUT2INC(code, 0, index);
7451: PUT2INC(code, 0, count);
7452:
7453: /* Process each potentially referenced group. */
7454:
7455: for (; slot < cslot; slot += cd->name_entry_size)
7456: {
7457: open_capitem *oc;
7458: recno = GET2(slot, 0);
7459: cd->backref_map |= (recno < 32)? (1 << recno) : 1;
7460: if (recno > cd->top_backref) cd->top_backref = recno;
7461:
7462: /* Check to see if this back reference is recursive, that it, it
7463: is inside the group that it references. A flag is set so that the
7464: group can be made atomic. */
7465:
7466: for (oc = cd->open_caps; oc != NULL; oc = oc->next)
7467: {
7468: if (oc->number == recno)
7469: {
7470: oc->flag = TRUE;
7471: break;
7472: }
7473: }
7474: }
7475:
7476: continue; /* End of back ref handling */
7477: }
7478: }
7479:
7480: /* First pass, or a non-duplicated name. */
7481:
7482: goto HANDLE_REFERENCE;
1.1 misha 7483:
7484:
7485: /* ------------------------------------------------------------ */
1.9 ! moko 7486: case CHAR_R: /* Recursion, same as (?0) */
! 7487: recno = 0;
! 7488: if (*(++ptr) != CHAR_RIGHT_PARENTHESIS)
! 7489: {
! 7490: *errorcodeptr = ERR29;
! 7491: goto FAILED;
! 7492: }
! 7493: goto HANDLE_RECURSION;
1.1 misha 7494:
7495:
7496: /* ------------------------------------------------------------ */
1.3 misha 7497: case CHAR_MINUS: case CHAR_PLUS: /* Recursion or subroutine */
7498: case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:
7499: case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
1.1 misha 7500: {
1.6 misha 7501: const pcre_uchar *called;
1.3 misha 7502: terminator = CHAR_RIGHT_PARENTHESIS;
1.1 misha 7503:
7504: /* Come here from the \g<...> and \g'...' code (Oniguruma
7505: compatibility). However, the syntax has been checked to ensure that
7506: the ... are a (signed) number, so that neither ERR63 nor ERR29 will
7507: be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
7508: ever be taken. */
7509:
7510: HANDLE_NUMERICAL_RECURSION:
7511:
1.3 misha 7512: if ((refsign = *ptr) == CHAR_PLUS)
1.1 misha 7513: {
7514: ptr++;
1.6 misha 7515: if (!IS_DIGIT(*ptr))
1.1 misha 7516: {
7517: *errorcodeptr = ERR63;
7518: goto FAILED;
7519: }
7520: }
1.3 misha 7521: else if (refsign == CHAR_MINUS)
1.1 misha 7522: {
1.6 misha 7523: if (!IS_DIGIT(ptr[1]))
1.1 misha 7524: goto OTHER_CHAR_AFTER_QUERY;
7525: ptr++;
7526: }
7527:
7528: recno = 0;
1.6 misha 7529: while(IS_DIGIT(*ptr))
1.9 ! moko 7530: {
! 7531: if (recno > INT_MAX / 10 - 1) /* Integer overflow */
! 7532: {
! 7533: while (IS_DIGIT(*ptr)) ptr++;
! 7534: *errorcodeptr = ERR61;
! 7535: goto FAILED;
! 7536: }
1.3 misha 7537: recno = recno * 10 + *ptr++ - CHAR_0;
1.9 ! moko 7538: }
1.1 misha 7539:
1.7 misha 7540: if (*ptr != (pcre_uchar)terminator)
1.1 misha 7541: {
7542: *errorcodeptr = ERR29;
7543: goto FAILED;
7544: }
7545:
1.3 misha 7546: if (refsign == CHAR_MINUS)
1.1 misha 7547: {
7548: if (recno == 0)
7549: {
7550: *errorcodeptr = ERR58;
7551: goto FAILED;
7552: }
7553: recno = cd->bracount - recno + 1;
7554: if (recno <= 0)
7555: {
7556: *errorcodeptr = ERR15;
7557: goto FAILED;
7558: }
7559: }
1.3 misha 7560: else if (refsign == CHAR_PLUS)
1.1 misha 7561: {
7562: if (recno == 0)
7563: {
7564: *errorcodeptr = ERR58;
7565: goto FAILED;
7566: }
7567: recno += cd->bracount;
7568: }
7569:
7570: /* Come here from code above that handles a named recursion */
7571:
7572: HANDLE_RECURSION:
7573:
7574: previous = code;
1.9 ! moko 7575: item_hwm_offset = cd->hwm - cd->start_workspace;
1.1 misha 7576: called = cd->start_code;
7577:
7578: /* When we are actually compiling, find the bracket that is being
7579: referenced. Temporarily end the regex in case it doesn't exist before
7580: this point. If we end up with a forward reference, first check that
7581: the bracket does occur later so we can give the error (and position)
7582: now. Then remember this forward reference in the workspace so it can
7583: be filled in at the end. */
7584:
7585: if (lengthptr == NULL)
7586: {
7587: *code = OP_END;
1.4 misha 7588: if (recno != 0)
1.6 misha 7589: called = PRIV(find_bracket)(cd->start_code, utf, recno);
1.1 misha 7590:
7591: /* Forward reference */
7592:
7593: if (called == NULL)
7594: {
1.8 moko 7595: if (recno > cd->final_bracount)
1.1 misha 7596: {
7597: *errorcodeptr = ERR15;
7598: goto FAILED;
7599: }
1.4 misha 7600:
7601: /* Fudge the value of "called" so that when it is inserted as an
7602: offset below, what it actually inserted is the reference number
1.6 misha 7603: of the group. Then remember the forward reference. */
1.4 misha 7604:
1.1 misha 7605: called = cd->start_code + recno;
1.6 misha 7606: if (cd->hwm >= cd->start_workspace + cd->workspace_size -
7607: WORK_SIZE_SAFETY_MARGIN)
7608: {
7609: *errorcodeptr = expand_workspace(cd);
7610: if (*errorcodeptr != 0) goto FAILED;
7611: }
7612: PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));
1.1 misha 7613: }
7614:
7615: /* If not a forward reference, and the subpattern is still open,
7616: this is a recursive call. We check to see if this is a left
1.6 misha 7617: recursion that could loop for ever, and diagnose that case. We
7618: must not, however, do this check if we are in a conditional
7619: subpattern because the condition might be testing for recursion in
7620: a pattern such as /(?(R)a+|(?R)b)/, which is perfectly valid.
7621: Forever loops are also detected at runtime, so those that occur in
7622: conditional subpatterns will be picked up then. */
1.1 misha 7623:
1.6 misha 7624: else if (GET(called, 1) == 0 && cond_depth <= 0 &&
7625: could_be_empty(called, code, bcptr, utf, cd))
1.1 misha 7626: {
7627: *errorcodeptr = ERR40;
7628: goto FAILED;
7629: }
7630: }
7631:
1.6 misha 7632: /* Insert the recursion/subroutine item. It does not have a set first
7633: character (relevant if it is repeated, because it will then be
7634: wrapped with ONCE brackets). */
1.1 misha 7635:
7636: *code = OP_RECURSE;
1.4 misha 7637: PUT(code, 1, (int)(called - cd->start_code));
1.1 misha 7638: code += 1 + LINK_SIZE;
1.6 misha 7639: groupsetfirstchar = FALSE;
1.1 misha 7640: }
7641:
7642: /* Can't determine a first byte now */
7643:
1.7 misha 7644: if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
1.9 ! moko 7645: zerofirstchar = firstchar;
! 7646: zerofirstcharflags = firstcharflags;
1.1 misha 7647: continue;
7648:
7649:
7650: /* ------------------------------------------------------------ */
7651: default: /* Other characters: check option setting */
7652: OTHER_CHAR_AFTER_QUERY:
7653: set = unset = 0;
7654: optset = &set;
7655:
1.3 misha 7656: while (*ptr != CHAR_RIGHT_PARENTHESIS && *ptr != CHAR_COLON)
1.1 misha 7657: {
7658: switch (*ptr++)
7659: {
1.3 misha 7660: case CHAR_MINUS: optset = &unset; break;
1.1 misha 7661:
1.3 misha 7662: case CHAR_J: /* Record that it changed in the external options */
1.1 misha 7663: *optset |= PCRE_DUPNAMES;
7664: cd->external_flags |= PCRE_JCHANGED;
7665: break;
7666:
1.3 misha 7667: case CHAR_i: *optset |= PCRE_CASELESS; break;
7668: case CHAR_m: *optset |= PCRE_MULTILINE; break;
7669: case CHAR_s: *optset |= PCRE_DOTALL; break;
7670: case CHAR_x: *optset |= PCRE_EXTENDED; break;
7671: case CHAR_U: *optset |= PCRE_UNGREEDY; break;
7672: case CHAR_X: *optset |= PCRE_EXTRA; break;
1.1 misha 7673:
7674: default: *errorcodeptr = ERR12;
7675: ptr--; /* Correct the offset */
7676: goto FAILED;
7677: }
7678: }
7679:
7680: /* Set up the changed option bits, but don't change anything yet. */
7681:
7682: newoptions = (options | set) & (~unset);
7683:
7684: /* If the options ended with ')' this is not the start of a nested
1.9 ! moko 7685: group with option changes, so the options change at this level.
1.6 misha 7686: If we are not at the pattern start, reset the greedy defaults and the
7687: case value for firstchar and reqchar. */
1.1 misha 7688:
1.3 misha 7689: if (*ptr == CHAR_RIGHT_PARENTHESIS)
1.1 misha 7690: {
1.9 ! moko 7691: greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
! 7692: greedy_non_default = greedy_default ^ 1;
! 7693: req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS:0;
1.1 misha 7694:
1.2 misha 7695: /* Change options at this level, and pass them back for use
1.6 misha 7696: in subsequent branches. */
1.2 misha 7697:
7698: *optionsptr = options = newoptions;
1.1 misha 7699: previous = NULL; /* This item can't be repeated */
7700: continue; /* It is complete */
7701: }
7702:
7703: /* If the options ended with ':' we are heading into a nested group
7704: with possible change of options. Such groups are non-capturing and are
7705: not assertions of any kind. All we need to do is skip over the ':';
7706: the newoptions value is handled below. */
7707:
7708: bravalue = OP_BRA;
7709: ptr++;
7710: } /* End of switch for character following (? */
7711: } /* End of (? handling */
7712:
1.4 misha 7713: /* Opening parenthesis not followed by '*' or '?'. If PCRE_NO_AUTO_CAPTURE
7714: is set, all unadorned brackets become non-capturing and behave like (?:...)
1.1 misha 7715: brackets. */
7716:
7717: else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)
7718: {
7719: bravalue = OP_BRA;
7720: }
7721:
7722: /* Else we have a capturing group. */
7723:
7724: else
7725: {
7726: NUMBERED_GROUP:
7727: cd->bracount += 1;
7728: PUT2(code, 1+LINK_SIZE, cd->bracount);
1.6 misha 7729: skipbytes = IMM2_SIZE;
1.1 misha 7730: }
7731:
1.8 moko 7732: /* Process nested bracketed regex. First check for parentheses nested too
7733: deeply. */
7734:
7735: if ((cd->parens_depth += 1) > PARENS_NEST_LIMIT)
7736: {
7737: *errorcodeptr = ERR82;
7738: goto FAILED;
7739: }
7740:
7741: /* All assertions used not to be repeatable, but this was changed for Perl
7742: compatibility. All kinds can now be repeated except for assertions that are
7743: conditions (Perl also forbids these to be repeated). We copy code into a
7744: non-register variable (tempcode) in order to be able to pass its address
7745: because some compilers complain otherwise. At the start of a conditional
7746: group whose condition is an assertion, cd->iscondassert is set. We unset it
7747: here so as to allow assertions later in the group to be quantified. */
7748:
7749: if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT &&
7750: cd->iscondassert)
7751: {
7752: previous = NULL;
7753: cd->iscondassert = FALSE;
7754: }
1.9 ! moko 7755: else
! 7756: {
! 7757: previous = code;
! 7758: item_hwm_offset = cd->hwm - cd->start_workspace;
! 7759: }
1.1 misha 7760:
7761: *code = bravalue;
7762: tempcode = code;
1.6 misha 7763: tempreqvary = cd->req_varyopt; /* Save value before bracket */
7764: tempbracount = cd->bracount; /* Save value before bracket */
7765: length_prevgroup = 0; /* Initialize for pre-compile phase */
1.1 misha 7766:
7767: if (!compile_regex(
1.6 misha 7768: newoptions, /* The complete new option state */
7769: &tempcode, /* Where to put code (updated) */
7770: &ptr, /* Input pointer (updated) */
7771: errorcodeptr, /* Where to put an error message */
1.1 misha 7772: (bravalue == OP_ASSERTBACK ||
7773: bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
1.6 misha 7774: reset_bracount, /* True if (?| group */
7775: skipbytes, /* Skip over bracket number */
7776: cond_depth +
7777: ((bravalue == OP_COND)?1:0), /* Depth of condition subpatterns */
7778: &subfirstchar, /* For possible first char */
1.7 misha 7779: &subfirstcharflags,
1.6 misha 7780: &subreqchar, /* For possible last char */
1.7 misha 7781: &subreqcharflags,
1.6 misha 7782: bcptr, /* Current branch chain */
7783: cd, /* Tables block */
7784: (lengthptr == NULL)? NULL : /* Actual compile phase */
7785: &length_prevgroup /* Pre-compile phase */
1.1 misha 7786: ))
7787: goto FAILED;
7788:
1.8 moko 7789: cd->parens_depth -= 1;
7790:
1.6 misha 7791: /* If this was an atomic group and there are no capturing groups within it,
7792: generate OP_ONCE_NC instead of OP_ONCE. */
7793:
7794: if (bravalue == OP_ONCE && cd->bracount <= tempbracount)
7795: *code = OP_ONCE_NC;
7796:
7797: if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)
7798: cd->assert_depth -= 1;
7799:
1.1 misha 7800: /* At the end of compiling, code is still pointing to the start of the
1.6 misha 7801: group, while tempcode has been updated to point past the end of the group.
7802: The pattern pointer (ptr) is on the bracket.
1.1 misha 7803:
1.6 misha 7804: If this is a conditional bracket, check that there are no more than
1.1 misha 7805: two branches in the group, or just one if it's a DEFINE group. We do this
7806: in the real compile phase, not in the pre-pass, where the whole group may
7807: not be available. */
7808:
7809: if (bravalue == OP_COND && lengthptr == NULL)
7810: {
1.6 misha 7811: pcre_uchar *tc = code;
1.1 misha 7812: int condcount = 0;
7813:
7814: do {
7815: condcount++;
7816: tc += GET(tc,1);
7817: }
7818: while (*tc != OP_KET);
7819:
7820: /* A DEFINE group is never obeyed inline (the "condition" is always
7821: false). It must have only one branch. */
7822:
7823: if (code[LINK_SIZE+1] == OP_DEF)
7824: {
7825: if (condcount > 1)
7826: {
7827: *errorcodeptr = ERR54;
7828: goto FAILED;
7829: }
7830: bravalue = OP_DEF; /* Just a flag to suppress char handling below */
7831: }
7832:
7833: /* A "normal" conditional group. If there is just one branch, we must not
1.6 misha 7834: make use of its firstchar or reqchar, because this is equivalent to an
1.1 misha 7835: empty second branch. */
7836:
7837: else
7838: {
7839: if (condcount > 2)
7840: {
7841: *errorcodeptr = ERR27;
7842: goto FAILED;
7843: }
1.7 misha 7844: if (condcount == 1) subfirstcharflags = subreqcharflags = REQ_NONE;
1.1 misha 7845: }
7846: }
7847:
7848: /* Error if hit end of pattern */
7849:
1.3 misha 7850: if (*ptr != CHAR_RIGHT_PARENTHESIS)
1.1 misha 7851: {
7852: *errorcodeptr = ERR14;
7853: goto FAILED;
7854: }
7855:
7856: /* In the pre-compile phase, update the length by the length of the group,
7857: less the brackets at either end. Then reduce the compiled code to just a
7858: set of non-capturing brackets so that it doesn't use much memory if it is
7859: duplicated by a quantifier.*/
7860:
7861: if (lengthptr != NULL)
7862: {
7863: if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)
7864: {
7865: *errorcodeptr = ERR20;
7866: goto FAILED;
7867: }
7868: *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;
1.6 misha 7869: code++; /* This already contains bravalue */
1.1 misha 7870: PUTINC(code, 0, 1 + LINK_SIZE);
7871: *code++ = OP_KET;
7872: PUTINC(code, 0, 1 + LINK_SIZE);
7873: break; /* No need to waste time with special character handling */
7874: }
7875:
7876: /* Otherwise update the main code pointer to the end of the group. */
7877:
7878: code = tempcode;
7879:
7880: /* For a DEFINE group, required and first character settings are not
7881: relevant. */
7882:
7883: if (bravalue == OP_DEF) break;
7884:
7885: /* Handle updating of the required and first characters for other types of
7886: group. Update for normal brackets of all kinds, and conditions with two
7887: branches (see code above). If the bracket is followed by a quantifier with
1.6 misha 7888: zero repeat, we have to back off. Hence the definition of zeroreqchar and
7889: zerofirstchar outside the main loop so that they can be accessed for the
1.1 misha 7890: back off. */
7891:
1.6 misha 7892: zeroreqchar = reqchar;
1.7 misha 7893: zeroreqcharflags = reqcharflags;
1.6 misha 7894: zerofirstchar = firstchar;
1.7 misha 7895: zerofirstcharflags = firstcharflags;
1.6 misha 7896: groupsetfirstchar = FALSE;
1.1 misha 7897:
7898: if (bravalue >= OP_ONCE)
7899: {
1.6 misha 7900: /* If we have not yet set a firstchar in this branch, take it from the
1.1 misha 7901: subpattern, remembering that it was set here so that a repeat of more
1.6 misha 7902: than one can replicate it as reqchar if necessary. If the subpattern has
7903: no firstchar, set "none" for the whole branch. In both cases, a zero
7904: repeat forces firstchar to "none". */
1.1 misha 7905:
1.7 misha 7906: if (firstcharflags == REQ_UNSET)
1.1 misha 7907: {
1.7 misha 7908: if (subfirstcharflags >= 0)
1.1 misha 7909: {
1.6 misha 7910: firstchar = subfirstchar;
1.7 misha 7911: firstcharflags = subfirstcharflags;
1.6 misha 7912: groupsetfirstchar = TRUE;
1.1 misha 7913: }
1.7 misha 7914: else firstcharflags = REQ_NONE;
7915: zerofirstcharflags = REQ_NONE;
1.1 misha 7916: }
7917:
1.6 misha 7918: /* If firstchar was previously set, convert the subpattern's firstchar
7919: into reqchar if there wasn't one, using the vary flag that was in
1.1 misha 7920: existence beforehand. */
7921:
1.7 misha 7922: else if (subfirstcharflags >= 0 && subreqcharflags < 0)
7923: {
7924: subreqchar = subfirstchar;
7925: subreqcharflags = subfirstcharflags | tempreqvary;
7926: }
1.1 misha 7927:
7928: /* If the subpattern set a required byte (or set a first byte that isn't
7929: really the first byte - see above), set it. */
7930:
1.7 misha 7931: if (subreqcharflags >= 0)
7932: {
7933: reqchar = subreqchar;
7934: reqcharflags = subreqcharflags;
7935: }
1.1 misha 7936: }
7937:
1.9 ! moko 7938: /* For a forward assertion, we take the reqchar, if set, provided that the
! 7939: group has also set a first char. This can be helpful if the pattern that
! 7940: follows the assertion doesn't set a different char. For example, it's
! 7941: useful for /(?=abcde).+/. We can't set firstchar for an assertion, however
! 7942: because it leads to incorrect effect for patterns such as /(?=a)a.+/ when
! 7943: the "real" "a" would then become a reqchar instead of a firstchar. This is
! 7944: overcome by a scan at the end if there's no firstchar, looking for an
! 7945: asserted first char. */
1.1 misha 7946:
1.9 ! moko 7947: else if (bravalue == OP_ASSERT && subreqcharflags >= 0 &&
! 7948: subfirstcharflags >= 0)
1.7 misha 7949: {
7950: reqchar = subreqchar;
7951: reqcharflags = subreqcharflags;
7952: }
1.1 misha 7953: break; /* End of processing '(' */
7954:
7955:
7956: /* ===================================================================*/
7957: /* Handle metasequences introduced by \. For ones like \d, the ESC_ values
1.4 misha 7958: are arranged to be the negation of the corresponding OP_values in the
7959: default case when PCRE_UCP is not set. For the back references, the values
1.7 misha 7960: are negative the reference number. Only back references and those types
1.4 misha 7961: that consume a character may be repeated. We can test for values between
7962: ESC_b and ESC_Z for the latter; this may have to change if any new ones are
7963: ever created. */
1.1 misha 7964:
1.3 misha 7965: case CHAR_BACKSLASH:
1.1 misha 7966: tempptr = ptr;
1.7 misha 7967: escape = check_escape(&ptr, &ec, errorcodeptr, cd->bracount, options, FALSE);
1.1 misha 7968: if (*errorcodeptr != 0) goto FAILED;
7969:
1.7 misha 7970: if (escape == 0) /* The escape coded a single character */
7971: c = ec;
7972: else
1.1 misha 7973: {
7974: /* For metasequences that actually match a character, we disable the
7975: setting of a first character if it hasn't already been set. */
7976:
1.7 misha 7977: if (firstcharflags == REQ_UNSET && escape > ESC_b && escape < ESC_Z)
7978: firstcharflags = REQ_NONE;
1.1 misha 7979:
7980: /* Set values to reset to if this is followed by a zero repeat. */
7981:
1.6 misha 7982: zerofirstchar = firstchar;
1.7 misha 7983: zerofirstcharflags = firstcharflags;
1.6 misha 7984: zeroreqchar = reqchar;
1.7 misha 7985: zeroreqcharflags = reqcharflags;
1.1 misha 7986:
7987: /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'
7988: is a subroutine call by number (Oniguruma syntax). In fact, the value
1.7 misha 7989: ESC_g is returned only for these cases. So we don't need to check for <
7990: or ' if the value is ESC_g. For the Perl syntax \g{n} the value is
7991: -n, and for the Perl syntax \g{name} the result is ESC_k (as
1.1 misha 7992: that is a synonym for a named back reference). */
7993:
1.7 misha 7994: if (escape == ESC_g)
1.1 misha 7995: {
1.6 misha 7996: const pcre_uchar *p;
1.8 moko 7997: pcre_uint32 cf;
7998:
1.9 ! moko 7999: item_hwm_offset = cd->hwm - cd->start_workspace; /* Normally this is set when '(' is read */
1.3 misha 8000: terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
8001: CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
1.1 misha 8002:
8003: /* These two statements stop the compiler for warning about possibly
8004: unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In
1.8 moko 8005: fact, because we do the check for a number below, the paths that
1.1 misha 8006: would actually be in error are never taken. */
8007:
8008: skipbytes = 0;
8009: reset_bracount = FALSE;
8010:
1.8 moko 8011: /* If it's not a signed or unsigned number, treat it as a name. */
1.1 misha 8012:
1.8 moko 8013: cf = ptr[1];
8014: if (cf != CHAR_PLUS && cf != CHAR_MINUS && !IS_DIGIT(cf))
1.1 misha 8015: {
8016: is_recurse = TRUE;
8017: goto NAMED_REF_OR_RECURSE;
8018: }
8019:
1.8 moko 8020: /* Signed or unsigned number (cf = ptr[1]) is known to be plus or minus
8021: or a digit. */
1.1 misha 8022:
8023: p = ptr + 2;
1.6 misha 8024: while (IS_DIGIT(*p)) p++;
1.7 misha 8025: if (*p != (pcre_uchar)terminator)
1.1 misha 8026: {
8027: *errorcodeptr = ERR57;
1.9 ! moko 8028: goto FAILED;
1.1 misha 8029: }
8030: ptr++;
8031: goto HANDLE_NUMERICAL_RECURSION;
8032: }
8033:
8034: /* \k<name> or \k'name' is a back reference by name (Perl syntax).
1.6 misha 8035: We also support \k{name} (.NET syntax). */
1.1 misha 8036:
1.7 misha 8037: if (escape == ESC_k)
1.1 misha 8038: {
1.6 misha 8039: if ((ptr[1] != CHAR_LESS_THAN_SIGN &&
8040: ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))
8041: {
8042: *errorcodeptr = ERR69;
1.9 ! moko 8043: goto FAILED;
1.6 misha 8044: }
1.1 misha 8045: is_recurse = FALSE;
1.3 misha 8046: terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
8047: CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
8048: CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;
1.1 misha 8049: goto NAMED_REF_OR_RECURSE;
8050: }
8051:
1.6 misha 8052: /* Back references are handled specially; must disable firstchar if
1.1 misha 8053: not set to cope with cases like (?=(\w+))\1: which would otherwise set
8054: ':' later. */
8055:
1.7 misha 8056: if (escape < 0)
1.1 misha 8057: {
1.4 misha 8058: open_capitem *oc;
1.7 misha 8059: recno = -escape;
1.1 misha 8060:
1.8 moko 8061: /* Come here from named backref handling when the reference is to a
8062: single group (i.e. not to a duplicated name. */
8063:
8064: HANDLE_REFERENCE:
1.9 ! moko 8065: if (firstcharflags == REQ_UNSET) zerofirstcharflags = firstcharflags = REQ_NONE;
1.1 misha 8066: previous = code;
1.9 ! moko 8067: item_hwm_offset = cd->hwm - cd->start_workspace;
1.6 misha 8068: *code++ = ((options & PCRE_CASELESS) != 0)? OP_REFI : OP_REF;
1.1 misha 8069: PUT2INC(code, 0, recno);
8070: cd->backref_map |= (recno < 32)? (1 << recno) : 1;
8071: if (recno > cd->top_backref) cd->top_backref = recno;
1.4 misha 8072:
8073: /* Check to see if this back reference is recursive, that it, it
8074: is inside the group that it references. A flag is set so that the
8075: group can be made atomic. */
8076:
8077: for (oc = cd->open_caps; oc != NULL; oc = oc->next)
8078: {
8079: if (oc->number == recno)
8080: {
8081: oc->flag = TRUE;
8082: break;
8083: }
8084: }
1.1 misha 8085: }
8086:
8087: /* So are Unicode property matches, if supported. */
8088:
8089: #ifdef SUPPORT_UCP
1.7 misha 8090: else if (escape == ESC_P || escape == ESC_p)
1.1 misha 8091: {
8092: BOOL negated;
1.7 misha 8093: unsigned int ptype = 0, pdata = 0;
8094: if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))
8095: goto FAILED;
1.1 misha 8096: previous = code;
1.9 ! moko 8097: item_hwm_offset = cd->hwm - cd->start_workspace;
1.7 misha 8098: *code++ = ((escape == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
1.1 misha 8099: *code++ = ptype;
8100: *code++ = pdata;
8101: }
8102: #else
8103:
8104: /* If Unicode properties are not supported, \X, \P, and \p are not
8105: allowed. */
8106:
1.7 misha 8107: else if (escape == ESC_X || escape == ESC_P || escape == ESC_p)
1.1 misha 8108: {
8109: *errorcodeptr = ERR45;
8110: goto FAILED;
8111: }
8112: #endif
8113:
8114: /* For the rest (including \X when Unicode properties are supported), we
1.4 misha 8115: can obtain the OP value by negating the escape value in the default
8116: situation when PCRE_UCP is not set. When it *is* set, we substitute
1.7 misha 8117: Unicode property tests. Note that \b and \B do a one-character
8118: lookbehind, and \A also behaves as if it does. */
1.1 misha 8119:
8120: else
8121: {
1.7 misha 8122: if ((escape == ESC_b || escape == ESC_B || escape == ESC_A) &&
8123: cd->max_lookbehind == 0)
8124: cd->max_lookbehind = 1;
1.4 misha 8125: #ifdef SUPPORT_UCP
1.7 misha 8126: if (escape >= ESC_DU && escape <= ESC_wu)
1.4 misha 8127: {
8128: nestptr = ptr + 1; /* Where to resume */
1.7 misha 8129: ptr = substitutes[escape - ESC_DU] - 1; /* Just before substitute */
1.4 misha 8130: }
8131: else
8132: #endif
1.6 misha 8133: /* In non-UTF-8 mode, we turn \C into OP_ALLANY instead of OP_ANYBYTE
8134: so that it works in DFA mode and in lookbehinds. */
8135:
1.4 misha 8136: {
1.7 misha 8137: previous = (escape > ESC_b && escape < ESC_Z)? code : NULL;
1.9 ! moko 8138: item_hwm_offset = cd->hwm - cd->start_workspace;
1.7 misha 8139: *code++ = (!utf && escape == ESC_C)? OP_ALLANY : escape;
1.4 misha 8140: }
1.1 misha 8141: }
8142: continue;
8143: }
8144:
8145: /* We have a data character whose value is in c. In UTF-8 mode it may have
8146: a value > 127. We set its representation in the length/buffer, and then
8147: handle it as a data character. */
8148:
1.7 misha 8149: #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1.6 misha 8150: if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
8151: mclength = PRIV(ord2utf)(c, mcbuffer);
1.1 misha 8152: else
8153: #endif
8154:
8155: {
8156: mcbuffer[0] = c;
8157: mclength = 1;
8158: }
8159: goto ONE_CHAR;
8160:
8161:
8162: /* ===================================================================*/
8163: /* Handle a literal character. It is guaranteed not to be whitespace or #
1.8 moko 8164: when the extended flag is set. If we are in a UTF mode, it may be a
8165: multi-unit literal character. */
1.1 misha 8166:
8167: default:
8168: NORMAL_CHAR:
8169: mclength = 1;
8170: mcbuffer[0] = c;
8171:
1.6 misha 8172: #ifdef SUPPORT_UTF
8173: if (utf && HAS_EXTRALEN(c))
8174: ACROSSCHAR(TRUE, ptr[1], mcbuffer[mclength++] = *(++ptr));
1.1 misha 8175: #endif
8176:
8177: /* At this point we have the character's bytes in mcbuffer, and the length
8178: in mclength. When not in UTF-8 mode, the length is always 1. */
8179:
8180: ONE_CHAR:
8181: previous = code;
1.9 ! moko 8182: item_hwm_offset = cd->hwm - cd->start_workspace;
1.7 misha 8183:
8184: /* For caseless UTF-8 mode when UCP support is available, check whether
8185: this character has more than one other case. If so, generate a special
8186: OP_PROP item instead of OP_CHARI. */
8187:
8188: #ifdef SUPPORT_UCP
8189: if (utf && (options & PCRE_CASELESS) != 0)
8190: {
8191: GETCHAR(c, mcbuffer);
8192: if ((c = UCD_CASESET(c)) != 0)
8193: {
8194: *code++ = OP_PROP;
8195: *code++ = PT_CLIST;
8196: *code++ = c;
1.8 moko 8197: if (firstcharflags == REQ_UNSET)
8198: firstcharflags = zerofirstcharflags = REQ_NONE;
1.7 misha 8199: break;
8200: }
8201: }
8202: #endif
8203:
8204: /* Caseful matches, or not one of the multicase characters. */
8205:
1.6 misha 8206: *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARI : OP_CHAR;
1.1 misha 8207: for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
8208:
8209: /* Remember if \r or \n were seen */
8210:
1.3 misha 8211: if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)
1.1 misha 8212: cd->external_flags |= PCRE_HASCRORLF;
8213:
8214: /* Set the first and required bytes appropriately. If no previous first
8215: byte, set it from this character, but revert to none on a zero repeat.
1.6 misha 8216: Otherwise, leave the firstchar value alone, and don't change it on a zero
1.1 misha 8217: repeat. */
8218:
1.7 misha 8219: if (firstcharflags == REQ_UNSET)
1.1 misha 8220: {
1.7 misha 8221: zerofirstcharflags = REQ_NONE;
1.6 misha 8222: zeroreqchar = reqchar;
1.7 misha 8223: zeroreqcharflags = reqcharflags;
1.1 misha 8224:
1.6 misha 8225: /* If the character is more than one byte long, we can set firstchar
1.1 misha 8226: only if it is not to be matched caselessly. */
8227:
8228: if (mclength == 1 || req_caseopt == 0)
8229: {
1.7 misha 8230: firstchar = mcbuffer[0];
8231: firstcharflags = req_caseopt;
8232:
8233: if (mclength != 1)
8234: {
8235: reqchar = code[-1];
8236: reqcharflags = cd->req_varyopt;
8237: }
1.1 misha 8238: }
1.7 misha 8239: else firstcharflags = reqcharflags = REQ_NONE;
1.1 misha 8240: }
8241:
1.6 misha 8242: /* firstchar was previously set; we can set reqchar only if the length is
1.1 misha 8243: 1 or the matching is caseful. */
8244:
8245: else
8246: {
1.6 misha 8247: zerofirstchar = firstchar;
1.7 misha 8248: zerofirstcharflags = firstcharflags;
1.6 misha 8249: zeroreqchar = reqchar;
1.7 misha 8250: zeroreqcharflags = reqcharflags;
1.1 misha 8251: if (mclength == 1 || req_caseopt == 0)
1.7 misha 8252: {
8253: reqchar = code[-1];
8254: reqcharflags = req_caseopt | cd->req_varyopt;
8255: }
1.1 misha 8256: }
8257:
8258: break; /* End of literal character handling */
8259: }
8260: } /* end of big loop */
8261:
8262:
8263: /* Control never reaches here by falling through, only by a goto for all the
8264: error states. Pass back the position in the pattern so that it can be displayed
8265: to the user for diagnosing the error. */
8266:
8267: FAILED:
8268: *ptrptr = ptr;
8269: return FALSE;
8270: }
8271:
8272:
8273:
8274: /*************************************************
8275: * Compile sequence of alternatives *
8276: *************************************************/
8277:
8278: /* On entry, ptr is pointing past the bracket character, but on return it
8279: points to the closing bracket, or vertical bar, or end of string. The code
8280: variable is pointing at the byte into which the BRA operator has been stored.
8281: This function is used during the pre-compile phase when we are trying to find
8282: out the amount of memory needed, as well as during the real compile phase. The
8283: value of lengthptr distinguishes the two phases.
8284:
8285: Arguments:
1.8 moko 8286: options option bits, including any changes for this subpattern
8287: codeptr -> the address of the current code pointer
8288: ptrptr -> the address of the current pattern pointer
8289: errorcodeptr -> pointer to error code variable
8290: lookbehind TRUE if this is a lookbehind assertion
8291: reset_bracount TRUE to reset the count for each branch
8292: skipbytes skip this many bytes at start (for brackets and OP_COND)
8293: cond_depth depth of nesting for conditional subpatterns
8294: firstcharptr place to put the first required character
1.7 misha 8295: firstcharflagsptr place to put the first character flags, or a negative number
1.8 moko 8296: reqcharptr place to put the last required character
8297: reqcharflagsptr place to put the last required character flags, or a negative number
8298: bcptr pointer to the chain of currently open branches
8299: cd points to the data block with tables pointers etc.
8300: lengthptr NULL during the real compile phase
8301: points to length accumulator during pre-compile phase
1.1 misha 8302:
1.8 moko 8303: Returns: TRUE on success
1.1 misha 8304: */
8305:
8306: static BOOL
1.6 misha 8307: compile_regex(int options, pcre_uchar **codeptr, const pcre_uchar **ptrptr,
1.1 misha 8308: int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
1.7 misha 8309: int cond_depth,
8310: pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,
8311: pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,
1.6 misha 8312: branch_chain *bcptr, compile_data *cd, int *lengthptr)
1.1 misha 8313: {
1.6 misha 8314: const pcre_uchar *ptr = *ptrptr;
8315: pcre_uchar *code = *codeptr;
8316: pcre_uchar *last_branch = code;
8317: pcre_uchar *start_bracket = code;
8318: pcre_uchar *reverse_count = NULL;
1.4 misha 8319: open_capitem capitem;
8320: int capnumber = 0;
1.7 misha 8321: pcre_uint32 firstchar, reqchar;
8322: pcre_int32 firstcharflags, reqcharflags;
8323: pcre_uint32 branchfirstchar, branchreqchar;
8324: pcre_int32 branchfirstcharflags, branchreqcharflags;
1.1 misha 8325: int length;
1.7 misha 8326: unsigned int orig_bracount;
8327: unsigned int max_bracount;
1.1 misha 8328: branch_chain bc;
1.8 moko 8329: size_t save_hwm_offset;
8330:
8331: /* If set, call the external function that checks for stack availability. */
8332:
8333: if (PUBL(stack_guard) != NULL && PUBL(stack_guard)())
8334: {
8335: *errorcodeptr= ERR85;
8336: return FALSE;
8337: }
8338:
8339: /* Miscellaneous initialization */
1.1 misha 8340:
8341: bc.outer = bcptr;
1.4 misha 8342: bc.current_branch = code;
1.1 misha 8343:
1.7 misha 8344: firstchar = reqchar = 0;
8345: firstcharflags = reqcharflags = REQ_UNSET;
1.1 misha 8346:
1.8 moko 8347: save_hwm_offset = cd->hwm - cd->start_workspace;
8348:
1.1 misha 8349: /* Accumulate the length for use in the pre-compile phase. Start with the
8350: length of the BRA and KET and any extra bytes that are required at the
8351: beginning. We accumulate in a local variable to save frequent testing of
8352: lenthptr for NULL. We cannot do this by looking at the value of code at the
8353: start and end of each alternative, because compiled items are discarded during
8354: the pre-compile phase so that the work space is not exceeded. */
8355:
8356: length = 2 + 2*LINK_SIZE + skipbytes;
8357:
8358: /* WARNING: If the above line is changed for any reason, you must also change
8359: the code that abstracts option settings at the start of the pattern and makes
8360: them global. It tests the value of length for (2 + 2*LINK_SIZE) in the
8361: pre-compile phase to find out whether anything has yet been compiled or not. */
8362:
1.4 misha 8363: /* If this is a capturing subpattern, add to the chain of open capturing items
8364: so that we can detect them if (*ACCEPT) is encountered. This is also used to
1.6 misha 8365: detect groups that contain recursive back references to themselves. Note that
8366: only OP_CBRA need be tested here; changing this opcode to one of its variants,
8367: e.g. OP_SCBRAPOS, happens later, after the group has been compiled. */
1.4 misha 8368:
8369: if (*code == OP_CBRA)
8370: {
8371: capnumber = GET2(code, 1 + LINK_SIZE);
8372: capitem.number = capnumber;
8373: capitem.next = cd->open_caps;
8374: capitem.flag = FALSE;
8375: cd->open_caps = &capitem;
8376: }
8377:
1.1 misha 8378: /* Offset is set zero to mark that this bracket is still open */
8379:
8380: PUT(code, 1, 0);
8381: code += 1 + LINK_SIZE + skipbytes;
8382:
8383: /* Loop for each alternative branch */
8384:
8385: orig_bracount = max_bracount = cd->bracount;
8386: for (;;)
8387: {
8388: /* For a (?| group, reset the capturing bracket count so that each branch
8389: uses the same numbers. */
8390:
8391: if (reset_bracount) cd->bracount = orig_bracount;
8392:
8393: /* Set up dummy OP_REVERSE if lookbehind assertion */
8394:
8395: if (lookbehind)
8396: {
8397: *code++ = OP_REVERSE;
8398: reverse_count = code;
8399: PUTINC(code, 0, 0);
8400: length += 1 + LINK_SIZE;
8401: }
8402:
8403: /* Now compile the branch; in the pre-compile phase its length gets added
8404: into the length. */
8405:
1.6 misha 8406: if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar,
1.7 misha 8407: &branchfirstcharflags, &branchreqchar, &branchreqcharflags, &bc,
8408: cond_depth, cd, (lengthptr == NULL)? NULL : &length))
1.1 misha 8409: {
8410: *ptrptr = ptr;
8411: return FALSE;
8412: }
8413:
8414: /* Keep the highest bracket count in case (?| was used and some branch
8415: has fewer than the rest. */
8416:
8417: if (cd->bracount > max_bracount) max_bracount = cd->bracount;
8418:
8419: /* In the real compile phase, there is some post-processing to be done. */
8420:
8421: if (lengthptr == NULL)
8422: {
1.6 misha 8423: /* If this is the first branch, the firstchar and reqchar values for the
1.1 misha 8424: branch become the values for the regex. */
8425:
8426: if (*last_branch != OP_ALT)
8427: {
1.6 misha 8428: firstchar = branchfirstchar;
1.7 misha 8429: firstcharflags = branchfirstcharflags;
1.6 misha 8430: reqchar = branchreqchar;
1.7 misha 8431: reqcharflags = branchreqcharflags;
1.1 misha 8432: }
8433:
1.6 misha 8434: /* If this is not the first branch, the first char and reqchar have to
1.1 misha 8435: match the values from all the previous branches, except that if the
1.6 misha 8436: previous value for reqchar didn't have REQ_VARY set, it can still match,
1.1 misha 8437: and we set REQ_VARY for the regex. */
8438:
8439: else
8440: {
1.6 misha 8441: /* If we previously had a firstchar, but it doesn't match the new branch,
8442: we have to abandon the firstchar for the regex, but if there was
8443: previously no reqchar, it takes on the value of the old firstchar. */
1.1 misha 8444:
1.7 misha 8445: if (firstcharflags >= 0 &&
8446: (firstcharflags != branchfirstcharflags || firstchar != branchfirstchar))
1.1 misha 8447: {
1.7 misha 8448: if (reqcharflags < 0)
8449: {
8450: reqchar = firstchar;
8451: reqcharflags = firstcharflags;
8452: }
8453: firstcharflags = REQ_NONE;
1.1 misha 8454: }
8455:
1.6 misha 8456: /* If we (now or from before) have no firstchar, a firstchar from the
8457: branch becomes a reqchar if there isn't a branch reqchar. */
1.1 misha 8458:
1.7 misha 8459: if (firstcharflags < 0 && branchfirstcharflags >= 0 && branchreqcharflags < 0)
8460: {
8461: branchreqchar = branchfirstchar;
8462: branchreqcharflags = branchfirstcharflags;
8463: }
1.1 misha 8464:
1.6 misha 8465: /* Now ensure that the reqchars match */
1.1 misha 8466:
1.7 misha 8467: if (((reqcharflags & ~REQ_VARY) != (branchreqcharflags & ~REQ_VARY)) ||
8468: reqchar != branchreqchar)
8469: reqcharflags = REQ_NONE;
8470: else
8471: {
8472: reqchar = branchreqchar;
8473: reqcharflags |= branchreqcharflags; /* To "or" REQ_VARY */
8474: }
1.1 misha 8475: }
8476:
8477: /* If lookbehind, check that this branch matches a fixed-length string, and
8478: put the length into the OP_REVERSE item. Temporarily mark the end of the
1.4 misha 8479: branch with OP_END. If the branch contains OP_RECURSE, the result is -3
8480: because there may be forward references that we can't check here. Set a
8481: flag to cause another lookbehind check at the end. Why not do it all at the
8482: end? Because common, erroneous checks are picked up here and the offset of
8483: the problem can be shown. */
1.1 misha 8484:
8485: if (lookbehind)
8486: {
8487: int fixed_length;
8488: *code = OP_END;
1.6 misha 8489: fixed_length = find_fixedlength(last_branch, (options & PCRE_UTF8) != 0,
1.8 moko 8490: FALSE, cd, NULL);
1.1 misha 8491: DPRINTF(("fixed length = %d\n", fixed_length));
1.4 misha 8492: if (fixed_length == -3)
8493: {
8494: cd->check_lookbehind = TRUE;
8495: }
8496: else if (fixed_length < 0)
1.1 misha 8497: {
1.6 misha 8498: *errorcodeptr = (fixed_length == -2)? ERR36 :
8499: (fixed_length == -4)? ERR70: ERR25;
1.1 misha 8500: *ptrptr = ptr;
8501: return FALSE;
8502: }
1.7 misha 8503: else
8504: {
8505: if (fixed_length > cd->max_lookbehind)
8506: cd->max_lookbehind = fixed_length;
8507: PUT(reverse_count, 0, fixed_length);
8508: }
1.1 misha 8509: }
8510: }
8511:
8512: /* Reached end of expression, either ')' or end of pattern. In the real
8513: compile phase, go back through the alternative branches and reverse the chain
8514: of offsets, with the field in the BRA item now becoming an offset to the
8515: first alternative. If there are no alternatives, it points to the end of the
8516: group. The length in the terminating ket is always the length of the whole
1.6 misha 8517: bracketed item. Return leaving the pointer at the terminating char. */
1.1 misha 8518:
1.3 misha 8519: if (*ptr != CHAR_VERTICAL_LINE)
1.1 misha 8520: {
8521: if (lengthptr == NULL)
8522: {
1.4 misha 8523: int branch_length = (int)(code - last_branch);
1.1 misha 8524: do
8525: {
8526: int prev_length = GET(last_branch, 1);
8527: PUT(last_branch, 1, branch_length);
8528: branch_length = prev_length;
8529: last_branch -= branch_length;
8530: }
8531: while (branch_length > 0);
8532: }
8533:
8534: /* Fill in the ket */
8535:
8536: *code = OP_KET;
1.4 misha 8537: PUT(code, 1, (int)(code - start_bracket));
1.1 misha 8538: code += 1 + LINK_SIZE;
8539:
1.4 misha 8540: /* If it was a capturing subpattern, check to see if it contained any
8541: recursive back references. If so, we must wrap it in atomic brackets.
1.8 moko 8542: Because we are moving code along, we must ensure that any pending recursive
8543: references are updated. In any event, remove the block from the chain. */
1.4 misha 8544:
8545: if (capnumber > 0)
8546: {
8547: if (cd->open_caps->flag)
8548: {
1.8 moko 8549: *code = OP_END;
8550: adjust_recurse(start_bracket, 1 + LINK_SIZE,
8551: (options & PCRE_UTF8) != 0, cd, save_hwm_offset);
1.4 misha 8552: memmove(start_bracket + 1 + LINK_SIZE, start_bracket,
1.6 misha 8553: IN_UCHARS(code - start_bracket));
1.4 misha 8554: *start_bracket = OP_ONCE;
8555: code += 1 + LINK_SIZE;
8556: PUT(start_bracket, 1, (int)(code - start_bracket));
8557: *code = OP_KET;
8558: PUT(code, 1, (int)(code - start_bracket));
8559: code += 1 + LINK_SIZE;
8560: length += 2 + 2*LINK_SIZE;
8561: }
8562: cd->open_caps = cd->open_caps->next;
8563: }
8564:
1.1 misha 8565: /* Retain the highest bracket number, in case resetting was used. */
8566:
8567: cd->bracount = max_bracount;
8568:
8569: /* Set values to pass back */
8570:
8571: *codeptr = code;
8572: *ptrptr = ptr;
1.6 misha 8573: *firstcharptr = firstchar;
1.7 misha 8574: *firstcharflagsptr = firstcharflags;
1.6 misha 8575: *reqcharptr = reqchar;
1.7 misha 8576: *reqcharflagsptr = reqcharflags;
1.1 misha 8577: if (lengthptr != NULL)
8578: {
8579: if (OFLOW_MAX - *lengthptr < length)
8580: {
8581: *errorcodeptr = ERR20;
8582: return FALSE;
8583: }
8584: *lengthptr += length;
8585: }
8586: return TRUE;
8587: }
8588:
8589: /* Another branch follows. In the pre-compile phase, we can move the code
8590: pointer back to where it was for the start of the first branch. (That is,
8591: pretend that each branch is the only one.)
8592:
8593: In the real compile phase, insert an ALT node. Its length field points back
8594: to the previous branch while the bracket remains open. At the end the chain
8595: is reversed. It's done like this so that the start of the bracket has a
8596: zero offset until it is closed, making it possible to detect recursion. */
8597:
8598: if (lengthptr != NULL)
8599: {
8600: code = *codeptr + 1 + LINK_SIZE + skipbytes;
8601: length += 1 + LINK_SIZE;
8602: }
8603: else
8604: {
8605: *code = OP_ALT;
1.4 misha 8606: PUT(code, 1, (int)(code - last_branch));
8607: bc.current_branch = last_branch = code;
1.1 misha 8608: code += 1 + LINK_SIZE;
8609: }
8610:
8611: ptr++;
8612: }
8613: /* Control never reaches here */
8614: }
8615:
8616:
8617:
8618:
8619: /*************************************************
8620: * Check for anchored expression *
8621: *************************************************/
8622:
8623: /* Try to find out if this is an anchored regular expression. Consider each
8624: alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
8625: all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
1.6 misha 8626: it's anchored. However, if this is a multiline pattern, then only OP_SOD will
8627: be found, because ^ generates OP_CIRCM in that mode.
1.1 misha 8628:
8629: We can also consider a regex to be anchored if OP_SOM starts all its branches.
8630: This is the code for \G, which means "match at start of match position, taking
8631: into account the match offset".
8632:
8633: A branch is also implicitly anchored if it starts with .* and DOTALL is set,
8634: because that will try the rest of the pattern at all possible matching points,
8635: so there is no point trying again.... er ....
8636:
8637: .... except when the .* appears inside capturing parentheses, and there is a
8638: subsequent back reference to those parentheses. We haven't enough information
8639: to catch that case precisely.
8640:
8641: At first, the best we could do was to detect when .* was in capturing brackets
8642: and the highest back reference was greater than or equal to that level.
8643: However, by keeping a bitmap of the first 31 back references, we can catch some
8644: of the more common cases more precisely.
8645:
1.7 misha 8646: ... A second exception is when the .* appears inside an atomic group, because
8647: this prevents the number of characters it matches from being adjusted.
8648:
1.1 misha 8649: Arguments:
8650: code points to start of expression (the bracket)
8651: bracket_map a bitmap of which brackets we are inside while testing; this
8652: handles up to substring 31; after that we just have to take
8653: the less precise approach
1.7 misha 8654: cd points to the compile data block
8655: atomcount atomic group level
1.1 misha 8656:
8657: Returns: TRUE or FALSE
8658: */
8659:
8660: static BOOL
1.6 misha 8661: is_anchored(register const pcre_uchar *code, unsigned int bracket_map,
1.7 misha 8662: compile_data *cd, int atomcount)
1.1 misha 8663: {
8664: do {
1.6 misha 8665: const pcre_uchar *scode = first_significant_code(
8666: code + PRIV(OP_lengths)[*code], FALSE);
1.1 misha 8667: register int op = *scode;
8668:
8669: /* Non-capturing brackets */
8670:
1.6 misha 8671: if (op == OP_BRA || op == OP_BRAPOS ||
8672: op == OP_SBRA || op == OP_SBRAPOS)
1.1 misha 8673: {
1.7 misha 8674: if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;
1.1 misha 8675: }
8676:
8677: /* Capturing brackets */
8678:
1.6 misha 8679: else if (op == OP_CBRA || op == OP_CBRAPOS ||
8680: op == OP_SCBRA || op == OP_SCBRAPOS)
1.1 misha 8681: {
8682: int n = GET2(scode, 1+LINK_SIZE);
8683: int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
1.7 misha 8684: if (!is_anchored(scode, new_map, cd, atomcount)) return FALSE;
8685: }
8686:
1.9 ! moko 8687: /* Positive forward assertion */
! 8688:
! 8689: else if (op == OP_ASSERT)
! 8690: {
! 8691: if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;
! 8692: }
! 8693:
! 8694: /* Condition; not anchored if no second branch */
1.7 misha 8695:
1.9 ! moko 8696: else if (op == OP_COND)
1.7 misha 8697: {
1.9 ! moko 8698: if (scode[GET(scode,1)] != OP_ALT) return FALSE;
1.7 misha 8699: if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;
1.1 misha 8700: }
8701:
1.7 misha 8702: /* Atomic groups */
1.1 misha 8703:
1.7 misha 8704: else if (op == OP_ONCE || op == OP_ONCE_NC)
1.1 misha 8705: {
1.7 misha 8706: if (!is_anchored(scode, bracket_map, cd, atomcount + 1))
8707: return FALSE;
1.1 misha 8708: }
8709:
8710: /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and
1.7 misha 8711: it isn't in brackets that are or may be referenced or inside an atomic
8712: group. */
1.1 misha 8713:
8714: else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
8715: op == OP_TYPEPOSSTAR))
8716: {
1.7 misha 8717: if (scode[1] != OP_ALLANY || (bracket_map & cd->backref_map) != 0 ||
8718: atomcount > 0 || cd->had_pruneorskip)
1.1 misha 8719: return FALSE;
8720: }
8721:
8722: /* Check for explicit anchoring */
8723:
1.6 misha 8724: else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;
1.7 misha 8725:
1.1 misha 8726: code += GET(code, 1);
8727: }
8728: while (*code == OP_ALT); /* Loop for each alternative */
8729: return TRUE;
8730: }
8731:
8732:
8733:
8734: /*************************************************
8735: * Check for starting with ^ or .* *
8736: *************************************************/
8737:
8738: /* This is called to find out if every branch starts with ^ or .* so that
8739: "first char" processing can be done to speed things up in multiline
8740: matching and for non-DOTALL patterns that start with .* (which must start at
8741: the beginning or after \n). As in the case of is_anchored() (see above), we
8742: have to take account of back references to capturing brackets that contain .*
1.7 misha 8743: because in that case we can't make the assumption. Also, the appearance of .*
1.9 ! moko 8744: inside atomic brackets or in an assertion, or in a pattern that contains *PRUNE
! 8745: or *SKIP does not count, because once again the assumption no longer holds.
1.1 misha 8746:
8747: Arguments:
8748: code points to start of expression (the bracket)
8749: bracket_map a bitmap of which brackets we are inside while testing; this
8750: handles up to substring 31; after that we just have to take
8751: the less precise approach
1.7 misha 8752: cd points to the compile data
8753: atomcount atomic group level
1.9 ! moko 8754: inassert TRUE if in an assertion
1.1 misha 8755:
8756: Returns: TRUE or FALSE
8757: */
8758:
8759: static BOOL
1.6 misha 8760: is_startline(const pcre_uchar *code, unsigned int bracket_map,
1.9 ! moko 8761: compile_data *cd, int atomcount, BOOL inassert)
1.1 misha 8762: {
8763: do {
1.6 misha 8764: const pcre_uchar *scode = first_significant_code(
8765: code + PRIV(OP_lengths)[*code], FALSE);
1.1 misha 8766: register int op = *scode;
8767:
1.3 misha 8768: /* If we are at the start of a conditional assertion group, *both* the
8769: conditional assertion *and* what follows the condition must satisfy the test
8770: for start of line. Other kinds of condition fail. Note that there may be an
8771: auto-callout at the start of a condition. */
8772:
8773: if (op == OP_COND)
8774: {
8775: scode += 1 + LINK_SIZE;
1.6 misha 8776: if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];
1.3 misha 8777: switch (*scode)
8778: {
8779: case OP_CREF:
1.8 moko 8780: case OP_DNCREF:
1.3 misha 8781: case OP_RREF:
1.8 moko 8782: case OP_DNRREF:
1.3 misha 8783: case OP_DEF:
1.8 moko 8784: case OP_FAIL:
1.3 misha 8785: return FALSE;
8786:
8787: default: /* Assertion */
1.9 ! moko 8788: if (!is_startline(scode, bracket_map, cd, atomcount, TRUE)) return FALSE;
1.3 misha 8789: do scode += GET(scode, 1); while (*scode == OP_ALT);
8790: scode += 1 + LINK_SIZE;
8791: break;
8792: }
1.6 misha 8793: scode = first_significant_code(scode, FALSE);
1.3 misha 8794: op = *scode;
8795: }
8796:
1.1 misha 8797: /* Non-capturing brackets */
8798:
1.6 misha 8799: if (op == OP_BRA || op == OP_BRAPOS ||
8800: op == OP_SBRA || op == OP_SBRAPOS)
1.1 misha 8801: {
1.9 ! moko 8802: if (!is_startline(scode, bracket_map, cd, atomcount, inassert)) return FALSE;
1.1 misha 8803: }
8804:
8805: /* Capturing brackets */
8806:
1.6 misha 8807: else if (op == OP_CBRA || op == OP_CBRAPOS ||
8808: op == OP_SCBRA || op == OP_SCBRAPOS)
1.1 misha 8809: {
8810: int n = GET2(scode, 1+LINK_SIZE);
8811: int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
1.9 ! moko 8812: if (!is_startline(scode, new_map, cd, atomcount, inassert)) return FALSE;
1.7 misha 8813: }
8814:
8815: /* Positive forward assertions */
8816:
8817: else if (op == OP_ASSERT)
8818: {
1.9 ! moko 8819: if (!is_startline(scode, bracket_map, cd, atomcount, TRUE)) return FALSE;
1.1 misha 8820: }
8821:
1.7 misha 8822: /* Atomic brackets */
1.1 misha 8823:
1.7 misha 8824: else if (op == OP_ONCE || op == OP_ONCE_NC)
1.3 misha 8825: {
1.9 ! moko 8826: if (!is_startline(scode, bracket_map, cd, atomcount + 1, inassert)) return FALSE;
1.3 misha 8827: }
1.1 misha 8828:
1.7 misha 8829: /* .* means "start at start or after \n" if it isn't in atomic brackets or
1.9 ! moko 8830: brackets that may be referenced or an assertion, as long as the pattern does
! 8831: not contain *PRUNE or *SKIP, because these break the feature. Consider, for
! 8832: example, /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab", i.e.
! 8833: not at the start of a line. */
1.1 misha 8834:
8835: else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)
8836: {
1.7 misha 8837: if (scode[1] != OP_ANY || (bracket_map & cd->backref_map) != 0 ||
1.9 ! moko 8838: atomcount > 0 || cd->had_pruneorskip || inassert)
1.7 misha 8839: return FALSE;
1.1 misha 8840: }
8841:
1.7 misha 8842: /* Check for explicit circumflex; anything else gives a FALSE result. Note
8843: in particular that this includes atomic brackets OP_ONCE and OP_ONCE_NC
8844: because the number of characters matched by .* cannot be adjusted inside
8845: them. */
1.1 misha 8846:
1.6 misha 8847: else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;
1.1 misha 8848:
8849: /* Move on to the next alternative */
8850:
8851: code += GET(code, 1);
8852: }
8853: while (*code == OP_ALT); /* Loop for each alternative */
8854: return TRUE;
8855: }
8856:
8857:
8858:
8859: /*************************************************
8860: * Check for asserted fixed first char *
8861: *************************************************/
8862:
8863: /* During compilation, the "first char" settings from forward assertions are
8864: discarded, because they can cause conflicts with actual literals that follow.
8865: However, if we end up without a first char setting for an unanchored pattern,
8866: it is worth scanning the regex to see if there is an initial asserted first
1.8 moko 8867: char. If all branches start with the same asserted char, or with a
8868: non-conditional bracket all of whose alternatives start with the same asserted
8869: char (recurse ad lib), then we return that char, with the flags set to zero or
8870: REQ_CASELESS; otherwise return zero with REQ_NONE in the flags.
1.1 misha 8871:
8872: Arguments:
8873: code points to start of expression (the bracket)
1.8 moko 8874: flags points to the first char flags, or to REQ_NONE
1.1 misha 8875: inassert TRUE if in an assertion
8876:
1.7 misha 8877: Returns: the fixed first char, or 0 with REQ_NONE in flags
1.1 misha 8878: */
8879:
1.7 misha 8880: static pcre_uint32
8881: find_firstassertedchar(const pcre_uchar *code, pcre_int32 *flags,
8882: BOOL inassert)
1.1 misha 8883: {
1.7 misha 8884: register pcre_uint32 c = 0;
8885: int cflags = REQ_NONE;
8886:
8887: *flags = REQ_NONE;
1.1 misha 8888: do {
1.7 misha 8889: pcre_uint32 d;
8890: int dflags;
1.6 misha 8891: int xl = (*code == OP_CBRA || *code == OP_SCBRA ||
8892: *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;
8893: const pcre_uchar *scode = first_significant_code(code + 1+LINK_SIZE + xl,
8894: TRUE);
1.7 misha 8895: register pcre_uchar op = *scode;
1.1 misha 8896:
8897: switch(op)
8898: {
8899: default:
1.7 misha 8900: return 0;
1.1 misha 8901:
8902: case OP_BRA:
1.6 misha 8903: case OP_BRAPOS:
1.1 misha 8904: case OP_CBRA:
1.6 misha 8905: case OP_SCBRA:
8906: case OP_CBRAPOS:
8907: case OP_SCBRAPOS:
1.1 misha 8908: case OP_ASSERT:
8909: case OP_ONCE:
1.6 misha 8910: case OP_ONCE_NC:
1.7 misha 8911: d = find_firstassertedchar(scode, &dflags, op == OP_ASSERT);
8912: if (dflags < 0)
8913: return 0;
8914: if (cflags < 0) { c = d; cflags = dflags; } else if (c != d || cflags != dflags) return 0;
1.1 misha 8915: break;
8916:
1.6 misha 8917: case OP_EXACT:
8918: scode += IMM2_SIZE;
8919: /* Fall through */
1.1 misha 8920:
8921: case OP_CHAR:
8922: case OP_PLUS:
8923: case OP_MINPLUS:
8924: case OP_POSPLUS:
1.7 misha 8925: if (!inassert) return 0;
8926: if (cflags < 0) { c = scode[1]; cflags = 0; }
8927: else if (c != scode[1]) return 0;
1.6 misha 8928: break;
8929:
8930: case OP_EXACTI:
8931: scode += IMM2_SIZE;
8932: /* Fall through */
8933:
8934: case OP_CHARI:
8935: case OP_PLUSI:
8936: case OP_MINPLUSI:
8937: case OP_POSPLUSI:
1.7 misha 8938: if (!inassert) return 0;
8939: if (cflags < 0) { c = scode[1]; cflags = REQ_CASELESS; }
8940: else if (c != scode[1]) return 0;
1.1 misha 8941: break;
8942: }
8943:
8944: code += GET(code, 1);
8945: }
8946: while (*code == OP_ALT);
1.7 misha 8947:
8948: *flags = cflags;
1.1 misha 8949: return c;
8950: }
8951:
8952:
8953:
8954: /*************************************************
1.8 moko 8955: * Add an entry to the name/number table *
8956: *************************************************/
8957:
8958: /* This function is called between compiling passes to add an entry to the
8959: name/number table, maintaining alphabetical order. Checking for permitted
8960: and forbidden duplicates has already been done.
8961:
8962: Arguments:
8963: cd the compile data block
8964: name the name to add
8965: length the length of the name
8966: groupno the group number
8967:
8968: Returns: nothing
8969: */
8970:
8971: static void
8972: add_name(compile_data *cd, const pcre_uchar *name, int length,
8973: unsigned int groupno)
8974: {
8975: int i;
8976: pcre_uchar *slot = cd->name_table;
8977:
8978: for (i = 0; i < cd->names_found; i++)
8979: {
8980: int crc = memcmp(name, slot+IMM2_SIZE, IN_UCHARS(length));
8981: if (crc == 0 && slot[IMM2_SIZE+length] != 0)
8982: crc = -1; /* Current name is a substring */
8983:
8984: /* Make space in the table and break the loop for an earlier name. For a
8985: duplicate or later name, carry on. We do this for duplicates so that in the
8986: simple case (when ?(| is not used) they are in order of their numbers. In all
8987: cases they are in the order in which they appear in the pattern. */
8988:
8989: if (crc < 0)
8990: {
8991: memmove(slot + cd->name_entry_size, slot,
8992: IN_UCHARS((cd->names_found - i) * cd->name_entry_size));
8993: break;
8994: }
8995:
8996: /* Continue the loop for a later or duplicate name */
8997:
8998: slot += cd->name_entry_size;
8999: }
9000:
9001: PUT2(slot, 0, groupno);
9002: memcpy(slot + IMM2_SIZE, name, IN_UCHARS(length));
9003: slot[IMM2_SIZE + length] = 0;
9004: cd->names_found++;
9005: }
9006:
9007:
9008:
9009: /*************************************************
1.1 misha 9010: * Compile a Regular Expression *
9011: *************************************************/
9012:
9013: /* This function takes a string and returns a pointer to a block of store
9014: holding a compiled version of the expression. The original API for this
9015: function had no error code return variable; it is retained for backwards
9016: compatibility. The new function is given a new name.
9017:
9018: Arguments:
9019: pattern the regular expression
9020: options various option bits
9021: errorcodeptr pointer to error code variable (pcre_compile2() only)
9022: can be NULL if you don't want a code value
9023: errorptr pointer to pointer to error text
9024: erroroffset ptr offset in pattern where error was detected
9025: tables pointer to character tables or NULL
9026:
9027: Returns: pointer to compiled data block, or NULL on error,
9028: with errorptr and erroroffset set
9029: */
9030:
1.7 misha 9031: #if defined COMPILE_PCRE8
1.2 misha 9032: PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
1.1 misha 9033: pcre_compile(const char *pattern, int options, const char **errorptr,
9034: int *erroroffset, const unsigned char *tables)
1.7 misha 9035: #elif defined COMPILE_PCRE16
1.6 misha 9036: PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION
9037: pcre16_compile(PCRE_SPTR16 pattern, int options, const char **errorptr,
9038: int *erroroffset, const unsigned char *tables)
1.7 misha 9039: #elif defined COMPILE_PCRE32
9040: PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION
9041: pcre32_compile(PCRE_SPTR32 pattern, int options, const char **errorptr,
9042: int *erroroffset, const unsigned char *tables)
1.6 misha 9043: #endif
1.1 misha 9044: {
1.7 misha 9045: #if defined COMPILE_PCRE8
1.1 misha 9046: return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
1.7 misha 9047: #elif defined COMPILE_PCRE16
1.6 misha 9048: return pcre16_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
1.7 misha 9049: #elif defined COMPILE_PCRE32
9050: return pcre32_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
1.6 misha 9051: #endif
1.1 misha 9052: }
9053:
9054:
1.7 misha 9055: #if defined COMPILE_PCRE8
1.2 misha 9056: PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
1.1 misha 9057: pcre_compile2(const char *pattern, int options, int *errorcodeptr,
9058: const char **errorptr, int *erroroffset, const unsigned char *tables)
1.7 misha 9059: #elif defined COMPILE_PCRE16
1.6 misha 9060: PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION
9061: pcre16_compile2(PCRE_SPTR16 pattern, int options, int *errorcodeptr,
9062: const char **errorptr, int *erroroffset, const unsigned char *tables)
1.7 misha 9063: #elif defined COMPILE_PCRE32
9064: PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION
9065: pcre32_compile2(PCRE_SPTR32 pattern, int options, int *errorcodeptr,
9066: const char **errorptr, int *erroroffset, const unsigned char *tables)
1.6 misha 9067: #endif
1.1 misha 9068: {
1.6 misha 9069: REAL_PCRE *re;
1.1 misha 9070: int length = 1; /* For final END opcode */
1.7 misha 9071: pcre_int32 firstcharflags, reqcharflags;
9072: pcre_uint32 firstchar, reqchar;
9073: pcre_uint32 limit_match = PCRE_UINT32_MAX;
9074: pcre_uint32 limit_recursion = PCRE_UINT32_MAX;
1.6 misha 9075: int newline;
1.1 misha 9076: int errorcode = 0;
9077: int skipatstart = 0;
1.6 misha 9078: BOOL utf;
1.7 misha 9079: BOOL never_utf = FALSE;
1.1 misha 9080: size_t size;
1.6 misha 9081: pcre_uchar *code;
9082: const pcre_uchar *codestart;
9083: const pcre_uchar *ptr;
1.1 misha 9084: compile_data compile_block;
9085: compile_data *cd = &compile_block;
9086:
9087: /* This space is used for "compiling" into during the first phase, when we are
9088: computing the amount of memory that is needed. Compiled items are thrown away
9089: as soon as possible, so that a fairly large buffer should be sufficient for
9090: this purpose. The same space is used in the second phase for remembering where
1.6 misha 9091: to fill in forward references to subpatterns. That may overflow, in which case
9092: new memory is obtained from malloc(). */
1.1 misha 9093:
1.6 misha 9094: pcre_uchar cworkspace[COMPILE_WORK_SIZE];
1.1 misha 9095:
1.8 moko 9096: /* This vector is used for remembering name groups during the pre-compile. In a
9097: similar way to cworkspace, it can be expanded using malloc() if necessary. */
9098:
9099: named_group named_groups[NAMED_GROUP_LIST_SIZE];
9100:
1.1 misha 9101: /* Set this early so that early errors get offset 0. */
9102:
1.6 misha 9103: ptr = (const pcre_uchar *)pattern;
1.1 misha 9104:
9105: /* We can't pass back an error message if errorptr is NULL; I guess the best we
9106: can do is just return NULL, but we can set a code value if there is a code
9107: pointer. */
9108:
9109: if (errorptr == NULL)
9110: {
9111: if (errorcodeptr != NULL) *errorcodeptr = 99;
9112: return NULL;
9113: }
9114:
9115: *errorptr = NULL;
9116: if (errorcodeptr != NULL) *errorcodeptr = ERR0;
9117:
9118: /* However, we can give a message for this error */
9119:
9120: if (erroroffset == NULL)
9121: {
9122: errorcode = ERR16;
9123: goto PCRE_EARLY_ERROR_RETURN2;
9124: }
9125:
9126: *erroroffset = 0;
9127:
9128: /* Set up pointers to the individual character tables */
9129:
1.6 misha 9130: if (tables == NULL) tables = PRIV(default_tables);
1.1 misha 9131: cd->lcc = tables + lcc_offset;
9132: cd->fcc = tables + fcc_offset;
9133: cd->cbits = tables + cbits_offset;
9134: cd->ctypes = tables + ctypes_offset;
9135:
1.3 misha 9136: /* Check that all undefined public option bits are zero */
9137:
9138: if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0)
9139: {
9140: errorcode = ERR17;
9141: goto PCRE_EARLY_ERROR_RETURN;
9142: }
9143:
1.7 misha 9144: /* If PCRE_NEVER_UTF is set, remember it. */
9145:
9146: if ((options & PCRE_NEVER_UTF) != 0) never_utf = TRUE;
9147:
1.1 misha 9148: /* Check for global one-time settings at the start of the pattern, and remember
9149: the offset for later. */
9150:
1.7 misha 9151: cd->external_flags = 0; /* Initialize here for LIMIT_MATCH/RECURSION */
9152:
1.3 misha 9153: while (ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&
9154: ptr[skipatstart+1] == CHAR_ASTERISK)
1.1 misha 9155: {
9156: int newnl = 0;
9157: int newbsr = 0;
9158:
1.7 misha 9159: /* For completeness and backward compatibility, (*UTFn) is supported in the
9160: relevant libraries, but (*UTF) is generic and always supported. Note that
9161: PCRE_UTF8 == PCRE_UTF16 == PCRE_UTF32. */
9162:
1.6 misha 9163: #ifdef COMPILE_PCRE8
1.7 misha 9164: if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF8_RIGHTPAR, 5) == 0)
1.3 misha 9165: { skipatstart += 7; options |= PCRE_UTF8; continue; }
1.6 misha 9166: #endif
9167: #ifdef COMPILE_PCRE16
1.7 misha 9168: if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF16_RIGHTPAR, 6) == 0)
1.6 misha 9169: { skipatstart += 8; options |= PCRE_UTF16; continue; }
9170: #endif
1.7 misha 9171: #ifdef COMPILE_PCRE32
9172: if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF32_RIGHTPAR, 6) == 0)
9173: { skipatstart += 8; options |= PCRE_UTF32; continue; }
9174: #endif
9175:
9176: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 4) == 0)
9177: { skipatstart += 6; options |= PCRE_UTF8; continue; }
1.6 misha 9178: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UCP_RIGHTPAR, 4) == 0)
1.4 misha 9179: { skipatstart += 6; options |= PCRE_UCP; continue; }
1.8 moko 9180: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_AUTO_POSSESS_RIGHTPAR, 16) == 0)
9181: { skipatstart += 18; options |= PCRE_NO_AUTO_POSSESS; continue; }
1.6 misha 9182: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_START_OPT_RIGHTPAR, 13) == 0)
1.5 misha 9183: { skipatstart += 15; options |= PCRE_NO_START_OPTIMIZE; continue; }
1.3 misha 9184:
1.7 misha 9185: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LIMIT_MATCH_EQ, 12) == 0)
9186: {
9187: pcre_uint32 c = 0;
9188: int p = skipatstart + 14;
9189: while (isdigit(ptr[p]))
9190: {
9191: if (c > PCRE_UINT32_MAX / 10 - 1) break; /* Integer overflow */
9192: c = c*10 + ptr[p++] - CHAR_0;
9193: }
9194: if (ptr[p++] != CHAR_RIGHT_PARENTHESIS) break;
9195: if (c < limit_match)
9196: {
9197: limit_match = c;
9198: cd->external_flags |= PCRE_MLSET;
9199: }
9200: skipatstart = p;
9201: continue;
9202: }
9203:
9204: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LIMIT_RECURSION_EQ, 16) == 0)
9205: {
9206: pcre_uint32 c = 0;
9207: int p = skipatstart + 18;
9208: while (isdigit(ptr[p]))
9209: {
9210: if (c > PCRE_UINT32_MAX / 10 - 1) break; /* Integer overflow check */
9211: c = c*10 + ptr[p++] - CHAR_0;
9212: }
9213: if (ptr[p++] != CHAR_RIGHT_PARENTHESIS) break;
9214: if (c < limit_recursion)
9215: {
9216: limit_recursion = c;
9217: cd->external_flags |= PCRE_RLSET;
9218: }
9219: skipatstart = p;
9220: continue;
9221: }
9222:
1.6 misha 9223: if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CR_RIGHTPAR, 3) == 0)
1.1 misha 9224: { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }
1.6 misha 9225: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LF_RIGHTPAR, 3) == 0)
1.1 misha 9226: { skipatstart += 5; newnl = PCRE_NEWLINE_LF; }
1.6 misha 9227: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CRLF_RIGHTPAR, 5) == 0)
1.1 misha 9228: { skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }
1.6 misha 9229: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANY_RIGHTPAR, 4) == 0)
1.1 misha 9230: { skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }
1.6 misha 9231: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANYCRLF_RIGHTPAR, 8) == 0)
1.1 misha 9232: { skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }
9233:
1.6 misha 9234: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)
1.1 misha 9235: { skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }
1.6 misha 9236: else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)
1.1 misha 9237: { skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }
9238:
9239: if (newnl != 0)
9240: options = (options & ~PCRE_NEWLINE_BITS) | newnl;
9241: else if (newbsr != 0)
9242: options = (options & ~(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) | newbsr;
9243: else break;
9244: }
9245:
1.7 misha 9246: /* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */
1.6 misha 9247: utf = (options & PCRE_UTF8) != 0;
1.7 misha 9248: if (utf && never_utf)
9249: {
9250: errorcode = ERR78;
9251: goto PCRE_EARLY_ERROR_RETURN2;
9252: }
1.3 misha 9253:
1.6 misha 9254: /* Can't support UTF unless PCRE has been compiled to include the code. The
9255: return of an error code from PRIV(valid_utf)() is a new feature, introduced in
9256: release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is
9257: not used here. */
9258:
9259: #ifdef SUPPORT_UTF
9260: if (utf && (options & PCRE_NO_UTF8_CHECK) == 0 &&
9261: (errorcode = PRIV(valid_utf)((PCRE_PUCHAR)pattern, -1, erroroffset)) != 0)
1.3 misha 9262: {
1.7 misha 9263: #if defined COMPILE_PCRE8
1.3 misha 9264: errorcode = ERR44;
1.7 misha 9265: #elif defined COMPILE_PCRE16
1.6 misha 9266: errorcode = ERR74;
1.7 misha 9267: #elif defined COMPILE_PCRE32
9268: errorcode = ERR77;
1.6 misha 9269: #endif
1.3 misha 9270: goto PCRE_EARLY_ERROR_RETURN2;
9271: }
9272: #else
1.6 misha 9273: if (utf)
1.3 misha 9274: {
9275: errorcode = ERR32;
9276: goto PCRE_EARLY_ERROR_RETURN;
9277: }
9278: #endif
9279:
1.4 misha 9280: /* Can't support UCP unless PCRE has been compiled to include the code. */
9281:
9282: #ifndef SUPPORT_UCP
9283: if ((options & PCRE_UCP) != 0)
9284: {
9285: errorcode = ERR67;
9286: goto PCRE_EARLY_ERROR_RETURN;
9287: }
9288: #endif
9289:
1.1 misha 9290: /* Check validity of \R options. */
9291:
1.6 misha 9292: if ((options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) ==
9293: (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
1.1 misha 9294: {
1.6 misha 9295: errorcode = ERR56;
9296: goto PCRE_EARLY_ERROR_RETURN;
1.1 misha 9297: }
9298:
9299: /* Handle different types of newline. The three bits give seven cases. The
9300: current code allows for fixed one- or two-byte sequences, plus "any" and
9301: "anycrlf". */
9302:
9303: switch (options & PCRE_NEWLINE_BITS)
9304: {
9305: case 0: newline = NEWLINE; break; /* Build-time default */
1.3 misha 9306: case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
9307: case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
1.1 misha 9308: case PCRE_NEWLINE_CR+
1.3 misha 9309: PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
1.1 misha 9310: case PCRE_NEWLINE_ANY: newline = -1; break;
9311: case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
9312: default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;
9313: }
9314:
9315: if (newline == -2)
9316: {
9317: cd->nltype = NLTYPE_ANYCRLF;
9318: }
9319: else if (newline < 0)
9320: {
9321: cd->nltype = NLTYPE_ANY;
9322: }
9323: else
9324: {
9325: cd->nltype = NLTYPE_FIXED;
9326: if (newline > 255)
9327: {
9328: cd->nllen = 2;
9329: cd->nl[0] = (newline >> 8) & 255;
9330: cd->nl[1] = newline & 255;
9331: }
9332: else
9333: {
9334: cd->nllen = 1;
9335: cd->nl[0] = newline;
9336: }
9337: }
9338:
9339: /* Maximum back reference and backref bitmap. The bitmap records up to 31 back
9340: references to help in deciding whether (.*) can be treated as anchored or not.
9341: */
9342:
9343: cd->top_backref = 0;
9344: cd->backref_map = 0;
9345:
9346: /* Reflect pattern for debugging output */
9347:
9348: DPRINTF(("------------------------------------------------------------------\n"));
1.6 misha 9349: #ifdef PCRE_DEBUG
9350: print_puchar(stdout, (PCRE_PUCHAR)pattern);
9351: #endif
9352: DPRINTF(("\n"));
1.1 misha 9353:
9354: /* Pretend to compile the pattern while actually just accumulating the length
9355: of memory required. This behaviour is triggered by passing a non-NULL final
9356: argument to compile_regex(). We pass a block of workspace (cworkspace) for it
9357: to compile parts of the pattern into; the compiled code is discarded when it is
9358: no longer needed, so hopefully this workspace will never overflow, though there
9359: is a test for its doing so. */
9360:
9361: cd->bracount = cd->final_bracount = 0;
9362: cd->names_found = 0;
9363: cd->name_entry_size = 0;
9364: cd->name_table = NULL;
1.8 moko 9365: cd->dupnames = FALSE;
1.9 ! moko 9366: cd->dupgroups = FALSE;
1.8 moko 9367: cd->namedrefcount = 0;
1.1 misha 9368: cd->start_code = cworkspace;
9369: cd->hwm = cworkspace;
1.8 moko 9370: cd->iscondassert = FALSE;
1.6 misha 9371: cd->start_workspace = cworkspace;
9372: cd->workspace_size = COMPILE_WORK_SIZE;
1.8 moko 9373: cd->named_groups = named_groups;
9374: cd->named_group_list_size = NAMED_GROUP_LIST_SIZE;
1.6 misha 9375: cd->start_pattern = (const pcre_uchar *)pattern;
9376: cd->end_pattern = (const pcre_uchar *)(pattern + STRLEN_UC((const pcre_uchar *)pattern));
1.1 misha 9377: cd->req_varyopt = 0;
1.8 moko 9378: cd->parens_depth = 0;
1.6 misha 9379: cd->assert_depth = 0;
1.7 misha 9380: cd->max_lookbehind = 0;
1.1 misha 9381: cd->external_options = options;
1.4 misha 9382: cd->open_caps = NULL;
1.1 misha 9383:
9384: /* Now do the pre-compile. On error, errorcode will be set non-zero, so we
9385: don't need to look at the result of the function here. The initial options have
9386: been put into the cd block so that they can be changed if an option setting is
9387: found within the regex right at the beginning. Bringing initial option settings
9388: outside can help speed up starting point checks. */
9389:
9390: ptr += skipatstart;
9391: code = cworkspace;
9392: *code = OP_BRA;
1.8 moko 9393:
1.6 misha 9394: (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,
1.7 misha 9395: FALSE, 0, 0, &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL,
9396: cd, &length);
1.1 misha 9397: if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;
9398:
9399: DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
1.6 misha 9400: (int)(cd->hwm - cworkspace)));
1.1 misha 9401:
9402: if (length > MAX_PATTERN_SIZE)
9403: {
9404: errorcode = ERR20;
9405: goto PCRE_EARLY_ERROR_RETURN;
9406: }
9407:
1.8 moko 9408: /* Compute the size of the data block for storing the compiled pattern. Integer
9409: overflow should no longer be possible because nowadays we limit the maximum
9410: value of cd->names_found and cd->name_entry_size. */
9411:
9412: size = sizeof(REAL_PCRE) +
9413: (length + cd->names_found * cd->name_entry_size) * sizeof(pcre_uchar);
9414:
9415: /* Get the memory. */
1.1 misha 9416:
1.6 misha 9417: re = (REAL_PCRE *)(PUBL(malloc))(size);
1.1 misha 9418: if (re == NULL)
9419: {
9420: errorcode = ERR21;
9421: goto PCRE_EARLY_ERROR_RETURN;
9422: }
9423:
9424: /* Put in the magic number, and save the sizes, initial options, internal
9425: flags, and character table pointer. NULL is used for the default character
9426: tables. The nullpad field is at the end; it's there to help in the case when a
9427: regex compiled on a system with 4-byte pointers is run on another with 8-byte
9428: pointers. */
9429:
9430: re->magic_number = MAGIC_NUMBER;
1.4 misha 9431: re->size = (int)size;
1.1 misha 9432: re->options = cd->external_options;
9433: re->flags = cd->external_flags;
1.7 misha 9434: re->limit_match = limit_match;
9435: re->limit_recursion = limit_recursion;
1.6 misha 9436: re->first_char = 0;
9437: re->req_char = 0;
9438: re->name_table_offset = sizeof(REAL_PCRE) / sizeof(pcre_uchar);
1.1 misha 9439: re->name_entry_size = cd->name_entry_size;
9440: re->name_count = cd->names_found;
9441: re->ref_count = 0;
1.6 misha 9442: re->tables = (tables == PRIV(default_tables))? NULL : tables;
1.1 misha 9443: re->nullpad = NULL;
1.7 misha 9444: #ifdef COMPILE_PCRE32
9445: re->dummy = 0;
9446: #else
9447: re->dummy1 = re->dummy2 = re->dummy3 = 0;
9448: #endif
1.1 misha 9449:
9450: /* The starting points of the name/number translation table and of the code are
9451: passed around in the compile data block. The start/end pattern and initial
9452: options are already set from the pre-compile phase, as is the name_entry_size
9453: field. Reset the bracket count and the names_found field. Also reset the hwm
9454: field; this time it's used for remembering forward references to subpatterns.
9455: */
9456:
9457: cd->final_bracount = cd->bracount; /* Save for checking forward references */
1.8 moko 9458: cd->parens_depth = 0;
1.6 misha 9459: cd->assert_depth = 0;
1.1 misha 9460: cd->bracount = 0;
1.7 misha 9461: cd->max_lookbehind = 0;
1.6 misha 9462: cd->name_table = (pcre_uchar *)re + re->name_table_offset;
1.1 misha 9463: codestart = cd->name_table + re->name_entry_size * re->name_count;
9464: cd->start_code = codestart;
1.6 misha 9465: cd->hwm = (pcre_uchar *)(cd->start_workspace);
1.8 moko 9466: cd->iscondassert = FALSE;
1.1 misha 9467: cd->req_varyopt = 0;
9468: cd->had_accept = FALSE;
1.7 misha 9469: cd->had_pruneorskip = FALSE;
1.4 misha 9470: cd->check_lookbehind = FALSE;
9471: cd->open_caps = NULL;
1.1 misha 9472:
1.8 moko 9473: /* If any named groups were found, create the name/number table from the list
9474: created in the first pass. */
9475:
9476: if (cd->names_found > 0)
9477: {
9478: int i = cd->names_found;
9479: named_group *ng = cd->named_groups;
9480: cd->names_found = 0;
9481: for (; i > 0; i--, ng++)
9482: add_name(cd, ng->name, ng->length, ng->number);
9483: if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE)
9484: (PUBL(free))((void *)cd->named_groups);
9485: }
9486:
1.1 misha 9487: /* Set up a starting, non-extracting bracket, then compile the expression. On
9488: error, errorcode will be set non-zero, so we don't need to look at the result
9489: of the function here. */
9490:
1.6 misha 9491: ptr = (const pcre_uchar *)pattern + skipatstart;
9492: code = (pcre_uchar *)codestart;
1.1 misha 9493: *code = OP_BRA;
1.6 misha 9494: (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,
1.7 misha 9495: &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL, cd, NULL);
1.1 misha 9496: re->top_bracket = cd->bracount;
9497: re->top_backref = cd->top_backref;
1.7 misha 9498: re->max_lookbehind = cd->max_lookbehind;
1.6 misha 9499: re->flags = cd->external_flags | PCRE_MODE;
1.1 misha 9500:
1.7 misha 9501: if (cd->had_accept)
9502: {
9503: reqchar = 0; /* Must disable after (*ACCEPT) */
9504: reqcharflags = REQ_NONE;
9505: }
1.1 misha 9506:
9507: /* If not reached end of pattern on success, there's an excess bracket. */
9508:
1.7 misha 9509: if (errorcode == 0 && *ptr != CHAR_NULL) errorcode = ERR22;
1.1 misha 9510:
9511: /* Fill in the terminating state and check for disastrous overflow, but
9512: if debugging, leave the test till after things are printed out. */
9513:
9514: *code++ = OP_END;
9515:
1.4 misha 9516: #ifndef PCRE_DEBUG
1.1 misha 9517: if (code - codestart > length) errorcode = ERR23;
9518: #endif
9519:
1.7 misha 9520: #ifdef SUPPORT_VALGRIND
9521: /* If the estimated length exceeds the really used length, mark the extra
9522: allocated memory as unaddressable, so that any out-of-bound reads can be
9523: detected. */
9524: VALGRIND_MAKE_MEM_NOACCESS(code, (length - (code - codestart)) * sizeof(pcre_uchar));
9525: #endif
9526:
1.6 misha 9527: /* Fill in any forward references that are required. There may be repeated
9528: references; optimize for them, as searching a large regex takes time. */
1.1 misha 9529:
1.6 misha 9530: if (cd->hwm > cd->start_workspace)
1.1 misha 9531: {
1.6 misha 9532: int prev_recno = -1;
9533: const pcre_uchar *groupptr = NULL;
9534: while (errorcode == 0 && cd->hwm > cd->start_workspace)
9535: {
9536: int offset, recno;
9537: cd->hwm -= LINK_SIZE;
9538: offset = GET(cd->hwm, 0);
1.9 ! moko 9539:
! 9540: /* Check that the hwm handling hasn't gone wrong. This whole area is
! 9541: rewritten in PCRE2 because there are some obscure cases. */
! 9542:
! 9543: if (offset == 0 || codestart[offset-1] != OP_RECURSE)
! 9544: {
! 9545: errorcode = ERR10;
! 9546: break;
! 9547: }
! 9548:
1.6 misha 9549: recno = GET(codestart, offset);
9550: if (recno != prev_recno)
9551: {
9552: groupptr = PRIV(find_bracket)(codestart, utf, recno);
9553: prev_recno = recno;
9554: }
9555: if (groupptr == NULL) errorcode = ERR53;
9556: else PUT(((pcre_uchar *)codestart), offset, (int)(groupptr - codestart));
9557: }
1.1 misha 9558: }
9559:
1.8 moko 9560: /* If the workspace had to be expanded, free the new memory. Set the pointer to
9561: NULL to indicate that forward references have been filled in. */
1.6 misha 9562:
9563: if (cd->workspace_size > COMPILE_WORK_SIZE)
9564: (PUBL(free))((void *)cd->start_workspace);
1.8 moko 9565: cd->start_workspace = NULL;
1.6 misha 9566:
1.1 misha 9567: /* Give an error if there's back reference to a non-existent capturing
9568: subpattern. */
9569:
9570: if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;
9571:
1.8 moko 9572: /* Unless disabled, check whether any single character iterators can be
9573: auto-possessified. The function overwrites the appropriate opcode values, so
9574: the type of the pointer must be cast. NOTE: the intermediate variable "temp" is
9575: used in this code because at least one compiler gives a warning about loss of
9576: "const" attribute if the cast (pcre_uchar *)codestart is used directly in the
9577: function call. */
9578:
1.9 ! moko 9579: if (errorcode == 0 && (options & PCRE_NO_AUTO_POSSESS) == 0)
1.8 moko 9580: {
9581: pcre_uchar *temp = (pcre_uchar *)codestart;
9582: auto_possessify(temp, utf, cd);
9583: }
9584:
1.4 misha 9585: /* If there were any lookbehind assertions that contained OP_RECURSE
9586: (recursions or subroutine calls), a flag is set for them to be checked here,
1.7 misha 9587: because they may contain forward references. Actual recursions cannot be fixed
1.4 misha 9588: length, but subroutine calls can. It is done like this so that those without
9589: OP_RECURSE that are not fixed length get a diagnosic with a useful offset. The
9590: exceptional ones forgo this. We scan the pattern to check that they are fixed
9591: length, and set their lengths. */
9592:
1.9 ! moko 9593: if (errorcode == 0 && cd->check_lookbehind)
1.4 misha 9594: {
1.6 misha 9595: pcre_uchar *cc = (pcre_uchar *)codestart;
1.4 misha 9596:
9597: /* Loop, searching for OP_REVERSE items, and process those that do not have
9598: their length set. (Actually, it will also re-process any that have a length
9599: of zero, but that is a pathological case, and it does no harm.) When we find
9600: one, we temporarily terminate the branch it is in while we scan it. */
9601:
1.6 misha 9602: for (cc = (pcre_uchar *)PRIV(find_bracket)(codestart, utf, -1);
1.4 misha 9603: cc != NULL;
1.6 misha 9604: cc = (pcre_uchar *)PRIV(find_bracket)(cc, utf, -1))
1.4 misha 9605: {
9606: if (GET(cc, 1) == 0)
9607: {
9608: int fixed_length;
1.6 misha 9609: pcre_uchar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
1.4 misha 9610: int end_op = *be;
9611: *be = OP_END;
1.6 misha 9612: fixed_length = find_fixedlength(cc, (re->options & PCRE_UTF8) != 0, TRUE,
1.8 moko 9613: cd, NULL);
1.4 misha 9614: *be = end_op;
9615: DPRINTF(("fixed length = %d\n", fixed_length));
9616: if (fixed_length < 0)
9617: {
1.6 misha 9618: errorcode = (fixed_length == -2)? ERR36 :
9619: (fixed_length == -4)? ERR70 : ERR25;
1.4 misha 9620: break;
9621: }
1.7 misha 9622: if (fixed_length > cd->max_lookbehind) cd->max_lookbehind = fixed_length;
1.4 misha 9623: PUT(cc, 1, fixed_length);
9624: }
9625: cc += 1 + LINK_SIZE;
9626: }
9627: }
9628:
1.1 misha 9629: /* Failed to compile, or error while post-processing */
9630:
9631: if (errorcode != 0)
9632: {
1.6 misha 9633: (PUBL(free))(re);
1.1 misha 9634: PCRE_EARLY_ERROR_RETURN:
1.6 misha 9635: *erroroffset = (int)(ptr - (const pcre_uchar *)pattern);
1.1 misha 9636: PCRE_EARLY_ERROR_RETURN2:
9637: *errorptr = find_error_text(errorcode);
9638: if (errorcodeptr != NULL) *errorcodeptr = errorcode;
9639: return NULL;
9640: }
9641:
9642: /* If the anchored option was not passed, set the flag if we can determine that
1.7 misha 9643: the pattern is anchored by virtue of ^ characters or \A or anything else, such
9644: as starting with non-atomic .* when DOTALL is set and there are no occurrences
9645: of *PRUNE or *SKIP.
1.1 misha 9646:
9647: Otherwise, if we know what the first byte has to be, save it, because that
9648: speeds up unanchored matches no end. If not, see if we can set the
9649: PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
1.7 misha 9650: start with ^. and also when all branches start with non-atomic .* for
9651: non-DOTALL matches when *PRUNE and SKIP are not present. */
1.1 misha 9652:
9653: if ((re->options & PCRE_ANCHORED) == 0)
9654: {
1.7 misha 9655: if (is_anchored(codestart, 0, cd, 0)) re->options |= PCRE_ANCHORED;
1.1 misha 9656: else
9657: {
1.7 misha 9658: if (firstcharflags < 0)
9659: firstchar = find_firstassertedchar(codestart, &firstcharflags, FALSE);
9660: if (firstcharflags >= 0) /* Remove caseless flag for non-caseable chars */
1.6 misha 9661: {
1.7 misha 9662: #if defined COMPILE_PCRE8
1.6 misha 9663: re->first_char = firstchar & 0xff;
1.7 misha 9664: #elif defined COMPILE_PCRE16
1.6 misha 9665: re->first_char = firstchar & 0xffff;
1.7 misha 9666: #elif defined COMPILE_PCRE32
9667: re->first_char = firstchar;
1.6 misha 9668: #endif
1.7 misha 9669: if ((firstcharflags & REQ_CASELESS) != 0)
1.6 misha 9670: {
9671: #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
9672: /* We ignore non-ASCII first chars in 8 bit mode. */
9673: if (utf)
9674: {
9675: if (re->first_char < 128)
9676: {
9677: if (cd->fcc[re->first_char] != re->first_char)
9678: re->flags |= PCRE_FCH_CASELESS;
9679: }
9680: else if (UCD_OTHERCASE(re->first_char) != re->first_char)
9681: re->flags |= PCRE_FCH_CASELESS;
9682: }
9683: else
9684: #endif
9685: if (MAX_255(re->first_char)
9686: && cd->fcc[re->first_char] != re->first_char)
9687: re->flags |= PCRE_FCH_CASELESS;
9688: }
9689:
1.1 misha 9690: re->flags |= PCRE_FIRSTSET;
9691: }
1.7 misha 9692:
1.9 ! moko 9693: else if (is_startline(codestart, 0, cd, 0, FALSE)) re->flags |= PCRE_STARTLINE;
1.1 misha 9694: }
9695: }
9696:
9697: /* For an anchored pattern, we use the "required byte" only if it follows a
9698: variable length item in the regex. Remove the caseless flag for non-caseable
9699: bytes. */
9700:
1.7 misha 9701: if (reqcharflags >= 0 &&
9702: ((re->options & PCRE_ANCHORED) == 0 || (reqcharflags & REQ_VARY) != 0))
1.1 misha 9703: {
1.7 misha 9704: #if defined COMPILE_PCRE8
1.6 misha 9705: re->req_char = reqchar & 0xff;
1.7 misha 9706: #elif defined COMPILE_PCRE16
1.6 misha 9707: re->req_char = reqchar & 0xffff;
1.7 misha 9708: #elif defined COMPILE_PCRE32
9709: re->req_char = reqchar;
1.6 misha 9710: #endif
1.7 misha 9711: if ((reqcharflags & REQ_CASELESS) != 0)
1.6 misha 9712: {
9713: #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
9714: /* We ignore non-ASCII first chars in 8 bit mode. */
9715: if (utf)
9716: {
9717: if (re->req_char < 128)
9718: {
9719: if (cd->fcc[re->req_char] != re->req_char)
9720: re->flags |= PCRE_RCH_CASELESS;
9721: }
9722: else if (UCD_OTHERCASE(re->req_char) != re->req_char)
9723: re->flags |= PCRE_RCH_CASELESS;
9724: }
9725: else
9726: #endif
9727: if (MAX_255(re->req_char) && cd->fcc[re->req_char] != re->req_char)
9728: re->flags |= PCRE_RCH_CASELESS;
9729: }
9730:
1.1 misha 9731: re->flags |= PCRE_REQCHSET;
9732: }
9733:
9734: /* Print out the compiled data if debugging is enabled. This is never the
9735: case when building a production library. */
9736:
1.4 misha 9737: #ifdef PCRE_DEBUG
1.1 misha 9738: printf("Length = %d top_bracket = %d top_backref = %d\n",
9739: length, re->top_bracket, re->top_backref);
9740:
9741: printf("Options=%08x\n", re->options);
9742:
9743: if ((re->flags & PCRE_FIRSTSET) != 0)
9744: {
1.6 misha 9745: pcre_uchar ch = re->first_char;
9746: const char *caseless =
9747: ((re->flags & PCRE_FCH_CASELESS) == 0)? "" : " (caseless)";
9748: if (PRINTABLE(ch)) printf("First char = %c%s\n", ch, caseless);
1.1 misha 9749: else printf("First char = \\x%02x%s\n", ch, caseless);
9750: }
9751:
9752: if ((re->flags & PCRE_REQCHSET) != 0)
9753: {
1.6 misha 9754: pcre_uchar ch = re->req_char;
9755: const char *caseless =
9756: ((re->flags & PCRE_RCH_CASELESS) == 0)? "" : " (caseless)";
9757: if (PRINTABLE(ch)) printf("Req char = %c%s\n", ch, caseless);
1.1 misha 9758: else printf("Req char = \\x%02x%s\n", ch, caseless);
9759: }
9760:
1.7 misha 9761: #if defined COMPILE_PCRE8
1.6 misha 9762: pcre_printint((pcre *)re, stdout, TRUE);
1.7 misha 9763: #elif defined COMPILE_PCRE16
1.6 misha 9764: pcre16_printint((pcre *)re, stdout, TRUE);
1.7 misha 9765: #elif defined COMPILE_PCRE32
9766: pcre32_printint((pcre *)re, stdout, TRUE);
1.6 misha 9767: #endif
1.1 misha 9768:
9769: /* This check is done here in the debugging case so that the code that
9770: was compiled can be seen. */
9771:
9772: if (code - codestart > length)
9773: {
1.6 misha 9774: (PUBL(free))(re);
1.1 misha 9775: *errorptr = find_error_text(ERR23);
1.6 misha 9776: *erroroffset = ptr - (pcre_uchar *)pattern;
1.1 misha 9777: if (errorcodeptr != NULL) *errorcodeptr = ERR23;
9778: return NULL;
9779: }
1.4 misha 9780: #endif /* PCRE_DEBUG */
1.1 misha 9781:
1.8 moko 9782: /* Check for a pattern than can match an empty string, so that this information
9783: can be provided to applications. */
9784:
9785: do
9786: {
9787: if (could_be_empty_branch(codestart, code, utf, cd, NULL))
9788: {
9789: re->flags |= PCRE_MATCH_EMPTY;
9790: break;
9791: }
9792: codestart += GET(codestart, 1);
9793: }
9794: while (*codestart == OP_ALT);
9795:
1.7 misha 9796: #if defined COMPILE_PCRE8
1.1 misha 9797: return (pcre *)re;
1.7 misha 9798: #elif defined COMPILE_PCRE16
1.6 misha 9799: return (pcre16 *)re;
1.7 misha 9800: #elif defined COMPILE_PCRE32
9801: return (pcre32 *)re;
1.6 misha 9802: #endif
1.1 misha 9803: }
9804:
9805: /* End of pcre_compile.c */
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pcre_compile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / pcre