7ad7b89dc00d5506e6d49fbdb367584ecc22ab83
[WebKit-https.git] / JavaScriptCore / pcre / pcre_compile.c
1 /*************************************************
2 *      Perl-Compatible Regular Expressions       *
3 *************************************************/
4
5 /* PCRE is a library of functions to support regular expressions whose syntax
6 and semantics are as close as possible to those of the Perl 5 language.
7
8                        Written by Philip Hazel
9            Copyright (c) 1997-2005 University of Cambridge
10            Copyright (c) 2004, 2005 Apple Computer, Inc.
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 /* This module contains the external function pcre_compile(), along with
43 supporting internal functions that are not used by other modules. */
44
45
46 #include "pcre_internal.h"
47
48
49 // WARNING: These macros evaluate their parameters more than once.
50 #if PCRE_UTF16
51 #define CTYPES(cd, x) ((x) <= 255 ? (cd)->ctypes[(x)] : 0)
52 #define DIGITAB(x) ((x) <= 255 ? digitab[(x)] : 0)
53 #else
54 #define CTYPES(cd, x) cd->ctypes[(x)]
55 #define DIGITAB(x) digitab[(x)]
56 #endif
57
58
59 /*************************************************
60 *      Code parameters and static tables         *
61 *************************************************/
62
63 /* Maximum number of items on the nested bracket stacks at compile time. This
64 applies to the nesting of all kinds of parentheses. It does not limit
65 un-nested, non-capturing parentheses. This number can be made bigger if
66 necessary - it is used to dimension one int and one unsigned char vector at
67 compile time. */
68
69 #define BRASTACK_SIZE 200
70
71
72 /* Table for handling escaped characters in the range '0'-'z'. Positive returns
73 are simple data values; negative values are for special things like \d and so
74 on. Zero means further processing is needed (for things like \x), or the escape
75 is invalid. */
76
77 #if !EBCDIC   /* This is the "normal" table for ASCII systems */
78 static const short int escapes[] = {
79      0,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
80      0,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
81    '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E,      0, -ESC_G,   /* @ - G */
82      0,      0,      0,      0,      0,      0,      0,      0,   /* H - O */
83 -ESC_P, -ESC_Q,      0, -ESC_S,      0,      0,      0, -ESC_W,   /* P - W */
84 -ESC_X,      0, -ESC_Z,    '[',   '\\',    ']',    '^',    '_',   /* X - _ */
85    '`',      7, -ESC_b,      0, -ESC_d,  ESC_e,  ESC_f,      0,   /* ` - g */
86      0,      0,      0,      0,      0,      0,  ESC_n,      0,   /* h - o */
87 -ESC_p,      0,  ESC_r, -ESC_s,  ESC_tee,    0,      0, -ESC_w,   /* p - w */
88      0,      0, -ESC_z                                            /* x - z */
89 };
90
91 #else         /* This is the "abnormal" table for EBCDIC systems */
92 static const short int escapes[] = {
93 /*  48 */     0,     0,      0,     '.',    '<',   '(',    '+',    '|',
94 /*  50 */   '&',     0,      0,       0,      0,     0,      0,      0,
95 /*  58 */     0,     0,    '!',     '$',    '*',   ')',    ';',    '~',
96 /*  60 */   '-',   '/',      0,       0,      0,     0,      0,      0,
97 /*  68 */     0,     0,    '|',     ',',    '%',   '_',    '>',    '?',
98 /*  70 */     0,     0,      0,       0,      0,     0,      0,      0,
99 /*  78 */     0,   '`',    ':',     '#',    '@',  '\'',    '=',    '"',
100 /*  80 */     0,     7, -ESC_b,       0, -ESC_d, ESC_e,  ESC_f,      0,
101 /*  88 */     0,     0,      0,     '{',      0,     0,      0,      0,
102 /*  90 */     0,     0,      0,     'l',      0, ESC_n,      0, -ESC_p,
103 /*  98 */     0, ESC_r,      0,     '}',      0,     0,      0,      0,
104 /*  A0 */     0,   '~', -ESC_s, ESC_tee,      0,     0, -ESC_w,      0,
105 /*  A8 */     0,-ESC_z,      0,       0,      0,   '[',      0,      0,
106 /*  B0 */     0,     0,      0,       0,      0,     0,      0,      0,
107 /*  B8 */     0,     0,      0,       0,      0,   ']',    '=',    '-',
108 /*  C0 */   '{',-ESC_A, -ESC_B,  -ESC_C, -ESC_D,-ESC_E,      0, -ESC_G,
109 /*  C8 */     0,     0,      0,       0,      0,     0,      0,      0,
110 /*  D0 */   '}',     0,      0,       0,      0,     0,      0, -ESC_P,
111 /*  D8 */-ESC_Q,     0,      0,       0,      0,     0,      0,      0,
112 /*  E0 */  '\\',     0, -ESC_S,       0,      0,     0, -ESC_W, -ESC_X,
113 /*  E8 */     0,-ESC_Z,      0,       0,      0,     0,      0,      0,
114 /*  F0 */     0,     0,      0,       0,      0,     0,      0,      0,
115 /*  F8 */     0,     0,      0,       0,      0,     0,      0,      0
116 };
117 #endif
118
119
120 /* Tables of names of POSIX character classes and their lengths. The list is
121 terminated by a zero length entry. The first three must be alpha, upper, lower,
122 as this is assumed for handling case independence. */
123
124 static const char * const posix_names[] = {
125   "alpha", "lower", "upper",
126   "alnum", "ascii", "blank", "cntrl", "digit", "graph",
127   "print", "punct", "space", "word",  "xdigit" };
128
129 static const uschar posix_name_lengths[] = {
130   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
131
132 /* Table of class bit maps for each POSIX class; up to three may be combined
133 to form the class. The table for [:blank:] is dynamically modified to remove
134 the vertical space characters. */
135
136 static const int posix_class_maps[] = {
137   cbit_lower, cbit_upper, -1,             /* alpha */
138   cbit_lower, -1,         -1,             /* lower */
139   cbit_upper, -1,         -1,             /* upper */
140   cbit_digit, cbit_lower, cbit_upper,     /* alnum */
141   cbit_print, cbit_cntrl, -1,             /* ascii */
142   cbit_space, -1,         -1,             /* blank - a GNU extension */
143   cbit_cntrl, -1,         -1,             /* cntrl */
144   cbit_digit, -1,         -1,             /* digit */
145   cbit_graph, -1,         -1,             /* graph */
146   cbit_print, -1,         -1,             /* print */
147   cbit_punct, -1,         -1,             /* punct */
148   cbit_space, -1,         -1,             /* space */
149   cbit_word,  -1,         -1,             /* word - a Perl extension */
150   cbit_xdigit,-1,         -1              /* xdigit */
151 };
152
153
154 /* The texts of compile-time error messages. These are "char *" because they
155 are passed to the outside world. */
156
157 static const char * const error_texts[] = {
158   "no error",
159   "\\ at end of pattern",
160   "\\c at end of pattern",
161   "unrecognized character follows \\",
162   "numbers out of order in {} quantifier",
163   /* 5 */
164   "number too big in {} quantifier",
165   "missing terminating ] for character class",
166   "invalid escape sequence in character class",
167   "range out of order in character class",
168   "nothing to repeat",
169   /* 10 */
170   "operand of unlimited repeat could match the empty string",
171   "internal error: unexpected repeat",
172   "unrecognized character after (?",
173   "POSIX named classes are supported only within a class",
174   "missing )",
175   /* 15 */
176   "reference to non-existent subpattern",
177   "erroffset passed as NULL",
178   "unknown option bit(s) set",
179   "missing ) after comment",
180   "parentheses nested too deeply",
181   /* 20 */
182   "regular expression too large",
183   "failed to get memory",
184   "unmatched parentheses",
185   "internal error: code overflow",
186   "unrecognized character after (?<",
187   /* 25 */
188   "lookbehind assertion is not fixed length",
189   "malformed number after (?(",
190   "conditional group contains more than two branches",
191   "assertion expected after (?(",
192   "(?R or (?digits must be followed by )",
193   /* 30 */
194   "unknown POSIX class name",
195   "POSIX collating elements are not supported",
196   "this version of PCRE is not compiled with PCRE_UTF8 support",
197   "spare error",
198   "character value in \\x{...} sequence is too large",
199   /* 35 */
200   "invalid condition (?(0)",
201   "\\C not allowed in lookbehind assertion",
202   "PCRE does not support \\L, \\l, \\N, \\U, or \\u",
203   "number after (?C is > 255",
204   "closing ) for (?C expected",
205   /* 40 */
206   "recursive call could loop indefinitely",
207   "unrecognized character after (?P",
208   "syntax error after (?P",
209   "two named groups have the same name",
210 #if PCRE_UTF16
211   "invalid UTF-16 string",
212 #else
213   "invalid UTF-8 string",
214 #endif
215   /* 45 */
216   "support for \\P, \\p, and \\X has not been compiled",
217   "malformed \\P or \\p sequence",
218   "unknown property name after \\P or \\p"
219 };
220
221
222 /* Table to identify digits and hex digits. This is used when compiling
223 patterns. Note that the tables in chartables are dependent on the locale, and
224 may mark arbitrary characters as digits - but the PCRE compiling code expects
225 to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
226 a private table here. It costs 256 bytes, but it is a lot faster than doing
227 character value tests (at least in some simple cases I timed), and in some
228 applications one wants PCRE to compile efficiently as well as match
229 efficiently.
230
231 For convenience, we use the same bit definitions as in chartables:
232
233   0x04   decimal digit
234   0x08   hexadecimal digit
235
236 Then we can use ctype_digit and ctype_xdigit in the code. */
237
238 #if !EBCDIC    /* This is the "normal" case, for ASCII systems */
239 static const unsigned char digitab[] =
240   {
241   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
242   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15 */
243   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
244   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
245   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - '  */
246   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ( - /  */
247   0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  */
248   0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /*  8 - ?  */
249   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  @ - G  */
250   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H - O  */
251   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  P - W  */
252   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  X - _  */
253   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  ` - g  */
254   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h - o  */
255   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  p - w  */
256   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  x -127 */
257   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
258   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
259   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
260   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
261   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
262   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
263   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
264   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
265   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
266   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
267   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
268   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
269   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
270   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
271   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
272   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
273
274 #else          /* This is the "abnormal" case, for EBCDIC systems */
275 static const unsigned char digitab[] =
276   {
277   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7  0 */
278   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15    */
279   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 10 */
280   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31    */
281   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  32- 39 20 */
282   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47    */
283   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 30 */
284   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63    */
285   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 40 */
286   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  72- |     */
287   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 50 */
288   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  88- ¬     */
289   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 60 */
290   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ?     */
291   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
292   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "     */
293   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g  80 */
294   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143    */
295   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p  90 */
296   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159    */
297   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x  A0 */
298   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175    */
299   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 B0 */
300   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191    */
301   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  { - G  C0 */
302   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207    */
303   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  } - P  D0 */
304   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223    */
305   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  \ - X  E0 */
306   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239    */
307   0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  F0 */
308   0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255    */
309
310 static const unsigned char ebcdic_chartab[] = { /* chartable partial dup */
311   0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*   0-  7 */
312   0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */
313   0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  16- 23 */
314   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
315   0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  32- 39 */
316   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47 */
317   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 */
318   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63 */
319   0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 */
320   0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /*  72- |  */
321   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 */
322   0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /*  88- ¬  */
323   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 */
324   0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ?  */
325   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
326   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "  */
327   0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g  */
328   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143 */
329   0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p  */
330   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159 */
331   0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x  */
332   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175 */
333   0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 */
334   0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
335   0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  { - G  */
336   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207 */
337   0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  } - P  */
338   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223 */
339   0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /*  \ - X  */
340   0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239 */
341   0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
342   0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255 */
343 #endif
344
345
346 /* Definition to allow mutual recursion */
347
348 static BOOL
349   compile_regex(int, int, int *, uschar **, const pcre_uchar **, int *, BOOL, int,
350     int *, int *, branch_chain *, compile_data *);
351
352
353
354 /*************************************************
355 *            Handle escapes                      *
356 *************************************************/
357
358 /* This function is called when a \ has been encountered. It either returns a
359 positive value for a simple escape such as \n, or a negative value which
360 encodes one of the more complicated things such as \d. When UTF-8 is enabled,
361 a positive value greater than 255 may be returned. On entry, ptr is pointing at
362 the \. On exit, it is on the final character of the escape sequence.
363
364 Arguments:
365   ptrptr         points to the pattern position pointer
366   errorcodeptr   points to the errorcode variable
367   bracount       number of previous extracting brackets
368   options        the options bits
369   isclass        TRUE if inside a character class
370
371 Returns:         zero or positive => a data character
372                  negative => a special escape sequence
373                  on error, errorptr is set
374 */
375
376 static int
377 check_escape(const pcre_uchar **ptrptr, int *errorcodeptr, int bracount,
378   int options, BOOL isclass)
379 {
380 const pcre_uchar *ptr = *ptrptr;
381 int c, i;
382
383 /* If backslash is at the end of the pattern, it's an error. */
384
385 c = *(++ptr);
386 if (c == 0) *errorcodeptr = ERR1;
387
388 /* Non-alphamerics are literals. For digits or letters, do an initial lookup in
389 a table. A non-zero result is something that can be returned immediately.
390 Otherwise further processing may be required. */
391
392 #if !EBCDIC    /* ASCII coding */
393 else if (c < '0' || c > 'z') {}                           /* Not alphameric */
394 else if ((i = escapes[c - '0']) != 0) c = i;
395
396 #else          /* EBCDIC coding */
397 else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphameric */
398 else if ((i = escapes[c - 0x48]) != 0)  c = i;
399 #endif
400
401 /* Escapes that need further processing, or are illegal. */
402
403 else
404   {
405   const pcre_uchar *oldptr;
406   switch (c)
407     {
408     /* A number of Perl escapes are not handled by PCRE. We give an explicit
409     error. */
410
411     case 'l':
412     case 'L':
413     case 'N':
414     case 'u':
415     case 'U':
416     *errorcodeptr = ERR37;
417     break;
418
419     /* The handling of escape sequences consisting of a string of digits
420     starting with one that is not zero is not straightforward. By experiment,
421     the way Perl works seems to be as follows:
422
423     Outside a character class, the digits are read as a decimal number. If the
424     number is less than 10, or if there are that many previous extracting
425     left brackets, then it is a back reference. Otherwise, up to three octal
426     digits are read to form an escaped byte. Thus \123 is likely to be octal
427     123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
428     value is greater than 377, the least significant 8 bits are taken. Inside a
429     character class, \ followed by a digit is always an octal number. */
430
431     case '1': case '2': case '3': case '4': case '5':
432     case '6': case '7': case '8': case '9':
433
434     if (!isclass)
435       {
436       oldptr = ptr;
437       c -= '0';
438       while ((DIGITAB(ptr[1]) & ctype_digit) != 0)
439         c = c * 10 + *(++ptr) - '0';
440       if (c < 10 || c <= bracount)
441         {
442         c = -(ESC_REF + c);
443         break;
444         }
445       ptr = oldptr;      /* Put the pointer back and fall through */
446       }
447
448     /* Handle an octal number following \. If the first digit is 8 or 9, Perl
449     generates a binary zero byte and treats the digit as a following literal.
450     Thus we have to pull back the pointer by one. */
451
452     if ((c = *ptr) >= '8')
453       {
454       ptr--;
455       c = 0;
456       break;
457       }
458
459     /* \0 always starts an octal number, but we may drop through to here with a
460     larger first octal digit. */
461
462     case '0':
463     c -= '0';
464     while(i++ < 2 && ptr[1] >= '0' && ptr[1] <= '7')
465         c = c * 8 + *(++ptr) - '0';
466     c &= 255;     /* Take least significant 8 bits */
467     break;
468
469     /* \x is complicated when UTF-8 is enabled. \x{ddd} is a character number
470     which can be greater than 0xff, but only if the ddd are hex digits. */
471
472     case 'x':
473 #ifdef SUPPORT_UTF8
474     if (ptr[1] == '{' && (options & PCRE_UTF8) != 0)
475       {
476       const pcre_uchar *pt = ptr + 2;
477       register int count = 0;
478       c = 0;
479       while ((DIGITAB(*pt) & ctype_xdigit) != 0)
480         {
481         int cc = *pt++;
482         count++;
483 #if !EBCDIC    /* ASCII coding */
484         if (cc >= 'a') cc -= 32;               /* Convert to upper case */
485         c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
486 #else          /* EBCDIC coding */
487         if (cc >= 'a' && cc <= 'z') cc += 64;  /* Convert to upper case */
488         c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
489 #endif
490         }
491       if (*pt == '}')
492         {
493         if (c < 0 || count > 8 || (c >= 0xd800 && c <= 0xdbff) || (c >= 0xfdd0 && c <= 0xfdef) || c == 0xfffe || c == 0xffff || c > 0x10FFFF) *errorcodeptr = ERR34;
494         ptr = pt;
495         break;
496         }
497       /* If the sequence of hex digits does not end with '}', then we don't
498       recognize this construct; fall through to the normal \x handling. */
499       }
500 #endif
501
502     /* Read just a single hex char */
503
504     c = 0;
505     while (i++ < 2 && (DIGITAB(ptr[1]) & ctype_xdigit) != 0)
506       {
507       int cc;                               /* Some compilers don't like ++ */
508       cc = *(++ptr);                        /* in initializers */
509 #if !EBCDIC    /* ASCII coding */
510       if (cc >= 'a') cc -= 32;              /* Convert to upper case */
511       c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
512 #else          /* EBCDIC coding */
513       if (cc <= 'z') cc += 64;              /* Convert to upper case */
514       c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
515 #endif
516       }
517     break;
518
519     /* Other special escapes not starting with a digit are straightforward */
520
521     case 'c':
522     c = *(++ptr);
523     if (c == 0)
524       {
525       *errorcodeptr = ERR2;
526       return 0;
527       }
528
529     /* A letter is upper-cased; then the 0x40 bit is flipped. This coding
530     is ASCII-specific, but then the whole concept of \cx is ASCII-specific.
531     (However, an EBCDIC equivalent has now been added.) */
532
533 #if !EBCDIC    /* ASCII coding */
534     if (c >= 'a' && c <= 'z') c -= 32;
535     c ^= 0x40;
536 #else          /* EBCDIC coding */
537     if (c >= 'a' && c <= 'z') c += 64;
538     c ^= 0xC0;
539 #endif
540     break;
541
542     /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
543     other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
544     for Perl compatibility, it is a literal. This code looks a bit odd, but
545     there used to be some cases other than the default, and there may be again
546     in future, so I haven't "optimized" it. */
547
548     default:
549     if ((options & PCRE_EXTRA) != 0) switch(c)
550       {
551       default:
552       *errorcodeptr = ERR3;
553       break;
554       }
555     break;
556     }
557   }
558
559 *ptrptr = ptr;
560 return c;
561 }
562
563
564
565 #ifdef SUPPORT_UCP
566 /*************************************************
567 *               Handle \P and \p                 *
568 *************************************************/
569
570 /* This function is called after \P or \p has been encountered, provided that
571 PCRE is compiled with support for Unicode properties. On entry, ptrptr is
572 pointing at the P or p. On exit, it is pointing at the final character of the
573 escape sequence.
574
575 Argument:
576   ptrptr         points to the pattern position pointer
577   negptr         points to a boolean that is set TRUE for negation else FALSE
578   errorcodeptr   points to the error code variable
579
580 Returns:     value from ucp_type_table, or -1 for an invalid type
581 */
582
583 static int
584 get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, int *errorcodeptr)
585 {
586 int c, i, bot, top;
587 const pcre_uchar *ptr = *ptrptr;
588 char name[4];
589
590 c = *(++ptr);
591 if (c == 0) goto ERROR_RETURN;
592
593 *negptr = FALSE;
594
595 /* \P or \p can be followed by a one- or two-character name in {}, optionally
596 preceded by ^ for negation. */
597
598 if (c == '{')
599   {
600   if (ptr[1] == '^')
601     {
602     *negptr = TRUE;
603     ptr++;
604     }
605   for (i = 0; i <= 2; i++)
606     {
607     c = *(++ptr);
608     if (c == 0) goto ERROR_RETURN;
609     if (c == '}') break;
610     if (c > 127) goto ERROR_RETURN;
611     name[i] = c;
612     }
613   if (c !='}')   /* Try to distinguish error cases */
614     {
615     while (*(++ptr) != 0 && *ptr != '}');
616     if (*ptr == '}') goto UNKNOWN_RETURN; else goto ERROR_RETURN;
617     }
618   name[i] = 0;
619   }
620
621 /* Otherwise there is just one following character */
622
623 else
624   {
625   if (c > 127) goto ERROR_RETURN;
626   name[0] = c;
627   name[1] = 0;
628   }
629
630 *ptrptr = ptr;
631
632 /* Search for a recognized property name using binary chop */
633
634 bot = 0;
635 top = _pcre_utt_size;
636
637 while (bot < top)
638   {
639   i = (bot + top)/2;
640   c = strcmp(name, _pcre_utt[i].name);
641   if (c == 0) return _pcre_utt[i].value;
642   if (c > 0) bot = i + 1; else top = i;
643   }
644
645 UNKNOWN_RETURN:
646 *errorcodeptr = ERR47;
647 *ptrptr = ptr;
648 return -1;
649
650 ERROR_RETURN:
651 *errorcodeptr = ERR46;
652 *ptrptr = ptr;
653 return -1;
654 }
655 #endif
656
657
658
659
660 /*************************************************
661 *            Check for counted repeat            *
662 *************************************************/
663
664 /* This function is called when a '{' is encountered in a place where it might
665 start a quantifier. It looks ahead to see if it really is a quantifier or not.
666 It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
667 where the ddds are digits.
668
669 Arguments:
670   p         pointer to the first char after '{'
671
672 Returns:    TRUE or FALSE
673 */
674
675 static BOOL
676 is_counted_repeat(const pcre_uchar *p)
677 {
678 if ((DIGITAB(*p) & ctype_digit) == 0) return FALSE;
679 p++;
680 while ((DIGITAB(*p) & ctype_digit) != 0) p++;
681 if (*p == '}') return TRUE;
682
683 if (*p++ != ',') return FALSE;
684 if (*p == '}') return TRUE;
685
686 if ((DIGITAB(*p) & ctype_digit) == 0) return FALSE;
687 p++;
688 while ((DIGITAB(*p) & ctype_digit) != 0) p++;
689
690 return (*p == '}');
691 }
692
693
694
695 /*************************************************
696 *         Read repeat counts                     *
697 *************************************************/
698
699 /* Read an item of the form {n,m} and return the values. This is called only
700 after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
701 so the syntax is guaranteed to be correct, but we need to check the values.
702
703 Arguments:
704   p              pointer to first char after '{'
705   minp           pointer to int for min
706   maxp           pointer to int for max
707                  returned as -1 if no max
708   errorcodeptr   points to error code variable
709
710 Returns:         pointer to '}' on success;
711                  current ptr on error, with errorcodeptr set non-zero
712 */
713
714 static const pcre_uchar *
715 read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, int *errorcodeptr)
716 {
717 int min = 0;
718 int max = -1;
719
720 while ((DIGITAB(*p) & ctype_digit) != 0) min = min * 10 + *p++ - '0';
721
722 if (*p == '}') max = min; else
723   {
724   if (*(++p) != '}')
725     {
726     max = 0;
727     while((DIGITAB(*p) & ctype_digit) != 0) max = max * 10 + *p++ - '0';
728     if (max < min)
729       {
730       *errorcodeptr = ERR4;
731       return p;
732       }
733     }
734   }
735
736 /* Do paranoid checks, then fill in the required variables, and pass back the
737 pointer to the terminating '}'. */
738
739 if (min > 65535 || max > 65535)
740   *errorcodeptr = ERR5;
741 else
742   {
743   *minp = min;
744   *maxp = max;
745   }
746 return p;
747 }
748
749
750
751 /*************************************************
752 *      Find first significant op code            *
753 *************************************************/
754
755 /* This is called by several functions that scan a compiled expression looking
756 for a fixed first character, or an anchoring op code etc. It skips over things
757 that do not influence this. For some calls, a change of option is important.
758 For some calls, it makes sense to skip negative forward and all backward
759 assertions, and also the \b assertion; for others it does not.
760
761 Arguments:
762   code         pointer to the start of the group
763   options      pointer to external options
764   optbit       the option bit whose changing is significant, or
765                  zero if none are
766   skipassert   TRUE if certain assertions are to be skipped
767
768 Returns:       pointer to the first significant opcode
769 */
770
771 static const uschar*
772 first_significant_code(const uschar *code, int *options, int optbit,
773   BOOL skipassert)
774 {
775 for (;;)
776   {
777   switch ((int)*code)
778     {
779     case OP_OPT:
780     if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))
781       *options = (int)code[1];
782     code += 2;
783     break;
784
785     case OP_ASSERT_NOT:
786     case OP_ASSERTBACK:
787     case OP_ASSERTBACK_NOT:
788     if (!skipassert) return code;
789     do code += GET(code, 1); while (*code == OP_ALT);
790     code += _pcre_OP_lengths[*code];
791     break;
792
793     case OP_WORD_BOUNDARY:
794     case OP_NOT_WORD_BOUNDARY:
795     if (!skipassert) return code;
796     /* Fall through */
797
798     case OP_CALLOUT:
799     case OP_CREF:
800     case OP_BRANUMBER:
801     code += _pcre_OP_lengths[*code];
802     break;
803
804     default:
805     return code;
806     }
807   }
808 /* Control never reaches here */
809 }
810
811
812
813
814 /*************************************************
815 *        Find the fixed length of a pattern      *
816 *************************************************/
817
818 /* Scan a pattern and compute the fixed length of subject that will match it,
819 if the length is fixed. This is needed for dealing with backward assertions.
820 In UTF8 mode, the result is in characters rather than bytes.
821
822 Arguments:
823   code     points to the start of the pattern (the bracket)
824   options  the compiling options
825
826 Returns:   the fixed length, or -1 if there is no fixed length,
827              or -2 if \C was encountered
828 */
829
830 static int
831 find_fixedlength(uschar *code, int options)
832 {
833 int length = -1;
834
835 register int branchlength = 0;
836 register uschar *cc = code + 1 + LINK_SIZE;
837
838 /* Scan along the opcodes for this branch. If we get to the end of the
839 branch, check the length against that of the other branches. */
840
841 for (;;)
842   {
843   int d;
844   register int op = *cc;
845   if (op >= OP_BRA) op = OP_BRA;
846
847   switch (op)
848     {
849     case OP_BRA:
850     case OP_ONCE:
851     case OP_COND:
852     d = find_fixedlength(cc, options);
853     if (d < 0) return d;
854     branchlength += d;
855     do cc += GET(cc, 1); while (*cc == OP_ALT);
856     cc += 1 + LINK_SIZE;
857     break;
858
859     /* Reached end of a branch; if it's a ket it is the end of a nested
860     call. If it's ALT it is an alternation in a nested call. If it is
861     END it's the end of the outer call. All can be handled by the same code. */
862
863     case OP_ALT:
864     case OP_KET:
865     case OP_KETRMAX:
866     case OP_KETRMIN:
867     case OP_END:
868     if (length < 0) length = branchlength;
869       else if (length != branchlength) return -1;
870     if (*cc != OP_ALT) return length;
871     cc += 1 + LINK_SIZE;
872     branchlength = 0;
873     break;
874
875     /* Skip over assertive subpatterns */
876
877     case OP_ASSERT:
878     case OP_ASSERT_NOT:
879     case OP_ASSERTBACK:
880     case OP_ASSERTBACK_NOT:
881     do cc += GET(cc, 1); while (*cc == OP_ALT);
882     /* Fall through */
883
884     /* Skip over things that don't match chars */
885
886     case OP_REVERSE:
887     case OP_BRANUMBER:
888     case OP_CREF:
889     case OP_OPT:
890     case OP_CALLOUT:
891     case OP_SOD:
892     case OP_SOM:
893     case OP_EOD:
894     case OP_EODN:
895     case OP_CIRC:
896     case OP_DOLL:
897     case OP_NOT_WORD_BOUNDARY:
898     case OP_WORD_BOUNDARY:
899     cc += _pcre_OP_lengths[*cc];
900     break;
901
902     /* Handle literal characters */
903
904     case OP_CHAR:
905     case OP_CHARNC:
906     branchlength++;
907     cc += 2;
908 #ifdef SUPPORT_UTF8
909     if ((options & PCRE_UTF8) != 0)
910       {
911       while ((*cc & 0xc0) == 0x80) cc++;
912       }
913 #endif
914     break;
915
916     /* Handle exact repetitions. The count is already in characters, but we
917     need to skip over a multibyte character in UTF8 mode.  */
918
919     case OP_EXACT:
920     branchlength += GET2(cc,1);
921     cc += 4;
922 #ifdef SUPPORT_UTF8
923     if ((options & PCRE_UTF8) != 0)
924       {
925       while((*cc & 0x80) == 0x80) cc++;
926       }
927 #endif
928     break;
929
930     case OP_TYPEEXACT:
931     branchlength += GET2(cc,1);
932     cc += 4;
933     break;
934
935     /* Handle single-char matchers */
936
937     case OP_PROP:
938     case OP_NOTPROP:
939     cc++;
940     /* Fall through */
941
942     case OP_NOT_DIGIT:
943     case OP_DIGIT:
944     case OP_NOT_WHITESPACE:
945     case OP_WHITESPACE:
946     case OP_NOT_WORDCHAR:
947     case OP_WORDCHAR:
948     case OP_ANY:
949     branchlength++;
950     cc++;
951     break;
952
953     /* The single-byte matcher isn't allowed */
954
955     case OP_ANYBYTE:
956     return -2;
957
958     /* Check a class for variable quantification */
959
960 #ifdef SUPPORT_UTF8
961     case OP_XCLASS:
962     cc += GET(cc, 1) - 33;
963     /* Fall through */
964 #endif
965
966     case OP_CLASS:
967     case OP_NCLASS:
968     cc += 33;
969
970     switch (*cc)
971       {
972       case OP_CRSTAR:
973       case OP_CRMINSTAR:
974       case OP_CRQUERY:
975       case OP_CRMINQUERY:
976       return -1;
977
978       case OP_CRRANGE:
979       case OP_CRMINRANGE:
980       if (GET2(cc,1) != GET2(cc,3)) return -1;
981       branchlength += GET2(cc,1);
982       cc += 5;
983       break;
984
985       default:
986       branchlength++;
987       }
988     break;
989
990     /* Anything else is variable length */
991
992     default:
993     return -1;
994     }
995   }
996 /* Control never gets here */
997 }
998
999
1000
1001
1002 /*************************************************
1003 *    Scan compiled regex for numbered bracket    *
1004 *************************************************/
1005
1006 /* This little function scans through a compiled pattern until it finds a
1007 capturing bracket with the given number.
1008
1009 Arguments:
1010   code        points to start of expression
1011   utf8        TRUE in UTF-8 mode
1012   number      the required bracket number
1013
1014 Returns:      pointer to the opcode for the bracket, or NULL if not found
1015 */
1016
1017 static const uschar *
1018 find_bracket(const uschar *code, BOOL utf8, int number)
1019 {
1020 #ifndef SUPPORT_UTF8
1021 utf8 = utf8;               /* Stop pedantic compilers complaining */
1022 #endif
1023
1024 for (;;)
1025   {
1026   register int c = *code;
1027   if (c == OP_END) return NULL;
1028   else if (c > OP_BRA)
1029     {
1030     int n = c - OP_BRA;
1031     if (n > EXTRACT_BASIC_MAX) n = GET2(code, 2+LINK_SIZE);
1032     if (n == number) return (uschar *)code;
1033     code += _pcre_OP_lengths[OP_BRA];
1034     }
1035   else
1036     {
1037     code += _pcre_OP_lengths[c];
1038
1039 #ifdef SUPPORT_UTF8
1040
1041     /* In UTF-8 mode, opcodes that are followed by a character may be followed
1042     by a multi-byte character. The length in the table is a minimum, so we have
1043     to scan along to skip the extra bytes. All opcodes are less than 128, so we
1044     can use relatively efficient code. */
1045
1046     if (utf8) switch(c)
1047       {
1048       case OP_CHAR:
1049       case OP_CHARNC:
1050       case OP_EXACT:
1051       case OP_UPTO:
1052       case OP_MINUPTO:
1053       case OP_STAR:
1054       case OP_MINSTAR:
1055       case OP_PLUS:
1056       case OP_MINPLUS:
1057       case OP_QUERY:
1058       case OP_MINQUERY:
1059       while ((*code & 0xc0) == 0x80) code++;
1060       break;
1061
1062       /* XCLASS is used for classes that cannot be represented just by a bit
1063       map. This includes negated single high-valued characters. The length in
1064       the table is zero; the actual length is stored in the compiled code. */
1065
1066       case OP_XCLASS:
1067       code += GET(code, 1) + 1;
1068       break;
1069       }
1070 #endif
1071     }
1072   }
1073 }
1074
1075
1076
1077 /*************************************************
1078 *   Scan compiled regex for recursion reference  *
1079 *************************************************/
1080
1081 /* This little function scans through a compiled pattern until it finds an
1082 instance of OP_RECURSE.
1083
1084 Arguments:
1085   code        points to start of expression
1086   utf8        TRUE in UTF-8 mode
1087
1088 Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
1089 */
1090
1091 static const uschar *
1092 find_recurse(const uschar *code, BOOL utf8)
1093 {
1094 #ifndef SUPPORT_UTF8
1095 utf8 = utf8;               /* Stop pedantic compilers complaining */
1096 #endif
1097
1098 for (;;)
1099   {
1100   register int c = *code;
1101   if (c == OP_END) return NULL;
1102   else if (c == OP_RECURSE) return code;
1103   else if (c > OP_BRA)
1104     {
1105     code += _pcre_OP_lengths[OP_BRA];
1106     }
1107   else
1108     {
1109     code += _pcre_OP_lengths[c];
1110
1111 #ifdef SUPPORT_UTF8
1112
1113     /* In UTF-8 mode, opcodes that are followed by a character may be followed
1114     by a multi-byte character. The length in the table is a minimum, so we have
1115     to scan along to skip the extra bytes. All opcodes are less than 128, so we
1116     can use relatively efficient code. */
1117
1118     if (utf8) switch(c)
1119       {
1120       case OP_CHAR:
1121       case OP_CHARNC:
1122       case OP_EXACT:
1123       case OP_UPTO:
1124       case OP_MINUPTO:
1125       case OP_STAR:
1126       case OP_MINSTAR:
1127       case OP_PLUS:
1128       case OP_MINPLUS:
1129       case OP_QUERY:
1130       case OP_MINQUERY:
1131       while ((*code & 0xc0) == 0x80) code++;
1132       break;
1133
1134       /* XCLASS is used for classes that cannot be represented just by a bit
1135       map. This includes negated single high-valued characters. The length in
1136       the table is zero; the actual length is stored in the compiled code. */
1137
1138       case OP_XCLASS:
1139       code += GET(code, 1) + 1;
1140       break;
1141       }
1142 #endif
1143     }
1144   }
1145 }
1146
1147
1148
1149 /*************************************************
1150 *    Scan compiled branch for non-emptiness      *
1151 *************************************************/
1152
1153 /* This function scans through a branch of a compiled pattern to see whether it
1154 can match the empty string or not. It is called only from could_be_empty()
1155 below. Note that first_significant_code() skips over assertions. If we hit an
1156 unclosed bracket, we return "empty" - this means we've struck an inner bracket
1157 whose current branch will already have been scanned.
1158
1159 Arguments:
1160   code        points to start of search
1161   endcode     points to where to stop
1162   utf8        TRUE if in UTF8 mode
1163
1164 Returns:      TRUE if what is matched could be empty
1165 */
1166
1167 static BOOL
1168 could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8)
1169 {
1170 register int c;
1171 for (code = first_significant_code(code + 1 + LINK_SIZE, NULL, 0, TRUE);
1172      code < endcode;
1173      code = first_significant_code(code + _pcre_OP_lengths[c], NULL, 0, TRUE))
1174   {
1175   const uschar *ccode;
1176
1177   c = *code;
1178
1179   if (c >= OP_BRA)
1180     {
1181     BOOL empty_branch;
1182     if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
1183
1184     /* Scan a closed bracket */
1185
1186     empty_branch = FALSE;
1187     do
1188       {
1189       if (!empty_branch && could_be_empty_branch(code, endcode, utf8))
1190         empty_branch = TRUE;
1191       code += GET(code, 1);
1192       }
1193     while (*code == OP_ALT);
1194     if (!empty_branch) return FALSE;   /* All branches are non-empty */
1195     code += 1 + LINK_SIZE;
1196     c = *code;
1197     }
1198
1199   else switch (c)
1200     {
1201     /* Check for quantifiers after a class */
1202
1203 #ifdef SUPPORT_UTF8
1204     case OP_XCLASS:
1205     ccode = code + GET(code, 1);
1206     goto CHECK_CLASS_REPEAT;
1207 #endif
1208
1209     case OP_CLASS:
1210     case OP_NCLASS:
1211     ccode = code + 33;
1212
1213 #ifdef SUPPORT_UTF8
1214     CHECK_CLASS_REPEAT:
1215 #endif
1216
1217     switch (*ccode)
1218       {
1219       case OP_CRSTAR:            /* These could be empty; continue */
1220       case OP_CRMINSTAR:
1221       case OP_CRQUERY:
1222       case OP_CRMINQUERY:
1223       break;
1224
1225       default:                   /* Non-repeat => class must match */
1226       case OP_CRPLUS:            /* These repeats aren't empty */
1227       case OP_CRMINPLUS:
1228       return FALSE;
1229
1230       case OP_CRRANGE:
1231       case OP_CRMINRANGE:
1232       if (GET2(ccode, 1) > 0) return FALSE;  /* Minimum > 0 */
1233       break;
1234       }
1235     break;
1236
1237     /* Opcodes that must match a character */
1238
1239     case OP_PROP:
1240     case OP_NOTPROP:
1241     case OP_EXTUNI:
1242     case OP_NOT_DIGIT:
1243     case OP_DIGIT:
1244     case OP_NOT_WHITESPACE:
1245     case OP_WHITESPACE:
1246     case OP_NOT_WORDCHAR:
1247     case OP_WORDCHAR:
1248     case OP_ANY:
1249     case OP_ANYBYTE:
1250     case OP_CHAR:
1251     case OP_CHARNC:
1252     case OP_NOT:
1253     case OP_PLUS:
1254     case OP_MINPLUS:
1255     case OP_EXACT:
1256     case OP_NOTPLUS:
1257     case OP_NOTMINPLUS:
1258     case OP_NOTEXACT:
1259     case OP_TYPEPLUS:
1260     case OP_TYPEMINPLUS:
1261     case OP_TYPEEXACT:
1262     return FALSE;
1263
1264     /* End of branch */
1265
1266     case OP_KET:
1267     case OP_KETRMAX:
1268     case OP_KETRMIN:
1269     case OP_ALT:
1270     return TRUE;
1271
1272     /* In UTF-8 mode, STAR, MINSTAR, QUERY, MINQUERY, UPTO, and MINUPTO  may be
1273     followed by a multibyte character */
1274
1275 #ifdef SUPPORT_UTF8
1276     case OP_STAR:
1277     case OP_MINSTAR:
1278     case OP_QUERY:
1279     case OP_MINQUERY:
1280     case OP_UPTO:
1281     case OP_MINUPTO:
1282     if (utf8) while ((code[2] & 0xc0) == 0x80) code++;
1283     break;
1284 #endif
1285     }
1286   }
1287
1288 return TRUE;
1289 }
1290
1291
1292
1293 /*************************************************
1294 *    Scan compiled regex for non-emptiness       *
1295 *************************************************/
1296
1297 /* This function is called to check for left recursive calls. We want to check
1298 the current branch of the current pattern to see if it could match the empty
1299 string. If it could, we must look outwards for branches at other levels,
1300 stopping when we pass beyond the bracket which is the subject of the recursion.
1301
1302 Arguments:
1303   code        points to start of the recursion
1304   endcode     points to where to stop (current RECURSE item)
1305   bcptr       points to the chain of current (unclosed) branch starts
1306   utf8        TRUE if in UTF-8 mode
1307
1308 Returns:      TRUE if what is matched could be empty
1309 */
1310
1311 static BOOL
1312 could_be_empty(const uschar *code, const uschar *endcode, branch_chain *bcptr,
1313   BOOL utf8)
1314 {
1315 while (bcptr != NULL && bcptr->current >= code)
1316   {
1317   if (!could_be_empty_branch(bcptr->current, endcode, utf8)) return FALSE;
1318   bcptr = bcptr->outer;
1319   }
1320 return TRUE;
1321 }
1322
1323
1324
1325 /*************************************************
1326 *           Check for POSIX class syntax         *
1327 *************************************************/
1328
1329 /* This function is called when the sequence "[:" or "[." or "[=" is
1330 encountered in a character class. It checks whether this is followed by an
1331 optional ^ and then a sequence of letters, terminated by a matching ":]" or
1332 ".]" or "=]".
1333
1334 Argument:
1335   ptr      pointer to the initial [
1336   endptr   where to return the end pointer
1337   cd       pointer to compile data
1338
1339 Returns:   TRUE or FALSE
1340 */
1341
1342 static BOOL
1343 check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr, compile_data *cd)
1344 {
1345 int terminator;          /* Don't combine these lines; the Solaris cc */
1346 terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
1347 if (*(++ptr) == '^') ptr++;
1348 while ((CTYPES(cd, *ptr) & ctype_letter) != 0) ptr++;
1349 if (*ptr == terminator && ptr[1] == ']')
1350   {
1351   *endptr = ptr;
1352   return TRUE;
1353   }
1354 return FALSE;
1355 }
1356
1357 #if PCRE_UTF16
1358
1359 static __inline BOOL strequal(const pcre_uchar *str1, int len, const char *str2)
1360 {
1361   int i;
1362   for (i = 0; i < len; i++)
1363     if (str1[i] != str2[i])
1364       return FALSE;
1365   return TRUE;
1366 }
1367
1368 #define STREQUAL(str1, len, str2) strequal((str1), (len), (str2))
1369
1370 #else
1371
1372 #define STREQUAL(str1, len, str2) (strncmp((const char *)(str1), (str2), (len)) == 0)
1373
1374 #endif
1375
1376 /*************************************************
1377 *          Check POSIX class name                *
1378 *************************************************/
1379
1380 /* This function is called to check the name given in a POSIX-style class entry
1381 such as [:alnum:].
1382
1383 Arguments:
1384   ptr        points to the first letter
1385   len        the length of the name
1386
1387 Returns:     a value representing the name, or -1 if unknown
1388 */
1389
1390 static int
1391 check_posix_name(const pcre_uchar *ptr, int len)
1392 {
1393 register int yield = 0;
1394 while (posix_name_lengths[yield] != 0)
1395   {
1396   if (len == posix_name_lengths[yield] &&
1397     STREQUAL(ptr, len, posix_names[yield])) return yield;
1398   yield++;
1399   }
1400 return -1;
1401 }
1402
1403
1404 /*************************************************
1405 *    Adjust OP_RECURSE items in repeated group   *
1406 *************************************************/
1407
1408 /* OP_RECURSE items contain an offset from the start of the regex to the group
1409 that is referenced. This means that groups can be replicated for fixed
1410 repetition simply by copying (because the recursion is allowed to refer to
1411 earlier groups that are outside the current group). However, when a group is
1412 optional (i.e. the minimum quantifier is zero), OP_BRAZERO is inserted before
1413 it, after it has been compiled. This means that any OP_RECURSE items within it
1414 that refer to the group itself or any contained groups have to have their
1415 offsets adjusted. That is the job of this function. Before it is called, the
1416 partially compiled regex must be temporarily terminated with OP_END.
1417
1418 Arguments:
1419   group      points to the start of the group
1420   adjust     the amount by which the group is to be moved
1421   utf8       TRUE in UTF-8 mode
1422   cd         contains pointers to tables etc.
1423
1424 Returns:     nothing
1425 */
1426
1427 static void
1428 adjust_recurse(uschar *group, int adjust, BOOL utf8, compile_data *cd)
1429 {
1430 uschar *ptr = group;
1431 while ((ptr = (uschar *)find_recurse(ptr, utf8)) != NULL)
1432   {
1433   int offset = GET(ptr, 1);
1434   if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
1435   ptr += 1 + LINK_SIZE;
1436   }
1437 }
1438
1439
1440
1441 /*************************************************
1442 *        Insert an automatic callout point       *
1443 *************************************************/
1444
1445 /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
1446 callout points before each pattern item.
1447
1448 Arguments:
1449   code           current code pointer
1450   ptr            current pattern pointer
1451   cd             pointers to tables etc
1452
1453 Returns:         new code pointer
1454 */
1455
1456 static uschar *
1457 auto_callout(uschar *code, const pcre_uchar *ptr, compile_data *cd)
1458 {
1459 *code++ = OP_CALLOUT;
1460 *code++ = 255;
1461 PUT(code, 0, ptr - cd->start_pattern);  /* Pattern offset */
1462 PUT(code, LINK_SIZE, 0);                /* Default length */
1463 return code + 2*LINK_SIZE;
1464 }
1465
1466
1467
1468 /*************************************************
1469 *         Complete a callout item                *
1470 *************************************************/
1471
1472 /* A callout item contains the length of the next item in the pattern, which
1473 we can't fill in till after we have reached the relevant point. This is used
1474 for both automatic and manual callouts.
1475
1476 Arguments:
1477   previous_callout   points to previous callout item
1478   ptr                current pattern pointer
1479   cd                 pointers to tables etc
1480
1481 Returns:             nothing
1482 */
1483
1484 static void
1485 complete_callout(uschar *previous_callout, const pcre_uchar *ptr, compile_data *cd)
1486 {
1487 int length = ptr - cd->start_pattern - GET(previous_callout, 2);
1488 PUT(previous_callout, 2 + LINK_SIZE, length);
1489 }
1490
1491
1492
1493 #ifdef SUPPORT_UCP
1494 /*************************************************
1495 *           Get othercase range                  *
1496 *************************************************/
1497
1498 /* This function is passed the start and end of a class range, in UTF-8 mode
1499 with UCP support. It searches up the characters, looking for internal ranges of
1500 characters in the "other" case. Each call returns the next one, updating the
1501 start address.
1502
1503 Arguments:
1504   cptr        points to starting character value; updated
1505   d           end value
1506   ocptr       where to put start of othercase range
1507   odptr       where to put end of othercase range
1508
1509 Yield:        TRUE when range returned; FALSE when no more
1510 */
1511
1512 static BOOL
1513 get_othercase_range(int *cptr, int d, int *ocptr, int *odptr)
1514 {
1515 int c, chartype, othercase, next;
1516
1517 for (c = *cptr; c <= d; c++)
1518   {
1519   if (_pcre_ucp_findchar(c, &chartype, &othercase) == ucp_L && othercase != 0)
1520     break;
1521   }
1522
1523 if (c > d) return FALSE;
1524
1525 *ocptr = othercase;
1526 next = othercase + 1;
1527
1528 for (++c; c <= d; c++)
1529   {
1530   if (_pcre_ucp_findchar(c, &chartype, &othercase) != ucp_L ||
1531         othercase != next)
1532     break;
1533   next++;
1534   }
1535
1536 *odptr = next - 1;
1537 *cptr = c;
1538
1539 return TRUE;
1540 }
1541 #endif  /* SUPPORT_UCP */
1542
1543
1544 /*************************************************
1545 *           Compile one branch                   *
1546 *************************************************/
1547
1548 /* Scan the pattern, compiling it into the code vector. If the options are
1549 changed during the branch, the pointer is used to change the external options
1550 bits.
1551
1552 Arguments:
1553   optionsptr     pointer to the option bits
1554   brackets       points to number of extracting brackets used
1555   codeptr        points to the pointer to the current code point
1556   ptrptr         points to the current pattern pointer
1557   errorcodeptr   points to error code variable
1558   firstbyteptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
1559   reqbyteptr     set to the last literal character required, else < 0
1560   bcptr          points to current branch chain
1561   cd             contains pointers to tables etc.
1562
1563 Returns:         TRUE on success
1564                  FALSE, with *errorcodeptr set non-zero on error
1565 */
1566
1567 static BOOL
1568 compile_branch(int *optionsptr, int *brackets, uschar **codeptr,
1569   const pcre_uchar **ptrptr, int *errorcodeptr, int *firstbyteptr,
1570   int *reqbyteptr, branch_chain *bcptr, compile_data *cd)
1571 {
1572 int repeat_type, op_type;
1573 int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
1574 int bravalue = 0;
1575 int greedy_default, greedy_non_default;
1576 int firstbyte, reqbyte;
1577 int zeroreqbyte, zerofirstbyte;
1578 int req_caseopt, reqvary, tempreqvary;
1579 int condcount = 0;
1580 int options = *optionsptr;
1581 int after_manual_callout = 0;
1582 register int c;
1583 register uschar *code = *codeptr;
1584 uschar *tempcode;
1585 BOOL inescq = FALSE;
1586 BOOL groupsetfirstbyte = FALSE;
1587 const pcre_uchar *ptr = *ptrptr;
1588 const pcre_uchar *tempptr;
1589 uschar *previous = NULL;
1590 uschar *previous_callout = NULL;
1591 uschar classbits[32];
1592
1593 #ifdef SUPPORT_UTF8
1594 BOOL class_utf8;
1595 BOOL utf8 = (options & PCRE_UTF8) != 0;
1596 uschar *class_utf8data;
1597 uschar utf8_char[6];
1598 #else
1599 BOOL utf8 = FALSE;
1600 #endif
1601
1602 /* Set up the default and non-default settings for greediness */
1603
1604 greedy_default = ((options & PCRE_UNGREEDY) != 0);
1605 greedy_non_default = greedy_default ^ 1;
1606
1607 /* Initialize no first byte, no required byte. REQ_UNSET means "no char
1608 matching encountered yet". It gets changed to REQ_NONE if we hit something that
1609 matches a non-fixed char first char; reqbyte just remains unset if we never
1610 find one.
1611
1612 When we hit a repeat whose minimum is zero, we may have to adjust these values
1613 to take the zero repeat into account. This is implemented by setting them to
1614 zerofirstbyte and zeroreqbyte when such a repeat is encountered. The individual
1615 item types that can be repeated set these backoff variables appropriately. */
1616
1617 firstbyte = reqbyte = zerofirstbyte = zeroreqbyte = REQ_UNSET;
1618
1619 /* The variable req_caseopt contains either the REQ_CASELESS value or zero,
1620 according to the current setting of the caseless flag. REQ_CASELESS is a bit
1621 value > 255. It is added into the firstbyte or reqbyte variables to record the
1622 case status of the value. This is used only for ASCII characters. */
1623
1624 req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
1625
1626 /* Switch on next character until the end of the branch */
1627
1628 for (;; ptr++)
1629   {
1630   BOOL negate_class;
1631   BOOL possessive_quantifier;
1632   BOOL is_quantifier;
1633   int class_charcount;
1634   int class_lastchar;
1635   int newoptions;
1636   int recno;
1637   int skipbytes;
1638   int subreqbyte;
1639   int subfirstbyte;
1640   int mclength;
1641   uschar mcbuffer[8];
1642
1643   /* Next byte in the pattern */
1644
1645   c = *ptr;
1646
1647   /* If in \Q...\E, check for the end; if not, we have a literal */
1648
1649   if (inescq && c != 0)
1650     {
1651     if (c == '\\' && ptr[1] == 'E')
1652       {
1653       inescq = FALSE;
1654       ptr++;
1655       continue;
1656       }
1657     else
1658       {
1659       if (previous_callout != NULL)
1660         {
1661         complete_callout(previous_callout, ptr, cd);
1662         previous_callout = NULL;
1663         }
1664       if ((options & PCRE_AUTO_CALLOUT) != 0)
1665         {
1666         previous_callout = code;
1667         code = auto_callout(code, ptr, cd);
1668         }
1669       goto NORMAL_CHAR;
1670       }
1671     }
1672
1673   /* Fill in length of a previous callout, except when the next thing is
1674   a quantifier. */
1675
1676   is_quantifier = c == '*' || c == '+' || c == '?' ||
1677     (c == '{' && is_counted_repeat(ptr+1));
1678
1679   if (!is_quantifier && previous_callout != NULL &&
1680        after_manual_callout-- <= 0)
1681     {
1682     complete_callout(previous_callout, ptr, cd);
1683     previous_callout = NULL;
1684     }
1685
1686   /* In extended mode, skip white space and comments */
1687
1688   if ((options & PCRE_EXTENDED) != 0)
1689     {
1690     if ((CTYPES(cd, c) & ctype_space) != 0) continue;
1691     if (c == '#')
1692       {
1693       /* The space before the ; is to avoid a warning on a silly compiler
1694       on the Macintosh. */
1695       while ((c = *(++ptr)) != 0 && c != NEWLINE) ;
1696       if (c != 0) continue;   /* Else fall through to handle end of string */
1697       }
1698     }
1699
1700   /* No auto callout for quantifiers. */
1701
1702   if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier)
1703     {
1704     previous_callout = code;
1705     code = auto_callout(code, ptr, cd);
1706     }
1707
1708   switch(c)
1709     {
1710     /* The branch terminates at end of string, |, or ). */
1711
1712     case 0:
1713     case '|':
1714     case ')':
1715     *firstbyteptr = firstbyte;
1716     *reqbyteptr = reqbyte;
1717     *codeptr = code;
1718     *ptrptr = ptr;
1719     return TRUE;
1720
1721     /* Handle single-character metacharacters. In multiline mode, ^ disables
1722     the setting of any following char as a first character. */
1723
1724     case '^':
1725     if ((options & PCRE_MULTILINE) != 0)
1726       {
1727       if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
1728       }
1729     previous = NULL;
1730     *code++ = OP_CIRC;
1731     break;
1732
1733     case '$':
1734     previous = NULL;
1735     *code++ = OP_DOLL;
1736     break;
1737
1738     /* There can never be a first char if '.' is first, whatever happens about
1739     repeats. The value of reqbyte doesn't change either. */
1740
1741     case '.':
1742     if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
1743     zerofirstbyte = firstbyte;
1744     zeroreqbyte = reqbyte;
1745     previous = code;
1746     *code++ = OP_ANY;
1747     break;
1748
1749     /* Character classes. If the included characters are all < 255 in value, we
1750     build a 32-byte bitmap of the permitted characters, except in the special
1751     case where there is only one such character. For negated classes, we build
1752     the map as usual, then invert it at the end. However, we use a different
1753     opcode so that data characters > 255 can be handled correctly.
1754
1755     If the class contains characters outside the 0-255 range, a different
1756     opcode is compiled. It may optionally have a bit map for characters < 256,
1757     but those above are are explicitly listed afterwards. A flag byte tells
1758     whether the bitmap is present, and whether this is a negated class or not.
1759     */
1760
1761     case '[':
1762     previous = code;
1763
1764     /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
1765     they are encountered at the top level, so we'll do that too. */
1766
1767     if ((ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
1768         check_posix_syntax(ptr, &tempptr, cd))
1769       {
1770       *errorcodeptr = (ptr[1] == ':')? ERR13 : ERR31;
1771       goto FAILED;
1772       }
1773
1774     /* If the first character is '^', set the negation flag and skip it. */
1775
1776     if ((c = *(++ptr)) == '^')
1777       {
1778       negate_class = TRUE;
1779       c = *(++ptr);
1780       }
1781     else
1782       {
1783       negate_class = FALSE;
1784       }
1785
1786     /* Keep a count of chars with values < 256 so that we can optimize the case
1787     of just a single character (as long as it's < 256). For higher valued UTF-8
1788     characters, we don't yet do any optimization. */
1789
1790     class_charcount = 0;
1791     class_lastchar = -1;
1792
1793 #ifdef SUPPORT_UTF8
1794     class_utf8 = FALSE;                       /* No chars >= 256 */
1795     class_utf8data = code + LINK_SIZE + 34;   /* For UTF-8 items */
1796 #endif
1797
1798     /* Initialize the 32-char bit map to all zeros. We have to build the
1799     map in a temporary bit of store, in case the class contains only 1
1800     character (< 256), because in that case the compiled code doesn't use the
1801     bit map. */
1802
1803     memset(classbits, 0, 32 * sizeof(uschar));
1804
1805     /* Process characters until ] is reached. By writing this as a "do" it
1806     means that an initial ] is taken as a data character. The first pass
1807     through the regex checked the overall syntax, so we don't need to be very
1808     strict here. At the start of the loop, c contains the first byte of the
1809     character. */
1810
1811     do
1812       {
1813 #ifdef SUPPORT_UTF8
1814       if (utf8 && c > 127)
1815         {                           /* Braces are required because the */
1816         GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
1817         }
1818 #endif
1819
1820       /* Inside \Q...\E everything is literal except \E */
1821
1822       if (inescq)
1823         {
1824         if (c == '\\' && ptr[1] == 'E')
1825           {
1826           inescq = FALSE;
1827           ptr++;
1828           continue;
1829           }
1830         else goto LONE_SINGLE_CHARACTER;
1831         }
1832
1833       /* Handle POSIX class names. Perl allows a negation extension of the
1834       form [:^name:]. A square bracket that doesn't match the syntax is
1835       treated as a literal. We also recognize the POSIX constructions
1836       [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
1837       5.6 and 5.8 do. */
1838
1839       if (c == '[' &&
1840           (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
1841           check_posix_syntax(ptr, &tempptr, cd))
1842         {
1843         BOOL local_negate = FALSE;
1844         int posix_class, i;
1845         register const uschar *cbits = cd->cbits;
1846
1847         if (ptr[1] != ':')
1848           {
1849           *errorcodeptr = ERR31;
1850           goto FAILED;
1851           }
1852
1853         ptr += 2;
1854         if (*ptr == '^')
1855           {
1856           local_negate = TRUE;
1857           ptr++;
1858           }
1859
1860         posix_class = check_posix_name(ptr, tempptr - ptr);
1861         if (posix_class < 0)
1862           {
1863           *errorcodeptr = ERR30;
1864           goto FAILED;
1865           }
1866
1867         /* If matching is caseless, upper and lower are converted to
1868         alpha. This relies on the fact that the class table starts with
1869         alpha, lower, upper as the first 3 entries. */
1870
1871         if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
1872           posix_class = 0;
1873
1874         /* Or into the map we are building up to 3 of the static class
1875         tables, or their negations. The [:blank:] class sets up the same
1876         chars as the [:space:] class (all white space). We remove the vertical
1877         white space chars afterwards. */
1878
1879         posix_class *= 3;
1880         for (i = 0; i < 3; i++)
1881           {
1882           BOOL blankclass = STREQUAL(ptr, 5, "blank");
1883           int taboffset = posix_class_maps[posix_class + i];
1884           if (taboffset < 0) break;
1885           if (local_negate)
1886             {
1887             if (i == 0)
1888               for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+taboffset];
1889             else
1890               for (c = 0; c < 32; c++) classbits[c] &= ~cbits[c+taboffset];
1891             if (blankclass) classbits[1] |= 0x3c;
1892             }
1893           else
1894             {
1895             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+taboffset];
1896             if (blankclass) classbits[1] &= ~0x3c;
1897             }
1898           }
1899
1900         ptr = tempptr + 1;
1901         class_charcount = 10;  /* Set > 1; assumes more than 1 per class */
1902         continue;    /* End of POSIX syntax handling */
1903         }
1904
1905       /* Backslash may introduce a single character, or it may introduce one
1906       of the specials, which just set a flag. Escaped items are checked for
1907       validity in the pre-compiling pass. The sequence \b is a special case.
1908       Inside a class (and only there) it is treated as backspace. Elsewhere
1909       it marks a word boundary. Other escapes have preset maps ready to
1910       or into the one we are building. We assume they have more than one
1911       character in them, so set class_charcount bigger than one. */
1912
1913       if (c == '\\')
1914         {
1915         c = check_escape(&ptr, errorcodeptr, *brackets, options, TRUE);
1916
1917         if (-c == ESC_b) c = '\b';       /* \b is backslash in a class */
1918         else if (-c == ESC_X) c = 'X';   /* \X is literal X in a class */
1919         else if (-c == ESC_Q)            /* Handle start of quoted string */
1920           {
1921           if (ptr[1] == '\\' && ptr[2] == 'E')
1922             {
1923             ptr += 2; /* avoid empty string */
1924             }
1925           else inescq = TRUE;
1926           continue;
1927           }
1928
1929         if (c < 0)
1930           {
1931           register const uschar *cbits = cd->cbits;
1932           class_charcount += 2;     /* Greater than 1 is what matters */
1933           switch (-c)
1934             {
1935             case ESC_d:
1936             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];
1937             continue;
1938
1939             case ESC_D:
1940             for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
1941             continue;
1942
1943             case ESC_w:
1944             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];
1945             continue;
1946
1947             case ESC_W:
1948             for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
1949             continue;
1950
1951             case ESC_s:
1952             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
1953             /* JavaScript does not omit VT, so we leave out the following line: */
1954             /* classbits[1] &= ~0x08;   Perl 5.004 onwards omits VT from \s */
1955             continue;
1956
1957             case ESC_S:
1958             for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
1959             /* JavaScript does not omit VT, so we leave out the following line: */
1960             /* classbits[1] |= 0x08;    Perl 5.004 onwards omits VT from \s */
1961             continue;
1962
1963 #ifdef SUPPORT_UCP
1964             case ESC_p:
1965             case ESC_P:
1966               {
1967               BOOL negated;
1968               int property = get_ucp(&ptr, &negated, errorcodeptr);
1969               if (property < 0) goto FAILED;
1970               class_utf8 = TRUE;
1971               *class_utf8data++ = ((-c == ESC_p) != negated)?
1972                 XCL_PROP : XCL_NOTPROP;
1973               *class_utf8data++ = property;
1974               class_charcount -= 2;   /* Not a < 256 character */
1975               }
1976             continue;
1977 #endif
1978
1979             /* Unrecognized escapes are faulted if PCRE is running in its
1980             strict mode. By default, for compatibility with Perl, they are
1981             treated as literals. */
1982
1983             default:
1984             if ((options & PCRE_EXTRA) != 0)
1985               {
1986               *errorcodeptr = ERR7;
1987               goto FAILED;
1988               }
1989             c = *ptr;              /* The final character */
1990             class_charcount -= 2;  /* Undo the default count from above */
1991             }
1992           }
1993
1994         /* Fall through if we have a single character (c >= 0). This may be
1995         > 256 in UTF-8 mode. */
1996
1997         }   /* End of backslash handling */
1998
1999       /* A single character may be followed by '-' to form a range. However,
2000       Perl does not permit ']' to be the end of the range. A '-' character
2001       here is treated as a literal. */
2002
2003       if (ptr[1] == '-' && ptr[2] != ']')
2004         {
2005         int d;
2006         ptr += 2;
2007
2008 #ifdef SUPPORT_UTF8
2009         if (utf8)
2010           {                           /* Braces are required because the */
2011           GETCHARLEN(d, ptr, ptr);    /* macro generates multiple statements */
2012           }
2013         else
2014 #endif
2015         d = *ptr;  /* Not UTF-8 mode */
2016
2017         /* The second part of a range can be a single-character escape, but
2018         not any of the other escapes. Perl 5.6 treats a hyphen as a literal
2019         in such circumstances. */
2020
2021         if (d == '\\')
2022           {
2023           const pcre_uchar *oldptr = ptr;
2024           d = check_escape(&ptr, errorcodeptr, *brackets, options, TRUE);
2025
2026           /* \b is backslash; \X is literal X; any other special means the '-'
2027           was literal */
2028
2029           if (d < 0)
2030             {
2031             if (d == -ESC_b) d = '\b';
2032             else if (d == -ESC_X) d = 'X'; else
2033               {
2034               ptr = oldptr - 2;
2035               goto LONE_SINGLE_CHARACTER;  /* A few lines below */
2036               }
2037             }
2038           }
2039
2040         /* The check that the two values are in the correct order happens in
2041         the pre-pass. Optimize one-character ranges */
2042
2043         if (d == c) goto LONE_SINGLE_CHARACTER;  /* A few lines below */
2044
2045         /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
2046         matching, we have to use an XCLASS with extra data items. Caseless
2047         matching for characters > 127 is available only if UCP support is
2048         available. */
2049
2050 #ifdef SUPPORT_UTF8
2051         if (utf8 && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
2052           {
2053           class_utf8 = TRUE;
2054
2055           /* With UCP support, we can find the other case equivalents of
2056           the relevant characters. There may be several ranges. Optimize how
2057           they fit with the basic range. */
2058
2059 #ifdef SUPPORT_UCP
2060           if ((options & PCRE_CASELESS) != 0)
2061             {
2062             int occ, ocd;
2063             int cc = c;
2064             int origd = d;
2065             while (get_othercase_range(&cc, origd, &occ, &ocd))
2066               {
2067               if (occ >= c && ocd <= d) continue;  /* Skip embedded ranges */
2068
2069               if (occ < c  && ocd >= c - 1)        /* Extend the basic range */
2070                 {                                  /* if there is overlap,   */
2071                 c = occ;                           /* noting that if occ < c */
2072                 continue;                          /* we can't have ocd > d  */
2073                 }                                  /* because a subrange is  */
2074               if (ocd > d && occ <= d + 1)         /* always shorter than    */
2075                 {                                  /* the basic range.       */
2076                 d = ocd;
2077                 continue;
2078                 }
2079
2080               if (occ == ocd)
2081                 {
2082                 *class_utf8data++ = XCL_SINGLE;
2083                 }
2084               else
2085                 {
2086                 *class_utf8data++ = XCL_RANGE;
2087                 class_utf8data += _pcre_ord2utf8(occ, class_utf8data);
2088                 }
2089               class_utf8data += _pcre_ord2utf8(ocd, class_utf8data);
2090               }
2091             }
2092 #endif  /* SUPPORT_UCP */
2093
2094           /* Now record the original range, possibly modified for UCP caseless
2095           overlapping ranges. */
2096
2097           *class_utf8data++ = XCL_RANGE;
2098           class_utf8data += _pcre_ord2utf8(c, class_utf8data);
2099           class_utf8data += _pcre_ord2utf8(d, class_utf8data);
2100
2101           /* With UCP support, we are done. Without UCP support, there is no
2102           caseless matching for UTF-8 characters > 127; we can use the bit map
2103           for the smaller ones. */
2104
2105 #ifdef SUPPORT_UCP
2106           continue;    /* With next character in the class */
2107 #else
2108           if ((options & PCRE_CASELESS) == 0 || c > 127) continue;
2109
2110           /* Adjust upper limit and fall through to set up the map */
2111
2112           d = 127;
2113
2114 #endif  /* SUPPORT_UCP */
2115           }
2116 #endif  /* SUPPORT_UTF8 */
2117
2118         /* We use the bit map for all cases when not in UTF-8 mode; else
2119         ranges that lie entirely within 0-127 when there is UCP support; else
2120         for partial ranges without UCP support. */
2121
2122         for (; c <= d; c++)
2123           {
2124           classbits[c/8] |= (1 << (c&7));
2125           if ((options & PCRE_CASELESS) != 0)
2126             {
2127             int uc = cd->fcc[c];           /* flip case */
2128             classbits[uc/8] |= (1 << (uc&7));
2129             }
2130           class_charcount++;                /* in case a one-char range */
2131           class_lastchar = c;
2132           }
2133
2134         continue;   /* Go get the next char in the class */
2135         }
2136
2137       /* Handle a lone single character - we can get here for a normal
2138       non-escape char, or after \ that introduces a single character or for an
2139       apparent range that isn't. */
2140
2141       LONE_SINGLE_CHARACTER:
2142
2143       /* Handle a character that cannot go in the bit map */
2144
2145 #ifdef SUPPORT_UTF8
2146       if (utf8 && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
2147         {
2148         class_utf8 = TRUE;
2149         *class_utf8data++ = XCL_SINGLE;
2150         class_utf8data += _pcre_ord2utf8(c, class_utf8data);
2151
2152 #ifdef SUPPORT_UCP
2153         if ((options & PCRE_CASELESS) != 0)
2154           {
2155           int chartype;
2156           int othercase;
2157           if (_pcre_ucp_findchar(c, &chartype, &othercase) >= 0 &&
2158                othercase > 0)
2159             {
2160             *class_utf8data++ = XCL_SINGLE;
2161             class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
2162             }
2163           }
2164 #endif  /* SUPPORT_UCP */
2165
2166         }
2167       else
2168 #endif  /* SUPPORT_UTF8 */
2169
2170       /* Handle a single-byte character */
2171         {
2172         classbits[c/8] |= (1 << (c&7));
2173         if ((options & PCRE_CASELESS) != 0)
2174           {
2175           c = cd->fcc[c];   /* flip case */
2176           classbits[c/8] |= (1 << (c&7));
2177           }
2178         class_charcount++;
2179         class_lastchar = c;
2180         }
2181       }
2182
2183     /* Loop until ']' reached; the check for end of string happens inside the
2184     loop. This "while" is the end of the "do" above. */
2185
2186     while ((c = *(++ptr)) != ']' || inescq);
2187
2188     /* If class_charcount is 1, we saw precisely one character whose value is
2189     less than 256. In non-UTF-8 mode we can always optimize. In UTF-8 mode, we
2190     can optimize the negative case only if there were no characters >= 128
2191     because OP_NOT and the related opcodes like OP_NOTSTAR operate on
2192     single-bytes only. This is an historical hangover. Maybe one day we can
2193     tidy these opcodes to handle multi-byte characters.
2194
2195     The optimization throws away the bit map. We turn the item into a
2196     1-character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
2197     that OP_NOT does not support multibyte characters. In the positive case, it
2198     can cause firstbyte to be set. Otherwise, there can be no first char if
2199     this item is first, whatever repeat count may follow. In the case of
2200     reqbyte, save the previous value for reinstating. */
2201
2202 #ifdef SUPPORT_UTF8
2203     if (class_charcount == 1 &&
2204           (!utf8 ||
2205           (!class_utf8 && (!negate_class || class_lastchar < 128))))
2206
2207 #else
2208     if (class_charcount == 1)
2209 #endif
2210       {
2211       zeroreqbyte = reqbyte;
2212
2213       /* The OP_NOT opcode works on one-byte characters only. */
2214
2215       if (negate_class)
2216         {
2217         if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2218         zerofirstbyte = firstbyte;
2219         *code++ = OP_NOT;
2220         *code++ = class_lastchar;
2221         break;
2222         }
2223
2224       /* For a single, positive character, get the value into mcbuffer, and
2225       then we can handle this with the normal one-character code. */
2226
2227 #ifdef SUPPORT_UTF8
2228       if (utf8 && class_lastchar > 127)
2229         mclength = _pcre_ord2utf8(class_lastchar, mcbuffer);
2230       else
2231 #endif
2232         {
2233         mcbuffer[0] = class_lastchar;
2234         mclength = 1;
2235         }
2236       goto ONE_CHAR;
2237       }       /* End of 1-char optimization */
2238
2239     /* The general case - not the one-char optimization. If this is the first
2240     thing in the branch, there can be no first char setting, whatever the
2241     repeat count. Any reqbyte setting must remain unchanged after any kind of
2242     repeat. */
2243
2244     if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2245     zerofirstbyte = firstbyte;
2246     zeroreqbyte = reqbyte;
2247
2248     /* If there are characters with values > 255, we have to compile an
2249     extended class, with its own opcode. If there are no characters < 256,
2250     we can omit the bitmap. */
2251
2252 #ifdef SUPPORT_UTF8
2253     if (class_utf8)
2254       {
2255       *class_utf8data++ = XCL_END;    /* Marks the end of extra data */
2256       *code++ = OP_XCLASS;
2257       code += LINK_SIZE;
2258       *code = negate_class? XCL_NOT : 0;
2259
2260       /* If the map is required, install it, and move on to the end of
2261       the extra data */
2262
2263       if (class_charcount > 0)
2264         {
2265         *code++ |= XCL_MAP;
2266         memcpy(code, classbits, 32);
2267         code = class_utf8data;
2268         }
2269
2270       /* If the map is not required, slide down the extra data. */
2271
2272       else
2273         {
2274         int len = class_utf8data - (code + 33);
2275         memmove(code + 1, code + 33, len);
2276         code += len + 1;
2277         }
2278
2279       /* Now fill in the complete length of the item */
2280
2281       PUT(previous, 1, code - previous);
2282       break;   /* End of class handling */
2283       }
2284 #endif
2285
2286     /* If there are no characters > 255, negate the 32-byte map if necessary,
2287     and copy it into the code vector. If this is the first thing in the branch,
2288     there can be no first char setting, whatever the repeat count. Any reqbyte
2289     setting must remain unchanged after any kind of repeat. */
2290
2291     if (negate_class)
2292       {
2293       *code++ = OP_NCLASS;
2294       for (c = 0; c < 32; c++) code[c] = ~classbits[c];
2295       }
2296     else
2297       {
2298       *code++ = OP_CLASS;
2299       memcpy(code, classbits, 32);
2300       }
2301     code += 32;
2302     break;
2303
2304     /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
2305     has been tested above. */
2306
2307     case '{':
2308     if (!is_quantifier) goto NORMAL_CHAR;
2309     ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);
2310     if (*errorcodeptr != 0) goto FAILED;
2311     goto REPEAT;
2312
2313     case '*':
2314     repeat_min = 0;
2315     repeat_max = -1;
2316     goto REPEAT;
2317
2318     case '+':
2319     repeat_min = 1;
2320     repeat_max = -1;
2321     goto REPEAT;
2322
2323     case '?':
2324     repeat_min = 0;
2325     repeat_max = 1;
2326
2327     REPEAT:
2328     if (previous == NULL)
2329       {
2330       *errorcodeptr = ERR9;
2331       goto FAILED;
2332       }
2333
2334     if (repeat_min == 0)
2335       {
2336       firstbyte = zerofirstbyte;    /* Adjust for zero repeat */
2337       reqbyte = zeroreqbyte;        /* Ditto */
2338       }
2339
2340     /* Remember whether this is a variable length repeat */
2341
2342     reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;
2343
2344     op_type = 0;                    /* Default single-char op codes */
2345     possessive_quantifier = FALSE;  /* Default not possessive quantifier */
2346
2347     /* Save start of previous item, in case we have to move it up to make space
2348     for an inserted OP_ONCE for the additional '+' extension. */
2349
2350     tempcode = previous;
2351
2352     /* If the next character is '+', we have a possessive quantifier. This
2353     implies greediness, whatever the setting of the PCRE_UNGREEDY option.
2354     If the next character is '?' this is a minimizing repeat, by default,
2355     but if PCRE_UNGREEDY is set, it works the other way round. We change the
2356     repeat type to the non-default. */
2357
2358     if (ptr[1] == '+')
2359       {
2360       repeat_type = 0;                  /* Force greedy */
2361       possessive_quantifier = TRUE;
2362       ptr++;
2363       }
2364     else if (ptr[1] == '?')
2365       {
2366       repeat_type = greedy_non_default;
2367       ptr++;
2368       }
2369     else repeat_type = greedy_default;
2370
2371     /* If previous was a recursion, we need to wrap it inside brackets so that
2372     it can be replicated if necessary. */
2373
2374     if (*previous == OP_RECURSE)
2375       {
2376       memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);
2377       code += 1 + LINK_SIZE;
2378       *previous = OP_BRA;
2379       PUT(previous, 1, code - previous);
2380       *code = OP_KET;
2381       PUT(code, 1, code - previous);
2382       code += 1 + LINK_SIZE;
2383       }
2384
2385     /* If previous was a character match, abolish the item and generate a
2386     repeat item instead. If a char item has a minumum of more than one, ensure
2387     that it is set in reqbyte - it might not be if a sequence such as x{3} is
2388     the first thing in a branch because the x will have gone into firstbyte
2389     instead.  */
2390
2391     if (*previous == OP_CHAR || *previous == OP_CHARNC)
2392       {
2393       /* Deal with UTF-8 characters that take up more than one byte. It's
2394       easier to write this out separately than try to macrify it. Use c to
2395       hold the length of the character in bytes, plus 0x80 to flag that it's a
2396       length rather than a small character. */
2397
2398 #ifdef SUPPORT_UTF8
2399       if (utf8 && (code[-1] & 0x80) != 0)
2400         {
2401         uschar *lastchar = code - 1;
2402         while((*lastchar & 0xc0) == 0x80) lastchar--;
2403         c = code - lastchar;            /* Length of UTF-8 character */
2404         memcpy(utf8_char, lastchar, c); /* Save the char */
2405         c |= 0x80;                      /* Flag c as a length */
2406         }
2407       else
2408 #endif
2409
2410       /* Handle the case of a single byte - either with no UTF8 support, or
2411       with UTF-8 disabled, or for a UTF-8 character < 128. */
2412
2413         {
2414         c = code[-1];
2415         if (repeat_min > 1) reqbyte = c | req_caseopt | cd->req_varyopt;
2416         }
2417
2418       goto OUTPUT_SINGLE_REPEAT;   /* Code shared with single character types */
2419       }
2420
2421     /* If previous was a single negated character ([^a] or similar), we use
2422     one of the special opcodes, replacing it. The code is shared with single-
2423     character repeats by setting opt_type to add a suitable offset into
2424     repeat_type. OP_NOT is currently used only for single-byte chars. */
2425
2426     else if (*previous == OP_NOT)
2427       {
2428       op_type = OP_NOTSTAR - OP_STAR;  /* Use "not" opcodes */
2429       c = previous[1];
2430       goto OUTPUT_SINGLE_REPEAT;
2431       }
2432
2433     /* If previous was a character type match (\d or similar), abolish it and
2434     create a suitable repeat item. The code is shared with single-character
2435     repeats by setting op_type to add a suitable offset into repeat_type. Note
2436     the the Unicode property types will be present only when SUPPORT_UCP is
2437     defined, but we don't wrap the little bits of code here because it just
2438     makes it horribly messy. */
2439
2440     else if (*previous < OP_EODN)
2441       {
2442       uschar *oldcode;
2443       int prop_type;
2444       op_type = OP_TYPESTAR - OP_STAR;  /* Use type opcodes */
2445       c = *previous;
2446
2447       OUTPUT_SINGLE_REPEAT:
2448       prop_type = (*previous == OP_PROP || *previous == OP_NOTPROP)?
2449         previous[1] : -1;
2450
2451       oldcode = code;
2452       code = previous;                  /* Usually overwrite previous item */
2453
2454       /* If the maximum is zero then the minimum must also be zero; Perl allows
2455       this case, so we do too - by simply omitting the item altogether. */
2456
2457       if (repeat_max == 0) goto END_REPEAT;
2458
2459       /* All real repeats make it impossible to handle partial matching (maybe
2460       one day we will be able to remove this restriction). */
2461
2462       if (repeat_max != 1) cd->nopartial = TRUE;
2463
2464       /* Combine the op_type with the repeat_type */
2465
2466       repeat_type += op_type;
2467
2468       /* A minimum of zero is handled either as the special case * or ?, or as
2469       an UPTO, with the maximum given. */
2470
2471       if (repeat_min == 0)
2472         {
2473         if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
2474           else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
2475         else
2476           {
2477           *code++ = OP_UPTO + repeat_type;
2478           PUT2INC(code, 0, repeat_max);
2479           }
2480         }
2481
2482       /* A repeat minimum of 1 is optimized into some special cases. If the
2483       maximum is unlimited, we use OP_PLUS. Otherwise, the original item it
2484       left in place and, if the maximum is greater than 1, we use OP_UPTO with
2485       one less than the maximum. */
2486
2487       else if (repeat_min == 1)
2488         {
2489         if (repeat_max == -1)
2490           *code++ = OP_PLUS + repeat_type;
2491         else
2492           {
2493           code = oldcode;                 /* leave previous item in place */
2494           if (repeat_max == 1) goto END_REPEAT;
2495           *code++ = OP_UPTO + repeat_type;
2496           PUT2INC(code, 0, repeat_max - 1);
2497           }
2498         }
2499
2500       /* The case {n,n} is just an EXACT, while the general case {n,m} is
2501       handled as an EXACT followed by an UPTO. */
2502
2503       else
2504         {
2505         *code++ = OP_EXACT + op_type;  /* NB EXACT doesn't have repeat_type */
2506         PUT2INC(code, 0, repeat_min);
2507
2508         /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
2509         we have to insert the character for the previous code. For a repeated
2510         Unicode property match, there is an extra byte that defines the
2511         required property. In UTF-8 mode, long characters have their length in
2512         c, with the 0x80 bit as a flag. */
2513
2514         if (repeat_max < 0)
2515           {
2516 #ifdef SUPPORT_UTF8
2517           if (utf8 && c >= 128)
2518             {
2519             memcpy(code, utf8_char, c & 7);
2520             code += c & 7;
2521             }
2522           else
2523 #endif
2524             {
2525             *code++ = c;
2526             if (prop_type >= 0) *code++ = prop_type;
2527             }
2528           *code++ = OP_STAR + repeat_type;
2529           }
2530
2531         /* Else insert an UPTO if the max is greater than the min, again
2532         preceded by the character, for the previously inserted code. */
2533
2534         else if (repeat_max != repeat_min)
2535           {
2536 #ifdef SUPPORT_UTF8
2537           if (utf8 && c >= 128)
2538             {
2539             memcpy(code, utf8_char, c & 7);
2540             code += c & 7;
2541             }
2542           else
2543 #endif
2544           *code++ = c;
2545           if (prop_type >= 0) *code++ = prop_type;
2546           repeat_max -= repeat_min;
2547           *code++ = OP_UPTO + repeat_type;
2548           PUT2INC(code, 0, repeat_max);
2549           }
2550         }
2551
2552       /* The character or character type itself comes last in all cases. */
2553
2554 #ifdef SUPPORT_UTF8
2555       if (utf8 && c >= 128)
2556         {
2557         memcpy(code, utf8_char, c & 7);
2558         code += c & 7;
2559         }
2560       else
2561 #endif
2562       *code++ = c;
2563
2564       /* For a repeated Unicode property match, there is an extra byte that
2565       defines the required property. */
2566
2567 #ifdef SUPPORT_UCP
2568       if (prop_type >= 0) *code++ = prop_type;
2569 #endif
2570       }
2571
2572     /* If previous was a character class or a back reference, we put the repeat
2573     stuff after it, but just skip the item if the repeat was {0,0}. */
2574
2575     else if (*previous == OP_CLASS ||
2576              *previous == OP_NCLASS ||
2577 #ifdef SUPPORT_UTF8
2578              *previous == OP_XCLASS ||
2579 #endif
2580              *previous == OP_REF)
2581       {
2582       if (repeat_max == 0)
2583         {
2584         code = previous;
2585         goto END_REPEAT;
2586         }
2587
2588       /* All real repeats make it impossible to handle partial matching (maybe
2589       one day we will be able to remove this restriction). */
2590
2591       if (repeat_max != 1) cd->nopartial = TRUE;
2592
2593       if (repeat_min == 0 && repeat_max == -1)
2594         *code++ = OP_CRSTAR + repeat_type;
2595       else if (repeat_min == 1 && repeat_max == -1)
2596         *code++ = OP_CRPLUS + repeat_type;
2597       else if (repeat_min == 0 && repeat_max == 1)
2598         *code++ = OP_CRQUERY + repeat_type;
2599       else
2600         {
2601         *code++ = OP_CRRANGE + repeat_type;
2602         PUT2INC(code, 0, repeat_min);
2603         if (repeat_max == -1) repeat_max = 0;  /* 2-byte encoding for max */
2604         PUT2INC(code, 0, repeat_max);
2605         }
2606       }
2607
2608     /* If previous was a bracket group, we may have to replicate it in certain
2609     cases. */
2610
2611     else if (*previous >= OP_BRA || *previous == OP_ONCE ||
2612              *previous == OP_COND)
2613       {
2614       register int i;
2615       int ketoffset = 0;
2616       int len = code - previous;
2617       uschar *bralink = NULL;
2618
2619       /* If the maximum repeat count is unlimited, find the end of the bracket
2620       by scanning through from the start, and compute the offset back to it
2621       from the current code pointer. There may be an OP_OPT setting following
2622       the final KET, so we can't find the end just by going back from the code
2623       pointer. */
2624
2625       if (repeat_max == -1)
2626         {
2627         register uschar *ket = previous;
2628         do ket += GET(ket, 1); while (*ket != OP_KET);
2629         ketoffset = code - ket;
2630         }
2631
2632       /* The case of a zero minimum is special because of the need to stick
2633       OP_BRAZERO in front of it, and because the group appears once in the
2634       data, whereas in other cases it appears the minimum number of times. For
2635       this reason, it is simplest to treat this case separately, as otherwise
2636       the code gets far too messy. There are several special subcases when the
2637       minimum is zero. */
2638
2639       if (repeat_min == 0)
2640         {
2641         /* If the maximum is also zero, we just omit the group from the output
2642         altogether. */
2643
2644         if (repeat_max == 0)
2645           {
2646           code = previous;
2647           goto END_REPEAT;
2648           }
2649
2650         /* If the maximum is 1 or unlimited, we just have to stick in the
2651         BRAZERO and do no more at this point. However, we do need to adjust
2652         any OP_RECURSE calls inside the group that refer to the group itself or
2653         any internal group, because the offset is from the start of the whole
2654         regex. Temporarily terminate the pattern while doing this. */
2655
2656         if (repeat_max <= 1)
2657           {
2658           *code = OP_END;
2659           adjust_recurse(previous, 1, utf8, cd);
2660           memmove(previous+1, previous, len);
2661           code++;
2662           *previous++ = OP_BRAZERO + repeat_type;
2663           }
2664
2665         /* If the maximum is greater than 1 and limited, we have to replicate
2666         in a nested fashion, sticking OP_BRAZERO before each set of brackets.
2667         The first one has to be handled carefully because it's the original
2668         copy, which has to be moved up. The remainder can be handled by code
2669         that is common with the non-zero minimum case below. We have to
2670         adjust the value or repeat_max, since one less copy is required. Once
2671         again, we may have to adjust any OP_RECURSE calls inside the group. */
2672
2673         else
2674           {
2675           int offset;
2676           *code = OP_END;
2677           adjust_recurse(previous, 2 + LINK_SIZE, utf8, cd);
2678           memmove(previous + 2 + LINK_SIZE, previous, len);
2679           code += 2 + LINK_SIZE;
2680           *previous++ = OP_BRAZERO + repeat_type;
2681           *previous++ = OP_BRA;
2682
2683           /* We chain together the bracket offset fields that have to be
2684           filled in later when the ends of the brackets are reached. */
2685
2686           offset = (bralink == NULL)? 0 : previous - bralink;
2687           bralink = previous;
2688           PUTINC(previous, 0, offset);
2689           }
2690
2691         repeat_max--;
2692         }
2693
2694       /* If the minimum is greater than zero, replicate the group as many
2695       times as necessary, and adjust the maximum to the number of subsequent
2696       copies that we need. If we set a first char from the group, and didn't
2697       set a required char, copy the latter from the former. */
2698
2699       else
2700         {
2701         if (repeat_min > 1)
2702           {
2703           if (groupsetfirstbyte && reqbyte < 0) reqbyte = firstbyte;
2704           for (i = 1; i < repeat_min; i++)
2705             {
2706             memcpy(code, previous, len);
2707             code += len;
2708             }
2709           }
2710         if (repeat_max > 0) repeat_max -= repeat_min;
2711         }
2712
2713       /* This code is common to both the zero and non-zero minimum cases. If
2714       the maximum is limited, it replicates the group in a nested fashion,
2715       remembering the bracket starts on a stack. In the case of a zero minimum,
2716       the first one was set up above. In all cases the repeat_max now specifies
2717       the number of additional copies needed. */
2718
2719       if (repeat_max >= 0)
2720         {
2721         for (i = repeat_max - 1; i >= 0; i--)
2722           {
2723           *code++ = OP_BRAZERO + repeat_type;
2724
2725           /* All but the final copy start a new nesting, maintaining the
2726           chain of brackets outstanding. */
2727
2728           if (i != 0)
2729             {
2730             int offset;
2731             *code++ = OP_BRA;
2732             offset = (bralink == NULL)? 0 : code - bralink;
2733             bralink = code;
2734             PUTINC(code, 0, offset);
2735             }
2736
2737           memcpy(code, previous, len);
2738           code += len;
2739           }
2740
2741         /* Now chain through the pending brackets, and fill in their length
2742         fields (which are holding the chain links pro tem). */
2743
2744         while (bralink != NULL)
2745           {
2746           int oldlinkoffset;
2747           int offset = code - bralink + 1;
2748           uschar *bra = code - offset;
2749           oldlinkoffset = GET(bra, 1);
2750           bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
2751           *code++ = OP_KET;
2752           PUTINC(code, 0, offset);
2753           PUT(bra, 1, offset);
2754           }
2755         }
2756
2757       /* If the maximum is unlimited, set a repeater in the final copy. We
2758       can't just offset backwards from the current code point, because we
2759       don't know if there's been an options resetting after the ket. The
2760       correct offset was computed above. */
2761
2762       else code[-ketoffset] = OP_KETRMAX + repeat_type;
2763       }
2764
2765     /* Else there's some kind of shambles */
2766
2767     else
2768       {
2769       *errorcodeptr = ERR11;
2770       goto FAILED;
2771       }
2772
2773     /* If the character following a repeat is '+', we wrap the entire repeated
2774     item inside OP_ONCE brackets. This is just syntactic sugar, taken from
2775     Sun's Java package. The repeated item starts at tempcode, not at previous,
2776     which might be the first part of a string whose (former) last char we
2777     repeated. However, we don't support '+' after a greediness '?'. */
2778
2779     if (possessive_quantifier)
2780       {
2781       int len = code - tempcode;
2782       memmove(tempcode + 1+LINK_SIZE, tempcode, len);
2783       code += 1 + LINK_SIZE;
2784       len += 1 + LINK_SIZE;
2785       tempcode[0] = OP_ONCE;
2786       *code++ = OP_KET;
2787       PUTINC(code, 0, len);
2788       PUT(tempcode, 1, len);
2789       }
2790
2791     /* In all case we no longer have a previous item. We also set the
2792     "follows varying string" flag for subsequently encountered reqbytes if
2793     it isn't already set and we have just passed a varying length item. */
2794
2795     END_REPEAT:
2796     previous = NULL;
2797     cd->req_varyopt |= reqvary;
2798     break;
2799
2800
2801     /* Start of nested bracket sub-expression, or comment or lookahead or
2802     lookbehind or option setting or condition. First deal with special things
2803     that can come after a bracket; all are introduced by ?, and the appearance
2804     of any of them means that this is not a referencing group. They were
2805     checked for validity in the first pass over the string, so we don't have to
2806     check for syntax errors here.  */
2807
2808     case '(':
2809     newoptions = options;
2810     skipbytes = 0;
2811
2812     if (*(++ptr) == '?')
2813       {
2814       int set, unset;
2815       int *optset;
2816
2817       switch (*(++ptr))
2818         {
2819         case '#':                 /* Comment; skip to ket */
2820         ptr++;
2821         while (*ptr != ')') ptr++;
2822         continue;
2823
2824         case ':':                 /* Non-extracting bracket */
2825         bravalue = OP_BRA;
2826         ptr++;
2827         break;
2828
2829         case '(':
2830         bravalue = OP_COND;       /* Conditional group */
2831
2832         /* Condition to test for recursion */
2833
2834         if (ptr[1] == 'R')
2835           {
2836           code[1+LINK_SIZE] = OP_CREF;
2837           PUT2(code, 2+LINK_SIZE, CREF_RECURSE);
2838           skipbytes = 3;
2839           ptr += 3;
2840           }
2841
2842         /* Condition to test for a numbered subpattern match. We know that
2843         if a digit follows ( then there will just be digits until ) because
2844         the syntax was checked in the first pass. */
2845
2846         else if ((DIGITAB(ptr[1]) && ctype_digit) != 0)
2847           {
2848           int condref;                 /* Don't amalgamate; some compilers */
2849           condref = *(++ptr) - '0';    /* grumble at autoincrement in declaration */
2850           while (*(++ptr) != ')') condref = condref*10 + *ptr - '0';
2851           if (condref == 0)
2852             {
2853             *errorcodeptr = ERR35;
2854             goto FAILED;
2855             }
2856           ptr++;
2857           code[1+LINK_SIZE] = OP_CREF;
2858           PUT2(code, 2+LINK_SIZE, condref);
2859           skipbytes = 3;
2860           }
2861         /* For conditions that are assertions, we just fall through, having
2862         set bravalue above. */
2863         break;
2864
2865         case '=':                 /* Positive lookahead */
2866         bravalue = OP_ASSERT;
2867         ptr++;
2868         break;
2869
2870         case '!':                 /* Negative lookahead */
2871         bravalue = OP_ASSERT_NOT;
2872         ptr++;
2873         break;
2874
2875         case '<':                 /* Lookbehinds */
2876         switch (*(++ptr))
2877           {
2878           case '=':               /* Positive lookbehind */
2879           bravalue = OP_ASSERTBACK;
2880           ptr++;
2881           break;
2882
2883           case '!':               /* Negative lookbehind */
2884           bravalue = OP_ASSERTBACK_NOT;
2885           ptr++;
2886           break;
2887           }
2888         break;
2889
2890         case '>':                 /* One-time brackets */
2891         bravalue = OP_ONCE;
2892         ptr++;
2893         break;
2894
2895         case 'C':                 /* Callout - may be followed by digits; */
2896         previous_callout = code;  /* Save for later completion */
2897         after_manual_callout = 1; /* Skip one item before completing */
2898         *code++ = OP_CALLOUT;     /* Already checked that the terminating */
2899           {                       /* closing parenthesis is present. */
2900           int n = 0;
2901           ++ptr;
2902           while ((DIGITAB(*ptr) & ctype_digit) != 0)
2903             {
2904             n = n * 10 + *ptr - '0';
2905             ++ptr;
2906             }
2907           if (n > 255)
2908             {
2909             *errorcodeptr = ERR38;
2910             goto FAILED;
2911             }
2912           *code++ = n;
2913           PUT(code, 0, ptr - cd->start_pattern + 1);  /* Pattern offset */
2914           PUT(code, LINK_SIZE, 0);                    /* Default length */
2915           code += 2 * LINK_SIZE;
2916           }
2917         previous = NULL;
2918         continue;
2919
2920         case 'P':                 /* Named subpattern handling */
2921         if (*(++ptr) == '<')      /* Definition */
2922           {
2923           int i, namelen;
2924           uschar *slot = cd->name_table;
2925           const pcre_uchar *name; /* Don't amalgamate; some compilers */
2926           name = ++ptr;           /* grumble at autoincrement in declaration */
2927
2928           while (*ptr++ != '>');
2929           namelen = ptr - name - 1;
2930
2931           // FIXME: This won't work for UTF-16.
2932           for (i = 0; i < cd->names_found; i++)
2933             {
2934             int crc = memcmp(name, slot+2, namelen);
2935             if (crc == 0)
2936               {
2937               if (slot[2+namelen] == 0)
2938                 {
2939                 *errorcodeptr = ERR43;
2940                 goto FAILED;
2941                 }
2942               crc = -1;             /* Current name is substring */
2943               }
2944             if (crc < 0)
2945               {
2946               memmove(slot + cd->name_entry_size, slot,
2947                 (cd->names_found - i) * cd->name_entry_size);
2948               break;
2949               }
2950             slot += cd->name_entry_size;
2951             }
2952
2953           PUT2(slot, 0, *brackets + 1);
2954           memcpy(slot + 2, name, namelen);
2955           slot[2+namelen] = 0;
2956           cd->names_found++;
2957           goto NUMBERED_GROUP;
2958           }
2959
2960         if (*ptr == '=' || *ptr == '>')  /* Reference or recursion */
2961           {
2962           int i, namelen;
2963           int type = *ptr++;
2964           const pcre_uchar *name = ptr;
2965           uschar *slot = cd->name_table;
2966
2967           while (*ptr != ')') ptr++;
2968           namelen = ptr - name;
2969
2970           for (i = 0; i < cd->names_found; i++)
2971             {
2972             if (STREQUAL(name, namelen, (char *)slot+2)) break;
2973             slot += cd->name_entry_size;
2974             }
2975           if (i >= cd->names_found)
2976             {
2977             *errorcodeptr = ERR15;
2978             goto FAILED;
2979             }
2980
2981           recno = GET2(slot, 0);
2982
2983           if (type == '>') goto HANDLE_RECURSION;  /* A few lines below */
2984
2985           /* Back reference */
2986
2987           previous = code;
2988           *code++ = OP_REF;
2989           PUT2INC(code, 0, recno);
2990           cd->backref_map |= (recno < 32)? (1 << recno) : 1;
2991           if (recno > cd->top_backref) cd->top_backref = recno;
2992           continue;
2993           }
2994
2995         /* Should never happen */
2996         break;
2997
2998         case 'R':                 /* Pattern recursion */
2999         ptr++;                    /* Same as (?0)      */
3000         /* Fall through */
3001
3002         /* Recursion or "subroutine" call */
3003
3004         case '0': case '1': case '2': case '3': case '4':
3005         case '5': case '6': case '7': case '8': case '9':
3006           {
3007           const uschar *called;
3008           recno = 0;
3009           while((DIGITAB(*ptr) & ctype_digit) != 0)
3010             recno = recno * 10 + *ptr++ - '0';
3011
3012           /* Come here from code above that handles a named recursion */
3013
3014           HANDLE_RECURSION:
3015
3016           previous = code;
3017
3018           /* Find the bracket that is being referenced. Temporarily end the
3019           regex in case it doesn't exist. */
3020
3021           *code = OP_END;
3022           called = (recno == 0)?
3023             cd->start_code : find_bracket(cd->start_code, utf8, recno);
3024
3025           if (called == NULL)
3026             {
3027             *errorcodeptr = ERR15;
3028             goto FAILED;
3029             }
3030
3031           /* If the subpattern is still open, this is a recursive call. We
3032           check to see if this is a left recursion that could loop for ever,
3033           and diagnose that case. */
3034
3035           if (GET(called, 1) == 0 && could_be_empty(called, code, bcptr, utf8))
3036             {
3037             *errorcodeptr = ERR40;
3038             goto FAILED;
3039             }
3040
3041           /* Insert the recursion/subroutine item */
3042
3043           *code = OP_RECURSE;
3044           PUT(code, 1, called - cd->start_code);
3045           code += 1 + LINK_SIZE;
3046           }
3047         continue;
3048
3049         /* Character after (? not specially recognized */
3050
3051         default:                  /* Option setting */
3052         set = unset = 0;
3053         optset = &set;
3054
3055         while (*ptr != ')' && *ptr != ':')
3056           {
3057           switch (*ptr++)
3058             {
3059             case '-': optset = &unset; break;
3060
3061             case 'i': *optset |= PCRE_CASELESS; break;
3062             case 'm': *optset |= PCRE_MULTILINE; break;
3063             case 's': *optset |= PCRE_DOTALL; break;
3064             case 'x': *optset |= PCRE_EXTENDED; break;
3065             case 'U': *optset |= PCRE_UNGREEDY; break;
3066             case 'X': *optset |= PCRE_EXTRA; break;
3067             }
3068           }
3069
3070         /* Set up the changed option bits, but don't change anything yet. */
3071
3072         newoptions = (options | set) & (~unset);
3073
3074         /* If the options ended with ')' this is not the start of a nested
3075         group with option changes, so the options change at this level. Compile
3076         code to change the ims options if this setting actually changes any of
3077         them. We also pass the new setting back so that it can be put at the
3078         start of any following branches, and when this group ends (if we are in
3079         a group), a resetting item can be compiled.
3080
3081         Note that if this item is right at the start of the pattern, the
3082         options will have been abstracted and made global, so there will be no
3083         change to compile. */
3084
3085         if (*ptr == ')')
3086           {
3087           if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))
3088             {
3089             *code++ = OP_OPT;
3090             *code++ = newoptions & PCRE_IMS;
3091             }
3092
3093           /* Change options at this level, and pass them back for use
3094           in subsequent branches. Reset the greedy defaults and the case
3095           value for firstbyte and reqbyte. */
3096
3097           *optionsptr = options = newoptions;
3098           greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
3099           greedy_non_default = greedy_default ^ 1;
3100           req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
3101
3102           previous = NULL;       /* This item can't be repeated */
3103           continue;              /* It is complete */
3104           }
3105
3106         /* If the options ended with ':' we are heading into a nested group
3107         with possible change of options. Such groups are non-capturing and are
3108         not assertions of any kind. All we need to do is skip over the ':';
3109         the newoptions value is handled below. */
3110
3111         bravalue = OP_BRA;
3112         ptr++;
3113         }
3114       }
3115
3116     /* If PCRE_NO_AUTO_CAPTURE is set, all unadorned brackets become
3117     non-capturing and behave like (?:...) brackets */
3118
3119     else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)
3120       {
3121       bravalue = OP_BRA;
3122       }
3123
3124     /* Else we have a referencing group; adjust the opcode. If the bracket
3125     number is greater than EXTRACT_BASIC_MAX, we set the opcode one higher, and
3126     arrange for the true number to follow later, in an OP_BRANUMBER item. */
3127
3128     else
3129       {
3130       NUMBERED_GROUP:
3131       if (++(*brackets) > EXTRACT_BASIC_MAX)
3132         {
3133         bravalue = OP_BRA + EXTRACT_BASIC_MAX + 1;
3134         code[1+LINK_SIZE] = OP_BRANUMBER;
3135         PUT2(code, 2+LINK_SIZE, *brackets);
3136         skipbytes = 3;
3137         }
3138       else bravalue = OP_BRA + *brackets;
3139       }
3140
3141     /* Process nested bracketed re. Assertions may not be repeated, but other
3142     kinds can be. We copy code into a non-register variable in order to be able
3143     to pass its address because some compilers complain otherwise. Pass in a
3144     new setting for the ims options if they have changed. */
3145
3146     previous = (bravalue >= OP_ONCE)? code : NULL;
3147     *code = bravalue;
3148     tempcode = code;
3149     tempreqvary = cd->req_varyopt;     /* Save value before bracket */
3150
3151     if (!compile_regex(
3152          newoptions,                   /* The complete new option state */
3153          options & PCRE_IMS,           /* The previous ims option state */
3154          brackets,                     /* Extracting bracket count */
3155          &tempcode,                    /* Where to put code (updated) */
3156          &ptr,                         /* Input pointer (updated) */
3157          errorcodeptr,                 /* Where to put an error message */
3158          (bravalue == OP_ASSERTBACK ||
3159           bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
3160          skipbytes,                    /* Skip over OP_COND/OP_BRANUMBER */
3161          &subfirstbyte,                /* For possible first char */
3162          &subreqbyte,                  /* For possible last char */
3163          bcptr,                        /* Current branch chain */
3164          cd))                          /* Tables block */
3165       goto FAILED;
3166
3167     /* At the end of compiling, code is still pointing to the start of the
3168     group, while tempcode has been updated to point past the end of the group
3169     and any option resetting that may follow it. The pattern pointer (ptr)
3170     is on the bracket. */
3171
3172     /* If this is a conditional bracket, check that there are no more than
3173     two branches in the group. */
3174
3175     else if (bravalue == OP_COND)
3176       {
3177       uschar *tc = code;
3178       condcount = 0;
3179
3180       do {
3181          condcount++;
3182          tc += GET(tc,1);
3183          }
3184       while (*tc != OP_KET);
3185
3186       if (condcount > 2)
3187         {
3188         *errorcodeptr = ERR27;
3189         goto FAILED;
3190         }
3191
3192       /* If there is just one branch, we must not make use of its firstbyte or
3193       reqbyte, because this is equivalent to an empty second branch. */
3194
3195       if (condcount == 1) subfirstbyte = subreqbyte = REQ_NONE;
3196       }
3197
3198     /* Handle updating of the required and first characters. Update for normal
3199     brackets of all kinds, and conditions with two branches (see code above).
3200     If the bracket is followed by a quantifier with zero repeat, we have to
3201     back off. Hence the definition of zeroreqbyte and zerofirstbyte outside the
3202     main loop so that they can be accessed for the back off. */
3203
3204     zeroreqbyte = reqbyte;
3205     zerofirstbyte = firstbyte;
3206     groupsetfirstbyte = FALSE;
3207
3208     if (bravalue >= OP_BRA || bravalue == OP_ONCE || bravalue == OP_COND)
3209       {
3210       /* If we have not yet set a firstbyte in this branch, take it from the
3211       subpattern, remembering that it was set here so that a repeat of more
3212       than one can replicate it as reqbyte if necessary. If the subpattern has
3213       no firstbyte, set "none" for the whole branch. In both cases, a zero
3214       repeat forces firstbyte to "none". */
3215
3216       if (firstbyte == REQ_UNSET)
3217         {
3218         if (subfirstbyte >= 0)
3219           {
3220           firstbyte = subfirstbyte;
3221           groupsetfirstbyte = TRUE;
3222           }
3223         else firstbyte = REQ_NONE;
3224         zerofirstbyte = REQ_NONE;
3225         }
3226
3227       /* If firstbyte was previously set, convert the subpattern's firstbyte
3228       into reqbyte if there wasn't one, using the vary flag that was in
3229       existence beforehand. */
3230
3231       else if (subfirstbyte >= 0 && subreqbyte < 0)
3232         subreqbyte = subfirstbyte | tempreqvary;
3233
3234       /* If the subpattern set a required byte (or set a first byte that isn't
3235       really the first byte - see above), set it. */
3236
3237       if (subreqbyte >= 0) reqbyte = subreqbyte;
3238       }
3239
3240     /* For a forward assertion, we take the reqbyte, if set. This can be
3241     helpful if the pattern that follows the assertion doesn't set a different
3242     char. For example, it's useful for /(?=abcde).+/. We can't set firstbyte
3243     for an assertion, however because it leads to incorrect effect for patterns
3244     such as /(?=a)a.+/ when the "real" "a" would then become a reqbyte instead
3245     of a firstbyte. This is overcome by a scan at the end if there's no
3246     firstbyte, looking for an asserted first char. */
3247
3248     else if (bravalue == OP_ASSERT && subreqbyte >= 0) reqbyte = subreqbyte;
3249
3250     /* Now update the main code pointer to the end of the group. */
3251
3252     code = tempcode;
3253
3254     /* Error if hit end of pattern */
3255
3256     if (*ptr != ')')
3257       {
3258       *errorcodeptr = ERR14;
3259       goto FAILED;
3260       }
3261     break;
3262
3263     /* Check \ for being a real metacharacter; if not, fall through and handle
3264     it as a data character at the start of a string. Escape items are checked
3265     for validity in the pre-compiling pass. */
3266
3267     case '\\':
3268     tempptr = ptr;
3269     c = check_escape(&ptr, errorcodeptr, *brackets, options, FALSE);
3270
3271     /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
3272     are arranged to be the negation of the corresponding OP_values. For the
3273     back references, the values are ESC_REF plus the reference number. Only
3274     back references and those types that consume a character may be repeated.
3275     We can test for values between ESC_b and ESC_Z for the latter; this may
3276     have to change if any new ones are ever created. */
3277
3278     if (c < 0)
3279       {
3280       if (-c == ESC_Q)            /* Handle start of quoted string */
3281         {
3282         if (ptr[1] == '\\' && ptr[2] == 'E') ptr += 2; /* avoid empty string */
3283           else inescq = TRUE;
3284         continue;
3285         }
3286
3287       /* For metasequences that actually match a character, we disable the
3288       setting of a first character if it hasn't already been set. */
3289
3290       if (firstbyte == REQ_UNSET && -c > ESC_b && -c < ESC_Z)
3291         firstbyte = REQ_NONE;
3292
3293       /* Set values to reset to if this is followed by a zero repeat. */
3294
3295       zerofirstbyte = firstbyte;
3296       zeroreqbyte = reqbyte;
3297
3298       /* Back references are handled specially */
3299
3300       if (-c >= ESC_REF)
3301         {
3302         int number = -c - ESC_REF;
3303         previous = code;
3304         *code++ = OP_REF;
3305         PUT2INC(code, 0, number);
3306         }
3307
3308       /* So are Unicode property matches, if supported. We know that get_ucp
3309       won't fail because it was tested in the pre-pass. */
3310
3311 #ifdef SUPPORT_UCP
3312       else if (-c == ESC_P || -c == ESC_p)
3313         {
3314         BOOL negated;
3315         int value = get_ucp(&ptr, &negated, errorcodeptr);
3316         previous = code;
3317         *code++ = ((-c == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
3318         *code++ = value;
3319         }
3320 #endif
3321
3322       /* For the rest, we can obtain the OP value by negating the escape
3323       value */
3324
3325       else
3326         {
3327         previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
3328         *code++ = -c;
3329         }
3330       continue;
3331       }
3332
3333     /* We have a data character whose value is in c. In UTF-8 mode it may have
3334     a value > 127. We set its representation in the length/buffer, and then
3335     handle it as a data character. */
3336
3337 #ifdef SUPPORT_UTF8
3338     if (utf8 && c > 127)
3339       mclength = _pcre_ord2utf8(c, mcbuffer);
3340     else
3341 #endif
3342
3343      {
3344      mcbuffer[0] = c;
3345      mclength = 1;
3346      }
3347
3348     goto ONE_CHAR;
3349
3350     /* Handle a literal character. It is guaranteed not to be whitespace or #
3351     when the extended flag is set. If we are in UTF-8 mode, it may be a
3352     multi-byte literal character. */
3353
3354     default:
3355     NORMAL_CHAR:
3356 #if PCRE_UTF16
3357     if (c < 128)
3358       {
3359        mclength = 1;
3360        mcbuffer[0] = c;
3361      }
3362     else
3363       mclength = _pcre_ord2utf8(c, mcbuffer);
3364 #else
3365     mclength = 1;
3366     mcbuffer[0] = c;
3367
3368 #ifdef SUPPORT_UTF8
3369     if (utf8 && (c & 0xc0) == 0xc0)
3370       {
3371       while ((ptr[1] & 0xc0) == 0x80)
3372         mcbuffer[mclength++] = *(++ptr);
3373       }
3374 #endif
3375 #endif
3376
3377     /* At this point we have the character's bytes in mcbuffer, and the length
3378     in mclength. When not in UTF-8 mode, the length is always 1. */
3379
3380     ONE_CHAR:
3381     previous = code;
3382     *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARNC : OP_CHAR;
3383     for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
3384
3385     /* Set the first and required bytes appropriately. If no previous first
3386     byte, set it from this character, but revert to none on a zero repeat.
3387     Otherwise, leave the firstbyte value alone, and don't change it on a zero
3388     repeat. */
3389
3390     if (firstbyte == REQ_UNSET)
3391       {
3392       zerofirstbyte = REQ_NONE;
3393       zeroreqbyte = reqbyte;
3394
3395       /* If the character is more than one byte long, we can set firstbyte
3396       only if it is not to be matched caselessly. */
3397
3398       if (mclength == 1 || req_caseopt == 0)
3399         {
3400         firstbyte = mcbuffer[0] | req_caseopt;
3401         if (mclength != 1) reqbyte = code[-1] | cd->req_varyopt;
3402         }
3403       else firstbyte = reqbyte = REQ_NONE;
3404       }
3405
3406     /* firstbyte was previously set; we can set reqbyte only the length is
3407     1 or the matching is caseful. */
3408
3409     else
3410       {
3411       zerofirstbyte = firstbyte;
3412       zeroreqbyte = reqbyte;
3413       if (mclength == 1 || req_caseopt == 0)
3414         reqbyte = code[-1] | req_caseopt | cd->req_varyopt;
3415       }
3416
3417     break;            /* End of literal character handling */
3418     }
3419   }                   /* end of big loop */
3420
3421 /* Control never reaches here by falling through, only by a goto for all the
3422 error states. Pass back the position in the pattern so that it can be displayed
3423 to the user for diagnosing the error. */
3424
3425 FAILED:
3426 *ptrptr = ptr;
3427 return FALSE;
3428 }
3429
3430
3431
3432
3433 /*************************************************
3434 *     Compile sequence of alternatives           *
3435 *************************************************/
3436
3437 /* On entry, ptr is pointing past the bracket character, but on return
3438 it points to the closing bracket, or vertical bar, or end of string.
3439 The code variable is pointing at the byte into which the BRA operator has been
3440 stored. If the ims options are changed at the start (for a (?ims: group) or
3441 during any branch, we need to insert an OP_OPT item at the start of every
3442 following branch to ensure they get set correctly at run time, and also pass
3443 the new options into every subsequent branch compile.
3444
3445 Argument:
3446   options        option bits, including any changes for this subpattern
3447   oldims         previous settings of ims option bits
3448   brackets       -> int containing the number of extracting brackets used
3449   codeptr        -> the address of the current code pointer
3450   ptrptr         -> the address of the current pattern pointer
3451   errorcodeptr   -> pointer to error code variable
3452   lookbehind     TRUE if this is a lookbehind assertion
3453   skipbytes      skip this many bytes at start (for OP_COND, OP_BRANUMBER)
3454   firstbyteptr   place to put the first required character, or a negative number
3455   reqbyteptr     place to put the last required character, or a negative number
3456   bcptr          pointer to the chain of currently open branches
3457   cd             points to the data block with tables pointers etc.
3458
3459 Returns:      TRUE on success
3460 */
3461
3462 static BOOL
3463 compile_regex(int options, int oldims, int *brackets, uschar **codeptr,
3464   const pcre_uchar **ptrptr, int *errorcodeptr, BOOL lookbehind, int skipbytes,
3465   int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr, compile_data *cd)
3466 {
3467 const pcre_uchar *ptr = *ptrptr;
3468 uschar *code = *codeptr;
3469 uschar *last_branch = code;
3470 uschar *start_bracket = code;
3471 uschar *reverse_count = NULL;
3472 int firstbyte, reqbyte;
3473 int branchfirstbyte, branchreqbyte;
3474 branch_chain bc;
3475
3476 bc.outer = bcptr;
3477 bc.current = code;
3478
3479 firstbyte = reqbyte = REQ_UNSET;
3480
3481 /* Offset is set zero to mark that this bracket is still open */
3482
3483 PUT(code, 1, 0);
3484 code += 1 + LINK_SIZE + skipbytes;
3485
3486 /* Loop for each alternative branch */
3487
3488 for (;;)
3489   {
3490   /* Handle a change of ims options at the start of the branch */
3491
3492   if ((options & PCRE_IMS) != oldims)
3493     {
3494     *code++ = OP_OPT;
3495     *code++ = options & PCRE_IMS;
3496     }
3497
3498   /* Set up dummy OP_REVERSE if lookbehind assertion */
3499
3500   if (lookbehind)
3501     {
3502     *code++ = OP_REVERSE;
3503     reverse_count = code;
3504     PUTINC(code, 0, 0);
3505     }
3506
3507   /* Now compile the branch */
3508
3509   if (!compile_branch(&options, brackets, &code, &ptr, errorcodeptr,
3510         &branchfirstbyte, &branchreqbyte, &bc, cd))
3511     {
3512     *ptrptr = ptr;
3513     return FALSE;
3514     }
3515
3516   /* If this is the first branch, the firstbyte and reqbyte values for the
3517   branch become the values for the regex. */
3518
3519   if (*last_branch != OP_ALT)
3520     {
3521     firstbyte = branchfirstbyte;
3522     reqbyte = branchreqbyte;
3523     }
3524
3525   /* If this is not the first branch, the first char and reqbyte have to
3526   match the values from all the previous branches, except that if the previous
3527   value for reqbyte didn't have REQ_VARY set, it can still match, and we set
3528   REQ_VARY for the regex. */
3529
3530   else
3531     {
3532     /* If we previously had a firstbyte, but it doesn't match the new branch,
3533     we have to abandon the firstbyte for the regex, but if there was previously
3534     no reqbyte, it takes on the value of the old firstbyte. */
3535
3536     if (firstbyte >= 0 && firstbyte != branchfirstbyte)
3537       {
3538       if (reqbyte < 0) reqbyte = firstbyte;
3539       firstbyte = REQ_NONE;
3540       }
3541
3542     /* If we (now or from before) have no firstbyte, a firstbyte from the
3543     branch becomes a reqbyte if there isn't a branch reqbyte. */
3544
3545     if (firstbyte < 0 && branchfirstbyte >= 0 && branchreqbyte < 0)
3546         branchreqbyte = branchfirstbyte;
3547
3548     /* Now ensure that the reqbytes match */
3549
3550     if ((reqbyte & ~REQ_VARY) != (branchreqbyte & ~REQ_VARY))
3551       reqbyte = REQ_NONE;
3552     else reqbyte |= branchreqbyte;   /* To "or" REQ_VARY */
3553     }
3554
3555   /* If lookbehind, check that this branch matches a fixed-length string,
3556   and put the length into the OP_REVERSE item. Temporarily mark the end of
3557   the branch with OP_END. */
3558
3559   if (lookbehind)
3560     {
3561     int length;
3562     *code = OP_END;
3563     length = find_fixedlength(last_branch, options);
3564     DPRINTF(("fixed length = %d\n", length));
3565     if (length < 0)
3566       {
3567       *errorcodeptr = (length == -2)? ERR36 : ERR25;
3568       *ptrptr = ptr;
3569       return FALSE;
3570       }
3571     PUT(reverse_count, 0, length);
3572     }
3573
3574   /* Reached end of expression, either ')' or end of pattern. Go back through
3575   the alternative branches and reverse the chain of offsets, with the field in
3576   the BRA item now becoming an offset to the first alternative. If there are
3577   no alternatives, it points to the end of the group. The length in the
3578   terminating ket is always the length of the whole bracketed item. If any of
3579   the ims options were changed inside the group, compile a resetting op-code
3580   following, except at the very end of the pattern. Return leaving the pointer
3581   at the terminating char. */
3582
3583   if (*ptr != '|')
3584     {
3585     int length = code - last_branch;
3586     do
3587       {
3588       int prev_length = GET(last_branch, 1);
3589       PUT(last_branch, 1, length);
3590       length = prev_length;
3591       last_branch -= length;
3592       }
3593     while (length > 0);
3594
3595     /* Fill in the ket */
3596
3597     *code = OP_KET;
3598     PUT(code, 1, code - start_bracket);
3599     code += 1 + LINK_SIZE;
3600
3601     /* Resetting option if needed */
3602
3603     if ((options & PCRE_IMS) != oldims && *ptr == ')')
3604       {
3605       *code++ = OP_OPT;
3606       *code++ = oldims;
3607       }
3608
3609     /* Set values to pass back */
3610
3611     *codeptr = code;
3612     *ptrptr = ptr;
3613     *firstbyteptr = firstbyte;
3614     *reqbyteptr = reqbyte;
3615     return TRUE;
3616     }
3617
3618   /* Another branch follows; insert an "or" node. Its length field points back
3619   to the previous branch while the bracket remains open. At the end the chain
3620   is reversed. It's done like this so that the start of the bracket has a
3621   zero offset until it is closed, making it possible to detect recursion. */
3622
3623   *code = OP_ALT;
3624   PUT(code, 1, code - last_branch);
3625   bc.current = last_branch = code;
3626   code += 1 + LINK_SIZE;
3627   ptr++;
3628   }
3629 /* Control never reaches here */
3630 }
3631
3632
3633
3634
3635 /*************************************************
3636 *          Check for anchored expression         *
3637 *************************************************/
3638
3639 /* Try to find out if this is an anchored regular expression. Consider each
3640 alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
3641 all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
3642 it's anchored. However, if this is a multiline pattern, then only OP_SOD
3643 counts, since OP_CIRC can match in the middle.
3644
3645 We can also consider a regex to be anchored if OP_SOM starts all its branches.
3646 This is the code for \G, which means "match at start of match position, taking
3647 into account the match offset".
3648
3649 A branch is also implicitly anchored if it starts with .* and DOTALL is set,
3650 because that will try the rest of the pattern at all possible matching points,
3651 so there is no point trying again.... er ....
3652
3653 .... except when the .* appears inside capturing parentheses, and there is a
3654 subsequent back reference to those parentheses. We haven't enough information
3655 to catch that case precisely.
3656
3657 At first, the best we could do was to detect when .* was in capturing brackets
3658 and the highest back reference was greater than or equal to that level.
3659 However, by keeping a bitmap of the first 31 back references, we can catch some
3660 of the more common cases more precisely.
3661
3662 Arguments:
3663   code           points to start of expression (the bracket)
3664   options        points to the options setting
3665   bracket_map    a bitmap of which brackets we are inside while testing; this
3666                   handles up to substring 31; after that we just have to take
3667                   the less precise approach
3668   backref_map    the back reference bitmap
3669
3670 Returns:     TRUE or FALSE
3671 */
3672
3673 static BOOL
3674 is_anchored(register const uschar *code, int *options, unsigned int bracket_map,
3675   unsigned int backref_map)
3676 {
3677 do {
3678    const uschar *scode =
3679      first_significant_code(code + 1+LINK_SIZE, options, PCRE_MULTILINE, FALSE);
3680    register int op = *scode;
3681
3682    /* Capturing brackets */
3683
3684    if (op > OP_BRA)
3685      {
3686      int new_map;
3687      op -= OP_BRA;
3688      if (op > EXTRACT_BASIC_MAX) op = GET2(scode, 2+LINK_SIZE);
3689      new_map = bracket_map | ((op < 32)? (1 << op) : 1);
3690      if (!is_anchored(scode, options, new_map, backref_map)) return FALSE;
3691      }
3692
3693    /* Other brackets */
3694
3695    else if (op == OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
3696      {
3697      if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
3698      }
3699
3700    /* .* is not anchored unless DOTALL is set and it isn't in brackets that
3701    are or may be referenced. */
3702
3703    else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR) &&
3704             (*options & PCRE_DOTALL) != 0)
3705      {
3706      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
3707      }
3708
3709    /* Check for explicit anchoring */
3710
3711    else if (op != OP_SOD && op != OP_SOM &&
3712            ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
3713      return FALSE;
3714    code += GET(code, 1);
3715    }
3716 while (*code == OP_ALT);   /* Loop for each alternative */
3717 return TRUE;
3718 }
3719
3720
3721
3722 /*************************************************
3723 *         Check for starting with ^ or .*        *
3724 *************************************************/
3725
3726 /* This is called to find out if every branch starts with ^ or .* so that
3727 "first char" processing can be done to speed things up in multiline
3728 matching and for non-DOTALL patterns that start with .* (which must start at
3729 the beginning or after \n). As in the case of is_anchored() (see above), we
3730 have to take account of back references to capturing brackets that contain .*
3731 because in that case we can't make the assumption.
3732
3733 Arguments:
3734   code           points to start of expression (the bracket)
3735   bracket_map    a bitmap of which brackets we are inside while testing; this
3736                   handles up to substring 31; after that we just have to take
3737                   the less precise approach
3738   backref_map    the back reference bitmap
3739
3740 Returns:         TRUE or FALSE
3741 */
3742
3743 static BOOL
3744 is_startline(const uschar *code, unsigned int bracket_map,
3745   unsigned int backref_map)
3746 {
3747 do {
3748    const uschar *scode = first_significant_code(code + 1+LINK_SIZE, NULL, 0,
3749      FALSE);
3750    register int op = *scode;
3751
3752    /* Capturing brackets */
3753
3754    if (op > OP_BRA)
3755      {
3756      int new_map;
3757      op -= OP_BRA;
3758      if (op > EXTRACT_BASIC_MAX) op = GET2(scode, 2+LINK_SIZE);
3759      new_map = bracket_map | ((op < 32)? (1 << op) : 1);
3760      if (!is_startline(scode, new_map, backref_map)) return FALSE;
3761      }
3762
3763    /* Other brackets */
3764
3765    else if (op == OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
3766      { if (!is_startline(scode, bracket_map, backref_map)) return FALSE; }
3767
3768    /* .* means "start at start or after \n" if it isn't in brackets that
3769    may be referenced. */
3770
3771    else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
3772      {
3773      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
3774      }
3775
3776    /* Check for explicit circumflex */
3777
3778    else if (op != OP_CIRC) return FALSE;
3779
3780    /* Move on to the next alternative */
3781
3782    code += GET(code, 1);
3783    }
3784 while (*code == OP_ALT);  /* Loop for each alternative */
3785 return TRUE;
3786 }
3787
3788
3789
3790 /*************************************************
3791 *       Check for asserted fixed first char      *
3792 *************************************************/
3793
3794 /* During compilation, the "first char" settings from forward assertions are
3795 discarded, because they can cause conflicts with actual literals that follow.
3796 However, if we end up without a first char setting for an unanchored pattern,
3797 it is worth scanning the regex to see if there is an initial asserted first
3798 char. If all branches start with the same asserted char, or with a bracket all
3799 of whose alternatives start with the same asserted char (recurse ad lib), then
3800 we return that char, otherwise -1.
3801
3802 Arguments:
3803   code       points to start of expression (the bracket)
3804   options    pointer to the options (used to check casing changes)
3805   inassert   TRUE if in an assertion
3806
3807 Returns:     -1 or the fixed first char
3808 */
3809
3810 static int
3811 find_firstassertedchar(const uschar *code, int *options, BOOL inassert)
3812 {
3813 register int c = -1;
3814 do {
3815    int d;
3816    const uschar *scode =
3817      first_significant_code(code + 1+LINK_SIZE, options, PCRE_CASELESS, TRUE);
3818    register int op = *scode;
3819
3820    if (op >= OP_BRA) op = OP_BRA;
3821
3822    switch(op)
3823      {
3824      default:
3825      return -1;
3826
3827      case OP_BRA:
3828      case OP_ASSERT:
3829      case OP_ONCE:
3830      case OP_COND:
3831      if ((d = find_firstassertedchar(scode, options, op == OP_ASSERT)) < 0)
3832        return -1;
3833      if (c < 0) c = d; else if (c != d) return -1;
3834      break;
3835
3836      case OP_EXACT:       /* Fall through */
3837      scode += 2;
3838
3839      case OP_CHAR:
3840      case OP_CHARNC:
3841      case OP_PLUS:
3842      case OP_MINPLUS:
3843      if (!inassert) return -1;
3844      if (c < 0)
3845        {
3846        c = scode[1];
3847        if ((*options & PCRE_CASELESS) != 0) c |= REQ_CASELESS;
3848        }
3849      else if (c != scode[1]) return -1;
3850      break;
3851      }
3852
3853    code += GET(code, 1);
3854    }
3855 while (*code == OP_ALT);
3856 return c;
3857 }
3858
3859
3860
3861 /*************************************************
3862 *        Compile a Regular Expression            *
3863 *************************************************/
3864
3865 /* This function takes a string and returns a pointer to a block of store
3866 holding a compiled version of the expression. The original API for this
3867 function had no error code return variable; it is retained for backwards
3868 compatibility. The new function is given a new name.
3869
3870 Arguments:
3871   pattern       the regular expression
3872   options       various option bits
3873   errorcodeptr  pointer to error code variable (pcre_compile2() only)
3874                   can be NULL if you don't want a code value
3875   errorptr      pointer to pointer to error text
3876   erroroffset   ptr offset in pattern where error was detected
3877   tables        pointer to character tables or NULL
3878
3879 Returns:        pointer to compiled data block, or NULL on error,
3880                 with errorptr and erroroffset set
3881 */
3882
3883 EXPORT pcre *
3884 pcre_compile(const pcre_char *pattern, int options, const char **errorptr,
3885   int *erroroffset, const unsigned char *tables)
3886 {
3887 return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
3888 }
3889
3890
3891 EXPORT pcre *
3892 pcre_compile2(const pcre_char *pattern, int options, int *errorcodeptr,
3893   const char **errorptr, int *erroroffset, const unsigned char *tables)
3894 {
3895 real_pcre *re;
3896 int length = 1 + LINK_SIZE;      /* For initial BRA plus length */
3897 int c, firstbyte, reqbyte;
3898 int bracount = 0;
3899 int branch_extra = 0;
3900 int branch_newextra;
3901 int item_count = -1;
3902 int name_count = 0;
3903 int max_name_size = 0;
3904 int lastitemlength = 0;
3905 int errorcode = 0;
3906 #ifdef SUPPORT_UTF8
3907 BOOL utf8;
3908 BOOL class_utf8;
3909 #endif
3910 BOOL inescq = FALSE;
3911 unsigned int brastackptr = 0;
3912 size_t size;
3913 uschar *code;
3914 const uschar *codestart;
3915 const pcre_uchar *ptr;
3916 compile_data compile_block;
3917 int brastack[BRASTACK_SIZE];
3918 uschar bralenstack[BRASTACK_SIZE];
3919
3920 /* We can't pass back an error message if errorptr is NULL; I guess the best we
3921 can do is just return NULL, but we can set a code value if there is a code
3922 pointer. */
3923
3924 if (errorptr == NULL)
3925   {
3926   if (errorcodeptr != NULL) *errorcodeptr = 99;
3927   return NULL;
3928   }
3929
3930 *errorptr = NULL;
3931 if (errorcodeptr != NULL) *errorcodeptr = ERR0;
3932
3933 /* However, we can give a message for this error */
3934
3935 if (erroroffset == NULL)
3936   {
3937   errorcode = ERR16;
3938   goto PCRE_EARLY_ERROR_RETURN;
3939   }
3940
3941 *erroroffset = 0;
3942
3943 /* Always set the UTF-8 flag if we're compiled for UTF-16; saves on ifdefs. */
3944
3945 #if PCRE_UTF16
3946 options |= PCRE_UTF8;
3947 #endif
3948
3949 /* Can't support UTF8 unless PCRE has been compiled to include the code. */
3950
3951 #ifdef SUPPORT_UTF8
3952 utf8 = (options & PCRE_UTF8) != 0;
3953 #if !PCRE_UTF16
3954 if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
3955      (*erroroffset = _pcre_valid_utf8((pcre_uchar *)pattern, -1)) >= 0)
3956   {
3957   errorcode = ERR44;
3958   goto PCRE_EARLY_ERROR_RETURN;
3959   }
3960 #endif
3961 #else
3962 if ((options & PCRE_UTF8) != 0)
3963   {
3964   errorcode = ERR32;
3965   goto PCRE_EARLY_ERROR_RETURN;
3966   }
3967 #endif
3968
3969 if ((options & ~PUBLIC_OPTIONS) != 0)
3970   {
3971   errorcode = ERR17;
3972   goto PCRE_EARLY_ERROR_RETURN;
3973   }
3974
3975 /* Set up pointers to the individual character tables */
3976
3977 if (tables == NULL) tables = _pcre_default_tables;
3978 compile_block.lcc = tables + lcc_offset;
3979 compile_block.fcc = tables + fcc_offset;
3980 compile_block.cbits = tables + cbits_offset;
3981 compile_block.ctypes = tables + ctypes_offset;
3982
3983 /* Maximum back reference and backref bitmap. This is updated for numeric
3984 references during the first pass, but for named references during the actual
3985 compile pass. The bitmap records up to 31 back references to help in deciding
3986 whether (.*) can be treated as anchored or not. */
3987
3988 compile_block.top_backref = 0;
3989 compile_block.backref_map = 0;
3990
3991 /* Reflect pattern for debugging output */
3992
3993 DPRINTF(("------------------------------------------------------------------\n"));
3994 DPRINTF(("%s\n", pattern));
3995
3996 /* The first thing to do is to make a pass over the pattern to compute the
3997 amount of store required to hold the compiled code. This does not have to be
3998 perfect as long as errors are overestimates. At the same time we can detect any
3999 flag settings right at the start, and extract them. Make an attempt to correct
4000 for any counted white space if an "extended" flag setting appears late in the
4001 pattern. We can't be so clever for #-comments. */
4002
4003 ptr = (const pcre_uchar *)(pattern - 1);
4004 while ((c = *(++ptr)) != 0)
4005   {
4006   int min, max;
4007   int class_optcount;
4008   int bracket_length;
4009   int duplength;
4010
4011   /* If we are inside a \Q...\E sequence, all chars are literal */
4012
4013   if (inescq)
4014     {
4015     if ((options & PCRE_AUTO_CALLOUT) != 0) length += 2 + 2*LINK_SIZE;
4016     goto NORMAL_CHAR;
4017     }
4018
4019   /* Otherwise, first check for ignored whitespace and comments */
4020
4021   if ((options & PCRE_EXTENDED) != 0)
4022     {
4023     if ((CTYPES(&compile_block, c) & ctype_space) != 0) continue;
4024     if (c == '#')
4025       {
4026       /* The space before the ; is to avoid a warning on a silly compiler
4027       on the Macintosh. */
4028       while ((c = *(++ptr)) != 0 && c != NEWLINE) ;
4029       if (c == 0) break;
4030       continue;
4031       }
4032     }
4033
4034   item_count++;    /* Is zero for the first non-comment item */
4035
4036   /* Allow space for auto callout before every item except quantifiers. */
4037
4038   if ((options & PCRE_AUTO_CALLOUT) != 0 &&
4039        c != '*' && c != '+' && c != '?' &&
4040        (c != '{' || !is_counted_repeat(ptr + 1)))
4041     length += 2 + 2*LINK_SIZE;
4042
4043   switch(c)
4044     {
4045     /* A backslashed item may be an escaped data character or it may be a
4046     character type. */
4047
4048     case '\\':
4049     c = check_escape(&ptr, &errorcode, bracount, options, FALSE);
4050     if (errorcode != 0) goto PCRE_ERROR_RETURN;
4051
4052     lastitemlength = 1;     /* Default length of last item for repeats */
4053
4054     if (c >= 0)             /* Data character */
4055       {
4056       length += 2;          /* For a one-byte character */
4057
4058 #ifdef SUPPORT_UTF8
4059       if (utf8 && c > 127)
4060         {
4061         int i;
4062         for (i = 0; i < _pcre_utf8_table1_size; i++)
4063           if (c <= _pcre_utf8_table1[i]) break;
4064         length += i;
4065         lastitemlength += i;
4066         }
4067 #endif
4068
4069       continue;
4070       }
4071
4072     /* If \Q, enter "literal" mode */
4073
4074     if (-c == ESC_Q)
4075       {
4076       inescq = TRUE;
4077       continue;
4078       }
4079
4080     /* \X is supported only if Unicode property support is compiled */
4081
4082 #ifndef SUPPORT_UCP
4083     if (-c == ESC_X)
4084       {
4085       errorcode = ERR45;
4086       goto PCRE_ERROR_RETURN;
4087       }
4088 #endif
4089
4090     /* \P and \p are for Unicode properties, but only when the support has
4091     been compiled. Each item needs 2 bytes. */
4092
4093     else if (-c == ESC_P || -c == ESC_p)
4094       {
4095 #ifdef SUPPORT_UCP