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

*      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-2008 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.

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

*/

/* 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

/* 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...

It turns out that the Mac Debugging.h header also defines the macro DPRINTF, so

be absolutely sure we get our version. */

#undef DPRINTF

#ifdef DEBUG

#define DPRINTF(p) printf p

#else

#define DPRINTF(p) /* Nothing */

#endif

/* 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>

/* When compiling a DLL for Windows, the exported symbols have to be declared

using some MS magic. I found some useful information on this web page:

http://msdn2.microsoft.com/en-us/library/y4h7bcy6(VS.80).aspx. According to the

information there, using __declspec(dllexport) without "extern" we have a

definition; with "extern" we have a declaration. The settings here override the

setting in pcre.h (which is included below); it defines only PCRE_EXP_DECL,

which is all that is needed for applications (they just import the symbols). We

use:

  PCRE_EXP_DECL       for declarations

  PCRE_EXP_DEFN       for definitions of exported functions

  PCRE_EXP_DATA_DEFN  for definitions of exported variables

The reason for the two DEFN macros is that in non-Windows environments, one

does not want to have "extern" before variable definitions because it leads to

compiler warnings. So we distinguish between functions and variables. In

Windows, the two should always be the same.

The reason for wrapping this in #ifndef PCRE_EXP_DECL is so that pcretest,

which is an application, but needs to import this file in order to "peek" at

internals, can #include pcre.h first to get an application's-eye view.

In principle, people compiling for non-Windows, non-Unix-like (i.e. uncommon,

special-purpose environments) might want to stick other stuff in front of

exported symbols. That's why, in the non-Windows case, we set PCRE_EXP_DEFN and

PCRE_EXP_DATA_DEFN only if they are not already set. */

#ifndef PCRE_EXP_DECL

#  ifdef _WIN32

#    ifndef PCRE_STATIC

#      define PCRE_EXP_DECL       extern __declspec(dllexport)

#      define PCRE_EXP_DEFN       __declspec(dllexport)

#      define PCRE_EXP_DATA_DEFN  __declspec(dllexport)

#    else

#      define PCRE_EXP_DECL       extern

#      define PCRE_EXP_DEFN

#      define PCRE_EXP_DATA_DEFN

#    endif

#  else

#    ifdef __cplusplus

#      define PCRE_EXP_DECL       extern "C"

#    else

#      define PCRE_EXP_DECL       extern

#    endif

#    ifndef PCRE_EXP_DEFN

#      define PCRE_EXP_DEFN       PCRE_EXP_DECL

#    endif

#    ifndef PCRE_EXP_DATA_DEFN

#      define PCRE_EXP_DATA_DEFN

#    endif

#  endif

#endif

/* When compiling with the MSVC compiler, it is sometimes necessary to include

a "calling convention" before exported function names. (This is secondhand

information; I know nothing about MSVC myself). For example, something like

  void __cdecl function(....)

might be needed. In order so make this easy, all the exported functions have

PCRE_CALL_CONVENTION just before their names. It is rarely needed; if not

set, we ensure here that it has no effect. */

#ifndef PCRE_CALL_CONVENTION

#define PCRE_CALL_CONVENTION

#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;

  typedef short pcre_int16;

#elif UINT_MAX == 65535

  typedef unsigned int pcre_uint16;

  typedef int pcre_int16;

#else

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

#endif

#if UINT_MAX == 4294967295

  typedef unsigned int pcre_uint32;

  typedef int pcre_int32;

#elif ULONG_MAX == 4294967295

  typedef unsigned long int pcre_uint32;

  typedef long int pcre_int32;

#else

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

#endif

/* 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;

/* This is an unsigned int value that no character can ever have. UTF-8

characters only go up to 0x7fffffff (though Unicode doesn't go beyond

0x0010ffff). */

#define NOTACHAR 0xffffffff

/* PCRE is able to support several different kinds of newline (CR, LF, CRLF,

"any" and "anycrlf" at present). The following macros are used to package up

testing for newlines. NLBLOCK, PSSTART, and PSEND are defined in the various

modules to indicate in which datablock the parameters exist, and what the

start/end of string field names are. */

#define NLTYPE_FIXED    0     /* Newline is a fixed length string */

