/*************************************************

*      Perl-Compatible Regular Expressions       *

*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax

and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel

     Original API code Copyright (c) 1997-2012 University of Cambridge

          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,

      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in the

      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its

      contributors may be used to endorse or promote products derived from

      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

-----------------------------------------------------------------------------

*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#define NLBLOCK cb             /* Block containing newline information */

#define PSSTART start_pattern  /* Field containing processed string start */

#define PSEND   end_pattern    /* Field containing processed string end */

#include "pcre2_internal.h"

/* In rare error cases debugging might require calling pcre2_printint(). */

#if 0

#ifdef EBCDIC

#define PRINTABLE(c) ((c) >= 64 && (c) < 255)

#else

#define PRINTABLE(c) ((c) >= 32 && (c) < 127)

#endif

#include "pcre2_printint.c"

#define DEBUG_CALL_PRINTINT

#endif

/* Other debugging code can be enabled by these defines. */

/* #define DEBUG_SHOW_CAPTURES */

/* #define DEBUG_SHOW_PARSED */

/* There are a few things that vary with different code unit sizes. Handle them

by defining macros in order to minimize #if usage. */

#if PCRE2_CODE_UNIT_WIDTH == 8

#define STRING_UTFn_RIGHTPAR     STRING_UTF8_RIGHTPAR, 5

#define XDIGIT(c)                xdigitab[c]

#else  /* Either 16-bit or 32-bit */

#define XDIGIT(c)                (MAX_255(c)? xdigitab[c] : 0xff)

#if PCRE2_CODE_UNIT_WIDTH == 16

#define STRING_UTFn_RIGHTPAR     STRING_UTF16_RIGHTPAR, 6

#else  /* 32-bit */

#define STRING_UTFn_RIGHTPAR     STRING_UTF32_RIGHTPAR, 6

#endif

#endif

/* Macros to store and retrieve a PCRE2_SIZE value in the parsed pattern, which

consists of uint32_t elements. Assume that if uint32_t can't hold it, two of

them will be able to (i.e. assume a 64-bit world). */

#if PCRE2_SIZE_MAX <= UINT32_MAX

#define PUTOFFSET(s,p) *p++ = s

#define GETOFFSET(s,p) s = *p++

#define GETPLUSOFFSET(s,p) s = *(++p)

#define READPLUSOFFSET(s,p) s = p[1]

#define SKIPOFFSET(p) p++

#define SIZEOFFSET 1

#else

#define PUTOFFSET(s,p) \

  { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); }

#define GETOFFSET(s,p) \

  { s = ((PCRE2_SIZE)p[0] << 32) | (PCRE2_SIZE)p[1]; p += 2; }

#define GETPLUSOFFSET(s,p) \

  { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; }

#define READPLUSOFFSET(s,p) \

  { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; }

#define SKIPOFFSET(p) p += 2

#define SIZEOFFSET 2

#endif

/* Macros for manipulating elements of the parsed pattern vector. */

#define META_CODE(x)   (x & 0xffff0000u)

#define META_DATA(x)   (x & 0x0000ffffu)

#define META_DIFF(x,y) ((x-y)>>16)

/* Function definitions to allow mutual recursion */

#ifdef SUPPORT_UNICODE

static unsigned int

  add_list_to_class_internal(uint8_t *, PCRE2_UCHAR **, uint32_t, uint32_t,

    compile_block *, const uint32_t *, unsigned int);

#endif

static int

  compile_regex(uint32_t, uint32_t, PCRE2_UCHAR **, uint32_t **, int *,

    uint32_t, uint32_t *, uint32_t *, uint32_t *, uint32_t *, branch_chain *,

    open_capitem *, compile_block *, PCRE2_SIZE *);

static int

  get_branchlength(uint32_t **, int *, int *, int *, parsed_recurse_check *,

    compile_block *);

static BOOL

  set_lookbehind_lengths(uint32_t **, int *, int *, parsed_recurse_check *,

    compile_block *);

static int

  check_lookbehinds(uint32_t *, uint32_t **, parsed_recurse_check *,

    compile_block *, int *);

/*************************************************

*      Code parameters and static tables         *

*************************************************/

#define MAX_GROUP_NUMBER   65535u

#define MAX_REPEAT_COUNT   65535u

#define REPEAT_UNLIMITED   (MAX_REPEAT_COUNT+1)

/* COMPILE_WORK_SIZE specifies the size of stack workspace, which is used in

different ways in the different pattern scans. The parsing and group-

identifying pre-scan uses it to handle nesting, and needs it to be 16-bit

aligned for this. Having defined the size in code units, we set up

C16_WORK_SIZE as the number of elements in the 16-bit vector.

During the first compiling phase, when determining how much memory is required,

the regex is partly compiled into this space, but the compiled parts are

discarded as soon as they can be, so that hopefully there will never be an

overrun. The code does, however, check for an overrun, which can occur for

pathological patterns. The size of the workspace depends on LINK_SIZE because

the length of compiled items varies with this.

In the real compile phase, this workspace is not currently used. */

#define COMPILE_WORK_SIZE (3000*LINK_SIZE)   /* Size in code units */

#define C16_WORK_SIZE \

  ((COMPILE_WORK_SIZE * sizeof(PCRE2_UCHAR))/sizeof(uint16_t))

/* A uint32_t vector is used for caching information about the size of

capturing groups, to improve performance. A default is created on the stack of

this size. */

#define GROUPINFO_DEFAULT_SIZE 256

/* The overrun tests check for a slightly smaller size so that they detect the

overrun before it actually does run off the end of the data block. */

#define WORK_SIZE_SAFETY_MARGIN (100)

/* This value determines the size of the initial vector that is used for

remembering named groups during the pre-compile. It is allocated on the stack,

but if it is too small, it is expanded, in a similar way to the workspace. The

value is the number of slots in the list. */

#define NAMED_GROUP_LIST_SIZE  20

/* The pre-compiling pass over the pattern creates a parsed pattern in a vector

of uint32_t. For short patterns this lives on the stack, with this size. Heap

memory is used for longer patterns. */

#define PARSED_PATTERN_DEFAULT_SIZE 1024

/* Maximum length value to check against when making sure that the variable

that holds the compiled pattern length does not overflow. We make it a bit less

than INT_MAX to allow for adding in group terminating code units, so that we

don't have to check them every time. */

