.pc/Fix-silly-quantifier-size-check.patch/pcre_compile.c

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