6bb1de3610011e370c5eae9ae53b0ca495f61674
[ossec-hids.git] / pcre2_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      Original API code Copyright (c) 1997-2012 University of Cambridge
10           New API code Copyright (c) 2016-2018 University of Cambridge
11
12 -----------------------------------------------------------------------------
13 Redistribution and use in source and binary forms, with or without
14 modification, are permitted provided that the following conditions are met:
15
16     * Redistributions of source code must retain the above copyright notice,
17       this list of conditions and the following disclaimer.
18
19     * Redistributions in binary form must reproduce the above copyright
20       notice, this list of conditions and the following disclaimer in the
21       documentation and/or other materials provided with the distribution.
22
23     * Neither the name of the University of Cambridge nor the names of its
24       contributors may be used to endorse or promote products derived from
25       this software without specific prior written permission.
26
27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 POSSIBILITY OF SUCH DAMAGE.
38 -----------------------------------------------------------------------------
39 */
40
41
42 #ifdef HAVE_CONFIG_H
43 #include "config.h"
44 #endif
45
46 #define NLBLOCK cb             /* Block containing newline information */
47 #define PSSTART start_pattern  /* Field containing processed string start */
48 #define PSEND   end_pattern    /* Field containing processed string end */
49
50 #include "pcre2_internal.h"
51
52 /* In rare error cases debugging might require calling pcre2_printint(). */
53
54 #if 0
55 #ifdef EBCDIC
56 #define PRINTABLE(c) ((c) >= 64 && (c) < 255)
57 #else
58 #define PRINTABLE(c) ((c) >= 32 && (c) < 127)
59 #endif
60 #include "pcre2_printint.c"
61 #define DEBUG_CALL_PRINTINT
62 #endif
63
64 /* Other debugging code can be enabled by these defines. */
65
66 /* #define DEBUG_SHOW_CAPTURES */
67 /* #define DEBUG_SHOW_PARSED */
68
69 /* There are a few things that vary with different code unit sizes. Handle them
70 by defining macros in order to minimize #if usage. */
71
72 #if PCRE2_CODE_UNIT_WIDTH == 8
73 #define STRING_UTFn_RIGHTPAR     STRING_UTF8_RIGHTPAR, 5
74 #define XDIGIT(c)                xdigitab[c]
75
76 #else  /* Either 16-bit or 32-bit */
77 #define XDIGIT(c)                (MAX_255(c)? xdigitab[c] : 0xff)
78
79 #if PCRE2_CODE_UNIT_WIDTH == 16
80 #define STRING_UTFn_RIGHTPAR     STRING_UTF16_RIGHTPAR, 6
81
82 #else  /* 32-bit */
83 #define STRING_UTFn_RIGHTPAR     STRING_UTF32_RIGHTPAR, 6
84 #endif
85 #endif
86
87 /* Macros to store and retrieve a PCRE2_SIZE value in the parsed pattern, which
88 consists of uint32_t elements. Assume that if uint32_t can't hold it, two of
89 them will be able to (i.e. assume a 64-bit world). */
90
91 #if PCRE2_SIZE_MAX <= UINT32_MAX
92 #define PUTOFFSET(s,p) *p++ = s
93 #define GETOFFSET(s,p) s = *p++
94 #define GETPLUSOFFSET(s,p) s = *(++p)
95 #define READPLUSOFFSET(s,p) s = p[1]
96 #define SKIPOFFSET(p) p++
97 #define SIZEOFFSET 1
98 #else
99 #define PUTOFFSET(s,p) \
100   { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); }
101 #define GETOFFSET(s,p) \
102   { s = ((PCRE2_SIZE)p[0] << 32) | (PCRE2_SIZE)p[1]; p += 2; }
103 #define GETPLUSOFFSET(s,p) \
104   { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; }
105 #define READPLUSOFFSET(s,p) \
106   { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; }
107 #define SKIPOFFSET(p) p += 2
108 #define SIZEOFFSET 2
109 #endif
110
111 /* Macros for manipulating elements of the parsed pattern vector. */
112
113 #define META_CODE(x)   (x & 0xffff0000u)
114 #define META_DATA(x)   (x & 0x0000ffffu)
115 #define META_DIFF(x,y) ((x-y)>>16)
116
117 /* Function definitions to allow mutual recursion */
118
119 #ifdef SUPPORT_UNICODE
120 static unsigned int
121   add_list_to_class_internal(uint8_t *, PCRE2_UCHAR **, uint32_t,
122     compile_block *, const uint32_t *, unsigned int);
123 #endif
124
125 static int
126   compile_regex(uint32_t, PCRE2_UCHAR **, uint32_t **, int *, uint32_t,
127     uint32_t *, int32_t *, uint32_t *, int32_t *, branch_chain *,
128     compile_block *, PCRE2_SIZE *);
129
130 static int
131   get_branchlength(uint32_t **, int *, int *, parsed_recurse_check *,
132     compile_block *);
133
134 static BOOL
135   set_lookbehind_lengths(uint32_t **, int *, int *, parsed_recurse_check *,
136     compile_block *);
137
138
139
140 /*************************************************
141 *      Code parameters and static tables         *
142 *************************************************/
143
144 #define MAX_GROUP_NUMBER   65535u
145 #define MAX_REPEAT_COUNT   65535u
146 #define REPEAT_UNLIMITED   (MAX_REPEAT_COUNT+1)
147
148 /* COMPILE_WORK_SIZE specifies the size of stack workspace, which is used in
149 different ways in the different pattern scans. The parsing and group-
150 identifying pre-scan uses it to handle nesting, and needs it to be 16-bit
151 aligned for this. Having defined the size in code units, we set up
152 C16_WORK_SIZE as the number of elements in the 16-bit vector.
153
154 During the first compiling phase, when determining how much memory is required,
155 the regex is partly compiled into this space, but the compiled parts are
156 discarded as soon as they can be, so that hopefully there will never be an
157 overrun. The code does, however, check for an overrun, which can occur for
158 pathological patterns. The size of the workspace depends on LINK_SIZE because
159 the length of compiled items varies with this.
160
161 In the real compile phase, this workspace is not currently used. */
162
163 #define COMPILE_WORK_SIZE (3000*LINK_SIZE)   /* Size in code units */
164
165 #define C16_WORK_SIZE \
166   ((COMPILE_WORK_SIZE * sizeof(PCRE2_UCHAR))/sizeof(uint16_t))
167
168 /* A uint32_t vector is used for caching information about the size of
169 capturing groups, to improve performance. A default is created on the stack of
170 this size. */
171
172 #define GROUPINFO_DEFAULT_SIZE 256
173
174 /* The overrun tests check for a slightly smaller size so that they detect the
175 overrun before it actually does run off the end of the data block. */
176
177 #define WORK_SIZE_SAFETY_MARGIN (100)
178
179 /* This value determines the size of the initial vector that is used for
180 remembering named groups during the pre-compile. It is allocated on the stack,
181 but if it is too small, it is expanded, in a similar way to the workspace. The
182 value is the number of slots in the list. */
183
184 #define NAMED_GROUP_LIST_SIZE  20
185
186 /* The pre-compiling pass over the pattern creates a parsed pattern in a vector
187 of uint32_t. For short patterns this lives on the stack, with this size. Heap
188 memory is used for longer patterns. */
189
190 #define PARSED_PATTERN_DEFAULT_SIZE 1024
191
192 /* Maximum length value to check against when making sure that the variable
193 that holds the compiled pattern length does not overflow. We make it a bit less
194 than INT_MAX to allow for adding in group terminating code units, so that we
195 don't have to check them every time. */
196
197 #define OFLOW_MAX (INT_MAX - 20)
198
199 /* Code values for parsed patterns, which are stored in a vector of 32-bit
200 unsigned ints. Values less than META_END are literal data values. The coding
201 for identifying the item is in the top 16-bits, leaving 16 bits for the
202 additional data that some of them need. The META_CODE, META_DATA, and META_DIFF
203 macros are used to manipulate parsed pattern elements.
204
205 NOTE: When these definitions are changed, the table of extra lengths for each
206 code (meta_extra_lengths, just below) must be updated to remain in step. */
207
208 #define META_END              0x80000000u  /* End of pattern */
209
210 #define META_ALT              0x80010000u  /* alternation */
211 #define META_ATOMIC           0x80020000u  /* atomic group */
212 #define META_BACKREF          0x80030000u  /* Back ref */
213 #define META_BACKREF_BYNAME   0x80040000u  /* \k'name' */
214 #define META_BIGVALUE         0x80050000u  /* Next is a literal > META_END */
215 #define META_CALLOUT_NUMBER   0x80060000u  /* (?C with numerical argument */
216 #define META_CALLOUT_STRING   0x80070000u  /* (?C with string argument */
217 #define META_CAPTURE          0x80080000u  /* Capturing parenthesis */
218 #define META_CIRCUMFLEX       0x80090000u  /* ^ metacharacter */
219 #define META_CLASS            0x800a0000u  /* start non-empty class */
220 #define META_CLASS_EMPTY      0x800b0000u  /* empty class */
221 #define META_CLASS_EMPTY_NOT  0x800c0000u  /* negative empty class */
222 #define META_CLASS_END        0x800d0000u  /* end of non-empty class */
223 #define META_CLASS_NOT        0x800e0000u  /* start non-empty negative class */
224 #define META_COND_ASSERT      0x800f0000u  /* (?(?assertion)... */
225 #define META_COND_DEFINE      0x80100000u  /* (?(DEFINE)... */
226 #define META_COND_NAME        0x80110000u  /* (?(<name>)... */
227 #define META_COND_NUMBER      0x80120000u  /* (?(digits)... */
228 #define META_COND_RNAME       0x80130000u  /* (?(R&name)... */
229 #define META_COND_RNUMBER     0x80140000u  /* (?(Rdigits)... */
230 #define META_COND_VERSION     0x80150000u  /* (?(VERSION<op>x.y)... */
231 #define META_DOLLAR           0x80160000u  /* $ metacharacter */
232 #define META_DOT              0x80170000u  /* . metacharacter */
233 #define META_ESCAPE           0x80180000u  /* \d and friends */
234 #define META_KET              0x80190000u  /* closing parenthesis */
235 #define META_NOCAPTURE        0x801a0000u  /* no capture parens */
236 #define META_OPTIONS          0x801b0000u  /* (?i) and friends */
237 #define META_POSIX            0x801c0000u  /* POSIX class item */
238 #define META_POSIX_NEG        0x801d0000u  /* negative POSIX class item */
239 #define META_RANGE_ESCAPED    0x801e0000u  /* range with at least one escape */
240 #define META_RANGE_LITERAL    0x801f0000u  /* range defined literally */
241 #define META_RECURSE          0x80200000u  /* Recursion */
242 #define META_RECURSE_BYNAME   0x80210000u  /* (?&name) */
243
244 /* These must be kept together to make it easy to check that an assertion
245 is present where expected in a conditional group. */
246
247 #define META_LOOKAHEAD        0x80220000u  /* (?= */
248 #define META_LOOKAHEADNOT     0x80230000u  /* (?! */
249 #define META_LOOKBEHIND       0x80240000u  /* (?<= */
250 #define META_LOOKBEHINDNOT    0x80250000u  /* (?<! */
251
252 /* These must be kept in this order, with consecutive values, and the _ARG
253 versions of COMMIT, PRUNE, SKIP, and THEN immediately after their non-argument
254 versions. */
255
256 #define META_MARK             0x80260000u  /* (*MARK) */
257 #define META_ACCEPT           0x80270000u  /* (*ACCEPT) */
258 #define META_FAIL             0x80280000u  /* (*FAIL) */
259 #define META_COMMIT           0x80290000u  /* These               */
260 #define META_COMMIT_ARG       0x802a0000u  /*   pairs             */
261 #define META_PRUNE            0x802b0000u  /*     must            */
262 #define META_PRUNE_ARG        0x802c0000u  /*       be            */
263 #define META_SKIP             0x802d0000u  /*         kept        */
264 #define META_SKIP_ARG         0x802e0000u  /*           in        */
265 #define META_THEN             0x802f0000u  /*             this    */
266 #define META_THEN_ARG         0x80300000u  /*               order */
267
268 /* These must be kept in groups of adjacent 3 values, and all together. */
269
270 #define META_ASTERISK         0x80310000u  /* *  */
271 #define META_ASTERISK_PLUS    0x80320000u  /* *+ */
272 #define META_ASTERISK_QUERY   0x80330000u  /* *? */
273 #define META_PLUS             0x80340000u  /* +  */
274 #define META_PLUS_PLUS        0x80350000u  /* ++ */
275 #define META_PLUS_QUERY       0x80360000u  /* +? */
276 #define META_QUERY            0x80370000u  /* ?  */
277 #define META_QUERY_PLUS       0x80380000u  /* ?+ */
278 #define META_QUERY_QUERY      0x80390000u  /* ?? */
279 #define META_MINMAX           0x803a0000u  /* {n,m}  repeat */
280 #define META_MINMAX_PLUS      0x803b0000u  /* {n,m}+ repeat */
281 #define META_MINMAX_QUERY     0x803c0000u  /* {n,m}? repeat */
282
283 #define META_FIRST_QUANTIFIER META_ASTERISK
284 #define META_LAST_QUANTIFIER  META_MINMAX_QUERY
285
286 /* Table of extra lengths for each of the meta codes. Must be kept in step with
287 the definitions above. For some items these values are a basic length to which
288 a variable amount has to be added. */
289
290 static unsigned char meta_extra_lengths[] = {
291   0,             /* META_END */
292   0,             /* META_ALT */
293   0,             /* META_ATOMIC */
294   0,             /* META_BACKREF - more if group is >= 10 */
295   1+SIZEOFFSET,  /* META_BACKREF_BYNAME */
296   1,             /* META_BIGVALUE */
297   3,             /* META_CALLOUT_NUMBER */
298   3+SIZEOFFSET,  /* META_CALLOUT_STRING */
299   0,             /* META_CAPTURE */
300   0,             /* META_CIRCUMFLEX */
301   0,             /* META_CLASS */
302   0,             /* META_CLASS_EMPTY */
303   0,             /* META_CLASS_EMPTY_NOT */
304   0,             /* META_CLASS_END */
305   0,             /* META_CLASS_NOT */
306   0,             /* META_COND_ASSERT */
307   SIZEOFFSET,    /* META_COND_DEFINE */
308   1+SIZEOFFSET,  /* META_COND_NAME */
309   1+SIZEOFFSET,  /* META_COND_NUMBER */
310   1+SIZEOFFSET,  /* META_COND_RNAME */
311   1+SIZEOFFSET,  /* META_COND_RNUMBER */
312   3,             /* META_COND_VERSION */
313   0,             /* META_DOLLAR */
314   0,             /* META_DOT */
315   0,             /* META_ESCAPE - more for ESC_P, ESC_p, ESC_g, ESC_k */
316   0,             /* META_KET */
317   0,             /* META_NOCAPTURE */
318   1,             /* META_OPTIONS */
319   1,             /* META_POSIX */
320   1,             /* META_POSIX_NEG */
321   0,             /* META_RANGE_ESCAPED */
322   0,             /* META_RANGE_LITERAL */
323   SIZEOFFSET,    /* META_RECURSE */
324   1+SIZEOFFSET,  /* META_RECURSE_BYNAME */
325   0,             /* META_LOOKAHEAD */
326   0,             /* META_LOOKAHEADNOT */
327   SIZEOFFSET,    /* META_LOOKBEHIND */
328   SIZEOFFSET,    /* META_LOOKBEHINDNOT */
329   1,             /* META_MARK - plus the string length */
330   0,             /* META_ACCEPT */
331   0,             /* META_FAIL */
332   0,             /* META_COMMIT */
333   1,             /* META_COMMIT_ARG - plus the string length */
334   0,             /* META_PRUNE */
335   1,             /* META_PRUNE_ARG - plus the string length */
336   0,             /* META_SKIP */
337   1,             /* META_SKIP_ARG - plus the string length */
338   0,             /* META_THEN */
339   1,             /* META_THEN_ARG - plus the string length */
340   0,             /* META_ASTERISK */
341   0,             /* META_ASTERISK_PLUS */
342   0,             /* META_ASTERISK_QUERY */
343   0,             /* META_PLUS */
344   0,             /* META_PLUS_PLUS */
345   0,             /* META_PLUS_QUERY */
346   0,             /* META_QUERY */
347   0,             /* META_QUERY_PLUS */
348   0,             /* META_QUERY_QUERY */
349   2,             /* META_MINMAX */
350   2,             /* META_MINMAX_PLUS */
351   2              /* META_MINMAX_QUERY */
352 };
353
354 /* Types for skipping parts of a parsed pattern. */
355
356 enum { PSKIP_ALT, PSKIP_CLASS, PSKIP_KET };
357
358 /* Macro for setting individual bits in class bitmaps. It took some
359 experimenting to figure out how to stop gcc 5.3.0 from warning with
360 -Wconversion. This version gets a warning:
361
362   #define SETBIT(a,b) a[(b)/8] |= (uint8_t)(1 << ((b)&7))
363
364 Let's hope the apparently less efficient version isn't actually so bad if the
365 compiler is clever with identical subexpressions. */
366
367 #define SETBIT(a,b) a[(b)/8] = (uint8_t)(a[(b)/8] | (1 << ((b)&7)))
368
369 /* Private flags added to firstcu and reqcu. */
370
371 #define REQ_CASELESS    (1 << 0)        /* Indicates caselessness */
372 #define REQ_VARY        (1 << 1)        /* reqcu followed non-literal item */
373 /* Negative values for the firstcu and reqcu flags */
374 #define REQ_UNSET       (-2)            /* Not yet found anything */
375 #define REQ_NONE        (-1)            /* Found not fixed char */
376
377 /* These flags are used in the groupinfo vector. */
378
379 #define GI_SET_FIXED_LENGTH    0x80000000u
380 #define GI_NOT_FIXED_LENGTH    0x40000000u
381 #define GI_FIXED_LENGTH_MASK   0x0000ffffu
382
383 /* This simple test for a decimal digit works for both ASCII/Unicode and EBCDIC
384 and is fast (a good compiler can turn it into a subtraction and unsigned
385 comparison). */
386
387 #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9)
388
389 /* Table to identify hex digits. The tables in chartables are dependent on the
390 locale, and may mark arbitrary characters as digits. We want to recognize only
391 0-9, a-z, and A-Z as hex digits, which is why we have a private table here. It
392 costs 256 bytes, but it is a lot faster than doing character value tests (at
393 least in some simple cases I timed), and in some applications one wants PCRE2
394 to compile efficiently as well as match efficiently. The value in the table is
395 the binary hex digit value, or 0xff for non-hex digits. */
396
397 /* This is the "normal" case, for ASCII systems, and EBCDIC systems running in
398 UTF-8 mode. */
399
400 #ifndef EBCDIC
401 static const uint8_t xdigitab[] =
402   {
403   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   0-  7 */
404   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   8- 15 */
405   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  16- 23 */
406   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  24- 31 */
407   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*    - '  */
408   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  ( - /  */
409   0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, /*  0 - 7  */
410   0x08,0x09,0xff,0xff,0xff,0xff,0xff,0xff, /*  8 - ?  */
411   0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  @ - G  */
412   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  H - O  */
413   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  P - W  */
414   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  X - _  */
415   0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  ` - g  */
416   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  h - o  */
417   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  p - w  */
418   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  x -127 */
419   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 128-135 */
420   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 136-143 */
421   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 144-151 */
422   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 152-159 */
423   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 160-167 */
424   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 168-175 */
425   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 176-183 */
426   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 184-191 */
427   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 192-199 */
428   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 2ff-207 */
429   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 208-215 */
430   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 216-223 */
431   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 224-231 */
432   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 232-239 */
433   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 240-247 */
434   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};/* 248-255 */
435
436 #else
437
438 /* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */
439
440 static const uint8_t xdigitab[] =
441   {
442   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   0-  7  0 */
443   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   8- 15    */
444   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  16- 23 10 */
445   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  24- 31    */
446   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  32- 39 20 */
447   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  40- 47    */
448   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  48- 55 30 */
449   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  56- 63    */
450   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*    - 71 40 */
451   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  72- |     */
452   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  & - 87 50 */
453   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  88- 95    */
454   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  - -103 60 */
455   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 104- ?     */
456   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 112-119 70 */
457   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 120- "     */
458   0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /* 128- g  80 */
459   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  h -143    */
460   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 144- p  90 */
461   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  q -159    */
462   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 160- x  A0 */
463   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  y -175    */
464   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  ^ -183 B0 */
465   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 184-191    */
466   0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  { - G  C0 */
467   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  H -207    */
468   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  } - P  D0 */
469   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  Q -223    */
470   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  \ - X  E0 */
471   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  Y -239    */
472   0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, /*  0 - 7  F0 */
473   0x08,0x09,0xff,0xff,0xff,0xff,0xff,0xff};/*  8 -255    */
474 #endif  /* EBCDIC */
475
476
477 /* Table for handling alphanumeric escaped characters. Positive returns are
478 simple data values; negative values are for special things like \d and so on.
479 Zero means further processing is needed (for things like \x), or the escape is
480 invalid. */
481
482 /* This is the "normal" table for ASCII systems or for EBCDIC systems running
483 in UTF-8 mode. It runs from '0' to 'z'. */
484
485 #ifndef EBCDIC
486 #define ESCAPES_FIRST       CHAR_0
487 #define ESCAPES_LAST        CHAR_z
488 #define UPPER_CASE(c)       (c-32)
489
490 static const short int escapes[] = {
491      0,                       0,
492      0,                       0,
493      0,                       0,
494      0,                       0,
495      0,                       0,
496      CHAR_COLON,              CHAR_SEMICOLON,
497      CHAR_LESS_THAN_SIGN,     CHAR_EQUALS_SIGN,
498      CHAR_GREATER_THAN_SIGN,  CHAR_QUESTION_MARK,
499      CHAR_COMMERCIAL_AT,      -ESC_A,
500      -ESC_B,                  -ESC_C,
501      -ESC_D,                  -ESC_E,
502      0,                       -ESC_G,
503      -ESC_H,                  0,
504      0,                       -ESC_K,
505      0,                       0,
506      -ESC_N,                  0,
507      -ESC_P,                  -ESC_Q,
508      -ESC_R,                  -ESC_S,
509      0,                       0,
510      -ESC_V,                  -ESC_W,
511      -ESC_X,                  0,
512      -ESC_Z,                  CHAR_LEFT_SQUARE_BRACKET,
513      CHAR_BACKSLASH,          CHAR_RIGHT_SQUARE_BRACKET,
514      CHAR_CIRCUMFLEX_ACCENT,  CHAR_UNDERSCORE,
515      CHAR_GRAVE_ACCENT,       CHAR_BEL,
516      -ESC_b,                  0,
517      -ESC_d,                  CHAR_ESC,
518      CHAR_FF,                 0,
519      -ESC_h,                  0,
520      0,                       -ESC_k,
521      0,                       0,
522      CHAR_LF,                 0,
523      -ESC_p,                  0,
524      CHAR_CR,                 -ESC_s,
525      CHAR_HT,                 0,
526      -ESC_v,                  -ESC_w,
527      0,                       0,
528      -ESC_z
529 };
530
531 #else
532
533 /* This is the "abnormal" table for EBCDIC systems without UTF-8 support.
534 It runs from 'a' to '9'. For some minimal testing of EBCDIC features, the code
535 is sometimes compiled on an ASCII system. In this case, we must not use CHAR_a
536 because it is defined as 'a', which of course picks up the ASCII value. */
537
538 #if 'a' == 0x81                    /* Check for a real EBCDIC environment */
539 #define ESCAPES_FIRST       CHAR_a
540 #define ESCAPES_LAST        CHAR_9
541 #define UPPER_CASE(c)       (c+64)
542 #else                              /* Testing in an ASCII environment */
543 #define ESCAPES_FIRST  ((unsigned char)'\x81')   /* EBCDIC 'a' */
544 #define ESCAPES_LAST   ((unsigned char)'\xf9')   /* EBCDIC '9' */
545 #define UPPER_CASE(c)  (c-32)
546 #endif
547
548 static const short int escapes[] = {
549 /*  80 */         CHAR_BEL, -ESC_b,       0, -ESC_d, CHAR_ESC, CHAR_FF,      0,
550 /*  88 */ -ESC_h,        0,      0,     '{',      0,        0,       0,      0,
551 /*  90 */      0,        0, -ESC_k,       0,      0,  CHAR_LF,       0, -ESC_p,
552 /*  98 */      0,  CHAR_CR,      0,     '}',      0,        0,       0,      0,
553 /*  A0 */      0,      '~', -ESC_s, CHAR_HT,      0,   -ESC_v,  -ESC_w,      0,
554 /*  A8 */      0,   -ESC_z,      0,       0,      0,      '[',       0,      0,
555 /*  B0 */      0,        0,      0,       0,      0,        0,       0,      0,
556 /*  B8 */      0,        0,      0,       0,      0,      ']',     '=',    '-',
557 /*  C0 */    '{',   -ESC_A, -ESC_B,  -ESC_C, -ESC_D,   -ESC_E,       0, -ESC_G,
558 /*  C8 */ -ESC_H,        0,      0,       0,      0,        0,       0,      0,
559 /*  D0 */    '}',        0, -ESC_K,       0,      0,   -ESC_N,       0, -ESC_P,
560 /*  D8 */ -ESC_Q,   -ESC_R,      0,       0,      0,        0,       0,      0,
561 /*  E0 */   '\\',        0, -ESC_S,       0,      0,   -ESC_V,  -ESC_W, -ESC_X,
562 /*  E8 */      0,   -ESC_Z,      0,       0,      0,        0,       0,      0,
563 /*  F0 */      0,        0,      0,       0,      0,        0,       0,      0,
564 /*  F8 */      0,        0
565 };
566
567 /* We also need a table of characters that may follow \c in an EBCDIC
568 environment for characters 0-31. */
569
570 static unsigned char ebcdic_escape_c[] = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
571
572 #endif   /* EBCDIC */
573
574
575 /* Table of special "verbs" like (*PRUNE). This is a short table, so it is
576 searched linearly. Put all the names into a single string, in order to reduce
577 the number of relocations when a shared library is dynamically linked. The
578 string is built from string macros so that it works in UTF-8 mode on EBCDIC
579 platforms. */
580
581 typedef struct verbitem {
582   unsigned int len;          /* Length of verb name */
583   uint32_t meta;             /* Base META_ code */
584   int has_arg;               /* Argument requirement */
585 } verbitem;
586
587 static const char verbnames[] =
588   "\0"                       /* Empty name is a shorthand for MARK */
589   STRING_MARK0
590   STRING_ACCEPT0
591   STRING_F0
592   STRING_FAIL0
593   STRING_COMMIT0
594   STRING_PRUNE0
595   STRING_SKIP0
596   STRING_THEN;
597
598 static const verbitem verbs[] = {
599   { 0, META_MARK,   +1 },  /* > 0 => must have an argument */
600   { 4, META_MARK,   +1 },
601   { 6, META_ACCEPT, -1 },  /* < 0 => Optional argument, convert to pre-MARK */
602   { 1, META_FAIL,   -1 },
603   { 4, META_FAIL,   -1 },
604   { 6, META_COMMIT,  0 },
605   { 5, META_PRUNE,   0 },  /* Optional argument; bump META code if found */
606   { 4, META_SKIP,    0 },
607   { 4, META_THEN,    0 }
608 };
609
610 static const int verbcount = sizeof(verbs)/sizeof(verbitem);
611
612 /* Verb opcodes, indexed by their META code offset from META_MARK. */
613
614 static const uint32_t verbops[] = {
615   OP_MARK, OP_ACCEPT, OP_FAIL, OP_COMMIT, OP_COMMIT_ARG, OP_PRUNE,
616   OP_PRUNE_ARG, OP_SKIP, OP_SKIP_ARG, OP_THEN, OP_THEN_ARG };
617
618 /* Offsets from OP_STAR for case-independent and negative repeat opcodes. */
619
620 static uint32_t chartypeoffset[] = {
621   OP_STAR - OP_STAR,    OP_STARI - OP_STAR,
622   OP_NOTSTAR - OP_STAR, OP_NOTSTARI - OP_STAR };
623
624 /* Tables of names of POSIX character classes and their lengths. The names are
625 now all in a single string, to reduce the number of relocations when a shared
626 library is dynamically loaded. The list of lengths is terminated by a zero
627 length entry. The first three must be alpha, lower, upper, as this is assumed
628 for handling case independence. The indices for graph, print, and punct are
629 needed, so identify them. */
630
631 static const char posix_names[] =
632   STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0
633   STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0
634   STRING_graph0 STRING_print0 STRING_punct0 STRING_space0
635   STRING_word0  STRING_xdigit;
636
637 static const uint8_t posix_name_lengths[] = {
638   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
639
640 #define PC_GRAPH  8
641 #define PC_PRINT  9
642 #define PC_PUNCT 10
643
644 /* Table of class bit maps for each POSIX class. Each class is formed from a
645 base map, with an optional addition or removal of another map. Then, for some
646 classes, there is some additional tweaking: for [:blank:] the vertical space
647 characters are removed, and for [:alpha:] and [:alnum:] the underscore
648 character is removed. The triples in the table consist of the base map offset,
649 second map offset or -1 if no second map, and a non-negative value for map
650 addition or a negative value for map subtraction (if there are two maps). The
651 absolute value of the third field has these meanings: 0 => no tweaking, 1 =>
652 remove vertical space characters, 2 => remove underscore. */
653
654 static const int posix_class_maps[] = {
655   cbit_word,  cbit_digit, -2,             /* alpha */
656   cbit_lower, -1,          0,             /* lower */
657   cbit_upper, -1,          0,             /* upper */
658   cbit_word,  -1,          2,             /* alnum - word without underscore */
659   cbit_print, cbit_cntrl,  0,             /* ascii */
660   cbit_space, -1,          1,             /* blank - a GNU extension */
661   cbit_cntrl, -1,          0,             /* cntrl */
662   cbit_digit, -1,          0,             /* digit */
663   cbit_graph, -1,          0,             /* graph */
664   cbit_print, -1,          0,             /* print */
665   cbit_punct, -1,          0,             /* punct */
666   cbit_space, -1,          0,             /* space */
667   cbit_word,  -1,          0,             /* word - a Perl extension */
668   cbit_xdigit,-1,          0              /* xdigit */
669 };
670
671 #ifdef SUPPORT_UNICODE
672
673 /* The POSIX class Unicode property substitutes that are used in UCP mode must
674 be in the order of the POSIX class names, defined above. */
675
676 static int posix_substitutes[] = {
677   PT_GC, ucp_L,     /* alpha */
678   PT_PC, ucp_Ll,    /* lower */
679   PT_PC, ucp_Lu,    /* upper */
680   PT_ALNUM, 0,      /* alnum */
681   -1, 0,            /* ascii, treat as non-UCP */
682   -1, 1,            /* blank, treat as \h */
683   PT_PC, ucp_Cc,    /* cntrl */
684   PT_PC, ucp_Nd,    /* digit */
685   PT_PXGRAPH, 0,    /* graph */
686   PT_PXPRINT, 0,    /* print */
687   PT_PXPUNCT, 0,    /* punct */
688   PT_PXSPACE, 0,    /* space */   /* Xps is POSIX space, but from 8.34 */
689   PT_WORD, 0,       /* word  */   /* Perl and POSIX space are the same */
690   -1, 0             /* xdigit, treat as non-UCP */
691 };
692 #define POSIX_SUBSIZE (sizeof(posix_substitutes) / (2*sizeof(uint32_t)))
693 #endif  /* SUPPORT_UNICODE */
694
695 /* Masks for checking option settings. When PCRE2_LITERAL is set, only a subset
696 are allowed. */
697
698 #define PUBLIC_LITERAL_COMPILE_OPTIONS \
699   (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \
700    PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_NO_START_OPTIMIZE| \
701    PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF)
702
703 #define PUBLIC_COMPILE_OPTIONS \
704   (PUBLIC_LITERAL_COMPILE_OPTIONS| \
705    PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \
706    PCRE2_ALT_VERBNAMES|PCRE2_DOLLAR_ENDONLY|PCRE2_DOTALL|PCRE2_DUPNAMES| \
707    PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MATCH_UNSET_BACKREF| \
708    PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C|PCRE2_NEVER_UCP| \
709    PCRE2_NEVER_UTF|PCRE2_NO_AUTO_CAPTURE|PCRE2_NO_AUTO_POSSESS| \
710    PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_UCP|PCRE2_UNGREEDY)
711
712 #define PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS \
713    (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD)
714
715 #define PUBLIC_COMPILE_EXTRA_OPTIONS \
716    (PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS| \
717     PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES|PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL)
718
719 /* Compile time error code numbers. They are given names so that they can more
720 easily be tracked. When a new number is added, the tables called eint1 and
721 eint2 in pcre2posix.c may need to be updated, and a new error text must be
722 added to compile_error_texts in pcre2_error.c. */
723
724 enum { ERR0 = COMPILE_ERROR_BASE,
725        ERR1,  ERR2,  ERR3,  ERR4,  ERR5,  ERR6,  ERR7,  ERR8,  ERR9,  ERR10,
726        ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19, ERR20,
727        ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR28, ERR29, ERR30,
728        ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39, ERR40,
729        ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47, ERR48, ERR49, ERR50,
730        ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59, ERR60,
731        ERR61, ERR62, ERR63, ERR64, ERR65, ERR66, ERR67, ERR68, ERR69, ERR70,
732        ERR71, ERR72, ERR73, ERR74, ERR75, ERR76, ERR77, ERR78, ERR79, ERR80,
733        ERR81, ERR82, ERR83, ERR84, ERR85, ERR86, ERR87, ERR88, ERR89, ERR90,
734        ERR91, ERR92, ERR93, ERR94 };
735
736 /* This is a table of start-of-pattern options such as (*UTF) and settings such
737 as (*LIMIT_MATCH=nnnn) and (*CRLF). For completeness and backward
738 compatibility, (*UTFn) is supported in the relevant libraries, but (*UTF) is
739 generic and always supported. */
740
741 enum { PSO_OPT,     /* Value is an option bit */
742        PSO_FLG,     /* Value is a flag bit */
743        PSO_NL,      /* Value is a newline type */
744        PSO_BSR,     /* Value is a \R type */
745        PSO_LIMH,    /* Read integer value for heap limit */
746        PSO_LIMM,    /* Read integer value for match limit */
747        PSO_LIMD };  /* Read integer value for depth limit */
748
749 typedef struct pso {
750   const uint8_t *name;
751   uint16_t length;
752   uint16_t type;
753   uint32_t value;
754 } pso;
755
756 /* NB: STRING_UTFn_RIGHTPAR contains the length as well */
757
758 static pso pso_list[] = {
759   { (uint8_t *)STRING_UTFn_RIGHTPAR,                  PSO_OPT, PCRE2_UTF },
760   { (uint8_t *)STRING_UTF_RIGHTPAR,                4, PSO_OPT, PCRE2_UTF },
761   { (uint8_t *)STRING_UCP_RIGHTPAR,                4, PSO_OPT, PCRE2_UCP },
762   { (uint8_t *)STRING_NOTEMPTY_RIGHTPAR,           9, PSO_FLG, PCRE2_NOTEMPTY_SET },
763   { (uint8_t *)STRING_NOTEMPTY_ATSTART_RIGHTPAR,  17, PSO_FLG, PCRE2_NE_ATST_SET },
764   { (uint8_t *)STRING_NO_AUTO_POSSESS_RIGHTPAR,   16, PSO_OPT, PCRE2_NO_AUTO_POSSESS },
765   { (uint8_t *)STRING_NO_DOTSTAR_ANCHOR_RIGHTPAR, 18, PSO_OPT, PCRE2_NO_DOTSTAR_ANCHOR },
766   { (uint8_t *)STRING_NO_JIT_RIGHTPAR,             7, PSO_FLG, PCRE2_NOJIT },
767   { (uint8_t *)STRING_NO_START_OPT_RIGHTPAR,      13, PSO_OPT, PCRE2_NO_START_OPTIMIZE },
768   { (uint8_t *)STRING_LIMIT_HEAP_EQ,              11, PSO_LIMH, 0 },
769   { (uint8_t *)STRING_LIMIT_MATCH_EQ,             12, PSO_LIMM, 0 },
770   { (uint8_t *)STRING_LIMIT_DEPTH_EQ,             12, PSO_LIMD, 0 },
771   { (uint8_t *)STRING_LIMIT_RECURSION_EQ,         16, PSO_LIMD, 0 },
772   { (uint8_t *)STRING_CR_RIGHTPAR,                 3, PSO_NL,  PCRE2_NEWLINE_CR },
773   { (uint8_t *)STRING_LF_RIGHTPAR,                 3, PSO_NL,  PCRE2_NEWLINE_LF },
774   { (uint8_t *)STRING_CRLF_RIGHTPAR,               5, PSO_NL,  PCRE2_NEWLINE_CRLF },
775   { (uint8_t *)STRING_ANY_RIGHTPAR,                4, PSO_NL,  PCRE2_NEWLINE_ANY },
776   { (uint8_t *)STRING_NUL_RIGHTPAR,                4, PSO_NL,  PCRE2_NEWLINE_NUL },
777   { (uint8_t *)STRING_ANYCRLF_RIGHTPAR,            8, PSO_NL,  PCRE2_NEWLINE_ANYCRLF },
778   { (uint8_t *)STRING_BSR_ANYCRLF_RIGHTPAR,       12, PSO_BSR, PCRE2_BSR_ANYCRLF },
779   { (uint8_t *)STRING_BSR_UNICODE_RIGHTPAR,       12, PSO_BSR, PCRE2_BSR_UNICODE }
780 };
781
782 /* This table is used when converting repeating opcodes into possessified
783 versions as a result of an explicit possessive quantifier such as ++. A zero
784 value means there is no possessified version - in those cases the item in
785 question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT
786 because all relevant opcodes are less than that. */
787
788 static const uint8_t opcode_possessify[] = {
789   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 0 - 15  */
790   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 16 - 31 */
791
792   0,                       /* NOTI */
793   OP_POSSTAR, 0,           /* STAR, MINSTAR */
794   OP_POSPLUS, 0,           /* PLUS, MINPLUS */
795   OP_POSQUERY, 0,          /* QUERY, MINQUERY */
796   OP_POSUPTO, 0,           /* UPTO, MINUPTO */
797   0,                       /* EXACT */
798   0, 0, 0, 0,              /* POS{STAR,PLUS,QUERY,UPTO} */
799
800   OP_POSSTARI, 0,          /* STARI, MINSTARI */
801   OP_POSPLUSI, 0,          /* PLUSI, MINPLUSI */
802   OP_POSQUERYI, 0,         /* QUERYI, MINQUERYI */
803   OP_POSUPTOI, 0,          /* UPTOI, MINUPTOI */
804   0,                       /* EXACTI */
805   0, 0, 0, 0,              /* POS{STARI,PLUSI,QUERYI,UPTOI} */
806
807   OP_NOTPOSSTAR, 0,        /* NOTSTAR, NOTMINSTAR */
808   OP_NOTPOSPLUS, 0,        /* NOTPLUS, NOTMINPLUS */
809   OP_NOTPOSQUERY, 0,       /* NOTQUERY, NOTMINQUERY */
810   OP_NOTPOSUPTO, 0,        /* NOTUPTO, NOTMINUPTO */
811   0,                       /* NOTEXACT */
812   0, 0, 0, 0,              /* NOTPOS{STAR,PLUS,QUERY,UPTO} */
813
814   OP_NOTPOSSTARI, 0,       /* NOTSTARI, NOTMINSTARI */
815   OP_NOTPOSPLUSI, 0,       /* NOTPLUSI, NOTMINPLUSI */
816   OP_NOTPOSQUERYI, 0,      /* NOTQUERYI, NOTMINQUERYI */
817   OP_NOTPOSUPTOI, 0,       /* NOTUPTOI, NOTMINUPTOI */
818   0,                       /* NOTEXACTI */
819   0, 0, 0, 0,              /* NOTPOS{STARI,PLUSI,QUERYI,UPTOI} */
820
821   OP_TYPEPOSSTAR, 0,       /* TYPESTAR, TYPEMINSTAR */
822   OP_TYPEPOSPLUS, 0,       /* TYPEPLUS, TYPEMINPLUS */
823   OP_TYPEPOSQUERY, 0,      /* TYPEQUERY, TYPEMINQUERY */
824   OP_TYPEPOSUPTO, 0,       /* TYPEUPTO, TYPEMINUPTO */
825   0,                       /* TYPEEXACT */
826   0, 0, 0, 0,              /* TYPEPOS{STAR,PLUS,QUERY,UPTO} */
827
828   OP_CRPOSSTAR, 0,         /* CRSTAR, CRMINSTAR */
829   OP_CRPOSPLUS, 0,         /* CRPLUS, CRMINPLUS */
830   OP_CRPOSQUERY, 0,        /* CRQUERY, CRMINQUERY */
831   OP_CRPOSRANGE, 0,        /* CRRANGE, CRMINRANGE */
832   0, 0, 0, 0,              /* CRPOS{STAR,PLUS,QUERY,RANGE} */
833
834   0, 0, 0,                 /* CLASS, NCLASS, XCLASS */
835   0, 0,                    /* REF, REFI */
836   0, 0,                    /* DNREF, DNREFI */
837   0, 0                     /* RECURSE, CALLOUT */
838 };
839
840
841 #ifdef DEBUG_SHOW_PARSED
842 /*************************************************
843 *     Show the parsed pattern for debugging      *
844 *************************************************/
845
846 /* For debugging the pre-scan, this code, which outputs the parsed data vector,
847 can be enabled. */
848
849 static void show_parsed(compile_block *cb)
850 {
851 uint32_t *pptr = cb->parsed_pattern;
852
853 for (;;)
854   {
855   int max, min;
856   PCRE2_SIZE offset;
857   uint32_t i;
858   uint32_t length;
859   uint32_t meta_arg = META_DATA(*pptr);
860
861   fprintf(stderr, "+++ %02d %.8x ", (int)(pptr - cb->parsed_pattern), *pptr);
862
863   if (*pptr < META_END)
864     {
865     if (*pptr > 32 && *pptr < 128) fprintf(stderr, "%c", *pptr);
866     pptr++;
867     }
868
869   else switch (META_CODE(*pptr++))
870     {
871     default:
872     fprintf(stderr, "**** OOPS - unknown META value - giving up ****\n");
873     return;
874
875     case META_END:
876     fprintf(stderr, "META_END\n");
877     return;
878
879     case META_CAPTURE:
880     fprintf(stderr, "META_CAPTURE %d", meta_arg);
881     break;
882
883     case META_RECURSE:
884     GETOFFSET(offset, pptr);
885     fprintf(stderr, "META_RECURSE %d %zd", meta_arg, offset);
886     break;
887
888     case META_BACKREF:
889     if (meta_arg < 10)
890       offset = cb->small_ref_offset[meta_arg];
891     else
892       GETOFFSET(offset, pptr);
893     fprintf(stderr, "META_BACKREF %d %zd", meta_arg, offset);
894     break;
895
896     case META_ESCAPE:
897     if (meta_arg == ESC_P || meta_arg == ESC_p)
898       {
899       uint32_t ptype = *pptr >> 16;
900       uint32_t pvalue = *pptr++ & 0xffff;
901       fprintf(stderr, "META \\%c %d %d", (meta_arg == ESC_P)? 'P':'p',
902         ptype, pvalue);
903       }
904     else
905       {
906       uint32_t cc;
907       /* There's just one escape we might have here that isn't negated in the
908       escapes table. */
909       if (meta_arg == ESC_g) cc = CHAR_g;
910       else for (cc = ESCAPES_FIRST; cc <= ESCAPES_LAST; cc++)
911         {
912         if (meta_arg == (uint32_t)(-escapes[cc - ESCAPES_FIRST])) break;
913         }
914       if (cc > ESCAPES_LAST) cc = CHAR_QUESTION_MARK;
915       fprintf(stderr, "META \\%c", cc);
916       }
917     break;
918
919     case META_MINMAX:
920     min = *pptr++;
921     max = *pptr++;
922     if (max != REPEAT_UNLIMITED)
923       fprintf(stderr, "META {%d,%d}", min, max);
924     else
925       fprintf(stderr, "META {%d,}", min);
926     break;
927
928     case META_MINMAX_QUERY:
929     min = *pptr++;
930     max = *pptr++;
931     if (max != REPEAT_UNLIMITED)
932       fprintf(stderr, "META {%d,%d}?", min, max);
933     else
934       fprintf(stderr, "META {%d,}?", min);
935     break;
936
937     case META_MINMAX_PLUS:
938     min = *pptr++;
939     max = *pptr++;
940     if (max != REPEAT_UNLIMITED)
941       fprintf(stderr, "META {%d,%d}+", min, max);
942     else
943       fprintf(stderr, "META {%d,}+", min);
944     break;
945
946     case META_BIGVALUE: fprintf(stderr, "META_BIGVALUE %.8x", *pptr++); break;
947     case META_CIRCUMFLEX: fprintf(stderr, "META_CIRCUMFLEX"); break;
948     case META_COND_ASSERT: fprintf(stderr, "META_COND_ASSERT"); break;
949     case META_DOLLAR: fprintf(stderr, "META_DOLLAR"); break;
950     case META_DOT: fprintf(stderr, "META_DOT"); break;
951     case META_ASTERISK: fprintf(stderr, "META *"); break;
952     case META_ASTERISK_QUERY: fprintf(stderr, "META *?"); break;
953     case META_ASTERISK_PLUS: fprintf(stderr, "META *+"); break;
954     case META_PLUS: fprintf(stderr, "META +"); break;
955     case META_PLUS_QUERY: fprintf(stderr, "META +?"); break;
956     case META_PLUS_PLUS: fprintf(stderr, "META ++"); break;
957     case META_QUERY: fprintf(stderr, "META ?"); break;
958     case META_QUERY_QUERY: fprintf(stderr, "META ??"); break;
959     case META_QUERY_PLUS: fprintf(stderr, "META ?+"); break;
960
961     case META_ATOMIC: fprintf(stderr, "META (?>"); break;
962     case META_NOCAPTURE: fprintf(stderr, "META (?:"); break;
963     case META_LOOKAHEAD: fprintf(stderr, "META (?="); break;
964     case META_LOOKAHEADNOT: fprintf(stderr, "META (?!"); break;
965     case META_KET: fprintf(stderr, "META )"); break;
966     case META_ALT: fprintf(stderr, "META | %d", meta_arg); break;
967
968     case META_CLASS: fprintf(stderr, "META ["); break;
969     case META_CLASS_NOT: fprintf(stderr, "META [^"); break;
970     case META_CLASS_END: fprintf(stderr, "META ]"); break;
971     case META_CLASS_EMPTY: fprintf(stderr, "META []"); break;
972     case META_CLASS_EMPTY_NOT: fprintf(stderr, "META [^]"); break;
973
974     case META_RANGE_LITERAL: fprintf(stderr, "META - (literal)"); break;
975     case META_RANGE_ESCAPED: fprintf(stderr, "META - (escaped)"); break;
976
977     case META_POSIX: fprintf(stderr, "META_POSIX %d", *pptr++); break;
978     case META_POSIX_NEG: fprintf(stderr, "META_POSIX_NEG %d", *pptr++); break;
979
980     case META_ACCEPT: fprintf(stderr, "META (*ACCEPT)"); break;
981     case META_FAIL: fprintf(stderr, "META (*FAIL)"); break;
982     case META_COMMIT: fprintf(stderr, "META (*COMMIT)"); break;
983     case META_PRUNE: fprintf(stderr, "META (*PRUNE)"); break;
984     case META_SKIP: fprintf(stderr, "META (*SKIP)"); break;
985     case META_THEN: fprintf(stderr, "META (*THEN)"); break;
986
987     case META_OPTIONS: fprintf(stderr, "META_OPTIONS 0x%02x", *pptr++); break;
988
989     case META_LOOKBEHIND:
990     fprintf(stderr, "META (?<= %d offset=", meta_arg);
991     GETOFFSET(offset, pptr);
992     fprintf(stderr, "%zd", offset);
993     break;
994
995     case META_LOOKBEHINDNOT:
996     fprintf(stderr, "META (?<! %d offset=", meta_arg);
997     GETOFFSET(offset, pptr);
998     fprintf(stderr, "%zd", offset);
999     break;
1000
1001     case META_CALLOUT_NUMBER:
1002     fprintf(stderr, "META (?C%d) next=%d/%d", pptr[2], pptr[0],
1003        pptr[1]);
1004     pptr += 3;
1005     break;
1006
1007     case META_CALLOUT_STRING:
1008       {
1009       uint32_t patoffset = *pptr++;    /* Offset of next pattern item */
1010       uint32_t patlength = *pptr++;    /* Length of next pattern item */
1011       fprintf(stderr, "META (?Cstring) length=%d offset=", *pptr++);
1012       GETOFFSET(offset, pptr);
1013       fprintf(stderr, "%zd next=%d/%d", offset, patoffset, patlength);
1014       }
1015     break;
1016
1017     case META_RECURSE_BYNAME:
1018     fprintf(stderr, "META (?(&name) length=%d offset=", *pptr++);
1019     GETOFFSET(offset, pptr);
1020     fprintf(stderr, "%zd", offset);
1021     break;
1022
1023     case META_BACKREF_BYNAME:
1024     fprintf(stderr, "META_BACKREF_BYNAME length=%d offset=", *pptr++);
1025     GETOFFSET(offset, pptr);
1026     fprintf(stderr, "%zd", offset);
1027     break;
1028
1029     case META_COND_NUMBER:
1030     fprintf(stderr, "META_COND_NUMBER %d offset=", pptr[SIZEOFFSET]);
1031     GETOFFSET(offset, pptr);
1032     fprintf(stderr, "%zd", offset);
1033     pptr++;
1034     break;
1035
1036     case META_COND_DEFINE:
1037     fprintf(stderr, "META (?(DEFINE) offset=");
1038     GETOFFSET(offset, pptr);
1039     fprintf(stderr, "%zd", offset);
1040     break;
1041
1042     case META_COND_VERSION:
1043     fprintf(stderr, "META (?(VERSION%s", (*pptr++ == 0)? "=" : ">=");
1044     fprintf(stderr, "%d.", *pptr++);
1045     fprintf(stderr, "%d)", *pptr++);
1046     break;
1047
1048     case META_COND_NAME:
1049     fprintf(stderr, "META (?(<name>) length=%d offset=", *pptr++);
1050     GETOFFSET(offset, pptr);
1051     fprintf(stderr, "%zd", offset);
1052     break;
1053
1054     case META_COND_RNAME:
1055     fprintf(stderr, "META (?(R&name) length=%d offset=", *pptr++);
1056     GETOFFSET(offset, pptr);
1057     fprintf(stderr, "%zd", offset);
1058     break;
1059
1060     /* This is kept as a name, because it might be. */
1061
1062     case META_COND_RNUMBER:
1063     fprintf(stderr, "META (?(Rnumber) length=%d offset=", *pptr++);
1064     GETOFFSET(offset, pptr);
1065     fprintf(stderr, "%zd", offset);
1066     break;
1067
1068     case META_MARK:
1069     fprintf(stderr, "META (*MARK:");
1070     goto SHOWARG;
1071
1072     case META_COMMIT_ARG:
1073     fprintf(stderr, "META (*COMMIT:");
1074     goto SHOWARG;
1075
1076     case META_PRUNE_ARG:
1077     fprintf(stderr, "META (*PRUNE:");
1078     goto SHOWARG;
1079
1080     case META_SKIP_ARG:
1081     fprintf(stderr, "META (*SKIP:");
1082     goto SHOWARG;
1083
1084     case META_THEN_ARG:
1085     fprintf(stderr, "META (*THEN:");
1086     SHOWARG:
1087     length = *pptr++;
1088     for (i = 0; i < length; i++)
1089       {
1090       uint32_t cc = *pptr++;
1091       if (cc > 32 && cc < 128) fprintf(stderr, "%c", cc);
1092         else fprintf(stderr, "\\x{%x}", cc);
1093       }
1094     fprintf(stderr, ") length=%u", length);
1095     break;
1096     }
1097   fprintf(stderr, "\n");
1098   }
1099 return;
1100 }
1101 #endif  /* DEBUG_SHOW_PARSED */
1102
1103
1104
1105 /*************************************************
1106 *               Copy compiled code               *
1107 *************************************************/
1108
1109 /* Compiled JIT code cannot be copied, so the new compiled block has no
1110 associated JIT data. */
1111
1112 PCRE2_EXP_DEFN pcre2_code * PCRE2_CALL_CONVENTION
1113 pcre2_code_copy(const pcre2_code *code)
1114 {
1115 PCRE2_SIZE* ref_count;
1116 pcre2_code *newcode;
1117
1118 if (code == NULL) return NULL;
1119 newcode = code->memctl.malloc(code->blocksize, code->memctl.memory_data);
1120 if (newcode == NULL) return NULL;
1121 memcpy(newcode, code, code->blocksize);
1122 newcode->executable_jit = NULL;
1123
1124 /* If the code is one that has been deserialized, increment the reference count
1125 in the decoded tables. */
1126
1127 if ((code->flags & PCRE2_DEREF_TABLES) != 0)
1128   {
1129   ref_count = (PCRE2_SIZE *)(code->tables + tables_length);
1130   (*ref_count)++;
1131   }
1132
1133 return newcode;
1134 }
1135
1136
1137
1138 /*************************************************
1139 *     Copy compiled code and character tables    *
1140 *************************************************/
1141
1142 /* Compiled JIT code cannot be copied, so the new compiled block has no
1143 associated JIT data. This version of code_copy also makes a separate copy of
1144 the character tables. */
1145
1146 PCRE2_EXP_DEFN pcre2_code * PCRE2_CALL_CONVENTION
1147 pcre2_code_copy_with_tables(const pcre2_code *code)
1148 {
1149 PCRE2_SIZE* ref_count;
1150 pcre2_code *newcode;
1151 uint8_t *newtables;
1152
1153 if (code == NULL) return NULL;
1154 newcode = code->memctl.malloc(code->blocksize, code->memctl.memory_data);
1155 if (newcode == NULL) return NULL;
1156 memcpy(newcode, code, code->blocksize);
1157 newcode->executable_jit = NULL;
1158
1159 newtables = code->memctl.malloc(tables_length + sizeof(PCRE2_SIZE),
1160   code->memctl.memory_data);
1161 if (newtables == NULL)
1162   {
1163   code->memctl.free((void *)newcode, code->memctl.memory_data);
1164   return NULL;
1165   }
1166 memcpy(newtables, code->tables, tables_length);
1167 ref_count = (PCRE2_SIZE *)(newtables + tables_length);
1168 *ref_count = 1;
1169
1170 newcode->tables = newtables;
1171 newcode->flags |= PCRE2_DEREF_TABLES;
1172 return newcode;
1173 }
1174
1175
1176
1177 /*************************************************
1178 *               Free compiled code               *
1179 *************************************************/
1180
1181 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
1182 pcre2_code_free(pcre2_code *code)
1183 {
1184 PCRE2_SIZE* ref_count;
1185
1186 if (code != NULL)
1187   {
1188   if (code->executable_jit != NULL)
1189     PRIV(jit_free)(code->executable_jit, &code->memctl);
1190
1191   if ((code->flags & PCRE2_DEREF_TABLES) != 0)
1192     {
1193     /* Decoded tables belong to the codes after deserialization, and they must
1194     be freed when there are no more reference to them. The *ref_count should
1195     always be > 0. */
1196
1197     ref_count = (PCRE2_SIZE *)(code->tables + tables_length);
1198     if (*ref_count > 0)
1199       {
1200       (*ref_count)--;
1201       if (*ref_count == 0)
1202         code->memctl.free((void *)code->tables, code->memctl.memory_data);
1203       }
1204     }
1205
1206   code->memctl.free(code, code->memctl.memory_data);
1207   }
1208 }
1209
1210
1211
1212 /*************************************************
1213 *         Read a number, possibly signed         *
1214 *************************************************/
1215
1216 /* This function is used to read numbers in the pattern. The initial pointer
1217 must be the sign or first digit of the number. When relative values (introduced
1218 by + or -) are allowed, they are relative group numbers, and the result must be
1219 greater than zero.
1220
1221 Arguments:
1222   ptrptr      points to the character pointer variable
1223   ptrend      points to the end of the input string
1224   allow_sign  if < 0, sign not allowed; if >= 0, sign is relative to this
1225   max_value   the largest number allowed
1226   max_error   the error to give for an over-large number
1227   intptr      where to put the result
1228   errcodeptr  where to put an error code
1229
1230 Returns:      TRUE  - a number was read
1231               FALSE - errorcode == 0 => no number was found
1232                       errorcode != 0 => an error occurred
1233 */
1234
1235 static BOOL
1236 read_number(PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, int32_t allow_sign,
1237   uint32_t max_value, uint32_t max_error, int *intptr, int *errorcodeptr)
1238 {
1239 int sign = 0;
1240 uint32_t n = 0;
1241 PCRE2_SPTR ptr = *ptrptr;
1242 BOOL yield = FALSE;
1243
1244 *errorcodeptr = 0;
1245
1246 if (allow_sign >= 0 && ptr < ptrend)
1247   {
1248   if (*ptr == CHAR_PLUS)
1249     {
1250     sign = +1;
1251     max_value -= allow_sign;
1252     ptr++;
1253     }
1254   else if (*ptr == CHAR_MINUS)
1255     {
1256     sign = -1;
1257     ptr++;
1258     }
1259   }
1260
1261 if (ptr >= ptrend || !IS_DIGIT(*ptr)) return FALSE;
1262 while (ptr < ptrend && IS_DIGIT(*ptr))
1263   {
1264   n = n * 10 + *ptr++ - CHAR_0;
1265   if (n > max_value)
1266     {
1267     *errorcodeptr = max_error;
1268     goto EXIT;
1269     }
1270   }
1271
1272 if (allow_sign >= 0 && sign != 0)
1273   {
1274   if (n == 0)
1275     {
1276     *errorcodeptr = ERR26;  /* +0 and -0 are not allowed */
1277     goto EXIT;
1278     }
1279
1280   if (sign > 0) n += allow_sign;
1281   else if ((int)n > allow_sign)
1282     {
1283     *errorcodeptr = ERR15;  /* Non-existent subpattern */
1284     goto EXIT;
1285     }
1286   else n = allow_sign + 1 - n;
1287   }
1288
1289 yield = TRUE;
1290
1291 EXIT:
1292 *intptr = n;
1293 *ptrptr = ptr;
1294 return yield;
1295 }
1296
1297
1298
1299 /*************************************************
1300 *         Read repeat counts                     *
1301 *************************************************/
1302
1303 /* Read an item of the form {n,m} and return the values if non-NULL pointers
1304 are supplied. Repeat counts must be less than 65536 (MAX_REPEAT_COUNT); a
1305 larger value is used for "unlimited". We have to use signed arguments for
1306 read_number() because it is capable of returning a signed value.
1307
1308 Arguments:
1309   ptrptr         points to pointer to character after'{'
1310   ptrend         pointer to end of input
1311   minp           if not NULL, pointer to int for min
1312   maxp           if not NULL, pointer to int for max (-1 if no max)
1313                  returned as -1 if no max
1314   errorcodeptr   points to error code variable
1315
1316 Returns:         FALSE if not a repeat quantifier, errorcode set zero
1317                  FALSE on error, with errorcode set non-zero
1318                  TRUE on success, with pointer updated to point after '}'
1319 */
1320
1321 static BOOL
1322 read_repeat_counts(PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, uint32_t *minp,
1323   uint32_t *maxp, int *errorcodeptr)
1324 {
1325 PCRE2_SPTR p = *ptrptr;
1326 BOOL yield = FALSE;
1327 int32_t min = 0;
1328 int32_t max = REPEAT_UNLIMITED; /* This value is larger than MAX_REPEAT_COUNT */
1329
1330 /* NB read_number() initializes the error code to zero. The only error is for a
1331 number that is too big. */
1332
1333 if (!read_number(&p, ptrend, -1, MAX_REPEAT_COUNT, ERR5, &min, errorcodeptr))
1334   goto EXIT;
1335
1336 if (p >= ptrend) goto EXIT;
1337
1338 if (*p == CHAR_RIGHT_CURLY_BRACKET)
1339   {
1340   p++;
1341   max = min;
1342   }
1343
1344 else
1345   {
1346   if (*p++ != CHAR_COMMA || p >= ptrend) goto EXIT;
1347   if (*p != CHAR_RIGHT_CURLY_BRACKET)
1348     {
1349     if (!read_number(&p, ptrend, -1, MAX_REPEAT_COUNT, ERR5, &max,
1350         errorcodeptr) || p >= ptrend ||  *p != CHAR_RIGHT_CURLY_BRACKET)
1351       goto EXIT;
1352     if (max < min)
1353       {
1354       *errorcodeptr = ERR4;
1355       goto EXIT;
1356       }
1357     }
1358   p++;
1359   }
1360
1361 yield = TRUE;
1362 if (minp != NULL) *minp = (uint32_t)min;
1363 if (maxp != NULL) *maxp = (uint32_t)max;
1364
1365 /* Update the pattern pointer on success, or after an error, but not when
1366 the result is "not a repeat quantifier". */
1367
1368 EXIT:
1369 if (yield || *errorcodeptr != 0) *ptrptr = p;
1370 return yield;
1371
1372
1373
1374 }
1375
1376
1377
1378 /*************************************************
1379 *            Handle escapes                      *
1380 *************************************************/
1381
1382 /* This function is called when a \ has been encountered. It either returns a
1383 positive value for a simple escape such as \d, or 0 for a data character, which
1384 is placed in chptr. A backreference to group n is returned as negative n. On
1385 entry, ptr is pointing at the character after \. On exit, it points after the
1386 final code unit of the escape sequence.
1387
1388 This function is also called from pcre2_substitute() to handle escape sequences
1389 in replacement strings. In this case, the cb argument is NULL, and in the case
1390 of escapes that have further processing, only sequences that define a data
1391 character are recognised. The isclass argument is not relevant; the options
1392 argument is the final value of the compiled pattern's options.
1393
1394 Arguments:
1395   ptrptr         points to the input position pointer
1396   ptrend         points to the end of the input
1397   chptr          points to a returned data character
1398   errorcodeptr   points to the errorcode variable (containing zero)
1399   options        the current options bits
1400   isclass        TRUE if inside a character class
1401   cb             compile data block
1402
1403 Returns:         zero => a data character
1404                  positive => a special escape sequence
1405                  negative => a numerical back reference
1406                  on error, errorcodeptr is set non-zero
1407 */
1408
1409 int
1410 PRIV(check_escape)(PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, uint32_t *chptr,
1411   int *errorcodeptr, uint32_t options, BOOL isclass, compile_block *cb)
1412 {
1413 BOOL utf = (options & PCRE2_UTF) != 0;
1414 PCRE2_SPTR ptr = *ptrptr;
1415 uint32_t c, cc;
1416 int escape = 0;
1417 int i;
1418
1419 /* If backslash is at the end of the string, it's an error. */
1420
1421 if (ptr >= ptrend)
1422   {
1423   *errorcodeptr = ERR1;
1424   return 0;
1425   }
1426
1427 GETCHARINCTEST(c, ptr);         /* Get character value, increment pointer */
1428 *errorcodeptr = 0;              /* Be optimistic */
1429
1430 /* Non-alphanumerics are literals, so we just leave the value in c. An initial
1431 value test saves a memory lookup for code points outside the alphanumeric
1432 range. Otherwise, do a table lookup. A non-zero result is something that can be
1433 returned immediately. Otherwise further processing is required. */
1434
1435 if (c < ESCAPES_FIRST || c > ESCAPES_LAST) {}  /* Definitely literal */
1436
1437 else if ((i = escapes[c - ESCAPES_FIRST]) != 0)
1438   {
1439   if (i > 0) c = (uint32_t)i; else  /* Positive is a data character */
1440     {
1441     escape = -i;                    /* Else return a special escape */
1442     if (cb != NULL && (escape == ESC_P || escape == ESC_p || escape == ESC_X))
1443       cb->external_flags |= PCRE2_HASBKPORX;   /* Note \P, \p, or \X */
1444
1445     /* Perl supports \N{name} for character names and \N{U+dddd} for numerical
1446     Unicode code points, as well as plain \N for "not newline". PCRE does not
1447     support \N{name}. However, it does support quantification such as \N{2,3},
1448     so if \N{ is not followed by U+dddd we check for a quantifier. */
1449
1450     if (escape == ESC_N && ptr < ptrend && *ptr == CHAR_LEFT_CURLY_BRACKET)
1451       {
1452       PCRE2_SPTR p = ptr + 1;
1453
1454       /* \N{U+ can be handled by the \x{ code. However, this construction is
1455       not valid in EBCDIC environments because it specifies a Unicode
1456       character, not a codepoint in the local code. For example \N{U+0041}
1457       must be "A" in all environments. Also, in Perl, \N{U+ forces Unicode
1458       casing semantics for the entire pattern, so allow it only in UTF (i.e.
1459       Unicode) mode. */
1460
1461       if (ptrend - p > 1 && *p == CHAR_U && p[1] == CHAR_PLUS)
1462         {
1463 #ifdef EBCDIC
1464         *errorcodeptr = ERR93;
1465 #else
1466         if (utf)
1467           {
1468           ptr = p + 1;
1469           escape = 0;   /* Not a fancy escape after all */
1470           goto COME_FROM_NU;
1471           }
1472         else *errorcodeptr = ERR93;
1473 #endif
1474         }
1475
1476       /* Give an error if what follows is not a quantifier, but don't override
1477       an error set by the quantifier reader (e.g. number overflow). */
1478
1479       else
1480         {
1481         if (!read_repeat_counts(&p, ptrend, NULL, NULL, errorcodeptr) &&
1482              *errorcodeptr == 0)
1483           *errorcodeptr = ERR37;
1484         }
1485       }
1486     }
1487   }
1488
1489 /* Escapes that need further processing, including those that are unknown.
1490 When called from pcre2_substitute(), only \c, \o, and \x are recognized (and \u
1491 when BSUX is set). */
1492
1493 else
1494   {
1495   PCRE2_SPTR oldptr;
1496   BOOL overflow;
1497   int s;
1498
1499   /* Filter calls from pcre2_substitute(). */
1500
1501   if (cb == NULL && c != CHAR_c && c != CHAR_o && c != CHAR_x &&
1502       (c != CHAR_u || (options & PCRE2_ALT_BSUX) != 0))
1503     {
1504     *errorcodeptr = ERR3;
1505     return 0;
1506     }
1507
1508   switch (c)
1509     {
1510     /* A number of Perl escapes are not handled by PCRE. We give an explicit
1511     error. */
1512
1513     case CHAR_F:
1514     case CHAR_l:
1515     case CHAR_L:
1516     *errorcodeptr = ERR37;
1517     break;
1518
1519     /* \u is unrecognized when PCRE2_ALT_BSUX is not set. When it is treated
1520     specially, \u must be followed by four hex digits. Otherwise it is a
1521     lowercase u letter. */
1522
1523     case CHAR_u:
1524     if ((options & PCRE2_ALT_BSUX) == 0) *errorcodeptr = ERR37; else
1525       {
1526       uint32_t xc;
1527       if (ptrend - ptr < 4) break;              /* Less than 4 chars */
1528       if ((cc = XDIGIT(ptr[0])) == 0xff) break;  /* Not a hex digit */
1529       if ((xc = XDIGIT(ptr[1])) == 0xff) break;  /* Not a hex digit */
1530       cc = (cc << 4) | xc;
1531       if ((xc = XDIGIT(ptr[2])) == 0xff) break;  /* Not a hex digit */
1532       cc = (cc << 4) | xc;
1533       if ((xc = XDIGIT(ptr[3])) == 0xff) break;  /* Not a hex digit */
1534       c = (cc << 4) | xc;
1535       ptr += 4;
1536       if (utf)
1537         {
1538         if (c > 0x10ffffU) *errorcodeptr = ERR77;
1539         else
1540           if (c >= 0xd800 && c <= 0xdfff &&
1541             (cb->cx->extra_options & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0)
1542               *errorcodeptr = ERR73;
1543         }
1544       else if (c > MAX_NON_UTF_CHAR) *errorcodeptr = ERR77;
1545       }
1546     break;
1547
1548     /* \U is unrecognized unless PCRE2_ALT_BSUX is set, in which case it is an
1549     upper case letter. */
1550
1551     case CHAR_U:
1552     if ((options & PCRE2_ALT_BSUX) == 0) *errorcodeptr = ERR37;
1553     break;
1554
1555     /* In a character class, \g is just a literal "g". Outside a character
1556     class, \g must be followed by one of a number of specific things:
1557
1558     (1) A number, either plain or braced. If positive, it is an absolute
1559     backreference. If negative, it is a relative backreference. This is a Perl
1560     5.10 feature.
1561
1562     (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
1563     is part of Perl's movement towards a unified syntax for back references. As
1564     this is synonymous with \k{name}, we fudge it up by pretending it really
1565     was \k{name}.
1566
1567     (3) For Oniguruma compatibility we also support \g followed by a name or a
1568     number either in angle brackets or in single quotes. However, these are
1569     (possibly recursive) subroutine calls, _not_ backreferences. We return
1570     the ESC_g code.
1571
1572     Summary: Return a negative number for a numerical back reference, ESC_k for
1573     a named back reference, and ESC_g for a named or numbered subroutine call.
1574     */
1575
1576     case CHAR_g:
1577     if (isclass) break;
1578
1579     if (ptr >= ptrend)
1580       {
1581       *errorcodeptr = ERR57;
1582       break;
1583       }
1584
1585     if (*ptr == CHAR_LESS_THAN_SIGN || *ptr == CHAR_APOSTROPHE)
1586       {
1587       escape = ESC_g;
1588       break;
1589       }
1590
1591     /* If there is a brace delimiter, try to read a numerical reference. If
1592     there isn't one, assume we have a name and treat it as \k. */
1593
1594     if (*ptr == CHAR_LEFT_CURLY_BRACKET)
1595       {
1596       PCRE2_SPTR p = ptr + 1;
1597       if (!read_number(&p, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &s,
1598           errorcodeptr))
1599         {
1600         if (*errorcodeptr == 0) escape = ESC_k;  /* No number found */
1601         break;
1602         }
1603       if (p >= ptrend || *p != CHAR_RIGHT_CURLY_BRACKET)
1604         {
1605         *errorcodeptr = ERR57;
1606         break;
1607         }
1608       ptr = p + 1;
1609       }
1610
1611     /* Read an undelimited number */
1612
1613     else
1614       {
1615       if (!read_number(&ptr, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &s,
1616           errorcodeptr))
1617         {
1618         if (*errorcodeptr == 0) *errorcodeptr = ERR57;  /* No number found */
1619         break;
1620         }
1621       }
1622
1623     if (s <= 0)
1624       {
1625       *errorcodeptr = ERR15;
1626       break;
1627       }
1628
1629     escape = -s;
1630     break;
1631
1632     /* The handling of escape sequences consisting of a string of digits
1633     starting with one that is not zero is not straightforward. Perl has changed
1634     over the years. Nowadays \g{} for backreferences and \o{} for octal are
1635     recommended to avoid the ambiguities in the old syntax.
1636
1637     Outside a character class, the digits are read as a decimal number. If the
1638     number is less than 10, or if there are that many previous extracting left
1639     brackets, it is a back reference. Otherwise, up to three octal digits are
1640     read to form an escaped character code. Thus \123 is likely to be octal 123
1641     (cf \0123, which is octal 012 followed by the literal 3).
1642
1643     Inside a character class, \ followed by a digit is always either a literal
1644     8 or 9 or an octal number. */
1645
1646     case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:
1647     case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
1648
1649     if (!isclass)
1650       {
1651       oldptr = ptr;
1652       ptr--;   /* Back to the digit */
1653       if (!read_number(&ptr, ptrend, -1, INT_MAX/10 - 1, ERR61, &s,
1654           errorcodeptr))
1655         break;
1656
1657       /* \1 to \9 are always back references. \8x and \9x are too; \1x to \7x
1658       are octal escapes if there are not that many previous captures. */
1659
1660       if (s < 10 || oldptr[-1] >= CHAR_8 || s <= (int)cb->bracount)
1661         {
1662         if (s > (int)MAX_GROUP_NUMBER) *errorcodeptr = ERR61;
1663           else escape = -s;     /* Indicates a back reference */
1664         break;
1665         }
1666       ptr = oldptr;      /* Put the pointer back and fall through */
1667       }
1668
1669     /* Handle a digit following \ when the number is not a back reference, or
1670     we are within a character class. If the first digit is 8 or 9, Perl used to
1671     generate a binary zero and then treat the digit as a following literal. At
1672     least by Perl 5.18 this changed so as not to insert the binary zero. */
1673
1674     if (c >= CHAR_8) break;
1675
1676     /* Fall through */
1677
1678     /* \0 always starts an octal number, but we may drop through to here with a
1679     larger first octal digit. The original code used just to take the least
1680     significant 8 bits of octal numbers (I think this is what early Perls used
1681     to do). Nowadays we allow for larger numbers in UTF-8 mode and 16-bit mode,
1682     but no more than 3 octal digits. */
1683
1684     case CHAR_0:
1685     c -= CHAR_0;
1686     while(i++ < 2 && ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7)
1687         c = c * 8 + *ptr++ - CHAR_0;
1688 #if PCRE2_CODE_UNIT_WIDTH == 8
1689     if (!utf && c > 0xff) *errorcodeptr = ERR51;
1690 #endif
1691     break;
1692
1693     /* \o is a relatively new Perl feature, supporting a more general way of
1694     specifying character codes in octal. The only supported form is \o{ddd}. */
1695
1696     case CHAR_o:
1697     if (ptr >= ptrend || *ptr++ != CHAR_LEFT_CURLY_BRACKET)
1698       {
1699       ptr--;
1700       *errorcodeptr = ERR55;
1701       }
1702     else if (ptr >= ptrend || *ptr == CHAR_RIGHT_CURLY_BRACKET)
1703       *errorcodeptr = ERR78;
1704     else
1705       {
1706       c = 0;
1707       overflow = FALSE;
1708       while (ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7)
1709         {
1710         cc = *ptr++;
1711         if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
1712 #if PCRE2_CODE_UNIT_WIDTH == 32
1713         if (c >= 0x20000000l) { overflow = TRUE; break; }
1714 #endif
1715         c = (c << 3) + (cc - CHAR_0);
1716 #if PCRE2_CODE_UNIT_WIDTH == 8
1717         if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
1718 #elif PCRE2_CODE_UNIT_WIDTH == 16
1719         if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
1720 #elif PCRE2_CODE_UNIT_WIDTH == 32
1721         if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
1722 #endif
1723         }
1724       if (overflow)
1725         {
1726         while (ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++;
1727         *errorcodeptr = ERR34;
1728         }
1729       else if (ptr < ptrend && *ptr++ == CHAR_RIGHT_CURLY_BRACKET)
1730         {
1731         if (utf && c >= 0xd800 && c <= 0xdfff && (cb == NULL ||
1732             (cb->cx->extra_options & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0))
1733           {
1734           ptr--;
1735           *errorcodeptr = ERR73;
1736           }
1737         }
1738       else
1739         {
1740         ptr--;
1741         *errorcodeptr = ERR64;
1742         }
1743       }
1744     break;
1745
1746     /* \x is complicated. When PCRE2_ALT_BSUX is set, \x must be followed by
1747     two hexadecimal digits. Otherwise it is a lowercase x letter. */
1748
1749     case CHAR_x:
1750     if ((options & PCRE2_ALT_BSUX) != 0)
1751       {
1752       uint32_t xc;
1753       if (ptrend - ptr < 2) break;               /* Less than 2 characters */
1754       if ((cc = XDIGIT(ptr[0])) == 0xff) break;  /* Not a hex digit */
1755       if ((xc = XDIGIT(ptr[1])) == 0xff) break;  /* Not a hex digit */
1756       c = (cc << 4) | xc;
1757       ptr += 2;
1758       }    /* End PCRE2_ALT_BSUX handling */
1759
1760     /* Handle \x in Perl's style. \x{ddd} is a character number which can be
1761     greater than 0xff in UTF-8 or non-8bit mode, but only if the ddd are hex
1762     digits. If not, { used to be treated as a data character. However, Perl
1763     seems to read hex digits up to the first non-such, and ignore the rest, so
1764     that, for example \x{zz} matches a binary zero. This seems crazy, so PCRE
1765     now gives an error. */
1766
1767     else
1768       {
1769       if (ptr < ptrend && *ptr == CHAR_LEFT_CURLY_BRACKET)
1770         {
1771 #ifndef EBCDIC
1772         COME_FROM_NU:
1773 #endif
1774         if (++ptr >= ptrend || *ptr == CHAR_RIGHT_CURLY_BRACKET)
1775           {
1776           *errorcodeptr = ERR78;
1777           break;
1778           }
1779         c = 0;
1780         overflow = FALSE;
1781
1782         while (ptr < ptrend && (cc = XDIGIT(*ptr)) != 0xff)
1783           {
1784           ptr++;
1785           if (c == 0 && cc == 0) continue;   /* Leading zeroes */
1786 #if PCRE2_CODE_UNIT_WIDTH == 32
1787           if (c >= 0x10000000l) { overflow = TRUE; break; }
1788 #endif
1789           c = (c << 4) | cc;
1790           if ((utf && c > 0x10ffffU) || (!utf && c > MAX_NON_UTF_CHAR))
1791             {
1792             overflow = TRUE;
1793             break;
1794             }
1795           }
1796
1797         if (overflow)
1798           {
1799           while (ptr < ptrend && XDIGIT(*ptr) != 0xff) ptr++;
1800           *errorcodeptr = ERR34;
1801           }
1802         else if (ptr < ptrend && *ptr++ == CHAR_RIGHT_CURLY_BRACKET)
1803           {
1804           if (utf && c >= 0xd800 && c <= 0xdfff && (cb == NULL ||
1805               (cb->cx->extra_options & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0))
1806             {
1807             ptr--;
1808             *errorcodeptr = ERR73;
1809             }
1810           }
1811
1812         /* If the sequence of hex digits does not end with '}', give an error.
1813         We used just to recognize this construct and fall through to the normal
1814         \x handling, but nowadays Perl gives an error, which seems much more
1815         sensible, so we do too. */
1816
1817         else
1818           {
1819           ptr--;
1820           *errorcodeptr = ERR67;
1821           }
1822         }   /* End of \x{} processing */
1823
1824       /* Read a up to two hex digits after \x */
1825
1826       else
1827         {
1828         c = 0;
1829         if (ptr >= ptrend || (cc = XDIGIT(*ptr)) == 0xff) break;  /* Not a hex digit */
1830         ptr++;
1831         c = cc;
1832         if (ptr >= ptrend || (cc = XDIGIT(*ptr)) == 0xff) break;  /* Not a hex digit */
1833         ptr++;
1834         c = (c << 4) | cc;
1835         }     /* End of \xdd handling */
1836       }       /* End of Perl-style \x handling */
1837     break;
1838
1839     /* The handling of \c is different in ASCII and EBCDIC environments. In an
1840     ASCII (or Unicode) environment, an error is given if the character
1841     following \c is not a printable ASCII character. Otherwise, the following
1842     character is upper-cased if it is a letter, and after that the 0x40 bit is
1843     flipped. The result is the value of the escape.
1844
1845     In an EBCDIC environment the handling of \c is compatible with the
1846     specification in the perlebcdic document. The following character must be
1847     a letter or one of small number of special characters. These provide a
1848     means of defining the character values 0-31.
1849
1850     For testing the EBCDIC handling of \c in an ASCII environment, recognize
1851     the EBCDIC value of 'c' explicitly. */
1852
1853 #if defined EBCDIC && 'a' != 0x81
1854     case 0x83:
1855 #else
1856     case CHAR_c:
1857 #endif
1858     if (ptr >= ptrend)
1859       {
1860       *errorcodeptr = ERR2;
1861       break;
1862       }
1863     c = *ptr;
1864     if (c >= CHAR_a && c <= CHAR_z) c = UPPER_CASE(c);
1865
1866     /* Handle \c in an ASCII/Unicode environment. */
1867
1868 #ifndef EBCDIC    /* ASCII/UTF-8 coding */
1869     if (c < 32 || c > 126)  /* Excludes all non-printable ASCII */
1870       {
1871       *errorcodeptr = ERR68;
1872       break;
1873       }
1874     c ^= 0x40;
1875
1876     /* Handle \c in an EBCDIC environment. The special case \c? is converted to
1877     255 (0xff) or 95 (0x5f) if other character suggest we are using th POSIX-BC
1878     encoding. (This is the way Perl indicates that it handles \c?.) The other
1879     valid sequences correspond to a list of specific characters. */
1880
1881 #else
1882     if (c == CHAR_QUESTION_MARK)
1883       c = ('\\' == 188 && '`' == 74)? 0x5f : 0xff;
1884     else
1885       {
1886       for (i = 0; i < 32; i++)
1887         {
1888         if (c == ebcdic_escape_c[i]) break;
1889         }
1890       if (i < 32) c = i; else *errorcodeptr = ERR68;
1891       }
1892 #endif  /* EBCDIC */
1893
1894     ptr++;
1895     break;
1896
1897     /* Any other alphanumeric following \ is an error. Perl gives an error only
1898     if in warning mode, but PCRE doesn't have a warning mode. */
1899
1900     default:
1901     *errorcodeptr = ERR3;
1902     *ptrptr = ptr - 1;     /* Point to the character at fault */
1903     return 0;
1904     }
1905   }
1906
1907 /* Set the pointer to the next character before returning. */
1908
1909 *ptrptr = ptr;
1910 *chptr = c;
1911 return escape;
1912 }
1913
1914
1915
1916 #ifdef SUPPORT_UNICODE
1917 /*************************************************
1918 *               Handle \P and \p                 *
1919 *************************************************/
1920
1921 /* This function is called after \P or \p has been encountered, provided that
1922 PCRE2 is compiled with support for UTF and Unicode properties. On entry, the
1923 contents of ptrptr are pointing after the P or p. On exit, it is left pointing
1924 after the final code unit of the escape sequence.
1925
1926 Arguments:
1927   ptrptr         the pattern position pointer
1928   negptr         a boolean that is set TRUE for negation else FALSE
1929   ptypeptr       an unsigned int that is set to the type value
1930   pdataptr       an unsigned int that is set to the detailed property value
1931   errorcodeptr   the error code variable
1932   cb             the compile data
1933
1934 Returns:         TRUE if the type value was found, or FALSE for an invalid type
1935 */
1936
1937 static BOOL
1938 get_ucp(PCRE2_SPTR *ptrptr, BOOL *negptr, uint16_t *ptypeptr,
1939   uint16_t *pdataptr, int *errorcodeptr, compile_block *cb)
1940 {
1941 PCRE2_UCHAR c;
1942 PCRE2_SIZE i, bot, top;
1943 PCRE2_SPTR ptr = *ptrptr;
1944 PCRE2_UCHAR name[32];
1945
1946 if (ptr >= cb->end_pattern) goto ERROR_RETURN;
1947 c = *ptr++;
1948 *negptr = FALSE;
1949
1950 /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
1951 negation. */
1952
1953 if (c == CHAR_LEFT_CURLY_BRACKET)
1954   {
1955   if (ptr >= cb->end_pattern) goto ERROR_RETURN;
1956   if (*ptr == CHAR_CIRCUMFLEX_ACCENT)
1957     {
1958     *negptr = TRUE;
1959     ptr++;
1960     }
1961   for (i = 0; i < (int)(sizeof(name) / sizeof(PCRE2_UCHAR)) - 1; i++)
1962     {
1963     if (ptr >= cb->end_pattern) goto ERROR_RETURN;
1964     c = *ptr++;
1965     if (c == CHAR_NUL) goto ERROR_RETURN;
1966     if (c == CHAR_RIGHT_CURLY_BRACKET) break;
1967     name[i] = c;
1968     }
1969   if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;
1970   name[i] = 0;
1971   }
1972
1973 /* Otherwise there is just one following character, which must be an ASCII
1974 letter. */
1975
1976 else if (MAX_255(c) && (cb->ctypes[c] & ctype_letter) != 0)
1977   {
1978   name[0] = c;
1979   name[1] = 0;
1980   }
1981 else goto ERROR_RETURN;
1982
1983 *ptrptr = ptr;
1984
1985 /* Search for a recognized property name using binary chop. */
1986
1987 bot = 0;
1988 top = PRIV(utt_size);
1989
1990 while (bot < top)
1991   {
1992   int r;
1993   i = (bot + top) >> 1;
1994   r = PRIV(strcmp_c8)(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);
1995   if (r == 0)
1996     {
1997     *ptypeptr = PRIV(utt)[i].type;
1998     *pdataptr = PRIV(utt)[i].value;
1999     return TRUE;
2000     }
2001   if (r > 0) bot = i + 1; else top = i;
2002   }
2003 *errorcodeptr = ERR47;   /* Unrecognized name */
2004 return FALSE;
2005
2006 ERROR_RETURN:            /* Malformed \P or \p */
2007 *errorcodeptr = ERR46;
2008 *ptrptr = ptr;
2009 return FALSE;
2010 }
2011 #endif
2012
2013
2014
2015 /*************************************************
2016 *           Check for POSIX class syntax         *
2017 *************************************************/
2018
2019 /* This function is called when the sequence "[:" or "[." or "[=" is
2020 encountered in a character class. It checks whether this is followed by a
2021 sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
2022 reach an unescaped ']' without the special preceding character, return FALSE.
2023
2024 Originally, this function only recognized a sequence of letters between the
2025 terminators, but it seems that Perl recognizes any sequence of characters,
2026 though of course unknown POSIX names are subsequently rejected. Perl gives an
2027 "Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
2028 didn't consider this to be a POSIX class. Likewise for [:1234:].
2029
2030 The problem in trying to be exactly like Perl is in the handling of escapes. We
2031 have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
2032 class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
2033 below handles the special cases \\ and \], but does not try to do any other
2034 escape processing. This makes it different from Perl for cases such as
2035 [:l\ower:] where Perl recognizes it as the POSIX class "lower" but PCRE does
2036 not recognize "l\ower". This is a lesser evil than not diagnosing bad classes
2037 when Perl does, I think.
2038
2039 A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.
2040 It seems that the appearance of a nested POSIX class supersedes an apparent
2041 external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or
2042 a digit. This is handled by returning FALSE if the start of a new group with
2043 the same terminator is encountered, since the next closing sequence must close
2044 the nested group, not the outer one.
2045
2046 In Perl, unescaped square brackets may also appear as part of class names. For
2047 example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for
2048 [:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not
2049 seem right at all. PCRE does not allow closing square brackets in POSIX class
2050 names.
2051
2052 Arguments:
2053   ptr      pointer to the character after the initial [ (colon, dot, equals)
2054   ptrend   pointer to the end of the pattern
2055   endptr   where to return a pointer to the terminating ':', '.', or '='
2056
2057 Returns:   TRUE or FALSE
2058 */
2059
2060 static BOOL
2061 check_posix_syntax(PCRE2_SPTR ptr, PCRE2_SPTR ptrend, PCRE2_SPTR *endptr)
2062 {
2063 PCRE2_UCHAR terminator;  /* Don't combine these lines; the Solaris cc */
2064 terminator = *ptr++;     /* compiler warns about "non-constant" initializer. */
2065
2066 for (; ptrend - ptr >= 2; ptr++)
2067   {
2068   if (*ptr == CHAR_BACKSLASH &&
2069       (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET || ptr[1] == CHAR_BACKSLASH))
2070     ptr++;
2071
2072   else if ((*ptr == CHAR_LEFT_SQUARE_BRACKET && ptr[1] == terminator) ||
2073             *ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
2074
2075   else if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
2076     {
2077     *endptr = ptr;
2078     return TRUE;
2079     }
2080   }
2081
2082 return FALSE;
2083 }
2084
2085
2086
2087 /*************************************************
2088 *          Check POSIX class name                *
2089 *************************************************/
2090
2091 /* This function is called to check the name given in a POSIX-style class entry
2092 such as [:alnum:].
2093
2094 Arguments:
2095   ptr        points to the first letter
2096   len        the length of the name
2097
2098 Returns:     a value representing the name, or -1 if unknown
2099 */
2100
2101 static int
2102 check_posix_name(PCRE2_SPTR ptr, int len)
2103 {
2104 const char *pn = posix_names;
2105 int yield = 0;
2106 while (posix_name_lengths[yield] != 0)
2107   {
2108   if (len == posix_name_lengths[yield] &&
2109     PRIV(strncmp_c8)(ptr, pn, (unsigned int)len) == 0) return yield;
2110   pn += posix_name_lengths[yield] + 1;
2111   yield++;
2112   }
2113 return -1;
2114 }
2115
2116
2117
2118 /*************************************************
2119 *       Read a subpattern or VERB name           *
2120 *************************************************/
2121
2122 /* This function is called from parse_regex() below whenever it needs to read
2123 the name of a subpattern or a (*VERB). The initial pointer must be to the
2124 character before the name. If that character is '*' we are reading a verb name.
2125 The pointer is updated to point after the name, for a VERB, or after tha name's
2126 terminator for a subpattern name. Returning both the offset and the name
2127 pointer is redundant information, but some callers use one and some the other,
2128 so it is simplest just to return both.
2129
2130 Arguments:
2131   ptrptr      points to the character pointer variable
2132   ptrend      points to the end of the input string
2133   terminator  the terminator of a subpattern name must be this
2134   offsetptr   where to put the offset from the start of the pattern
2135   nameptr     where to put a pointer to the name in the input
2136   namelenptr  where to put the length of the name
2137   errcodeptr  where to put an error code
2138   cb          pointer to the compile data block
2139
2140 Returns:    TRUE if a name was read
2141             FALSE otherwise, with error code set
2142 */
2143
2144 static BOOL
2145 read_name(PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, uint32_t terminator,
2146   PCRE2_SIZE *offsetptr, PCRE2_SPTR *nameptr, uint32_t *namelenptr,
2147   int *errorcodeptr, compile_block *cb)
2148 {
2149 PCRE2_SPTR ptr = *ptrptr;
2150 BOOL is_verb = (*ptr == CHAR_ASTERISK);
2151 uint32_t namelen = 0;
2152 uint32_t ctype = is_verb? ctype_letter : ctype_word;
2153
2154 if (++ptr >= ptrend)
2155   {
2156   *errorcodeptr = is_verb? ERR60:  /* Verb not recognized or malformed */
2157                            ERR62;  /* Subpattern name expected */
2158   goto FAILED;
2159   }
2160
2161 *nameptr = ptr;
2162 *offsetptr = (PCRE2_SIZE)(ptr - cb->start_pattern);
2163
2164 if (IS_DIGIT(*ptr))
2165   {
2166   *errorcodeptr = ERR44;   /* Group name must not start with digit */
2167   goto FAILED;
2168   }
2169
2170 while (ptr < ptrend && MAX_255(*ptr) && (cb->ctypes[*ptr] & ctype) != 0)
2171   {
2172   ptr++;
2173   namelen++;
2174   if (namelen > MAX_NAME_SIZE)
2175     {
2176     *errorcodeptr = ERR48;
2177     goto FAILED;
2178     }
2179   }
2180
2181 /* Subpattern names must not be empty, and their terminator is checked here.
2182 (What follows a verb name is checked separately.) */
2183
2184 if (!is_verb)
2185   {
2186   if (namelen == 0)
2187     {
2188     *errorcodeptr = ERR62;   /* Subpattern name expected */
2189     goto FAILED;
2190     }
2191   if (ptr >= ptrend || *ptr != (PCRE2_UCHAR)terminator)
2192     {
2193     *errorcodeptr = ERR42;
2194     goto FAILED;
2195     }
2196   ptr++;
2197   }
2198
2199 *namelenptr = namelen;
2200 *ptrptr = ptr;
2201 return TRUE;
2202
2203 FAILED:
2204 *ptrptr = ptr;
2205 return FALSE;
2206 }
2207
2208
2209
2210 /*************************************************
2211 *          Manage callouts at start of cycle     *
2212 *************************************************/
2213
2214 /* At the start of a new item in parse_regex() we are able to record the
2215 details of the previous item in a prior callout, and also to set up an
2216 automatic callout if enabled. Avoid having two adjacent automatic callouts,
2217 which would otherwise happen for items such as \Q that contribute nothing to
2218 the parsed pattern.
2219
2220 Arguments:
2221   ptr              current pattern pointer
2222   pcalloutptr      points to a pointer to previous callout, or NULL
2223   auto_callout     TRUE if auto_callouts are enabled
2224   parsed_pattern   the parsed pattern pointer
2225   cb               compile block
2226
2227 Returns: possibly updated parsed_pattern pointer.
2228 */
2229
2230 static uint32_t *
2231 manage_callouts(PCRE2_SPTR ptr, uint32_t **pcalloutptr, BOOL auto_callout,
2232   uint32_t *parsed_pattern, compile_block *cb)
2233 {
2234 uint32_t *previous_callout = *pcalloutptr;
2235
2236 if (previous_callout != NULL) previous_callout[2] = (uint32_t)(ptr -
2237   cb->start_pattern - (PCRE2_SIZE)previous_callout[1]);
2238
2239 if (!auto_callout) previous_callout = NULL; else
2240   {
2241   if (previous_callout == NULL ||
2242       previous_callout != parsed_pattern - 4 ||
2243       previous_callout[3] != 255)
2244     {
2245     previous_callout = parsed_pattern;  /* Set up new automatic callout */
2246     parsed_pattern += 4;
2247     previous_callout[0] = META_CALLOUT_NUMBER;
2248     previous_callout[2] = 0;
2249     previous_callout[3] = 255;
2250     }
2251   previous_callout[1] = (uint32_t)(ptr - cb->start_pattern);
2252   }
2253
2254 *pcalloutptr = previous_callout;
2255 return parsed_pattern;
2256 }
2257
2258
2259
2260 /*************************************************
2261 *      Parse regex and identify named groups     *
2262 *************************************************/
2263
2264 /* This function is called first of all. It scans the pattern and does two
2265 things: (1) It identifies capturing groups and makes a table of named capturing
2266 groups so that information about them is fully available to both the compiling
2267 scans. (2) It writes a parsed version of the pattern with comments omitted and
2268 escapes processed into the parsed_pattern vector.
2269
2270 Arguments:
2271   ptr             points to the start of the pattern
2272   options         compiling dynamic options (may change during the scan)
2273   has_lookbehind  points to a boolean, set TRUE if a lookbehind is found
2274   cb              pointer to the compile data block
2275
2276 Returns:   zero on success or a non-zero error code, with the
2277              error offset placed in the cb field
2278 */
2279
2280 /* A structure and some flags for dealing with nested groups. */
2281
2282 typedef struct nest_save {
2283   uint16_t  nest_depth;
2284   uint16_t  reset_group;
2285   uint16_t  max_group;
2286   uint16_t  flags;
2287   uint32_t  options;
2288 } nest_save;
2289
2290 #define NSF_RESET          0x0001u
2291 #define NSF_CONDASSERT     0x0002u
2292
2293 /* Options that are changeable within the pattern must be tracked during
2294 parsing. Some (e.g. PCRE2_EXTENDED) are implemented entirely during parsing,
2295 but all must be tracked so that META_OPTIONS items set the correct values for
2296 the main compiling phase. */
2297
2298 #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \
2299   PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \
2300   PCRE2_UNGREEDY)
2301
2302 /* States used for analyzing ranges in character classes. The two OK values
2303 must be last. */
2304
2305 enum { RANGE_NO, RANGE_STARTED, RANGE_OK_ESCAPED, RANGE_OK_LITERAL };
2306
2307 /* Only in 32-bit mode can there be literals > META_END. A macros encapsulates
2308 the storing of literal values in the parsed pattern. */
2309
2310 #if PCRE2_CODE_UNIT_WIDTH == 32
2311 #define PARSED_LITERAL(c, p) \
2312   { \
2313   if (c >= META_END) *p++ = META_BIGVALUE; \
2314   *p++ = c; \
2315   okquantifier = TRUE; \
2316   }
2317 #else
2318 #define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE;
2319 #endif
2320
2321 /* Here's the actual function. */
2322
2323 static int parse_regex(PCRE2_SPTR ptr, uint32_t options, BOOL *has_lookbehind,
2324   compile_block *cb)
2325 {
2326 uint32_t c;
2327 uint32_t delimiter;
2328 uint32_t namelen;
2329 uint32_t class_range_state;
2330 uint32_t *verblengthptr = NULL;     /* Value avoids compiler warning */
2331 uint32_t *previous_callout = NULL;
2332 uint32_t *parsed_pattern = cb->parsed_pattern;
2333 uint32_t *parsed_pattern_end = cb->parsed_pattern_end;
2334 uint32_t meta_quantifier = 0;
2335 uint32_t add_after_mark = 0;
2336 uint16_t nest_depth = 0;
2337 int after_manual_callout = 0;
2338 int expect_cond_assert = 0;
2339 int errorcode = 0;
2340 int escape;
2341 int i;
2342 BOOL inescq = FALSE;
2343 BOOL inverbname = FALSE;
2344 BOOL utf = (options & PCRE2_UTF) != 0;
2345 BOOL auto_callout = (options & PCRE2_AUTO_CALLOUT) != 0;
2346 BOOL isdupname;
2347 BOOL negate_class;
2348 BOOL okquantifier = FALSE;
2349 PCRE2_SPTR thisptr;
2350 PCRE2_SPTR name;
2351 PCRE2_SPTR ptrend = cb->end_pattern;
2352 PCRE2_SPTR verbnamestart = NULL;    /* Value avoids compiler warning */
2353 named_group *ng;
2354 nest_save *top_nest, *end_nests;
2355
2356 /* Insert leading items for word and line matching (features provided for the
2357 benefit of pcre2grep). */
2358
2359 if ((cb->cx->extra_options & PCRE2_EXTRA_MATCH_LINE) != 0)
2360   {
2361   *parsed_pattern++ = META_CIRCUMFLEX;
2362   *parsed_pattern++ = META_NOCAPTURE;
2363   }
2364 else if ((cb->cx->extra_options & PCRE2_EXTRA_MATCH_WORD) != 0)
2365   {
2366   *parsed_pattern++ = META_ESCAPE + ESC_b;
2367   *parsed_pattern++ = META_NOCAPTURE;
2368   }
2369
2370 /* If the pattern is actually a literal string, process it separately to avoid
2371 cluttering up the main loop. */
2372
2373 if ((options & PCRE2_LITERAL) != 0)
2374   {
2375   while (ptr < ptrend)
2376     {
2377     if (parsed_pattern >= parsed_pattern_end)
2378       {
2379       errorcode = ERR63;  /* Internal error (parsed pattern overflow) */
2380       goto FAILED;
2381       }
2382     thisptr = ptr;
2383     GETCHARINCTEST(c, ptr);
2384     if (auto_callout)
2385       parsed_pattern = manage_callouts(thisptr, &previous_callout,
2386         auto_callout, parsed_pattern, cb);
2387     PARSED_LITERAL(c, parsed_pattern);
2388     }
2389   goto PARSED_END;
2390   }
2391
2392 /* Process a real regex which may contain meta-characters. */
2393
2394 top_nest = NULL;
2395 end_nests = (nest_save *)(cb->start_workspace + cb->workspace_size);
2396
2397 /* The size of the nest_save structure might not be a factor of the size of the
2398 workspace. Therefore we must round down end_nests so as to correctly avoid
2399 creating a nest_save that spans the end of the workspace. */
2400
2401 end_nests = (nest_save *)((char *)end_nests -
2402   ((cb->workspace_size * sizeof(PCRE2_UCHAR)) % sizeof(nest_save)));
2403
2404 /* PCRE2_EXTENDED_MORE implies PCRE2_EXTENDED */
2405
2406 if ((options & PCRE2_EXTENDED_MORE) != 0) options |= PCRE2_EXTENDED;
2407
2408 /* Now scan the pattern */
2409
2410 while (ptr < ptrend)
2411   {
2412   int prev_expect_cond_assert;
2413   uint32_t min_repeat, max_repeat;
2414   uint32_t set, unset, *optset;
2415   uint32_t terminator;
2416   uint32_t prev_meta_quantifier;
2417   BOOL prev_okquantifier;
2418   PCRE2_SPTR tempptr;
2419   PCRE2_SIZE offset;
2420
2421   if (parsed_pattern >= parsed_pattern_end)
2422     {
2423     errorcode = ERR63;  /* Internal error (parsed pattern overflow) */
2424     goto FAILED;
2425     }
2426
2427   if (nest_depth > cb->cx->parens_nest_limit)
2428     {
2429     errorcode = ERR19;
2430     goto FAILED;        /* Parentheses too deeply nested */
2431     }
2432
2433   /* Get next input character, save its position for callout handling. */
2434
2435   thisptr = ptr;
2436   GETCHARINCTEST(c, ptr);
2437
2438   /* Copy quoted literals until \E, allowing for the possibility of automatic
2439   callouts, except when processing a (*VERB) "name".  */
2440
2441   if (inescq)
2442     {
2443     if (c == CHAR_BACKSLASH && ptr < ptrend && *ptr == CHAR_E)
2444       {
2445       inescq = FALSE;
2446       ptr++;   /* Skip E */
2447       }
2448     else
2449       {
2450       if (expect_cond_assert > 0)   /* A literal is not allowed if we are */
2451         {                           /* expecting a conditional assertion, */
2452         ptr--;                      /* but an empty \Q\E sequence is OK.  */
2453         errorcode = ERR28;
2454         goto FAILED;
2455         }
2456       if (!inverbname && after_manual_callout-- <= 0)
2457         parsed_pattern = manage_callouts(thisptr, &previous_callout,
2458           auto_callout, parsed_pattern, cb);
2459       PARSED_LITERAL(c, parsed_pattern);
2460       meta_quantifier = 0;
2461       }
2462     continue;  /* Next character */
2463     }
2464
2465   /* If we are processing the "name" part of a (*VERB:NAME) item, all
2466   characters up to the closing parenthesis are literals except when
2467   PCRE2_ALT_VERBNAMES is set. That causes backslash interpretation, but only \Q
2468   and \E and escaped characters are allowed (no character types such as \d). If
2469   PCRE2_EXTENDED is also set, we must ignore white space and # comments. Do
2470   this by not entering the special (*VERB:NAME) processing - they are then
2471   picked up below. Note that c is a character, not a code unit, so we must not
2472   use MAX_255 to test its size because MAX_255 tests code units and is assumed
2473   TRUE in 8-bit mode. */
2474
2475   if (inverbname &&
2476        (
2477         /* EITHER: not both options set */
2478         ((options & (PCRE2_EXTENDED | PCRE2_ALT_VERBNAMES)) !=
2479                     (PCRE2_EXTENDED | PCRE2_ALT_VERBNAMES)) ||
2480 #ifdef SUPPORT_UNICODE
2481         /* OR: character > 255 AND not Unicode Pattern White Space */
2482         (c > 255 && (c|1) != 0x200f && (c|1) != 0x2029) ||
2483 #endif
2484         /* OR: not a # comment or isspace() white space */
2485         (c < 256 && c != CHAR_NUMBER_SIGN && (cb->ctypes[c] & ctype_space) == 0
2486 #ifdef SUPPORT_UNICODE
2487         /* and not CHAR_NEL when Unicode is supported */
2488           && c != CHAR_NEL
2489 #endif
2490        )))
2491     {
2492     PCRE2_SIZE verbnamelength;
2493
2494     switch(c)
2495       {
2496       default:
2497       PARSED_LITERAL(c, parsed_pattern);
2498       break;
2499
2500       case CHAR_RIGHT_PARENTHESIS:
2501       inverbname = FALSE;
2502       okquantifier = FALSE;   /* Was probably set by literals */
2503       /* This is the length in characters */
2504       verbnamelength = (PCRE2_SIZE)(parsed_pattern - verblengthptr - 1);
2505       /* But the limit on the length is in code units */
2506       if (ptr - verbnamestart - 1 > (int)MAX_MARK)
2507         {
2508         ptr--;
2509         errorcode = ERR76;
2510         goto FAILED;
2511         }
2512       *verblengthptr = (uint32_t)verbnamelength;
2513
2514       /* If this name was on a verb such as (*ACCEPT) which does not continue,
2515       a (*MARK) was generated for the name. We now add the original verb as the
2516       next item. */
2517
2518       if (add_after_mark != 0)
2519         {
2520         *parsed_pattern++ = add_after_mark;
2521         add_after_mark = 0;
2522         }
2523       break;
2524
2525       case CHAR_BACKSLASH:
2526       if ((options & PCRE2_ALT_VERBNAMES) != 0)
2527         {
2528         escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode, options,
2529           FALSE, cb);
2530         if (errorcode != 0) goto FAILED;
2531         }
2532       else escape = 0;   /* Treat all as literal */
2533
2534       switch(escape)
2535         {
2536         case 0:
2537         PARSED_LITERAL(c, parsed_pattern);
2538         break;
2539
2540         case ESC_Q:
2541         inescq = TRUE;
2542         break;
2543
2544         case ESC_E:           /* Ignore */
2545         break;
2546
2547         default:
2548         errorcode = ERR40;    /* Invalid in verb name */
2549         goto FAILED;
2550         }
2551       }
2552     continue;   /* Next character in pattern */
2553     }
2554
2555   /* Not a verb name character. At this point we must process everything that
2556   must not change the quantification state. This is mainly comments, but we
2557   handle \Q and \E here as well, so that an item such as A\Q\E+ is treated as
2558   A+, as in Perl. An isolated \E is ignored. */
2559
2560   if (c == CHAR_BACKSLASH && ptr < ptrend)
2561     {
2562     if (*ptr == CHAR_Q || *ptr == CHAR_E)
2563       {
2564       inescq = *ptr == CHAR_Q;
2565       ptr++;
2566       continue;
2567       }
2568     }
2569
2570   /* Skip over whitespace and # comments in extended mode. Note that c is a
2571   character, not a code unit, so we must not use MAX_255 to test its size
2572   because MAX_255 tests code units and is assumed TRUE in 8-bit mode. The
2573   whitespace characters are those designated as "Pattern White Space" by
2574   Unicode, which are the isspace() characters plus CHAR_NEL (newline), which is
2575   U+0085 in Unicode, plus U+200E, U+200F, U+2028, and U+2029. These are a
2576   subset of space characters that match \h and \v. */
2577
2578   if ((options & PCRE2_EXTENDED) != 0)
2579     {
2580     if (c < 256 && (cb->ctypes[c] & ctype_space) != 0) continue;
2581 #ifdef SUPPORT_UNICODE
2582     if (c == CHAR_NEL || (c|1) == 0x200f || (c|1) == 0x2029) continue;
2583 #endif
2584     if (c == CHAR_NUMBER_SIGN)
2585       {
2586       while (ptr < ptrend)
2587         {
2588         if (IS_NEWLINE(ptr))      /* For non-fixed-length newline cases, */
2589           {                       /* IS_NEWLINE sets cb->nllen. */
2590           ptr += cb->nllen;
2591           break;
2592           }
2593         ptr++;
2594 #ifdef SUPPORT_UNICODE
2595         if (utf) FORWARDCHARTEST(ptr, ptrend);
2596 #endif
2597         }
2598       continue;  /* Next character in pattern */
2599       }
2600     }
2601
2602   /* Skip over bracketed comments */
2603
2604   if (c == CHAR_LEFT_PARENTHESIS && ptrend - ptr >= 2 &&
2605       ptr[0] == CHAR_QUESTION_MARK && ptr[1] == CHAR_NUMBER_SIGN)
2606     {
2607     while (++ptr < ptrend && *ptr != CHAR_RIGHT_PARENTHESIS);
2608     if (ptr >= ptrend)
2609       {
2610       errorcode = ERR18;  /* A special error for missing ) in a comment */
2611       goto FAILED;        /* to make it easier to debug. */
2612       }
2613     ptr++;
2614     continue;  /* Next character in pattern */
2615     }
2616
2617   /* If the next item is not a quantifier, fill in length of any previous
2618   callout and create an auto callout if required. */
2619
2620   if (c != CHAR_ASTERISK && c != CHAR_PLUS && c != CHAR_QUESTION_MARK &&
2621        (c != CHAR_LEFT_CURLY_BRACKET ||
2622          (tempptr = ptr,
2623          !read_repeat_counts(&tempptr, ptrend, NULL, NULL, &errorcode))))
2624     {
2625     if (after_manual_callout-- <= 0)
2626       parsed_pattern = manage_callouts(thisptr, &previous_callout, auto_callout,
2627         parsed_pattern, cb);
2628     }
2629
2630   /* If expect_cond_assert is 2, we have just passed (?( and are expecting an
2631   assertion, possibly preceded by a callout. If the value is 1, we have just
2632   had the callout and expect an assertion. There must be at least 3 more
2633   characters in all cases. When expect_cond_assert is 2, we know that the
2634   current character is an opening parenthesis, as otherwise we wouldn't be
2635   here. However, when it is 1, we need to check, and it's easiest just to check
2636   always. Note that expect_cond_assert may be negative, since all callouts just
2637   decrement it. */
2638
2639   if (expect_cond_assert > 0)
2640     {
2641     BOOL ok = c == CHAR_LEFT_PARENTHESIS && ptrend - ptr >= 3 &&
2642               ptr[0] == CHAR_QUESTION_MARK;
2643     if (ok) switch(ptr[1])
2644       {
2645       case CHAR_C:
2646       ok = expect_cond_assert == 2;
2647       break;
2648
2649       case CHAR_EQUALS_SIGN:
2650       case CHAR_EXCLAMATION_MARK:
2651       break;
2652
2653       case CHAR_LESS_THAN_SIGN:
2654       ok = ptr[2] == CHAR_EQUALS_SIGN || ptr[2] == CHAR_EXCLAMATION_MARK;
2655       break;
2656
2657       default:
2658       ok = FALSE;
2659       }
2660
2661     if (!ok)
2662       {
2663       ptr--;   /* Adjust error offset */
2664       errorcode = ERR28;
2665       goto FAILED;
2666       }
2667     }
2668
2669   /* Remember whether we are expecting a conditional assertion, and set the
2670   default for this item. */
2671
2672   prev_expect_cond_assert = expect_cond_assert;
2673   expect_cond_assert = 0;
2674
2675   /* Remember quantification status for the previous significant item, then set
2676   default for this item. */
2677
2678   prev_okquantifier = okquantifier;
2679   prev_meta_quantifier = meta_quantifier;
2680   okquantifier = FALSE;
2681   meta_quantifier = 0;
2682
2683   /* If the previous significant item was a quantifier, adjust the parsed code
2684   if there is a following modifier. The base meta value is always followed by
2685   the PLUS and QUERY values, in that order. We do this here rather than after
2686   reading a quantifier so that intervening comments and /x whitespace can be
2687   ignored without having to replicate code. */
2688
2689   if (prev_meta_quantifier != 0 && (c == CHAR_QUESTION_MARK || c == CHAR_PLUS))
2690     {
2691     parsed_pattern[(prev_meta_quantifier == META_MINMAX)? -3 : -1] =
2692       prev_meta_quantifier + ((c == CHAR_QUESTION_MARK)?
2693         0x00020000u : 0x00010000u);
2694     continue;  /* Next character in pattern */
2695     }
2696
2697
2698   /* Process the next item in the main part of a pattern. */
2699
2700   switch(c)
2701     {
2702     default:              /* Non-special character */
2703     PARSED_LITERAL(c, parsed_pattern);
2704     break;
2705
2706
2707     /* ---- Escape sequence ---- */
2708
2709     case CHAR_BACKSLASH:
2710     tempptr = ptr;
2711     escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode, options,
2712       FALSE, cb);
2713     if (errorcode != 0)
2714       {
2715       ESCAPE_FAILED:
2716       if ((cb->cx->extra_options & PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL) == 0)
2717         goto FAILED;
2718       ptr = tempptr;
2719       if (ptr >= ptrend) c = CHAR_BACKSLASH; else
2720         {
2721         GETCHARINCTEST(c, ptr);   /* Get character value, increment pointer */
2722         }
2723       escape = 0;                 /* Treat as literal character */
2724       }
2725
2726     /* The escape was a data escape or literal character. */
2727
2728     if (escape == 0)
2729       {
2730       PARSED_LITERAL(c, parsed_pattern);
2731       }
2732
2733     /* The escape was a back (or forward) reference. We keep the offset in
2734     order to give a more useful diagnostic for a bad forward reference. For
2735     references to groups numbered less than 10 we can't use more than two items
2736     in parsed_pattern because they may be just two characters in the input (and
2737     in a 64-bit world an offset may need two elements). So for them, the offset
2738     of the first occurrent is held in a special vector. */
2739
2740     else if (escape < 0)
2741       {
2742       offset = (PCRE2_SIZE)(ptr - cb->start_pattern - 1);
2743       escape = -escape;
2744       *parsed_pattern++ = META_BACKREF | (uint32_t)escape;
2745       if (escape < 10)
2746         {
2747         if (cb->small_ref_offset[escape] == PCRE2_UNSET)
2748           cb->small_ref_offset[escape] = offset;
2749         }
2750       else
2751         {
2752         PUTOFFSET(offset, parsed_pattern);
2753         }
2754       okquantifier = TRUE;
2755       }
2756
2757     /* The escape was a character class such as \d etc. or other special
2758     escape indicator such as \A or \X. Most of them generate just a single
2759     parsed item, but \P and \p are followed by a 16-bit type and a 16-bit
2760     value. They are supported only when Unicode is available. The type and
2761     value are packed into a single 32-bit value so that the whole sequences
2762     uses only two elements in the parsed_vector. This is because the same
2763     coding is used if \d (for example) is turned into \p{Nd} when PCRE2_UCP is
2764     set.
2765
2766     There are also some cases where the escape sequence is followed by a name:
2767     \k{name}, \k<name>, and \k'name' are backreferences by name, and \g<name>
2768     and \g'name' are subroutine calls by name; \g{name} is a synonym for
2769     \k{name}. Note that \g<number> and \g'number' are handled by check_escape()
2770     and returned as a negative value (handled above). A name is coded as an
2771     offset into the pattern and a length. */
2772
2773     else switch (escape)
2774       {
2775       case ESC_C:
2776 #ifdef NEVER_BACKSLASH_C
2777       errorcode = ERR85;
2778       goto ESCAPE_FAILED;
2779 #else
2780       if ((options & PCRE2_NEVER_BACKSLASH_C) != 0)
2781         {
2782         errorcode = ERR83;
2783         goto ESCAPE_FAILED;
2784         }
2785 #endif
2786       okquantifier = TRUE;
2787       *parsed_pattern++ = META_ESCAPE + escape;
2788       break;
2789
2790       case ESC_X:
2791 #ifndef SUPPORT_UNICODE
2792       errorcode = ERR45;   /* Supported only with Unicode support */
2793       goto ESCAPE_FAILED;
2794 #endif
2795       case ESC_H:
2796       case ESC_h:
2797       case ESC_N:
2798       case ESC_R:
2799       case ESC_V:
2800       case ESC_v:
2801       okquantifier = TRUE;
2802       *parsed_pattern++ = META_ESCAPE + escape;
2803       break;
2804
2805       default:  /* \A, \B, \b, \G, \K, \Z, \z cannot be quantified. */
2806       *parsed_pattern++ = META_ESCAPE + escape;
2807       break;
2808
2809       /* Escapes that change in UCP mode. Note that PCRE2_UCP will never be set
2810       without Unicode support because it is checked when pcre2_compile() is
2811       called. */
2812
2813       case ESC_d:
2814       case ESC_D:
2815       case ESC_s:
2816       case ESC_S:
2817       case ESC_w:
2818       case ESC_W:
2819       okquantifier = TRUE;
2820       if ((options & PCRE2_UCP) == 0)
2821         {
2822         *parsed_pattern++ = META_ESCAPE + escape;
2823         }
2824       else
2825         {
2826         *parsed_pattern++ = META_ESCAPE +
2827           ((escape == ESC_d || escape == ESC_s || escape == ESC_w)?
2828             ESC_p : ESC_P);
2829         switch(escape)
2830           {
2831           case ESC_d:
2832           case ESC_D:
2833           *parsed_pattern++ = (PT_PC << 16) | ucp_Nd;
2834           break;
2835
2836           case ESC_s:
2837           case ESC_S:
2838           *parsed_pattern++ = PT_SPACE << 16;
2839           break;
2840
2841           case ESC_w:
2842           case ESC_W:
2843           *parsed_pattern++ = PT_WORD << 16;
2844           break;
2845           }
2846         }
2847       break;
2848
2849       /* Unicode property matching */
2850
2851       case ESC_P:
2852       case ESC_p:
2853 #ifdef SUPPORT_UNICODE
2854         {
2855         BOOL negated;
2856         uint16_t ptype = 0, pdata = 0;
2857         if (!get_ucp(&ptr, &negated, &ptype, &pdata, &errorcode, cb))
2858           goto ESCAPE_FAILED;
2859         if (negated) escape = (escape == ESC_P)? ESC_p : ESC_P;
2860         *parsed_pattern++ = META_ESCAPE + escape;
2861         *parsed_pattern++ = (ptype << 16) | pdata;
2862         okquantifier = TRUE;
2863         }
2864 #else
2865       errorcode = ERR45;
2866       goto ESCAPE_FAILED;
2867 #endif
2868       break;  /* End \P and \p */
2869
2870       /* When \g is used with quotes or angle brackets as delimiters, it is a
2871       numerical or named subroutine call, and control comes here. When used
2872       with brace delimiters it is a numberical back reference and does not come
2873       here because check_escape() returns it directly as a reference. \k is
2874       always a named back reference. */
2875
2876       case ESC_g:
2877       case ESC_k:
2878       if (ptr >= ptrend || (*ptr != CHAR_LEFT_CURLY_BRACKET &&
2879           *ptr != CHAR_LESS_THAN_SIGN && *ptr != CHAR_APOSTROPHE))
2880         {
2881         errorcode = (escape == ESC_g)? ERR57 : ERR69;
2882         goto ESCAPE_FAILED;
2883         }
2884       terminator = (*ptr == CHAR_LESS_THAN_SIGN)?
2885         CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
2886         CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;
2887
2888       /* For a non-braced \g, check for a numerical recursion. */
2889
2890       if (escape == ESC_g && terminator != CHAR_RIGHT_CURLY_BRACKET)
2891         {
2892         PCRE2_SPTR p = ptr + 1;
2893
2894         if (read_number(&p, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &i,
2895             &errorcode))
2896           {
2897           if (p >= ptrend || *p != terminator)
2898             {
2899             errorcode = ERR57;
2900             goto ESCAPE_FAILED;
2901             }
2902           ptr = p;
2903           goto SET_RECURSION;
2904           }
2905         if (errorcode != 0) goto ESCAPE_FAILED;
2906         }
2907
2908       /* Not a numerical recursion */
2909
2910       if (!read_name(&ptr, ptrend, terminator, &offset, &name, &namelen,
2911           &errorcode, cb)) goto ESCAPE_FAILED;
2912
2913       /* \k and \g when used with braces are back references, whereas \g used
2914       with quotes or angle brackets is a recursion */
2915
2916       *parsed_pattern++ =
2917         (escape == ESC_k || terminator == CHAR_RIGHT_CURLY_BRACKET)?
2918           META_BACKREF_BYNAME : META_RECURSE_BYNAME;
2919       *parsed_pattern++ = namelen;
2920
2921       PUTOFFSET(offset, parsed_pattern);
2922       okquantifier = TRUE;
2923       break;  /* End special escape processing */
2924       }
2925     break;    /* End escape sequence processing */
2926
2927
2928     /* ---- Single-character special items ---- */
2929
2930     case CHAR_CIRCUMFLEX_ACCENT:
2931     *parsed_pattern++ = META_CIRCUMFLEX;
2932     break;
2933
2934     case CHAR_DOLLAR_SIGN:
2935     *parsed_pattern++ = META_DOLLAR;
2936     break;
2937
2938     case CHAR_DOT:
2939     *parsed_pattern++ = META_DOT;
2940     okquantifier = TRUE;
2941     break;
2942
2943
2944     /* ---- Single-character quantifiers ---- */
2945
2946     case CHAR_ASTERISK:
2947     meta_quantifier = META_ASTERISK;
2948     goto CHECK_QUANTIFIER;
2949
2950     case CHAR_PLUS:
2951     meta_quantifier = META_PLUS;
2952     goto CHECK_QUANTIFIER;
2953
2954     case CHAR_QUESTION_MARK:
2955     meta_quantifier = META_QUERY;
2956     goto CHECK_QUANTIFIER;
2957
2958
2959     /* ---- Potential {n,m} quantifier ---- */
2960
2961     case CHAR_LEFT_CURLY_BRACKET:
2962     if (!read_repeat_counts(&ptr, ptrend, &min_repeat, &max_repeat,
2963         &errorcode))
2964       {
2965       if (errorcode != 0) goto FAILED;     /* Error in quantifier. */
2966       PARSED_LITERAL(c, parsed_pattern);   /* Not a quantifier */
2967       break;                               /* No more quantifier processing */
2968       }
2969     meta_quantifier = META_MINMAX;
2970     /* Fall through */
2971
2972
2973     /* ---- Quantifier post-processing ---- */
2974
2975     /* Check that a quantifier is allowed after the previous item. */
2976
2977     CHECK_QUANTIFIER:
2978     if (!prev_okquantifier)
2979       {
2980       errorcode = ERR9;
2981       goto FAILED_BACK;
2982       }
2983
2984     /* Now we can put the quantifier into the parsed pattern vector. At this
2985     stage, we have only the basic quantifier. The check for a following + or ?
2986     modifier happens at the top of the loop, after any intervening comments
2987     have been removed. */
2988
2989     *parsed_pattern++ = meta_quantifier;
2990     if (c == CHAR_LEFT_CURLY_BRACKET)
2991       {
2992       *parsed_pattern++ = min_repeat;
2993       *parsed_pattern++ = max_repeat;
2994       }
2995     break;
2996
2997
2998     /* ---- Character class ---- */
2999
3000     case CHAR_LEFT_SQUARE_BRACKET:
3001     okquantifier = TRUE;
3002
3003     /* In another (POSIX) regex library, the ugly syntax [[:<:]] and [[:>:]] is
3004     used for "start of word" and "end of word". As these are otherwise illegal
3005     sequences, we don't break anything by recognizing them. They are replaced
3006     by \b(?=\w) and \b(?<=\w) respectively. Sequences like [a[:<:]] are
3007     erroneous and are handled by the normal code below. */
3008
3009     if (ptrend - ptr >= 6 &&
3010          (PRIV(strncmp_c8)(ptr, STRING_WEIRD_STARTWORD, 6) == 0 ||
3011           PRIV(strncmp_c8)(ptr, STRING_WEIRD_ENDWORD, 6) == 0))
3012       {
3013       *parsed_pattern++ = META_ESCAPE + ESC_b;
3014
3015       if (ptr[2] == CHAR_LESS_THAN_SIGN)
3016         {
3017         *parsed_pattern++ = META_LOOKAHEAD;
3018         }
3019       else
3020         {
3021         *parsed_pattern++ = META_LOOKBEHIND;
3022         *has_lookbehind = TRUE;
3023
3024         /* The offset is used only for the "non-fixed length" error; this won't
3025         occur here, so just store zero. */
3026
3027         PUTOFFSET((PCRE2_SIZE)0, parsed_pattern);
3028         }
3029
3030       if ((options & PCRE2_UCP) == 0)
3031         *parsed_pattern++ = META_ESCAPE + ESC_w;
3032       else
3033         {
3034         *parsed_pattern++ = META_ESCAPE + ESC_p;
3035         *parsed_pattern++ = PT_WORD << 16;
3036         }
3037       *parsed_pattern++ = META_KET;
3038       ptr += 6;
3039       break;
3040       }
3041
3042     /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
3043     they are encountered at the top level, so we'll do that too. */
3044
3045     if (ptr < ptrend && (*ptr == CHAR_COLON || *ptr == CHAR_DOT ||
3046          *ptr == CHAR_EQUALS_SIGN) &&
3047         check_posix_syntax(ptr, ptrend, &tempptr))
3048       {
3049       errorcode = (*ptr-- == CHAR_COLON)? ERR12 : ERR13;
3050       goto FAILED;
3051       }
3052
3053     /* Process a regular character class. If the first character is '^', set
3054     the negation flag. If the first few characters (either before or after ^)
3055     are \Q\E or \E or space or tab in extended-more mode, we skip them too.
3056     This makes for compatibility with Perl. */
3057
3058     negate_class = FALSE;
3059     while (ptr < ptrend)
3060       {
3061       GETCHARINCTEST(c, ptr);
3062       if (c == CHAR_BACKSLASH)
3063         {
3064         if (ptr < ptrend && *ptr == CHAR_E) ptr++;
3065         else if (ptrend - ptr >= 3 &&
3066              PRIV(strncmp_c8)(ptr, STR_Q STR_BACKSLASH STR_E, 3) == 0)
3067           ptr += 3;
3068         else
3069           break;
3070         }
3071       else if ((options & PCRE2_EXTENDED_MORE) != 0 &&
3072                (c == CHAR_SPACE || c == CHAR_HT))  /* Note: just these two */
3073         continue;
3074       else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)
3075         negate_class = TRUE;
3076       else break;
3077       }
3078
3079     /* Now the real contents of the class; c has the first "real" character.
3080     Empty classes are permitted only if the option is set. */
3081
3082     if (c == CHAR_RIGHT_SQUARE_BRACKET &&
3083         (cb->external_options & PCRE2_ALLOW_EMPTY_CLASS) != 0)
3084       {
3085       *parsed_pattern++ = negate_class? META_CLASS_EMPTY_NOT : META_CLASS_EMPTY;
3086       break;  /* End of class processing */
3087       }
3088
3089     /* Process a non-empty class. */
3090
3091     *parsed_pattern++ = negate_class? META_CLASS_NOT : META_CLASS;
3092     class_range_state = RANGE_NO;
3093
3094     /* In an EBCDIC environment, Perl treats alphabetic ranges specially
3095     because there are holes in the encoding, and simply using the range A-Z
3096     (for example) would include the characters in the holes. This applies only
3097     to ranges where both values are literal; [\xC1-\xE9] is different to [A-Z]
3098     in this respect. In order to accommodate this, we keep track of whether
3099     character values are literal or not, and a state variable for handling
3100     ranges. */
3101
3102     /* Loop for the contents of the class */
3103
3104     for (;;)
3105       {
3106       BOOL char_is_literal = TRUE;
3107
3108       /* Inside \Q...\E everything is literal except \E */
3109
3110       if (inescq)
3111         {
3112         if (c == CHAR_BACKSLASH && ptr < ptrend && *ptr == CHAR_E)
3113           {
3114           inescq = FALSE;                   /* Reset literal state */
3115           ptr++;                            /* Skip the 'E' */
3116           goto CLASS_CONTINUE;
3117           }
3118         goto CLASS_LITERAL;
3119         }
3120
3121       /* Skip over space and tab (only) in extended-more mode. */
3122
3123       if ((options & PCRE2_EXTENDED_MORE) != 0 &&
3124           (c == CHAR_SPACE || c == CHAR_HT))
3125         goto CLASS_CONTINUE;
3126
3127       /* Handle POSIX class names. Perl allows a negation extension of the
3128       form [:^name:]. A square bracket that doesn't match the syntax is
3129       treated as a literal. We also recognize the POSIX constructions
3130       [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
3131       5.6 and 5.8 do. */
3132
3133       if (c == CHAR_LEFT_SQUARE_BRACKET &&
3134           ptrend - ptr >= 3 &&
3135           (*ptr == CHAR_COLON || *ptr == CHAR_DOT ||
3136            *ptr == CHAR_EQUALS_SIGN) &&
3137           check_posix_syntax(ptr, ptrend, &tempptr))
3138         {
3139         BOOL posix_negate = FALSE;
3140         int posix_class;
3141
3142         /* Perl treats a hyphen before a POSIX class as a literal, not the
3143         start of a range. However, it gives a warning in its warning mode. PCRE
3144         does not have a warning mode, so we give an error, because this is
3145         likely an error on the user's part. */
3146
3147         if (class_range_state == RANGE_STARTED)
3148           {
3149           errorcode = ERR50;
3150           goto FAILED;
3151           }
3152
3153         if (*ptr != CHAR_COLON)
3154           {
3155           errorcode = ERR13;
3156           goto FAILED_BACK;
3157           }
3158
3159         if (*(++ptr) == CHAR_CIRCUMFLEX_ACCENT)
3160           {
3161           posix_negate = TRUE;
3162           ptr++;
3163           }
3164
3165         posix_class = check_posix_name(ptr, (int)(tempptr - ptr));
3166         if (posix_class < 0)
3167           {
3168           errorcode = ERR30;
3169           goto FAILED;
3170           }
3171         ptr = tempptr + 2;
3172
3173         /* Perl treats a hyphen after a POSIX class as a literal, not the
3174         start of a range. However, it gives a warning in its warning mode
3175         unless the hyphen is the last character in the class. PCRE does not
3176         have a warning mode, so we give an error, because this is likely an
3177         error on the user's part. */
3178
3179         if (ptr < ptrend - 1 && *ptr == CHAR_MINUS &&
3180             ptr[1] != CHAR_RIGHT_SQUARE_BRACKET)
3181           {
3182           errorcode = ERR50;
3183           goto FAILED;
3184           }
3185
3186         /* Set "a hyphen is not the start of a range" for the -] case, and also
3187         in case the POSIX class is followed by \E or \Q\E (possibly repeated -
3188         fuzzers do that kind of thing) and *then* a hyphen. This causes that
3189         hyphen to be treated as a literal. I don't think it's worth setting up
3190         special apparatus to do otherwise. */
3191
3192         class_range_state = RANGE_NO;
3193
3194         /* When PCRE2_UCP is set, some of the POSIX classes are converted to
3195         use Unicode properties \p or \P or, in one case, \h or \H. The
3196         substitutes table has two values per class, containing the type and
3197         value of a \p or \P item. The special cases are specified with a
3198         negative type: a non-zero value causes \h or \H to be used, and a zero
3199         value falls through to behave like a non-UCP POSIX class. */
3200
3201 #ifdef SUPPORT_UNICODE
3202         if ((options & PCRE2_UCP) != 0)
3203           {
3204           int ptype = posix_substitutes[2*posix_class];
3205           int pvalue = posix_substitutes[2*posix_class + 1];
3206           if (ptype >= 0)
3207             {
3208             *parsed_pattern++ = META_ESCAPE + (posix_negate? ESC_P : ESC_p);
3209             *parsed_pattern++ = (ptype << 16) | pvalue;
3210             goto CLASS_CONTINUE;
3211             }
3212
3213           if (pvalue != 0)
3214             {
3215             *parsed_pattern++ = META_ESCAPE + (posix_negate? ESC_H : ESC_h);
3216             goto CLASS_CONTINUE;
3217             }
3218
3219           /* Fall through */
3220           }
3221 #endif  /* SUPPORT_UNICODE */
3222
3223         /* Non-UCP POSIX class */
3224
3225         *parsed_pattern++ = posix_negate? META_POSIX_NEG : META_POSIX;
3226         *parsed_pattern++ = posix_class;
3227         }
3228
3229       /* Handle potential start of range */
3230
3231       else if (c == CHAR_MINUS && class_range_state >= RANGE_OK_ESCAPED)
3232         {
3233         *parsed_pattern++ = (class_range_state == RANGE_OK_LITERAL)?
3234           META_RANGE_LITERAL : META_RANGE_ESCAPED;
3235         class_range_state = RANGE_STARTED;
3236         }
3237
3238       /* Handle a literal character */
3239
3240       else if (c != CHAR_BACKSLASH)
3241         {
3242         CLASS_LITERAL:
3243         if (class_range_state == RANGE_STARTED)
3244           {
3245           if (c == parsed_pattern[-2])       /* Optimize one-char range */
3246             parsed_pattern--;
3247           else if (parsed_pattern[-2] > c)   /* Check range is in order */
3248             {
3249             errorcode = ERR8;
3250             goto FAILED_BACK;
3251             }
3252           else
3253             {
3254             if (!char_is_literal && parsed_pattern[-1] == META_RANGE_LITERAL)
3255               parsed_pattern[-1] = META_RANGE_ESCAPED;
3256             PARSED_LITERAL(c, parsed_pattern);
3257             }
3258           class_range_state = RANGE_NO;
3259           }
3260         else  /* Potential start of range */
3261           {
3262           class_range_state = char_is_literal?
3263             RANGE_OK_LITERAL : RANGE_OK_ESCAPED;
3264           PARSED_LITERAL(c, parsed_pattern);
3265           }
3266         }
3267
3268       /* Handle escapes in a class */
3269
3270       else
3271         {
3272         tempptr = ptr;
3273         escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode,
3274           options, TRUE, cb);
3275         if (errorcode != 0)
3276           {
3277           CLASS_ESCAPE_FAILED:
3278           if ((cb->cx->extra_options & PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL) == 0)
3279             goto FAILED;
3280           ptr = tempptr;
3281           if (ptr >= ptrend) c = CHAR_BACKSLASH; else
3282             {
3283             GETCHARINCTEST(c, ptr);   /* Get character value, increment pointer */
3284             }
3285           escape = 0;                 /* Treat as literal character */
3286           }
3287
3288         if (escape == 0)  /* Escaped character code point is in c */
3289           {
3290           char_is_literal = FALSE;
3291           goto CLASS_LITERAL;
3292           }
3293
3294         /* These three escapes do not alter the class range state. */
3295
3296         if (escape == ESC_b)
3297           {
3298           c = CHAR_BS;   /* \b is backspace in a class */
3299           char_is_literal = FALSE;
3300           goto CLASS_LITERAL;
3301           }
3302
3303         else if (escape == ESC_Q)
3304           {
3305           inescq = TRUE;  /* Enter literal mode */
3306           goto CLASS_CONTINUE;
3307           }
3308
3309         else if (escape == ESC_E)  /* Ignore orphan \E */
3310           goto CLASS_CONTINUE;
3311
3312         /* The second part of a range can be a single-character escape
3313         sequence (detected above), but not any of the other escapes. Perl
3314         treats a hyphen as a literal in such circumstances. However, in Perl's
3315         warning mode, a warning is given, so PCRE now faults it, as it is
3316         almost certainly a mistake on the user's part. */
3317
3318         if (class_range_state == RANGE_STARTED)
3319           {
3320           errorcode = ERR50;
3321           goto CLASS_ESCAPE_FAILED;
3322           }
3323
3324         /* Of the remaining escapes, only those that define characters are
3325         allowed in a class. None may start a range. */
3326
3327         class_range_state = RANGE_NO;
3328         switch(escape)
3329           {
3330           case ESC_N:
3331           errorcode = ERR71;  /* Not supported in a class */
3332           goto CLASS_ESCAPE_FAILED;
3333
3334           case ESC_H:
3335           case ESC_h:
3336           case ESC_V:
3337           case ESC_v:
3338           *parsed_pattern++ = META_ESCAPE + escape;
3339           break;
3340
3341           /* These escapes are converted to Unicode property tests when
3342           PCRE2_UCP is set. */
3343
3344           case ESC_d:
3345           case ESC_D:
3346           case ESC_s:
3347           case ESC_S:
3348           case ESC_w:
3349           case ESC_W:
3350           if ((options & PCRE2_UCP) == 0)
3351             {
3352             *parsed_pattern++ = META_ESCAPE + escape;
3353             }
3354           else
3355             {
3356             *parsed_pattern++ = META_ESCAPE +
3357               ((escape == ESC_d || escape == ESC_s || escape == ESC_w)?
3358                 ESC_p : ESC_P);
3359             switch(escape)
3360               {
3361               case ESC_d:
3362               case ESC_D:
3363               *parsed_pattern++ = (PT_PC << 16) | ucp_Nd;
3364               break;
3365
3366               case ESC_s:
3367               case ESC_S:
3368               *parsed_pattern++ = PT_SPACE << 16;
3369               break;
3370
3371               case ESC_w:
3372               case ESC_W:
3373               *parsed_pattern++ = PT_WORD << 16;
3374               break;
3375               }
3376             }
3377           break;
3378
3379           /* Explicit Unicode property matching */
3380
3381           case ESC_P:
3382           case ESC_p:
3383 #ifdef SUPPORT_UNICODE
3384             {
3385             BOOL negated;
3386             uint16_t ptype = 0, pdata = 0;
3387             if (!get_ucp(&ptr, &negated, &ptype, &pdata, &errorcode, cb))
3388               goto FAILED;
3389             if (negated) escape = (escape == ESC_P)? ESC_p : ESC_P;
3390             *parsed_pattern++ = META_ESCAPE + escape;
3391             *parsed_pattern++ = (ptype << 16) | pdata;
3392             }
3393 #else
3394           errorcode = ERR45;
3395           goto CLASS_ESCAPE_FAILED;
3396 #endif
3397           break;  /* End \P and \p */
3398
3399           default:    /* All others are not allowed in a class */
3400           errorcode = ERR7;
3401           ptr--;
3402           goto CLASS_ESCAPE_FAILED;
3403           }
3404
3405         /* Perl gives a warning unless a following hyphen is the last character
3406         in the class. PCRE throws an error. */
3407
3408         if (ptr < ptrend - 1 && *ptr == CHAR_MINUS &&
3409             ptr[1] != CHAR_RIGHT_SQUARE_BRACKET)
3410           {
3411           errorcode = ERR50;
3412           goto FAILED;
3413           }
3414         }
3415
3416       /* Proceed to next thing in the class. */
3417
3418       CLASS_CONTINUE:
3419       if (ptr >= ptrend)
3420         {
3421         errorcode = ERR6;  /* Missing terminating ']' */
3422         goto FAILED;
3423         }
3424       GETCHARINCTEST(c, ptr);
3425       if (c == CHAR_RIGHT_SQUARE_BRACKET && !inescq) break;
3426       }     /* End of class-processing loop */
3427
3428     if (class_range_state == RANGE_STARTED)
3429       {
3430       parsed_pattern[-1] = CHAR_MINUS;
3431       class_range_state = RANGE_NO;
3432       }
3433
3434     *parsed_pattern++ = META_CLASS_END;
3435     break;  /* End of character class */
3436
3437
3438     /* ---- Opening parenthesis ---- */
3439
3440     case CHAR_LEFT_PARENTHESIS:
3441     if (ptr >= ptrend) goto UNCLOSED_PARENTHESIS;
3442
3443     /* If ( is not followed by ? it is either a capture or a special verb. */
3444
3445     if (*ptr != CHAR_QUESTION_MARK)
3446       {
3447       const char *vn;
3448
3449       /* Handle capturing brackets (or non-capturing if auto-capture is turned
3450       off). */
3451
3452       if (*ptr != CHAR_ASTERISK)
3453         {
3454         nest_depth++;
3455         if ((options & PCRE2_NO_AUTO_CAPTURE) == 0)
3456           {
3457           cb->bracount++;
3458           *parsed_pattern++ = META_CAPTURE | cb->bracount;
3459           }
3460         else *parsed_pattern++ = META_NOCAPTURE;
3461         }
3462
3463
3464       /* ---- Handle (*VERB) and (*VERB:NAME) ---- */
3465
3466       /* Do nothing for (*) so it gives a "bad quantifier" error rather than
3467       "(*MARK) must have an argument". */
3468
3469       else if (ptrend - ptr > 1 && ptr[1] != CHAR_RIGHT_PARENTHESIS)
3470         {
3471         vn = verbnames;
3472         if (!read_name(&ptr, ptrend, 0, &offset, &name, &namelen, &errorcode,
3473           cb)) goto FAILED;
3474         if (ptr >= ptrend || (*ptr != CHAR_COLON &&
3475                               *ptr != CHAR_RIGHT_PARENTHESIS))
3476           {
3477           errorcode = ERR60;  /* Malformed */
3478           goto FAILED;
3479           }
3480
3481         /* Scan the table of verb names */
3482
3483         for (i = 0; i < verbcount; i++)
3484           {
3485           if (namelen == verbs[i].len &&
3486               PRIV(strncmp_c8)(name, vn, namelen) == 0)
3487             break;
3488           vn += verbs[i].len + 1;
3489           }
3490
3491         if (i >= verbcount)
3492           {
3493           errorcode = ERR60;  /* Verb not recognized */
3494           goto FAILED;
3495           }
3496
3497         /* An empty argument is treated as no argument. */
3498
3499         if (*ptr == CHAR_COLON && ptr + 1 < ptrend &&
3500              ptr[1] == CHAR_RIGHT_PARENTHESIS)
3501           ptr++;    /* Advance to the closing parens */
3502
3503         /* Check for mandatory non-empty argument; this is (*MARK) */
3504
3505         if (verbs[i].has_arg > 0 && *ptr != CHAR_COLON)
3506           {
3507           errorcode = ERR66;
3508           goto FAILED;
3509           }
3510
3511         /* It appears that Perl allows any characters whatsoever, other than a
3512         closing parenthesis, to appear in arguments ("names"), so we no longer
3513         insist on letters, digits, and underscores. Perl does not, however, do
3514         any interpretation within arguments, and has no means of including a
3515         closing parenthesis. PCRE supports escape processing but only when it
3516         is requested by an option. We set inverbname TRUE here, and let the
3517         main loop take care of this so that escape and \x processing is done by
3518         the main code above. */
3519
3520         if (*ptr++ == CHAR_COLON)   /* Skip past : or ) */
3521           {
3522           /* Some optional arguments can be treated as a preceding (*MARK) */
3523
3524           if (verbs[i].has_arg < 0)
3525             {
3526             add_after_mark = verbs[i].meta;
3527             *parsed_pattern++ = META_MARK;
3528             }
3529
3530           /* The remaining verbs with arguments (except *MARK) need a different
3531           opcode. */
3532
3533           else
3534             {
3535             *parsed_pattern++ = verbs[i].meta +
3536               ((verbs[i].meta != META_MARK)? 0x00010000u:0);
3537             }
3538
3539           /* Set up for reading the name in the main loop. */
3540
3541           verblengthptr = parsed_pattern++;
3542           verbnamestart = ptr;
3543           inverbname = TRUE;
3544           }
3545         else  /* No verb "name" argument */
3546           {
3547           *parsed_pattern++ = verbs[i].meta;
3548           }
3549         }     /* End of (*VERB) handling */
3550       break;  /* Done with this parenthesis */
3551       }       /* End of groups that don't start with (? */
3552
3553
3554     /* ---- Items starting (? ---- */
3555
3556     /* The type of item is determined by what follows (?. Handle (?| and option
3557     changes under "default" because both need a new block on the nest stack.
3558     Comments starting with (?# are handled above. Note that there is some
3559     ambiguity about the sequence (?- because if a digit follows it's a relative
3560     recursion or subroutine call whereas otherwise it's an option unsetting. */
3561
3562     if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;
3563
3564     switch(*ptr)
3565       {
3566       default:
3567       if (*ptr == CHAR_MINUS && ptrend - ptr > 1 && IS_DIGIT(ptr[1]))
3568         goto RECURSION_BYNUMBER;  /* The + case is handled by CHAR_PLUS */
3569
3570       /* We now have either (?| or a (possibly empty) option setting,
3571       optionally followed by a non-capturing group. */
3572
3573       nest_depth++;
3574       if (top_nest == NULL) top_nest = (nest_save *)(cb->start_workspace);
3575       else if (++top_nest >= end_nests)
3576         {
3577         errorcode = ERR84;
3578         goto FAILED;
3579         }
3580       top_nest->nest_depth = nest_depth;
3581       top_nest->flags = 0;
3582       top_nest->options = options & PARSE_TRACKED_OPTIONS;
3583
3584       /* Start of non-capturing group that resets the capture count for each
3585       branch. */
3586
3587       if (*ptr == CHAR_VERTICAL_LINE)
3588         {
3589         top_nest->reset_group = (uint16_t)cb->bracount;
3590         top_nest->max_group = (uint16_t)cb->bracount;
3591         top_nest->flags |= NSF_RESET;
3592         cb->external_flags |= PCRE2_DUPCAPUSED;
3593         *parsed_pattern++ = META_NOCAPTURE;
3594         ptr++;
3595         }
3596
3597       /* Scan for options imnsxJU to be set or unset. */
3598
3599       else
3600         {
3601         BOOL hyphenok = TRUE;
3602         uint32_t oldoptions = options;
3603
3604         top_nest->reset_group = 0;
3605         top_nest->max_group = 0;
3606         set = unset = 0;
3607         optset = &set;
3608
3609         /* ^ at the start unsets imnsx and disables the subsequent use of - */
3610
3611         if (ptr < ptrend && *ptr == CHAR_CIRCUMFLEX_ACCENT)
3612           {
3613           options &= ~(PCRE2_CASELESS|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE|
3614                        PCRE2_DOTALL|PCRE2_EXTENDED|PCRE2_EXTENDED_MORE);
3615           hyphenok = FALSE;
3616           ptr++;
3617           }
3618
3619         while (ptr < ptrend && *ptr != CHAR_RIGHT_PARENTHESIS &&
3620                                *ptr != CHAR_COLON)
3621           {
3622           switch (*ptr++)
3623             {
3624             case CHAR_MINUS:
3625             if (!hyphenok)
3626               {
3627               errorcode = ERR94;
3628               ptr--;  /* Correct the offset */
3629               goto FAILED;
3630               }
3631             optset = &unset;
3632             hyphenok = FALSE;
3633             break;
3634
3635             case CHAR_J:  /* Record that it changed in the external options */
3636             *optset |= PCRE2_DUPNAMES;
3637             cb->external_flags |= PCRE2_JCHANGED;
3638             break;
3639
3640             case CHAR_i: *optset |= PCRE2_CASELESS; break;
3641             case CHAR_m: *optset |= PCRE2_MULTILINE; break;
3642             case CHAR_n: *optset |= PCRE2_NO_AUTO_CAPTURE; break;
3643             case CHAR_s: *optset |= PCRE2_DOTALL; break;
3644             case CHAR_U: *optset |= PCRE2_UNGREEDY; break;
3645
3646             /* If x appears twice it sets the extended extended option. */
3647
3648             case CHAR_x:
3649             *optset |= PCRE2_EXTENDED;
3650             if (ptr < ptrend && *ptr == CHAR_x)
3651               {
3652               *optset |= PCRE2_EXTENDED_MORE;
3653               ptr++;
3654               }
3655             break;
3656
3657             default:
3658             errorcode = ERR11;
3659             ptr--;    /* Correct the offset */
3660             goto FAILED;
3661             }
3662           }
3663
3664         /* If we are setting extended without extended-more, ensure that any
3665         existing extended-more gets unset. Also, unsetting extended must also
3666         unset extended-more. */
3667
3668         if ((set & (PCRE2_EXTENDED|PCRE2_EXTENDED_MORE)) == PCRE2_EXTENDED ||
3669             (unset & PCRE2_EXTENDED) != 0)
3670           unset |= PCRE2_EXTENDED_MORE;
3671
3672         options = (options | set) & (~unset);
3673
3674         /* If the options ended with ')' this is not the start of a nested
3675         group with option changes, so the options change at this level.
3676         In this case, if the previous level set up a nest block, discard the
3677         one we have just created. Otherwise adjust it for the previous level.
3678         If the options ended with ':' we are starting a non-capturing group,
3679         possibly with an options setting. */
3680
3681         if (ptr >= ptrend) goto UNCLOSED_PARENTHESIS;
3682         if (*ptr++ == CHAR_RIGHT_PARENTHESIS)
3683           {
3684           nest_depth--;  /* This is not a nested group after all. */
3685           if (top_nest > (nest_save *)(cb->start_workspace) &&
3686               (top_nest-1)->nest_depth == nest_depth) top_nest--;
3687           else top_nest->nest_depth = nest_depth;
3688           }
3689         else *parsed_pattern++ = META_NOCAPTURE;
3690
3691         /* If nothing changed, no need to record. */
3692
3693         if (options != oldoptions)
3694           {
3695           *parsed_pattern++ = META_OPTIONS;
3696           *parsed_pattern++ = options;
3697           }
3698         }     /* End options processing */
3699       break;  /* End default case after (? */
3700
3701
3702       /* ---- Python syntax support ---- */
3703
3704       case CHAR_P:
3705       if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;
3706
3707       /* (?P<name> is the same as (?<name>, which defines a named group. */
3708
3709       if (*ptr == CHAR_LESS_THAN_SIGN)
3710         {
3711         terminator = CHAR_GREATER_THAN_SIGN;
3712         goto DEFINE_NAME;
3713         }
3714
3715       /* (?P>name) is the same as (?&name), which is a recursion or subroutine
3716       call. */
3717
3718       if (*ptr == CHAR_GREATER_THAN_SIGN) goto RECURSE_BY_NAME;
3719
3720       /* (?P=name) is the same as \k<name>, a back reference by name. Anything
3721       else after (?P is an error. */
3722
3723       if (*ptr != CHAR_EQUALS_SIGN)
3724         {
3725         errorcode = ERR41;
3726         goto FAILED;
3727         }
3728       if (!read_name(&ptr, ptrend, CHAR_RIGHT_PARENTHESIS, &offset, &name,
3729           &namelen, &errorcode, cb)) goto FAILED;
3730       *parsed_pattern++ = META_BACKREF_BYNAME;
3731       *parsed_pattern++ = namelen;
3732       PUTOFFSET(offset, parsed_pattern);
3733       okquantifier = TRUE;
3734       break;   /* End of (?P processing */
3735
3736
3737       /* ---- Recursion/subroutine calls by number ---- */
3738
3739       case CHAR_R:
3740       i = 0;         /* (?R) == (?R0) */
3741       ptr++;
3742       if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
3743         {
3744         errorcode = ERR58;
3745         goto FAILED;
3746         }
3747       goto SET_RECURSION;
3748
3749       /* An item starting (?- followed by a digit comes here via the "default"
3750       case because (?- followed by a non-digit is an options setting. */
3751
3752       case CHAR_PLUS:
3753       if (ptrend - ptr < 2 || !IS_DIGIT(ptr[1]))
3754         {
3755         errorcode = ERR29;   /* Missing number */
3756         goto FAILED;
3757         }
3758       /* Fall through */
3759
3760       case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:
3761       case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
3762       RECURSION_BYNUMBER:
3763       if (!read_number(&ptr, ptrend,
3764           (IS_DIGIT(*ptr))? -1:(int)(cb->bracount), /* + and - are relative */
3765           MAX_GROUP_NUMBER, ERR61,
3766           &i, &errorcode)) goto FAILED;
3767       if (i < 0)  /* NB (?0) is permitted */
3768         {
3769         errorcode = ERR15;   /* Unknown group */
3770         goto FAILED_BACK;
3771         }
3772       if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
3773         goto UNCLOSED_PARENTHESIS;
3774
3775       SET_RECURSION:
3776       *parsed_pattern++ = META_RECURSE | (uint32_t)i;
3777       offset = (PCRE2_SIZE)(ptr - cb->start_pattern);
3778       ptr++;
3779       PUTOFFSET(offset, parsed_pattern);
3780       okquantifier = TRUE;
3781       break;  /* End of recursive call by number handling */
3782
3783
3784       /* ---- Recursion/subroutine calls by name ---- */
3785
3786       case CHAR_AMPERSAND:
3787       RECURSE_BY_NAME:
3788       if (!read_name(&ptr, ptrend, CHAR_RIGHT_PARENTHESIS, &offset, &name,
3789           &namelen, &errorcode, cb)) goto FAILED;
3790       *parsed_pattern++ = META_RECURSE_BYNAME;
3791       *parsed_pattern++ = namelen;
3792       PUTOFFSET(offset, parsed_pattern);
3793       okquantifier = TRUE;
3794       break;
3795
3796       /* ---- Callout with numerical or string argument ---- */
3797
3798       case CHAR_C:
3799       if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;
3800
3801       /* If the previous item was a condition starting (?(? an assertion,
3802       optionally preceded by a callout, is expected. This is checked later on,
3803       during actual compilation. However we need to identify this kind of
3804       assertion in this pass because it must not be qualified. The value of
3805       expect_cond_assert is set to 2 after (?(? is processed. We decrement it
3806       for a callout - still leaving a positive value that identifies the
3807       assertion. Multiple callouts or any other items will make it zero or
3808       less, which doesn't matter because they will cause an error later. */
3809
3810       expect_cond_assert = prev_expect_cond_assert - 1;
3811
3812       /* If previous_callout is not NULL, it means this follows a previous
3813       callout. If it was a manual callout, do nothing; this means its "length
3814       of next pattern item" field will remain zero. If it was an automatic
3815       callout, abolish it. */
3816
3817       if (previous_callout != NULL && (options & PCRE2_AUTO_CALLOUT) != 0 &&
3818           previous_callout == parsed_pattern - 4 &&
3819           parsed_pattern[-1] == 255)
3820         parsed_pattern = previous_callout;
3821
3822       /* Save for updating next pattern item length, and skip one item before
3823       completing. */
3824
3825       previous_callout = parsed_pattern;
3826       after_manual_callout = 1;
3827
3828       /* Handle a string argument; specific delimiter is required. */
3829
3830       if (*ptr != CHAR_RIGHT_PARENTHESIS && !IS_DIGIT(*ptr))
3831         {
3832         PCRE2_SIZE calloutlength;
3833         PCRE2_SPTR startptr = ptr;
3834
3835         delimiter = 0;
3836         for (i = 0; PRIV(callout_start_delims)[i] != 0; i++)
3837           {
3838           if (*ptr == PRIV(callout_start_delims)[i])
3839             {
3840             delimiter = PRIV(callout_end_delims)[i];
3841             break;
3842             }
3843           }
3844         if (delimiter == 0)
3845           {
3846           errorcode = ERR82;
3847           goto FAILED;
3848           }
3849
3850         *parsed_pattern = META_CALLOUT_STRING;
3851         parsed_pattern += 3;   /* Skip pattern info */
3852
3853         for (;;)
3854           {
3855           if (++ptr >= ptrend)
3856             {
3857             errorcode = ERR81;
3858             ptr = startptr;   /* To give a more useful message */
3859             goto FAILED;
3860             }
3861           if (*ptr == delimiter && (++ptr >= ptrend || *ptr != delimiter))
3862             break;
3863           }
3864
3865         calloutlength = (PCRE2_SIZE)(ptr - startptr);
3866         if (calloutlength > UINT32_MAX)
3867           {
3868           errorcode = ERR72;
3869           goto FAILED;
3870           }
3871         *parsed_pattern++ = (uint32_t)calloutlength;
3872         offset = (PCRE2_SIZE)(startptr - cb->start_pattern);
3873         PUTOFFSET(offset, parsed_pattern);
3874         }
3875
3876       /* Handle a callout with an optional numerical argument, which must be
3877       less than or equal to 255. A missing argument gives 0. */
3878
3879       else
3880         {
3881         int n = 0;
3882         *parsed_pattern = META_CALLOUT_NUMBER;     /* Numerical callout */
3883         parsed_pattern += 3;                       /* Skip pattern info */
3884         while (ptr < ptrend && IS_DIGIT(*ptr))
3885           {
3886           n = n * 10 + *ptr++ - CHAR_0;
3887           if (n > 255)
3888             {
3889             errorcode = ERR38;
3890             goto FAILED;
3891             }
3892           }
3893         *parsed_pattern++ = n;
3894         }
3895
3896       /* Both formats must have a closing parenthesis */
3897
3898       if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
3899         {
3900         errorcode = ERR39;
3901         goto FAILED;
3902         }
3903       ptr++;
3904
3905       /* Remember the offset to the next item in the pattern, and set a default
3906       length. This should get updated after the next item is read. */
3907
3908       previous_callout[1] = (uint32_t)(ptr - cb->start_pattern);
3909       previous_callout[2] = 0;
3910       break;                  /* End callout */
3911
3912
3913       /* ---- Conditional group ---- */
3914
3915       /* A condition can be an assertion, a number (referring to a numbered
3916       group's having been set), a name (referring to a named group), or 'R',
3917       referring to overall recursion. R<digits> and R&name are also permitted
3918       for recursion state tests. Numbers may be preceded by + or - to specify a
3919       relative group number.
3920
3921       There are several syntaxes for testing a named group: (?(name)) is used
3922       by Python; Perl 5.10 onwards uses (?(<name>) or (?('name')).
3923
3924       There are two unfortunate ambiguities. 'R' can be the recursive thing or
3925       the name 'R' (and similarly for 'R' followed by digits). 'DEFINE' can be
3926       the Perl DEFINE feature or the Python named test. We look for a name
3927       first; if not found, we try the other case.
3928
3929       For compatibility with auto-callouts, we allow a callout to be specified
3930       before a condition that is an assertion. */
3931
3932       case CHAR_LEFT_PARENTHESIS:
3933       if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;
3934       nest_depth++;
3935
3936       /* If the next character is ? there must be an assertion next (optionally
3937       preceded by a callout). We do not check this here, but instead we set
3938       expect_cond_assert to 2. If this is still greater than zero (callouts
3939       decrement it) when the next assertion is read, it will be marked as a
3940       condition that must not be repeated. A value greater than zero also
3941       causes checking that an assertion (possibly with callout) follows. */
3942
3943       if (*ptr == CHAR_QUESTION_MARK)
3944         {
3945         *parsed_pattern++ = META_COND_ASSERT;
3946         ptr--;   /* Pull pointer back to the opening parenthesis. */
3947         expect_cond_assert = 2;
3948         break;  /* End of conditional */
3949         }
3950
3951       /* Handle (?([+-]number)... */
3952
3953       if (read_number(&ptr, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &i,
3954           &errorcode))
3955         {
3956         if (i <= 0)
3957           {
3958           errorcode = ERR15;
3959           goto FAILED;
3960           }
3961         *parsed_pattern++ = META_COND_NUMBER;
3962         offset = (PCRE2_SIZE)(ptr - cb->start_pattern - 2);
3963         PUTOFFSET(offset, parsed_pattern);
3964         *parsed_pattern++ = i;
3965         }
3966       else if (errorcode != 0) goto FAILED;   /* Number too big */
3967
3968       /* No number found. Handle the special case (?(VERSION[>]=n.m)... */
3969
3970       else if (ptrend - ptr >= 10 &&
3971                PRIV(strncmp_c8)(ptr, STRING_VERSION, 7) == 0 &&
3972                ptr[7] != CHAR_RIGHT_PARENTHESIS)
3973         {
3974         uint32_t ge = 0;
3975         int major = 0;
3976         int minor = 0;
3977
3978         ptr += 7;
3979         if (*ptr == CHAR_GREATER_THAN_SIGN)
3980           {
3981           ge = 1;
3982           ptr++;
3983           }
3984
3985         /* NOTE: cannot write IS_DIGIT(*(++ptr)) here because IS_DIGIT
3986         references its argument twice. */
3987
3988         if (*ptr != CHAR_EQUALS_SIGN || (ptr++, !IS_DIGIT(*ptr)))
3989           goto BAD_VERSION_CONDITION;
3990
3991         if (!read_number(&ptr, ptrend, -1, 1000, ERR79, &major, &errorcode))
3992           goto FAILED;
3993
3994         if (ptr >= ptrend) goto BAD_VERSION_CONDITION;
3995         if (*ptr == CHAR_DOT)
3996           {
3997           if (++ptr >= ptrend || !IS_DIGIT(*ptr)) goto BAD_VERSION_CONDITION;
3998           minor = (*ptr++ - CHAR_0) * 10;
3999           if (IS_DIGIT(*ptr)) minor += *ptr++ - CHAR_0;
4000           if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
4001             goto BAD_VERSION_CONDITION;
4002           }
4003
4004         *parsed_pattern++ = META_COND_VERSION;
4005         *parsed_pattern++ = ge;
4006         *parsed_pattern++ = major;
4007         *parsed_pattern++ = minor;
4008         }
4009
4010       /* All the remaining cases now require us to read a name. We cannot at
4011       this stage distinguish ambiguous cases such as (?(R12) which might be a
4012       recursion test by number or a name, because the named groups have not yet
4013       all been identified. Those cases are treated as names, but given a
4014       different META code. */
4015
4016       else
4017         {
4018         BOOL was_r_ampersand = FALSE;
4019
4020         if (*ptr == CHAR_R && ptrend - ptr > 1 && ptr[1] == CHAR_AMPERSAND)
4021           {
4022           terminator = CHAR_RIGHT_PARENTHESIS;
4023           was_r_ampersand = TRUE;
4024           ptr++;
4025           }
4026         else if (*ptr == CHAR_LESS_THAN_SIGN)
4027           terminator = CHAR_GREATER_THAN_SIGN;
4028         else if (*ptr == CHAR_APOSTROPHE)
4029           terminator = CHAR_APOSTROPHE;
4030         else
4031           {
4032           terminator = CHAR_RIGHT_PARENTHESIS;
4033           ptr--;   /* Point to char before name */
4034           }
4035         if (!read_name(&ptr, ptrend, terminator, &offset, &name, &namelen,
4036             &errorcode, cb)) goto FAILED;
4037
4038         /* Handle (?(R&name) */
4039
4040         if (was_r_ampersand)
4041           {
4042           *parsed_pattern = META_COND_RNAME;
4043           ptr--;   /* Back to closing parens */
4044           }
4045
4046         /* Handle (?(name). If the name is "DEFINE" we identify it with a
4047         special code. Likewise if the name consists of R followed only by
4048         digits. Otherwise, handle it like a quoted name. */
4049
4050         else if (terminator == CHAR_RIGHT_PARENTHESIS)
4051           {
4052           if (namelen == 6 && PRIV(strncmp_c8)(name, STRING_DEFINE, 6) == 0)
4053             *parsed_pattern = META_COND_DEFINE;
4054           else
4055             {
4056             for (i = 1; i < (int)namelen; i++)
4057               if (!IS_DIGIT(name[i])) break;
4058             *parsed_pattern = (*name == CHAR_R && i >= (int)namelen)?
4059               META_COND_RNUMBER : META_COND_NAME;
4060             }
4061           ptr--;   /* Back to closing parens */
4062           }
4063
4064         /* Handle (?('name') or (?(<name>) */
4065
4066         else *parsed_pattern = META_COND_NAME;
4067
4068         /* All these cases except DEFINE end with the name length and offset;
4069         DEFINE just has an offset (for the "too many branches" error). */
4070
4071         if (*parsed_pattern++ != META_COND_DEFINE) *parsed_pattern++ = namelen;
4072         PUTOFFSET(offset, parsed_pattern);
4073         }  /* End cases that read a name */
4074
4075       /* Check the closing parenthesis of the condition */
4076
4077       if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
4078         {
4079         errorcode = ERR24;
4080         goto FAILED;
4081         }
4082       ptr++;
4083       break;  /* End of condition processing */
4084
4085
4086       /* ---- Atomic group ---- */
4087
4088       case CHAR_GREATER_THAN_SIGN:
4089       *parsed_pattern++ = META_ATOMIC;
4090       nest_depth++;
4091       ptr++;
4092       break;
4093
4094
4095       /* ---- Lookahead assertions ---- */
4096
4097       case CHAR_EQUALS_SIGN:
4098       *parsed_pattern++ = META_LOOKAHEAD;
4099       ptr++;
4100       goto POST_ASSERTION;
4101
4102       case CHAR_EXCLAMATION_MARK:
4103       *parsed_pattern++ = META_LOOKAHEADNOT;
4104       ptr++;
4105       goto POST_ASSERTION;
4106
4107
4108       /* ---- Lookbehind assertions ---- */
4109
4110       /* (?< followed by = or ! is a lookbehind assertion. Otherwise (?< is the
4111       start of the name of a capturing group. */
4112
4113       case CHAR_LESS_THAN_SIGN:
4114       if (ptrend - ptr <= 1 ||
4115          (ptr[1] != CHAR_EQUALS_SIGN && ptr[1] != CHAR_EXCLAMATION_MARK))
4116         {
4117         terminator = CHAR_GREATER_THAN_SIGN;
4118         goto DEFINE_NAME;
4119         }
4120       *parsed_pattern++ = (ptr[1] == CHAR_EQUALS_SIGN)?
4121         META_LOOKBEHIND : META_LOOKBEHINDNOT;
4122       *has_lookbehind = TRUE;
4123       offset = (PCRE2_SIZE)(ptr - cb->start_pattern - 2);
4124       PUTOFFSET(offset, parsed_pattern);
4125       ptr += 2;
4126       /* Fall through */
4127
4128       /* If the previous item was a condition starting (?(? an assertion,
4129       optionally preceded by a callout, is expected. This is checked later on,
4130       during actual compilation. However we need to identify this kind of
4131       assertion in this pass because it must not be qualified. The value of
4132       expect_cond_assert is set to 2 after (?(? is processed. We decrement it
4133       for a callout - still leaving a positive value that identifies the
4134       assertion. Multiple callouts or any other items will make it zero or
4135       less, which doesn't matter because they will cause an error later. */
4136
4137       POST_ASSERTION:
4138       nest_depth++;
4139       if (prev_expect_cond_assert > 0)
4140         {
4141         if (top_nest == NULL) top_nest = (nest_save *)(cb->start_workspace);
4142         else if (++top_nest >= end_nests)
4143           {
4144           errorcode = ERR84;
4145           goto FAILED;
4146           }
4147         top_nest->nest_depth = nest_depth;
4148         top_nest->flags = NSF_CONDASSERT;
4149         top_nest->options = options & PARSE_TRACKED_OPTIONS;
4150         }
4151       break;
4152
4153
4154       /* ---- Define a named group ---- */
4155
4156       /* A named group may be defined as (?'name') or (?<name>). In the latter
4157       case we jump to DEFINE_NAME from the disambiguation of (?< above with the
4158       terminator set to '>'. */
4159
4160       case CHAR_APOSTROPHE:
4161       terminator = CHAR_APOSTROPHE;    /* Terminator */
4162
4163       DEFINE_NAME:
4164       if (!read_name(&ptr, ptrend, terminator, &offset, &name, &namelen,
4165           &errorcode, cb)) goto FAILED;
4166
4167       /* We have a name for this capturing group. It is also assigned a number,
4168       which is its primary means of identification. */
4169
4170       cb->bracount++;
4171       *parsed_pattern++ = META_CAPTURE | cb->bracount;
4172       nest_depth++;
4173
4174       /* Check not too many names */
4175
4176       if (cb->names_found >= MAX_NAME_COUNT)
4177         {
4178         errorcode = ERR49;
4179         goto FAILED;
4180         }
4181
4182       /* Adjust the entry size to accommodate the longest name found. */
4183
4184       if (namelen + IMM2_SIZE + 1 > cb->name_entry_size)
4185         cb->name_entry_size = (uint16_t)(namelen + IMM2_SIZE + 1);
4186
4187       /* Scan the list to check for duplicates. For duplicate names, if the
4188       number is the same, break the loop, which causes the name to be
4189       discarded; otherwise, if DUPNAMES is not set, give an error.
4190       If it is set, allow the name with a different number, but continue
4191       scanning in case this is a duplicate with the same number. For
4192       non-duplicate names, give an error if the number is duplicated. */
4193
4194       isdupname = FALSE;
4195       ng = cb->named_groups;
4196       for (i = 0; i < cb->names_found; i++, ng++)
4197         {
4198         if (namelen == ng->length &&
4199             PRIV(strncmp)(name, ng->name, (PCRE2_SIZE)namelen) == 0)
4200           {
4201           if (ng->number == cb->bracount) break;
4202           if ((options & PCRE2_DUPNAMES) == 0)
4203             {
4204             errorcode = ERR43;
4205             goto FAILED;
4206             }
4207           isdupname = ng->isdup = TRUE;     /* Mark as a duplicate */
4208           cb->dupnames = TRUE;              /* Duplicate names exist */
4209           }
4210         else if (ng->number == cb->bracount)
4211           {
4212           errorcode = ERR65;
4213           goto FAILED;
4214           }
4215         }
4216
4217       if (i < cb->names_found) break;   /* Ignore duplicate with same number */
4218
4219       /* Increase the list size if necessary */
4220
4221       if (cb->names_found >= cb->named_group_list_size)
4222         {
4223         uint32_t newsize = cb->named_group_list_size * 2;
4224         named_group *newspace =
4225           cb->cx->memctl.malloc(newsize * sizeof(named_group),
4226           cb->cx->memctl.memory_data);
4227         if (newspace == NULL)
4228           {
4229           errorcode = ERR21;
4230           goto FAILED;
4231           }
4232
4233         memcpy(newspace, cb->named_groups,
4234           cb->named_group_list_size * sizeof(named_group));
4235         if (cb->named_group_list_size > NAMED_GROUP_LIST_SIZE)
4236           cb->cx->memctl.free((void *)cb->named_groups,
4237           cb->cx->memctl.memory_data);
4238         cb->named_groups = newspace;
4239         cb->named_group_list_size = newsize;
4240         }
4241
4242       /* Add this name to the list */
4243
4244       cb->named_groups[cb->names_found].name = name;
4245       cb->named_groups[cb->names_found].length = (uint16_t)namelen;
4246       cb->named_groups[cb->names_found].number = cb->bracount;
4247       cb->named_groups[cb->names_found].isdup = (uint16_t)isdupname;
4248       cb->names_found++;
4249       break;
4250       }        /* End of (? switch */
4251     break;     /* End of ( handling */
4252
4253
4254     /* ---- Branch terminators ---- */
4255
4256     /* Alternation: reset the capture count if we are in a (?| group. */
4257
4258     case CHAR_VERTICAL_LINE:
4259     if (top_nest != NULL && top_nest->nest_depth == nest_depth &&
4260         (top_nest->flags & NSF_RESET) != 0)
4261       {
4262       if (cb->bracount > top_nest->max_group)
4263         top_nest->max_group = (uint16_t)cb->bracount;
4264       cb->bracount = top_nest->reset_group;
4265       }
4266     *parsed_pattern++ = META_ALT;
4267     break;
4268
4269     /* End of group; reset the capture count to the maximum if we are in a (?|
4270     group and/or reset the options that are tracked during parsing. Disallow
4271     quantifier for a condition that is an assertion. */
4272
4273     case CHAR_RIGHT_PARENTHESIS:
4274     okquantifier = TRUE;
4275     if (top_nest != NULL && top_nest->nest_depth == nest_depth)
4276       {
4277       options = (options & ~PARSE_TRACKED_OPTIONS) | top_nest->options;
4278       if ((top_nest->flags & NSF_RESET) != 0 &&
4279           top_nest->max_group > cb->bracount)
4280         cb->bracount = top_nest->max_group;
4281       if ((top_nest->flags & NSF_CONDASSERT) != 0)
4282         okquantifier = FALSE;
4283       if (top_nest == (nest_save *)(cb->start_workspace)) top_nest = NULL;
4284         else top_nest--;
4285       }
4286     if (nest_depth == 0)    /* Unmatched closing parenthesis */
4287       {
4288       errorcode = ERR22;
4289       goto FAILED_BACK;
4290       }
4291     nest_depth--;
4292     *parsed_pattern++ = META_KET;
4293     break;
4294     }  /* End of switch on pattern character */
4295   }    /* End of main character scan loop */
4296
4297 /* End of pattern reached. Check for missing ) at the end of a verb name. */
4298
4299 if (inverbname && ptr >= ptrend)
4300   {
4301   errorcode = ERR60;
4302   goto FAILED;
4303   }
4304
4305 /* Manage callout for the final item */
4306
4307 PARSED_END:
4308 parsed_pattern = manage_callouts(ptr, &previous_callout, auto_callout,
4309   parsed_pattern, cb);
4310
4311 /* Insert trailing items for word and line matching (features provided for the
4312 benefit of pcre2grep). */
4313
4314 if ((cb->cx->extra_options & PCRE2_EXTRA_MATCH_LINE) != 0)
4315   {
4316   *parsed_pattern++ = META_KET;
4317   *parsed_pattern++ = META_DOLLAR;
4318   }
4319 else if ((cb->cx->extra_options & PCRE2_EXTRA_MATCH_WORD) != 0)
4320   {
4321   *parsed_pattern++ = META_KET;
4322   *parsed_pattern++ = META_ESCAPE + ESC_b;
4323   }
4324
4325 /* Terminate the parsed pattern, then return success if all groups are closed.
4326 Otherwise we have unclosed parentheses. */
4327
4328 if (parsed_pattern >= parsed_pattern_end)
4329   {
4330   errorcode = ERR63;  /* Internal error (parsed pattern overflow) */
4331   goto FAILED;
4332   }
4333
4334 *parsed_pattern = META_END;
4335 if (nest_depth == 0) return 0;
4336
4337 UNCLOSED_PARENTHESIS:
4338 errorcode = ERR14;
4339
4340 /* Come here for all failures. */
4341
4342 FAILED:
4343 cb->erroroffset = (PCRE2_SIZE)(ptr - cb->start_pattern);
4344 return errorcode;
4345
4346 /* Some errors need to indicate the previous character. */
4347
4348 FAILED_BACK:
4349 ptr--;
4350 goto FAILED;
4351
4352 /* This failure happens several times. */
4353
4354 BAD_VERSION_CONDITION:
4355 errorcode = ERR79;
4356 goto FAILED;
4357 }
4358
4359
4360
4361 /*************************************************
4362 *       Find first significant opcode            *
4363 *************************************************/
4364
4365 /* This is called by several functions that scan a compiled expression looking
4366 for a fixed first character, or an anchoring opcode etc. It skips over things
4367 that do not influence this. For some calls, it makes sense to skip negative
4368 forward and all backward assertions, and also the \b assertion; for others it
4369 does not.
4370
4371 Arguments:
4372   code         pointer to the start of the group
4373   skipassert   TRUE if certain assertions are to be skipped
4374
4375 Returns:       pointer to the first significant opcode
4376 */
4377
4378 static const PCRE2_UCHAR*
4379 first_significant_code(PCRE2_SPTR code, BOOL skipassert)
4380 {
4381 for (;;)
4382   {
4383   switch ((int)*code)
4384     {
4385     case OP_ASSERT_NOT:
4386     case OP_ASSERTBACK:
4387     case OP_ASSERTBACK_NOT:
4388     if (!skipassert) return code;
4389     do code += GET(code, 1); while (*code == OP_ALT);
4390     code += PRIV(OP_lengths)[*code];
4391     break;
4392
4393     case OP_WORD_BOUNDARY:
4394     case OP_NOT_WORD_BOUNDARY:
4395     if (!skipassert) return code;
4396     /* Fall through */
4397
4398     case OP_CALLOUT:
4399     case OP_CREF:
4400     case OP_DNCREF:
4401     case OP_RREF:
4402     case OP_DNRREF:
4403     case OP_FALSE:
4404     case OP_TRUE:
4405     code += PRIV(OP_lengths)[*code];
4406     break;
4407
4408     case OP_CALLOUT_STR:
4409     code += GET(code, 1 + 2*LINK_SIZE);
4410     break;
4411
4412     case OP_SKIPZERO:
4413     code += 2 + GET(code, 2) + LINK_SIZE;
4414     break;
4415
4416     case OP_COND:
4417     case OP_SCOND:
4418     if (code[1+LINK_SIZE] != OP_FALSE ||   /* Not DEFINE */
4419         code[GET(code, 1)] != OP_KET)      /* More than one branch */
4420       return code;
4421     code += GET(code, 1) + 1 + LINK_SIZE;
4422     break;
4423
4424     default:
4425     return code;
4426     }
4427   }
4428 /* Control never reaches here */
4429 }
4430
4431
4432
4433 #ifdef SUPPORT_UNICODE
4434 /*************************************************
4435 *           Get othercase range                  *
4436 *************************************************/
4437
4438 /* This function is passed the start and end of a class range in UCP mode. It
4439 searches up the characters, looking for ranges of characters in the "other"
4440 case. Each call returns the next one, updating the start address. A character
4441 with multiple other cases is returned on its own with a special return value.
4442
4443 Arguments:
4444   cptr        points to starting character value; updated
4445   d           end value
4446   ocptr       where to put start of othercase range
4447   odptr       where to put end of othercase range
4448
4449 Yield:        -1 when no more
4450                0 when a range is returned
4451               >0 the CASESET offset for char with multiple other cases
4452                 in this case, ocptr contains the original
4453 */
4454
4455 static int
4456 get_othercase_range(uint32_t *cptr, uint32_t d, uint32_t *ocptr,
4457   uint32_t *odptr)
4458 {
4459 uint32_t c, othercase, next;
4460 unsigned int co;
4461
4462 /* Find the first character that has an other case. If it has multiple other
4463 cases, return its case offset value. */
4464
4465 for (c = *cptr; c <= d; c++)
4466   {
4467   if ((co = UCD_CASESET(c)) != 0)
4468     {
4469     *ocptr = c++;   /* Character that has the set */
4470     *cptr = c;      /* Rest of input range */
4471     return (int)co;
4472     }
4473   if ((othercase = UCD_OTHERCASE(c)) != c) break;
4474   }
4475
4476 if (c > d) return -1;  /* Reached end of range */
4477
4478 /* Found a character that has a single other case. Search for the end of the
4479 range, which is either the end of the input range, or a character that has zero
4480 or more than one other cases. */
4481
4482 *ocptr = othercase;
4483 next = othercase + 1;
4484
4485 for (++c; c <= d; c++)
4486   {
4487   if ((co = UCD_CASESET(c)) != 0 || UCD_OTHERCASE(c) != next) break;
4488   next++;
4489   }
4490
4491 *odptr = next - 1;     /* End of othercase range */
4492 *cptr = c;             /* Rest of input range */
4493 return 0;
4494 }
4495 #endif  /* SUPPORT_UNICODE */
4496
4497
4498
4499 /*************************************************
4500 * Add a character or range to a class (internal) *
4501 *************************************************/
4502
4503 /* This function packages up the logic of adding a character or range of
4504 characters to a class. The character values in the arguments will be within the
4505 valid values for the current mode (8-bit, 16-bit, UTF, etc). This function is
4506 called only from within the "add to class" group of functions, some of which
4507 are recursive and mutually recursive. The external entry point is
4508 add_to_class().
4509
4510 Arguments:
4511   classbits     the bit map for characters < 256
4512   uchardptr     points to the pointer for extra data
4513   options       the options word
4514   cb            compile data
4515   start         start of range character
4516   end           end of range character
4517
4518 Returns:        the number of < 256 characters added
4519                 the pointer to extra data is updated
4520 */
4521
4522 static unsigned int
4523 add_to_class_internal(uint8_t *classbits, PCRE2_UCHAR **uchardptr,
4524   uint32_t options, compile_block *cb, uint32_t start, uint32_t end)
4525 {
4526 uint32_t c;
4527 uint32_t classbits_end = (end <= 0xff ? end : 0xff);
4528 unsigned int n8 = 0;
4529
4530 /* If caseless matching is required, scan the range and process alternate
4531 cases. In Unicode, there are 8-bit characters that have alternate cases that
4532 are greater than 255 and vice-versa. Sometimes we can just extend the original
4533 range. */
4534
4535 if ((options & PCRE2_CASELESS) != 0)
4536   {
4537 #ifdef SUPPORT_UNICODE
4538   if ((options & PCRE2_UTF) != 0)
4539     {
4540     int rc;
4541     uint32_t oc, od;
4542
4543     options &= ~PCRE2_CASELESS;   /* Remove for recursive calls */
4544     c = start;
4545
4546     while ((rc = get_othercase_range(&c, end, &oc, &od)) >= 0)
4547       {
4548       /* Handle a single character that has more than one other case. */
4549
4550       if (rc > 0) n8 += add_list_to_class_internal(classbits, uchardptr, options, cb,
4551         PRIV(ucd_caseless_sets) + rc, oc);
4552
4553       /* Do nothing if the other case range is within the original range. */
4554
4555       else if (oc >= cb->class_range_start && od <= cb->class_range_end) continue;
4556
4557       /* Extend the original range if there is overlap, noting that if oc < c, we
4558       can't have od > end because a subrange is always shorter than the basic
4559       range. Otherwise, use a recursive call to add the additional range. */
4560
4561       else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */
4562       else if (od > end && oc <= end + 1)
4563         {
4564         end = od;       /* Extend upwards */
4565         if (end > classbits_end) classbits_end = (end <= 0xff ? end : 0xff);
4566         }
4567       else n8 += add_to_class_internal(classbits, uchardptr, options, cb, oc, od);
4568       }
4569     }
4570   else
4571 #endif  /* SUPPORT_UNICODE */
4572
4573   /* Not UTF mode */
4574
4575   for (c = start; c <= classbits_end; c++)
4576     {
4577     SETBIT(classbits, cb->fcc[c]);
4578     n8++;
4579     }
4580   }
4581
4582 /* Now handle the originally supplied range. Adjust the final value according
4583 to the bit length - this means that the same lists of (e.g.) horizontal spaces
4584 can be used in all cases. */
4585
4586 if ((options & PCRE2_UTF) == 0 && end > MAX_NON_UTF_CHAR)
4587   end = MAX_NON_UTF_CHAR;
4588
4589 if (start > cb->class_range_start && end < cb->class_range_end) return n8;
4590
4591 /* Use the bitmap for characters < 256. Otherwise use extra data.*/
4592
4593 for (c = start; c <= classbits_end; c++)
4594   {
4595   /* Regardless of start, c will always be <= 255. */
4596   SETBIT(classbits, c);
4597   n8++;
4598   }
4599
4600 #ifdef SUPPORT_WIDE_CHARS
4601 if (start <= 0xff) start = 0xff + 1;
4602
4603 if (end >= start)
4604   {
4605   PCRE2_UCHAR *uchardata = *uchardptr;
4606
4607 #ifdef SUPPORT_UNICODE
4608   if ((options & PCRE2_UTF) != 0)
4609     {
4610     if (start < end)
4611       {
4612       *uchardata++ = XCL_RANGE;
4613       uchardata += PRIV(ord2utf)(start, uchardata);
4614       uchardata += PRIV(ord2utf)(end, uchardata);
4615       }
4616     else if (start == end)
4617       {
4618       *uchardata++ = XCL_SINGLE;
4619       uchardata += PRIV(ord2utf)(start, uchardata);
4620       }
4621     }
4622   else
4623 #endif  /* SUPPORT_UNICODE */
4624
4625   /* Without UTF support, character values are constrained by the bit length,
4626   and can only be > 256 for 16-bit and 32-bit libraries. */
4627
4628 #if PCRE2_CODE_UNIT_WIDTH == 8
4629     {}
4630 #else
4631   if (start < end)
4632     {
4633     *uchardata++ = XCL_RANGE;
4634     *uchardata++ = start;
4635     *uchardata++ = end;
4636     }
4637   else if (start == end)
4638     {
4639     *uchardata++ = XCL_SINGLE;
4640     *uchardata++ = start;
4641     }
4642 #endif  /* PCRE2_CODE_UNIT_WIDTH == 8 */
4643   *uchardptr = uchardata;   /* Updata extra data pointer */
4644   }
4645 #else  /* SUPPORT_WIDE_CHARS */
4646   (void)uchardptr;          /* Avoid compiler warning */
4647 #endif /* SUPPORT_WIDE_CHARS */
4648
4649 return n8;    /* Number of 8-bit characters */
4650 }
4651
4652
4653
4654 #ifdef SUPPORT_UNICODE
4655 /*************************************************
4656 * Add a list of characters to a class (internal) *
4657 *************************************************/
4658
4659 /* This function is used for adding a list of case-equivalent characters to a
4660 class when in UTF mode. This function is called only from within
4661 add_to_class_internal(), with which it is mutually recursive.
4662
4663 Arguments:
4664   classbits     the bit map for characters < 256
4665   uchardptr     points to the pointer for extra data
4666   options       the options word
4667   cb            contains pointers to tables etc.
4668   p             points to row of 32-bit values, terminated by NOTACHAR
4669   except        character to omit; this is used when adding lists of
4670                   case-equivalent characters to avoid including the one we
4671                   already know about
4672
4673 Returns:        the number of < 256 characters added
4674                 the pointer to extra data is updated
4675 */
4676
4677 static unsigned int
4678 add_list_to_class_internal(uint8_t *classbits, PCRE2_UCHAR **uchardptr,
4679   uint32_t options, compile_block *cb, const uint32_t *p, unsigned int except)
4680 {
4681 unsigned int n8 = 0;
4682 while (p[0] < NOTACHAR)
4683   {
4684   unsigned int n = 0;
4685   if (p[0] != except)
4686     {
4687     while(p[n+1] == p[0] + n + 1) n++;
4688     n8 += add_to_class_internal(classbits, uchardptr, options, cb, p[0], p[n]);
4689     }
4690   p += n + 1;
4691   }
4692 return n8;
4693 }
4694 #endif
4695
4696
4697
4698 /*************************************************
4699 *   External entry point for add range to class  *
4700 *************************************************/
4701
4702 /* This function sets the overall range so that the internal functions can try
4703 to avoid duplication when handling case-independence.
4704
4705 Arguments:
4706   classbits     the bit map for characters < 256
4707   uchardptr     points to the pointer for extra data
4708   options       the options word
4709   cb            compile data
4710   start         start of range character
4711   end           end of range character
4712
4713 Returns:        the number of < 256 characters added
4714                 the pointer to extra data is updated
4715 */
4716
4717 static unsigned int
4718 add_to_class(uint8_t *classbits, PCRE2_UCHAR **uchardptr, uint32_t options,
4719   compile_block *cb, uint32_t start, uint32_t end)
4720 {
4721 cb->class_range_start = start;
4722 cb->class_range_end = end;
4723 return add_to_class_internal(classbits, uchardptr, options, cb, start, end);
4724 }
4725
4726
4727 /*************************************************
4728 *   External entry point for add list to class   *
4729 *************************************************/
4730
4731 /* This function is used for adding a list of horizontal or vertical whitespace
4732 characters to a class. The list must be in order so that ranges of characters
4733 can be detected and handled appropriately. This function sets the overall range
4734 so that the internal functions can try to avoid duplication when handling
4735 case-independence.
4736
4737 Arguments:
4738   classbits     the bit map for characters < 256
4739   uchardptr     points to the pointer for extra data
4740   options       the options word
4741   cb            contains pointers to tables etc.
4742   p             points to row of 32-bit values, terminated by NOTACHAR
4743   except        character to omit; this is used when adding lists of
4744                   case-equivalent characters to avoid including the one we
4745                   already know about
4746
4747 Returns:        the number of < 256 characters added
4748                 the pointer to extra data is updated
4749 */
4750
4751 static unsigned int
4752 add_list_to_class(uint8_t *classbits, PCRE2_UCHAR **uchardptr, uint32_t options,
4753   compile_block *cb, const uint32_t *p, unsigned int except)
4754 {
4755 unsigned int n8 = 0;
4756 while (p[0] < NOTACHAR)
4757   {
4758   unsigned int n = 0;
4759   if (p[0] != except)
4760     {
4761     while(p[n+1] == p[0] + n + 1) n++;
4762     cb->class_range_start = p[0];
4763     cb->class_range_end = p[n];
4764     n8 += add_to_class_internal(classbits, uchardptr, options, cb, p[0], p[n]);
4765     }
4766   p += n + 1;
4767   }
4768 return n8;
4769 }
4770
4771
4772
4773 /*************************************************
4774 *    Add characters not in a list to a class     *
4775 *************************************************/
4776
4777 /* This function is used for adding the complement of a list of horizontal or
4778 vertical whitespace to a class. The list must be in order.
4779
4780 Arguments:
4781   classbits     the bit map for characters < 256
4782   uchardptr     points to the pointer for extra data
4783   options       the options word
4784   cb            contains pointers to tables etc.
4785   p             points to row of 32-bit values, terminated by NOTACHAR
4786
4787 Returns:        the number of < 256 characters added
4788                 the pointer to extra data is updated
4789 */
4790
4791 static unsigned int
4792 add_not_list_to_class(uint8_t *classbits, PCRE2_UCHAR **uchardptr,
4793   uint32_t options, compile_block *cb, const uint32_t *p)
4794 {
4795 BOOL utf = (options & PCRE2_UTF) != 0;
4796 unsigned int n8 = 0;
4797 if (p[0] > 0)
4798   n8 += add_to_class(classbits, uchardptr, options, cb, 0, p[0] - 1);
4799 while (p[0] < NOTACHAR)
4800   {
4801   while (p[1] == p[0] + 1) p++;
4802   n8 += add_to_class(classbits, uchardptr, options, cb, p[0] + 1,
4803     (p[1] == NOTACHAR) ? (utf ? 0x10ffffu : 0xffffffffu) : p[1] - 1);
4804   p++;
4805   }
4806 return n8;
4807 }
4808
4809
4810
4811 /*************************************************
4812 *    Find details of duplicate group names       *
4813 *************************************************/
4814
4815 /* This is called from compile_branch() when it needs to know the index and
4816 count of duplicates in the names table when processing named backreferences,
4817 either directly, or as conditions.
4818
4819 Arguments:
4820   name          points to the name
4821   length        the length of the name
4822   indexptr      where to put the index
4823   countptr      where to put the count of duplicates
4824   errorcodeptr  where to put an error code
4825   cb            the compile block
4826
4827 Returns:        TRUE if OK, FALSE if not, error code set
4828 */
4829
4830 static BOOL
4831 find_dupname_details(PCRE2_SPTR name, uint32_t length, int *indexptr,
4832   int *countptr, int *errorcodeptr, compile_block *cb)
4833 {
4834 uint32_t i, groupnumber;
4835 int count;
4836 PCRE2_UCHAR *slot = cb->name_table;
4837
4838 /* Find the first entry in the table */
4839
4840 for (i = 0; i < cb->names_found; i++)
4841   {
4842   if (PRIV(strncmp)(name, slot+IMM2_SIZE, length) == 0 &&
4843       slot[IMM2_SIZE+length] == 0) break;
4844   slot += cb->name_entry_size;
4845   }
4846
4847 /* This should not occur, because this function is called only when we know we
4848 have duplicate names. Give an internal error. */
4849
4850 if (i >= cb->names_found)
4851   {
4852   *errorcodeptr = ERR53;
4853   cb->erroroffset = name - cb->start_pattern;
4854   return FALSE;
4855   }
4856
4857 /* Record the index and then see how many duplicates there are, updating the
4858 backref map and maximum back reference as we do. */
4859
4860 *indexptr = i;
4861 count = 0;
4862
4863 for (;;)
4864   {
4865   count++;
4866   groupnumber = GET2(slot,0);
4867   cb->backref_map |= (groupnumber < 32)? (1u << groupnumber) : 1;
4868   if (groupnumber > cb->top_backref) cb->top_backref = groupnumber;
4869   if (++i >= cb->names_found) break;
4870   slot += cb->name_entry_size;
4871   if (PRIV(strncmp)(name, slot+IMM2_SIZE, length) != 0 ||
4872     (slot+IMM2_SIZE)[length] != 0) break;
4873   }
4874
4875 *countptr = count;
4876 return TRUE;
4877 }
4878
4879
4880
4881 /*************************************************
4882 *           Compile one branch                   *
4883 *************************************************/
4884
4885 /* Scan the parsed pattern, compiling it into the a vector of PCRE2_UCHAR. If
4886 the options are changed during the branch, the pointer is used to change the
4887 external options bits. This function is used during the pre-compile phase when
4888 we are trying to find out the amount of memory needed, as well as during the
4889 real compile phase. The value of lengthptr distinguishes the two phases.
4890
4891 Arguments:
4892   optionsptr        pointer to the option bits
4893   codeptr           points to the pointer to the current code point
4894   pptrptr           points to the current parsed pattern pointer
4895   errorcodeptr      points to error code variable
4896   firstcuptr        place to put the first required code unit
4897   firstcuflagsptr   place to put the first code unit flags, or a negative number
4898   reqcuptr          place to put the last required code unit
4899   reqcuflagsptr     place to put the last required code unit flags, or a negative number
4900   bcptr             points to current branch chain
4901   cb                contains pointers to tables etc.
4902   lengthptr         NULL during the real compile phase
4903                     points to length accumulator during pre-compile phase
4904
4905 Returns:            0 There's been an error, *errorcodeptr is non-zero
4906                    +1 Success, this branch must match at least one character
4907                    -1 Success, this branch may match an empty string
4908 */
4909
4910 static int
4911 compile_branch(uint32_t *optionsptr, PCRE2_UCHAR **codeptr, uint32_t **pptrptr,
4912   int *errorcodeptr, uint32_t *firstcuptr, int32_t *firstcuflagsptr,
4913   uint32_t *reqcuptr, int32_t *reqcuflagsptr, branch_chain *bcptr,
4914   compile_block *cb, PCRE2_SIZE *lengthptr)
4915 {
4916 int bravalue = 0;
4917 int okreturn = -1;
4918 int group_return = 0;
4919 uint32_t repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
4920 uint32_t greedy_default, greedy_non_default;
4921 uint32_t repeat_type, op_type;
4922 uint32_t options = *optionsptr;               /* May change dynamically */
4923 uint32_t firstcu, reqcu;
4924 uint32_t zeroreqcu, zerofirstcu;
4925 uint32_t escape;
4926 uint32_t *pptr = *pptrptr;
4927 uint32_t meta, meta_arg;
4928 int32_t firstcuflags, reqcuflags;
4929 int32_t zeroreqcuflags, zerofirstcuflags;
4930 int32_t req_caseopt, reqvary, tempreqvary;
4931 PCRE2_SIZE offset = 0;
4932 PCRE2_SIZE length_prevgroup = 0;
4933 PCRE2_UCHAR *code = *codeptr;
4934 PCRE2_UCHAR *last_code = code;
4935 PCRE2_UCHAR *orig_code = code;
4936 PCRE2_UCHAR *tempcode;
4937 PCRE2_UCHAR *previous = NULL;
4938 PCRE2_UCHAR op_previous;
4939 BOOL groupsetfirstcu = FALSE;
4940 BOOL matched_char = FALSE;
4941 BOOL previous_matched_char = FALSE;
4942 const uint8_t *cbits = cb->cbits;
4943 uint8_t classbits[32];
4944
4945 /* We can fish out the UTF setting once and for all into a BOOL, but we must
4946 not do this for other options (e.g. PCRE2_EXTENDED) because they may change
4947 dynamically as we process the pattern. */
4948
4949 #ifdef SUPPORT_UNICODE
4950 BOOL utf = (options & PCRE2_UTF) != 0;
4951 #else  /* No UTF support */
4952 BOOL utf = FALSE;
4953 #endif
4954
4955 /* Helper variables for OP_XCLASS opcode (for characters > 255). We define
4956 class_uchardata always so that it can be passed to add_to_class() always,
4957 though it will not be used in non-UTF 8-bit cases. This avoids having to supply
4958 alternative calls for the different cases. */
4959
4960 PCRE2_UCHAR *class_uchardata;
4961 #ifdef SUPPORT_WIDE_CHARS
4962 BOOL xclass;
4963 PCRE2_UCHAR *class_uchardata_base;
4964 #endif
4965
4966 /* Set up the default and non-default settings for greediness */
4967
4968 greedy_default = ((options & PCRE2_UNGREEDY) != 0);
4969 greedy_non_default = greedy_default ^ 1;
4970
4971 /* Initialize no first unit, no required unit. REQ_UNSET means "no char
4972 matching encountered yet". It gets changed to REQ_NONE if we hit something that
4973 matches a non-fixed first unit; reqcu just remains unset if we never find one.
4974
4975 When we hit a repeat whose minimum is zero, we may have to adjust these values
4976 to take the zero repeat into account. This is implemented by setting them to
4977 zerofirstcu and zeroreqcu when such a repeat is encountered. The individual
4978 item types that can be repeated set these backoff variables appropriately. */
4979
4980 firstcu = reqcu = zerofirstcu = zeroreqcu = 0;
4981 firstcuflags = reqcuflags = zerofirstcuflags = zeroreqcuflags = REQ_UNSET;
4982
4983 /* The variable req_caseopt contains either the REQ_CASELESS value or zero,
4984 according to the current setting of the caseless flag. The REQ_CASELESS value
4985 leaves the lower 28 bit empty. It is added into the firstcu or reqcu variables
4986 to record the case status of the value. This is used only for ASCII characters.
4987 */
4988
4989 req_caseopt = ((options & PCRE2_CASELESS) != 0)? REQ_CASELESS:0;
4990
4991 /* Switch on next META item until the end of the branch */
4992
4993 for (;; pptr++)
4994   {
4995 #ifdef SUPPORT_WIDE_CHARS
4996   BOOL xclass_has_prop;
4997 #endif
4998   BOOL negate_class;
4999   BOOL should_flip_negation;
5000   BOOL match_all_or_no_wide_chars;
5001   BOOL possessive_quantifier;
5002   BOOL note_group_empty;
5003   int class_has_8bitchar;
5004   int i;
5005   uint32_t mclength;
5006   uint32_t skipunits;
5007   uint32_t subreqcu, subfirstcu;
5008   uint32_t groupnumber;
5009   uint32_t verbarglen, verbculen;
5010   int32_t subreqcuflags, subfirstcuflags;  /* Must be signed */
5011   open_capitem *oc;
5012   PCRE2_UCHAR mcbuffer[8];
5013
5014   /* Get next META item in the pattern and its potential argument. */
5015
5016   meta = META_CODE(*pptr);
5017   meta_arg = META_DATA(*pptr);
5018
5019   /* If we are in the pre-compile phase, accumulate the length used for the
5020   previous cycle of this loop, unless the next item is a quantifier. */
5021
5022   if (lengthptr != NULL)
5023     {
5024     if (code > cb->start_workspace + cb->workspace_size -
5025         WORK_SIZE_SAFETY_MARGIN)                       /* Check for overrun */
5026       {
5027       *errorcodeptr = (code >= cb->start_workspace + cb->workspace_size)?
5028         ERR52 : ERR86;
5029       return 0;
5030       }
5031
5032     /* There is at least one situation where code goes backwards: this is the
5033     case of a zero quantifier after a class (e.g. [ab]{0}). When the quantifier
5034     is processed, the whole class is eliminated. However, it is created first,
5035     so we have to allow memory for it. Therefore, don't ever reduce the length
5036     at this point. */
5037
5038     if (code < last_code) code = last_code;
5039
5040     /* If the next thing is not a quantifier, we add the length of the previous
5041     item into the total, and reset the code pointer to the start of the
5042     workspace. Otherwise leave the previous item available to be quantified. */
5043
5044     if (meta < META_ASTERISK || meta > META_MINMAX_QUERY)
5045       {
5046       if (OFLOW_MAX - *lengthptr < (PCRE2_SIZE)(code - orig_code))
5047         {
5048         *errorcodeptr = ERR20;   /* Integer overflow */
5049         return 0;
5050         }
5051       *lengthptr += (PCRE2_SIZE)(code - orig_code);
5052       if (*lengthptr > MAX_PATTERN_SIZE)
5053         {
5054         *errorcodeptr = ERR20;   /* Pattern is too large */
5055         return 0;
5056         }
5057       code = orig_code;
5058       }
5059
5060     /* Remember where this code item starts so we can catch the "backwards"
5061     case above next time round. */
5062
5063     last_code = code;
5064     }
5065
5066   /* Process the next parsed pattern item. If it is not a quantifier, remember
5067   where it starts so that it can be quantified when a quantifier follows.
5068   Checking for the legality of quantifiers happens in parse_regex(), except for
5069   a quantifier after an assertion that is a condition. */
5070
5071   if (meta < META_ASTERISK || meta > META_MINMAX_QUERY)
5072     {
5073     previous = code;
5074     if (matched_char) okreturn = 1;
5075     }
5076
5077   previous_matched_char = matched_char;
5078   matched_char = FALSE;
5079   note_group_empty = FALSE;
5080   skipunits = 0;         /* Default value for most subgroups */
5081
5082   switch(meta)
5083     {
5084     /* ===================================================================*/
5085     /* The branch terminates at pattern end or | or ) */
5086
5087     case META_END:
5088     case META_ALT:
5089     case META_KET:
5090     *firstcuptr = firstcu;
5091     *firstcuflagsptr = firstcuflags;
5092     *reqcuptr = reqcu;
5093     *reqcuflagsptr = reqcuflags;
5094     *codeptr = code;
5095     *pptrptr = pptr;
5096     return okreturn;
5097
5098
5099     /* ===================================================================*/
5100     /* Handle single-character metacharacters. In multiline mode, ^ disables
5101     the setting of any following char as a first character. */
5102
5103     case META_CIRCUMFLEX:
5104     if ((options & PCRE2_MULTILINE) != 0)
5105       {
5106       if (firstcuflags == REQ_UNSET)
5107         zerofirstcuflags = firstcuflags = REQ_NONE;
5108       *code++ = OP_CIRCM;
5109       }
5110     else *code++ = OP_CIRC;
5111     break;
5112
5113     case META_DOLLAR:
5114     *code++ = ((options & PCRE2_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;
5115     break;
5116
5117     /* There can never be a first char if '.' is first, whatever happens about
5118     repeats. The value of reqcu doesn't change either. */
5119
5120     case META_DOT:
5121     matched_char = TRUE;
5122     if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
5123     zerofirstcu = firstcu;
5124     zerofirstcuflags = firstcuflags;
5125     zeroreqcu = reqcu;
5126     zeroreqcuflags = reqcuflags;
5127     *code++ = ((options & PCRE2_DOTALL) != 0)? OP_ALLANY: OP_ANY;
5128     break;
5129
5130
5131     /* ===================================================================*/
5132     /* Empty character classes are allowed if PCRE2_ALLOW_EMPTY_CLASS is set.
5133     Otherwise, an initial ']' is taken as a data character. When empty classes
5134     are allowed, [] must always fail, so generate OP_FAIL, whereas [^] must
5135     match any character, so generate OP_ALLANY. */
5136
5137     case META_CLASS_EMPTY:
5138     case META_CLASS_EMPTY_NOT:
5139     matched_char = TRUE;
5140     *code++ = (meta == META_CLASS_EMPTY_NOT)? OP_ALLANY : OP_FAIL;
5141     if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
5142     zerofirstcu = firstcu;
5143     zerofirstcuflags = firstcuflags;
5144     break;
5145
5146
5147     /* ===================================================================*/
5148     /* Non-empty character class. If the included characters are all < 256, we
5149     build a 32-byte bitmap of the permitted characters, except in the special
5150     case where there is only one such character. For negated classes, we build
5151     the map as usual, then invert it at the end. However, we use a different
5152     opcode so that data characters > 255 can be handled correctly.
5153
5154     If the class contains characters outside the 0-255 range, a different
5155     opcode is compiled. It may optionally have a bit map for characters < 256,
5156     but those above are are explicitly listed afterwards. A flag code unit
5157     tells whether the bitmap is present, and whether this is a negated class or
5158     not. */
5159
5160     case META_CLASS_NOT:
5161     case META_CLASS:
5162     matched_char = TRUE;
5163     negate_class = meta == META_CLASS_NOT;
5164
5165     /* We can optimize the case of a single character in a class by generating
5166     OP_CHAR or OP_CHARI if it's positive, or OP_NOT or OP_NOTI if it's
5167     negative. In the negative case there can be no first char if this item is
5168     first, whatever repeat count may follow. In the case of reqcu, save the
5169     previous value for reinstating. */
5170
5171     /* NOTE: at present this optimization is not effective if the only
5172     character in a class in 32-bit, non-UCP mode has its top bit set. */
5173
5174     if (pptr[1] < META_END && pptr[2] == META_CLASS_END)
5175       {
5176 #ifdef SUPPORT_UNICODE
5177       uint32_t d;
5178 #endif
5179       uint32_t c = pptr[1];
5180
5181       pptr += 2;                 /* Move on to class end */
5182       if (meta == META_CLASS)    /* A positive one-char class can be */
5183         {                        /* handled as a normal literal character. */
5184         meta = c;                /* Set up the character */
5185         goto NORMAL_CHAR_SET;
5186         }
5187
5188       /* Handle a negative one-character class */
5189
5190       zeroreqcu = reqcu;
5191       zeroreqcuflags = reqcuflags;
5192       if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
5193       zerofirstcu = firstcu;
5194       zerofirstcuflags = firstcuflags;
5195
5196       /* For caseless UTF mode, check whether this character has more than
5197       one other case. If so, generate a special OP_NOTPROP item instead of
5198       OP_NOTI. */
5199
5200 #ifdef SUPPORT_UNICODE
5201       if (utf && (options & PCRE2_CASELESS) != 0 &&
5202           (d = UCD_CASESET(c)) != 0)
5203         {
5204         *code++ = OP_NOTPROP;
5205         *code++ = PT_CLIST;
5206         *code++ = d;
5207         break;   /* We are finished with this class */
5208         }
5209 #endif
5210       /* Char has only one other case, or UCP not available */
5211
5212       *code++ = ((options & PCRE2_CASELESS) != 0)? OP_NOTI: OP_NOT;
5213       code += PUTCHAR(c, code);
5214       break;   /* We are finished with this class */
5215       }        /* End of 1-char optimization */
5216
5217     /* Handle character classes that contain more than just one literal
5218     character. */
5219
5220     /* If a non-extended class contains a negative special such as \S, we need
5221     to flip the negation flag at the end, so that support for characters > 255
5222     works correctly (they are all included in the class). An extended class may
5223     need to insert specific matching or non-matching code for wide characters.
5224     */
5225
5226     should_flip_negation = match_all_or_no_wide_chars = FALSE;
5227
5228     /* Extended class (xclass) will be used when characters > 255
5229     might match. */
5230
5231 #ifdef SUPPORT_WIDE_CHARS
5232     xclass = FALSE;
5233     class_uchardata = code + LINK_SIZE + 2;   /* For XCLASS items */
5234     class_uchardata_base = class_uchardata;   /* Save the start */
5235 #endif
5236
5237     /* For optimization purposes, we track some properties of the class:
5238     class_has_8bitchar will be non-zero if the class contains at least one
5239     character with a code point less than 256; xclass_has_prop will be TRUE if
5240     Unicode property checks are present in the class. */
5241
5242     class_has_8bitchar = 0;
5243 #ifdef SUPPORT_WIDE_CHARS
5244     xclass_has_prop = FALSE;
5245 #endif
5246
5247     /* Initialize the 256-bit (32-byte) bit map to all zeros. We build the map
5248     in a temporary bit of memory, in case the class contains fewer than two
5249     8-bit characters because in that case the compiled code doesn't use the bit
5250     map. */
5251
5252     memset(classbits, 0, 32 * sizeof(uint8_t));
5253
5254     /* Process items until META_CLASS_END is reached. */
5255
5256     while ((meta = *(++pptr)) != META_CLASS_END)
5257       {
5258       /* Handle POSIX classes such as [:alpha:] etc. */
5259
5260       if (meta == META_POSIX || meta == META_POSIX_NEG)
5261         {
5262         BOOL local_negate = (meta == META_POSIX_NEG);
5263         int posix_class = *(++pptr);
5264         int taboffset, tabopt;
5265         uint8_t pbits[32];
5266
5267         should_flip_negation = local_negate;  /* Note negative special */
5268
5269         /* If matching is caseless, upper and lower are converted to alpha.
5270         This relies on the fact that the class table starts with alpha,
5271         lower, upper as the first 3 entries. */
5272
5273         if ((options & PCRE2_CASELESS) != 0 && posix_class <= 2)
5274           posix_class = 0;
5275
5276         /* When PCRE2_UCP is set, some of the POSIX classes are converted to
5277         different escape sequences that use Unicode properties \p or \P.
5278         Others that are not available via \p or \P have to generate
5279         XCL_PROP/XCL_NOTPROP directly, which is done here. */
5280
5281 #ifdef SUPPORT_UNICODE
5282         if ((options & PCRE2_UCP) != 0) switch(posix_class)
5283           {
5284           case PC_GRAPH:
5285           case PC_PRINT:
5286           case PC_PUNCT:
5287           *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP;
5288           *class_uchardata++ = (PCRE2_UCHAR)
5289             ((posix_class == PC_GRAPH)? PT_PXGRAPH :
5290              (posix_class == PC_PRINT)? PT_PXPRINT : PT_PXPUNCT);
5291           *class_uchardata++ = 0;
5292           xclass_has_prop = TRUE;
5293           goto CONTINUE_CLASS;
5294
5295           /* For the other POSIX classes (ascii, xdigit) we are going to
5296           fall through to the non-UCP case and build a bit map for
5297           characters with code points less than 256. However, if we are in
5298           a negated POSIX class, characters with code points greater than
5299           255 must either all match or all not match, depending on whether
5300           the whole class is not or is negated. For example, for
5301           [[:^ascii:]... they must all match, whereas for [^[:^xdigit:]...
5302           they must not.
5303
5304           In the special case where there are no xclass items, this is
5305           automatically handled by the use of OP_CLASS or OP_NCLASS, but an
5306           explicit range is needed for OP_XCLASS. Setting a flag here
5307           causes the range to be generated later when it is known that
5308           OP_XCLASS is required. In the 8-bit library this is relevant only in
5309           utf mode, since no wide characters can exist otherwise. */
5310
5311           default:
5312 #if PCRE2_CODE_UNIT_WIDTH == 8
5313           if (utf)
5314 #endif
5315           match_all_or_no_wide_chars |= local_negate;
5316           break;
5317           }
5318 #endif  /* SUPPORT_UNICODE */
5319
5320         /* In the non-UCP case, or when UCP makes no difference, we build the
5321         bit map for the POSIX class in a chunk of local store because we may
5322         be adding and subtracting from it, and we don't want to subtract bits
5323         that may be in the main map already. At the end we or the result into
5324         the bit map that is being built. */
5325
5326         posix_class *= 3;
5327
5328         /* Copy in the first table (always present) */
5329
5330         memcpy(pbits, cbits + posix_class_maps[posix_class],
5331           32 * sizeof(uint8_t));
5332
5333         /* If there is a second table, add or remove it as required. */
5334
5335         taboffset = posix_class_maps[posix_class + 1];
5336         tabopt = posix_class_maps[posix_class + 2];
5337
5338         if (taboffset >= 0)
5339           {
5340           if (tabopt >= 0)
5341             for (i = 0; i < 32; i++) pbits[i] |= cbits[(int)i + taboffset];
5342           else
5343             for (i = 0; i < 32; i++) pbits[i] &= ~cbits[(int)i + taboffset];
5344           }
5345
5346         /* Now see if we need to remove any special characters. An option
5347         value of 1 removes vertical space and 2 removes underscore. */
5348
5349         if (tabopt < 0) tabopt = -tabopt;
5350         if (tabopt == 1) pbits[1] &= ~0x3c;
5351           else if (tabopt == 2) pbits[11] &= 0x7f;
5352
5353         /* Add the POSIX table or its complement into the main table that is
5354         being built and we are done. */
5355
5356         if (local_negate)
5357           for (i = 0; i < 32; i++) classbits[i] |= ~pbits[i];
5358         else
5359           for (i = 0; i < 32; i++) classbits[i] |= pbits[i];
5360
5361         /* Every class contains at least one < 256 character. */
5362
5363         class_has_8bitchar = 1;
5364         goto CONTINUE_CLASS;    /* End of POSIX handling */
5365         }
5366
5367       /* Other than POSIX classes, the only items we should encounter are
5368       \d-type escapes and literal characters (possibly as ranges). */
5369
5370       if (meta == META_BIGVALUE)
5371         {
5372         meta = *(++pptr);
5373         goto CLASS_LITERAL;
5374         }
5375
5376       /* Any other non-literal must be an escape */
5377
5378       if (meta >= META_END)
5379         {
5380         if (META_CODE(meta) != META_ESCAPE)
5381           {
5382 #ifdef DEBUG_SHOW_PARSED
5383           fprintf(stderr, "** Unrecognized parsed pattern item 0x%.8x "
5384                           "in character class\n", meta);
5385 #endif
5386           *errorcodeptr = ERR89;  /* Internal error - unrecognized. */
5387           return 0;
5388           }
5389         escape = META_DATA(meta);
5390
5391         /* Every class contains at least one < 256 character. */
5392
5393         class_has_8bitchar++;
5394
5395         switch(escape)
5396           {
5397           case ESC_d:
5398           for (i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_digit];
5399           break;
5400
5401           case ESC_D:
5402           should_flip_negation = TRUE;
5403           for (i = 0; i < 32; i++) classbits[i] |= ~cbits[i+cbit_digit];
5404           break;
5405
5406           case ESC_w:
5407           for (i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_word];
5408           break;
5409
5410           case ESC_W:
5411           should_flip_negation = TRUE;
5412           for (i = 0; i < 32; i++) classbits[i] |= ~cbits[i+cbit_word];
5413           break;
5414
5415           /* Perl 5.004 onwards omitted VT from \s, but restored it at Perl
5416           5.18. Before PCRE 8.34, we had to preserve the VT bit if it was
5417           previously set by something earlier in the character class.
5418           Luckily, the value of CHAR_VT is 0x0b in both ASCII and EBCDIC, so
5419           we could just adjust the appropriate bit. From PCRE 8.34 we no
5420           longer treat \s and \S specially. */
5421
5422           case ESC_s:
5423           for (i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_space];
5424           break;
5425
5426           case ESC_S:
5427           should_flip_negation = TRUE;
5428           for (i = 0; i < 32; i++) classbits[i] |= ~cbits[i+cbit_space];
5429           break;
5430
5431           /* When adding the horizontal or vertical space lists to a class, or
5432           their complements, disable PCRE2_CASELESS, because it justs wastes
5433           time, and in the "not-x" UTF cases can create unwanted duplicates in
5434           the XCLASS list (provoked by characters that have more than one other
5435           case and by both cases being in the same "not-x" sublist). */
5436
5437           case ESC_h:
5438           (void)add_list_to_class(classbits, &class_uchardata,
5439             options & ~PCRE2_CASELESS, cb, PRIV(hspace_list), NOTACHAR);
5440           break;
5441
5442           case ESC_H:
5443           (void)add_not_list_to_class(classbits, &class_uchardata,
5444             options & ~PCRE2_CASELESS, cb, PRIV(hspace_list));
5445           break;
5446
5447           case ESC_v:
5448           (void)add_list_to_class(classbits, &class_uchardata,
5449             options & ~PCRE2_CASELESS, cb, PRIV(vspace_list), NOTACHAR);
5450           break;
5451
5452           case ESC_V:
5453           (void)add_not_list_to_class(classbits, &class_uchardata,
5454             options & ~PCRE2_CASELESS, cb, PRIV(vspace_list));
5455           break;
5456
5457           /* If Unicode is not supported, \P and \p are not allowed and are
5458           faulted at parse time, so will never appear here. */
5459
5460 #ifdef SUPPORT_UNICODE
5461           case ESC_p:
5462           case ESC_P:
5463             {
5464             uint32_t ptype = *(++pptr) >> 16;
5465             uint32_t pdata = *pptr & 0xffff;
5466             *class_uchardata++ = (escape == ESC_p)? XCL_PROP : XCL_NOTPROP;
5467             *class_uchardata++ = ptype;
5468             *class_uchardata++ = pdata;
5469             xclass_has_prop = TRUE;
5470             class_has_8bitchar--;                /* Undo! */
5471             }
5472           break;
5473 #endif
5474           }
5475
5476         goto CONTINUE_CLASS;
5477         }  /* End handling \d-type escapes */
5478
5479       /* A literal character may be followed by a range meta. At parse time
5480       there are checks for out-of-order characters, for ranges where the two
5481       characters are equal, and for hyphens that cannot indicate a range. At
5482       this point, therefore, no checking is needed. */
5483
5484       else
5485         {
5486         uint32_t c, d;
5487
5488         CLASS_LITERAL:
5489         c = d = meta;
5490
5491         /* Remember if \r or \n were explicitly used */
5492
5493         if (c == CHAR_CR || c == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF;
5494
5495         /* Process a character range */
5496
5497         if (pptr[1] == META_RANGE_LITERAL || pptr[1] == META_RANGE_ESCAPED)
5498           {
5499 #ifdef EBCDIC
5500           BOOL range_is_literal = (pptr[1] == META_RANGE_LITERAL);
5501 #endif
5502           pptr += 2;
5503           d = *pptr;
5504           if (d == META_BIGVALUE) d = *(++pptr);
5505
5506           /* Remember an explicit \r or \n, and add the range to the class. */
5507
5508           if (d == CHAR_CR || d == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF;
5509
5510           /* In an EBCDIC environment, Perl treats alphabetic ranges specially
5511           because there are holes in the encoding, and simply using the range
5512           A-Z (for example) would include the characters in the holes. This
5513           applies only to literal ranges; [\xC1-\xE9] is different to [A-Z]. */
5514
5515 #ifdef EBCDIC
5516           if (range_is_literal &&
5517                (cb->ctypes[c] & ctype_letter) != 0 &&
5518                (cb->ctypes[d] & ctype_letter) != 0 &&
5519                (d <= CHAR_z) == (d <= CHAR_z))
5520             {
5521             uint32_t uc = (d <= CHAR_z)? 0 : 64;
5522             uint32_t C = d - uc;
5523             uint32_t D = d - uc;
5524
5525             if (C <= CHAR_i)
5526               {
5527               class_has_8bitchar +=
5528                 add_to_class(classbits, &class_uchardata, options, cb, C + uc,
5529                   ((D < CHAR_i)? D : CHAR_i) + uc);
5530               C = CHAR_j;
5531               }
5532
5533             if (C <= D && C <= CHAR_r)
5534               {
5535               class_has_8bitchar +=
5536                 add_to_class(classbits, &class_uchardata, options, cb, C + uc,
5537                   ((D < CHAR_r)? D : CHAR_r) + uc);
5538               C = CHAR_s;
5539               }
5540
5541             if (C <= D)
5542               {
5543               class_has_8bitchar +=
5544                 add_to_class(classbits, &class_uchardata, options, cb, C + uc,
5545                   D + uc);
5546               }
5547             }
5548           else
5549 #endif
5550           /* Not an EBCDIC special range */
5551
5552           class_has_8bitchar +=
5553             add_to_class(classbits, &class_uchardata, options, cb, c, d);
5554           goto CONTINUE_CLASS;   /* Go get the next char in the class */
5555           }  /* End of range handling */
5556
5557
5558         /* Handle a single character. */
5559
5560         class_has_8bitchar +=
5561           add_to_class(classbits, &class_uchardata, options, cb, meta, meta);
5562         }
5563
5564       /* Continue to the next item in the class. */
5565
5566       CONTINUE_CLASS:
5567
5568 #ifdef SUPPORT_WIDE_CHARS
5569       /* If any wide characters or Unicode properties have been encountered,
5570       set xclass = TRUE. Then, in the pre-compile phase, accumulate the length
5571       of the extra data and reset the pointer. This is so that very large
5572       classes that contain a zillion wide characters or Unicode property tests
5573       do not overwrite the workspace (which is on the stack). */
5574
5575       if (class_uchardata > class_uchardata_base)
5576         {
5577         xclass = TRUE;
5578         if (lengthptr != NULL)
5579           {
5580           *lengthptr += class_uchardata - class_uchardata_base;
5581           class_uchardata = class_uchardata_base;
5582           }
5583         }
5584 #endif
5585
5586       continue;  /* Needed to avoid error when not supporting wide chars */
5587       }   /* End of main class-processing loop */
5588
5589     /* If this class is the first thing in the branch, there can be no first
5590     char setting, whatever the repeat count. Any reqcu setting must remain
5591     unchanged after any kind of repeat. */
5592
5593     if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
5594     zerofirstcu = firstcu;
5595     zerofirstcuflags = firstcuflags;
5596     zeroreqcu = reqcu;
5597     zeroreqcuflags = reqcuflags;
5598
5599     /* If there are characters with values > 255, or Unicode property settings
5600     (\p or \P), we have to compile an extended class, with its own opcode,
5601     unless there were no property settings and there was a negated special such
5602     as \S in the class, and PCRE2_UCP is not set, because in that case all
5603     characters > 255 are in or not in the class, so any that were explicitly
5604     given as well can be ignored.
5605
5606     In the UCP case, if certain negated POSIX classes ([:^ascii:] or
5607     [^:xdigit:]) were present in a class, we either have to match or not match
5608     all wide characters (depending on whether the whole class is or is not
5609     negated). This requirement is indicated by match_all_or_no_wide_chars being
5610     true. We do this by including an explicit range, which works in both cases.
5611     This applies only in UTF and 16-bit and 32-bit non-UTF modes, since there
5612     cannot be any wide characters in 8-bit non-UTF mode.
5613
5614     When there *are* properties in a positive UTF-8 or any 16-bit or 32_bit
5615     class where \S etc is present without PCRE2_UCP, causing an extended class
5616     to be compiled, we make sure that all characters > 255 are included by
5617     forcing match_all_or_no_wide_chars to be true.
5618
5619     If, when generating an xclass, there are no characters < 256, we can omit
5620     the bitmap in the actual compiled code. */
5621
5622 #ifdef SUPPORT_WIDE_CHARS  /* Defined for 16/32 bits, or 8-bit with Unicode */
5623     if (xclass && (
5624 #ifdef SUPPORT_UNICODE
5625         (options & PCRE2_UCP) != 0 ||
5626 #endif
5627         xclass_has_prop || !should_flip_negation))
5628       {
5629       if (match_all_or_no_wide_chars || (
5630 #if PCRE2_CODE_UNIT_WIDTH == 8
5631            utf &&
5632 #endif
5633            should_flip_negation && !negate_class && (options & PCRE2_UCP) == 0))
5634         {
5635         *class_uchardata++ = XCL_RANGE;
5636         if (utf)   /* Will always be utf in the 8-bit library */
5637           {
5638           class_uchardata += PRIV(ord2utf)(0x100, class_uchardata);
5639           class_uchardata += PRIV(ord2utf)(MAX_UTF_CODE_POINT, class_uchardata);
5640           }
5641         else       /* Can only happen for the 16-bit & 32-bit libraries */
5642           {
5643 #if PCRE2_CODE_UNIT_WIDTH == 16
5644           *class_uchardata++ = 0x100;
5645           *class_uchardata++ = 0xffffu;
5646 #elif PCRE2_CODE_UNIT_WIDTH == 32
5647           *class_uchardata++ = 0x100;
5648           *class_uchardata++ = 0xffffffffu;
5649 #endif
5650           }
5651         }
5652       *class_uchardata++ = XCL_END;    /* Marks the end of extra data */
5653       *code++ = OP_XCLASS;
5654       code += LINK_SIZE;
5655       *code = negate_class? XCL_NOT:0;
5656       if (xclass_has_prop) *code |= XCL_HASPROP;
5657
5658       /* If the map is required, move up the extra data to make room for it;
5659       otherwise just move the code pointer to the end of the extra data. */
5660
5661       if (class_has_8bitchar > 0)
5662         {
5663         *code++ |= XCL_MAP;
5664         (void)memmove(code + (32 / sizeof(PCRE2_UCHAR)), code,
5665           CU2BYTES(class_uchardata - code));
5666         if (negate_class && !xclass_has_prop)
5667           for (i = 0; i < 32; i++) classbits[i] = ~classbits[i];
5668         memcpy(code, classbits, 32);
5669         code = class_uchardata + (32 / sizeof(PCRE2_UCHAR));
5670         }
5671       else code = class_uchardata;
5672
5673       /* Now fill in the complete length of the item */
5674
5675       PUT(previous, 1, (int)(code - previous));
5676       break;   /* End of class handling */
5677       }
5678 #endif  /* SUPPORT_WIDE_CHARS */
5679
5680     /* If there are no characters > 255, or they are all to be included or
5681     excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the
5682     whole class was negated and whether there were negative specials such as \S
5683     (non-UCP) in the class. Then copy the 32-byte map into the code vector,
5684     negating it if necessary. */
5685
5686     *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
5687     if (lengthptr == NULL)    /* Save time in the pre-compile phase */
5688       {
5689       if (negate_class)
5690         for (i = 0; i < 32; i++) classbits[i] = ~classbits[i];
5691       memcpy(code, classbits, 32);
5692       }
5693     code += 32 / sizeof(PCRE2_UCHAR);
5694     break;  /* End of class processing */
5695
5696
5697     /* ===================================================================*/
5698     /* Deal with (*VERB)s. */
5699
5700     /* Check for open captures before ACCEPT and close those that are within
5701     the same assertion level, also converting ACCEPT to ASSERT_ACCEPT in an
5702     assertion. In the first pass, just accumulate the length required;
5703     otherwise hitting (*ACCEPT) inside many nested parentheses can cause
5704     workspace overflow. Do not set firstcu after *ACCEPT. */
5705
5706     case META_ACCEPT:
5707     cb->had_accept = TRUE;
5708     for (oc = cb->open_caps;
5709          oc != NULL && oc->assert_depth >= cb->assert_depth;
5710          oc = oc->next)
5711       {
5712       if (lengthptr != NULL)
5713         {
5714         *lengthptr += CU2BYTES(1) + IMM2_SIZE;
5715         }
5716       else
5717         {
5718         *code++ = OP_CLOSE;
5719         PUT2INC(code, 0, oc->number);
5720         }
5721       }
5722     *code++ = (cb->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
5723     if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
5724     break;
5725
5726     case META_PRUNE:
5727     case META_SKIP:
5728     cb->had_pruneorskip = TRUE;
5729     /* Fall through */
5730     case META_COMMIT:
5731     case META_FAIL:
5732     *code++ = verbops[(meta - META_MARK) >> 16];
5733     break;
5734
5735     case META_THEN:
5736     cb->external_flags |= PCRE2_HASTHEN;
5737     *code++ = OP_THEN;
5738     break;
5739
5740     /* Handle verbs with arguments. Arguments can be very long, especially in
5741     16- and 32-bit modes, and can overflow the workspace in the first pass.
5742     However, the argument length is constrained to be small enough to fit in
5743     one code unit. This check happens in parse_regex(). In the first pass,
5744     instead of putting the argument into memory, we just update the length
5745     counter and set up an empty argument. */
5746
5747     case META_THEN_ARG:
5748     cb->external_flags |= PCRE2_HASTHEN;
5749     goto VERB_ARG;
5750
5751     case META_PRUNE_ARG:
5752     case META_SKIP_ARG:
5753     cb->had_pruneorskip = TRUE;
5754     /* Fall through */
5755     case META_MARK:
5756     case META_COMMIT_ARG:
5757     VERB_ARG:
5758     *code++ = verbops[(meta - META_MARK) >> 16];
5759     /* The length is in characters. */
5760     verbarglen = *(++pptr);
5761     verbculen = 0;
5762     tempcode = code++;
5763     for (i = 0; i < (int)verbarglen; i++)
5764       {
5765       meta = *(++pptr);
5766 #ifdef SUPPORT_UNICODE
5767       if (utf) mclength = PRIV(ord2utf)(meta, mcbuffer); else
5768 #endif
5769         {
5770         mclength = 1;
5771         mcbuffer[0] = meta;
5772         }
5773       if (lengthptr != NULL) *lengthptr += mclength; else
5774         {
5775         memcpy(code, mcbuffer, CU2BYTES(mclength));
5776         code += mclength;
5777         verbculen += mclength;
5778         }
5779       }
5780
5781     *tempcode = verbculen;   /* Fill in the code unit length */
5782     *code++ = 0;             /* Terminating zero */
5783     break;
5784
5785
5786     /* ===================================================================*/
5787     /* Handle options change. The new setting must be passed back for use in
5788     subsequent branches. Reset the greedy defaults and the case value for
5789     firstcu and reqcu. */
5790
5791     case META_OPTIONS:
5792     *optionsptr = options = *(++pptr);
5793     greedy_default = ((options & PCRE2_UNGREEDY) != 0);
5794     greedy_non_default = greedy_default ^ 1;
5795     req_caseopt = ((options & PCRE2_CASELESS) != 0)? REQ_CASELESS : 0;
5796     break;
5797
5798
5799     /* ===================================================================*/
5800     /* Handle conditional subpatterns. The case of (?(Rdigits) is ambiguous
5801     because it could be a numerical check on recursion, or a name check on a
5802     group's being set. The pre-pass sets up META_COND_RNUMBER as a name so that
5803     we can handle it either way. We first try for a name; if not found, process
5804     the number. */
5805
5806     case META_COND_RNUMBER:   /* (?(Rdigits) */
5807     case META_COND_NAME:      /* (?(name) or (?'name') or ?(<name>) */
5808     case META_COND_RNAME:     /* (?(R&name) - test for recursion */
5809     bravalue = OP_COND;
5810       {
5811       int count, index;
5812       PCRE2_SPTR name;
5813       named_group *ng = cb->named_groups;
5814       uint32_t length = *(++pptr);
5815
5816       GETPLUSOFFSET(offset, pptr);
5817       name = cb->start_pattern + offset;
5818
5819       /* In the first pass, the names generated in the pre-pass are available,
5820       but the main name table has not yet been created. Scan the list of names
5821       generated in the pre-pass in order to get a number and whether or not
5822       this name is duplicated. If it is not duplicated, we can handle it as a
5823       numerical group. */
5824
5825       for (i = 0; i < cb->names_found; i++, ng++)
5826         {
5827         if (length == ng->length &&
5828             PRIV(strncmp)(name, ng->name, length) == 0)
5829           {
5830           if (!ng->isdup)
5831             {
5832             code[1+LINK_SIZE] = (meta == META_COND_RNAME)? OP_RREF : OP_CREF;
5833             PUT2(code, 2+LINK_SIZE, ng->number);
5834             if (ng->number > cb->top_backref) cb->top_backref = ng->number;
5835             skipunits = 1+IMM2_SIZE;
5836             goto GROUP_PROCESS_NOTE_EMPTY;
5837             }
5838           break;  /* Found a duplicated name */
5839           }
5840         }
5841
5842       /* If the name was not found we have a bad reference, unless we are
5843       dealing with R<digits>, which is treated as a recursion test by number.
5844       */
5845
5846       if (i >= cb->names_found)
5847         {
5848         groupnumber = 0;
5849         if (meta == META_COND_RNUMBER)
5850           {
5851           for (i = 1; i < (int)length; i++)
5852             {
5853             groupnumber = groupnumber * 10 + name[i] - CHAR_0;
5854             if (groupnumber > MAX_GROUP_NUMBER)
5855               {
5856               *errorcodeptr = ERR61;
5857               cb->erroroffset = offset + i;
5858               return 0;
5859               }
5860             }
5861           }
5862
5863         if (meta != META_COND_RNUMBER || groupnumber > cb->bracount)
5864           {
5865           *errorcodeptr = ERR15;
5866           cb->erroroffset = offset;
5867           return 0;
5868           }
5869
5870         /* (?Rdigits) treated as a recursion reference by number. A value of
5871         zero (which is the result of both (?R) and (?R0)) means "any", and is
5872         translated into RREF_ANY (which is 0xffff). */
5873
5874         if (groupnumber == 0) groupnumber = RREF_ANY;
5875         code[1+LINK_SIZE] = OP_RREF;
5876         PUT2(code, 2+LINK_SIZE, groupnumber);
5877         skipunits = 1+IMM2_SIZE;
5878         goto GROUP_PROCESS_NOTE_EMPTY;
5879         }
5880
5881       /* A duplicated name was found. Note that if an R<digits> name is found
5882       (META_COND_RNUMBER), it is a reference test, not a recursion test. */
5883
5884       code[1+LINK_SIZE] = (meta == META_COND_RNAME)? OP_RREF : OP_CREF;
5885
5886       /* We have a duplicated name. In the compile pass we have to search the
5887       main table in order to get the index and count values. */
5888
5889       count = 0;  /* Values for first pass (avoids compiler warning) */
5890       index = 0;
5891       if (lengthptr == NULL && !find_dupname_details(name, length, &index,
5892             &count, errorcodeptr, cb)) return 0;
5893
5894       /* Add one to the opcode to change CREF/RREF into DNCREF/DNRREF and
5895       insert appropriate data values. */
5896
5897       code[1+LINK_SIZE]++;
5898       skipunits = 1+2*IMM2_SIZE;
5899       PUT2(code, 2+LINK_SIZE, index);
5900       PUT2(code, 2+LINK_SIZE+IMM2_SIZE, count);
5901       }
5902     goto GROUP_PROCESS_NOTE_EMPTY;
5903
5904     /* The DEFINE condition is always false. It's internal groups may never
5905     be called, so matched_char must remain false, hence the jump to
5906     GROUP_PROCESS rather than GROUP_PROCESS_NOTE_EMPTY. */
5907
5908     case META_COND_DEFINE:
5909     bravalue = OP_COND;
5910     GETPLUSOFFSET(offset, pptr);
5911     code[1+LINK_SIZE] = OP_DEFINE;
5912     skipunits = 1;
5913     goto GROUP_PROCESS;
5914
5915     /* Conditional test of a group's being set. */
5916
5917     case META_COND_NUMBER:
5918     bravalue = OP_COND;
5919     GETPLUSOFFSET(offset, pptr);
5920     groupnumber = *(++pptr);
5921     if (groupnumber > cb->bracount)
5922       {
5923       *errorcodeptr = ERR15;
5924       cb->erroroffset = offset;
5925       return 0;
5926       }
5927     if (groupnumber > cb->top_backref) cb->top_backref = groupnumber;
5928     offset -= 2;   /* Point at initial ( for too many branches error */
5929     code[1+LINK_SIZE] = OP_CREF;
5930     skipunits = 1+IMM2_SIZE;
5931     PUT2(code, 2+LINK_SIZE, groupnumber);
5932     goto GROUP_PROCESS_NOTE_EMPTY;
5933
5934     /* Test for the PCRE2 version. */
5935
5936     case META_COND_VERSION:
5937     bravalue = OP_COND;
5938     if (pptr[1] > 0)
5939       code[1+LINK_SIZE] = ((PCRE2_MAJOR > pptr[2]) ||
5940         (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR >= pptr[3]))?
5941           OP_TRUE : OP_FALSE;
5942     else
5943       code[1+LINK_SIZE] = (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR == pptr[3])?
5944         OP_TRUE : OP_FALSE;
5945     skipunits = 1;
5946     pptr += 3;
5947     goto GROUP_PROCESS_NOTE_EMPTY;
5948
5949     /* The condition is an assertion, possibly preceded by a callout. */
5950
5951     case META_COND_ASSERT:
5952     bravalue = OP_COND;
5953     goto GROUP_PROCESS_NOTE_EMPTY;
5954
5955
5956     /* ===================================================================*/
5957     /* Handle all kinds of nested bracketed groups. The non-capturing,
5958     non-conditional cases are here; others come to GROUP_PROCESS via goto. */
5959
5960     case META_LOOKAHEAD:
5961     bravalue = OP_ASSERT;
5962     cb->assert_depth += 1;
5963     goto GROUP_PROCESS;
5964
5965     /* Optimize (?!) to (*FAIL) unless it is quantified - which is a weird
5966     thing to do, but Perl allows all assertions to be quantified, and when
5967     they contain capturing parentheses there may be a potential use for
5968     this feature. Not that that applies to a quantified (?!) but we allow
5969     it for uniformity. */
5970
5971     case META_LOOKAHEADNOT:
5972     if (pptr[1] == META_KET &&
5973          (pptr[2] < META_ASTERISK || pptr[2] > META_MINMAX_QUERY))
5974       {
5975       *code++ = OP_FAIL;
5976       pptr++;
5977       }
5978     else
5979       {
5980       bravalue = OP_ASSERT_NOT;
5981       cb->assert_depth += 1;
5982       goto GROUP_PROCESS;
5983       }
5984     break;
5985
5986     case META_LOOKBEHIND:
5987     bravalue = OP_ASSERTBACK;
5988     cb->assert_depth += 1;
5989     goto GROUP_PROCESS;
5990
5991     case META_LOOKBEHINDNOT:
5992     bravalue = OP_ASSERTBACK_NOT;
5993     cb->assert_depth += 1;
5994     goto GROUP_PROCESS;
5995
5996     case META_ATOMIC:
5997     bravalue = OP_ONCE;
5998     goto GROUP_PROCESS_NOTE_EMPTY;
5999
6000     case META_NOCAPTURE:
6001     bravalue = OP_BRA;
6002     /* Fall through */
6003
6004     /* Process nested bracketed regex. The nesting depth is maintained for the
6005     benefit of the stackguard function. The test for too deep nesting is now
6006     done in parse_regex(). Assertion and DEFINE groups come to GROUP_PROCESS;
6007     others come to GROUP_PROCESS_NOTE_EMPTY, to indicate that we need to take
6008     note of whether or not they may match an empty string. */
6009
6010     GROUP_PROCESS_NOTE_EMPTY:
6011     note_group_empty = TRUE;
6012
6013     GROUP_PROCESS:
6014     cb->parens_depth += 1;
6015     *code = bravalue;
6016     pptr++;
6017     tempcode = code;
6018     tempreqvary = cb->req_varyopt;        /* Save value before group */
6019     length_prevgroup = 0;                 /* Initialize for pre-compile phase */
6020
6021     if ((group_return =
6022          compile_regex(
6023          options,                         /* The option state */
6024          &tempcode,                       /* Where to put code (updated) */
6025          &pptr,                           /* Input pointer (updated) */
6026          errorcodeptr,                    /* Where to put an error message */
6027          skipunits,                       /* Skip over bracket number */
6028          &subfirstcu,                     /* For possible first char */
6029          &subfirstcuflags,
6030          &subreqcu,                       /* For possible last char */
6031          &subreqcuflags,
6032          bcptr,                           /* Current branch chain */
6033          cb,                              /* Compile data block */
6034          (lengthptr == NULL)? NULL :      /* Actual compile phase */
6035            &length_prevgroup              /* Pre-compile phase */
6036          )) == 0)
6037       return 0;  /* Error */
6038
6039     cb->parens_depth -= 1;
6040
6041     /* If that was a non-conditional significant group (not an assertion, not a
6042     DEFINE) that matches at least one character, then the current item matches
6043     a character. Conditionals are handled below. */
6044
6045     if (note_group_empty && bravalue != OP_COND && group_return > 0)
6046       matched_char = TRUE;
6047
6048     /* If we've just compiled an assertion, pop the assert depth. */
6049
6050     if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)
6051       cb->assert_depth -= 1;
6052
6053     /* At the end of compiling, code is still pointing to the start of the
6054     group, while tempcode has been updated to point past the end of the group.
6055     The parsed pattern pointer (pptr) is on the closing META_KET.
6056
6057     If this is a conditional bracket, check that there are no more than
6058     two branches in the group, or just one if it's a DEFINE group. We do this
6059     in the real compile phase, not in the pre-pass, where the whole group may
6060     not be available. */
6061
6062     if (bravalue == OP_COND && lengthptr == NULL)
6063       {
6064       PCRE2_UCHAR *tc = code;
6065       int condcount = 0;
6066
6067       do {
6068          condcount++;
6069          tc += GET(tc,1);
6070          }
6071       while (*tc != OP_KET);
6072
6073       /* A DEFINE group is never obeyed inline (the "condition" is always
6074       false). It must have only one branch. Having checked this, change the
6075       opcode to OP_FALSE. */
6076
6077       if (code[LINK_SIZE+1] == OP_DEFINE)
6078         {
6079         if (condcount > 1)
6080           {
6081           cb->erroroffset = offset;
6082           *errorcodeptr = ERR54;
6083           return 0;
6084           }
6085         code[LINK_SIZE+1] = OP_FALSE;
6086         bravalue = OP_DEFINE;   /* A flag to suppress char handling below */
6087         }
6088
6089       /* A "normal" conditional group. If there is just one branch, we must not
6090       make use of its firstcu or reqcu, because this is equivalent to an
6091       empty second branch. Also, it may match an empty string. If there are two
6092       branches, this item must match a character if the group must. */
6093
6094       else
6095         {
6096         if (condcount > 2)
6097           {
6098           cb->erroroffset = offset;
6099           *errorcodeptr = ERR27;
6100           return 0;
6101           }
6102         if (condcount == 1) subfirstcuflags = subreqcuflags = REQ_NONE;
6103           else if (group_return > 0) matched_char = TRUE;
6104         }
6105       }
6106
6107     /* In the pre-compile phase, update the length by the length of the group,
6108     less the brackets at either end. Then reduce the compiled code to just a
6109     set of non-capturing brackets so that it doesn't use much memory if it is
6110     duplicated by a quantifier.*/
6111
6112     if (lengthptr != NULL)
6113       {
6114       if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)
6115         {
6116         *errorcodeptr = ERR20;
6117         return 0;
6118         }
6119       *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;
6120       code++;   /* This already contains bravalue */
6121       PUTINC(code, 0, 1 + LINK_SIZE);
6122       *code++ = OP_KET;
6123       PUTINC(code, 0, 1 + LINK_SIZE);
6124       break;    /* No need to waste time with special character handling */
6125       }
6126
6127     /* Otherwise update the main code pointer to the end of the group. */
6128
6129     code = tempcode;
6130
6131     /* For a DEFINE group, required and first character settings are not
6132     relevant. */
6133
6134     if (bravalue == OP_DEFINE) break;
6135
6136     /* Handle updating of the required and first code units for other types of
6137     group. Update for normal brackets of all kinds, and conditions with two
6138     branches (see code above). If the bracket is followed by a quantifier with
6139     zero repeat, we have to back off. Hence the definition of zeroreqcu and
6140     zerofirstcu outside the main loop so that they can be accessed for the back
6141     off. */
6142
6143     zeroreqcu = reqcu;
6144     zeroreqcuflags = reqcuflags;
6145     zerofirstcu = firstcu;
6146     zerofirstcuflags = firstcuflags;
6147     groupsetfirstcu = FALSE;
6148
6149     if (bravalue >= OP_ONCE)  /* Not an assertion */
6150       {
6151       /* If we have not yet set a firstcu in this branch, take it from the
6152       subpattern, remembering that it was set here so that a repeat of more
6153       than one can replicate it as reqcu if necessary. If the subpattern has
6154       no firstcu, set "none" for the whole branch. In both cases, a zero
6155       repeat forces firstcu to "none". */
6156
6157       if (firstcuflags == REQ_UNSET && subfirstcuflags != REQ_UNSET)
6158         {
6159         if (subfirstcuflags >= 0)
6160           {
6161           firstcu = subfirstcu;
6162           firstcuflags = subfirstcuflags;
6163           groupsetfirstcu = TRUE;
6164           }
6165         else firstcuflags = REQ_NONE;
6166         zerofirstcuflags = REQ_NONE;
6167         }
6168
6169       /* If firstcu was previously set, convert the subpattern's firstcu
6170       into reqcu if there wasn't one, using the vary flag that was in
6171       existence beforehand. */
6172
6173       else if (subfirstcuflags >= 0 && subreqcuflags < 0)
6174         {
6175         subreqcu = subfirstcu;
6176         subreqcuflags = subfirstcuflags | tempreqvary;
6177         }
6178
6179       /* If the subpattern set a required code unit (or set a first code unit
6180       that isn't really the first code unit - see above), set it. */
6181
6182       if (subreqcuflags >= 0)
6183         {
6184         reqcu = subreqcu;
6185         reqcuflags = subreqcuflags;
6186         }
6187       }
6188
6189     /* For a forward assertion, we take the reqcu, if set, provided that the
6190     group has also set a firstcu. This can be helpful if the pattern that
6191     follows the assertion doesn't set a different char. For example, it's
6192     useful for /(?=abcde).+/. We can't set firstcu for an assertion, however
6193     because it leads to incorrect effect for patterns such as /(?=a)a.+/ when
6194     the "real" "a" would then become a reqcu instead of a firstcu. This is
6195     overcome by a scan at the end if there's no firstcu, looking for an
6196     asserted first char. A similar effect for patterns like /(?=.*X)X$/ means
6197     we must only take the reqcu when the group also set a firstcu. Otherwise,
6198     in that example, 'X' ends up set for both. */
6199
6200     else if (bravalue == OP_ASSERT && subreqcuflags >= 0 &&
6201              subfirstcuflags >= 0)
6202       {
6203       reqcu = subreqcu;
6204       reqcuflags = subreqcuflags;
6205       }
6206
6207     break;  /* End of nested group handling */
6208
6209
6210     /* ===================================================================*/
6211     /* Handle named backreferences and recursions. */
6212
6213     case META_BACKREF_BYNAME:
6214     case META_RECURSE_BYNAME:
6215       {
6216       int count, index;
6217       PCRE2_SPTR name;
6218       BOOL is_dupname = FALSE;
6219       named_group *ng = cb->named_groups;
6220       uint32_t length = *(++pptr);
6221
6222       GETPLUSOFFSET(offset, pptr);
6223       name = cb->start_pattern + offset;
6224
6225       /* In the first pass, the names generated in the pre-pass are available,
6226       but the main name table has not yet been created. Scan the list of names
6227       generated in the pre-pass in order to get a number and whether or not
6228       this name is duplicated. */
6229
6230       groupnumber = 0;
6231       for (i = 0; i < cb->names_found; i++, ng++)
6232         {
6233         if (length == ng->length &&
6234             PRIV(strncmp)(name, ng->name, length) == 0)
6235           {
6236           is_dupname = ng->isdup;
6237           groupnumber = ng->number;
6238
6239           /* For a recursion, that's all that is needed. We can now go to
6240           the code above that handles numerical recursion, applying it to
6241           the first group with the given name. */
6242
6243           if (meta == META_RECURSE_BYNAME)
6244             {
6245             meta_arg = groupnumber;
6246             goto HANDLE_NUMERICAL_RECURSION;
6247             }
6248
6249           /* For a back reference, update the back reference map and the
6250           maximum back reference. Then, for each group, we must check to
6251           see if it is recursive, that is, it is inside the group that it
6252           references. A flag is set so that the group can be made atomic.
6253           */
6254
6255           cb->backref_map |= (groupnumber < 32)? (1u << groupnumber) : 1;
6256           if (groupnumber > cb->top_backref)
6257             cb->top_backref = groupnumber;
6258
6259           for (oc = cb->open_caps; oc != NULL; oc = oc->next)
6260             {
6261             if (oc->number == groupnumber)
6262               {
6263               oc->flag = TRUE;
6264               break;
6265               }
6266             }
6267           }
6268         }
6269
6270       /* If the name was not found we have a bad reference. */
6271
6272       if (groupnumber == 0)
6273         {
6274         *errorcodeptr = ERR15;
6275         cb->erroroffset = offset;
6276         return 0;
6277         }
6278
6279       /* If a back reference name is not duplicated, we can handle it as
6280       a numerical reference. */
6281
6282       if (!is_dupname)
6283         {
6284         meta_arg = groupnumber;
6285         goto HANDLE_SINGLE_REFERENCE;
6286         }
6287
6288       /* If a back reference name is duplicated, we generate a different
6289       opcode to a numerical back reference. In the second pass we must
6290       search for the index and count in the final name table. */
6291
6292       count = 0;  /* Values for first pass (avoids compiler warning) */
6293       index = 0;
6294       if (lengthptr == NULL && !find_dupname_details(name, length, &index,
6295             &count, errorcodeptr, cb)) return 0;
6296
6297       if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
6298       *code++ = ((options & PCRE2_CASELESS) != 0)? OP_DNREFI : OP_DNREF;
6299       PUT2INC(code, 0, index);
6300       PUT2INC(code, 0, count);
6301       }
6302     break;
6303
6304
6305     /* ===================================================================*/
6306     /* Handle a numerical callout. */
6307
6308     case META_CALLOUT_NUMBER:
6309     code[0] = OP_CALLOUT;
6310     PUT(code, 1, pptr[1]);               /* Offset to next pattern item */
6311     PUT(code, 1 + LINK_SIZE, pptr[2]);   /* Length of next pattern item */
6312     code[1 + 2*LINK_SIZE] = pptr[3];
6313     pptr += 3;
6314     code += PRIV(OP_lengths)[OP_CALLOUT];
6315     break;
6316
6317
6318     /* ===================================================================*/
6319     /* Handle a callout with a string argument. In the pre-pass we just compute
6320     the length without generating anything. The length in pptr[3] includes both
6321     delimiters; in the actual compile only the first one is copied, but a
6322     terminating zero is added. Any doubled delimiters within the string make
6323     this an overestimate, but it is not worth bothering about. */
6324
6325     case META_CALLOUT_STRING:
6326     if (lengthptr != NULL)
6327       {
6328       *lengthptr += pptr[3] + (1 + 4*LINK_SIZE);
6329       pptr += 3;
6330       SKIPOFFSET(pptr);
6331       }
6332
6333     /* In the real compile we can copy the string. The starting delimiter is
6334      included so that the client can discover it if they want. We also pass the
6335      start offset to help a script language give better error messages. */
6336
6337     else
6338       {
6339       PCRE2_SPTR pp;
6340       uint32_t delimiter;
6341       uint32_t length = pptr[3];
6342       PCRE2_UCHAR *callout_string = code + (1 + 4*LINK_SIZE);
6343
6344       code[0] = OP_CALLOUT_STR;
6345       PUT(code, 1, pptr[1]);               /* Offset to next pattern item */
6346       PUT(code, 1 + LINK_SIZE, pptr[2]);   /* Length of next pattern item */
6347
6348       pptr += 3;
6349       GETPLUSOFFSET(offset, pptr);         /* Offset to string in pattern */
6350       pp = cb->start_pattern + offset;
6351       delimiter = *callout_string++ = *pp++;
6352       if (delimiter == CHAR_LEFT_CURLY_BRACKET)
6353         delimiter = CHAR_RIGHT_CURLY_BRACKET;
6354       PUT(code, 1 + 3*LINK_SIZE, (int)(offset + 1));  /* One after delimiter */
6355
6356       /* The syntax of the pattern was checked in the parsing scan. The length
6357       includes both delimiters, but we have passed the opening one just above,
6358       so we reduce length before testing it. The test is for > 1 because we do
6359       not want to copy the final delimiter. This also ensures that pp[1] is
6360       accessible. */
6361
6362       while (--length > 1)
6363         {
6364         if (*pp == delimiter && pp[1] == delimiter)
6365           {
6366           *callout_string++ = delimiter;
6367           pp += 2;
6368           length--;
6369           }
6370         else *callout_string++ = *pp++;
6371         }
6372       *callout_string++ = CHAR_NUL;
6373
6374       /* Set the length of the entire item, the advance to its end. */
6375
6376       PUT(code, 1 + 2*LINK_SIZE, (int)(callout_string - code));
6377       code = callout_string;
6378       }
6379     break;
6380
6381
6382     /* ===================================================================*/
6383     /* Handle repetition. The different types are all sorted out in the parsing
6384     pass. */
6385
6386     case META_MINMAX_PLUS:
6387     case META_MINMAX_QUERY:
6388     case META_MINMAX:
6389     repeat_min = *(++pptr);
6390     repeat_max = *(++pptr);
6391     goto REPEAT;
6392
6393     case META_ASTERISK:
6394     case META_ASTERISK_PLUS:
6395     case META_ASTERISK_QUERY:
6396     repeat_min = 0;
6397     repeat_max = REPEAT_UNLIMITED;
6398     goto REPEAT;
6399
6400     case META_PLUS:
6401     case META_PLUS_PLUS:
6402     case META_PLUS_QUERY:
6403     repeat_min = 1;
6404     repeat_max = REPEAT_UNLIMITED;
6405     goto REPEAT;
6406
6407     case META_QUERY:
6408     case META_QUERY_PLUS:
6409     case META_QUERY_QUERY:
6410     repeat_min = 0;
6411     repeat_max = 1;
6412
6413     REPEAT:
6414     if (previous_matched_char && repeat_min > 0) matched_char = TRUE;
6415
6416     /* Remember whether this is a variable length repeat, and default to
6417     single-char opcodes. */
6418
6419     reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;
6420     op_type = 0;
6421
6422     /* If the repeat is {1} we can ignore it. */
6423
6424     if (repeat_max == 1 && repeat_min == 1) goto END_REPEAT;
6425
6426     /* Adjust first and required code units for a zero repeat. */
6427
6428     if (repeat_min == 0)
6429       {
6430       firstcu = zerofirstcu;
6431       firstcuflags = zerofirstcuflags;
6432       reqcu = zeroreqcu;
6433       reqcuflags = zeroreqcuflags;
6434       }
6435
6436     /* Note the greediness and possessiveness. */
6437
6438     switch (meta)
6439       {
6440       case META_MINMAX_PLUS:
6441       case META_ASTERISK_PLUS:
6442       case META_PLUS_PLUS:
6443       case META_QUERY_PLUS:
6444       repeat_type = 0;                  /* Force greedy */
6445       possessive_quantifier = TRUE;
6446       break;
6447
6448       case META_MINMAX_QUERY:
6449       case META_ASTERISK_QUERY:
6450       case META_PLUS_QUERY:
6451       case META_QUERY_QUERY:
6452       repeat_type = greedy_non_default;
6453       possessive_quantifier = FALSE;
6454       break;
6455
6456       default:
6457       repeat_type = greedy_default;
6458       possessive_quantifier = FALSE;
6459       break;
6460       }
6461
6462     /* Save start of previous item, in case we have to move it up in order to
6463     insert something before it, and remember what it was. */
6464
6465     tempcode = previous;
6466     op_previous = *previous;
6467
6468     /* Now handle repetition for the different types of item. */
6469
6470     switch (op_previous)
6471       {
6472       /* If previous was a character or negated character match, abolish the
6473       item and generate a repeat item instead. If a char item has a minimum of
6474       more than one, ensure that it is set in reqcu - it might not be if a
6475       sequence such as x{3} is the first thing in a branch because the x will
6476       have gone into firstcu instead.  */
6477
6478       case OP_CHAR:
6479       case OP_CHARI:
6480       case OP_NOT:
6481       case OP_NOTI:
6482       op_type = chartypeoffset[op_previous - OP_CHAR];
6483
6484       /* Deal with UTF characters that take up more than one code unit. */
6485
6486 #ifdef MAYBE_UTF_MULTI
6487       if (utf && NOT_FIRSTCU(code[-1]))
6488         {
6489         PCRE2_UCHAR *lastchar = code - 1;
6490         BACKCHAR(lastchar);
6491         mclength = (uint32_t)(code - lastchar);   /* Length of UTF character */
6492         memcpy(mcbuffer, lastchar, CU2BYTES(mclength));  /* Save the char */
6493         }
6494       else
6495 #endif  /* MAYBE_UTF_MULTI */
6496
6497       /* Handle the case of a single code unit - either with no UTF support, or
6498       with UTF disabled, or for a single-code-unit UTF character. */
6499         {
6500         mcbuffer[0] = code[-1];
6501         mclength = 1;
6502         if (op_previous <= OP_CHARI && repeat_min > 1)
6503           {
6504           reqcu = mcbuffer[0];
6505           reqcuflags = req_caseopt | cb->req_varyopt;
6506           }
6507         }
6508       goto OUTPUT_SINGLE_REPEAT;  /* Code shared with single character types */
6509
6510       /* If previous was a character class or a back reference, we put the
6511       repeat stuff after it, but just skip the item if the repeat was {0,0}. */
6512
6513 #ifdef SUPPORT_WIDE_CHARS
6514       case OP_XCLASS:
6515 #endif
6516       case OP_CLASS:
6517       case OP_NCLASS:
6518       case OP_REF:
6519       case OP_REFI:
6520       case OP_DNREF:
6521       case OP_DNREFI:
6522
6523       if (repeat_max == 0)
6524         {
6525         code = previous;
6526         goto END_REPEAT;
6527         }
6528
6529       if (repeat_min == 0 && repeat_max == REPEAT_UNLIMITED)
6530         *code++ = OP_CRSTAR + repeat_type;
6531       else if (repeat_min == 1 && repeat_max == REPEAT_UNLIMITED)
6532         *code++ = OP_CRPLUS + repeat_type;
6533       else if (repeat_min == 0 && repeat_max == 1)
6534         *code++ = OP_CRQUERY + repeat_type;
6535       else
6536         {
6537         *code++ = OP_CRRANGE + repeat_type;
6538         PUT2INC(code, 0, repeat_min);
6539         if (repeat_max == REPEAT_UNLIMITED) repeat_max = 0;  /* 2-byte encoding for max */
6540         PUT2INC(code, 0, repeat_max);
6541         }
6542       break;
6543
6544       /* If previous is OP_FAIL, it was generated by an empty class []
6545       (PCRE2_ALLOW_EMPTY_CLASS is set). The other ways in which OP_FAIL can be
6546       generated, that is by (*FAIL) or (?!), disallow a quantifier at parse
6547       time. We can just ignore this repeat. */
6548
6549       case OP_FAIL:
6550       goto END_REPEAT;
6551
6552       /* Prior to 10.30, repeated recursions were wrapped in OP_ONCE brackets
6553       because pcre2_match() could not handle backtracking into recursively
6554       called groups. Now that this backtracking is available, we no longer need
6555       to do this. However, we still need to replicate recursions as we do for
6556       groups so as to have independent backtracking points. We can replicate
6557       for the minimum number of repeats directly. For optional repeats we now
6558       wrap the recursion in OP_BRA brackets and make use of the bracket
6559       repetition. */
6560
6561       case OP_RECURSE:
6562
6563       /* Generate unwrapped repeats for a non-zero minimum, except when the
6564       minimum is 1 and the maximum unlimited, because that can be handled with
6565       OP_BRA terminated by OP_KETRMAX/MIN. When the maximum is equal to the
6566       minimum, we just need to generate the appropriate additional copies.
6567       Otherwise we need to generate one more, to simulate the situation when
6568       the minimum is zero. */
6569
6570       if (repeat_min > 0 && (repeat_min != 1 || repeat_max != REPEAT_UNLIMITED))
6571         {
6572         int replicate = repeat_min;
6573         if (repeat_min == repeat_max) replicate--;
6574
6575         /* In the pre-compile phase, we don't actually do the replication. We
6576         just adjust the length as if we had. Do some paranoid checks for
6577         potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit
6578         integer type when available, otherwise double. */
6579
6580         if (lengthptr != NULL)
6581           {
6582           PCRE2_SIZE delta = replicate*(1 + LINK_SIZE);
6583           if ((INT64_OR_DOUBLE)replicate*
6584                 (INT64_OR_DOUBLE)(1 + LINK_SIZE) >
6585                   (INT64_OR_DOUBLE)INT_MAX ||
6586               OFLOW_MAX - *lengthptr < delta)
6587             {
6588             *errorcodeptr = ERR20;
6589             return 0;
6590             }
6591           *lengthptr += delta;
6592           }
6593
6594         else for (i = 0; i < replicate; i++)
6595           {
6596           memcpy(code, previous, CU2BYTES(1 + LINK_SIZE));
6597           previous = code;
6598           code += 1 + LINK_SIZE;
6599           }
6600
6601         /* If the number of repeats is fixed, we are done. Otherwise, adjust
6602         the counts and fall through. */
6603
6604         if (repeat_min == repeat_max) break;
6605         if (repeat_max != REPEAT_UNLIMITED) repeat_max -= repeat_min;
6606         repeat_min = 0;
6607         }
6608
6609       /* Wrap the recursion call in OP_BRA brackets. */
6610
6611       (void)memmove(previous + 1 + LINK_SIZE, previous, CU2BYTES(1 + LINK_SIZE));
6612       op_previous = *previous = OP_BRA;
6613       PUT(previous, 1, 2 + 2*LINK_SIZE);
6614       previous[2 + 2*LINK_SIZE] = OP_KET;
6615       PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);
6616       code += 2 + 2 * LINK_SIZE;
6617       length_prevgroup = 3 + 3*LINK_SIZE;
6618       group_return = -1;  /* Set "may match empty string" */
6619
6620       /* Now treat as a repeated OP_BRA. */
6621       /* Fall through */
6622
6623       /* If previous was a bracket group, we may have to replicate it in
6624       certain cases. Note that at this point we can encounter only the "basic"
6625       bracket opcodes such as BRA and CBRA, as this is the place where they get
6626       converted into the more special varieties such as BRAPOS and SBRA.
6627       Originally, PCRE did not allow repetition of assertions, but now it does,
6628       for Perl compatibility. */
6629
6630       case OP_ASSERT:
6631       case OP_ASSERT_NOT:
6632       case OP_ASSERTBACK:
6633       case OP_ASSERTBACK_NOT:
6634       case OP_ONCE:
6635       case OP_BRA:
6636       case OP_CBRA:
6637       case OP_COND:
6638         {
6639         int len = (int)(code - previous);
6640         PCRE2_UCHAR *bralink = NULL;
6641         PCRE2_UCHAR *brazeroptr = NULL;
6642
6643         /* Repeating a DEFINE group (or any group where the condition is always
6644         FALSE and there is only one branch) is pointless, but Perl allows the
6645         syntax, so we just ignore the repeat. */
6646
6647         if (op_previous == OP_COND && previous[LINK_SIZE+1] == OP_FALSE &&
6648             previous[GET(previous, 1)] != OP_ALT)
6649           goto END_REPEAT;
6650
6651         /* There is no sense in actually repeating assertions. The only
6652         potential use of repetition is in cases when the assertion is optional.
6653         Therefore, if the minimum is greater than zero, just ignore the repeat.
6654         If the maximum is not zero or one, set it to 1. */
6655
6656         if (op_previous < OP_ONCE)    /* Assertion */
6657           {
6658           if (repeat_min > 0) goto END_REPEAT;
6659           if (repeat_max > 1) repeat_max = 1;
6660           }
6661
6662         /* The case of a zero minimum is special because of the need to stick
6663         OP_BRAZERO in front of it, and because the group appears once in the
6664         data, whereas in other cases it appears the minimum number of times. For
6665         this reason, it is simplest to treat this case separately, as otherwise
6666         the code gets far too messy. There are several special subcases when the
6667         minimum is zero. */
6668
6669         if (repeat_min == 0)
6670           {
6671           /* If the maximum is also zero, we used to just omit the group from
6672           the output altogether, like this:
6673
6674           ** if (repeat_max == 0)
6675           **   {
6676           **   code = previous;
6677           **   goto END_REPEAT;
6678           **   }
6679
6680           However, that fails when a group or a subgroup within it is
6681           referenced as a subroutine from elsewhere in the pattern, so now we
6682           stick in OP_SKIPZERO in front of it so that it is skipped on
6683           execution. As we don't have a list of which groups are referenced, we
6684           cannot do this selectively.
6685
6686           If the maximum is 1 or unlimited, we just have to stick in the
6687           BRAZERO and do no more at this point. */
6688
6689           if (repeat_max <= 1 || repeat_max == REPEAT_UNLIMITED)
6690             {
6691             (void)memmove(previous + 1, previous, CU2BYTES(len));
6692             code++;
6693             if (repeat_max == 0)
6694               {
6695               *previous++ = OP_SKIPZERO;
6696               goto END_REPEAT;
6697               }
6698             brazeroptr = previous;    /* Save for possessive optimizing */
6699             *previous++ = OP_BRAZERO + repeat_type;
6700             }
6701
6702           /* If the maximum is greater than 1 and limited, we have to replicate
6703           in a nested fashion, sticking OP_BRAZERO before each set of brackets.
6704           The first one has to be handled carefully because it's the original
6705           copy, which has to be moved up. The remainder can be handled by code
6706           that is common with the non-zero minimum case below. We have to
6707           adjust the value or repeat_max, since one less copy is required. */
6708
6709           else
6710             {
6711             int linkoffset;
6712             (void)memmove(previous + 2 + LINK_SIZE, previous, CU2BYTES(len));
6713             code += 2 + LINK_SIZE;
6714             *previous++ = OP_BRAZERO + repeat_type;
6715             *previous++ = OP_BRA;
6716
6717             /* We chain together the bracket link offset fields that have to be
6718             filled in later when the ends of the brackets are reached. */
6719
6720             linkoffset = (bralink == NULL)? 0 : (int)(previous - bralink);
6721             bralink = previous;
6722             PUTINC(previous, 0, linkoffset);
6723             }
6724
6725           if (repeat_max != REPEAT_UNLIMITED) repeat_max--;
6726           }
6727
6728         /* If the minimum is greater than zero, replicate the group as many
6729         times as necessary, and adjust the maximum to the number of subsequent
6730         copies that we need. */
6731
6732         else
6733           {
6734           if (repeat_min > 1)
6735             {
6736             /* In the pre-compile phase, we don't actually do the replication.
6737             We just adjust the length as if we had. Do some paranoid checks for
6738             potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit
6739             integer type when available, otherwise double. */
6740
6741             if (lengthptr != NULL)
6742               {
6743               PCRE2_SIZE delta = (repeat_min - 1)*length_prevgroup;
6744               if ((INT64_OR_DOUBLE)(repeat_min - 1)*
6745                     (INT64_OR_DOUBLE)length_prevgroup >
6746                       (INT64_OR_DOUBLE)INT_MAX ||
6747                   OFLOW_MAX - *lengthptr < delta)
6748                 {
6749                 *errorcodeptr = ERR20;
6750                 return 0;
6751                 }
6752               *lengthptr += delta;
6753               }
6754
6755             /* This is compiling for real. If there is a set first code unit
6756             for the group, and we have not yet set a "required code unit", set
6757             it. */
6758
6759             else
6760               {
6761               if (groupsetfirstcu && reqcuflags < 0)
6762                 {
6763                 reqcu = firstcu;
6764                 reqcuflags = firstcuflags;
6765                 }
6766               for (i = 1; (uint32_t)i < repeat_min; i++)
6767                 {
6768                 memcpy(code, previous, CU2BYTES(len));
6769                 code += len;
6770                 }
6771               }
6772             }
6773
6774           if (repeat_max != REPEAT_UNLIMITED) repeat_max -= repeat_min;
6775           }
6776
6777         /* This code is common to both the zero and non-zero minimum cases. If
6778         the maximum is limited, it replicates the group in a nested fashion,
6779         remembering the bracket starts on a stack. In the case of a zero
6780         minimum, the first one was set up above. In all cases the repeat_max
6781         now specifies the number of additional copies needed. Again, we must
6782         remember to replicate entries on the forward reference list. */
6783
6784         if (repeat_max != REPEAT_UNLIMITED)
6785           {
6786           /* In the pre-compile phase, we don't actually do the replication. We
6787           just adjust the length as if we had. For each repetition we must add
6788           1 to the length for BRAZERO and for all but the last repetition we
6789           must add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
6790           paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type
6791           is a 64-bit integer type when available, otherwise double. */
6792
6793           if (lengthptr != NULL && repeat_max > 0)
6794             {
6795             PCRE2_SIZE delta = repeat_max*(length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
6796                         2 - 2*LINK_SIZE;   /* Last one doesn't nest */
6797             if ((INT64_OR_DOUBLE)repeat_max *
6798                   (INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
6799                     > (INT64_OR_DOUBLE)INT_MAX ||
6800                 OFLOW_MAX - *lengthptr < delta)
6801               {
6802               *errorcodeptr = ERR20;
6803               return 0;
6804               }
6805             *lengthptr += delta;
6806             }
6807
6808           /* This is compiling for real */
6809
6810           else for (i = repeat_max - 1; i >= 0; i--)
6811             {
6812             *code++ = OP_BRAZERO + repeat_type;
6813
6814             /* All but the final copy start a new nesting, maintaining the
6815             chain of brackets outstanding. */
6816
6817             if (i != 0)
6818               {
6819               int linkoffset;
6820               *code++ = OP_BRA;
6821               linkoffset = (bralink == NULL)? 0 : (int)(code - bralink);
6822               bralink = code;
6823               PUTINC(code, 0, linkoffset);
6824               }
6825
6826             memcpy(code, previous, CU2BYTES(len));
6827             code += len;
6828             }
6829
6830           /* Now chain through the pending brackets, and fill in their length
6831           fields (which are holding the chain links pro tem). */
6832
6833           while (bralink != NULL)
6834             {
6835             int oldlinkoffset;
6836             int linkoffset = (int)(code - bralink + 1);
6837             PCRE2_UCHAR *bra = code - linkoffset;
6838             oldlinkoffset = GET(bra, 1);
6839             bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
6840             *code++ = OP_KET;
6841             PUTINC(code, 0, linkoffset);
6842             PUT(bra, 1, linkoffset);
6843             }
6844           }
6845
6846         /* If the maximum is unlimited, set a repeater in the final copy. For
6847         ONCE brackets, that's all we need to do. However, possessively repeated
6848         ONCE brackets can be converted into non-capturing brackets, as the
6849         behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
6850         deal with possessive ONCEs specially.
6851
6852         Otherwise, when we are doing the actual compile phase, check to see
6853         whether this group is one that could match an empty string. If so,
6854         convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
6855         that runtime checking can be done. [This check is also applied to ONCE
6856         groups at runtime, but in a different way.]
6857
6858         Then, if the quantifier was possessive and the bracket is not a
6859         conditional, we convert the BRA code to the POS form, and the KET code to
6860         KETRPOS. (It turns out to be convenient at runtime to detect this kind of
6861         subpattern at both the start and at the end.) The use of special opcodes
6862         makes it possible to reduce greatly the stack usage in pcre2_match(). If
6863         the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO.
6864
6865         Then, if the minimum number of matches is 1 or 0, cancel the possessive
6866         flag so that the default action below, of wrapping everything inside
6867         atomic brackets, does not happen. When the minimum is greater than 1,
6868         there will be earlier copies of the group, and so we still have to wrap
6869         the whole thing. */
6870
6871         else
6872           {
6873           PCRE2_UCHAR *ketcode = code - 1 - LINK_SIZE;
6874           PCRE2_UCHAR *bracode = ketcode - GET(ketcode, 1);
6875
6876           /* Convert possessive ONCE brackets to non-capturing */
6877
6878           if (*bracode == OP_ONCE && possessive_quantifier) *bracode = OP_BRA;
6879
6880           /* For non-possessive ONCE brackets, all we need to do is to
6881           set the KET. */
6882
6883           if (*bracode == OP_ONCE) *ketcode = OP_KETRMAX + repeat_type;
6884
6885           /* Handle non-ONCE brackets and possessive ONCEs (which have been
6886           converted to non-capturing above). */
6887
6888           else
6889             {
6890             /* In the compile phase, adjust the opcode if the group can match
6891             an empty string. For a conditional group with only one branch, the
6892             value of group_return will not show "could be empty", so we must
6893             check that separately. */
6894
6895             if (lengthptr == NULL)
6896               {
6897               if (group_return < 0) *bracode += OP_SBRA - OP_BRA;
6898               if (*bracode == OP_COND && bracode[GET(bracode,1)] != OP_ALT)
6899                 *bracode = OP_SCOND;
6900               }
6901
6902             /* Handle possessive quantifiers. */
6903
6904             if (possessive_quantifier)
6905               {
6906               /* For COND brackets, we wrap the whole thing in a possessively
6907               repeated non-capturing bracket, because we have not invented POS
6908               versions of the COND opcodes. */
6909
6910               if (*bracode == OP_COND || *bracode == OP_SCOND)
6911                 {
6912                 int nlen = (int)(code - bracode);
6913                 (void)memmove(bracode + 1 + LINK_SIZE, bracode, CU2BYTES(nlen));
6914                 code += 1 + LINK_SIZE;
6915                 nlen += 1 + LINK_SIZE;
6916                 *bracode = (*bracode == OP_COND)? OP_BRAPOS : OP_SBRAPOS;
6917                 *code++ = OP_KETRPOS;
6918                 PUTINC(code, 0, nlen);
6919                 PUT(bracode, 1, nlen);
6920                 }
6921
6922               /* For non-COND brackets, we modify the BRA code and use KETRPOS. */
6923
6924               else
6925                 {
6926                 *bracode += 1;              /* Switch to xxxPOS opcodes */
6927                 *ketcode = OP_KETRPOS;
6928                 }
6929
6930               /* If the minimum is zero, mark it as possessive, then unset the
6931               possessive flag when the minimum is 0 or 1. */
6932
6933               if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;
6934               if (repeat_min < 2) possessive_quantifier = FALSE;
6935               }
6936
6937             /* Non-possessive quantifier */
6938
6939             else *ketcode = OP_KETRMAX + repeat_type;
6940             }
6941           }
6942         }
6943       break;
6944
6945       /* If previous was a character type match (\d or similar), abolish it and
6946       create a suitable repeat item. The code is shared with single-character
6947       repeats by setting op_type to add a suitable offset into repeat_type.
6948       Note the the Unicode property types will be present only when
6949       SUPPORT_UNICODE is defined, but we don't wrap the little bits of code
6950       here because it just makes it horribly messy. */
6951
6952       default:
6953       if (op_previous >= OP_EODN)   /* Not a character type - internal error */
6954         {
6955         *errorcodeptr = ERR10;
6956         return 0;
6957         }
6958       else
6959         {
6960         int prop_type, prop_value;
6961         PCRE2_UCHAR *oldcode;
6962
6963         op_type = OP_TYPESTAR - OP_STAR;      /* Use type opcodes */
6964         mclength = 0;                         /* Not a character */
6965
6966         if (op_previous == OP_PROP || op_previous == OP_NOTPROP)
6967           {
6968           prop_type = previous[1];
6969           prop_value = previous[2];
6970           }
6971         else
6972           {
6973           /* Come here from just above with a character in mcbuffer/mclength. */
6974           OUTPUT_SINGLE_REPEAT:
6975           prop_type = prop_value = -1;
6976           }
6977
6978         /* At this point, if prop_type == prop_value == -1 we either have a
6979         character in mcbuffer when mclength is greater than zero, or we have
6980         mclength zero, in which case there is a non-property character type in
6981         op_previous. If prop_type/value are not negative, we have a property
6982         character type in op_previous. */
6983
6984         oldcode = code;                   /* Save where we were */
6985         code = previous;                  /* Usually overwrite previous item */
6986
6987         /* If the maximum is zero then the minimum must also be zero; Perl allows
6988         this case, so we do too - by simply omitting the item altogether. */
6989
6990         if (repeat_max == 0) goto END_REPEAT;
6991
6992         /* Combine the op_type with the repeat_type */
6993
6994         repeat_type += op_type;
6995
6996         /* A minimum of zero is handled either as the special case * or ?, or as
6997         an UPTO, with the maximum given. */
6998
6999         if (repeat_min == 0)
7000           {
7001           if (repeat_max == REPEAT_UNLIMITED) *code++ = OP_STAR + repeat_type;
7002             else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
7003           else
7004             {
7005             *code++ = OP_UPTO + repeat_type;
7006             PUT2INC(code, 0, repeat_max);
7007             }
7008           }
7009
7010         /* A repeat minimum of 1 is optimized into some special cases. If the
7011         maximum is unlimited, we use OP_PLUS. Otherwise, the original item is
7012         left in place and, if the maximum is greater than 1, we use OP_UPTO with
7013         one less than the maximum. */
7014
7015         else if (repeat_min == 1)
7016           {
7017           if (repeat_max == REPEAT_UNLIMITED)
7018             *code++ = OP_PLUS + repeat_type;
7019           else
7020             {
7021             code = oldcode;  /* Leave previous item in place */
7022             if (repeat_max == 1) goto END_REPEAT;
7023             *code++ = OP_UPTO + repeat_type;
7024             PUT2INC(code, 0, repeat_max - 1);
7025             }
7026           }
7027
7028         /* The case {n,n} is just an EXACT, while the general case {n,m} is
7029         handled as an EXACT followed by an UPTO or STAR or QUERY. */
7030
7031         else
7032           {
7033           *code++ = OP_EXACT + op_type;  /* NB EXACT doesn't have repeat_type */
7034           PUT2INC(code, 0, repeat_min);
7035
7036           /* Unless repeat_max equals repeat_min, fill in the data for EXACT,
7037           and then generate the second opcode. For a repeated Unicode property
7038           match, there are two extra values that define the required property,
7039           and mclength is set zero to indicate this. */
7040
7041           if (repeat_max != repeat_min)
7042             {
7043             if (mclength > 0)
7044               {
7045               memcpy(code, mcbuffer, CU2BYTES(mclength));
7046               code += mclength;
7047               }
7048             else
7049               {
7050               *code++ = op_previous;
7051               if (prop_type >= 0)
7052                 {
7053                 *code++ = prop_type;
7054                 *code++ = prop_value;
7055                 }
7056               }
7057
7058             /* Now set up the following opcode */
7059
7060             if (repeat_max == REPEAT_UNLIMITED)
7061               *code++ = OP_STAR + repeat_type;
7062             else
7063               {
7064               repeat_max -= repeat_min;
7065               if (repeat_max == 1)
7066                 {
7067                 *code++ = OP_QUERY + repeat_type;
7068                 }
7069               else
7070                 {
7071                 *code++ = OP_UPTO + repeat_type;
7072                 PUT2INC(code, 0, repeat_max);
7073                 }
7074               }
7075             }
7076           }
7077
7078         /* Fill in the character or character type for the final opcode. */
7079
7080         if (mclength > 0)
7081           {
7082           memcpy(code, mcbuffer, CU2BYTES(mclength));
7083           code += mclength;
7084           }
7085         else
7086           {
7087           *code++ = op_previous;
7088           if (prop_type >= 0)
7089             {
7090             *code++ = prop_type;
7091             *code++ = prop_value;
7092             }
7093           }
7094         }
7095       break;
7096       }  /* End of switch on different op_previous values */
7097
7098
7099     /* If the character following a repeat is '+', possessive_quantifier is
7100     TRUE. For some opcodes, there are special alternative opcodes for this
7101     case. For anything else, we wrap the entire repeated item inside OP_ONCE
7102     brackets. Logically, the '+' notation is just syntactic sugar, taken from
7103     Sun's Java package, but the special opcodes can optimize it.
7104
7105     Some (but not all) possessively repeated subpatterns have already been
7106     completely handled in the code just above. For them, possessive_quantifier
7107     is always FALSE at this stage. Note that the repeated item starts at
7108     tempcode, not at previous, which might be the first part of a string whose
7109     (former) last char we repeated. */
7110
7111     if (possessive_quantifier)
7112       {
7113       int len;
7114
7115       /* Possessifying an EXACT quantifier has no effect, so we can ignore it.
7116       However, QUERY, STAR, or UPTO may follow (for quantifiers such as {5,6},
7117       {5,}, or {5,10}). We skip over an EXACT item; if the length of what
7118       remains is greater than zero, there's a further opcode that can be
7119       handled. If not, do nothing, leaving the EXACT alone. */
7120
7121       switch(*tempcode)
7122         {
7123         case OP_TYPEEXACT:
7124         tempcode += PRIV(OP_lengths)[*tempcode] +
7125           ((tempcode[1 + IMM2_SIZE] == OP_PROP
7126           || tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);
7127         break;
7128
7129         /* CHAR opcodes are used for exacts whose count is 1. */
7130
7131         case OP_CHAR:
7132         case OP_CHARI:
7133         case OP_NOT:
7134         case OP_NOTI:
7135         case OP_EXACT:
7136         case OP_EXACTI:
7137         case OP_NOTEXACT:
7138         case OP_NOTEXACTI:
7139         tempcode += PRIV(OP_lengths)[*tempcode];
7140 #ifdef SUPPORT_UNICODE
7141         if (utf && HAS_EXTRALEN(tempcode[-1]))
7142           tempcode += GET_EXTRALEN(tempcode[-1]);
7143 #endif
7144         break;
7145
7146         /* For the class opcodes, the repeat operator appears at the end;
7147         adjust tempcode to point to it. */
7148
7149         case OP_CLASS:
7150         case OP_NCLASS:
7151         tempcode += 1 + 32/sizeof(PCRE2_UCHAR);
7152         break;
7153
7154 #ifdef SUPPORT_WIDE_CHARS
7155         case OP_XCLASS:
7156         tempcode += GET(tempcode, 1);
7157         break;
7158 #endif
7159         }
7160
7161       /* If tempcode is equal to code (which points to the end of the repeated
7162       item), it means we have skipped an EXACT item but there is no following
7163       QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In
7164       all other cases, tempcode will be pointing to the repeat opcode, and will
7165       be less than code, so the value of len will be greater than 0. */
7166
7167       len = (int)(code - tempcode);
7168       if (len > 0)
7169         {
7170         unsigned int repcode = *tempcode;
7171
7172         /* There is a table for possessifying opcodes, all of which are less
7173         than OP_CALLOUT. A zero entry means there is no possessified version.
7174         */
7175
7176         if (repcode < OP_CALLOUT && opcode_possessify[repcode] > 0)
7177           *tempcode = opcode_possessify[repcode];
7178
7179         /* For opcode without a special possessified version, wrap the item in
7180         ONCE brackets. */
7181
7182         else
7183           {
7184           (void)memmove(tempcode + 1 + LINK_SIZE, tempcode, CU2BYTES(len));
7185           code += 1 + LINK_SIZE;
7186           len += 1 + LINK_SIZE;
7187           tempcode[0] = OP_ONCE;
7188           *code++ = OP_KET;
7189           PUTINC(code, 0, len);
7190           PUT(tempcode, 1, len);
7191           }
7192         }
7193       }
7194
7195     /* We set the "follows varying string" flag for subsequently encountered
7196     reqcus if it isn't already set and we have just passed a varying length
7197     item. */
7198
7199     END_REPEAT:
7200     cb->req_varyopt |= reqvary;
7201     break;
7202
7203
7204     /* ===================================================================*/
7205     /* Handle a 32-bit data character with a value greater than META_END. */
7206
7207     case META_BIGVALUE:
7208     pptr++;
7209     goto NORMAL_CHAR;
7210
7211
7212     /* ===============================================================*/
7213     /* Handle a back reference by number, which is the meta argument. The
7214     pattern offsets for back references to group numbers less than 10 are held
7215     in a special vector, to avoid using more than two parsed pattern elements
7216     in 64-bit environments. We only need the offset to the first occurrence,
7217     because if that doesn't fail, subsequent ones will also be OK. */
7218
7219     case META_BACKREF:
7220     if (meta_arg < 10) offset = cb->small_ref_offset[meta_arg];
7221       else GETPLUSOFFSET(offset, pptr);
7222
7223     if (meta_arg > cb->bracount)
7224       {
7225       cb->erroroffset = offset;
7226       *errorcodeptr = ERR15;  /* Non-existent subpattern */
7227       return 0;
7228       }
7229
7230     /* Come here from named backref handling when the reference is to a
7231     single group (that is, not to a duplicated name). The back reference
7232     data will have already been updated. We must disable firstcu if not
7233     set, to cope with cases like (?=(\w+))\1: which would otherwise set ':'
7234     later. */
7235
7236     HANDLE_SINGLE_REFERENCE:
7237     if (firstcuflags == REQ_UNSET) zerofirstcuflags = firstcuflags = REQ_NONE;
7238     *code++ = ((options & PCRE2_CASELESS) != 0)? OP_REFI : OP_REF;
7239     PUT2INC(code, 0, meta_arg);
7240
7241     /* Update the map of back references, and keep the highest one. We
7242     could do this in parse_regex() for numerical back references, but not
7243     for named back references, because we don't know the numbers to which
7244     named back references refer. So we do it all in this function. */
7245
7246     cb->backref_map |= (meta_arg < 32)? (1u << meta_arg) : 1;
7247     if (meta_arg > cb->top_backref) cb->top_backref = meta_arg;
7248
7249     /* Check to see if this back reference is recursive, that it, it
7250     is inside the group that it references. A flag is set so that the
7251     group can be made atomic. */
7252
7253     for (oc = cb->open_caps; oc != NULL; oc = oc->next)
7254       {
7255       if (oc->number == meta_arg)
7256         {
7257         oc->flag = TRUE;
7258         break;
7259         }
7260       }
7261     break;
7262
7263
7264     /* ===============================================================*/
7265     /* Handle recursion by inserting the number of the called group (which is
7266     the meta argument) after OP_RECURSE. At the end of compiling the pattern is
7267     scanned and these numbers are replaced by offsets within the pattern. It is
7268     done like this to avoid problems with forward references and adjusting
7269     offsets when groups are duplicated and moved (as discovered in previous
7270     implementations). Note that a recursion does not have a set first character
7271     (relevant if it is repeated, because it will then be wrapped with ONCE
7272     brackets). */
7273
7274     case META_RECURSE:
7275     GETPLUSOFFSET(offset, pptr);
7276     if (meta_arg > cb->bracount)
7277       {
7278       cb->erroroffset = offset;
7279       *errorcodeptr = ERR15;  /* Non-existent subpattern */
7280       return 0;
7281       }
7282     HANDLE_NUMERICAL_RECURSION:
7283     *code = OP_RECURSE;
7284     PUT(code, 1, meta_arg);
7285     code += 1 + LINK_SIZE;
7286     groupsetfirstcu = FALSE;
7287     cb->had_recurse = TRUE;
7288     if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
7289     break;
7290
7291
7292     /* ===============================================================*/
7293     /* Handle capturing parentheses; the number is the meta argument. */
7294
7295     case META_CAPTURE:
7296     bravalue = OP_CBRA;
7297     skipunits = IMM2_SIZE;
7298     PUT2(code, 1+LINK_SIZE, meta_arg);
7299     cb->lastcapture = meta_arg;
7300     goto GROUP_PROCESS_NOTE_EMPTY;
7301
7302
7303     /* ===============================================================*/
7304     /* Handle escape sequence items. For ones like \d, the ESC_values are
7305     arranged to be the same as the corresponding OP_values in the default case
7306     when PCRE2_UCP is not set (which is the only case in which they will appear
7307     here).
7308
7309     Note: \Q and \E are never seen here, as they were dealt with in
7310     parse_pattern(). Neither are numerical back references or recursions, which
7311     were turned into META_BACKREF or META_RECURSE items, respectively. \k and
7312     \g, when followed by names, are turned into META_BACKREF_BYNAME or
7313     META_RECURSE_BYNAME. */
7314
7315     case META_ESCAPE:
7316
7317     /* We can test for escape sequences that consume a character because their
7318     values lie between ESC_b and ESC_Z; this may have to change if any new ones
7319     are ever created. For these sequences, we disable the setting of a first
7320     character if it hasn't already been set. */
7321
7322     if (meta_arg > ESC_b && meta_arg < ESC_Z)
7323       {
7324       matched_char = TRUE;
7325       if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
7326       }
7327
7328     /* Set values to reset to if this is followed by a zero repeat. */
7329
7330     zerofirstcu = firstcu;
7331     zerofirstcuflags = firstcuflags;
7332     zeroreqcu = reqcu;
7333     zeroreqcuflags = reqcuflags;
7334
7335     /* If Unicode is not supported, \P and \p are not allowed and are
7336     faulted at parse time, so will never appear here. */
7337
7338 #ifdef SUPPORT_UNICODE
7339     if (meta_arg == ESC_P || meta_arg == ESC_p)
7340       {
7341       uint32_t ptype = *(++pptr) >> 16;
7342       uint32_t pdata = *pptr & 0xffff;
7343       *code++ = (meta_arg == ESC_p)? OP_PROP : OP_NOTPROP;
7344       *code++ = ptype;
7345       *code++ = pdata;
7346       break;  /* End META_ESCAPE */
7347       }
7348 #endif
7349
7350     /* For the rest (including \X when Unicode is supported - if not it's
7351     faulted at parse time), the OP value is the escape value when PCRE2_UCP is
7352     not set; if it is set, these escapes do not show up here because they are
7353     converted into Unicode property tests in parse_regex(). Note that \b and \B
7354     do a one-character lookbehind, and \A also behaves as if it does. */
7355
7356     if (meta_arg == ESC_C) cb->external_flags |= PCRE2_HASBKC; /* Record */
7357     if ((meta_arg == ESC_b || meta_arg == ESC_B || meta_arg == ESC_A) &&
7358          cb->max_lookbehind == 0)
7359       cb->max_lookbehind = 1;
7360
7361     /* In non-UTF mode, and for both 32-bit modes, we turn \C into OP_ALLANY
7362     instead of OP_ANYBYTE so that it works in DFA mode and in lookbehinds. */
7363
7364 #if PCRE2_CODE_UNIT_WIDTH == 32
7365     *code++ = (meta_arg == ESC_C)? OP_ALLANY : meta_arg;
7366 #else
7367     *code++ = (!utf && meta_arg == ESC_C)? OP_ALLANY : meta_arg;
7368 #endif
7369     break;  /* End META_ESCAPE */
7370
7371
7372     /* ===================================================================*/
7373     /* Handle an unrecognized meta value. A parsed pattern value less than
7374     META_END is a literal. Otherwise we have a problem. */
7375
7376     default:
7377     if (meta >= META_END)
7378       {
7379 #ifdef DEBUG_SHOW_PARSED
7380       fprintf(stderr, "** Unrecognized parsed pattern item 0x%.8x\n", *pptr);
7381 #endif
7382       *errorcodeptr = ERR89;  /* Internal error - unrecognized. */
7383       return 0;
7384       }
7385
7386     /* Handle a literal character. We come here by goto in the case of a
7387     32-bit, non-UTF character whose value is greater than META_END. */
7388
7389     NORMAL_CHAR:
7390     meta = *pptr;     /* Get the full 32 bits */
7391     NORMAL_CHAR_SET:  /* Character is already in meta */
7392     matched_char = TRUE;
7393
7394     /* For caseless UTF mode, check whether this character has more than one
7395     other case. If so, generate a special OP_PROP item instead of OP_CHARI. */
7396
7397 #ifdef SUPPORT_UNICODE
7398     if (utf && (options & PCRE2_CASELESS) != 0)
7399       {
7400       uint32_t caseset = UCD_CASESET(meta);
7401       if (caseset != 0)
7402         {
7403         *code++ = OP_PROP;
7404         *code++ = PT_CLIST;
7405         *code++ = caseset;
7406         if (firstcuflags == REQ_UNSET)
7407           firstcuflags = zerofirstcuflags = REQ_NONE;
7408         break;  /* End handling this meta item */
7409         }
7410       }
7411 #endif
7412
7413     /* Caseful matches, or not one of the multicase characters. Get the
7414     character's code units into mcbuffer, with the length in mclength. When not
7415     in UTF mode, the length is always 1. */
7416
7417 #ifdef SUPPORT_UNICODE
7418     if (utf) mclength = PRIV(ord2utf)(meta, mcbuffer); else
7419 #endif
7420       {
7421       mclength = 1;
7422       mcbuffer[0] = meta;
7423       }
7424
7425     /* Generate the appropriate code */
7426
7427     *code++ = ((options & PCRE2_CASELESS) != 0)? OP_CHARI : OP_CHAR;
7428     memcpy(code, mcbuffer, CU2BYTES(mclength));
7429     code += mclength;
7430
7431     /* Remember if \r or \n were seen */
7432
7433     if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)
7434       cb->external_flags |= PCRE2_HASCRORLF;
7435
7436     /* Set the first and required code units appropriately. If no previous
7437     first code unit, set it from this character, but revert to none on a zero
7438     repeat. Otherwise, leave the firstcu value alone, and don't change it on
7439     a zero repeat. */
7440
7441     if (firstcuflags == REQ_UNSET)
7442       {
7443       zerofirstcuflags = REQ_NONE;
7444       zeroreqcu = reqcu;
7445       zeroreqcuflags = reqcuflags;
7446
7447       /* If the character is more than one code unit long, we can set firstcu
7448       only if it is not to be matched caselessly. */
7449
7450       if (mclength == 1 || req_caseopt == 0)
7451         {
7452         firstcu = mcbuffer[0];
7453         firstcuflags = req_caseopt;
7454         if (mclength != 1)
7455           {
7456           reqcu = code[-1];
7457           reqcuflags = cb->req_varyopt;
7458           }
7459         }
7460       else firstcuflags = reqcuflags = REQ_NONE;
7461       }
7462
7463     /* firstcu was previously set; we can set reqcu only if the length is
7464     1 or the matching is caseful. */
7465
7466     else
7467       {
7468       zerofirstcu = firstcu;
7469       zerofirstcuflags = firstcuflags;
7470       zeroreqcu = reqcu;
7471       zeroreqcuflags = reqcuflags;
7472       if (mclength == 1 || req_caseopt == 0)
7473         {
7474         reqcu = code[-1];
7475         reqcuflags = req_caseopt | cb->req_varyopt;
7476         }
7477       }
7478     break;    /* End default meta handling */
7479     }         /* End of big switch */
7480   }           /* End of big loop */
7481
7482 /* Control never reaches here. */
7483 }
7484
7485
7486
7487 /*************************************************
7488 *   Compile regex: a sequence of alternatives    *
7489 *************************************************/
7490
7491 /* On entry, pptr is pointing past the bracket meta, but on return it points to
7492 the closing bracket or META_END. The code variable is pointing at the code unit
7493 into which the BRA operator has been stored. This function is used during the
7494 pre-compile phase when we are trying to find out the amount of memory needed,
7495 as well as during the real compile phase. The value of lengthptr distinguishes
7496 the two phases.
7497
7498 Arguments:
7499   options           option bits, including any changes for this subpattern
7500   codeptr           -> the address of the current code pointer
7501   pptrptr           -> the address of the current parsed pattern pointer
7502   errorcodeptr      -> pointer to error code variable
7503   skipunits         skip this many code units at start (for brackets and OP_COND)
7504   firstcuptr        place to put the first required code unit
7505   firstcuflagsptr   place to put the first code unit flags, or a negative number
7506   reqcuptr          place to put the last required code unit
7507   reqcuflagsptr     place to put the last required code unit flags, or a negative number
7508   bcptr             pointer to the chain of currently open branches
7509   cb                points to the data block with tables pointers etc.
7510   lengthptr         NULL during the real compile phase
7511                     points to length accumulator during pre-compile phase
7512
7513 Returns:            0 There has been an error
7514                    +1 Success, this group must match at least one character
7515                    -1 Success, this group may match an empty string
7516 */
7517
7518 static int
7519 compile_regex(uint32_t options, PCRE2_UCHAR **codeptr, uint32_t **pptrptr,
7520   int *errorcodeptr, uint32_t skipunits, uint32_t *firstcuptr,
7521   int32_t *firstcuflagsptr, uint32_t *reqcuptr,int32_t *reqcuflagsptr,
7522   branch_chain *bcptr, compile_block *cb, PCRE2_SIZE *lengthptr)
7523 {
7524 PCRE2_UCHAR *code = *codeptr;
7525 PCRE2_UCHAR *last_branch = code;
7526 PCRE2_UCHAR *start_bracket = code;
7527 BOOL lookbehind;
7528 open_capitem capitem;
7529 int capnumber = 0;
7530 int okreturn = 1;
7531 uint32_t *pptr = *pptrptr;
7532 uint32_t firstcu, reqcu;
7533 uint32_t lookbehindlength;
7534 int32_t firstcuflags, reqcuflags;
7535 uint32_t branchfirstcu, branchreqcu;
7536 int32_t branchfirstcuflags, branchreqcuflags;
7537 PCRE2_SIZE length;
7538 branch_chain bc;
7539
7540 /* If set, call the external function that checks for stack availability. */
7541
7542 if (cb->cx->stack_guard != NULL &&
7543     cb->cx->stack_guard(cb->parens_depth, cb->cx->stack_guard_data))
7544   {
7545   *errorcodeptr= ERR33;
7546   return 0;
7547   }
7548
7549 /* Miscellaneous initialization */
7550
7551 bc.outer = bcptr;
7552 bc.current_branch = code;
7553
7554 firstcu = reqcu = 0;
7555 firstcuflags = reqcuflags = REQ_UNSET;
7556
7557 /* Accumulate the length for use in the pre-compile phase. Start with the
7558 length of the BRA and KET and any extra code units that are required at the
7559 beginning. We accumulate in a local variable to save frequent testing of
7560 lengthptr for NULL. We cannot do this by looking at the value of 'code' at the
7561 start and end of each alternative, because compiled items are discarded during
7562 the pre-compile phase so that the workspace is not exceeded. */
7563
7564 length = 2 + 2*LINK_SIZE + skipunits;
7565
7566 /* Remember if this is a lookbehind assertion, and if it is, save its length
7567 and skip over the pattern offset. */
7568
7569 lookbehind = *code == OP_ASSERTBACK || *code == OP_ASSERTBACK_NOT;
7570 if (lookbehind)
7571   {
7572   lookbehindlength = META_DATA(pptr[-1]);
7573   pptr += SIZEOFFSET;
7574   }
7575 else lookbehindlength = 0;
7576
7577 /* If this is a capturing subpattern, add to the chain of open capturing items
7578 so that we can detect them if (*ACCEPT) is encountered. Note that only OP_CBRA
7579 need be tested here; changing this opcode to one of its variants, e.g.
7580 OP_SCBRAPOS, happens later, after the group has been compiled. */
7581
7582 if (*code == OP_CBRA)
7583   {
7584   capnumber = GET2(code, 1 + LINK_SIZE);
7585   capitem.number = capnumber;
7586   capitem.next = cb->open_caps;
7587   capitem.flag = FALSE;
7588   capitem.assert_depth = cb->assert_depth;
7589   cb->open_caps = &capitem;
7590   }
7591
7592 /* Offset is set zero to mark that this bracket is still open */
7593
7594 PUT(code, 1, 0);
7595 code += 1 + LINK_SIZE + skipunits;
7596
7597 /* Loop for each alternative branch */
7598
7599 for (;;)
7600   {
7601   int branch_return;
7602
7603   /* Insert OP_REVERSE if this is as lookbehind assertion. */
7604
7605   if (lookbehind && lookbehindlength > 0)
7606     {
7607     *code++ = OP_REVERSE;
7608     PUTINC(code, 0, lookbehindlength);
7609     length += 1 + LINK_SIZE;
7610     }
7611
7612   /* Now compile the branch; in the pre-compile phase its length gets added
7613   into the length. */
7614
7615   if ((branch_return =
7616         compile_branch(&options, &code, &pptr, errorcodeptr, &branchfirstcu,
7617           &branchfirstcuflags, &branchreqcu, &branchreqcuflags, &bc,
7618           cb, (lengthptr == NULL)? NULL : &length)) == 0)
7619     return 0;
7620
7621   /* If a branch can match an empty string, so can the whole group. */
7622
7623   if (branch_return < 0) okreturn = -1;
7624
7625   /* In the real compile phase, there is some post-processing to be done. */
7626
7627   if (lengthptr == NULL)
7628     {
7629     /* If this is the first branch, the firstcu and reqcu values for the
7630     branch become the values for the regex. */
7631
7632     if (*last_branch != OP_ALT)
7633       {
7634       firstcu = branchfirstcu;
7635       firstcuflags = branchfirstcuflags;
7636       reqcu = branchreqcu;
7637       reqcuflags = branchreqcuflags;
7638       }
7639
7640     /* If this is not the first branch, the first char and reqcu have to
7641     match the values from all the previous branches, except that if the
7642     previous value for reqcu didn't have REQ_VARY set, it can still match,
7643     and we set REQ_VARY for the regex. */
7644
7645     else
7646       {
7647       /* If we previously had a firstcu, but it doesn't match the new branch,
7648       we have to abandon the firstcu for the regex, but if there was
7649       previously no reqcu, it takes on the value of the old firstcu. */
7650
7651       if (firstcuflags != branchfirstcuflags || firstcu != branchfirstcu)
7652         {
7653         if (firstcuflags >= 0)
7654           {
7655           if (reqcuflags < 0)
7656             {
7657             reqcu = firstcu;
7658             reqcuflags = firstcuflags;
7659             }
7660           }
7661         firstcuflags = REQ_NONE;
7662         }
7663
7664       /* If we (now or from before) have no firstcu, a firstcu from the
7665       branch becomes a reqcu if there isn't a branch reqcu. */
7666
7667       if (firstcuflags < 0 && branchfirstcuflags >= 0 &&
7668           branchreqcuflags < 0)
7669         {
7670         branchreqcu = branchfirstcu;
7671         branchreqcuflags = branchfirstcuflags;
7672         }
7673
7674       /* Now ensure that the reqcus match */
7675
7676       if (((reqcuflags & ~REQ_VARY) != (branchreqcuflags & ~REQ_VARY)) ||
7677           reqcu != branchreqcu)
7678         reqcuflags = REQ_NONE;
7679       else
7680         {
7681         reqcu = branchreqcu;
7682         reqcuflags |= branchreqcuflags; /* To "or" REQ_VARY */
7683         }
7684       }
7685     }
7686
7687   /* Handle reaching the end of the expression, either ')' or end of pattern.
7688   In the real compile phase, go back through the alternative branches and
7689   reverse the chain of offsets, with the field in the BRA item now becoming an
7690   offset to the first alternative. If there are no alternatives, it points to
7691   the end of the group. The length in the terminating ket is always the length
7692   of the whole bracketed item. Return leaving the pointer at the terminating
7693   char. */
7694
7695   if (META_CODE(*pptr) != META_ALT)
7696     {
7697     if (lengthptr == NULL)
7698       {
7699       PCRE2_SIZE branch_length = code - last_branch;
7700       do
7701         {
7702         PCRE2_SIZE prev_length = GET(last_branch, 1);
7703         PUT(last_branch, 1, branch_length);
7704         branch_length = prev_length;
7705         last_branch -= branch_length;
7706         }
7707       while (branch_length > 0);
7708       }
7709
7710     /* Fill in the ket */
7711
7712     *code = OP_KET;
7713     PUT(code, 1, (int)(code - start_bracket));
7714     code += 1 + LINK_SIZE;
7715
7716     /* If it was a capturing subpattern, check to see if it contained any
7717     recursive back references. If so, we must wrap it in atomic brackets. In
7718     any event, remove the block from the chain. */
7719
7720     if (capnumber > 0)
7721       {
7722       if (cb->open_caps->flag)
7723         {
7724         (void)memmove(start_bracket + 1 + LINK_SIZE, start_bracket,
7725           CU2BYTES(code - start_bracket));
7726         *start_bracket = OP_ONCE;
7727         code += 1 + LINK_SIZE;
7728         PUT(start_bracket, 1, (int)(code - start_bracket));
7729         *code = OP_KET;
7730         PUT(code, 1, (int)(code - start_bracket));
7731         code += 1 + LINK_SIZE;
7732         length += 2 + 2*LINK_SIZE;
7733         }
7734       cb->open_caps = cb->open_caps->next;
7735       }
7736
7737     /* Set values to pass back */
7738
7739     *codeptr = code;
7740     *pptrptr = pptr;
7741     *firstcuptr = firstcu;
7742     *firstcuflagsptr = firstcuflags;
7743     *reqcuptr = reqcu;
7744     *reqcuflagsptr = reqcuflags;
7745     if (lengthptr != NULL)
7746       {
7747       if (OFLOW_MAX - *lengthptr < length)
7748         {
7749         *errorcodeptr = ERR20;
7750         return 0;
7751         }
7752       *lengthptr += length;
7753       }
7754     return okreturn;
7755     }
7756
7757   /* Another branch follows. In the pre-compile phase, we can move the code
7758   pointer back to where it was for the start of the first branch. (That is,
7759   pretend that each branch is the only one.)
7760
7761   In the real compile phase, insert an ALT node. Its length field points back
7762   to the previous branch while the bracket remains open. At the end the chain
7763   is reversed. It's done like this so that the start of the bracket has a
7764   zero offset until it is closed, making it possible to detect recursion. */
7765
7766   if (lengthptr != NULL)
7767     {
7768     code = *codeptr + 1 + LINK_SIZE + skipunits;
7769     length += 1 + LINK_SIZE;
7770     }
7771   else
7772     {
7773     *code = OP_ALT;
7774     PUT(code, 1, (int)(code - last_branch));
7775     bc.current_branch = last_branch = code;
7776     code += 1 + LINK_SIZE;
7777     }
7778
7779   /* Set the lookbehind length (if not in a lookbehind the value will be zero)
7780   and then advance past the vertical bar. */
7781
7782   lookbehindlength = META_DATA(*pptr);
7783   pptr++;
7784   }
7785 /* Control never reaches here */
7786 }
7787
7788
7789
7790 /*************************************************
7791 *          Check for anchored pattern            *
7792 *************************************************/
7793
7794 /* Try to find out if this is an anchored regular expression. Consider each
7795 alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
7796 all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
7797 it's anchored. However, if this is a multiline pattern, then only OP_SOD will
7798 be found, because ^ generates OP_CIRCM in that mode.
7799
7800 We can also consider a regex to be anchored if OP_SOM starts all its branches.
7801 This is the code for \G, which means "match at start of match position, taking
7802 into account the match offset".
7803
7804 A branch is also implicitly anchored if it starts with .* and DOTALL is set,
7805 because that will try the rest of the pattern at all possible matching points,
7806 so there is no point trying again.... er ....
7807
7808 .... except when the .* appears inside capturing parentheses, and there is a
7809 subsequent back reference to those parentheses. We haven't enough information
7810 to catch that case precisely.
7811
7812 At first, the best we could do was to detect when .* was in capturing brackets
7813 and the highest back reference was greater than or equal to that level.
7814 However, by keeping a bitmap of the first 31 back references, we can catch some
7815 of the more common cases more precisely.
7816
7817 ... A second exception is when the .* appears inside an atomic group, because
7818 this prevents the number of characters it matches from being adjusted.
7819
7820 Arguments:
7821   code           points to start of the compiled pattern
7822   bracket_map    a bitmap of which brackets we are inside while testing; this
7823                    handles up to substring 31; after that we just have to take
7824                    the less precise approach
7825   cb             points to the compile data block
7826   atomcount      atomic group level
7827   inassert       TRUE if in an assertion
7828
7829 Returns:     TRUE or FALSE
7830 */
7831
7832 static BOOL
7833 is_anchored(PCRE2_SPTR code, unsigned int bracket_map, compile_block *cb,
7834   int atomcount, BOOL inassert)
7835 {
7836 do {
7837    PCRE2_SPTR scode = first_significant_code(
7838      code + PRIV(OP_lengths)[*code], FALSE);
7839    int op = *scode;
7840
7841    /* Non-capturing brackets */
7842
7843    if (op == OP_BRA  || op == OP_BRAPOS ||
7844        op == OP_SBRA || op == OP_SBRAPOS)
7845      {
7846      if (!is_anchored(scode, bracket_map, cb, atomcount, inassert))
7847        return FALSE;
7848      }
7849
7850    /* Capturing brackets */
7851
7852    else if (op == OP_CBRA  || op == OP_CBRAPOS ||
7853             op == OP_SCBRA || op == OP_SCBRAPOS)
7854      {
7855      int n = GET2(scode, 1+LINK_SIZE);
7856      int new_map = bracket_map | ((n < 32)? (1u << n) : 1);
7857      if (!is_anchored(scode, new_map, cb, atomcount, inassert)) return FALSE;
7858      }
7859
7860    /* Positive forward assertion */
7861
7862    else if (op == OP_ASSERT)
7863      {
7864      if (!is_anchored(scode, bracket_map, cb, atomcount, TRUE)) return FALSE;
7865      }
7866
7867    /* Condition. If there is no second branch, it can't be anchored. */
7868
7869    else if (op == OP_COND || op == OP_SCOND)
7870      {
7871      if (scode[GET(scode,1)] != OP_ALT) return FALSE;
7872      if (!is_anchored(scode, bracket_map, cb, atomcount, inassert))
7873        return FALSE;
7874      }
7875
7876    /* Atomic groups */
7877
7878    else if (op == OP_ONCE)
7879      {
7880      if (!is_anchored(scode, bracket_map, cb, atomcount + 1, inassert))
7881        return FALSE;
7882      }
7883
7884    /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and
7885    it isn't in brackets that are or may be referenced or inside an atomic
7886    group or an assertion. Also the pattern must not contain *PRUNE or *SKIP,
7887    because these break the feature. Consider, for example, /(?s).*?(*PRUNE)b/
7888    with the subject "aab", which matches "b", i.e. not at the start of a line.
7889    There is also an option that disables auto-anchoring. */
7890
7891    else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
7892              op == OP_TYPEPOSSTAR))
7893      {
7894      if (scode[1] != OP_ALLANY || (bracket_map & cb->backref_map) != 0 ||
7895          atomcount > 0 || cb->had_pruneorskip || inassert ||
7896          (cb->external_options & PCRE2_NO_DOTSTAR_ANCHOR) != 0)
7897        return FALSE;
7898      }
7899
7900    /* Check for explicit anchoring */
7901
7902    else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;
7903
7904    code += GET(code, 1);
7905    }
7906 while (*code == OP_ALT);   /* Loop for each alternative */
7907 return TRUE;
7908 }
7909
7910
7911
7912 /*************************************************
7913 *         Check for starting with ^ or .*        *
7914 *************************************************/
7915
7916 /* This is called to find out if every branch starts with ^ or .* so that
7917 "first char" processing can be done to speed things up in multiline
7918 matching and for non-DOTALL patterns that start with .* (which must start at
7919 the beginning or after \n). As in the case of is_anchored() (see above), we
7920 have to take account of back references to capturing brackets that contain .*
7921 because in that case we can't make the assumption. Also, the appearance of .*
7922 inside atomic brackets or in an assertion, or in a pattern that contains *PRUNE
7923 or *SKIP does not count, because once again the assumption no longer holds.
7924
7925 Arguments:
7926   code           points to start of the compiled pattern or a group
7927   bracket_map    a bitmap of which brackets we are inside while testing; this
7928                    handles up to substring 31; after that we just have to take
7929                    the less precise approach
7930   cb             points to the compile data
7931   atomcount      atomic group level
7932   inassert       TRUE if in an assertion
7933
7934 Returns:         TRUE or FALSE
7935 */
7936
7937 static BOOL
7938 is_startline(PCRE2_SPTR code, unsigned int bracket_map, compile_block *cb,
7939   int atomcount, BOOL inassert)
7940 {
7941 do {
7942    PCRE2_SPTR scode = first_significant_code(
7943      code + PRIV(OP_lengths)[*code], FALSE);
7944    int op = *scode;
7945
7946    /* If we are at the start of a conditional assertion group, *both* the
7947    conditional assertion *and* what follows the condition must satisfy the test
7948    for start of line. Other kinds of condition fail. Note that there may be an
7949    auto-callout at the start of a condition. */
7950
7951    if (op == OP_COND)
7952      {
7953      scode += 1 + LINK_SIZE;
7954
7955      if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];
7956        else if (*scode == OP_CALLOUT_STR) scode += GET(scode, 1 + 2*LINK_SIZE);
7957
7958      switch (*scode)
7959        {
7960        case OP_CREF:
7961        case OP_DNCREF:
7962        case OP_RREF:
7963        case OP_DNRREF:
7964        case OP_FAIL:
7965        case OP_FALSE:
7966        case OP_TRUE:
7967        return FALSE;
7968
7969        default:     /* Assertion */
7970        if (!is_startline(scode, bracket_map, cb, atomcount, TRUE)) return FALSE;
7971        do scode += GET(scode, 1); while (*scode == OP_ALT);
7972        scode += 1 + LINK_SIZE;
7973        break;
7974        }
7975      scode = first_significant_code(scode, FALSE);
7976      op = *scode;
7977      }
7978
7979    /* Non-capturing brackets */
7980
7981    if (op == OP_BRA  || op == OP_BRAPOS ||
7982        op == OP_SBRA || op == OP_SBRAPOS)
7983      {
7984      if (!is_startline(scode, bracket_map, cb, atomcount, inassert))
7985        return FALSE;
7986      }
7987
7988    /* Capturing brackets */
7989
7990    else if (op == OP_CBRA  || op == OP_CBRAPOS ||
7991             op == OP_SCBRA || op == OP_SCBRAPOS)
7992      {
7993      int n = GET2(scode, 1+LINK_SIZE);
7994      int new_map = bracket_map | ((n < 32)? (1u << n) : 1);
7995      if (!is_startline(scode, new_map, cb, atomcount, inassert)) return FALSE;
7996      }
7997
7998    /* Positive forward assertions */
7999
8000    else if (op == OP_ASSERT)
8001      {
8002      if (!is_startline(scode, bracket_map, cb, atomcount, TRUE))
8003        return FALSE;
8004      }
8005
8006    /* Atomic brackets */
8007
8008    else if (op == OP_ONCE)
8009      {
8010      if (!is_startline(scode, bracket_map, cb, atomcount + 1, inassert))
8011        return FALSE;
8012      }
8013
8014    /* .* means "start at start or after \n" if it isn't in atomic brackets or
8015    brackets that may be referenced or an assertion, and as long as the pattern
8016    does not contain *PRUNE or *SKIP, because these break the feature. Consider,
8017    for example, /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab",
8018    i.e. not at the start of a line. There is also an option that disables this
8019    optimization. */
8020
8021    else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)
8022      {
8023      if (scode[1] != OP_ANY || (bracket_map & cb->backref_map) != 0 ||
8024          atomcount > 0 || cb->had_pruneorskip || inassert ||
8025          (cb->external_options & PCRE2_NO_DOTSTAR_ANCHOR) != 0)
8026        return FALSE;
8027      }
8028
8029    /* Check for explicit circumflex; anything else gives a FALSE result. Note
8030    in particular that this includes atomic brackets OP_ONCE because the number
8031    of characters matched by .* cannot be adjusted inside them. */
8032
8033    else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;
8034
8035    /* Move on to the next alternative */
8036
8037    code += GET(code, 1);
8038    }
8039 while (*code == OP_ALT);  /* Loop for each alternative */
8040 return TRUE;
8041 }
8042
8043
8044
8045 /*************************************************
8046 *   Scan compiled regex for recursion reference  *
8047 *************************************************/
8048
8049 /* This function scans through a compiled pattern until it finds an instance of
8050 OP_RECURSE.
8051
8052 Arguments:
8053   code        points to start of expression
8054   utf         TRUE in UTF mode
8055
8056 Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
8057 */
8058
8059 static PCRE2_SPTR
8060 find_recurse(PCRE2_SPTR code, BOOL utf)
8061 {
8062 for (;;)
8063   {
8064   PCRE2_UCHAR c = *code;
8065   if (c == OP_END) return NULL;
8066   if (c == OP_RECURSE) return code;
8067
8068   /* XCLASS is used for classes that cannot be represented just by a bit map.
8069   This includes negated single high-valued characters. CALLOUT_STR is used for
8070   callouts with string arguments. In both cases the length in the table is
8071   zero; the actual length is stored in the compiled code. */
8072
8073   if (c == OP_XCLASS) code += GET(code, 1);
8074     else if (c == OP_CALLOUT_STR) code += GET(code, 1 + 2*LINK_SIZE);
8075
8076   /* Otherwise, we can get the item's length from the table, except that for
8077   repeated character types, we have to test for \p and \P, which have an extra
8078   two code units of parameters, and for MARK/PRUNE/SKIP/THEN with an argument,
8079   we must add in its length. */
8080
8081   else
8082     {
8083     switch(c)
8084       {
8085       case OP_TYPESTAR:
8086       case OP_TYPEMINSTAR:
8087       case OP_TYPEPLUS:
8088       case OP_TYPEMINPLUS:
8089       case OP_TYPEQUERY:
8090       case OP_TYPEMINQUERY:
8091       case OP_TYPEPOSSTAR:
8092       case OP_TYPEPOSPLUS:
8093       case OP_TYPEPOSQUERY:
8094       if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
8095       break;
8096
8097       case OP_TYPEPOSUPTO:
8098       case OP_TYPEUPTO:
8099       case OP_TYPEMINUPTO:
8100       case OP_TYPEEXACT:
8101       if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
8102         code += 2;
8103       break;
8104
8105       case OP_MARK:
8106       case OP_COMMIT_ARG:
8107       case OP_PRUNE_ARG:
8108       case OP_SKIP_ARG:
8109       case OP_THEN_ARG:
8110       code += code[1];
8111       break;
8112       }
8113
8114     /* Add in the fixed length from the table */
8115
8116     code += PRIV(OP_lengths)[c];
8117
8118     /* In UTF-8 and UTF-16 modes, opcodes that are followed by a character may
8119     be followed by a multi-unit character. The length in the table is a
8120     minimum, so we have to arrange to skip the extra units. */
8121
8122 #ifdef MAYBE_UTF_MULTI
8123     if (utf) switch(c)
8124       {
8125       case OP_CHAR:
8126       case OP_CHARI:
8127       case OP_NOT:
8128       case OP_NOTI:
8129       case OP_EXACT:
8130       case OP_EXACTI:
8131       case OP_NOTEXACT:
8132       case OP_NOTEXACTI:
8133       case OP_UPTO:
8134       case OP_UPTOI:
8135       case OP_NOTUPTO:
8136       case OP_NOTUPTOI:
8137       case OP_MINUPTO:
8138       case OP_MINUPTOI:
8139       case OP_NOTMINUPTO:
8140       case OP_NOTMINUPTOI:
8141       case OP_POSUPTO:
8142       case OP_POSUPTOI:
8143       case OP_NOTPOSUPTO:
8144       case OP_NOTPOSUPTOI:
8145       case OP_STAR:
8146       case OP_STARI:
8147       case OP_NOTSTAR:
8148       case OP_NOTSTARI:
8149       case OP_MINSTAR:
8150       case OP_MINSTARI:
8151       case OP_NOTMINSTAR:
8152       case OP_NOTMINSTARI:
8153       case OP_POSSTAR:
8154       case OP_POSSTARI:
8155       case OP_NOTPOSSTAR:
8156       case OP_NOTPOSSTARI:
8157       case OP_PLUS:
8158       case OP_PLUSI:
8159       case OP_NOTPLUS:
8160       case OP_NOTPLUSI:
8161       case OP_MINPLUS:
8162       case OP_MINPLUSI:
8163       case OP_NOTMINPLUS:
8164       case OP_NOTMINPLUSI:
8165       case OP_POSPLUS:
8166       case OP_POSPLUSI:
8167       case OP_NOTPOSPLUS:
8168       case OP_NOTPOSPLUSI:
8169       case OP_QUERY:
8170       case OP_QUERYI:
8171       case OP_NOTQUERY:
8172       case OP_NOTQUERYI:
8173       case OP_MINQUERY:
8174       case OP_MINQUERYI:
8175       case OP_NOTMINQUERY:
8176       case OP_NOTMINQUERYI:
8177       case OP_POSQUERY:
8178       case OP_POSQUERYI:
8179       case OP_NOTPOSQUERY:
8180       case OP_NOTPOSQUERYI:
8181       if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
8182       break;
8183       }
8184 #else
8185     (void)(utf);  /* Keep compiler happy by referencing function argument */
8186 #endif  /* MAYBE_UTF_MULTI */
8187     }
8188   }
8189 }
8190
8191
8192
8193 /*************************************************
8194 *    Check for asserted fixed first code unit    *
8195 *************************************************/
8196
8197 /* During compilation, the "first code unit" settings from forward assertions
8198 are discarded, because they can cause conflicts with actual literals that
8199 follow. However, if we end up without a first code unit setting for an
8200 unanchored pattern, it is worth scanning the regex to see if there is an
8201 initial asserted first code unit. If all branches start with the same asserted
8202 code unit, or with a non-conditional bracket all of whose alternatives start
8203 with the same asserted code unit (recurse ad lib), then we return that code
8204 unit, with the flags set to zero or REQ_CASELESS; otherwise return zero with
8205 REQ_NONE in the flags.
8206
8207 Arguments:
8208   code       points to start of compiled pattern
8209   flags      points to the first code unit flags
8210   inassert   non-zero if in an assertion
8211
8212 Returns:     the fixed first code unit, or 0 with REQ_NONE in flags
8213 */
8214
8215 static uint32_t
8216 find_firstassertedcu(PCRE2_SPTR code, int32_t *flags, uint32_t inassert)
8217 {
8218 uint32_t c = 0;
8219 int cflags = REQ_NONE;
8220
8221 *flags = REQ_NONE;
8222 do {
8223    uint32_t d;
8224    int dflags;
8225    int xl = (*code == OP_CBRA || *code == OP_SCBRA ||
8226              *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;
8227    PCRE2_SPTR scode = first_significant_code(code + 1+LINK_SIZE + xl, TRUE);
8228    PCRE2_UCHAR op = *scode;
8229
8230    switch(op)
8231      {
8232      default:
8233      return 0;
8234
8235      case OP_BRA:
8236      case OP_BRAPOS:
8237      case OP_CBRA:
8238      case OP_SCBRA:
8239      case OP_CBRAPOS:
8240      case OP_SCBRAPOS:
8241      case OP_ASSERT:
8242      case OP_ONCE:
8243      d = find_firstassertedcu(scode, &dflags, inassert + ((op==OP_ASSERT)?1:0));
8244      if (dflags < 0)
8245        return 0;
8246      if (cflags < 0) { c = d; cflags = dflags; }
8247        else if (c != d || cflags != dflags) return 0;
8248      break;
8249
8250      case OP_EXACT:
8251      scode += IMM2_SIZE;
8252      /* Fall through */
8253
8254      case OP_CHAR:
8255      case OP_PLUS:
8256      case OP_MINPLUS:
8257      case OP_POSPLUS:
8258      if (inassert == 0) return 0;
8259      if (cflags < 0) { c = scode[1]; cflags = 0; }
8260        else if (c != scode[1]) return 0;
8261      break;
8262
8263      case OP_EXACTI:
8264      scode += IMM2_SIZE;
8265      /* Fall through */
8266
8267      case OP_CHARI:
8268      case OP_PLUSI:
8269      case OP_MINPLUSI:
8270      case OP_POSPLUSI:
8271      if (inassert == 0) return 0;
8272      if (cflags < 0) { c = scode[1]; cflags = REQ_CASELESS; }
8273        else if (c != scode[1]) return 0;
8274      break;
8275      }
8276
8277    code += GET(code, 1);
8278    }
8279 while (*code == OP_ALT);
8280
8281 *flags = cflags;
8282 return c;
8283 }
8284
8285
8286
8287 /*************************************************
8288 *     Add an entry to the name/number table      *
8289 *************************************************/
8290
8291 /* This function is called between compiling passes to add an entry to the
8292 name/number table, maintaining alphabetical order. Checking for permitted
8293 and forbidden duplicates has already been done.
8294
8295 Arguments:
8296   cb           the compile data block
8297   name         the name to add
8298   length       the length of the name
8299   groupno      the group number
8300   tablecount   the count of names in the table so far
8301
8302 Returns:       nothing
8303 */
8304
8305 static void
8306 add_name_to_table(compile_block *cb, PCRE2_SPTR name, int length,
8307   unsigned int groupno, uint32_t tablecount)
8308 {
8309 uint32_t i;
8310 PCRE2_UCHAR *slot = cb->name_table;
8311
8312 for (i = 0; i < tablecount; i++)
8313   {
8314   int crc = memcmp(name, slot+IMM2_SIZE, CU2BYTES(length));
8315   if (crc == 0 && slot[IMM2_SIZE+length] != 0)
8316     crc = -1; /* Current name is a substring */
8317
8318   /* Make space in the table and break the loop for an earlier name. For a
8319   duplicate or later name, carry on. We do this for duplicates so that in the
8320   simple case (when ?(| is not used) they are in order of their numbers. In all
8321   cases they are in the order in which they appear in the pattern. */
8322
8323   if (crc < 0)
8324     {
8325     (void)memmove(slot + cb->name_entry_size, slot,
8326       CU2BYTES((tablecount - i) * cb->name_entry_size));
8327     break;
8328     }
8329
8330   /* Continue the loop for a later or duplicate name */
8331
8332   slot += cb->name_entry_size;
8333   }
8334
8335 PUT2(slot, 0, groupno);
8336 memcpy(slot + IMM2_SIZE, name, CU2BYTES(length));
8337
8338 /* Add a terminating zero and fill the rest of the slot with zeroes so that
8339 the memory is all initialized. Otherwise valgrind moans about uninitialized
8340 memory when saving serialized compiled patterns. */
8341
8342 memset(slot + IMM2_SIZE + length, 0,
8343   CU2BYTES(cb->name_entry_size - length - IMM2_SIZE));
8344 }
8345
8346
8347
8348 /*************************************************
8349 *             Skip in parsed pattern             *
8350 *************************************************/
8351
8352 /* This function is called to skip parts of the parsed pattern when finding the
8353 length of a lookbehind branch. It is called after (*ACCEPT) and (*FAIL) to find
8354 the end of the branch, it is called to skip over an internal lookaround, and it
8355 is also called to skip to the end of a class, during which it will never
8356 encounter nested groups (but there's no need to have special code for that).
8357
8358 When called to find the end of a branch or group, pptr must point to the first
8359 meta code inside the branch, not the branch-starting code. In other cases it
8360 can point to the item that causes the function to be called.
8361
8362 Arguments:
8363   pptr       current pointer to skip from
8364   skiptype   PSKIP_CLASS when skipping to end of class
8365              PSKIP_ALT when META_ALT ends the skip
8366              PSKIP_KET when only META_KET ends the skip
8367
8368 Returns:     new value of pptr
8369              NULL if META_END is reached - should never occur
8370                or for an unknown meta value - likewise
8371 */
8372
8373 static uint32_t *
8374 parsed_skip(uint32_t *pptr, uint32_t skiptype)
8375 {
8376 uint32_t nestlevel = 0;
8377
8378 for (;; pptr++)
8379   {
8380   uint32_t meta = META_CODE(*pptr);
8381
8382   switch(meta)
8383     {
8384     default:  /* Just skip over most items */
8385     if (meta < META_END) continue;  /* Literal */
8386     break;
8387
8388     /* This should never occur. */
8389
8390     case META_END:
8391     return NULL;
8392
8393     /* The data for these items is variable in length. */
8394
8395     case META_BACKREF:  /* Offset is present only if group >= 10 */
8396     if (META_DATA(*pptr) >= 10) pptr += SIZEOFFSET;
8397     break;
8398
8399     case META_ESCAPE:   /* A few escapes are followed by data items. */
8400     switch (META_DATA(*pptr))
8401       {
8402       case ESC_P:
8403       case ESC_p:
8404       pptr += 1;
8405       break;
8406
8407       case ESC_g:
8408       case ESC_k:
8409       pptr += 1 + SIZEOFFSET;
8410       break;
8411       }
8412     break;
8413
8414     case META_MARK:     /* Add the length of the name. */
8415     case META_COMMIT_ARG:
8416     case META_PRUNE_ARG:
8417     case META_SKIP_ARG:
8418     case META_THEN_ARG:
8419     pptr += pptr[1];
8420     break;
8421
8422     /* These are the "active" items in this loop. */
8423
8424     case META_CLASS_END:
8425     if (skiptype == PSKIP_CLASS) return pptr;
8426     break;
8427
8428     case META_ATOMIC:
8429     case META_CAPTURE:
8430     case META_COND_ASSERT:
8431     case META_COND_DEFINE:
8432     case META_COND_NAME:
8433     case META_COND_NUMBER:
8434     case META_COND_RNAME:
8435     case META_COND_RNUMBER:
8436     case META_COND_VERSION:
8437     case META_LOOKAHEAD:
8438     case META_LOOKAHEADNOT:
8439     case META_LOOKBEHIND:
8440     case META_LOOKBEHINDNOT:
8441     case META_NOCAPTURE:
8442     nestlevel++;
8443     break;
8444
8445     case META_ALT:
8446     if (nestlevel == 0 && skiptype == PSKIP_ALT) return pptr;
8447     break;
8448
8449     case META_KET:
8450     if (nestlevel == 0) return pptr;
8451     nestlevel--;
8452     break;
8453     }
8454
8455   /* The extra data item length for each meta is in a table. */
8456
8457   meta = (meta >> 16) & 0x7fff;
8458   if (meta >= sizeof(meta_extra_lengths)) return NULL;
8459   pptr += meta_extra_lengths[meta];
8460   }
8461 /* Control never reaches here */
8462 return pptr;
8463 }
8464
8465
8466
8467 /*************************************************
8468 *       Find length of a parsed group            *
8469 *************************************************/
8470
8471 /* This is called for nested groups within a branch of a lookbehind whose
8472 length is being computed. If all the branches in the nested group have the same
8473 length, that is OK. On entry, the pointer must be at the first element after
8474 the group initializing code. On exit it points to OP_KET. Caching is used to
8475 improve processing speed when the same capturing group occurs many times.
8476
8477 Arguments:
8478   pptrptr     pointer to pointer in the parsed pattern
8479   isinline    FALSE if a reference or recursion; TRUE for inline group
8480   errcodeptr  pointer to the errorcode
8481   lcptr       pointer to the loop counter
8482   group       number of captured group or -1 for a non-capturing group
8483   recurses    chain of recurse_check to catch mutual recursion
8484   cb          pointer to the compile data
8485
8486 Returns:      the group length or a negative number
8487 */
8488
8489 static int
8490 get_grouplength(uint32_t **pptrptr, BOOL isinline, int *errcodeptr, int *lcptr,
8491   int group, parsed_recurse_check *recurses, compile_block *cb)
8492 {
8493 int branchlength;
8494 int grouplength = -1;
8495
8496 /* The cache can be used only if there is no possibility of there being two
8497 groups with the same number. We do not need to set the end pointer for a group
8498 that is being processed as a back reference or recursion, but we must do so for
8499 an inline group. */
8500
8501 if (group > 0 && (cb->external_flags & PCRE2_DUPCAPUSED) == 0)
8502   {
8503   uint32_t groupinfo = cb->groupinfo[group];
8504   if ((groupinfo & GI_NOT_FIXED_LENGTH) != 0) return -1;
8505   if ((groupinfo & GI_SET_FIXED_LENGTH) != 0)
8506     {
8507     if (isinline) *pptrptr = parsed_skip(*pptrptr, PSKIP_KET);
8508     return groupinfo & GI_FIXED_LENGTH_MASK;
8509     }
8510   }
8511
8512 /* Scan the group. In this case we find the end pointer of necessity. */
8513
8514 for(;;)
8515   {
8516   branchlength = get_branchlength(pptrptr, errcodeptr, lcptr, recurses, cb);
8517   if (branchlength < 0) goto ISNOTFIXED;
8518   if (grouplength == -1) grouplength = branchlength;
8519     else if (grouplength != branchlength) goto ISNOTFIXED;
8520   if (**pptrptr == META_KET) break;
8521   *pptrptr += 1;   /* Skip META_ALT */
8522   }
8523
8524 if (group > 0)
8525   cb->groupinfo[group] |= (uint32_t)(GI_SET_FIXED_LENGTH | grouplength);
8526 return grouplength;
8527
8528 ISNOTFIXED:
8529 if (group > 0) cb->groupinfo[group] |= GI_NOT_FIXED_LENGTH;
8530 return -1;
8531 }
8532
8533
8534
8535 /*************************************************
8536 *        Find length of a parsed branch          *
8537 *************************************************/
8538
8539 /* Return a fixed length for a branch in a lookbehind, giving an error if the
8540 length is not fixed. If any lookbehinds are encountered on the way, they get
8541 their length set. On entry, *pptrptr points to the first element inside the
8542 branch. On exit it is set to point to the ALT or KET.
8543
8544 Arguments:
8545   pptrptr     pointer to pointer in the parsed pattern
8546   errcodeptr  pointer to error code
8547   lcptr       pointer to loop counter
8548   recurses    chain of recurse_check to catch mutual recursion
8549   cb          pointer to compile block
8550
8551 Returns:      the length, or a negative value on error
8552 */
8553
8554 static int
8555 get_branchlength(uint32_t **pptrptr, int *errcodeptr, int *lcptr,
8556   parsed_recurse_check *recurses, compile_block *cb)
8557 {
8558 int branchlength = 0;
8559 int grouplength;
8560 uint32_t lastitemlength = 0;
8561 uint32_t *pptr = *pptrptr;
8562 PCRE2_SIZE offset;
8563 parsed_recurse_check this_recurse;
8564
8565 /* A large and/or complex regex can take too long to process. This can happen
8566 more often when (?| groups are present in the pattern because their length
8567 cannot be cached. */
8568
8569 if ((*lcptr)++ > 2000)
8570   {
8571   *errcodeptr = ERR35;  /* Lookbehind is too complicated */
8572   return -1;
8573   }
8574
8575 /* Scan the branch, accumulating the length. */
8576
8577 for (;; pptr++)
8578   {
8579   parsed_recurse_check *r;
8580   uint32_t *gptr, *gptrend;
8581   uint32_t escape;
8582   uint32_t group = 0;
8583   uint32_t itemlength = 0;
8584
8585   if (*pptr < META_END)
8586     {
8587     itemlength = 1;
8588     }
8589
8590   else switch (META_CODE(*pptr))
8591     {
8592     case META_KET:
8593     case META_ALT:
8594     goto EXIT;
8595
8596     /* (*ACCEPT) and (*FAIL) terminate the branch, but we must skip to the
8597     actual termination. */
8598
8599     case META_ACCEPT:
8600     case META_FAIL:
8601     pptr = parsed_skip(pptr, PSKIP_ALT);
8602     if (pptr == NULL) goto PARSED_SKIP_FAILED;
8603     goto EXIT;
8604
8605     case META_MARK:
8606     case META_COMMIT_ARG:
8607     case META_PRUNE_ARG:
8608     case META_SKIP_ARG:
8609     case META_THEN_ARG:
8610     pptr += pptr[1] + 1;
8611     break;
8612
8613     case META_CIRCUMFLEX:
8614     case META_COMMIT:
8615     case META_DOLLAR:
8616     case META_PRUNE:
8617     case META_SKIP:
8618     case META_THEN:
8619     break;
8620
8621     case META_OPTIONS:
8622     pptr += 1;
8623     break;
8624
8625     case META_BIGVALUE:
8626     itemlength = 1;
8627     pptr += 1;
8628     break;
8629
8630     case META_CLASS:
8631     case META_CLASS_NOT:
8632     itemlength = 1;
8633     pptr = parsed_skip(pptr, PSKIP_CLASS);
8634     if (pptr == NULL) goto PARSED_SKIP_FAILED;
8635     break;
8636
8637     case META_CLASS_EMPTY_NOT:
8638     case META_DOT:
8639     itemlength = 1;
8640     break;
8641
8642     case META_CALLOUT_NUMBER:
8643     pptr += 3;
8644     break;
8645
8646     case META_CALLOUT_STRING:
8647     pptr += 3 + SIZEOFFSET;
8648     break;
8649
8650     /* Only some escapes consume a character. Of those, \R and \X are never
8651     allowed because they might match more than character. \C is allowed only in
8652     32-bit and non-UTF 8/16-bit modes. */
8653
8654     case META_ESCAPE:
8655     escape = META_DATA(*pptr);
8656     if (escape == ESC_R || escape == ESC_X) return -1;
8657     if (escape > ESC_b && escape < ESC_Z)
8658       {
8659 #if PCRE2_CODE_UNIT_WIDTH != 32
8660       if ((cb->external_options & PCRE2_UTF) != 0 && escape == ESC_C)
8661         {
8662         *errcodeptr = ERR36;
8663         return -1;
8664         }
8665 #endif
8666       itemlength = 1;
8667       if (escape == ESC_p || escape == ESC_P) pptr++;  /* Skip prop data */
8668       }
8669     break;
8670
8671     /* Lookaheads can be ignored, but we must start the skip inside the group
8672     so that it isn't treated as a group within the branch. */
8673
8674     case META_LOOKAHEAD:
8675     case META_LOOKAHEADNOT:
8676     pptr = parsed_skip(pptr + 1, PSKIP_KET);
8677     if (pptr == NULL) goto PARSED_SKIP_FAILED;
8678
8679     /* Also ignore any qualifiers that follow a lookahead assertion. */
8680
8681     switch (pptr[1])
8682       {
8683       case META_ASTERISK:
8684       case META_ASTERISK_PLUS:
8685       case META_ASTERISK_QUERY:
8686       case META_PLUS:
8687       case META_PLUS_PLUS:
8688       case META_PLUS_QUERY:
8689       case META_QUERY:
8690       case META_QUERY_PLUS:
8691       case META_QUERY_QUERY:
8692       pptr++;
8693       break;
8694
8695       case META_MINMAX:
8696       case META_MINMAX_PLUS:
8697       case META_MINMAX_QUERY:
8698       pptr += 3;
8699       break;
8700
8701       default:
8702       break;
8703       }
8704     break;
8705
8706     /* Lookbehinds can be ignored, but must themselves be checked. */
8707
8708     case META_LOOKBEHIND:
8709     case META_LOOKBEHINDNOT:
8710     if (!set_lookbehind_lengths(&pptr, errcodeptr, lcptr, recurses, cb))
8711       return -1;
8712     break;
8713
8714     /* Back references and recursions are handled by very similar code. At this
8715     stage, the names generated in the parsing pass are available, but the main
8716     name table has not yet been created. So for the named varieties, scan the
8717     list of names in order to get the number of the first one in the pattern,
8718     and whether or not this name is duplicated. */
8719
8720     case META_BACKREF_BYNAME:
8721     if ((cb->external_options & PCRE2_MATCH_UNSET_BACKREF) != 0)
8722       goto ISNOTFIXED;
8723     /* Fall through */
8724
8725     case META_RECURSE_BYNAME:
8726       {
8727       int i;
8728       PCRE2_SPTR name;
8729       BOOL is_dupname = FALSE;
8730       named_group *ng = cb->named_groups;
8731       uint32_t meta_code = META_CODE(*pptr);
8732       uint32_t length = *(++pptr);
8733
8734       GETPLUSOFFSET(offset, pptr);
8735       name = cb->start_pattern + offset;
8736       for (i = 0; i < cb->names_found; i++, ng++)
8737         {
8738         if (length == ng->length && PRIV(strncmp)(name, ng->name, length) == 0)
8739           {
8740           group = ng->number;
8741           is_dupname = ng->isdup;
8742           break;
8743           }
8744         }
8745
8746       if (group == 0)
8747         {
8748         *errcodeptr = ERR15;  /* Non-existent subpattern */
8749         cb->erroroffset = offset;
8750         return -1;
8751         }
8752
8753       /* A numerical back reference can be fixed length if duplicate capturing
8754       groups are not being used. A non-duplicate named back reference can also
8755       be handled. */
8756
8757       if (meta_code == META_RECURSE_BYNAME ||
8758           (!is_dupname && (cb->external_flags & PCRE2_DUPCAPUSED) == 0))
8759         goto RECURSE_OR_BACKREF_LENGTH;  /* Handle as a numbered version. */
8760       }
8761     goto ISNOTFIXED;                     /* Duplicate name or number */
8762
8763     /* The offset values for back references < 10 are in a separate vector
8764     because otherwise they would use more than two parsed pattern elements on
8765     64-bit systems. */
8766
8767     case META_BACKREF:
8768     if ((cb->external_options & PCRE2_MATCH_UNSET_BACKREF) != 0 ||
8769         (cb->external_flags & PCRE2_DUPCAPUSED) != 0)
8770       goto ISNOTFIXED;
8771     group = META_DATA(*pptr);
8772     if (group < 10)
8773       {
8774       offset = cb->small_ref_offset[group];
8775       goto RECURSE_OR_BACKREF_LENGTH;
8776       }
8777
8778     /* Fall through */
8779     /* For groups >= 10 - picking up group twice does no harm. */
8780
8781     /* A true recursion implies not fixed length, but a subroutine call may
8782     be OK. Back reference "recursions" are also failed. */
8783
8784     case META_RECURSE:
8785     group = META_DATA(*pptr);
8786     GETPLUSOFFSET(offset, pptr);
8787
8788     RECURSE_OR_BACKREF_LENGTH:
8789     if (group > cb->bracount)
8790       {
8791       cb->erroroffset = offset;
8792       *errcodeptr = ERR15;  /* Non-existent subpattern */
8793       return -1;
8794       }
8795     if (group == 0) goto ISNOTFIXED;  /* Local recursion */
8796     for (gptr = cb->parsed_pattern; *gptr != META_END; gptr++)
8797       {
8798       if (META_CODE(*gptr) == META_BIGVALUE) gptr++;
8799         else if (*gptr == (META_CAPTURE | group)) break;
8800       }
8801
8802     /* We must start the search for the end of the group at the first meta code
8803     inside the group. Otherwise it will be treated as an enclosed group. */
8804
8805     gptrend = parsed_skip(gptr + 1, PSKIP_KET);
8806     if (gptrend == NULL) goto PARSED_SKIP_FAILED;
8807     if (pptr > gptr && pptr < gptrend) goto ISNOTFIXED;  /* Local recursion */
8808     for (r = recurses; r != NULL; r = r->prev) if (r->groupptr == gptr) break;
8809     if (r != NULL) goto ISNOTFIXED;   /* Mutual recursion */
8810     this_recurse.prev = recurses;
8811     this_recurse.groupptr = gptr;
8812
8813     /* We do not need to know the position of the end of the group, that is,
8814     gptr is not used after the call to get_grouplength(). Setting the second
8815     argument FALSE stops it scanning for the end when the length can be found
8816     in the cache. */
8817
8818     gptr++;
8819     grouplength = get_grouplength(&gptr, FALSE, errcodeptr, lcptr, group,
8820       &this_recurse, cb);
8821     if (grouplength < 0)
8822       {
8823       if (*errcodeptr == 0) goto ISNOTFIXED;
8824       return -1;  /* Error already set */
8825       }
8826     itemlength = grouplength;
8827     break;
8828
8829     /* Check nested groups - advance past the initial data for each type and
8830     then seek a fixed length with get_grouplength(). */
8831
8832     case META_COND_NAME:
8833     case META_COND_NUMBER:
8834     case META_COND_RNAME:
8835     case META_COND_RNUMBER:
8836     case META_COND_DEFINE:
8837     pptr += 2 + SIZEOFFSET;
8838     goto CHECK_GROUP;
8839
8840     case META_COND_ASSERT:
8841     pptr += 1;
8842     goto CHECK_GROUP;
8843
8844     case META_COND_VERSION:
8845     pptr += 4;
8846     goto CHECK_GROUP;
8847
8848     case META_CAPTURE:
8849     group = META_DATA(*pptr);
8850     /* Fall through */
8851
8852     case META_ATOMIC:
8853     case META_NOCAPTURE:
8854     pptr++;
8855     CHECK_GROUP:
8856     grouplength = get_grouplength(&pptr, TRUE, errcodeptr, lcptr, group,
8857       recurses, cb);
8858     if (grouplength < 0) return -1;
8859     itemlength = grouplength;
8860     break;
8861
8862     /* Exact repetition is OK; variable repetition is not. A repetition of zero
8863     must subtract the length that has already been added. */
8864
8865     case META_MINMAX:
8866     case META_MINMAX_PLUS:
8867     case META_MINMAX_QUERY:
8868     if (pptr[1] == pptr[2])
8869       {
8870       if (pptr[1] == 0) branchlength -= lastitemlength;
8871         else itemlength = (pptr[1] - 1) * lastitemlength;
8872       pptr += 2;
8873       break;
8874       }
8875     /* Fall through */
8876
8877     /* Any other item means this branch does not have a fixed length. */
8878
8879     default:
8880     ISNOTFIXED:
8881     *errcodeptr = ERR25;   /* Not fixed length */
8882     return -1;
8883     }
8884
8885   /* Add the item length to the branchlength, and save it for use if the next
8886   thing is a quantifier. */
8887
8888   branchlength += itemlength;
8889   lastitemlength = itemlength;
8890
8891   /* Ensure that the length does not overflow the limit. */
8892
8893   if (branchlength > LOOKBEHIND_MAX)
8894     {
8895     *errcodeptr = ERR87;
8896     return -1;
8897     }
8898   }
8899
8900 EXIT:
8901 *pptrptr = pptr;
8902 if (branchlength > cb->max_lookbehind) cb->max_lookbehind = branchlength;
8903 return branchlength;
8904
8905 PARSED_SKIP_FAILED:
8906 *errcodeptr = ERR90;
8907 return -1;
8908 }
8909
8910
8911
8912 /*************************************************
8913 *        Set lengths in a lookbehind             *
8914 *************************************************/
8915
8916 /* This function is called for each lookbehind, to set the lengths in its
8917 branches. An error occurs if any branch does not have a fixed length that is
8918 less than the maximum (65535). On exit, the pointer must be left on the final
8919 ket.
8920
8921 Arguments:
8922   pptrptr     pointer to pointer in the parsed pattern
8923   errcodeptr  pointer to error code
8924   lcptr       pointer to loop counter
8925   recurses    chain of recurse_check to catch mutual recursion
8926   cb          pointer to compile block
8927
8928 Returns:      TRUE if all is well
8929               FALSE otherwise, with error code and offset set
8930 */
8931
8932 static BOOL
8933 set_lookbehind_lengths(uint32_t **pptrptr, int *errcodeptr, int *lcptr,
8934   parsed_recurse_check *recurses, compile_block *cb)
8935 {
8936 PCRE2_SIZE offset;
8937 int branchlength;
8938 uint32_t *bptr = *pptrptr;
8939
8940 READPLUSOFFSET(offset, bptr);  /* Offset for error messages */
8941 *pptrptr += SIZEOFFSET;
8942
8943 do
8944   {
8945   *pptrptr += 1;
8946   branchlength = get_branchlength(pptrptr, errcodeptr, lcptr, recurses, cb);
8947   if (branchlength < 0)
8948     {
8949     /* The errorcode and offset may already be set from a nested lookbehind. */
8950     if (*errcodeptr == 0) *errcodeptr = ERR25;
8951     if (cb->erroroffset == PCRE2_UNSET) cb->erroroffset = offset;
8952     return FALSE;
8953     }
8954   *bptr |= branchlength;  /* branchlength never more than 65535 */
8955   bptr = *pptrptr;
8956   }
8957 while (*bptr == META_ALT);
8958
8959 return TRUE;
8960 }
8961
8962
8963
8964 /*************************************************
8965 *         Check parsed pattern lookbehinds       *
8966 *************************************************/
8967
8968 /* This function is called at the end of parsing a pattern if any lookbehinds
8969 were encountered. It scans the parsed pattern for them, calling
8970 set_lookbehind_lengths() for each one. At the start, the errorcode is zero and
8971 the error offset is marked unset. The enables the functions above not to
8972 override settings from deeper nestings.
8973
8974 Arguments cb      points to the compile block
8975 Returns:          0 on success, or an errorcode (cb->erroroffset will be set)
8976 */
8977
8978 static int
8979 check_lookbehinds(compile_block *cb)
8980 {
8981 uint32_t *pptr;
8982 int errorcode = 0;
8983 int loopcount = 0;
8984
8985 cb->erroroffset = PCRE2_UNSET;
8986
8987 for (pptr = cb->parsed_pattern; *pptr != META_END; pptr++)
8988   {
8989   if (*pptr < META_END) continue;  /* Literal */
8990
8991   switch (META_CODE(*pptr))
8992     {
8993     default:
8994     return ERR70;  /* Unrecognized meta code */
8995
8996     case META_ESCAPE:
8997     if (*pptr - META_ESCAPE == ESC_P || *pptr - META_ESCAPE == ESC_p)
8998       pptr += 1;
8999     break;
9000
9001     case META_ACCEPT:
9002     case META_ALT:
9003     case META_ASTERISK:
9004     case META_ASTERISK_PLUS:
9005     case META_ASTERISK_QUERY:
9006     case META_ATOMIC:
9007     case META_BACKREF:
9008     case META_CAPTURE:
9009     case META_CIRCUMFLEX:
9010     case META_CLASS:
9011     case META_CLASS_EMPTY:
9012     case META_CLASS_EMPTY_NOT:
9013     case META_CLASS_END:
9014     case META_CLASS_NOT:
9015     case META_COMMIT:
9016     case META_COND_ASSERT:
9017     case META_DOLLAR:
9018     case META_DOT:
9019     case META_FAIL:
9020     case META_KET:
9021     case META_LOOKAHEAD:
9022     case META_LOOKAHEADNOT:
9023     case META_NOCAPTURE:
9024     case META_PLUS:
9025     case META_PLUS_PLUS:
9026     case META_PLUS_QUERY:
9027     case META_PRUNE:
9028     case META_QUERY:
9029     case META_QUERY_PLUS:
9030     case META_QUERY_QUERY:
9031     case META_RANGE_ESCAPED:
9032     case META_RANGE_LITERAL:
9033     case META_SKIP:
9034     case META_THEN:
9035     break;
9036
9037     case META_RECURSE:
9038     pptr += SIZEOFFSET;
9039     break;
9040
9041     case META_BACKREF_BYNAME:
9042     case META_COND_DEFINE:
9043     case META_COND_NAME:
9044     case META_COND_NUMBER:
9045     case META_COND_RNAME:
9046     case META_COND_RNUMBER:
9047     case META_RECURSE_BYNAME:
9048     pptr += 1 + SIZEOFFSET;
9049     break;
9050
9051     case META_CALLOUT_STRING:
9052     pptr += 3 + SIZEOFFSET;
9053     break;
9054
9055     case META_BIGVALUE:
9056     case META_OPTIONS:
9057     case META_POSIX:
9058     case META_POSIX_NEG:
9059     pptr += 1;
9060     break;
9061
9062     case META_MINMAX:
9063     case META_MINMAX_QUERY:
9064     case META_MINMAX_PLUS:
9065     pptr += 2;
9066     break;
9067
9068     case META_CALLOUT_NUMBER:
9069     case META_COND_VERSION:
9070     pptr += 3;
9071     break;
9072
9073     case META_MARK:
9074     case META_COMMIT_ARG:
9075     case META_PRUNE_ARG:
9076     case META_SKIP_ARG:
9077     case META_THEN_ARG:
9078     pptr += 1 + pptr[1];
9079     break;
9080
9081     case META_LOOKBEHIND:
9082     case META_LOOKBEHINDNOT:
9083     if (!set_lookbehind_lengths(&pptr, &errorcode, &loopcount, NULL, cb))
9084       return errorcode;
9085     break;
9086     }
9087   }
9088
9089 return 0;
9090 }
9091
9092
9093
9094 /*************************************************
9095 *     External function to compile a pattern     *
9096 *************************************************/
9097
9098 /* This function reads a regular expression in the form of a string and returns
9099 a pointer to a block of store holding a compiled version of the expression.
9100
9101 Arguments:
9102   pattern       the regular expression
9103   patlen        the length of the pattern, or PCRE2_ZERO_TERMINATED
9104   options       option bits
9105   errorptr      pointer to errorcode
9106   erroroffset   pointer to error offset
9107   ccontext      points to a compile context or is NULL
9108
9109 Returns:        pointer to compiled data block, or NULL on error,
9110                 with errorcode and erroroffset set
9111 */
9112
9113 PCRE2_EXP_DEFN pcre2_code * PCRE2_CALL_CONVENTION
9114 pcre2_compile(PCRE2_SPTR pattern, PCRE2_SIZE patlen, uint32_t options,
9115    int *errorptr, PCRE2_SIZE *erroroffset, pcre2_compile_context *ccontext)
9116 {
9117 BOOL utf;                             /* Set TRUE for UTF mode */
9118 BOOL has_lookbehind = FALSE;          /* Set TRUE if a lookbehind is found */
9119 BOOL zero_terminated;                 /* Set TRUE for zero-terminated pattern */
9120 pcre2_real_code *re = NULL;           /* What we will return */
9121 compile_block cb;                     /* "Static" compile-time data */
9122 const uint8_t *tables;                /* Char tables base pointer */
9123
9124 PCRE2_UCHAR *code;                    /* Current pointer in compiled code */
9125 PCRE2_SPTR codestart;                 /* Start of compiled code */
9126 PCRE2_SPTR ptr;                       /* Current pointer in pattern */
9127 uint32_t *pptr;                       /* Current pointer in parsed pattern */
9128
9129 PCRE2_SIZE length = 1;                /* Allow for final END opcode */
9130 PCRE2_SIZE usedlength;                /* Actual length used */
9131 PCRE2_SIZE re_blocksize;              /* Size of memory block */
9132 PCRE2_SIZE big32count = 0;            /* 32-bit literals >= 0x80000000 */
9133 PCRE2_SIZE parsed_size_needed;        /* Needed for parsed pattern */
9134
9135 int32_t firstcuflags, reqcuflags;     /* Type of first/req code unit */
9136 uint32_t firstcu, reqcu;              /* Value of first/req code unit */
9137 uint32_t setflags = 0;                /* NL and BSR set flags */
9138
9139 uint32_t skipatstart;                 /* When checking (*UTF) etc */
9140 uint32_t limit_heap  = UINT32_MAX;
9141 uint32_t limit_match = UINT32_MAX;    /* Unset match limits */
9142 uint32_t limit_depth = UINT32_MAX;
9143
9144 int newline = 0;                      /* Unset; can be set by the pattern */
9145 int bsr = 0;                          /* Unset; can be set by the pattern */
9146 int errorcode = 0;                    /* Initialize to avoid compiler warn */
9147 int regexrc;                          /* Return from compile */
9148
9149 uint32_t i;                           /* Local loop counter */
9150
9151 /* Comments at the head of this file explain about these variables. */
9152
9153 uint32_t stack_groupinfo[GROUPINFO_DEFAULT_SIZE];
9154 uint32_t stack_parsed_pattern[PARSED_PATTERN_DEFAULT_SIZE];
9155 named_group named_groups[NAMED_GROUP_LIST_SIZE];
9156
9157 /* The workspace is used in different ways in the different compiling phases.
9158 It needs to be 16-bit aligned for the preliminary parsing scan. */
9159
9160 uint32_t c16workspace[C16_WORK_SIZE];
9161 PCRE2_UCHAR *cworkspace = (PCRE2_UCHAR *)c16workspace;
9162
9163
9164 /* -------------- Check arguments and set up the pattern ----------------- */
9165
9166 /* There must be error code and offset pointers. */
9167
9168 if (errorptr == NULL || erroroffset == NULL) return NULL;
9169 *errorptr = ERR0;
9170 *erroroffset = 0;
9171
9172 /* There must be a pattern! */
9173
9174 if (pattern == NULL)
9175   {
9176   *errorptr = ERR16;
9177   return NULL;
9178   }
9179
9180 /* A NULL compile context means "use a default context" */
9181
9182 if (ccontext == NULL)
9183   ccontext = (pcre2_compile_context *)(&PRIV(default_compile_context));
9184
9185 /* Check that all undefined public option bits are zero. */
9186
9187 if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0 ||
9188     (ccontext->extra_options & ~PUBLIC_COMPILE_EXTRA_OPTIONS) != 0)
9189   {
9190   *errorptr = ERR17;
9191   return NULL;
9192   }
9193
9194 if ((options & PCRE2_LITERAL) != 0 &&
9195     ((options & ~PUBLIC_LITERAL_COMPILE_OPTIONS) != 0 ||
9196      (ccontext->extra_options & ~PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS) != 0))
9197   {
9198   *errorptr = ERR92;
9199   return NULL;
9200   }
9201
9202 /* A zero-terminated pattern is indicated by the special length value
9203 PCRE2_ZERO_TERMINATED. Check for an overlong pattern. */
9204
9205 if ((zero_terminated = (patlen == PCRE2_ZERO_TERMINATED)))
9206   patlen = PRIV(strlen)(pattern);
9207
9208 if (patlen > ccontext->max_pattern_length)
9209   {
9210   *errorptr = ERR88;
9211   return NULL;
9212   }
9213
9214 /* From here on, all returns from this function should end up going via the
9215 EXIT label. */
9216
9217
9218 /* ------------ Initialize the "static" compile data -------------- */
9219
9220 tables = (ccontext->tables != NULL)? ccontext->tables : PRIV(default_tables);
9221
9222 cb.lcc = tables + lcc_offset;          /* Individual */
9223 cb.fcc = tables + fcc_offset;          /*   character */
9224 cb.cbits = tables + cbits_offset;      /*      tables */
9225 cb.ctypes = tables + ctypes_offset;
9226
9227 cb.assert_depth = 0;
9228 cb.bracount = 0;
9229 cb.cx = ccontext;
9230 cb.dupnames = FALSE;
9231 cb.end_pattern = pattern + patlen;
9232 cb.erroroffset = 0;
9233 cb.external_flags = 0;
9234 cb.external_options = options;
9235 cb.groupinfo = stack_groupinfo;
9236 cb.had_recurse = FALSE;
9237 cb.lastcapture = 0;
9238 cb.max_lookbehind = 0;
9239 cb.name_entry_size = 0;
9240 cb.name_table = NULL;
9241 cb.named_groups = named_groups;
9242 cb.named_group_list_size = NAMED_GROUP_LIST_SIZE;
9243 cb.names_found = 0;
9244 cb.open_caps = NULL;
9245 cb.parens_depth = 0;
9246 cb.parsed_pattern = stack_parsed_pattern;
9247 cb.req_varyopt = 0;
9248 cb.start_code = cworkspace;
9249 cb.start_pattern = pattern;
9250 cb.start_workspace = cworkspace;
9251 cb.workspace_size = COMPILE_WORK_SIZE;
9252
9253 /* Maximum back reference and backref bitmap. The bitmap records up to 31 back
9254 references to help in deciding whether (.*) can be treated as anchored or not.
9255 */
9256
9257 cb.top_backref = 0;
9258 cb.backref_map = 0;
9259
9260 /* Escape sequences \1 to \9 are always back references, but as they are only
9261 two characters long, only two elements can be used in the parsed_pattern
9262 vector. The first contains the reference, and we'd like to use the second to
9263 record the offset in the pattern, so that forward references to non-existent
9264 groups can be diagnosed later with an offset. However, on 64-bit systems,
9265 PCRE2_SIZE won't fit. Instead, we have a vector of offsets for the first
9266 occurrence of \1 to \9, indexed by the second parsed_pattern value. All other
9267 references have enough space for the offset to be put into the parsed pattern.
9268 */
9269
9270 for (i = 0; i < 10; i++) cb.small_ref_offset[i] = PCRE2_UNSET;
9271
9272
9273 /* --------------- Start looking at the pattern --------------- */
9274
9275 /* Unless PCRE2_LITERAL is set, check for global one-time option settings at
9276 the start of the pattern, and remember the offset to the actual regex. With
9277 valgrind support, make the terminator of a zero-terminated pattern
9278 inaccessible. This catches bugs that would otherwise only show up for
9279 non-zero-terminated patterns. */
9280
9281 #ifdef SUPPORT_VALGRIND
9282 if (zero_terminated) VALGRIND_MAKE_MEM_NOACCESS(pattern + patlen, CU2BYTES(1));
9283 #endif
9284
9285 ptr = pattern;
9286 skipatstart = 0;
9287
9288 if ((options & PCRE2_LITERAL) == 0)
9289   {
9290   while (patlen - skipatstart >= 2 &&
9291          ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&
9292          ptr[skipatstart+1] == CHAR_ASTERISK)
9293     {
9294     for (i = 0; i < sizeof(pso_list)/sizeof(pso); i++)
9295       {
9296       uint32_t c, pp;
9297       pso *p = pso_list + i;
9298
9299       if (patlen - skipatstart - 2 >= p->length &&
9300           PRIV(strncmp_c8)(ptr + skipatstart + 2, (char *)(p->name),
9301             p->length) == 0)
9302         {
9303         skipatstart += p->length + 2;
9304         switch(p->type)
9305           {
9306           case PSO_OPT:
9307           cb.external_options |= p->value;
9308           break;
9309
9310           case PSO_FLG:
9311           setflags |= p->value;
9312           break;
9313
9314           case PSO_NL:
9315           newline = p->value;
9316           setflags |= PCRE2_NL_SET;
9317           break;
9318
9319           case PSO_BSR:
9320           bsr = p->value;
9321           setflags |= PCRE2_BSR_SET;
9322           break;
9323
9324           case PSO_LIMM:
9325           case PSO_LIMD:
9326           case PSO_LIMH:
9327           c = 0;
9328           pp = skipatstart;
9329           if (!IS_DIGIT(ptr[pp]))
9330             {
9331             errorcode = ERR60;
9332             ptr += pp;
9333             goto HAD_EARLY_ERROR;
9334             }
9335           while (IS_DIGIT(ptr[pp]))
9336             {
9337             if (c > UINT32_MAX / 10 - 1) break;   /* Integer overflow */
9338             c = c*10 + (ptr[pp++] - CHAR_0);
9339             }
9340           if (ptr[pp++] != CHAR_RIGHT_PARENTHESIS)
9341             {
9342             errorcode = ERR60;
9343             ptr += pp;
9344             goto HAD_EARLY_ERROR;
9345             }
9346           if (p->type == PSO_LIMH) limit_heap = c;
9347             else if (p->type == PSO_LIMM) limit_match = c;
9348             else limit_depth = c;
9349           skipatstart += pp - skipatstart;
9350           break;
9351           }
9352         break;   /* Out of the table scan loop */
9353         }
9354       }
9355     if (i >= sizeof(pso_list)/sizeof(pso)) break;   /* Out of pso loop */
9356     }
9357   }
9358
9359 /* End of pattern-start options; advance to start of real regex. */
9360
9361 ptr += skipatstart;
9362
9363 /* Can't support UTF or UCP unless PCRE2 has been compiled with UTF support. */
9364
9365 #ifndef SUPPORT_UNICODE
9366 if ((cb.external_options & (PCRE2_UTF|PCRE2_UCP)) != 0)
9367   {
9368   errorcode = ERR32;
9369   goto HAD_EARLY_ERROR;
9370   }
9371 #endif
9372
9373 /* Check UTF. We have the original options in 'options', with that value as
9374 modified by (*UTF) etc in cb->external_options. The extra option
9375 PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES is not permitted in UTF-16 mode because the
9376 surrogate code points cannot be represented in UTF-16. */
9377
9378 utf = (cb.external_options & PCRE2_UTF) != 0;
9379 if (utf)
9380   {
9381   if ((options & PCRE2_NEVER_UTF) != 0)
9382     {
9383     errorcode = ERR74;
9384     goto HAD_EARLY_ERROR;
9385     }
9386   if ((options & PCRE2_NO_UTF_CHECK) == 0 &&
9387        (errorcode = PRIV(valid_utf)(pattern, patlen, erroroffset)) != 0)
9388     goto HAD_ERROR;  /* Offset was set by valid_utf() */
9389
9390 #if PCRE2_CODE_UNIT_WIDTH == 16
9391   if ((ccontext->extra_options & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) != 0)
9392     {
9393     errorcode = ERR91;
9394     goto HAD_EARLY_ERROR;
9395     }
9396 #endif
9397   }
9398
9399 /* Check UCP lockout. */
9400
9401 if ((cb.external_options & (PCRE2_UCP|PCRE2_NEVER_UCP)) ==
9402     (PCRE2_UCP|PCRE2_NEVER_UCP))
9403   {
9404   errorcode = ERR75;
9405   goto HAD_EARLY_ERROR;
9406   }
9407
9408 /* Process the BSR setting. */
9409
9410 if (bsr == 0) bsr = ccontext->bsr_convention;
9411
9412 /* Process the newline setting. */
9413
9414 if (newline == 0) newline = ccontext->newline_convention;
9415 cb.nltype = NLTYPE_FIXED;
9416 switch(newline)
9417   {
9418   case PCRE2_NEWLINE_CR:
9419   cb.nllen = 1;
9420   cb.nl[0] = CHAR_CR;
9421   break;
9422
9423   case PCRE2_NEWLINE_LF:
9424   cb.nllen = 1;
9425   cb.nl[0] = CHAR_NL;
9426   break;
9427
9428   case PCRE2_NEWLINE_NUL:
9429   cb.nllen = 1;
9430   cb.nl[0] = CHAR_NUL;
9431   break;
9432
9433   case PCRE2_NEWLINE_CRLF:
9434   cb.nllen = 2;
9435   cb.nl[0] = CHAR_CR;
9436   cb.nl[1] = CHAR_NL;
9437   break;
9438
9439   case PCRE2_NEWLINE_ANY:
9440   cb.nltype = NLTYPE_ANY;
9441   break;
9442
9443   case PCRE2_NEWLINE_ANYCRLF:
9444   cb.nltype = NLTYPE_ANYCRLF;
9445   break;
9446
9447   default:
9448   errorcode = ERR56;
9449   goto HAD_EARLY_ERROR;
9450   }
9451
9452 /* Pre-scan the pattern to do two things: (1) Discover the named groups and
9453 their numerical equivalents, so that this information is always available for
9454 the remaining processing. (2) At the same time, parse the pattern and put a
9455 processed version into the parsed_pattern vector. This has escapes interpreted
9456 and comments removed (amongst other things).
9457
9458 In all but one case, when PCRE2_AUTO_CALLOUT is not set, the number of unsigned
9459 32-bit ints in the parsed pattern is bounded by the length of the pattern plus
9460 one (for the terminator) plus four if PCRE2_EXTRA_WORD or PCRE2_EXTRA_LINE is
9461 set. The exceptional case is when running in 32-bit, non-UTF mode, when literal
9462 characters greater than META_END (0x80000000) have to be coded as two units. In
9463 this case, therefore, we scan the pattern to check for such values. */
9464
9465 #if PCRE2_CODE_UNIT_WIDTH == 32
9466 if (!utf)
9467   {
9468   PCRE2_SPTR p;
9469   for (p = ptr; p < cb.end_pattern; p++) if (*p >= META_END) big32count++;
9470   }
9471 #endif
9472
9473 /* Ensure that the parsed pattern buffer is big enough. When PCRE2_AUTO_CALLOUT
9474 is set we have to assume a numerical callout (4 elements) for each character
9475 plus one at the end. This is overkill, but memory is plentiful these days. For
9476 many smaller patterns the vector on the stack (which was set up above) can be
9477 used. */
9478
9479 parsed_size_needed = patlen - skipatstart + big32count;
9480
9481 if ((ccontext->extra_options &
9482      (PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_MATCH_LINE)) != 0)
9483   parsed_size_needed += 4;
9484
9485 if ((options & PCRE2_AUTO_CALLOUT) != 0)
9486   parsed_size_needed = (parsed_size_needed + 1) * 5;
9487
9488 if (parsed_size_needed >= PARSED_PATTERN_DEFAULT_SIZE)
9489   {
9490   uint32_t *heap_parsed_pattern = ccontext->memctl.malloc(
9491     (parsed_size_needed + 1) * sizeof(uint32_t), ccontext->memctl.memory_data);
9492   if (heap_parsed_pattern == NULL)
9493     {
9494     *errorptr = ERR21;
9495     goto EXIT;
9496     }
9497   cb.parsed_pattern = heap_parsed_pattern;
9498   }
9499 cb.parsed_pattern_end = cb.parsed_pattern + parsed_size_needed + 1;
9500
9501 /* Do the parsing scan. */
9502
9503 errorcode = parse_regex(ptr, cb.external_options, &has_lookbehind, &cb);
9504 if (errorcode != 0) goto HAD_CB_ERROR;
9505
9506 /* Workspace is needed to remember information about numbered groups: whether a
9507 group can match an empty string and what its fixed length is. This is done to
9508 avoid the possibility of recursive references causing very long compile times
9509 when checking these features. Unnumbered groups do not have this exposure since
9510 they cannot be referenced. We use an indexed vector for this purpose. If there
9511 are sufficiently few groups, the default vector on the stack, as set up above,
9512 can be used. Otherwise we have to get/free a special vector. The vector must be
9513 initialized to zero. */
9514
9515 if (cb.bracount >= GROUPINFO_DEFAULT_SIZE)
9516   {
9517   cb.groupinfo = ccontext->memctl.malloc(
9518     (cb.bracount + 1)*sizeof(uint32_t), ccontext->memctl.memory_data);
9519   if (cb.groupinfo == NULL)
9520     {
9521     errorcode = ERR21;
9522     cb.erroroffset = 0;
9523     goto HAD_CB_ERROR;
9524     }
9525   }
9526 memset(cb.groupinfo, 0, (cb.bracount + 1) * sizeof(uint32_t));
9527
9528 /* If there were any lookbehinds, scan the parsed pattern to figure out their
9529 lengths. */
9530
9531 if (has_lookbehind)
9532   {
9533   errorcode = check_lookbehinds(&cb);
9534   if (errorcode != 0) goto HAD_CB_ERROR;
9535   }
9536
9537 /* For debugging, there is a function that shows the parsed data vector. */
9538
9539 #ifdef DEBUG_SHOW_PARSED
9540 fprintf(stderr, "+++ Pre-scan complete:\n");
9541 show_parsed(&cb);
9542 #endif
9543
9544 /* For debugging capturing information this code can be enabled. */
9545
9546 #ifdef DEBUG_SHOW_CAPTURES
9547   {
9548   named_group *ng = cb.named_groups;
9549   fprintf(stderr, "+++Captures: %d\n", cb.bracount);
9550   for (i = 0; i < cb.names_found; i++, ng++)
9551     {
9552     fprintf(stderr, "+++%3d %.*s\n", ng->number, ng->length, ng->name);
9553     }
9554   }
9555 #endif
9556
9557 /* Pretend to compile the pattern while actually just accumulating the amount
9558 of memory required in the 'length' variable. This behaviour is triggered by
9559 passing a non-NULL final argument to compile_regex(). We pass a block of
9560 workspace (cworkspace) for it to compile parts of the pattern into; the
9561 compiled code is discarded when it is no longer needed, so hopefully this
9562 workspace will never overflow, though there is a test for its doing so.
9563
9564 On error, errorcode will be set non-zero, so we don't need to look at the
9565 result of the function. The initial options have been put into the cb block,
9566 but we still have to pass a separate options variable (the first argument)
9567 because the options may change as the pattern is processed. */
9568
9569 cb.erroroffset = patlen;   /* For any subsequent errors that do not set it */
9570 pptr = cb.parsed_pattern;
9571 code = cworkspace;
9572 *code = OP_BRA;
9573
9574 (void)compile_regex(cb.external_options, &code, &pptr, &errorcode, 0, &firstcu,
9575    &firstcuflags, &reqcu, &reqcuflags, NULL, &cb, &length);
9576
9577 if (errorcode != 0) goto HAD_CB_ERROR;  /* Offset is in cb.erroroffset */
9578
9579 /* This should be caught in compile_regex(), but just in case... */
9580
9581 if (length > MAX_PATTERN_SIZE)
9582   {
9583   errorcode = ERR20;
9584   goto HAD_CB_ERROR;
9585   }
9586
9587 /* Compute the size of, and then get and initialize, the data block for storing
9588 the compiled pattern and names table. Integer overflow should no longer be
9589 possible because nowadays we limit the maximum value of cb.names_found and
9590 cb.name_entry_size. */
9591
9592 re_blocksize = sizeof(pcre2_real_code) +
9593   CU2BYTES(length +
9594   (PCRE2_SIZE)cb.names_found * (PCRE2_SIZE)cb.name_entry_size);
9595 re = (pcre2_real_code *)
9596   ccontext->memctl.malloc(re_blocksize, ccontext->memctl.memory_data);
9597 if (re == NULL)
9598   {
9599   errorcode = ERR21;
9600   goto HAD_CB_ERROR;
9601   }
9602
9603 /* The compiler may put padding at the end of the pcre2_real_code structure in
9604 order to round it up to a multiple of 4 or 8 bytes. This means that when a
9605 compiled pattern is copied (for example, when serialized) undefined bytes are
9606 read, and this annoys debuggers such as valgrind. To avoid this, we explicitly
9607 write to the last 8 bytes of the structure before setting the fields. */
9608
9609 memset((char *)re + sizeof(pcre2_real_code) - 8, 0, 8);
9610 re->memctl = ccontext->memctl;
9611 re->tables = tables;
9612 re->executable_jit = NULL;
9613 memset(re->start_bitmap, 0, 32 * sizeof(uint8_t));
9614 re->blocksize = re_blocksize;
9615 re->magic_number = MAGIC_NUMBER;
9616 re->compile_options = options;
9617 re->overall_options = cb.external_options;
9618 re->extra_options = ccontext->extra_options;
9619 re->flags = PCRE2_CODE_UNIT_WIDTH/8 | cb.external_flags | setflags;
9620 re->limit_heap = limit_heap;
9621 re->limit_match = limit_match;
9622 re->limit_depth = limit_depth;
9623 re->first_codeunit = 0;
9624 re->last_codeunit = 0;
9625 re->bsr_convention = bsr;
9626 re->newline_convention = newline;
9627 re->max_lookbehind = 0;
9628 re->minlength = 0;
9629 re->top_bracket = 0;
9630 re->top_backref = 0;
9631 re->name_entry_size = cb.name_entry_size;
9632 re->name_count = cb.names_found;
9633
9634 /* The basic block is immediately followed by the name table, and the compiled
9635 code follows after that. */
9636
9637 codestart = (PCRE2_SPTR)((uint8_t *)re + sizeof(pcre2_real_code)) +
9638   re->name_entry_size * re->name_count;
9639
9640 /* Update the compile data block for the actual compile. The starting points of
9641 the name/number translation table and of the code are passed around in the
9642 compile data block. The start/end pattern and initial options are already set
9643 from the pre-compile phase, as is the name_entry_size field. */
9644
9645 cb.parens_depth = 0;
9646 cb.assert_depth = 0;
9647 cb.lastcapture = 0;
9648 cb.name_table = (PCRE2_UCHAR *)((uint8_t *)re + sizeof(pcre2_real_code));
9649 cb.start_code = codestart;
9650 cb.req_varyopt = 0;
9651 cb.had_accept = FALSE;
9652 cb.had_pruneorskip = FALSE;
9653 cb.open_caps = NULL;
9654
9655 /* If any named groups were found, create the name/number table from the list
9656 created in the pre-pass. */
9657
9658 if (cb.names_found > 0)
9659   {
9660   named_group *ng = cb.named_groups;
9661   for (i = 0; i < cb.names_found; i++, ng++)
9662     add_name_to_table(&cb, ng->name, ng->length, ng->number, i);
9663   }
9664
9665 /* Set up a starting, non-extracting bracket, then compile the expression. On
9666 error, errorcode will be set non-zero, so we don't need to look at the result
9667 of the function here. */
9668
9669 pptr = cb.parsed_pattern;
9670 code = (PCRE2_UCHAR *)codestart;
9671 *code = OP_BRA;
9672 regexrc = compile_regex(re->overall_options, &code, &pptr, &errorcode, 0,
9673   &firstcu, &firstcuflags, &reqcu, &reqcuflags, NULL, &cb, NULL);
9674 if (regexrc < 0) re->flags |= PCRE2_MATCH_EMPTY;
9675 re->top_bracket = cb.bracount;
9676 re->top_backref = cb.top_backref;
9677 re->max_lookbehind = cb.max_lookbehind;
9678
9679 if (cb.had_accept)
9680   {
9681   reqcu = 0;              /* Must disable after (*ACCEPT) */
9682   reqcuflags = REQ_NONE;
9683   }
9684
9685 /* Fill in the final opcode and check for disastrous overflow. If no overflow,
9686 but the estimated length exceeds the really used length, adjust the value of
9687 re->blocksize, and if valgrind support is configured, mark the extra allocated
9688 memory as unaddressable, so that any out-of-bound reads can be detected. */
9689
9690 *code++ = OP_END;
9691 usedlength = code - codestart;
9692 if (usedlength > length) errorcode = ERR23; else
9693   {
9694   re->blocksize -= CU2BYTES(length - usedlength);
9695 #ifdef SUPPORT_VALGRIND
9696   VALGRIND_MAKE_MEM_NOACCESS(code, CU2BYTES(length - usedlength));
9697 #endif
9698   }
9699
9700 /* Scan the pattern for recursion/subroutine calls and convert the group
9701 numbers into offsets. Maintain a small cache so that repeated groups containing
9702 recursions are efficiently handled. */
9703
9704 #define RSCAN_CACHE_SIZE 8
9705
9706 if (errorcode == 0 && cb.had_recurse)
9707   {
9708   PCRE2_UCHAR *rcode;
9709   PCRE2_SPTR rgroup;
9710   unsigned int ccount = 0;
9711   int start = RSCAN_CACHE_SIZE;
9712   recurse_cache rc[RSCAN_CACHE_SIZE];
9713
9714   for (rcode = (PCRE2_UCHAR *)find_recurse(codestart, utf);
9715        rcode != NULL;
9716        rcode = (PCRE2_UCHAR *)find_recurse(rcode + 1 + LINK_SIZE, utf))
9717     {
9718     int p, groupnumber;
9719
9720     groupnumber = (int)GET(rcode, 1);
9721     if (groupnumber == 0) rgroup = codestart; else
9722       {
9723       PCRE2_SPTR search_from = codestart;
9724       rgroup = NULL;
9725       for (i = 0, p = start; i < ccount; i++, p = (p + 1) & 7)
9726         {
9727         if (groupnumber == rc[p].groupnumber)
9728           {
9729           rgroup = rc[p].group;
9730           break;
9731           }
9732
9733         /* Group n+1 must always start to the right of group n, so we can save
9734         search time below when the new group number is greater than any of the
9735         previously found groups. */
9736
9737         if (groupnumber > rc[p].groupnumber) search_from = rc[p].group;
9738         }
9739
9740       if (rgroup == NULL)
9741         {
9742         rgroup = PRIV(find_bracket)(search_from, utf, groupnumber);
9743         if (rgroup == NULL)
9744           {
9745           errorcode = ERR53;
9746           break;
9747           }
9748         if (--start < 0) start = RSCAN_CACHE_SIZE - 1;
9749         rc[start].groupnumber = groupnumber;
9750         rc[start].group = rgroup;
9751         if (ccount < RSCAN_CACHE_SIZE) ccount++;
9752         }
9753       }
9754
9755     PUT(rcode, 1, rgroup - codestart);
9756     }
9757   }
9758
9759 /* In rare debugging situations we sometimes need to look at the compiled code
9760 at this stage. */
9761
9762 #ifdef DEBUG_CALL_PRINTINT
9763 pcre2_printint(re, stderr, TRUE);
9764 fprintf(stderr, "Length=%lu Used=%lu\n", length, usedlength);
9765 #endif
9766
9767 /* Unless disabled, check whether any single character iterators can be
9768 auto-possessified. The function overwrites the appropriate opcode values, so
9769 the type of the pointer must be cast. NOTE: the intermediate variable "temp" is
9770 used in this code because at least one compiler gives a warning about loss of
9771 "const" attribute if the cast (PCRE2_UCHAR *)codestart is used directly in the
9772 function call. */
9773
9774 if (errorcode == 0 && (re->overall_options & PCRE2_NO_AUTO_POSSESS) == 0)
9775   {
9776   PCRE2_UCHAR *temp = (PCRE2_UCHAR *)codestart;
9777   if (PRIV(auto_possessify)(temp, utf, &cb) != 0) errorcode = ERR80;
9778   }
9779
9780 /* Failed to compile, or error while post-processing. */
9781
9782 if (errorcode != 0) goto HAD_CB_ERROR;
9783
9784 /* Successful compile. If the anchored option was not passed, set it if
9785 we can determine that the pattern is anchored by virtue of ^ characters or \A
9786 or anything else, such as starting with non-atomic .* when DOTALL is set and
9787 there are no occurrences of *PRUNE or *SKIP (though there is an option to
9788 disable this case). */
9789
9790 if ((re->overall_options & PCRE2_ANCHORED) == 0 &&
9791      is_anchored(codestart, 0, &cb, 0, FALSE))
9792   re->overall_options |= PCRE2_ANCHORED;
9793
9794 /* Set up the first code unit or startline flag, the required code unit, and
9795 then study the pattern. This code need not be obeyed if PCRE2_NO_START_OPTIMIZE
9796 is set, as the data it would create will not be used. Note that a first code
9797 unit (but not the startline flag) is useful for anchored patterns because it
9798 can still give a quick "no match" and also avoid searching for a last code
9799 unit. */
9800
9801 if ((re->overall_options & PCRE2_NO_START_OPTIMIZE) == 0)
9802   {
9803   /* If we do not have a first code unit, see if there is one that is asserted
9804   (these are not saved during the compile because they can cause conflicts with
9805   actual literals that follow). */
9806
9807   if (firstcuflags < 0)
9808     firstcu = find_firstassertedcu(codestart, &firstcuflags, 0);
9809
9810   /* Save the data for a first code unit. */
9811
9812   if (firstcuflags >= 0)
9813     {
9814     re->first_codeunit = firstcu;
9815     re->flags |= PCRE2_FIRSTSET;
9816
9817     /* Handle caseless first code units. */
9818
9819     if ((firstcuflags & REQ_CASELESS) != 0)
9820       {
9821       if (firstcu < 128 || (!utf && firstcu < 255))
9822         {
9823         if (cb.fcc[firstcu] != firstcu) re->flags |= PCRE2_FIRSTCASELESS;
9824         }
9825
9826       /* The first code unit is > 128 in UTF mode, or > 255 otherwise. In
9827       8-bit UTF mode, codepoints in the range 128-255 are introductory code
9828       points and cannot have another case. In 16-bit and 32-bit modes, we can
9829       check wide characters when UTF (and therefore UCP) is supported. */
9830
9831 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 8
9832       else if (firstcu <= MAX_UTF_CODE_POINT &&
9833                UCD_OTHERCASE(firstcu) != firstcu)
9834         re->flags |= PCRE2_FIRSTCASELESS;
9835 #endif
9836       }
9837     }
9838
9839   /* When there is no first code unit, for non-anchored patterns, see if we can
9840   set the PCRE2_STARTLINE flag. This is helpful for multiline matches when all
9841   branches start with ^ and also when all branches start with non-atomic .* for
9842   non-DOTALL matches when *PRUNE and SKIP are not present. (There is an option
9843   that disables this case.) */
9844
9845   else if ((re->overall_options & PCRE2_ANCHORED) == 0 &&
9846            is_startline(codestart, 0, &cb, 0, FALSE))
9847     re->flags |= PCRE2_STARTLINE;
9848
9849   /* Handle the "required code unit", if one is set. In the case of an anchored
9850   pattern, do this only if it follows a variable length item in the pattern. */
9851
9852   if (reqcuflags >= 0 &&
9853        ((re->overall_options & PCRE2_ANCHORED) == 0 ||
9854         (reqcuflags & REQ_VARY) != 0))
9855     {
9856     re->last_codeunit = reqcu;
9857     re->flags |= PCRE2_LASTSET;
9858
9859     /* Handle caseless required code units as for first code units (above). */
9860
9861     if ((reqcuflags & REQ_CASELESS) != 0)
9862       {
9863       if (reqcu < 128 || (!utf && reqcu < 255))
9864         {
9865         if (cb.fcc[reqcu] != reqcu) re->flags |= PCRE2_LASTCASELESS;
9866         }
9867 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 8
9868       else if (reqcu <= MAX_UTF_CODE_POINT && UCD_OTHERCASE(reqcu) != reqcu)
9869         re->flags |= PCRE2_LASTCASELESS;
9870 #endif
9871       }
9872     }
9873
9874   /* Finally, study the compiled pattern to set up information such as a bitmap
9875   of starting code units and a minimum matching length. */
9876
9877   if (PRIV(study)(re) != 0)
9878     {
9879     errorcode = ERR31;
9880     goto HAD_CB_ERROR;
9881     }
9882   }   /* End of start-of-match optimizations. */
9883
9884 /* Control ends up here in all cases. When running under valgrind, make a
9885 pattern's terminating zero defined again. If memory was obtained for the parsed
9886 version of the pattern, free it before returning. Also free the list of named
9887 groups if a larger one had to be obtained, and likewise the group information
9888 vector. */
9889
9890 EXIT:
9891 #ifdef SUPPORT_VALGRIND
9892 if (zero_terminated) VALGRIND_MAKE_MEM_DEFINED(pattern + patlen, CU2BYTES(1));
9893 #endif
9894 if (cb.parsed_pattern != stack_parsed_pattern)
9895   ccontext->memctl.free(cb.parsed_pattern, ccontext->memctl.memory_data);
9896 if (cb.named_group_list_size > NAMED_GROUP_LIST_SIZE)
9897   ccontext->memctl.free((void *)cb.named_groups, ccontext->memctl.memory_data);
9898 if (cb.groupinfo != stack_groupinfo)
9899   ccontext->memctl.free((void *)cb.groupinfo, ccontext->memctl.memory_data);
9900 return re;    /* Will be NULL after an error */
9901
9902 /* Errors discovered in parse_regex() set the offset value in the compile
9903 block. Errors discovered before it is called must compute it from the ptr
9904 value. After parse_regex() is called, the offset in the compile block is set to
9905 the end of the pattern, but certain errors in compile_regex() may reset it if
9906 an offset is available in the parsed pattern. */
9907
9908 HAD_CB_ERROR:
9909 ptr = pattern + cb.erroroffset;
9910
9911 HAD_EARLY_ERROR:
9912 *erroroffset = ptr - pattern;
9913
9914 HAD_ERROR:
9915 *errorptr = errorcode;
9916 pcre2_code_free(re);
9917 re = NULL;
9918 goto EXIT;
9919 }
9920
9921 /* End of pcre2_compile.c */