#define OFLOW_MAX (INT_MAX - 20)

/* Code values for parsed patterns, which are stored in a vector of 32-bit

unsigned ints. Values less than META_END are literal data values. The coding

for identifying the item is in the top 16-bits, leaving 16 bits for the

additional data that some of them need. The META_CODE, META_DATA, and META_DIFF

macros are used to manipulate parsed pattern elements.

NOTE: When these definitions are changed, the table of extra lengths for each

code (meta_extra_lengths, just below) must be updated to remain in step. */

#define META_END              0x80000000u  /* End of pattern */

#define META_ALT              0x80010000u  /* alternation */

#define META_ATOMIC           0x80020000u  /* atomic group */

#define META_BACKREF          0x80030000u  /* Back ref */

#define META_BACKREF_BYNAME   0x80040000u  /* \k'name' */

#define META_BIGVALUE         0x80050000u  /* Next is a literal > META_END */

#define META_CALLOUT_NUMBER   0x80060000u  /* (?C with numerical argument */

#define META_CALLOUT_STRING   0x80070000u  /* (?C with string argument */

#define META_CAPTURE          0x80080000u  /* Capturing parenthesis */

#define META_CIRCUMFLEX       0x80090000u  /* ^ metacharacter */

#define META_CLASS            0x800a0000u  /* start non-empty class */

#define META_CLASS_EMPTY      0x800b0000u  /* empty class */

#define META_CLASS_EMPTY_NOT  0x800c0000u  /* negative empty class */

#define META_CLASS_END        0x800d0000u  /* end of non-empty class */

#define META_CLASS_NOT        0x800e0000u  /* start non-empty negative class */

#define META_COND_ASSERT      0x800f0000u  /* (?(?assertion)... */

#define META_COND_DEFINE      0x80100000u  /* (?(DEFINE)... */

#define META_COND_NAME        0x80110000u  /* (?(<name>)... */

#define META_COND_NUMBER      0x80120000u  /* (?(digits)... */

#define META_COND_RNAME       0x80130000u  /* (?(R&name)... */

#define META_COND_RNUMBER     0x80140000u  /* (?(Rdigits)... */

#define META_COND_VERSION     0x80150000u  /* (?(VERSION<op>x.y)... */

#define META_DOLLAR           0x80160000u  /* $ metacharacter */

#define META_DOT              0x80170000u  /* . metacharacter */

#define META_ESCAPE           0x80180000u  /* \d and friends */

#define META_KET              0x80190000u  /* closing parenthesis */

#define META_NOCAPTURE        0x801a0000u  /* no capture parens */

#define META_OPTIONS          0x801b0000u  /* (?i) and friends */

#define META_POSIX            0x801c0000u  /* POSIX class item */

#define META_POSIX_NEG        0x801d0000u  /* negative POSIX class item */

#define META_RANGE_ESCAPED    0x801e0000u  /* range with at least one escape */

#define META_RANGE_LITERAL    0x801f0000u  /* range defined literally */

#define META_RECURSE          0x80200000u  /* Recursion */

#define META_RECURSE_BYNAME   0x80210000u  /* (?&name) */

#define META_SCRIPT_RUN       0x80220000u  /* (*script_run:...) */

/* These must be kept together to make it easy to check that an assertion

is present where expected in a conditional group. */

#define META_LOOKAHEAD        0x80230000u  /* (?= */

#define META_LOOKAHEADNOT     0x80240000u  /* (?! */

#define META_LOOKBEHIND       0x80250000u  /* (?<= */

#define META_LOOKBEHINDNOT    0x80260000u  /* (?<! */

/* These cannot be conditions */

#define META_LOOKAHEAD_NA     0x80270000u  /* (*napla: */

#define META_LOOKBEHIND_NA    0x80280000u  /* (*naplb: */

/* These must be kept in this order, with consecutive values, and the _ARG

versions of COMMIT, PRUNE, SKIP, and THEN immediately after their non-argument

versions. */

#define META_MARK             0x80290000u  /* (*MARK) */

#define META_ACCEPT           0x802a0000u  /* (*ACCEPT) */

#define META_FAIL             0x802b0000u  /* (*FAIL) */

#define META_COMMIT           0x802c0000u  /* These               */

#define META_COMMIT_ARG       0x802d0000u  /*   pairs             */

#define META_PRUNE            0x802e0000u  /*     must            */

#define META_PRUNE_ARG        0x802f0000u  /*       be            */

#define META_SKIP             0x80300000u  /*         kept        */

#define META_SKIP_ARG         0x80310000u  /*           in        */

#define META_THEN             0x80320000u  /*             this    */

#define META_THEN_ARG         0x80330000u  /*               order */

/* These must be kept in groups of adjacent 3 values, and all together. */

#define META_ASTERISK         0x80340000u  /* *  */

#define META_ASTERISK_PLUS    0x80350000u  /* *+ */

#define META_ASTERISK_QUERY   0x80360000u  /* *? */

#define META_PLUS             0x80370000u  /* +  */

#define META_PLUS_PLUS        0x80380000u  /* ++ */

#define META_PLUS_QUERY       0x80390000u  /* +? */

#define META_QUERY            0x803a0000u  /* ?  */

#define META_QUERY_PLUS       0x803b0000u  /* ?+ */

#define META_QUERY_QUERY      0x803c0000u  /* ?? */

#define META_MINMAX           0x803d0000u  /* {n,m}  repeat */

#define META_MINMAX_PLUS      0x803e0000u  /* {n,m}+ repeat */

#define META_MINMAX_QUERY     0x803f0000u  /* {n,m}? repeat */

#define META_FIRST_QUANTIFIER META_ASTERISK

#define META_LAST_QUANTIFIER  META_MINMAX_QUERY

/* This is a special "meta code" that is used only to distinguish (*asr: from

(*sr: in the table of aphabetic assertions. It is never stored in the parsed

pattern because (*asr: is turned into (*sr:(*atomic: at that stage. There is

therefore no need for it to have a length entry, so use a high value. */

#define META_ATOMIC_SCRIPT_RUN 0x8fff0000u

/* Table of extra lengths for each of the meta codes. Must be kept in step with

the definitions above. For some items these values are a basic length to which

a variable amount has to be added. */

