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

*      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 header contains definitions that are shared between the different

modules, but which are not relevant to the exported API. This includes some

functions whose names all begin with "_pcre_". */

#ifndef PCRE_INTERNAL_H

#define PCRE_INTERNAL_H

#include "Assertions.h"

/* Added to prevent 64-to-32 shortening warnings when compiling for 64-bit

  <rdar://problem/4712064> PCRE generates many warnings with -Wshorten-64-to-32 */

#if defined(__GNUC__) && defined(__LP64__)

#define INT_CAST(i) (int)(i); ASSERT((i) <= INT_MAX)

#else

#define INT_CAST(i) (i)

#endif

#if COMPILER(MSVC)

#pragma warning(disable: 4232)

#pragma warning(disable: 4244)

#endif

#define _pcre_OP_lengths kjs_pcre_OP_lengths

#define _pcre_default_tables kjs_pcre_default_tables

#define _pcre_ord2utf8 kjs_pcre_ord2utf8

#define _pcre_printint kjs_pcre_printint

#define _pcre_try_flipped kjs_pcre_try_flipped

#define _pcre_ucp_findchar kjs_pcre_ucp_findchar

#define _pcre_utf8_table1 kjs_pcre_utf8_table1

#define _pcre_utf8_table1_size  kjs_pcre_utf8_table1_size

#define _pcre_utf8_table2 kjs_pcre_utf8_table2

#define _pcre_utf8_table3 kjs_pcre_utf8_table3

#define _pcre_utf8_table4 kjs_pcre_utf8_table4

#define _pcre_utt kjs_pcre_utt

#define _pcre_utt_size kjs_pcre_utt_size

#define _pcre_valid_utf8 kjs_pcre_valid_utf8

#define _pcre_xclass kjs_pcre_xclass

/* Define DEBUG to get debugging output on stdout. */

#if 0

#define DEBUG

#endif

/* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef

inline, and there are *still* stupid compilers about that don't like indented

pre-processor statements, or at least there were when I first wrote this. After

all, it had only been about 10 years then... */

#ifdef DEBUG

#define DPRINTF(p) printf p

#else

#define DPRINTF(p) /*nothing*/

#endif

/* Get the definitions provided by running "configure" */

#include "pcre-config.h"

/* Standard C headers plus the external interface definition. The only time

setjmp and stdarg are used is when NO_RECURSE is set. */

#include <ctype.h>

#include <limits.h>

#include <setjmp.h>

#include <stdarg.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifndef PCRE_SPY

#define PCRE_DEFINITION       /* Win32 __declspec(export) trigger for .dll */

#endif

/* We need to have types that specify unsigned 16-bit and 32-bit integers. We

cannot determine these outside the compilation (e.g. by running a program as

part of "configure") because PCRE is often cross-compiled for use on other

systems. Instead we make use of the maximum sizes that are available at

preprocessor time in standard C environments. */

#if USHRT_MAX == 65535

  typedef unsigned short pcre_uint16;

#elif UINT_MAX == 65535

  typedef unsigned int pcre_uint16;

#else

  #error Cannot determine a type for 16-bit unsigned integers

#endif

#if UINT_MAX == 4294967295

  typedef unsigned int pcre_uint32;

#elif ULONG_MAX == 4294967295

  typedef unsigned long int pcre_uint32;

#else

  #error Cannot determine a type for 32-bit unsigned integers

#endif

/* Include the public PCRE header and the definitions of UCP character property

values. */

#include "pcre.h"

#include "ucp.h"

/* All character handling must be done as unsigned characters. Otherwise there

are problems with top-bit-set characters and functions such as isspace().

However, we leave the interface to the outside world as char *, because that

should make things easier for callers. We define a short type for unsigned char

to save lots of typing. I tried "uchar", but it causes problems on Digital

Unix, where it is defined in sys/types, so use "uschar" instead. */

typedef unsigned char uschar;

/* Use pcre_uchar for always-unsigned version of pcre_char. */

#if PCRE_UTF16

typedef pcre_char pcre_uchar;

#else

typedef unsigned char pcre_uchar;

#endif

/* When compiling for use with the Virtual Pascal compiler, these functions

need to have their names changed. PCRE must be compiled with the -DVPCOMPAT

option on the command line. */

