chiark / gitweb /
pcre3 (2:8.35-7.4) unstable; urgency=medium
[pcre3.git] / pcre_compile.c
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 while (IS_DIGIT(*p)) 
1587   {
1588   min = min * 10 + (int)(*p++ - CHAR_0);
1589   if (min > 65535)
1590     {
1591     *errorcodeptr = ERR5;
1592     return p;
1593     }
1594   }   
1595
1596 if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else
1597   {
1598   if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)
1599     {
1600     max = 0;
1601     while(IS_DIGIT(*p)) 
1602       {
1603       max = max * 10 + (int)(*p++ - CHAR_0);
1604       if (max > 65535)
1605         {
1606         *errorcodeptr = ERR5;
1607         return p;
1608         }
1609       }   
1610     if (max < min)
1611       {
1612       *errorcodeptr = ERR4;
1613       return p;
1614       }
1615     }
1616   }
1617
1618 *minp = min;
1619 *maxp = max;
1620 return p;
1621 }
1622
1623
1624
1625 /*************************************************
1626 *      Find first significant op code            *
1627 *************************************************/
1628
1629 /* This is called by several functions that scan a compiled expression looking
1630 for a fixed first character, or an anchoring op code etc. It skips over things
1631 that do not influence this. For some calls, it makes sense to skip negative
1632 forward and all backward assertions, and also the \b assertion; for others it
1633 does not.
1634
1635 Arguments:
1636   code         pointer to the start of the group
1637   skipassert   TRUE if certain assertions are to be skipped
1638
1639 Returns:       pointer to the first significant opcode
1640 */
1641
1642 static const pcre_uchar*
1643 first_significant_code(const pcre_uchar *code, BOOL skipassert)
1644 {
1645 for (;;)
1646   {
1647   switch ((int)*code)
1648     {
1649     case OP_ASSERT_NOT:
1650     case OP_ASSERTBACK:
1651     case OP_ASSERTBACK_NOT:
1652     if (!skipassert) return code;
1653     do code += GET(code, 1); while (*code == OP_ALT);
1654     code += PRIV(OP_lengths)[*code];
1655     break;
1656
1657     case OP_WORD_BOUNDARY:
1658     case OP_NOT_WORD_BOUNDARY:
1659     if (!skipassert) return code;
1660     /* Fall through */
1661
1662     case OP_CALLOUT:
1663     case OP_CREF:
1664     case OP_DNCREF:
1665     case OP_RREF:
1666     case OP_DNRREF:
1667     case OP_DEF:
1668     code += PRIV(OP_lengths)[*code];
1669     break;
1670
1671     default:
1672     return code;
1673     }
1674   }
1675 /* Control never reaches here */
1676 }
1677
1678
1679
1680 /*************************************************
1681 *        Find the fixed length of a branch       *
1682 *************************************************/
1683
1684 /* Scan a branch and compute the fixed length of subject that will match it,
1685 if the length is fixed. This is needed for dealing with backward assertions.
1686 In UTF8 mode, the result is in characters rather than bytes. The branch is
1687 temporarily terminated with OP_END when this function is called.
1688
1689 This function is called when a backward assertion is encountered, so that if it
1690 fails, the error message can point to the correct place in the pattern.
1691 However, we cannot do this when the assertion contains subroutine calls,
1692 because they can be forward references. We solve this by remembering this case
1693 and doing the check at the end; a flag specifies which mode we are running in.
1694
1695 Arguments:
1696   code     points to the start of the pattern (the bracket)
1697   utf      TRUE in UTF-8 / UTF-16 / UTF-32 mode
1698   atend    TRUE if called when the pattern is complete
1699   cd       the "compile data" structure
1700
1701 Returns:   the fixed length,
1702              or -1 if there is no fixed length,
1703              or -2 if \C was encountered (in UTF-8 mode only)
1704              or -3 if an OP_RECURSE item was encountered and atend is FALSE
1705              or -4 if an unknown opcode was encountered (internal error)
1706 */
1707
1708 static int
1709 find_fixedlength(pcre_uchar *code, BOOL utf, BOOL atend, compile_data *cd)
1710 {
1711 int length = -1;
1712
1713 register int branchlength = 0;
1714 register pcre_uchar *cc = code + 1 + LINK_SIZE;
1715
1716 /* Scan along the opcodes for this branch. If we get to the end of the
1717 branch, check the length against that of the other branches. */
1718
1719 for (;;)
1720   {
1721   int d;
1722   pcre_uchar *ce, *cs;
1723   register pcre_uchar op = *cc;
1724
1725   switch (op)
1726     {
1727     /* We only need to continue for OP_CBRA (normal capturing bracket) and
1728     OP_BRA (normal non-capturing bracket) because the other variants of these
1729     opcodes are all concerned with unlimited repeated groups, which of course
1730     are not of fixed length. */
1731
1732     case OP_CBRA:
1733     case OP_BRA:
1734     case OP_ONCE:
1735     case OP_ONCE_NC:
1736     case OP_COND:
1737     d = find_fixedlength(cc + ((op == OP_CBRA)? IMM2_SIZE : 0), utf, atend, cd);
1738     if (d < 0) return d;
1739     branchlength += d;
1740     do cc += GET(cc, 1); while (*cc == OP_ALT);
1741     cc += 1 + LINK_SIZE;
1742     break;
1743
1744     /* Reached end of a branch; if it's a ket it is the end of a nested call.
1745     If it's ALT it is an alternation in a nested call. An ACCEPT is effectively
1746     an ALT. If it is END it's the end of the outer call. All can be handled by
1747     the same code. Note that we must not include the OP_KETRxxx opcodes here,
1748     because they all imply an unlimited repeat. */
1749
1750     case OP_ALT:
1751     case OP_KET:
1752     case OP_END:
1753     case OP_ACCEPT:
1754     case OP_ASSERT_ACCEPT:
1755     if (length < 0) length = branchlength;
1756       else if (length != branchlength) return -1;
1757     if (*cc != OP_ALT) return length;
1758     cc += 1 + LINK_SIZE;
1759     branchlength = 0;
1760     break;
1761
1762     /* A true recursion implies not fixed length, but a subroutine call may
1763     be OK. If the subroutine is a forward reference, we can't deal with
1764     it until the end of the pattern, so return -3. */
1765
1766     case OP_RECURSE:
1767     if (!atend) return -3;
1768     cs = ce = (pcre_uchar *)cd->start_code + GET(cc, 1);  /* Start subpattern */
1769     do ce += GET(ce, 1); while (*ce == OP_ALT);           /* End subpattern */
1770     if (cc > cs && cc < ce) return -1;                    /* Recursion */
1771     d = find_fixedlength(cs + IMM2_SIZE, utf, atend, cd);
1772     if (d < 0) return d;
1773     branchlength += d;
1774     cc += 1 + LINK_SIZE;
1775     break;
1776
1777     /* Skip over assertive subpatterns */
1778
1779     case OP_ASSERT:
1780     case OP_ASSERT_NOT:
1781     case OP_ASSERTBACK:
1782     case OP_ASSERTBACK_NOT:
1783     do cc += GET(cc, 1); while (*cc == OP_ALT);
1784     cc += PRIV(OP_lengths)[*cc];
1785     break;
1786
1787     /* Skip over things that don't match chars */
1788
1789     case OP_MARK:
1790     case OP_PRUNE_ARG:
1791     case OP_SKIP_ARG:
1792     case OP_THEN_ARG:
1793     cc += cc[1] + PRIV(OP_lengths)[*cc];
1794     break;
1795
1796     case OP_CALLOUT:
1797     case OP_CIRC:
1798     case OP_CIRCM:
1799     case OP_CLOSE:
1800     case OP_COMMIT:
1801     case OP_CREF:
1802     case OP_DEF:
1803     case OP_DNCREF:
1804     case OP_DNRREF:
1805     case OP_DOLL:
1806     case OP_DOLLM:
1807     case OP_EOD:
1808     case OP_EODN:
1809     case OP_FAIL:
1810     case OP_NOT_WORD_BOUNDARY:
1811     case OP_PRUNE:
1812     case OP_REVERSE:
1813     case OP_RREF:
1814     case OP_SET_SOM:
1815     case OP_SKIP:
1816     case OP_SOD:
1817     case OP_SOM:
1818     case OP_THEN:
1819     case OP_WORD_BOUNDARY:
1820     cc += PRIV(OP_lengths)[*cc];
1821     break;
1822
1823     /* Handle literal characters */
1824
1825     case OP_CHAR:
1826     case OP_CHARI:
1827     case OP_NOT:
1828     case OP_NOTI:
1829     branchlength++;
1830     cc += 2;
1831 #ifdef SUPPORT_UTF
1832     if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1833 #endif
1834     break;
1835
1836     /* Handle exact repetitions. The count is already in characters, but we
1837     need to skip over a multibyte character in UTF8 mode.  */
1838
1839     case OP_EXACT:
1840     case OP_EXACTI:
1841     case OP_NOTEXACT:
1842     case OP_NOTEXACTI:
1843     branchlength += (int)GET2(cc,1);
1844     cc += 2 + IMM2_SIZE;
1845 #ifdef SUPPORT_UTF
1846     if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1847 #endif
1848     break;
1849
1850     case OP_TYPEEXACT:
1851     branchlength += GET2(cc,1);
1852     if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP)
1853       cc += 2;
1854     cc += 1 + IMM2_SIZE + 1;
1855     break;
1856
1857     /* Handle single-char matchers */
1858
1859     case OP_PROP:
1860     case OP_NOTPROP:
1861     cc += 2;
1862     /* Fall through */
1863
1864     case OP_HSPACE:
1865     case OP_VSPACE:
1866     case OP_NOT_HSPACE:
1867     case OP_NOT_VSPACE:
1868     case OP_NOT_DIGIT:
1869     case OP_DIGIT:
1870     case OP_NOT_WHITESPACE:
1871     case OP_WHITESPACE:
1872     case OP_NOT_WORDCHAR:
1873     case OP_WORDCHAR:
1874     case OP_ANY:
1875     case OP_ALLANY:
1876     branchlength++;
1877     cc++;
1878     break;
1879
1880     /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode;
1881     otherwise \C is coded as OP_ALLANY. */
1882
1883     case OP_ANYBYTE:
1884     return -2;
1885
1886     /* Check a class for variable quantification */
1887
1888     case OP_CLASS:
1889     case OP_NCLASS:
1890 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
1891     case OP_XCLASS:
1892     /* The original code caused an unsigned overflow in 64 bit systems,
1893     so now we use a conditional statement. */
1894     if (op == OP_XCLASS)
1895       cc += GET(cc, 1);
1896     else
1897       cc += PRIV(OP_lengths)[OP_CLASS];
1898 #else
1899     cc += PRIV(OP_lengths)[OP_CLASS];
1900 #endif
1901
1902     switch (*cc)
1903       {
1904       case OP_CRSTAR:
1905       case OP_CRMINSTAR:
1906       case OP_CRPLUS:
1907       case OP_CRMINPLUS:
1908       case OP_CRQUERY:
1909       case OP_CRMINQUERY:
1910       case OP_CRPOSSTAR:
1911       case OP_CRPOSPLUS:
1912       case OP_CRPOSQUERY:
1913       return -1;
1914
1915       case OP_CRRANGE:
1916       case OP_CRMINRANGE:
1917       case OP_CRPOSRANGE:
1918       if (GET2(cc,1) != GET2(cc,1+IMM2_SIZE)) return -1;
1919       branchlength += (int)GET2(cc,1);
1920       cc += 1 + 2 * IMM2_SIZE;
1921       break;
1922
1923       default:
1924       branchlength++;
1925       }
1926     break;
1927
1928     /* Anything else is variable length */
1929
1930     case OP_ANYNL:
1931     case OP_BRAMINZERO:
1932     case OP_BRAPOS:
1933     case OP_BRAPOSZERO:
1934     case OP_BRAZERO:
1935     case OP_CBRAPOS:
1936     case OP_EXTUNI:
1937     case OP_KETRMAX:
1938     case OP_KETRMIN:
1939     case OP_KETRPOS:
1940     case OP_MINPLUS:
1941     case OP_MINPLUSI:
1942     case OP_MINQUERY:
1943     case OP_MINQUERYI:
1944     case OP_MINSTAR:
1945     case OP_MINSTARI:
1946     case OP_MINUPTO:
1947     case OP_MINUPTOI:
1948     case OP_NOTMINPLUS:
1949     case OP_NOTMINPLUSI:
1950     case OP_NOTMINQUERY:
1951     case OP_NOTMINQUERYI:
1952     case OP_NOTMINSTAR:
1953     case OP_NOTMINSTARI:
1954     case OP_NOTMINUPTO:
1955     case OP_NOTMINUPTOI:
1956     case OP_NOTPLUS:
1957     case OP_NOTPLUSI:
1958     case OP_NOTPOSPLUS:
1959     case OP_NOTPOSPLUSI:
1960     case OP_NOTPOSQUERY:
1961     case OP_NOTPOSQUERYI:
1962     case OP_NOTPOSSTAR:
1963     case OP_NOTPOSSTARI:
1964     case OP_NOTPOSUPTO:
1965     case OP_NOTPOSUPTOI:
1966     case OP_NOTQUERY:
1967     case OP_NOTQUERYI:
1968     case OP_NOTSTAR:
1969     case OP_NOTSTARI:
1970     case OP_NOTUPTO:
1971     case OP_NOTUPTOI:
1972     case OP_PLUS:
1973     case OP_PLUSI:
1974     case OP_POSPLUS:
1975     case OP_POSPLUSI:
1976     case OP_POSQUERY:
1977     case OP_POSQUERYI:
1978     case OP_POSSTAR:
1979     case OP_POSSTARI:
1980     case OP_POSUPTO:
1981     case OP_POSUPTOI:
1982     case OP_QUERY:
1983     case OP_QUERYI:
1984     case OP_REF:
1985     case OP_REFI:
1986     case OP_DNREF:
1987     case OP_DNREFI:
1988     case OP_SBRA:
1989     case OP_SBRAPOS:
1990     case OP_SCBRA:
1991     case OP_SCBRAPOS:
1992     case OP_SCOND:
1993     case OP_SKIPZERO:
1994     case OP_STAR:
1995     case OP_STARI:
1996     case OP_TYPEMINPLUS:
1997     case OP_TYPEMINQUERY:
1998     case OP_TYPEMINSTAR:
1999     case OP_TYPEMINUPTO:
2000     case OP_TYPEPLUS:
2001     case OP_TYPEPOSPLUS:
2002     case OP_TYPEPOSQUERY:
2003     case OP_TYPEPOSSTAR:
2004     case OP_TYPEPOSUPTO:
2005     case OP_TYPEQUERY:
2006     case OP_TYPESTAR:
2007     case OP_TYPEUPTO:
2008     case OP_UPTO:
2009     case OP_UPTOI:
2010     return -1;
2011
2012     /* Catch unrecognized opcodes so that when new ones are added they
2013     are not forgotten, as has happened in the past. */
2014
2015     default:
2016     return -4;
2017     }
2018   }
2019 /* Control never gets here */
2020 }
2021
2022
2023
2024 /*************************************************
2025 *    Scan compiled regex for specific bracket    *
2026 *************************************************/
2027
2028 /* This little function scans through a compiled pattern until it finds a
2029 capturing bracket with the given number, or, if the number is negative, an
2030 instance of OP_REVERSE for a lookbehind. The function is global in the C sense
2031 so that it can be called from pcre_study() when finding the minimum matching
2032 length.
2033
2034 Arguments:
2035   code        points to start of expression
2036   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
2037   number      the required bracket number or negative to find a lookbehind
2038
2039 Returns:      pointer to the opcode for the bracket, or NULL if not found
2040 */
2041
2042 const pcre_uchar *
2043 PRIV(find_bracket)(const pcre_uchar *code, BOOL utf, int number)
2044 {
2045 for (;;)
2046   {
2047   register pcre_uchar c = *code;
2048
2049   if (c == OP_END) return NULL;
2050
2051   /* XCLASS is used for classes that cannot be represented just by a bit
2052   map. This includes negated single high-valued characters. The length in
2053   the table is zero; the actual length is stored in the compiled code. */
2054
2055   if (c == OP_XCLASS) code += GET(code, 1);
2056
2057   /* Handle recursion */
2058
2059   else if (c == OP_REVERSE)
2060     {
2061     if (number < 0) return (pcre_uchar *)code;
2062     code += PRIV(OP_lengths)[c];
2063     }
2064
2065   /* Handle capturing bracket */
2066
2067   else if (c == OP_CBRA || c == OP_SCBRA ||
2068            c == OP_CBRAPOS || c == OP_SCBRAPOS)
2069     {
2070     int n = (int)GET2(code, 1+LINK_SIZE);
2071     if (n == number) return (pcre_uchar *)code;
2072     code += PRIV(OP_lengths)[c];
2073     }
2074
2075   /* Otherwise, we can get the item's length from the table, except that for
2076   repeated character types, we have to test for \p and \P, which have an extra
2077   two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
2078   must add in its length. */
2079
2080   else
2081     {
2082     switch(c)
2083       {
2084       case OP_TYPESTAR:
2085       case OP_TYPEMINSTAR:
2086       case OP_TYPEPLUS:
2087       case OP_TYPEMINPLUS:
2088       case OP_TYPEQUERY:
2089       case OP_TYPEMINQUERY:
2090       case OP_TYPEPOSSTAR:
2091       case OP_TYPEPOSPLUS:
2092       case OP_TYPEPOSQUERY:
2093       if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2094       break;
2095
2096       case OP_TYPEUPTO:
2097       case OP_TYPEMINUPTO:
2098       case OP_TYPEEXACT:
2099       case OP_TYPEPOSUPTO:
2100       if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2101         code += 2;
2102       break;
2103
2104       case OP_MARK:
2105       case OP_PRUNE_ARG:
2106       case OP_SKIP_ARG:
2107       case OP_THEN_ARG:
2108       code += code[1];
2109       break;
2110       }
2111
2112     /* Add in the fixed length from the table */
2113
2114     code += PRIV(OP_lengths)[c];
2115
2116   /* In UTF-8 mode, opcodes that are followed by a character may be followed by
2117   a multi-byte character. The length in the table is a minimum, so we have to
2118   arrange to skip the extra bytes. */
2119
2120 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2121     if (utf) switch(c)
2122       {
2123       case OP_CHAR:
2124       case OP_CHARI:
2125       case OP_EXACT:
2126       case OP_EXACTI:
2127       case OP_UPTO:
2128       case OP_UPTOI:
2129       case OP_MINUPTO:
2130       case OP_MINUPTOI:
2131       case OP_POSUPTO:
2132       case OP_POSUPTOI:
2133       case OP_STAR:
2134       case OP_STARI:
2135       case OP_MINSTAR:
2136       case OP_MINSTARI:
2137       case OP_POSSTAR:
2138       case OP_POSSTARI:
2139       case OP_PLUS:
2140       case OP_PLUSI:
2141       case OP_MINPLUS:
2142       case OP_MINPLUSI:
2143       case OP_POSPLUS:
2144       case OP_POSPLUSI:
2145       case OP_QUERY:
2146       case OP_QUERYI:
2147       case OP_MINQUERY:
2148       case OP_MINQUERYI:
2149       case OP_POSQUERY:
2150       case OP_POSQUERYI:
2151       if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
2152       break;
2153       }
2154 #else
2155     (void)(utf);  /* Keep compiler happy by referencing function argument */
2156 #endif
2157     }
2158   }
2159 }
2160
2161
2162
2163 /*************************************************
2164 *   Scan compiled regex for recursion reference  *
2165 *************************************************/
2166
2167 /* This little function scans through a compiled pattern until it finds an
2168 instance of OP_RECURSE.
2169
2170 Arguments:
2171   code        points to start of expression
2172   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
2173
2174 Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
2175 */
2176
2177 static const pcre_uchar *
2178 find_recurse(const pcre_uchar *code, BOOL utf)
2179 {
2180 for (;;)
2181   {
2182   register pcre_uchar c = *code;
2183   if (c == OP_END) return NULL;
2184   if (c == OP_RECURSE) return code;
2185
2186   /* XCLASS is used for classes that cannot be represented just by a bit
2187   map. This includes negated single high-valued characters. The length in
2188   the table is zero; the actual length is stored in the compiled code. */
2189
2190   if (c == OP_XCLASS) code += GET(code, 1);
2191
2192   /* Otherwise, we can get the item's length from the table, except that for
2193   repeated character types, we have to test for \p and \P, which have an extra
2194   two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
2195   must add in its length. */
2196
2197   else
2198     {
2199     switch(c)
2200       {
2201       case OP_TYPESTAR:
2202       case OP_TYPEMINSTAR:
2203       case OP_TYPEPLUS:
2204       case OP_TYPEMINPLUS:
2205       case OP_TYPEQUERY:
2206       case OP_TYPEMINQUERY:
2207       case OP_TYPEPOSSTAR:
2208       case OP_TYPEPOSPLUS:
2209       case OP_TYPEPOSQUERY:
2210       if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2211       break;
2212
2213       case OP_TYPEPOSUPTO:
2214       case OP_TYPEUPTO:
2215       case OP_TYPEMINUPTO:
2216       case OP_TYPEEXACT:
2217       if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2218         code += 2;
2219       break;
2220
2221       case OP_MARK:
2222       case OP_PRUNE_ARG:
2223       case OP_SKIP_ARG:
2224       case OP_THEN_ARG:
2225       code += code[1];
2226       break;
2227       }
2228
2229     /* Add in the fixed length from the table */
2230
2231     code += PRIV(OP_lengths)[c];
2232
2233     /* In UTF-8 mode, opcodes that are followed by a character may be followed
2234     by a multi-byte character. The length in the table is a minimum, so we have
2235     to arrange to skip the extra bytes. */
2236
2237 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2238     if (utf) switch(c)
2239       {
2240       case OP_CHAR:
2241       case OP_CHARI:
2242       case OP_NOT:
2243       case OP_NOTI:
2244       case OP_EXACT:
2245       case OP_EXACTI:
2246       case OP_NOTEXACT:
2247       case OP_NOTEXACTI:
2248       case OP_UPTO:
2249       case OP_UPTOI:
2250       case OP_NOTUPTO:
2251       case OP_NOTUPTOI:
2252       case OP_MINUPTO:
2253       case OP_MINUPTOI:
2254       case OP_NOTMINUPTO:
2255       case OP_NOTMINUPTOI:
2256       case OP_POSUPTO:
2257       case OP_POSUPTOI:
2258       case OP_NOTPOSUPTO:
2259       case OP_NOTPOSUPTOI:
2260       case OP_STAR:
2261       case OP_STARI:
2262       case OP_NOTSTAR:
2263       case OP_NOTSTARI:
2264       case OP_MINSTAR:
2265       case OP_MINSTARI:
2266       case OP_NOTMINSTAR:
2267       case OP_NOTMINSTARI:
2268       case OP_POSSTAR:
2269       case OP_POSSTARI:
2270       case OP_NOTPOSSTAR:
2271       case OP_NOTPOSSTARI:
2272       case OP_PLUS:
2273       case OP_PLUSI:
2274       case OP_NOTPLUS:
2275       case OP_NOTPLUSI:
2276       case OP_MINPLUS:
2277       case OP_MINPLUSI:
2278       case OP_NOTMINPLUS:
2279       case OP_NOTMINPLUSI:
2280       case OP_POSPLUS:
2281       case OP_POSPLUSI:
2282       case OP_NOTPOSPLUS:
2283       case OP_NOTPOSPLUSI:
2284       case OP_QUERY:
2285       case OP_QUERYI:
2286       case OP_NOTQUERY:
2287       case OP_NOTQUERYI:
2288       case OP_MINQUERY:
2289       case OP_MINQUERYI:
2290       case OP_NOTMINQUERY:
2291       case OP_NOTMINQUERYI:
2292       case OP_POSQUERY:
2293       case OP_POSQUERYI:
2294       case OP_NOTPOSQUERY:
2295       case OP_NOTPOSQUERYI:
2296       if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
2297       break;
2298       }
2299 #else
2300     (void)(utf);  /* Keep compiler happy by referencing function argument */
2301 #endif
2302     }
2303   }
2304 }
2305
2306
2307
2308 /*************************************************
2309 *    Scan compiled branch for non-emptiness      *
2310 *************************************************/
2311
2312 /* This function scans through a branch of a compiled pattern to see whether it
2313 can match the empty string or not. It is called from could_be_empty()
2314 below and from compile_branch() when checking for an unlimited repeat of a
2315 group that can match nothing. Note that first_significant_code() skips over
2316 backward and negative forward assertions when its final argument is TRUE. If we
2317 hit an unclosed bracket, we return "empty" - this means we've struck an inner
2318 bracket whose current branch will already have been scanned.
2319
2320 Arguments:
2321   code        points to start of search
2322   endcode     points to where to stop
2323   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
2324   cd          contains pointers to tables etc.
2325   recurses    chain of recurse_check to catch mutual recursion
2326
2327 Returns:      TRUE if what is matched could be empty
2328 */
2329
2330 typedef struct recurse_check {
2331   struct recurse_check *prev;
2332   const pcre_uchar *group;
2333 } recurse_check;
2334
2335 static BOOL
2336 could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,
2337   BOOL utf, compile_data *cd, recurse_check *recurses)
2338 {
2339 register pcre_uchar c;
2340 recurse_check this_recurse;
2341
2342 for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);
2343      code < endcode;
2344      code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))
2345   {
2346   const pcre_uchar *ccode;
2347
2348   c = *code;
2349
2350   /* Skip over forward assertions; the other assertions are skipped by
2351   first_significant_code() with a TRUE final argument. */
2352
2353   if (c == OP_ASSERT)
2354     {
2355     do code += GET(code, 1); while (*code == OP_ALT);
2356     c = *code;
2357     continue;
2358     }
2359
2360   /* For a recursion/subroutine call, if its end has been reached, which
2361   implies a backward reference subroutine call, we can scan it. If it's a
2362   forward reference subroutine call, we can't. To detect forward reference
2363   we have to scan up the list that is kept in the workspace. This function is
2364   called only when doing the real compile, not during the pre-compile that
2365   measures the size of the compiled pattern. */
2366
2367   if (c == OP_RECURSE)
2368     {
2369     const pcre_uchar *scode = cd->start_code + GET(code, 1);
2370     const pcre_uchar *endgroup = scode;
2371     BOOL empty_branch;
2372
2373     /* Test for forward reference or uncompleted reference. This is disabled
2374     when called to scan a completed pattern by setting cd->start_workspace to
2375     NULL. */
2376
2377     if (cd->start_workspace != NULL)
2378       {
2379       const pcre_uchar *tcode;
2380       for (tcode = cd->start_workspace; tcode < cd->hwm; tcode += LINK_SIZE)
2381         if ((int)GET(tcode, 0) == (int)(code + 1 - cd->start_code)) return TRUE;
2382       if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
2383       }
2384
2385     /* If the reference is to a completed group, we need to detect whether this
2386     is a recursive call, as otherwise there will be an infinite loop. If it is
2387     a recursion, just skip over it. Simple recursions are easily detected. For
2388     mutual recursions we keep a chain on the stack. */
2389
2390     do endgroup += GET(endgroup, 1); while (*endgroup == OP_ALT);
2391     if (code >= scode && code <= endgroup) continue;  /* Simple recursion */
2392     else
2393       {  
2394       recurse_check *r = recurses;
2395       for (r = recurses; r != NULL; r = r->prev)
2396         if (r->group == scode) break;
2397       if (r != NULL) continue;   /* Mutual recursion */
2398       } 
2399
2400     /* Completed reference; scan the referenced group, remembering it on the
2401     stack chain to detect mutual recursions. */
2402
2403     empty_branch = FALSE;
2404     this_recurse.prev = recurses;
2405     this_recurse.group = scode;
2406
2407     do
2408       {
2409       if (could_be_empty_branch(scode, endcode, utf, cd, &this_recurse))
2410         {
2411         empty_branch = TRUE;
2412         break;
2413         }
2414       scode += GET(scode, 1);
2415       }
2416     while (*scode == OP_ALT);
2417
2418     if (!empty_branch) return FALSE;  /* All branches are non-empty */
2419     continue;
2420     }
2421
2422   /* Groups with zero repeats can of course be empty; skip them. */
2423
2424   if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO ||
2425       c == OP_BRAPOSZERO)
2426     {
2427     code += PRIV(OP_lengths)[c];
2428     do code += GET(code, 1); while (*code == OP_ALT);
2429     c = *code;
2430     continue;
2431     }
2432
2433   /* A nested group that is already marked as "could be empty" can just be
2434   skipped. */
2435
2436   if (c == OP_SBRA  || c == OP_SBRAPOS ||
2437       c == OP_SCBRA || c == OP_SCBRAPOS)
2438     {
2439     do code += GET(code, 1); while (*code == OP_ALT);
2440     c = *code;
2441     continue;
2442     }
2443
2444   /* For other groups, scan the branches. */
2445
2446   if (c == OP_BRA  || c == OP_BRAPOS ||
2447       c == OP_CBRA || c == OP_CBRAPOS ||
2448       c == OP_ONCE || c == OP_ONCE_NC ||
2449       c == OP_COND)
2450     {
2451     BOOL empty_branch;
2452     if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
2453
2454     /* If a conditional group has only one branch, there is a second, implied,
2455     empty branch, so just skip over the conditional, because it could be empty.
2456     Otherwise, scan the individual branches of the group. */
2457
2458     if (c == OP_COND && code[GET(code, 1)] != OP_ALT)
2459       code += GET(code, 1);
2460     else
2461       {
2462       empty_branch = FALSE;
2463       do
2464         {
2465         if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd, NULL))
2466           empty_branch = TRUE;
2467         code += GET(code, 1);
2468         }
2469       while (*code == OP_ALT);
2470       if (!empty_branch) return FALSE;   /* All branches are non-empty */
2471       }
2472
2473     c = *code;
2474     continue;
2475     }
2476
2477   /* Handle the other opcodes */
2478
2479   switch (c)
2480     {
2481     /* Check for quantifiers after a class. XCLASS is used for classes that
2482     cannot be represented just by a bit map. This includes negated single
2483     high-valued characters. The length in PRIV(OP_lengths)[] is zero; the
2484     actual length is stored in the compiled code, so we must update "code"
2485     here. */
2486
2487 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
2488     case OP_XCLASS:
2489     ccode = code += GET(code, 1);
2490     goto CHECK_CLASS_REPEAT;
2491 #endif
2492
2493     case OP_CLASS:
2494     case OP_NCLASS:
2495     ccode = code + PRIV(OP_lengths)[OP_CLASS];
2496
2497 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
2498     CHECK_CLASS_REPEAT:
2499 #endif
2500
2501     switch (*ccode)
2502       {
2503       case OP_CRSTAR:            /* These could be empty; continue */
2504       case OP_CRMINSTAR:
2505       case OP_CRQUERY:
2506       case OP_CRMINQUERY:
2507       case OP_CRPOSSTAR:
2508       case OP_CRPOSQUERY:
2509       break;
2510
2511       default:                   /* Non-repeat => class must match */
2512       case OP_CRPLUS:            /* These repeats aren't empty */
2513       case OP_CRMINPLUS:
2514       case OP_CRPOSPLUS:
2515       return FALSE;
2516
2517       case OP_CRRANGE:
2518       case OP_CRMINRANGE:
2519       case OP_CRPOSRANGE:
2520       if (GET2(ccode, 1) > 0) return FALSE;  /* Minimum > 0 */
2521       break;
2522       }
2523     break;
2524
2525     /* Opcodes that must match a character */
2526
2527     case OP_ANY:
2528     case OP_ALLANY:
2529     case OP_ANYBYTE:
2530
2531     case OP_PROP:
2532     case OP_NOTPROP:
2533     case OP_ANYNL:
2534
2535     case OP_NOT_HSPACE:
2536     case OP_HSPACE:
2537     case OP_NOT_VSPACE:
2538     case OP_VSPACE:
2539     case OP_EXTUNI:
2540
2541     case OP_NOT_DIGIT:
2542     case OP_DIGIT:
2543     case OP_NOT_WHITESPACE:
2544     case OP_WHITESPACE:
2545     case OP_NOT_WORDCHAR:
2546     case OP_WORDCHAR:
2547
2548     case OP_CHAR:
2549     case OP_CHARI:
2550     case OP_NOT:
2551     case OP_NOTI:
2552
2553     case OP_PLUS:
2554     case OP_PLUSI:
2555     case OP_MINPLUS:
2556     case OP_MINPLUSI:
2557
2558     case OP_NOTPLUS:
2559     case OP_NOTPLUSI:
2560     case OP_NOTMINPLUS:
2561     case OP_NOTMINPLUSI:
2562
2563     case OP_POSPLUS:
2564     case OP_POSPLUSI:
2565     case OP_NOTPOSPLUS:
2566     case OP_NOTPOSPLUSI:
2567
2568     case OP_EXACT:
2569     case OP_EXACTI:
2570     case OP_NOTEXACT:
2571     case OP_NOTEXACTI:
2572
2573     case OP_TYPEPLUS:
2574     case OP_TYPEMINPLUS:
2575     case OP_TYPEPOSPLUS:
2576     case OP_TYPEEXACT:
2577
2578     return FALSE;
2579
2580     /* These are going to continue, as they may be empty, but we have to
2581     fudge the length for the \p and \P cases. */
2582
2583     case OP_TYPESTAR:
2584     case OP_TYPEMINSTAR:
2585     case OP_TYPEPOSSTAR:
2586     case OP_TYPEQUERY:
2587     case OP_TYPEMINQUERY:
2588     case OP_TYPEPOSQUERY:
2589     if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
2590     break;
2591
2592     /* Same for these */
2593
2594     case OP_TYPEUPTO:
2595     case OP_TYPEMINUPTO:
2596     case OP_TYPEPOSUPTO:
2597     if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
2598       code += 2;
2599     break;
2600
2601     /* End of branch */
2602
2603     case OP_KET:
2604     case OP_KETRMAX:
2605     case OP_KETRMIN:
2606     case OP_KETRPOS:
2607     case OP_ALT:
2608     return TRUE;
2609
2610     /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
2611     MINUPTO, and POSUPTO and their caseless and negative versions may be
2612     followed by a multibyte character. */
2613
2614 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2615     case OP_STAR:
2616     case OP_STARI:
2617     case OP_NOTSTAR:
2618     case OP_NOTSTARI:
2619
2620     case OP_MINSTAR:
2621     case OP_MINSTARI:
2622     case OP_NOTMINSTAR:
2623     case OP_NOTMINSTARI:
2624
2625     case OP_POSSTAR:
2626     case OP_POSSTARI:
2627     case OP_NOTPOSSTAR:
2628     case OP_NOTPOSSTARI:
2629
2630     case OP_QUERY:
2631     case OP_QUERYI:
2632     case OP_NOTQUERY:
2633     case OP_NOTQUERYI:
2634
2635     case OP_MINQUERY:
2636     case OP_MINQUERYI:
2637     case OP_NOTMINQUERY:
2638     case OP_NOTMINQUERYI:
2639
2640     case OP_POSQUERY:
2641     case OP_POSQUERYI:
2642     case OP_NOTPOSQUERY:
2643     case OP_NOTPOSQUERYI:
2644
2645     if (utf && HAS_EXTRALEN(code[1])) code += GET_EXTRALEN(code[1]);
2646     break;
2647
2648     case OP_UPTO:
2649     case OP_UPTOI:
2650     case OP_NOTUPTO:
2651     case OP_NOTUPTOI:
2652
2653     case OP_MINUPTO:
2654     case OP_MINUPTOI:
2655     case OP_NOTMINUPTO:
2656     case OP_NOTMINUPTOI:
2657
2658     case OP_POSUPTO:
2659     case OP_POSUPTOI:
2660     case OP_NOTPOSUPTO:
2661     case OP_NOTPOSUPTOI:
2662
2663     if (utf && HAS_EXTRALEN(code[1 + IMM2_SIZE])) code += GET_EXTRALEN(code[1 + IMM2_SIZE]);
2664     break;
2665 #endif
2666
2667     /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument
2668     string. */
2669
2670     case OP_MARK:
2671     case OP_PRUNE_ARG:
2672     case OP_SKIP_ARG:
2673     case OP_THEN_ARG:
2674     code += code[1];
2675     break;
2676
2677     /* None of the remaining opcodes are required to match a character. */
2678
2679     default:
2680     break;
2681     }
2682   }
2683
2684 return TRUE;
2685 }
2686
2687
2688
2689 /*************************************************
2690 *    Scan compiled regex for non-emptiness       *
2691 *************************************************/
2692
2693 /* This function is called to check for left recursive calls. We want to check
2694 the current branch of the current pattern to see if it could match the empty
2695 string. If it could, we must look outwards for branches at other levels,
2696 stopping when we pass beyond the bracket which is the subject of the recursion.
2697 This function is called only during the real compile, not during the
2698 pre-compile.
2699
2700 Arguments:
2701   code        points to start of the recursion
2702   endcode     points to where to stop (current RECURSE item)
2703   bcptr       points to the chain of current (unclosed) branch starts
2704   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
2705   cd          pointers to tables etc
2706
2707 Returns:      TRUE if what is matched could be empty
2708 */
2709
2710 static BOOL
2711 could_be_empty(const pcre_uchar *code, const pcre_uchar *endcode,
2712   branch_chain *bcptr, BOOL utf, compile_data *cd)
2713 {
2714 while (bcptr != NULL && bcptr->current_branch >= code)
2715   {
2716   if (!could_be_empty_branch(bcptr->current_branch, endcode, utf, cd, NULL))
2717     return FALSE;
2718   bcptr = bcptr->outer;
2719   }
2720 return TRUE;
2721 }
2722
2723
2724
2725 /*************************************************
2726 *        Base opcode of repeated opcodes         *
2727 *************************************************/
2728
2729 /* Returns the base opcode for repeated single character type opcodes. If the
2730 opcode is not a repeated character type, it returns with the original value.
2731
2732 Arguments:  c opcode
2733 Returns:    base opcode for the type
2734 */
2735
2736 static pcre_uchar
2737 get_repeat_base(pcre_uchar c)
2738 {
2739 return (c > OP_TYPEPOSUPTO)? c :
2740        (c >= OP_TYPESTAR)?   OP_TYPESTAR :
2741        (c >= OP_NOTSTARI)?   OP_NOTSTARI :
2742        (c >= OP_NOTSTAR)?    OP_NOTSTAR :
2743        (c >= OP_STARI)?      OP_STARI :
2744                              OP_STAR;
2745 }
2746
2747
2748
2749 #ifdef SUPPORT_UCP
2750 /*************************************************
2751 *        Check a character and a property        *
2752 *************************************************/
2753
2754 /* This function is called by check_auto_possessive() when a property item
2755 is adjacent to a fixed character.
2756
2757 Arguments:
2758   c            the character
2759   ptype        the property type
2760   pdata        the data for the type
2761   negated      TRUE if it's a negated property (\P or \p{^)
2762
2763 Returns:       TRUE if auto-possessifying is OK
2764 */
2765
2766 static BOOL
2767 check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata,
2768   BOOL negated)
2769 {
2770 const pcre_uint32 *p;
2771 const ucd_record *prop = GET_UCD(c);
2772
2773 switch(ptype)
2774   {
2775   case PT_LAMP:
2776   return (prop->chartype == ucp_Lu ||
2777           prop->chartype == ucp_Ll ||
2778           prop->chartype == ucp_Lt) == negated;
2779
2780   case PT_GC:
2781   return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;
2782
2783   case PT_PC:
2784   return (pdata == prop->chartype) == negated;
2785
2786   case PT_SC:
2787   return (pdata == prop->script) == negated;
2788
2789   /* These are specials */
2790
2791   case PT_ALNUM:
2792   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2793           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;
2794
2795   /* Perl space used to exclude VT, but from Perl 5.18 it is included, which
2796   means that Perl space and POSIX space are now identical. PCRE was changed
2797   at release 8.34. */
2798
2799   case PT_SPACE:    /* Perl space */
2800   case PT_PXSPACE:  /* POSIX space */
2801   switch(c)
2802     {
2803     HSPACE_CASES:
2804     VSPACE_CASES:
2805     return negated;
2806
2807     default:
2808     return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated;
2809     }
2810   break;  /* Control never reaches here */
2811
2812   case PT_WORD:
2813   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2814           PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
2815           c == CHAR_UNDERSCORE) == negated;
2816
2817   case PT_CLIST:
2818   p = PRIV(ucd_caseless_sets) + prop->caseset;
2819   for (;;)
2820     {
2821     if (c < *p) return !negated;
2822     if (c == *p++) return negated;
2823     }
2824   break;  /* Control never reaches here */
2825   }
2826
2827 return FALSE;
2828 }
2829 #endif  /* SUPPORT_UCP */
2830
2831
2832
2833 /*************************************************
2834 *        Fill the character property list        *
2835 *************************************************/
2836
2837 /* Checks whether the code points to an opcode that can take part in auto-
2838 possessification, and if so, fills a list with its properties.
2839
2840 Arguments:
2841   code        points to start of expression
2842   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
2843   fcc         points to case-flipping table
2844   list        points to output list
2845               list[0] will be filled with the opcode
2846               list[1] will be non-zero if this opcode
2847                 can match an empty character string
2848               list[2..7] depends on the opcode
2849
2850 Returns:      points to the start of the next opcode if *code is accepted
2851               NULL if *code is not accepted
2852 */
2853
2854 static const pcre_uchar *
2855 get_chr_property_list(const pcre_uchar *code, BOOL utf,
2856   const pcre_uint8 *fcc, pcre_uint32 *list)
2857 {
2858 pcre_uchar c = *code;
2859 pcre_uchar base;
2860 const pcre_uchar *end;
2861 pcre_uint32 chr;
2862
2863 #ifdef SUPPORT_UCP
2864 pcre_uint32 *clist_dest;
2865 const pcre_uint32 *clist_src;
2866 #else
2867 utf = utf;  /* Suppress "unused parameter" compiler warning */
2868 #endif
2869
2870 list[0] = c;
2871 list[1] = FALSE;
2872 code++;
2873
2874 if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
2875   {
2876   base = get_repeat_base(c);
2877   c -= (base - OP_STAR);
2878
2879   if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO)
2880     code += IMM2_SIZE;
2881
2882   list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT && c != OP_POSPLUS);
2883
2884   switch(base)
2885     {
2886     case OP_STAR:
2887     list[0] = OP_CHAR;
2888     break;
2889
2890     case OP_STARI:
2891     list[0] = OP_CHARI;
2892     break;
2893
2894     case OP_NOTSTAR:
2895     list[0] = OP_NOT;
2896     break;
2897
2898     case OP_NOTSTARI:
2899     list[0] = OP_NOTI;
2900     break;
2901
2902     case OP_TYPESTAR:
2903     list[0] = *code;
2904     code++;
2905     break;
2906     }
2907   c = list[0];
2908   }
2909
2910 switch(c)
2911   {
2912   case OP_NOT_DIGIT:
2913   case OP_DIGIT:
2914   case OP_NOT_WHITESPACE:
2915   case OP_WHITESPACE:
2916   case OP_NOT_WORDCHAR:
2917   case OP_WORDCHAR:
2918   case OP_ANY:
2919   case OP_ALLANY:
2920   case OP_ANYNL:
2921   case OP_NOT_HSPACE:
2922   case OP_HSPACE:
2923   case OP_NOT_VSPACE:
2924   case OP_VSPACE:
2925   case OP_EXTUNI:
2926   case OP_EODN:
2927   case OP_EOD:
2928   case OP_DOLL:
2929   case OP_DOLLM:
2930   return code;
2931
2932   case OP_CHAR:
2933   case OP_NOT:
2934   GETCHARINCTEST(chr, code);
2935   list[2] = chr;
2936   list[3] = NOTACHAR;
2937   return code;
2938
2939   case OP_CHARI:
2940   case OP_NOTI:
2941   list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT;
2942   GETCHARINCTEST(chr, code);
2943   list[2] = chr;
2944
2945 #ifdef SUPPORT_UCP
2946   if (chr < 128 || (chr < 256 && !utf))
2947     list[3] = fcc[chr];
2948   else
2949     list[3] = UCD_OTHERCASE(chr);
2950 #elif defined SUPPORT_UTF || !defined COMPILE_PCRE8
2951   list[3] = (chr < 256) ? fcc[chr] : chr;
2952 #else
2953   list[3] = fcc[chr];
2954 #endif
2955
2956   /* The othercase might be the same value. */
2957
2958   if (chr == list[3])
2959     list[3] = NOTACHAR;
2960   else
2961     list[4] = NOTACHAR;
2962   return code;
2963
2964 #ifdef SUPPORT_UCP
2965   case OP_PROP:
2966   case OP_NOTPROP:
2967   if (code[0] != PT_CLIST)
2968     {
2969     list[2] = code[0];
2970     list[3] = code[1];
2971     return code + 2;
2972     }
2973
2974   /* Convert only if we have enough space. */
2975
2976   clist_src = PRIV(ucd_caseless_sets) + code[1];
2977   clist_dest = list + 2;
2978   code += 2;
2979
2980   do {
2981      if (clist_dest >= list + 8)
2982        {
2983        /* Early return if there is not enough space. This should never
2984        happen, since all clists are shorter than 5 character now. */
2985        list[2] = code[0];
2986        list[3] = code[1];
2987        return code;
2988        }
2989      *clist_dest++ = *clist_src;
2990      }
2991   while(*clist_src++ != NOTACHAR);
2992
2993   /* All characters are stored. The terminating NOTACHAR
2994   is copied form the clist itself. */
2995
2996   list[0] = (c == OP_PROP) ? OP_CHAR : OP_NOT;
2997   return code;
2998 #endif
2999
3000   case OP_NCLASS:
3001   case OP_CLASS:
3002 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3003   case OP_XCLASS:
3004   if (c == OP_XCLASS)
3005     end = code + GET(code, 0) - 1;
3006   else
3007 #endif
3008     end = code + 32 / sizeof(pcre_uchar);
3009
3010   switch(*end)
3011     {
3012     case OP_CRSTAR:
3013     case OP_CRMINSTAR:
3014     case OP_CRQUERY:
3015     case OP_CRMINQUERY:
3016     case OP_CRPOSSTAR:
3017     case OP_CRPOSQUERY:
3018     list[1] = TRUE;
3019     end++;
3020     break;
3021
3022     case OP_CRPLUS:
3023     case OP_CRMINPLUS:
3024     case OP_CRPOSPLUS:
3025     end++;
3026     break;
3027
3028     case OP_CRRANGE:
3029     case OP_CRMINRANGE:
3030     case OP_CRPOSRANGE:
3031     list[1] = (GET2(end, 1) == 0);
3032     end += 1 + 2 * IMM2_SIZE;
3033     break;
3034     }
3035   list[2] = end - code;
3036   return end;
3037   }
3038 return NULL;    /* Opcode not accepted */
3039 }
3040
3041
3042
3043 /*************************************************
3044 *    Scan further character sets for match       *
3045 *************************************************/
3046
3047 /* Checks whether the base and the current opcode have a common character, in
3048 which case the base cannot be possessified.
3049
3050 Arguments:
3051   code        points to the byte code
3052   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
3053   cd          static compile data
3054   base_list   the data list of the base opcode
3055
3056 Returns:      TRUE if the auto-possessification is possible
3057 */
3058
3059 static BOOL
3060 compare_opcodes(const pcre_uchar *code, BOOL utf, const compile_data *cd,
3061   const pcre_uint32 *base_list, const pcre_uchar *base_end)
3062 {
3063 pcre_uchar c;
3064 pcre_uint32 list[8];
3065 const pcre_uint32 *chr_ptr;
3066 const pcre_uint32 *ochr_ptr;
3067 const pcre_uint32 *list_ptr;
3068 const pcre_uchar *next_code;
3069 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3070 const pcre_uchar *xclass_flags;
3071 #endif
3072 const pcre_uint8 *class_bitset;
3073 const pcre_uint8 *set1, *set2, *set_end;
3074 pcre_uint32 chr;
3075 BOOL accepted, invert_bits;
3076
3077 /* Note: the base_list[1] contains whether the current opcode has greedy
3078 (represented by a non-zero value) quantifier. This is a different from
3079 other character type lists, which stores here that the character iterator
3080 matches to an empty string (also represented by a non-zero value). */
3081
3082 for(;;)
3083   {
3084   /* All operations move the code pointer forward.
3085   Therefore infinite recursions are not possible. */
3086
3087   c = *code;
3088
3089   /* Skip over callouts */
3090
3091   if (c == OP_CALLOUT)
3092     {
3093     code += PRIV(OP_lengths)[c];
3094     continue;
3095     }
3096
3097   if (c == OP_ALT)
3098     {
3099     do code += GET(code, 1); while (*code == OP_ALT);
3100     c = *code;
3101     }
3102
3103   switch(c)
3104     {
3105     case OP_END:
3106     case OP_KETRPOS:
3107     /* TRUE only in greedy case. The non-greedy case could be replaced by
3108     an OP_EXACT, but it is probably not worth it. (And note that OP_EXACT
3109     uses more memory, which we cannot get at this stage.) */
3110
3111     return base_list[1] != 0;
3112
3113     case OP_KET:
3114     /* If the bracket is capturing, and referenced by an OP_RECURSE, or
3115     it is an atomic sub-pattern (assert, once, etc.) the non-greedy case
3116     cannot be converted to a possessive form. */
3117
3118     if (base_list[1] == 0) return FALSE;
3119
3120     switch(*(code - GET(code, 1)))
3121       {
3122       case OP_ASSERT:
3123       case OP_ASSERT_NOT:
3124       case OP_ASSERTBACK:
3125       case OP_ASSERTBACK_NOT:
3126       case OP_ONCE:
3127       case OP_ONCE_NC:
3128       /* Atomic sub-patterns and assertions can always auto-possessify their
3129       last iterator. */
3130       return TRUE;
3131       }
3132
3133     code += PRIV(OP_lengths)[c];
3134     continue;
3135
3136     case OP_ONCE:
3137     case OP_ONCE_NC:
3138     case OP_BRA:
3139     case OP_CBRA:
3140     next_code = code + GET(code, 1);
3141     code += PRIV(OP_lengths)[c];
3142
3143     while (*next_code == OP_ALT)
3144       {
3145       if (!compare_opcodes(code, utf, cd, base_list, base_end)) return FALSE;
3146       code = next_code + 1 + LINK_SIZE;
3147       next_code += GET(next_code, 1);
3148       }
3149     continue;
3150
3151     case OP_BRAZERO:
3152     case OP_BRAMINZERO:
3153
3154     next_code = code + 1;
3155     if (*next_code != OP_BRA && *next_code != OP_CBRA
3156         && *next_code != OP_ONCE && *next_code != OP_ONCE_NC) return FALSE;
3157
3158     do next_code += GET(next_code, 1); while (*next_code == OP_ALT);
3159
3160     /* The bracket content will be checked by the
3161     OP_BRA/OP_CBRA case above. */
3162     next_code += 1 + LINK_SIZE;
3163     if (!compare_opcodes(next_code, utf, cd, base_list, base_end))
3164       return FALSE;
3165
3166     code += PRIV(OP_lengths)[c];
3167     continue;
3168     }
3169
3170   /* Check for a supported opcode, and load its properties. */
3171
3172   code = get_chr_property_list(code, utf, cd->fcc, list);
3173   if (code == NULL) return FALSE;    /* Unsupported */
3174
3175   /* If either opcode is a small character list, set pointers for comparing
3176   characters from that list with another list, or with a property. */
3177
3178   if (base_list[0] == OP_CHAR)
3179     {
3180     chr_ptr = base_list + 2;
3181     list_ptr = list;
3182     }
3183   else if (list[0] == OP_CHAR)
3184     {
3185     chr_ptr = list + 2;
3186     list_ptr = base_list;
3187     }
3188
3189   /* Character bitsets can also be compared to certain opcodes. */
3190
3191   else if (base_list[0] == OP_CLASS || list[0] == OP_CLASS
3192 #ifdef COMPILE_PCRE8
3193       /* In 8 bit, non-UTF mode, OP_CLASS and OP_NCLASS are the same. */
3194       || (!utf && (base_list[0] == OP_NCLASS || list[0] == OP_NCLASS))
3195 #endif
3196       )
3197     {
3198 #ifdef COMPILE_PCRE8
3199     if (base_list[0] == OP_CLASS || (!utf && base_list[0] == OP_NCLASS))
3200 #else
3201     if (base_list[0] == OP_CLASS)
3202 #endif
3203       {
3204       set1 = (pcre_uint8 *)(base_end - base_list[2]);
3205       list_ptr = list;
3206       }
3207     else
3208       {
3209       set1 = (pcre_uint8 *)(code - list[2]);
3210       list_ptr = base_list;
3211       }
3212
3213     invert_bits = FALSE;
3214     switch(list_ptr[0])
3215       {
3216       case OP_CLASS:
3217       case OP_NCLASS:
3218       set2 = (pcre_uint8 *)
3219         ((list_ptr == list ? code : base_end) - list_ptr[2]);
3220       break;
3221
3222 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3223       case OP_XCLASS:
3224       xclass_flags = (list_ptr == list ? code : base_end) - list_ptr[2] + LINK_SIZE;
3225       if ((*xclass_flags & XCL_HASPROP) != 0) return FALSE;
3226       if ((*xclass_flags & XCL_MAP) == 0)
3227         {
3228         /* No bits are set for characters < 256. */
3229         if (list[1] == 0) return TRUE;
3230         /* Might be an empty repeat. */
3231         continue;
3232         }
3233       set2 = (pcre_uint8 *)(xclass_flags + 1);
3234       break;
3235 #endif
3236
3237       case OP_NOT_DIGIT:
3238       invert_bits = TRUE;
3239       /* Fall through */
3240       case OP_DIGIT:
3241       set2 = (pcre_uint8 *)(cd->cbits + cbit_digit);
3242       break;
3243
3244       case OP_NOT_WHITESPACE:
3245       invert_bits = TRUE;
3246       /* Fall through */
3247       case OP_WHITESPACE:
3248       set2 = (pcre_uint8 *)(cd->cbits + cbit_space);
3249       break;
3250
3251       case OP_NOT_WORDCHAR:
3252       invert_bits = TRUE;
3253       /* Fall through */
3254       case OP_WORDCHAR:
3255       set2 = (pcre_uint8 *)(cd->cbits + cbit_word);
3256       break;
3257
3258       default:
3259       return FALSE;
3260       }
3261
3262     /* Because the sets are unaligned, we need
3263     to perform byte comparison here. */
3264     set_end = set1 + 32;
3265     if (invert_bits)
3266       {
3267       do
3268         {
3269         if ((*set1++ & ~(*set2++)) != 0) return FALSE;
3270         }
3271       while (set1 < set_end);
3272       }
3273     else
3274       {
3275       do
3276         {
3277         if ((*set1++ & *set2++) != 0) return FALSE;
3278         }
3279       while (set1 < set_end);
3280       }
3281
3282     if (list[1] == 0) return TRUE;
3283     /* Might be an empty repeat. */
3284     continue;
3285     }
3286
3287   /* Some property combinations also acceptable. Unicode property opcodes are
3288   processed specially; the rest can be handled with a lookup table. */
3289
3290   else
3291     {
3292     pcre_uint32 leftop, rightop;
3293
3294     leftop = base_list[0];
3295     rightop = list[0];
3296
3297 #ifdef SUPPORT_UCP
3298     accepted = FALSE; /* Always set in non-unicode case. */
3299     if (leftop == OP_PROP || leftop == OP_NOTPROP)
3300       {
3301       if (rightop == OP_EOD)
3302         accepted = TRUE;
3303       else if (rightop == OP_PROP || rightop == OP_NOTPROP)
3304         {
3305         int n;
3306         const pcre_uint8 *p;
3307         BOOL same = leftop == rightop;
3308         BOOL lisprop = leftop == OP_PROP;
3309         BOOL risprop = rightop == OP_PROP;
3310         BOOL bothprop = lisprop && risprop;
3311
3312         /* There's a table that specifies how each combination is to be
3313         processed:
3314           0   Always return FALSE (never auto-possessify)
3315           1   Character groups are distinct (possessify if both are OP_PROP)
3316           2   Check character categories in the same group (general or particular)
3317           3   Return TRUE if the two opcodes are not the same
3318           ... see comments below
3319         */
3320
3321         n = propposstab[base_list[2]][list[2]];
3322         switch(n)
3323           {
3324           case 0: break;
3325           case 1: accepted = bothprop; break;
3326           case 2: accepted = (base_list[3] == list[3]) != same; break;
3327           case 3: accepted = !same; break;
3328
3329           case 4:  /* Left general category, right particular category */
3330           accepted = risprop && catposstab[base_list[3]][list[3]] == same;
3331           break;
3332
3333           case 5:  /* Right general category, left particular category */
3334           accepted = lisprop && catposstab[list[3]][base_list[3]] == same;
3335           break;
3336
3337           /* This code is logically tricky. Think hard before fiddling with it.
3338           The posspropstab table has four entries per row. Each row relates to
3339           one of PCRE's special properties such as ALNUM or SPACE or WORD.
3340           Only WORD actually needs all four entries, but using repeats for the
3341           others means they can all use the same code below.
3342
3343           The first two entries in each row are Unicode general categories, and
3344           apply always, because all the characters they include are part of the
3345           PCRE character set. The third and fourth entries are a general and a
3346           particular category, respectively, that include one or more relevant
3347           characters. One or the other is used, depending on whether the check
3348           is for a general or a particular category. However, in both cases the
3349           category contains more characters than the specials that are defined
3350           for the property being tested against. Therefore, it cannot be used
3351           in a NOTPROP case.
3352
3353           Example: the row for WORD contains ucp_L, ucp_N, ucp_P, ucp_Po.
3354           Underscore is covered by ucp_P or ucp_Po. */
3355
3356           case 6:  /* Left alphanum vs right general category */
3357           case 7:  /* Left space vs right general category */
3358           case 8:  /* Left word vs right general category */
3359           p = posspropstab[n-6];
3360           accepted = risprop && lisprop ==
3361             (list[3] != p[0] &&
3362              list[3] != p[1] &&
3363             (list[3] != p[2] || !lisprop));
3364           break;
3365
3366           case 9:   /* Right alphanum vs left general category */
3367           case 10:  /* Right space vs left general category */
3368           case 11:  /* Right word vs left general category */
3369           p = posspropstab[n-9];
3370           accepted = lisprop && risprop ==
3371             (base_list[3] != p[0] &&
3372              base_list[3] != p[1] &&
3373             (base_list[3] != p[2] || !risprop));
3374           break;
3375
3376           case 12:  /* Left alphanum vs right particular category */
3377           case 13:  /* Left space vs right particular category */
3378           case 14:  /* Left word vs right particular category */
3379           p = posspropstab[n-12];
3380           accepted = risprop && lisprop ==
3381             (catposstab[p[0]][list[3]] &&
3382              catposstab[p[1]][list[3]] &&
3383             (list[3] != p[3] || !lisprop));
3384           break;
3385
3386           case 15:  /* Right alphanum vs left particular category */
3387           case 16:  /* Right space vs left particular category */
3388           case 17:  /* Right word vs left particular category */
3389           p = posspropstab[n-15];
3390           accepted = lisprop && risprop ==
3391             (catposstab[p[0]][base_list[3]] &&
3392              catposstab[p[1]][base_list[3]] &&
3393             (base_list[3] != p[3] || !risprop));
3394           break;
3395           }
3396         }
3397       }
3398
3399     else
3400 #endif  /* SUPPORT_UCP */
3401
3402     accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP &&
3403            rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP &&
3404            autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP];
3405
3406     if (!accepted)
3407       return FALSE;
3408
3409     if (list[1] == 0) return TRUE;
3410     /* Might be an empty repeat. */
3411     continue;
3412     }
3413
3414   /* Control reaches here only if one of the items is a small character list.
3415   All characters are checked against the other side. */
3416
3417   do
3418     {
3419     chr = *chr_ptr;
3420
3421     switch(list_ptr[0])
3422       {
3423       case OP_CHAR:
3424       ochr_ptr = list_ptr + 2;
3425       do
3426         {
3427         if (chr == *ochr_ptr) return FALSE;
3428         ochr_ptr++;
3429         }
3430       while(*ochr_ptr != NOTACHAR);
3431       break;
3432
3433       case OP_NOT:
3434       ochr_ptr = list_ptr + 2;
3435       do
3436         {
3437         if (chr == *ochr_ptr)
3438           break;
3439         ochr_ptr++;
3440         }
3441       while(*ochr_ptr != NOTACHAR);
3442       if (*ochr_ptr == NOTACHAR) return FALSE;   /* Not found */
3443       break;
3444
3445       /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not*
3446       set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
3447
3448       case OP_DIGIT:
3449       if (chr < 256 && (cd->ctypes[chr] & ctype_digit) != 0) return FALSE;
3450       break;
3451
3452       case OP_NOT_DIGIT:
3453       if (chr > 255 || (cd->ctypes[chr] & ctype_digit) == 0) return FALSE;
3454       break;
3455
3456       case OP_WHITESPACE:
3457       if (chr < 256 && (cd->ctypes[chr] & ctype_space) != 0) return FALSE;
3458       break;
3459
3460       case OP_NOT_WHITESPACE:
3461       if (chr > 255 || (cd->ctypes[chr] & ctype_space) == 0) return FALSE;
3462       break;
3463
3464       case OP_WORDCHAR:
3465       if (chr < 255 && (cd->ctypes[chr] & ctype_word) != 0) return FALSE;
3466       break;
3467
3468       case OP_NOT_WORDCHAR:
3469       if (chr > 255 || (cd->ctypes[chr] & ctype_word) == 0) return FALSE;
3470       break;
3471
3472       case OP_HSPACE:
3473       switch(chr)
3474         {
3475         HSPACE_CASES: return FALSE;
3476         default: break;
3477         }
3478       break;
3479
3480       case OP_NOT_HSPACE:
3481       switch(chr)
3482         {
3483         HSPACE_CASES: break;
3484         default: return FALSE;
3485         }
3486       break;
3487
3488       case OP_ANYNL:
3489       case OP_VSPACE:
3490       switch(chr)
3491         {
3492         VSPACE_CASES: return FALSE;
3493         default: break;
3494         }
3495       break;
3496
3497       case OP_NOT_VSPACE:
3498       switch(chr)
3499         {
3500         VSPACE_CASES: break;
3501         default: return FALSE;
3502         }
3503       break;
3504
3505       case OP_DOLL:
3506       case OP_EODN:
3507       switch (chr)
3508         {
3509         case CHAR_CR:
3510         case CHAR_LF:
3511         case CHAR_VT:
3512         case CHAR_FF:
3513         case CHAR_NEL:
3514 #ifndef EBCDIC
3515         case 0x2028:
3516         case 0x2029:
3517 #endif  /* Not EBCDIC */
3518         return FALSE;
3519         }
3520       break;
3521
3522       case OP_EOD:    /* Can always possessify before \z */
3523       break;
3524
3525 #ifdef SUPPORT_UCP
3526       case OP_PROP:
3527       case OP_NOTPROP:
3528       if (!check_char_prop(chr, list_ptr[2], list_ptr[3],
3529             list_ptr[0] == OP_NOTPROP))
3530         return FALSE;
3531       break;
3532 #endif
3533
3534       case OP_NCLASS:
3535       if (chr > 255) return FALSE;
3536       /* Fall through */
3537
3538       case OP_CLASS:
3539       if (chr > 255) break;
3540       class_bitset = (pcre_uint8 *)
3541         ((list_ptr == list ? code : base_end) - list_ptr[2]);
3542       if ((class_bitset[chr >> 3] & (1 << (chr & 7))) != 0) return FALSE;
3543       break;
3544
3545 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3546       case OP_XCLASS:
3547       if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) -
3548           list_ptr[2] + LINK_SIZE, utf)) return FALSE;
3549       break;
3550 #endif
3551
3552       default:
3553       return FALSE;
3554       }
3555
3556     chr_ptr++;
3557     }
3558   while(*chr_ptr != NOTACHAR);
3559
3560   /* At least one character must be matched from this opcode. */
3561
3562   if (list[1] == 0) return TRUE;
3563   }
3564
3565 /* Control never reaches here. There used to be a fail-save return FALSE; here,
3566 but some compilers complain about an unreachable statement. */
3567
3568 }
3569
3570
3571
3572 /*************************************************
3573 *    Scan compiled regex for auto-possession     *
3574 *************************************************/
3575
3576 /* Replaces single character iterations with their possessive alternatives
3577 if appropriate. This function modifies the compiled opcode!
3578
3579 Arguments:
3580   code        points to start of the byte code
3581   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
3582   cd          static compile data
3583
3584 Returns:      nothing
3585 */
3586
3587 static void
3588 auto_possessify(pcre_uchar *code, BOOL utf, const compile_data *cd)
3589 {
3590 register pcre_uchar c;
3591 const pcre_uchar *end;
3592 pcre_uchar *repeat_opcode;
3593 pcre_uint32 list[8];
3594
3595 for (;;)
3596   {
3597   c = *code;
3598
3599   if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
3600     {
3601     c -= get_repeat_base(c) - OP_STAR;
3602     end = (c <= OP_MINUPTO) ?
3603       get_chr_property_list(code, utf, cd->fcc, list) : NULL;
3604     list[1] = c == OP_STAR || c == OP_PLUS || c == OP_QUERY || c == OP_UPTO;
3605
3606     if (end != NULL && compare_opcodes(end, utf, cd, list, end))
3607       {
3608       switch(c)
3609         {
3610         case OP_STAR:
3611         *code += OP_POSSTAR - OP_STAR;
3612         break;
3613
3614         case OP_MINSTAR:
3615         *code += OP_POSSTAR - OP_MINSTAR;
3616         break;
3617
3618         case OP_PLUS:
3619         *code += OP_POSPLUS - OP_PLUS;
3620         break;
3621
3622         case OP_MINPLUS:
3623         *code += OP_POSPLUS - OP_MINPLUS;
3624         break;
3625
3626         case OP_QUERY:
3627         *code += OP_POSQUERY - OP_QUERY;
3628         break;
3629
3630         case OP_MINQUERY:
3631         *code += OP_POSQUERY - OP_MINQUERY;
3632         break;
3633
3634         case OP_UPTO:
3635         *code += OP_POSUPTO - OP_UPTO;
3636         break;
3637
3638         case OP_MINUPTO:
3639         *code += OP_POSUPTO - OP_MINUPTO;
3640         break;
3641         }
3642       }
3643     c = *code;
3644     }
3645   else if (c == OP_CLASS || c == OP_NCLASS || c == OP_XCLASS)
3646     {
3647 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3648     if (c == OP_XCLASS)
3649       repeat_opcode = code + GET(code, 1);
3650     else
3651 #endif
3652       repeat_opcode = code + 1 + (32 / sizeof(pcre_uchar));
3653
3654     c = *repeat_opcode;
3655     if (c >= OP_CRSTAR && c <= OP_CRMINRANGE)
3656       {
3657       /* end must not be NULL. */
3658       end = get_chr_property_list(code, utf, cd->fcc, list);
3659
3660       list[1] = (c & 1) == 0;
3661
3662       if (compare_opcodes(end, utf, cd, list, end))
3663         {
3664         switch (c)
3665           {
3666           case OP_CRSTAR:
3667           case OP_CRMINSTAR:
3668           *repeat_opcode = OP_CRPOSSTAR;
3669           break;
3670
3671           case OP_CRPLUS:
3672           case OP_CRMINPLUS:
3673           *repeat_opcode = OP_CRPOSPLUS;
3674           break;
3675
3676           case OP_CRQUERY:
3677           case OP_CRMINQUERY:
3678           *repeat_opcode = OP_CRPOSQUERY;
3679           break;
3680
3681           case OP_CRRANGE:
3682           case OP_CRMINRANGE:
3683           *repeat_opcode = OP_CRPOSRANGE;
3684           break;
3685           }
3686         }
3687       }
3688     c = *code;
3689     }
3690
3691   switch(c)
3692     {
3693     case OP_END:
3694     return;
3695
3696     case OP_TYPESTAR:
3697     case OP_TYPEMINSTAR:
3698     case OP_TYPEPLUS:
3699     case OP_TYPEMINPLUS:
3700     case OP_TYPEQUERY:
3701     case OP_TYPEMINQUERY:
3702     case OP_TYPEPOSSTAR:
3703     case OP_TYPEPOSPLUS:
3704     case OP_TYPEPOSQUERY:
3705     if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
3706     break;
3707