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

*      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

           Copyright (c) 1997-2005 University of Cambridge

           Copyright (c) 2004, 2005 Apple Computer, Inc.

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

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.

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

*/

/* This module contains the external function pcre_compile(), along with

supporting internal functions that are not used by other modules. */

#include "pcre_internal.h"

/* WARNING: These macros evaluate their parameters more than once. */

#if PCRE_UTF16

#define CTYPES(cd, x) ((x) <= 255 ? (cd)->ctypes[(x)] : 0)

#define DIGITAB(x) ((x) <= 255 ? digitab[(x)] : 0)

#else

#define CTYPES(cd, x) cd->ctypes[(x)]

#define DIGITAB(x) digitab[(x)]

#endif

/* When DEBUG is defined, we need the pcre_printint() function, which is also

used by pcretest. DEBUG is not defined when building a production library. */

#ifdef DEBUG

#include "pcre_printint.src"

#endif

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

*      Code parameters and static tables         *

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

/* Maximum number of items on the nested bracket stacks at compile time. This

applies to the nesting of all kinds of parentheses. It does not limit

un-nested, non-capturing parentheses. This number can be made bigger if

necessary - it is used to dimension one int and one unsigned char vector at

compile time. */

#define BRASTACK_SIZE 200

/* Table for handling escaped characters in the range '0'-'z'. 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. */

#if JAVASCRIPT   /* This is the "JavaScript" table for ASCII systems */

static const short int escapes[] = {

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

     0,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */

   '@',      0, -ESC_B,      0, -ESC_D,      0,      0,      0,   /* @ - G */

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

     0,      0,      0, -ESC_S,      0,      0,      0, -ESC_W,   /* P - W */

     0,      0,      0,    '[',   '\\',    ']',    '^',    '_',   /* X - _ */

   '`',      7, -ESC_b,      0, -ESC_d,      0,  ESC_f,      0,   /* ` - g */

     0,      0,      0,      0,      0,      0,  ESC_n,      0,   /* h - o */

     0,      0,  ESC_r, -ESC_s,  ESC_tee,    0,  ESC_v, -ESC_w,   /* p - w */

     0,      0,      0                                            /* x - z */

};

#else

#if !EBCDIC   /* This is the "normal" table for ASCII systems */

static const short int escapes[] = {

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

     0,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */

   '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E,      0, -ESC_G,   /* @ - G */

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

-ESC_P, -ESC_Q,      0, -ESC_S,      0,      0,      0, -ESC_W,   /* P - W */

-ESC_X,      0, -ESC_Z,    '[',   '\\',    ']',    '^',    '_',   /* X - _ */

   '`',      7, -ESC_b,      0, -ESC_d,  ESC_e,  ESC_f,      0,   /* ` - g */

     0,      0,      0,      0,      0,      0,  ESC_n,      0,   /* h - o */

-ESC_p,      0,  ESC_r, -ESC_s,  ESC_tee,    0,      0, -ESC_w,   /* p - w */

     0,      0, -ESC_z                                            /* x - z */

};

#else         /* This is the "abnormal" table for EBCDIC systems */

static const short int escapes[] = {

/*  48 */     0,     0,      0,     '.',    '<',   '(',    '+',    '|',

/*  50 */   '&',     0,      0,       0,      0,     0,      0,      0,

/*  58 */     0,     0,    '!',     '$',    '*',   ')',    ';',    '~',

/*  60 */   '-',   '/',      0,       0,      0,     0,      0,      0,

/*  68 */     0,     0,    '|',     ',',    '%',   '_',    '>',    '?',

/*  70 */     0,     0,      0,       0,      0,     0,      0,      0,

/*  78 */     0,   '`',    ':',     '#',    '@',  '\'',    '=',    '"',

/*  80 */     0,     7, -ESC_b,       0, -ESC_d, ESC_e,  ESC_f,      0,

/*  88 */     0,     0,      0,     '{',      0,     0,      0,      0,

/*  90 */     0,     0,      0,     'l',      0, ESC_n,      0, -ESC_p,

/*  98 */     0, ESC_r,      0,     '}',      0,     0,      0,      0,

/*  A0 */     0,   '~', -ESC_s, ESC_tee,      0,     0, -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 */     0,     0,      0,       0,      0,     0,      0,      0,

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

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

/*  E0 */  '\\',     0, -ESC_S,       0,      0,     0, -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,      0,       0,      0,     0,      0,      0

};

#endif

#endif

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

terminated by a zero length entry. The first three must be alpha, upper, lower,

as this is assumed for handling case independence. */

static const char * const posix_names[] = {

  "alpha", "lower", "upper",

  "alnum", "ascii", "blank", "cntrl", "digit", "graph",

  "print", "punct", "space", "word",  "xdigit" };