#ifdef VPCOMPAT

#define strncmp(s1,s2,m) _strncmp(s1,s2,m)

#define memcpy(d,s,n)    _memcpy(d,s,n)

#define memmove(d,s,n)   _memmove(d,s,n)

#define memset(s,c,n)    _memset(s,c,n)

#else  /* VPCOMPAT */

/* To cope with SunOS4 and other systems that lack memmove() but have bcopy(),

define a macro for memmove() if HAVE_MEMMOVE is false, provided that HAVE_BCOPY

is set. Otherwise, include an emulating function for those systems that have

neither (there some non-Unix environments where this is the case). This assumes

that all calls to memmove are moving strings upwards in store, which is the

case in PCRE. */

#if ! HAVE_MEMMOVE

#undef  memmove        /* some systems may have a macro */

#if HAVE_BCOPY

#define memmove(a, b, c) bcopy(b, a, c)

#else  /* HAVE_BCOPY */

void *

pcre_memmove(unsigned char *dest, const unsigned char *src, size_t n)

{

int i;

dest += n;

src += n;

for (i = 0; i < n; ++i) *(--dest) =  *(--src);

}

#define memmove(a, b, c) pcre_memmove(a, b, c)

#endif   /* not HAVE_BCOPY */

#endif   /* not HAVE_MEMMOVE */

#endif   /* not VPCOMPAT */

/* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored

in big-endian order) by default. These are used, for example, to link from the

start of a subpattern to its alternatives and its end. The use of 2 bytes per

offset limits the size of the compiled regex to around 64K, which is big enough

for almost everybody. However, I received a request for an even bigger limit.

For this reason, and also to make the code easier to maintain, the storing and

loading of offsets from the byte string is now handled by the macros that are

defined here.

The macros are controlled by the value of LINK_SIZE. This defaults to 2 in

the config.h file, but can be overridden by using -D on the command line. This

is automated on Unix systems via the "configure" command. */

#if LINK_SIZE == 2

#define PUT(a,n,d)   \

  (a[n] = (d) >> 8), \

  (a[(n)+1] = (d) & 255)

#define GET(a,n) \

  (((a)[n] << 8) | (a)[(n)+1])

#define MAX_PATTERN_SIZE (1 << 16)

#elif LINK_SIZE == 3

#define PUT(a,n,d)       \

  (a[n] = (d) >> 16),    \

  (a[(n)+1] = (d) >> 8), \

  (a[(n)+2] = (d) & 255)

#define GET(a,n) \

  (((a)[n] << 16) | ((a)[(n)+1] << 8) | (a)[(n)+2])

#define MAX_PATTERN_SIZE (1 << 24)

#elif LINK_SIZE == 4

#define PUT(a,n,d)        \

  (a[n] = (d) >> 24),     \

  (a[(n)+1] = (d) >> 16), \

  (a[(n)+2] = (d) >> 8),  \

  (a[(n)+3] = (d) & 255)

#define GET(a,n) \

  (((a)[n] << 24) | ((a)[(n)+1] << 16) | ((a)[(n)+2] << 8) | (a)[(n)+3])

#define MAX_PATTERN_SIZE (1 << 30)   /* Keep it positive */

#else

#error LINK_SIZE must be either 2, 3, or 4

#endif

/* Convenience macro defined in terms of the others */

#define PUTINC(a,n,d)   PUT(a,n,d), a += LINK_SIZE

/* PCRE uses some other 2-byte quantities that do not change when the size of

offsets changes. There are used for repeat counts and for other things such as

capturing parenthesis numbers in back references. */

#define PUT2(a,n,d)   \

  a[n] = (d) >> 8; \

  a[(n)+1] = (d) & 255

#define GET2(a,n) \

  (((a)[n] << 8) | (a)[(n)+1])

#define PUT2INC(a,n,d)  PUT2(a,n,d), a += 2

/* When UTF-8 encoding is being used, a character is no longer just a single

byte. The macros for character handling generate simple sequences when used in

byte-mode, and more complicated ones for UTF-8 characters. */

#ifndef SUPPORT_UTF8

#define GETCHAR(c, eptr) c = *eptr;

#define GETCHARTEST(c, eptr) c = *eptr;