#define NLTYPE_ANY      1     /* Newline is any Unicode line ending */

#define NLTYPE_ANYCRLF  2     /* Newline is CR, LF, or CRLF */

/* This macro checks for a newline at the given position */

#define IS_NEWLINE(p) \

  ((NLBLOCK->nltype != NLTYPE_FIXED)? \

    ((p) < NLBLOCK->PSEND && \

     _pcre_is_newline((p), NLBLOCK->nltype, NLBLOCK->PSEND, &(NLBLOCK->nllen),\

       utf8)) \

    : \

    ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \

     (p)[0] == NLBLOCK->nl[0] && \

     (NLBLOCK->nllen == 1 || (p)[1] == NLBLOCK->nl[1]) \

    ) \

  )

/* This macro checks for a newline immediately preceding the given position */

#define WAS_NEWLINE(p) \

  ((NLBLOCK->nltype != NLTYPE_FIXED)? \

    ((p) > NLBLOCK->PSSTART && \

     _pcre_was_newline((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \

       &(NLBLOCK->nllen), utf8)) \

    : \

    ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \

     (p)[-NLBLOCK->nllen] == NLBLOCK->nl[0] && \

     (NLBLOCK->nllen == 1 || (p)[-NLBLOCK->nllen+1] == NLBLOCK->nl[1]) \

    ) \

  )

/* When PCRE is compiled as a C++ library, the subject pointer can be replaced

with a custom type. This makes it possible, for example, to allow pcre_exec()

to process subject strings that are discontinuous by using a smart pointer

class. It must always be possible to inspect all of the subject string in

pcre_exec() because of the way it backtracks. Two macros are required in the

normal case, for sign-unspecified and unsigned char pointers. The former is

used for the external interface and appears in pcre.h, which is why its name

must begin with PCRE_. */

#ifdef CUSTOM_SUBJECT_PTR

#define PCRE_SPTR CUSTOM_SUBJECT_PTR

#define USPTR CUSTOM_SUBJECT_PTR

#else

#define PCRE_SPTR const char *

#define USPTR const unsigned char *

#endif

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

values. */

#include "pcre.h"

#include "ucp.h"

/* 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 strlen(s)        _strlen(s)

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

#define memcmp(s,c,n)    _memcmp(s,c,n)

#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). */

#ifndef HAVE_MEMMOVE

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

#ifdef HAVE_BCOPY

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

#else  /* HAVE_BCOPY */

static void *

pcre_memmove(void *d, const void *s, size_t n)

{

size_t i;

unsigned char *dest = (unsigned char *)d;

const unsigned char *src = (const unsigned char *)s;

if (dest > src)

  {

  dest += n;

  src += n;

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

  return (void *)dest;

  }

else

  {

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

  return (void *)(dest - n);

  }

}

#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. BACKCHAR should

never be called in byte mode. To make sure it can never even appear when UTF-8

support is omitted, we don't even define it. */

#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. This is called when

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

#define GETCHAR(c, eptr) \

  c = *eptr; \

  if (c >= 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) \

    { \

    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(c, eptr) \

  c = *eptr++; \

  if (c >= 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; \

      } \

    }

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

#define GETCHARINCTEST(c, eptr) \

  c = *eptr++; \

  if (utf8 && c >= 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; \

      } \

    }

/* 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 GETCHARLEN(c, eptr, len) \

  c = *eptr; \

  if (c >= 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; \

    }

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

it is. This is called only in UTF-8 mode - we don't put a test within the macro

because almost all calls are already within a block of UTF-8 only code. */

#define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) 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 flags containing information about the compiled regex. They used to

live at the top end of the options word, but that got almost full, so now they

are in a 16-bit flags word. */

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

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

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

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

#define PCRE_JCHANGED      0x0010  /* j option used in regex */

#define PCRE_HASCRORLF     0x0020  /* explicit \r or \n in pattern */

/* 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 PCRE_NEWLINE_BITS (PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|PCRE_NEWLINE_ANY| \

                           PCRE_NEWLINE_ANYCRLF)

#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| \

   PCRE_DUPNAMES|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \

   PCRE_JAVASCRIPT_COMPAT)