static const uschar posix_name_lengths[] = {

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

/* Table of class bit maps for each POSIX class; up to three may be combined

to form the class. The table for [:blank:] is dynamically modified to remove

the vertical space characters. */

static const int posix_class_maps[] = {

  cbit_lower, cbit_upper, -1,             /* alpha */

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

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

  cbit_digit, cbit_lower, cbit_upper,     /* alnum */

  cbit_print, cbit_cntrl, -1,             /* ascii */

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

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

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

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

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

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

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

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

  cbit_xdigit,-1,         -1              /* xdigit */

};

/* The texts of compile-time error messages. These are "char *" because they

are passed to the outside world. */

static const char * const error_texts[] = {

  "no error",

  "\\ at end of pattern",

  "\\c at end of pattern",

  "unrecognized character follows \\",

  "numbers out of order in {} quantifier",

  /* 5 */

  "number too big in {} quantifier",

  "missing terminating ] for character class",

  "invalid escape sequence in character class",

  "range out of order in character class",

  "nothing to repeat",

  /* 10 */

  "operand of unlimited repeat could match the empty string",

  "internal error: unexpected repeat",

  "unrecognized character after (?",

  "POSIX named classes are supported only within a class",

  "missing )",

  /* 15 */

  "reference to non-existent subpattern",

  "erroffset passed as NULL",

  "unknown option bit(s) set",

  "missing ) after comment",

  "parentheses nested too deeply",

  /* 20 */

  "regular expression too large",

  "failed to get memory",

  "unmatched parentheses",

  "internal error: code overflow",

  "unrecognized character after (?<",

  /* 25 */

  "lookbehind assertion is not fixed length",

  "malformed number after (?(",

  "conditional group contains more than two branches",

  "assertion expected after (?(",

  "(?R or (?digits must be followed by )",

  /* 30 */

  "unknown POSIX class name",

  "POSIX collating elements are not supported",

  "this version of PCRE is not compiled with PCRE_UTF8 support",

  "spare error",

  "character value in \\x{...} sequence is too large",

  /* 35 */

  "invalid condition (?(0)",

  "\\C not allowed in lookbehind assertion",

  "PCRE does not support \\L, \\l, \\N, \\U, or \\u",

  "number after (?C is > 255",

  "closing ) for (?C expected",

  /* 40 */

  "recursive call could loop indefinitely",

  "unrecognized character after (?P",

  "syntax error after (?P",

  "two named groups have the same name",

#if PCRE_UTF16

  "invalid UTF-16 string",

#else

  "invalid UTF-8 string",

#endif

  /* 45 */

  "support for \\P, \\p, and \\X has not been compiled",

  "malformed \\P or \\p sequence",

  "unknown property name after \\P or \\p"

};

/* Table to identify digits and hex digits. This is used when compiling

patterns. Note that the tables in chartables are dependent on the locale, and

may mark arbitrary characters as digits - but the PCRE compiling code expects

to handle only 0-9, a-z, and A-Z as digits when compiling. That 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 PCRE to compile efficiently as well as match

efficiently.

For convenience, we use the same bit definitions as in chartables:

  0x04   decimal digit

  0x08   hexadecimal digit

Then we can use ctype_digit and ctype_xdigit in the code. */

#if !EBCDIC    /* This is the "normal" case, for ASCII systems */

static const unsigned char digitab[] =

  {

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - '  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ( - /  */

  0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  */

  0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /*  8 - ?  */

  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  @ - G  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H - O  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  P - W  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  X - _  */

  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  ` - g  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h - o  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  p - w  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  x -127 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */

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

#else          /* This is the "abnormal" case, for EBCDIC systems */

static const unsigned char digitab[] =

  {

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7  0 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15    */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31    */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47    */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63    */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 40 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  72- |     */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  88- 0xAC  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 60 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ?     */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "     */

  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g  80 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143    */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159    */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175    */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191    */

  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  { - G  C0 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207    */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223    */

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

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239    */

  0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  F0 */

  0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255    */

static const unsigned char ebcdic_chartab[] = { /* chartable partial dup */

  0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*   0-  7 */

  0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */

  0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  16- 23 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */

  0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  32- 39 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63 */

  0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 */

  0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /*  72- |  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 */

  0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /*  88- 0xAC */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 */

  0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ?  */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "  */

  0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g  */

  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143 */

  0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p  */

  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159 */

  0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x  */

  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175 */

  0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 */

  0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */

  0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  { - G  */

  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207 */

  0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  } - P  */

  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223 */

  0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /*  \ - X  */

  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239 */

  0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */

  0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255 */

#endif

/* Definition to allow mutual recursion */

static BOOL

  compile_regex(int, int, int *, uschar **, const pcre_uchar **, const pcre_uchar *, int *, BOOL, int,

    int *, int *, branch_chain *, compile_data *);

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

*            Handle escapes                      *

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

/* This function is called when a \ has been encountered. It either returns a

positive value for a simple escape such as \n, or a negative value which

encodes one of the more complicated things such as \d. When UTF-8 is enabled,

a positive value greater than 255 may be returned. On entry, ptr is pointing at

the \. On exit, it is on the final character of the escape sequence.

Arguments:

  ptrptr         points to the pattern position pointer

  errorcodeptr   points to the errorcode variable

  bracount       number of previous extracting brackets

  options        the options bits

  isclass        TRUE if inside a character class

Returns:         zero or positive => a data character

                 negative => a special escape sequence

                 on error, errorptr is set

*/

static int

check_escape(const pcre_uchar **ptrptr, const pcre_uchar *patternEnd, int *errorcodeptr, int bracount,

  int options, BOOL isclass)

{

const pcre_uchar *ptr = *ptrptr;

int c, i;

/* If backslash is at the end of the pattern, it's an error. */

if (++ptr == patternEnd) {

    *errorcodeptr = ERR1;

    *ptrptr = ptr;

    return 0;

}

c = *ptr;

/* Non-alphamerics are literals. For digits or letters, do an initial lookup in

a table. A non-zero result is something that can be returned immediately.

Otherwise further processing may be required. */

#if !EBCDIC    /* ASCII coding */

if (c < '0' || c > 'z') {}                           /* Not alphameric */

else if ((i = escapes[c - '0']) != 0) c = i;

#else          /* EBCDIC coding */

if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphameric */

else if ((i = escapes[c - 0x48]) != 0)  c = i;

#endif

/* Escapes that need further processing, or are illegal. */

else

  {

  const pcre_uchar *oldptr;

  switch (c)

    {

    /* A number of Perl escapes are not handled by PCRE. We give an explicit

    error. */

#if !JAVASCRIPT

    case 'l':

    case 'L':

    case 'N':

    case 'u':

    case 'U':

    *errorcodeptr = ERR37;

    break;

#endif

    /* The handling of escape sequences consisting of a string of digits

    starting with one that is not zero is not straightforward. By experiment,

    the way Perl works seems to be as follows:

    Outside a character class, the digits are read as a decimal number. If the

    number is less than 10, or if there are that many previous extracting

    left brackets, then it is a back reference. Otherwise, up to three octal

    digits are read to form an escaped byte. Thus \123 is likely to be octal

    123 (cf \0123, which is octal 012 followed by the literal 3). If the octal

    value is greater than 377, the least significant 8 bits are taken. Inside a

    character class, \ followed by a digit is always an octal number. */

    case '1': case '2': case '3': case '4': case '5':

    case '6': case '7': case '8': case '9':

    if (!isclass)

      {

      oldptr = ptr;

      c -= '0';

      while (ptr + 1 < patternEnd && (DIGITAB(ptr[1]) & ctype_digit) != 0)

        c = c * 10 + *(++ptr) - '0';

      if (c < 10 || c <= bracount)

        {

        c = -(ESC_REF + c);

        break;

        }

      ptr = oldptr;      /* Put the pointer back and fall through */

      }

    /* Handle an octal number following \. If the first digit is 8 or 9, Perl

    generates a binary zero byte and treats the digit as a following literal.

    Thus we have to pull back the pointer by one. */

    if ((c = *ptr) >= '8')

      {

      ptr--;

      c = 0;

      break;

      }

    /* \0 always starts an octal number, but we may drop through to here with a

    larger first octal digit. */

    case '0':

    c -= '0';

    while (i++ < 2 && ptr + 1 < patternEnd && ptr[1] >= '0' && ptr[1] <= '7')

        c = c * 8 + *(++ptr) - '0';

    c &= 255;     /* Take least significant 8 bits */

    break;

    /* \x is complicated when UTF-8 is enabled. \x{ddd} is a character number

    which can be greater than 0xff, but only if the ddd are hex digits. */

    case 'x':

#ifdef SUPPORT_UTF8

    if (ptr + 1 < patternEnd && ptr[1] == '{' && (options & PCRE_UTF8) != 0)

      {

      const pcre_uchar *pt = ptr + 2;

      register int count = 0;

      c = 0;

      while (pt < patternEnd && (DIGITAB(*pt) & ctype_xdigit) != 0)

        {

        int cc = *pt++;

        count++;

#if !EBCDIC    /* ASCII coding */

        if (cc >= 'a') cc -= 32;               /* Convert to upper case */

        c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));

#else          /* EBCDIC coding */

        if (cc >= 'a' && cc <= 'z') cc += 64;  /* Convert to upper case */

        c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));

#endif

        }

      if (pt < patternEnd && *pt == '}')

        {

        if (c < 0 || count > 8 || (c >= 0xd800 && c <= 0xdbff) || (c >= 0xfdd0 && c <= 0xfdef) || c == 0xfffe || c == 0xffff || c > 0x10FFFF) *errorcodeptr = ERR34;

        ptr = pt;

        break;

        }

      /* If the sequence of hex digits does not end with '}', then we don't

      recognize this construct; fall through to the normal \x handling. */