#define GETCHARINC(c, eptr) c = *eptr++;

#define GETCHARINCTEST(c, eptr) c = *eptr++;

#define GETCHARLEN(c, eptr, len) c = *eptr;

#define BACKCHAR(eptr)

#else   /* SUPPORT_UTF8 */

/* Get the next UTF-8 character, not advancing the pointer, incrementing length

if there are extra bytes. This is called when we know we are in UTF-8 mode. */

#define GETUTF8CHARLEN(c, eptr, len) \

  c = *eptr; \

  if ((c & 0xc0) == 0xc0) \

    { \

    int gcii; \

    int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \

    int gcss = 6*gcaa; \

    c = (c & _pcre_utf8_table3[gcaa]) << gcss; \

    for (gcii = 1; gcii <= gcaa; gcii++) \

      { \

      gcss -= 6; \

      c |= (eptr[gcii] & 0x3f) << gcss; \

      } \

    len += gcaa; \

    }

/* Get the next UTF-8 character, advancing the pointer. This is called when we

know we are in UTF-8 mode. */

#define GETUTF8CHARINC(c, eptr) \

c = *eptr++; \

if ((c & 0xc0) == 0xc0) \

{ \

  int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \

    int gcss = 6*gcaa; \

      c = (c & _pcre_utf8_table3[gcaa]) << gcss; \

        while (gcaa-- > 0) \

        { \

          gcss -= 6; \

            c |= (*eptr++ & 0x3f) << gcss; \

        } \

}

#if PCRE_UTF16

#define LEAD_OFFSET (0xd800 - (0x10000 >> 10))

#define SURROGATE_OFFSET (0x10000 - (0xd800 << 10) - 0xdc00)

#define IS_LEADING_SURROGATE(c) (((c) & ~0x3ff) == 0xd800)

#define IS_TRAILING_SURROGATE(c) (((c) & ~0x3ff) == 0xdc00)

#define DECODE_SURROGATE_PAIR(l, t) (((l) << 10) + (t) + SURROGATE_OFFSET)

#define LEADING_SURROGATE(c) (LEAD_OFFSET + ((c) >> 10))

#define TRAILING_SURROGATE(c) (0xdc00 + ((c) & 0x3FF))

#define GETCHAR(c, eptr) \

  c = eptr[0]; \

  if (IS_LEADING_SURROGATE(c)) \

    c = DECODE_SURROGATE_PAIR(c, eptr[1])

#define GETCHARTEST(c, eptr) GETCHAR(c, eptr)

#define GETCHARINC(c, eptr) \

  c = *eptr++; \

  if (IS_LEADING_SURROGATE(c)) \

    c = DECODE_SURROGATE_PAIR(c, *eptr++)

#define GETCHARINCTEST(c, eptr) GETCHARINC(c, eptr)

#define GETCHARLEN(c, eptr, len) \

  c = eptr[0]; \

  if (IS_LEADING_SURROGATE(c)) \

    { \

    c = DECODE_SURROGATE_PAIR(c, eptr[1]); \

    ++len; \

    }

#define GETCHARLENEND(c, eptr, end, len) \

  c = eptr[0]; \

  if (IS_LEADING_SURROGATE(c)) \

    { \

    c = DECODE_SURROGATE_PAIR(c, eptr + 1 < end ? eptr[1] : 0); \

    ++len; \

    }

#define ISMIDCHAR(c) IS_TRAILING_SURROGATE(c)

#else

/* Get the next UTF-8 character, not advancing the pointer. This is called when

we know we are in UTF-8 mode. */

#define GETCHAR(c, eptr) \

  c = *eptr; \

  if ((c & 0xc0) == 0xc0) \

    { \

    int gcii; \

    int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \

    int gcss = 6*gcaa; \

    c = (c & _pcre_utf8_table3[gcaa]) << gcss; \

    for (gcii = 1; gcii <= gcaa; gcii++) \

      { \

      gcss -= 6; \

      c |= (eptr[gcii] & 0x3f) << gcss; \

      } \

    }

/* Get the next UTF-8 character, testing for UTF-8 mode, and not advancing the

pointer. */

