pcre_compile.c

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