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

Contents of /code/trunk/pcre_compile.c

Parent Directory Parent Directory | Revision Log Revision Log


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