static unsigned char meta_extra_lengths[] = {

  0,             /* META_END */

  0,             /* META_ALT */

  0,             /* META_ATOMIC */

  0,             /* META_BACKREF - more if group is >= 10 */

  1+SIZEOFFSET,  /* META_BACKREF_BYNAME */

  1,             /* META_BIGVALUE */

  3,             /* META_CALLOUT_NUMBER */

  3+SIZEOFFSET,  /* META_CALLOUT_STRING */

  0,             /* META_CAPTURE */

  0,             /* META_CIRCUMFLEX */

  0,             /* META_CLASS */

  0,             /* META_CLASS_EMPTY */

  0,             /* META_CLASS_EMPTY_NOT */

  0,             /* META_CLASS_END */

  0,             /* META_CLASS_NOT */

  0,             /* META_COND_ASSERT */

  SIZEOFFSET,    /* META_COND_DEFINE */

  1+SIZEOFFSET,  /* META_COND_NAME */

  1+SIZEOFFSET,  /* META_COND_NUMBER */

  1+SIZEOFFSET,  /* META_COND_RNAME */

  1+SIZEOFFSET,  /* META_COND_RNUMBER */

  3,             /* META_COND_VERSION */

  0,             /* META_DOLLAR */

  0,             /* META_DOT */

  0,             /* META_ESCAPE - more for ESC_P, ESC_p, ESC_g, ESC_k */

  0,             /* META_KET */

  0,             /* META_NOCAPTURE */

  1,             /* META_OPTIONS */

  1,             /* META_POSIX */

  1,             /* META_POSIX_NEG */

  0,             /* META_RANGE_ESCAPED */

  0,             /* META_RANGE_LITERAL */

  SIZEOFFSET,    /* META_RECURSE */

  1+SIZEOFFSET,  /* META_RECURSE_BYNAME */

  0,             /* META_SCRIPT_RUN */

  0,             /* META_LOOKAHEAD */

  0,             /* META_LOOKAHEADNOT */

  SIZEOFFSET,    /* META_LOOKBEHIND */

  SIZEOFFSET,    /* META_LOOKBEHINDNOT */

  0,             /* META_LOOKAHEAD_NA */

  SIZEOFFSET,    /* META_LOOKBEHIND_NA */

  1,             /* META_MARK - plus the string length */

  0,             /* META_ACCEPT */

  0,             /* META_FAIL */

  0,             /* META_COMMIT */

  1,             /* META_COMMIT_ARG - plus the string length */

  0,             /* META_PRUNE */

  1,             /* META_PRUNE_ARG - plus the string length */

  0,             /* META_SKIP */

  1,             /* META_SKIP_ARG - plus the string length */

  0,             /* META_THEN */

  1,             /* META_THEN_ARG - plus the string length */

  0,             /* META_ASTERISK */

  0,             /* META_ASTERISK_PLUS */

  0,             /* META_ASTERISK_QUERY */

  0,             /* META_PLUS */

  0,             /* META_PLUS_PLUS */

  0,             /* META_PLUS_QUERY */

  0,             /* META_QUERY */

  0,             /* META_QUERY_PLUS */

  0,             /* META_QUERY_QUERY */

  2,             /* META_MINMAX */

  2,             /* META_MINMAX_PLUS */

  2              /* META_MINMAX_QUERY */

};

/* Types for skipping parts of a parsed pattern. */

enum { PSKIP_ALT, PSKIP_CLASS, PSKIP_KET };

/* Macro for setting individual bits in class bitmaps. It took some

experimenting to figure out how to stop gcc 5.3.0 from warning with

-Wconversion. This version gets a warning:

  #define SETBIT(a,b) a[(b)/8] |= (uint8_t)(1u << ((b)&7))

Let's hope the apparently less efficient version isn't actually so bad if the

compiler is clever with identical subexpressions. */

#define SETBIT(a,b) a[(b)/8] = (uint8_t)(a[(b)/8] | (1u << ((b)&7)))

/* Values and flags for the unsigned xxcuflags variables that accompany xxcu

variables, which are concerned with first and required code units. A value

greater than or equal to REQ_NONE means "no code unit set"; otherwise the

matching xxcu variable is set, and the low valued bits are relevant. */

#define REQ_UNSET     0xffffffffu  /* Not yet found anything */

#define REQ_NONE      0xfffffffeu  /* Found not fixed character */

#define REQ_CASELESS  0x00000001u  /* Code unit in xxcu is caseless */

#define REQ_VARY      0x00000002u  /* Code unit is followed by non-literal */

/* These flags are used in the groupinfo vector. */

#define GI_SET_FIXED_LENGTH    0x80000000u

#define GI_NOT_FIXED_LENGTH    0x40000000u

#define GI_FIXED_LENGTH_MASK   0x0000ffffu

/* This simple test for a decimal digit works for both ASCII/Unicode and EBCDIC

and is fast (a good compiler can turn it into a subtraction and unsigned

comparison). */

#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9)

/* Table to identify hex digits. The tables in chartables are dependent on the

locale, and may mark arbitrary characters as digits. We want to recognize only

0-9, a-z, and A-Z as hex digits, which is why we have a private table here. It

costs 256 bytes, but it is a lot faster than doing character value tests (at

least in some simple cases I timed), and in some applications one wants PCRE2

to compile efficiently as well as match efficiently. The value in the table is

the binary hex digit value, or 0xff for non-hex digits. */

/* This is the "normal" case, for ASCII systems, and EBCDIC systems running in

UTF-8 mode. */

#ifndef EBCDIC