#define GETCHARTEST(c, eptr) \

  c = *eptr; \

  if (utf8 && (c & 0xc0) == 0xc0) \

    { \

    int gcii; \

    int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \

    int gcss = 6*gcaa; \

    c = (c & _pcre_utf8_table3[gcaa]) << gcss; \

    for (gcii = 1; gcii <= gcaa; gcii++) \

      { \

      gcss -= 6; \

      c |= (eptr[gcii] & 0x3f) << gcss; \

      } \

    }

/* Get the next UTF-8 character, advancing the pointer. This is called when we

know we are in UTF-8 mode. */

#define GETCHARINC GETUTF8CHARINC

/* Get the next character, testing for UTF-8 mode, and advancing the pointer */

#define GETCHARINCTEST(c, eptr) \

  c = *eptr++; \

  if (utf8 && (c & 0xc0) == 0xc0) \

    { \

    int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \

    int gcss = 6*gcaa; \

    c = (c & _pcre_utf8_table3[gcaa]) << gcss; \

    while (gcaa-- > 0) \

      { \

      gcss -= 6; \

      c |= (*eptr++ & 0x3f) << gcss; \

      } \

    }

#define GETCHARLEN(c, eptr) GETUTF8CHARLEN(c, eptr)

/* Return 1 if not the start of a character. */

#define ISMIDCHAR(c) (((c) & 0xc0) == 0x80)

#endif

/* If the pointer is not at the start of a character, move it back until

it is. Called only in UTF-8 mode. */

#define BACKCHAR(eptr) while(ISMIDCHAR(*eptr)) eptr--;

#endif

/* In case there is no definition of offsetof() provided - though any proper

Standard C system should have one. */

#ifndef offsetof

#define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field))

#endif

/* These are the public options that can change during matching. */

#define PCRE_IMS (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL)

/* Private options flags start at the most significant end of the four bytes,

but skip the top bit so we can use ints for convenience without getting tangled

with negative values. The public options defined in pcre.h start at the least

significant end. Make sure they don't overlap! */

#define PCRE_FIRSTSET      0x40000000  /* first_byte is set */

#define PCRE_REQCHSET      0x20000000  /* req_byte is set */

#define PCRE_STARTLINE     0x10000000  /* start after \n for multiline */

#define PCRE_ICHANGED      0x08000000  /* i option changes within regex */

#define PCRE_NOPARTIAL     0x04000000  /* can't use partial with this regex */

/* Options for the "extra" block produced by pcre_study(). */

#define PCRE_STUDY_MAPPED   0x01     /* a map of starting chars exists */

/* Masks for identifying the public options that are permitted at compile

time, run time, or study time, respectively. */

#define PUBLIC_OPTIONS \

  (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \

   PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \

   PCRE_NO_AUTO_CAPTURE|PCRE_NO_UTF8_CHECK|PCRE_AUTO_CALLOUT|PCRE_FIRSTLINE)

#define PUBLIC_EXEC_OPTIONS \

  (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \

   PCRE_PARTIAL)

#define PUBLIC_DFA_EXEC_OPTIONS \

  (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \

   PCRE_PARTIAL|PCRE_DFA_SHORTEST|PCRE_DFA_RESTART)

#define PUBLIC_STUDY_OPTIONS 0   /* None defined */

/* Magic number to provide a small check against being handed junk. Also used

to detect whether a pattern was compiled on a host of different endianness. */

#define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */

/* Negative values for the firstchar and reqchar variables */

#define REQ_UNSET (-2)

#define REQ_NONE  (-1)

/* The maximum remaining length of subject we are prepared to search for a

req_byte match. */

#define REQ_BYTE_MAX 1000

/* Flags added to firstbyte or reqbyte; a "non-literal" item is either a

variable-length repeat, or a anything other than literal characters. */

#define REQ_CASELESS 0x0100    /* indicates caselessness */

#define REQ_VARY     0x0200    /* reqbyte followed non-literal item */

/* Miscellaneous definitions */

typedef int BOOL;

#define FALSE   0

#define TRUE    1

/* Escape items that are just an encoding of a particular data value. Note that

ESC_n is defined as yet another macro, which is set in config.h to either \n

(the default) or \r (which some people want). */

#ifndef ESC_e

#define ESC_e 27

#endif

#ifndef ESC_f

#define ESC_f '\f'

#endif