static const uint8_t xdigitab[] =

  {

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   0-  7 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   8- 15 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  16- 23 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  24- 31 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*    - '  */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  ( - /  */

  0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, /*  0 - 7  */

  0x08,0x09,0xff,0xff,0xff,0xff,0xff,0xff, /*  8 - ?  */

  0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  @ - G  */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  H - O  */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  P - W  */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  X - _  */

  0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  ` - g  */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  h - o  */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  p - w  */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  x -127 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 128-135 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 136-143 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 144-151 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 152-159 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 160-167 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 168-175 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 176-183 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 184-191 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 192-199 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 2ff-207 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 208-215 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 216-223 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 224-231 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 232-239 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 240-247 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};/* 248-255 */

#else

/* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */

static const uint8_t xdigitab[] =

  {

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   0-  7  0 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   8- 15    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  16- 23 10 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  24- 31    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  32- 39 20 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  40- 47    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  48- 55 30 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  56- 63    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*    - 71 40 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  72- |     */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  & - 87 50 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  88- 95    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  - -103 60 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 104- ?     */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 112-119 70 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 120- "     */

  0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /* 128- g  80 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  h -143    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 144- p  90 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  q -159    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 160- x  A0 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  y -175    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  ^ -183 B0 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 184-191    */

  0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  { - G  C0 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  H -207    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  } - P  D0 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  Q -223    */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  \ - X  E0 */

  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  Y -239    */

  0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, /*  0 - 7  F0 */

  0x08,0x09,0xff,0xff,0xff,0xff,0xff,0xff};/*  8 -255    */

#endif  /* EBCDIC */

/* Table for handling alphanumeric escaped characters. Positive returns are

simple data values; negative values are for special things like \d and so on.

Zero means further processing is needed (for things like \x), or the escape is

invalid. */

/* This is the "normal" table for ASCII systems or for EBCDIC systems running

in UTF-8 mode. It runs from '0' to 'z'. */

#ifndef EBCDIC

#define ESCAPES_FIRST       CHAR_0

#define ESCAPES_LAST        CHAR_z

#define UPPER_CASE(c)       (c-32)

static const short int escapes[] = {

     0,                       0,

     0,                       0,

     0,                       0,

     0,                       0,

     0,                       0,

     CHAR_COLON,              CHAR_SEMICOLON,

     CHAR_LESS_THAN_SIGN,     CHAR_EQUALS_SIGN,

     CHAR_GREATER_THAN_SIGN,  CHAR_QUESTION_MARK,

     CHAR_COMMERCIAL_AT,      -ESC_A,

     -ESC_B,                  -ESC_C,

     -ESC_D,                  -ESC_E,

     0,                       -ESC_G,

     -ESC_H,                  0,

     0,                       -ESC_K,

     0,                       0,

     -ESC_N,                  0,

     -ESC_P,                  -ESC_Q,

     -ESC_R,                  -ESC_S,

     0,                       0,

     -ESC_V,                  -ESC_W,

     -ESC_X,                  0,

     -ESC_Z,                  CHAR_LEFT_SQUARE_BRACKET,

     CHAR_BACKSLASH,          CHAR_RIGHT_SQUARE_BRACKET,

     CHAR_CIRCUMFLEX_ACCENT,  CHAR_UNDERSCORE,

     CHAR_GRAVE_ACCENT,       CHAR_BEL,

     -ESC_b,                  0,

     -ESC_d,                  CHAR_ESC,

     CHAR_FF,                 0,

     -ESC_h,                  0,

     0,                       -ESC_k,

     0,                       0,

     CHAR_LF,                 0,

     -ESC_p,                  0,

     CHAR_CR,                 -ESC_s,

     CHAR_HT,                 0,

     -ESC_v,                  -ESC_w,

     0,                       0,

     -ESC_z

};

#else

/* This is the "abnormal" table for EBCDIC systems without UTF-8 support.

It runs from 'a' to '9'. For some minimal testing of EBCDIC features, the code

is sometimes compiled on an ASCII system. In this case, we must not use CHAR_a

because it is defined as 'a', which of course picks up the ASCII value. */

#if 'a' == 0x81                    /* Check for a real EBCDIC environment */

#define ESCAPES_FIRST       CHAR_a

#define ESCAPES_LAST        CHAR_9

#define UPPER_CASE(c)       (c+64)

#else                              /* Testing in an ASCII environment */

#define ESCAPES_FIRST  ((unsigned char)'\x81')   /* EBCDIC 'a' */

#define ESCAPES_LAST   ((unsigned char)'\xf9')   /* EBCDIC '9' */

#define UPPER_CASE(c)  (c-32)

#endif

static const short int escapes[] = {

/*  80 */         CHAR_BEL, -ESC_b,       0, -ESC_d, CHAR_ESC, CHAR_FF,      0,

/*  88 */ -ESC_h,        0,      0,     '{',      0,        0,       0,      0,

/*  90 */      0,        0, -ESC_k,       0,      0,  CHAR_LF,       0, -ESC_p,

/*  98 */      0,  CHAR_CR,      0,     '}',      0,        0,       0,      0,

/*  A0 */      0,      '~', -ESC_s, CHAR_HT,      0,   -ESC_v,  -ESC_w,      0,

/*  A8 */      0,   -ESC_z,      0,       0,      0,      '[',       0,      0,

/*  B0 */      0,        0,      0,       0,      0,        0,       0,      0,

/*  B8 */      0,        0,      0,       0,      0,      ']',     '=',    '-',

/*  C0 */    '{',   -ESC_A, -ESC_B,  -ESC_C, -ESC_D,   -ESC_E,       0, -ESC_G,

/*  C8 */ -ESC_H,        0,      0,       0,      0,        0,       0,      0,

/*  D0 */    '}',        0, -ESC_K,       0,      0,   -ESC_N,       0, -ESC_P,

/*  D8 */ -ESC_Q,   -ESC_R,      0,       0,      0,        0,       0,      0,

/*  E0 */   '\\',        0, -ESC_S,       0,      0,   -ESC_V,  -ESC_W, -ESC_X,

/*  E8 */      0,   -ESC_Z,      0,       0,      0,        0,       0,      0,

/*  F0 */      0,        0,      0,       0,      0,        0,       0,      0,

/*  F8 */      0,        0

};

/* We also need a table of characters that may follow \c in an EBCDIC

environment for characters 0-31. */

static unsigned char ebcdic_escape_c[] = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";

#endif   /* EBCDIC */

/* Table of special "verbs" like (*PRUNE). This is a short table, so it is

searched linearly. Put all the names into a single string, in order to reduce

the number of relocations when a shared library is dynamically linked. The

string is built from string macros so that it works in UTF-8 mode on EBCDIC

platforms. */

typedef struct verbitem {

  unsigned int len;          /* Length of verb name */

  uint32_t meta;             /* Base META_ code */

  int has_arg;               /* Argument requirement */

} verbitem;

static const char verbnames[] =

  "\0"                       /* Empty name is a shorthand for MARK */

  STRING_MARK0

  STRING_ACCEPT0

  STRING_F0

  STRING_FAIL0

  STRING_COMMIT0

  STRING_PRUNE0

  STRING_SKIP0

  STRING_THEN;

static const verbitem verbs[] = {

  { 0, META_MARK,   +1 },  /* > 0 => must have an argument */

  { 4, META_MARK,   +1 },

  { 6, META_ACCEPT, -1 },  /* < 0 => Optional argument, convert to pre-MARK */

  { 1, META_FAIL,   -1 },

  { 4, META_FAIL,   -1 },

  { 6, META_COMMIT,  0 },

  { 5, META_PRUNE,   0 },  /* Optional argument; bump META code if found */

  { 4, META_SKIP,    0 },

  { 4, META_THEN,    0 }

};

static const int verbcount = sizeof(verbs)/sizeof(verbitem);

/* Verb opcodes, indexed by their META code offset from META_MARK. */

static const uint32_t verbops[] = {

  OP_MARK, OP_ACCEPT, OP_FAIL, OP_COMMIT, OP_COMMIT_ARG, OP_PRUNE,

  OP_PRUNE_ARG, OP_SKIP, OP_SKIP_ARG, OP_THEN, OP_THEN_ARG };

/* Table of "alpha assertions" like (*pla:...), similar to the (*VERB) table. */

typedef struct alasitem {

  unsigned int len;          /* Length of name */

  uint32_t meta;             /* Base META_ code */

} alasitem;

static const char alasnames[] =

  STRING_pla0

  STRING_plb0

  STRING_napla0

  STRING_naplb0

  STRING_nla0

  STRING_nlb0

  STRING_positive_lookahead0

  STRING_positive_lookbehind0

  STRING_non_atomic_positive_lookahead0

  STRING_non_atomic_positive_lookbehind0

  STRING_negative_lookahead0

  STRING_negative_lookbehind0

  STRING_atomic0

  STRING_sr0

  STRING_asr0

  STRING_script_run0

  STRING_atomic_script_run;

static const alasitem alasmeta[] = {

  {  3, META_LOOKAHEAD         },

  {  3, META_LOOKBEHIND        },

  {  5, META_LOOKAHEAD_NA      },

  {  5, META_LOOKBEHIND_NA     },

  {  3, META_LOOKAHEADNOT      },

  {  3, META_LOOKBEHINDNOT     },

  { 18, META_LOOKAHEAD         },

  { 19, META_LOOKBEHIND        },

  { 29, META_LOOKAHEAD_NA      },

  { 30, META_LOOKBEHIND_NA     },

  { 18, META_LOOKAHEADNOT      },

  { 19, META_LOOKBEHINDNOT     },

  {  6, META_ATOMIC            },

  {  2, META_SCRIPT_RUN        }, /* sr = script run */

  {  3, META_ATOMIC_SCRIPT_RUN }, /* asr = atomic script run */

  { 10, META_SCRIPT_RUN        }, /* script run */

  { 17, META_ATOMIC_SCRIPT_RUN }  /* atomic script run */

};

static const int alascount = sizeof(alasmeta)/sizeof(alasitem);

/* Offsets from OP_STAR for case-independent and negative repeat opcodes. */

static uint32_t chartypeoffset[] = {

  OP_STAR - OP_STAR,    OP_STARI - OP_STAR,

  OP_NOTSTAR - OP_STAR, OP_NOTSTARI - OP_STAR };

/* Tables of names of POSIX character classes and their lengths. The names are

now all in a single string, to reduce the number of relocations when a shared

library is dynamically loaded. The list of lengths is terminated by a zero

length entry. The first three must be alpha, lower, upper, as this is assumed

for handling case independence. The indices for several classes are needed, so

identify them. */

static const char posix_names[] =

  STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0

  STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0

  STRING_graph0 STRING_print0 STRING_punct0 STRING_space0

  STRING_word0  STRING_xdigit;

static const uint8_t posix_name_lengths[] = {

  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };

#define PC_DIGIT   7

#define PC_GRAPH   8

#define PC_PRINT   9

#define PC_PUNCT  10

#define PC_XDIGIT 13

/* Table of class bit maps for each POSIX class. Each class is formed from a

base map, with an optional addition or removal of another map. Then, for some

classes, there is some additional tweaking: for [:blank:] the vertical space

characters are removed, and for [:alpha:] and [:alnum:] the underscore

character is removed. The triples in the table consist of the base map offset,

second map offset or -1 if no second map, and a non-negative value for map

addition or a negative value for map subtraction (if there are two maps). The

absolute value of the third field has these meanings: 0 => no tweaking, 1 =>

remove vertical space characters, 2 => remove underscore. */

static const int posix_class_maps[] = {

  cbit_word,   cbit_digit, -2,            /* alpha */

  cbit_lower,  -1,          0,            /* lower */

  cbit_upper,  -1,          0,            /* upper */

  cbit_word,   -1,          2,            /* alnum - word without underscore */

  cbit_print,  cbit_cntrl,  0,            /* ascii */

  cbit_space,  -1,          1,            /* blank - a GNU extension */

  cbit_cntrl,  -1,          0,            /* cntrl */

  cbit_digit,  -1,          0,            /* digit */

  cbit_graph,  -1,          0,            /* graph */

  cbit_print,  -1,          0,            /* print */

  cbit_punct,  -1,          0,            /* punct */

  cbit_space,  -1,          0,            /* space */

  cbit_word,   -1,          0,            /* word - a Perl extension */

  cbit_xdigit, -1,          0             /* xdigit */

};

#ifdef SUPPORT_UNICODE

/* The POSIX class Unicode property substitutes that are used in UCP mode must

be in the order of the POSIX class names, defined above. */

static int posix_substitutes[] = {

  PT_GC, ucp_L,     /* alpha */

  PT_PC, ucp_Ll,    /* lower */

  PT_PC, ucp_Lu,    /* upper */

  PT_ALNUM, 0,      /* alnum */

  -1, 0,            /* ascii, treat as non-UCP */

  -1, 1,            /* blank, treat as \h */

  PT_PC, ucp_Cc,    /* cntrl */

  PT_PC, ucp_Nd,    /* digit */

  PT_PXGRAPH, 0,    /* graph */

  PT_PXPRINT, 0,    /* print */

  PT_PXPUNCT, 0,    /* punct */

  PT_PXSPACE, 0,    /* space */   /* Xps is POSIX space, but from 8.34 */

  PT_WORD, 0,       /* word  */   /* Perl and POSIX space are the same */

  PT_PXXDIGIT, 0    /* xdigit */  /* Perl has additional hex digits */

};

#define POSIX_SUBSIZE (sizeof(posix_substitutes) / (2*sizeof(uint32_t)))

#endif  /* SUPPORT_UNICODE */

/* Masks for checking option settings. When PCRE2_LITERAL is set, only a subset

are allowed. */

#define PUBLIC_LITERAL_COMPILE_OPTIONS \

  (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \

   PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_MATCH_INVALID_UTF| \

   PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF)

#define PUBLIC_COMPILE_OPTIONS \

  (PUBLIC_LITERAL_COMPILE_OPTIONS| \

   PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \

   PCRE2_ALT_VERBNAMES|PCRE2_DOLLAR_ENDONLY|PCRE2_DOTALL|PCRE2_DUPNAMES| \

   PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MATCH_UNSET_BACKREF| \

   PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C|PCRE2_NEVER_UCP| \

   PCRE2_NEVER_UTF|PCRE2_NO_AUTO_CAPTURE|PCRE2_NO_AUTO_POSSESS| \

   PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_UCP|PCRE2_UNGREEDY)

#define PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS \

   (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_CASELESS_RESTRICT)

#define PUBLIC_COMPILE_EXTRA_OPTIONS \

   (PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS| \

    PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES|PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL| \

    PCRE2_EXTRA_ESCAPED_CR_IS_LF|PCRE2_EXTRA_ALT_BSUX| \

    PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK|PCRE2_EXTRA_ASCII_BSD| \

    PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW|PCRE2_EXTRA_ASCII_POSIX| \

    PCRE2_EXTRA_ASCII_DIGIT)

/* Compile time error code numbers. They are given names so that they can more

easily be tracked. When a new number is added, the tables called eint1 and

eint2 in pcre2posix.c may need to be updated, and a new error text must be

added to compile_error_texts in pcre2_error.c. Also, the error codes in

pcre2.h.in must be updated - their values are exactly 100 greater than these

values. */

enum { ERR0 = COMPILE_ERROR_BASE,

       ERR1,  ERR2,  ERR3,  ERR4,  ERR5,  ERR6,  ERR7,  ERR8,  ERR9,  ERR10,

       ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19, ERR20,

       ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR28, ERR29, ERR30,

       ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39, ERR40,

       ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47, ERR48, ERR49, ERR50,

       ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59, ERR60,

       ERR61, ERR62, ERR63, ERR64, ERR65, ERR66, ERR67, ERR68, ERR69, ERR70,

       ERR71, ERR72, ERR73, ERR74, ERR75, ERR76, ERR77, ERR78, ERR79, ERR80,

       ERR81, ERR82, ERR83, ERR84, ERR85, ERR86, ERR87, ERR88, ERR89, ERR90,

       ERR91, ERR92, ERR93, ERR94, ERR95, ERR96, ERR97, ERR98, ERR99, ERR100,

       ERR101 };

/* This is a table of start-of-pattern options such as (*UTF) and settings such

as (*LIMIT_MATCH=nnnn) and (*CRLF). For completeness and backward

compatibility, (*UTFn) is supported in the relevant libraries, but (*UTF) is

generic and always supported. */

enum { PSO_OPT,     /* Value is an option bit */

       PSO_FLG,     /* Value is a flag bit */

       PSO_NL,      /* Value is a newline type */

       PSO_BSR,     /* Value is a \R type */

       PSO_LIMH,    /* Read integer value for heap limit */

       PSO_LIMM,    /* Read integer value for match limit */

       PSO_LIMD     /* Read integer value for depth limit */

     };

typedef struct pso {

  const uint8_t *name;

  uint16_t length;

  uint16_t type;

  uint32_t value;

} pso;

/* NB: STRING_UTFn_RIGHTPAR contains the length as well */

static const pso pso_list[] = {

  { (uint8_t *)STRING_UTFn_RIGHTPAR,                  PSO_OPT, PCRE2_UTF },

  { (uint8_t *)STRING_UTF_RIGHTPAR,                4, PSO_OPT, PCRE2_UTF },

  { (uint8_t *)STRING_UCP_RIGHTPAR,                4, PSO_OPT, PCRE2_UCP },

  { (uint8_t *)STRING_NOTEMPTY_RIGHTPAR,           9, PSO_FLG, PCRE2_NOTEMPTY_SET },

  { (uint8_t *)STRING_NOTEMPTY_ATSTART_RIGHTPAR,  17, PSO_FLG, PCRE2_NE_ATST_SET },

  { (uint8_t *)STRING_NO_AUTO_POSSESS_RIGHTPAR,   16, PSO_OPT, PCRE2_NO_AUTO_POSSESS },

  { (uint8_t *)STRING_NO_DOTSTAR_ANCHOR_RIGHTPAR, 18, PSO_OPT, PCRE2_NO_DOTSTAR_ANCHOR },

  { (uint8_t *)STRING_NO_JIT_RIGHTPAR,             7, PSO_FLG, PCRE2_NOJIT },

  { (uint8_t *)STRING_NO_START_OPT_RIGHTPAR,      13, PSO_OPT, PCRE2_NO_START_OPTIMIZE },

  { (uint8_t *)STRING_LIMIT_HEAP_EQ,              11, PSO_LIMH, 0 },

  { (uint8_t *)STRING_LIMIT_MATCH_EQ,             12, PSO_LIMM, 0 },

  { (uint8_t *)STRING_LIMIT_DEPTH_EQ,             12, PSO_LIMD, 0 },

  { (uint8_t *)STRING_LIMIT_RECURSION_EQ,         16, PSO_LIMD, 0 },

  { (uint8_t *)STRING_CR_RIGHTPAR,                 3, PSO_NL,  PCRE2_NEWLINE_CR },

  { (uint8_t *)STRING_LF_RIGHTPAR,                 3, PSO_NL,  PCRE2_NEWLINE_LF },

  { (uint8_t *)STRING_CRLF_RIGHTPAR,               5, PSO_NL,  PCRE2_NEWLINE_CRLF },

  { (uint8_t *)STRING_ANY_RIGHTPAR,                4, PSO_NL,  PCRE2_NEWLINE_ANY },

  { (uint8_t *)STRING_NUL_RIGHTPAR,                4, PSO_NL,  PCRE2_NEWLINE_NUL },

  { (uint8_t *)STRING_ANYCRLF_RIGHTPAR,            8, PSO_NL,  PCRE2_NEWLINE_ANYCRLF },

  { (uint8_t *)STRING_BSR_ANYCRLF_RIGHTPAR,       12, PSO_BSR, PCRE2_BSR_ANYCRLF },

  { (uint8_t *)STRING_BSR_UNICODE_RIGHTPAR,       12, PSO_BSR, PCRE2_BSR_UNICODE }

};

/* This table is used when converting repeating opcodes into possessified

versions as a result of an explicit possessive quantifier such as ++. A zero

value means there is no possessified version - in those cases the item in

question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT

because all relevant opcodes are less than that. */

static const uint8_t opcode_possessify[] = {

  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 0 - 15  */

  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 16 - 31 */

  0,                       /* NOTI */

  OP_POSSTAR, 0,           /* STAR, MINSTAR */

  OP_POSPLUS, 0,           /* PLUS, MINPLUS */

  OP_POSQUERY, 0,          /* QUERY, MINQUERY */

  OP_POSUPTO, 0,           /* UPTO, MINUPTO */

  0,                       /* EXACT */

  0, 0, 0, 0,              /* POS{STAR,PLUS,QUERY,UPTO} */

  OP_POSSTARI, 0,          /* STARI, MINSTARI */

  OP_POSPLUSI, 0,          /* PLUSI, MINPLUSI */

  OP_POSQUERYI, 0,         /* QUERYI, MINQUERYI */

  OP_POSUPTOI, 0,          /* UPTOI, MINUPTOI */

  0,                       /* EXACTI */

  0, 0, 0, 0,              /* POS{STARI,PLUSI,QUERYI,UPTOI} */

  OP_NOTPOSSTAR, 0,        /* NOTSTAR, NOTMINSTAR */

  OP_NOTPOSPLUS, 0,        /* NOTPLUS, NOTMINPLUS */

  OP_NOTPOSQUERY, 0,       /* NOTQUERY, NOTMINQUERY */

  OP_NOTPOSUPTO, 0,        /* NOTUPTO, NOTMINUPTO */

  0,                       /* NOTEXACT */

  0, 0, 0, 0,              /* NOTPOS{STAR,PLUS,QUERY,UPTO} */

  OP_NOTPOSSTARI, 0,       /* NOTSTARI, NOTMINSTARI */

  OP_NOTPOSPLUSI, 0,       /* NOTPLUSI, NOTMINPLUSI */

  OP_NOTPOSQUERYI, 0,      /* NOTQUERYI, NOTMINQUERYI */

  OP_NOTPOSUPTOI, 0,       /* NOTUPTOI, NOTMINUPTOI */

  0,                       /* NOTEXACTI */

  0, 0, 0, 0,              /* NOTPOS{STARI,PLUSI,QUERYI,UPTOI} */

  OP_TYPEPOSSTAR, 0,       /* TYPESTAR, TYPEMINSTAR */

  OP_TYPEPOSPLUS, 0,       /* TYPEPLUS, TYPEMINPLUS */

  OP_TYPEPOSQUERY, 0,      /* TYPEQUERY, TYPEMINQUERY */

  OP_TYPEPOSUPTO, 0,       /* TYPEUPTO, TYPEMINUPTO */

  0,                       /* TYPEEXACT */

  0, 0, 0, 0,              /* TYPEPOS{STAR,PLUS,QUERY,UPTO} */

  OP_CRPOSSTAR, 0,         /* CRSTAR, CRMINSTAR */

  OP_CRPOSPLUS, 0,         /* CRPLUS, CRMINPLUS */

  OP_CRPOSQUERY, 0,        /* CRQUERY, CRMINQUERY */

  OP_CRPOSRANGE, 0,        /* CRRANGE, CRMINRANGE */

  0, 0, 0, 0,              /* CRPOS{STAR,PLUS,QUERY,RANGE} */

  0, 0, 0,                 /* CLASS, NCLASS, XCLASS */

  0, 0,                    /* REF, REFI */

  0, 0,                    /* DNREF, DNREFI */

  0, 0                     /* RECURSE, CALLOUT */

};

#ifdef DEBUG_SHOW_PARSED

/*************************************************

*     Show the parsed pattern for debugging      *

*************************************************/

/* For debugging the pre-scan, this code, which outputs the parsed data vector,

can be enabled. */

static void show_parsed(compile_block *cb)

{

uint32_t *pptr = cb->parsed_pattern;

for (;;)

  {

  int max, min;

  PCRE2_SIZE offset;

  uint32_t i;

  uint32_t length;

  uint32_t meta_arg = META_DATA(*pptr);

  fprintf(stderr, "+++ %02d %.8x ", (int)(pptr - cb->parsed_pattern), *pptr);

  if (*pptr < META_END)

    {

    if (*pptr > 32 && *pptr < 128) fprintf(stderr, "%c", *pptr);

    pptr++;

    }

  else switch (META_CODE(*pptr++))

    {

    default:

    fprintf(stderr, "**** OOPS - unknown META value - giving up ****\n");

    return;

    case META_END:

    fprintf(stderr, "META_END\n");

    return;

    case META_CAPTURE:

    fprintf(stderr, "META_CAPTURE %d", meta_arg);

    break;

    case META_RECURSE:

    GETOFFSET(offset, pptr);

    fprintf(stderr, "META_RECURSE %d %zd", meta_arg, offset);

    break;

    case META_BACKREF:

    if (meta_arg < 10)

      offset = cb->small_ref_offset[meta_arg];

    else

      GETOFFSET(offset, pptr);

    fprintf(stderr, "META_BACKREF %d %zd", meta_arg, offset);

    break;

    case META_ESCAPE:

    if (meta_arg == ESC_P || meta_arg == ESC_p)

      {

      uint32_t ptype = *pptr >> 16;

      uint32_t pvalue = *pptr++ & 0xffff;

      fprintf(stderr, "META \\%c %d %d", (meta_arg == ESC_P)? 'P':'p',

        ptype, pvalue);

      }

    else

      {

      uint32_t cc;

      /* There's just one escape we might have here that isn't negated in the

      escapes table. */

      if (meta_arg == ESC_g) cc = CHAR_g;

      else for (cc = ESCAPES_FIRST; cc <= ESCAPES_LAST; cc++)

        {

        if (meta_arg == (uint32_t)(-escapes[cc - ESCAPES_FIRST])) break;

        }

      if (cc > ESCAPES_LAST) cc = CHAR_QUESTION_MARK;

      fprintf(stderr, "META \\%c", cc);

      }

    break;

    case META_MINMAX:

    min = *pptr++;

    max = *pptr++;

    if (max != REPEAT_UNLIMITED)

      fprintf(stderr, "META {%d,%d}", min, max);

    else

      fprintf(stderr, "META {%d,}", min);

    break;

    case META_MINMAX_QUERY:

    min = *pptr++;

    max = *pptr++;

    if (max != REPEAT_UNLIMITED)

      fprintf(stderr, "META {%d,%d}?", min, max);

    else

      fprintf(stderr, "META {%d,}?", min);

    break;

    case META_MINMAX_PLUS:

    min = *pptr++;

    max = *pptr++;

    if (max != REPEAT_UNLIMITED)

      fprintf(stderr, "META {%d,%d}+", min, max);

    else

      fprintf(stderr, "META {%d,}+", min);

    break;

    case META_BIGVALUE: fprintf(stderr, "META_BIGVALUE %.8x", *pptr++); break;

    case META_CIRCUMFLEX: fprintf(stderr, "META_CIRCUMFLEX"); break;

    case META_COND_ASSERT: fprintf(stderr, "META_COND_ASSERT"); break;

    case META_DOLLAR: fprintf(stderr, "META_DOLLAR"); break;

    case META_DOT: fprintf(stderr, "META_DOT"); break;

    case META_ASTERISK: fprintf(stderr, "META *"); break;

    case META_ASTERISK_QUERY: fprintf(stderr, "META *?"); break;

    case META_ASTERISK_PLUS: fprintf(stderr, "META *+"); break;

    case META_PLUS: fprintf(stderr, "META +"); break;

    case META_PLUS_QUERY: fprintf(stderr, "META +?"); break;

    case META_PLUS_PLUS: fprintf(stderr, "META ++"); break;

    case META_QUERY: fprintf(stderr, "META ?"); break;

    case META_QUERY_QUERY: fprintf(stderr, "META ??"); break;

    case META_QUERY_PLUS: fprintf(stderr, "META ?+"); break;

    case META_ATOMIC: fprintf(stderr, "META (?>"); break;

    case META_NOCAPTURE: fprintf(stderr, "META (?:"); break;

    case META_LOOKAHEAD: fprintf(stderr, "META (?="); break;

    case META_LOOKAHEADNOT: fprintf(stderr, "META (?!"); break;

    case META_LOOKAHEAD_NA: fprintf(stderr, "META (*napla:"); break;

    case META_SCRIPT_RUN: fprintf(stderr, "META (*sr:"); break;

    case META_KET: fprintf(stderr, "META )"); break;

    case META_ALT: fprintf(stderr, "META | %d", meta_arg); break;

    case META_CLASS: fprintf(stderr, "META ["); break;

    case META_CLASS_NOT: fprintf(stderr, "META [^"); break;

    case META_CLASS_END: fprintf(stderr, "META ]"); break;

    case META_CLASS_EMPTY: fprintf(stderr, "META []"); break;

    case META_CLASS_EMPTY_NOT: fprintf(stderr, "META [^]"); break;

    case META_RANGE_LITERAL: fprintf(stderr, "META - (literal)"); break;

    case META_RANGE_ESCAPED: fprintf(stderr, "META - (escaped)"); break;

    case META_POSIX: fprintf(stderr, "META_POSIX %d", *pptr++); break;

    case META_POSIX_NEG: fprintf(stderr, "META_POSIX_NEG %d", *pptr++); break;

    case META_ACCEPT: fprintf(stderr, "META (*ACCEPT)"); break;

    case META_FAIL: fprintf(stderr, "META (*FAIL)"); break;

    case META_COMMIT: fprintf(stderr, "META (*COMMIT)"); break;

    case META_PRUNE: fprintf(stderr, "META (*PRUNE)"); break;

    case META_SKIP: fprintf(stderr, "META (*SKIP)"); break;

    case META_THEN: fprintf(stderr, "META (*THEN)"); break;

    case META_OPTIONS:

    fprintf(stderr, "META_OPTIONS 0x%08x 0x%08x", pptr[0], pptr[1]);

    pptr += 2;

    break;

    case META_LOOKBEHIND:

    fprintf(stderr, "META (?<= %d %d", meta_arg, *pptr);

    pptr += 2;

    break;

    case META_LOOKBEHIND_NA:

    fprintf(stderr, "META (*naplb: %d %d", meta_arg, *pptr);

    pptr += 2;

    break;

    case META_LOOKBEHINDNOT:

    fprintf(stderr, "META (?<! %d %d", meta_arg, *pptr);

    pptr += 2;

    break;

    case META_CALLOUT_NUMBER:

    fprintf(stderr, "META (?C%d) next=%d/%d", pptr[2], pptr[0],

       pptr[1]);

    pptr += 3;

    break;

    case META_CALLOUT_STRING:

      {

      uint32_t patoffset = *pptr++;    /* Offset of next pattern item */

      uint32_t patlength = *pptr++;    /* Length of next pattern item */

      fprintf(stderr, "META (?Cstring) length=%d offset=", *pptr++);

      GETOFFSET(offset, pptr);

      fprintf(stderr, "%zd next=%d/%d", offset, patoffset, patlength);

      }

    break;

    case META_RECURSE_BYNAME:

    fprintf(stderr, "META (?(&name) length=%d offset=", *pptr++);

    GETOFFSET(offset, pptr);

    fprintf(stderr, "%zd", offset);

    break;

    case META_BACKREF_BYNAME:

    fprintf(stderr, "META_BACKREF_BYNAME length=%d offset=", *pptr++);

    GETOFFSET(offset, pptr);

    fprintf(stderr, "%zd", offset);

    break;

    case META_COND_NUMBER:

    fprintf(stderr, "META_COND_NUMBER %d offset=", pptr[SIZEOFFSET]);

    GETOFFSET(offset, pptr);

    fprintf(stderr, "%zd", offset);