/[pcre]/code/trunk/pcre_jit_compile.c

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 669 by ph10,
Tue Aug 23 09:56:11 2011 UTC
+revision 953 by zherczeg,
Thu Mar 29 17:41:57 2012 UTC
 Line 6
  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
+            Copyright (c) 1997-2012 University of Cambridge
    The machine code generator part (this module) was written by Zoltan Herczeg
-                       Copyright (c) 2010-2011
+                       Copyright (c) 2010-2012
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 52 
 POSSIBILITY OF SUCH DAMAGE.
  we just include it. This way we don't need to touch the build
  system files. */
+ #define SLJIT_MALLOC(size) (PUBL(malloc))(size)
+ #define SLJIT_FREE(ptr) (PUBL(free))(ptr)
  #define SLJIT_CONFIG_AUTO 1
+ #define SLJIT_CONFIG_STATIC 1
  #define SLJIT_VERBOSE 0
  #define SLJIT_DEBUG 0
  #include "sljit/sljitLir.c"
  #if defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED
- #error "Unsupported architecture"
+ #error Unsupported architecture
  #endif
  /* Allocate memory on the stack. Fast, but limited size. */
-Line 119 
 The generated code will be the following
+Line 122 
 The generated code will be the following
   jump to D hot path
   C fallback path
   A fallback path
   Notice, that the order of fallback code paths are the opposite of the fast
   code paths. In this way the topmost value on the stack is always belong
   to the current fallback code path. The fallback code path must check
-Line 145 
 Thus we can restore the locals to a part
+Line 148 
 Thus we can restore the locals to a part
  typedef struct jit_arguments {
    /* Pointers first. */
    struct sljit_stack *stack;
-   PCRE_SPTR str;
+   const pcre_uchar *str;
-   PCRE_SPTR begin;
+   const pcre_uchar *begin;
-   PCRE_SPTR end;
+   const pcre_uchar *end;
    int *offsets;
-   uschar *ptr;
+   pcre_uchar *uchar_ptr;
+   pcre_uchar *mark_ptr;
    /* Everything else after. */
    int offsetcount;
-   uschar notbol;
+   int calllimit;
-   uschar noteol;
+   pcre_uint8 notbol;
-   uschar notempty;
+   pcre_uint8 noteol;
-   uschar notempty_atstart;
+   pcre_uint8 notempty;
+   pcre_uint8 notempty_atstart;
  } jit_arguments;
- typedef struct executable_function {
+ typedef struct executable_functions {
-   void *executable_func;
+   void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];
-   pcre_jit_callback callback;
+   PUBL(jit_callback) callback;
    void *userdata;
- } executable_function;
+   sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
+ } executable_functions;
  typedef struct jump_list {
    struct sljit_jump *jump;
    struct jump_list *next;
  } jump_list;
- enum stub_types { stack_alloc, max_index };
+ enum stub_types { stack_alloc };
  typedef struct stub_list {
    enum stub_types type;
-Line 193 
 typedef struct fallback_common {
+Line 199 
 typedef struct fallback_common {
    struct fallback_common *top;
    jump_list *topfallbacks;
    /* Opcode pointer. */
-   uschar *cc;
+   pcre_uchar *cc;
  } fallback_common;
  typedef struct assert_fallback {
-Line 264 
 typedef struct recurse_fallback {
+Line 270 
 typedef struct recurse_fallback {
  typedef struct compiler_common {
    struct sljit_compiler *compiler;
-   uschar *start;
+   pcre_uchar *start;
+   /* Local stack area size and variable pointers. */
    int localsize;
    int *localptrs;
-   const uschar *fcc;
-   sljit_w lcc;
    int cbraptr;
+   /* OVector starting point. Must be divisible by 2. */
+   int ovector_start;
+   /* Last known position of the requested byte. */
+   int req_char_ptr;
+   /* Head of the last recursion. */
+   int recursive_head;
+   /* First inspected character for partial matching. */
+   int start_used_ptr;
+   /* Starting pointer for partial soft matches. */
+   int hit_start;
+   /* End pointer of the first line. */
+   int first_line_end;
+   /* Points to the marked string. */
+   int mark_ptr;
+   /* Other  */
+   const pcre_uint8 *fcc;
+   sljit_w lcc;
+   int mode;
    int nltype;
    int newline;
    int bsr_nltype;
    int endonly;
+   BOOL has_set_som;
    sljit_w ctypes;
+   sljit_uw name_table;
+   sljit_w name_count;
+   sljit_w name_entry_size;
+   /* Labels and jump lists. */
+   struct sljit_label *partialmatchlabel;
+   struct sljit_label *leavelabel;
    struct sljit_label *acceptlabel;
    stub_list *stubs;
    recurse_entry *entries;
    recurse_entry *currententry;
+   jump_list *partialmatch;
+   jump_list *leave;
    jump_list *accept;
+   jump_list *calllimit;
    jump_list *stackalloc;
    jump_list *revertframes;
    jump_list *wordboundary;
-Line 289 
 typedef struct compiler_common {
+Line 325 
 typedef struct compiler_common {
    jump_list *casefulcmp;
    jump_list *caselesscmp;
    BOOL jscript_compat;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   BOOL utf8;
+   BOOL utf;
  #ifdef SUPPORT_UCP
-   BOOL useucp;
+   BOOL use_ucp;
  #endif
-   jump_list *utf8readchar;
+   jump_list *utfreadchar;
-   jump_list *utf8readtype8;
+ #ifdef COMPILE_PCRE8
+   jump_list *utfreadtype8;
  #endif
+ #endif /* SUPPORT_UTF */
  #ifdef SUPPORT_UCP
    jump_list *getucd;
  #endif
-Line 308 
 typedef struct compare_context {
+Line 346 
 typedef struct compare_context {
    int length;
    int sourcereg;
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
-   int byteptr;
+   int ucharptr;
    union {
-     int asint;
+     sljit_i asint;
-     short asshort;
+     sljit_uh asushort;
+ #ifdef COMPILE_PCRE8
      sljit_ub asbyte;
-     sljit_ub asbytes[4];
+     sljit_ub asuchars[4];
+ #else
+ #ifdef COMPILE_PCRE16
+     sljit_uh asuchars[2];
+ #endif
+ #endif
    } c;
    union {
-     int asint;
+     sljit_i asint;
-     short asshort;
+     sljit_uh asushort;
+ #ifdef COMPILE_PCRE8
      sljit_ub asbyte;
-     sljit_ub asbytes[4];
+     sljit_ub asuchars[4];
+ #else
+ #ifdef COMPILE_PCRE16
+     sljit_uh asuchars[2];
+ #endif
+ #endif
    } oc;
  #endif
  } compare_context;
  enum {
    frame_end = 0,
-   frame_setmaxindex = -1,
+   frame_setstrbegin = -1,
-   frame_setstrbegin = -2
+   frame_setmark = -2
  };
+ /* Undefine sljit macros. */
+ #undef CMP
  /* Used for accessing the elements of the stack. */
  #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_w))
  #define TMP1          SLJIT_TEMPORARY_REG1
  #define TMP2          SLJIT_TEMPORARY_REG3
  #define TMP3          SLJIT_TEMPORARY_EREG2
- #define STR_PTR       SLJIT_GENERAL_REG1
+ #define STR_PTR       SLJIT_SAVED_REG1
- #define STR_END       SLJIT_GENERAL_REG2
+ #define STR_END       SLJIT_SAVED_REG2
  #define STACK_TOP     SLJIT_TEMPORARY_REG2
- #define STACK_LIMIT   SLJIT_GENERAL_REG3
+ #define STACK_LIMIT   SLJIT_SAVED_REG3
- #define ARGUMENTS     SLJIT_GENERAL_EREG1
+ #define ARGUMENTS     SLJIT_SAVED_EREG1
- #define MAX_INDEX     SLJIT_GENERAL_EREG2
+ #define CALL_COUNT    SLJIT_SAVED_EREG2
  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1
  /* Locals layout. */
-Line 351 
 enum {
+Line 404 
 enum {
  /* Two local variables for possessive quantifiers (char1 cannot use them). */
  #define POSSESSIVE0      (2 * sizeof(sljit_w))
  #define POSSESSIVE1      (3 * sizeof(sljit_w))
- /* Head of the saved local variables */
+ /* Max limit of recursions. */
- #define LOCALS_HEAD      (4 * sizeof(sljit_w))
+ #define CALL_LIMIT       (4 * sizeof(sljit_w))
- /* Head of the last recursion. */
- #define RECURSIVE_HEAD   (5 * sizeof(sljit_w))
- /* Last known position of the requested byte. */
- #define REQ_BYTE_PTR     (6 * sizeof(sljit_w))
- /* End pointer of the first line. */
- #define FIRSTLINE_END    (7 * sizeof(sljit_w))
  /* The output vector is stored on the stack, and contains pointers
  to characters. The vector data is divided into two groups: the first
  group contains the start / end character pointers, and the second is
  the start pointers when the end of the capturing group has not yet reached. */
- #define OVECTOR_START    (8 * sizeof(sljit_w))
+ #define OVECTOR_START    (common->ovector_start)
  #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_w))
  #define OVECTOR_PRIV(i)  (common->cbraptr + (i) * sizeof(sljit_w))
- #define PRIV(cc)         (common->localptrs[(cc) - common->start])
+ #define PRIV_DATA(cc)    (common->localptrs[(cc) - common->start])
+ #ifdef COMPILE_PCRE8
+ #define MOV_UCHAR  SLJIT_MOV_UB
+ #define MOVU_UCHAR SLJIT_MOVU_UB
+ #else
+ #ifdef COMPILE_PCRE16
+ #define MOV_UCHAR  SLJIT_MOV_UH
+ #define MOVU_UCHAR SLJIT_MOVU_UH
+ #else
+ #error Unsupported compiling mode
+ #endif
+ #endif
  /* Shortcuts. */
  #define DEFINE_COMPILER \
-Line 390 
 the start pointers when the end of the c
+Line 449 
 the start pointers when the end of the c
  #define COND_VALUE(op, dst, dstw, type) \
    sljit_emit_cond_value(compiler, (op), (dst), (dstw), (type))
- static uschar* bracketend(uschar* cc)
+ static pcre_uchar* bracketend(pcre_uchar* cc)
  {
  SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
  do cc += GET(cc, 1); while (*cc == OP_ALT);
-Line 399 
 cc += 1 + LINK_SIZE;
+Line 458 
 cc += 1 + LINK_SIZE;
  return cc;
  }
  /* Functions whose might need modification for all new supported opcodes:
   next_opcode
   get_localspace
   set_localptrs
-Line 411 
 return cc;
+Line 470 
 return cc;
   compile_fallbackpath
  */
- static uschar *next_opcode(compiler_common *common, uschar *cc)
+ static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
  {
  SLJIT_UNUSED_ARG(common);
  switch(*cc)
-Line 460 
 switch(*cc)
+Line 519 
 switch(*cc)
    case OP_BRAZERO:
    case OP_BRAMINZERO:
    case OP_BRAPOSZERO:
+   case OP_COMMIT:
    case OP_FAIL:
    case OP_ACCEPT:
    case OP_ASSERT_ACCEPT:
    case OP_SKIPZERO:
    return cc + 1;
+   case OP_ANYBYTE:
+ #ifdef SUPPORT_UTF
+   if (common->utf) return NULL;
+ #endif
+   return cc + 1;
    case OP_CHAR:
    case OP_CHARI:
    case OP_NOT:
    case OP_NOTI:
    case OP_STAR:
    case OP_MINSTAR:
    case OP_PLUS:
-Line 508 
 switch(*cc)
+Line 573 
 switch(*cc)
    case OP_NOTPOSPLUSI:
    case OP_NOTPOSQUERYI:
    cc += 2;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
+   if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
    return cc;
-Line 529 
 switch(*cc)
+Line 594 
 switch(*cc)
    case OP_NOTMINUPTOI:
    case OP_NOTEXACTI:
    case OP_NOTPOSUPTOI:
-   cc += 4;
+   cc += 2 + IMM2_SIZE;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
+   if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
    return cc;
    case OP_NOTPROP:
    case OP_PROP:
+   return cc + 1 + 2;
    case OP_TYPEUPTO:
    case OP_TYPEMINUPTO:
    case OP_TYPEEXACT:
-Line 544 
 switch(*cc)
+Line 611 
 switch(*cc)
    case OP_REF:
    case OP_REFI:
    case OP_CREF:
+   case OP_NCREF:
+   case OP_RREF:
+   case OP_NRREF:
    case OP_CLOSE:
-   cc += 3;
+   cc += 1 + IMM2_SIZE;
    return cc;
    case OP_CRRANGE:
    case OP_CRMINRANGE:
-   return cc + 5;
+   return cc + 1 + 2 * IMM2_SIZE;
    case OP_CLASS:
    case OP_NCLASS:
-   return cc + 33;
+   return cc + 1 + 32 / sizeof(pcre_uchar);
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    case OP_XCLASS:
    return cc + GET(cc, 1);
  #endif
-Line 568 
 switch(*cc)
+Line 638 
 switch(*cc)
    case OP_ASSERTBACK_NOT:
    case OP_REVERSE:
    case OP_ONCE:
+   case OP_ONCE_NC:
    case OP_BRA:
    case OP_BRAPOS:
    case OP_COND:
-Line 585 
 switch(*cc)
+Line 656 
 switch(*cc)
    case OP_CBRAPOS:
    case OP_SCBRA:
    case OP_SCBRAPOS:
-   return cc + 1 + LINK_SIZE + 2;
+   return cc + 1 + LINK_SIZE + IMM2_SIZE;
+   case OP_MARK:
+   return cc + 1 + 2 + cc[1];
    default:
    return NULL;
    }
  }
- static int get_localspace(compiler_common *common, uschar *cc, uschar *ccend)
+ static int get_localspace(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
  {
  int localspace = 0;
- uschar *alternative;
+ pcre_uchar *alternative;
  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
    {
    switch(*cc)
      {
+     case OP_SET_SOM:
+     common->has_set_som = TRUE;
+     cc += 1;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
      case OP_ONCE:
+     case OP_ONCE_NC:
      case OP_BRAPOS:
      case OP_SBRA:
      case OP_SBRAPOS:
-Line 617 
 while (cc < ccend)
+Line 697 
 while (cc < ccend)
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
      localspace += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE + 2;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-Line 628 
 while (cc < ccend)
+Line 708 
 while (cc < ccend)
      cc += 1 + LINK_SIZE;
      break;
+     case OP_RECURSE:
+     /* Set its value only once. */
+     if (common->recursive_head == 0)
+       {
+       common->recursive_head = common->ovector_start;
+       common->ovector_start += sizeof(sljit_w);
+       }
+     cc += 1 + LINK_SIZE;
+     break;
+     case OP_MARK:
+     if (common->mark_ptr == 0)
+       {
+       common->mark_ptr = common->ovector_start;
+       common->ovector_start += sizeof(sljit_w);
+       }
+     cc += 1 + 2 + cc[1];
+     break;
      default:
      cc = next_opcode(common, cc);
      if (cc == NULL)
-Line 638 
 while (cc < ccend)
+Line 737 
 while (cc < ccend)
  return localspace;
  }
- static void set_localptrs(compiler_common *common, int localptr, uschar *ccend)
+ static void set_localptrs(compiler_common *common, int localptr, pcre_uchar *ccend)
  {
- uschar *cc = common->start;
+ pcre_uchar *cc = common->start;
- uschar *alternative;
+ pcre_uchar *alternative;
  while (cc < ccend)
    {
    switch(*cc)
-Line 651 
 while (cc < ccend)
+Line 750 
 while (cc < ccend)
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
      case OP_ONCE:
+     case OP_ONCE_NC:
      case OP_BRAPOS:
      case OP_SBRA:
      case OP_SBRAPOS:
-Line 664 
 while (cc < ccend)
+Line 764 
 while (cc < ccend)
      case OP_SCBRAPOS:
      common->localptrs[cc - common->start] = localptr;
      localptr += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE + 2;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-Line 687 
 while (cc < ccend)
+Line 787 
 while (cc < ccend)
  }
  /* Returns with -1 if no need for frame. */
- static int get_framesize(compiler_common *common, uschar *cc, BOOL recursive)
+ static int get_framesize(compiler_common *common, pcre_uchar *cc, BOOL recursive)
  {
- uschar *ccend = bracketend(cc);
+ pcre_uchar *ccend = bracketend(cc);
- uschar *end;
  int length = 0;
  BOOL possessive = FALSE;
- BOOL needs_frame = FALSE;
+ BOOL setsom_found = recursive;
- BOOL needs_maxindex = FALSE;
+ BOOL setmark_found = recursive;
- BOOL setsom_found = FALSE;
  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
    {
-   length = 3 + 2;
+   length = 3;
-   needs_maxindex = TRUE;
    possessive = TRUE;
    }
-Line 710 
 while (cc < ccend)
+Line 807 
 while (cc < ccend)
    switch(*cc)
      {
      case OP_SET_SOM:
-     case OP_RECURSE:
+     SLJIT_ASSERT(common->has_set_som);
      if (!setsom_found)
        {
        length += 2;
        setsom_found = TRUE;
        }
-     cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;
+     cc += 1;
      break;
-     case OP_ASSERT:
+     case OP_MARK:
-     case OP_ASSERT_NOT:
+     SLJIT_ASSERT(common->mark_ptr != 0);
-     case OP_ASSERTBACK:
+     if (!setmark_found)
-     case OP_ASSERTBACK_NOT:
-     case OP_ONCE:
-     if (needs_frame || length > 0)
        {
-       cc = bracketend(cc);
+       length += 2;
-       break;
+       setmark_found = TRUE;
        }
-     /* Check whether a frame must be created. */
+     cc += 1 + 2 + cc[1];
-     end = bracketend(cc);
+     break;
-     while (cc < end)
-       {
+     case OP_RECURSE:
-       if (*cc == OP_SET_SOM || *cc == OP_CBRA || *cc == OP_CBRAPOS
+     if (common->has_set_som && !setsom_found)
-           || *cc == OP_SCBRA || *cc == OP_SCBRAPOS || *cc == OP_RECURSE)
+       {
-         needs_frame = TRUE;
+       length += 2;
-       cc = next_opcode(common, cc);
+       setsom_found = TRUE;
-       SLJIT_ASSERT(cc != NULL);
+       }
+     if (common->mark_ptr != 0 && !setmark_found)
+       {
+       length += 2;
+       setmark_found = TRUE;
        }
+     cc += 1 + LINK_SIZE;
      break;
      case OP_CBRA:
      case OP_CBRAPOS:
      case OP_SCBRA:
      case OP_SCBRAPOS:
-     if (!needs_maxindex)
-       {
-       needs_maxindex = TRUE;
-       length += 2;
-       }
      length += 3;
-     cc += 1 + LINK_SIZE + 2;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      default:
-Line 761 
 while (cc < ccend)
+Line 855 
 while (cc < ccend)
      }
  /* Possessive quantifiers can use a special case. */
- if (SLJIT_UNLIKELY(possessive) && !needs_frame && length == 3 + 2)
+ if (SLJIT_UNLIKELY(possessive) && length == 3)
    return -1;
  if (length > 0)
-   return length + 2;
+   return length + 1;
- return needs_frame ? 0 : -1;
+ return -1;
  }
- static void init_frame(compiler_common *common, uschar *cc, int stackpos, int stacktop, BOOL recursive)
+ static void init_frame(compiler_common *common, pcre_uchar *cc, int stackpos, int stacktop, BOOL recursive)
  {
- /* TMP2 must contain STACK_TOP - (-STACK(stackpos)) */
  DEFINE_COMPILER;
- uschar *ccend = bracketend(cc);
+ pcre_uchar *ccend = bracketend(cc);
- BOOL needs_maxindex = FALSE;
+ BOOL setsom_found = recursive;
- BOOL setsom_found = FALSE;
+ BOOL setmark_found = recursive;
  int offset;
- if (stackpos < stacktop)
+ /* >= 1 + shortest item size (2) */
-   {
+ SLJIT_UNUSED_ARG(stacktop);
-   SLJIT_ASSERT(stackpos + 1 == stacktop);
+ SLJIT_ASSERT(stackpos >= stacktop + 2);
-   return;
-   }
  stackpos = STACK(stackpos);
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD);
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD, TMP2, 0);
- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacktop), TMP1, 0);
  if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
    cc = next_opcode(common, cc);
  SLJIT_ASSERT(cc != NULL);
-Line 796 
 while (cc < ccend)
+Line 883 
 while (cc < ccend)
    switch(*cc)
      {
      case OP_SET_SOM:
-     case OP_RECURSE:
+     SLJIT_ASSERT(common->has_set_som);
      if (!setsom_found)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
-Line 806 
 while (cc < ccend)
+Line 893 
 while (cc < ccend)
        stackpos += (int)sizeof(sljit_w);
        setsom_found = TRUE;
        }
-     cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;
+     cc += 1;
      break;
-     case OP_ASSERT:
+     case OP_MARK:
-     case OP_ASSERT_NOT:
+     SLJIT_ASSERT(common->mark_ptr != 0);
-     case OP_ASSERTBACK:
+     if (!setmark_found)
-     case OP_ASSERTBACK_NOT:
+       {
-     case OP_ONCE:
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
-     cc = bracketend(cc);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);
+       stackpos += (int)sizeof(sljit_w);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+       stackpos += (int)sizeof(sljit_w);
+       setmark_found = TRUE;
+       }
+     cc += 1 + 2 + cc[1];
      break;
-     case OP_CBRA:
+     case OP_RECURSE:
-     case OP_CBRAPOS:
+     if (common->has_set_som && !setsom_found)
-     case OP_SCBRA:
-     case OP_SCBRAPOS:
-     if (!needs_maxindex)
        {
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmaxindex);
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setstrbegin);
        stackpos += (int)sizeof(sljit_w);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, MAX_INDEX, 0);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
        stackpos += (int)sizeof(sljit_w);
-       needs_maxindex = TRUE;
+       setsom_found = TRUE;
        }
+     if (common->mark_ptr != 0 && !setmark_found)
+       {
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);
+       stackpos += (int)sizeof(sljit_w);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+       stackpos += (int)sizeof(sljit_w);
+       setmark_found = TRUE;
+       }
+     cc += 1 + LINK_SIZE;
+     break;
+     case OP_CBRA:
+     case OP_CBRAPOS:
+     case OP_SCBRA:
+     case OP_SCBRAPOS:
      offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));
      stackpos += (int)sizeof(sljit_w);
-Line 839 
 while (cc < ccend)
+Line 946 
 while (cc < ccend)
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);
      stackpos += (int)sizeof(sljit_w);
-     cc += 1 + LINK_SIZE + 2;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      default:
-Line 849 
 while (cc < ccend)
+Line 956 
 while (cc < ccend)
      }
  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_end);
- SLJIT_ASSERT(stackpos == STACK(stacktop + 1));
+ SLJIT_ASSERT(stackpos == STACK(stacktop));
  }
- static SLJIT_INLINE int get_localsize(compiler_common *common, uschar *cc, uschar *ccend)
+ static SLJIT_INLINE int get_localsize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
  {
  int localsize = 2;
- uschar *alternative;
+ pcre_uchar *alternative;
  /* Calculate the sum of the local variables. */
  while (cc < ccend)
    {
-Line 866 
 while (cc < ccend)
+Line 973 
 while (cc < ccend)
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
      case OP_ONCE:
+     case OP_ONCE_NC:
      case OP_BRAPOS:
      case OP_SBRA:
      case OP_SBRAPOS:
-Line 877 
 while (cc < ccend)
+Line 985 
 while (cc < ccend)
      case OP_CBRA:
      case OP_SCBRA:
      localsize++;
-     cc += 1 + LINK_SIZE + 2;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
      localsize += 2;
-     cc += 1 + LINK_SIZE + 2;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-Line 904 
 SLJIT_ASSERT(cc == ccend);
+Line 1012 
 SLJIT_ASSERT(cc == ccend);
  return localsize;
  }
- static void copy_locals(compiler_common *common, uschar *cc, uschar *ccend,
+ static void copy_locals(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
    BOOL save, int stackptr, int stacktop)
  {
  DEFINE_COMPILER;
-Line 913 
 int count;
+Line 1021 
 int count;
  BOOL tmp1next = TRUE;
  BOOL tmp1empty = TRUE;
  BOOL tmp2empty = TRUE;
- uschar *alternative;
+ pcre_uchar *alternative;
  enum {
    start,
    loop,
-Line 948 
 while (status != end)
+Line 1056 
 while (status != end)
    switch(status)
      {
      case start:
-     SLJIT_ASSERT(save);
+     SLJIT_ASSERT(save && common->recursive_head != 0);
      count = 1;
-     srcw[0] = RECURSIVE_HEAD;
+     srcw[0] = common->recursive_head;
      status = loop;
      break;
-Line 968 
 while (status != end)
+Line 1076 
 while (status != end)
        case OP_ASSERTBACK:
        case OP_ASSERTBACK_NOT:
        case OP_ONCE:
+       case OP_ONCE_NC:
        case OP_BRAPOS:
        case OP_SBRA:
        case OP_SBRAPOS:
        case OP_SCOND:
        count = 1;
-       srcw[0] = PRIV(cc);
+       srcw[0] = PRIV_DATA(cc);
        SLJIT_ASSERT(srcw[0] != 0);
        cc += 1 + LINK_SIZE;
        break;
-Line 982 
 while (status != end)
+Line 1091 
 while (status != end)
        case OP_SCBRA:
        count = 1;
        srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
-       cc += 1 + LINK_SIZE + 2;
+       cc += 1 + LINK_SIZE + IMM2_SIZE;
        break;
        case OP_CBRAPOS:
        case OP_SCBRAPOS:
        count = 2;
        srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
-       srcw[0] = PRIV(cc);
+       srcw[0] = PRIV_DATA(cc);
        SLJIT_ASSERT(srcw[0] != 0);
-       cc += 1 + LINK_SIZE + 2;
+       cc += 1 + LINK_SIZE + IMM2_SIZE;
        break;
        case OP_COND:
-Line 1000 
 while (status != end)
+Line 1109 
 while (status != end)
        if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
          {
          count = 1;
-         srcw[0] = PRIV(cc);
+         srcw[0] = PRIV_DATA(cc);
          SLJIT_ASSERT(srcw[0] != 0);
          }
        cc += 1 + LINK_SIZE;
-Line 1164 
 while (list_item)
+Line 1273 
 while (list_item)
      case stack_alloc:
      add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
      break;
-     case max_index:
-     OP1(SLJIT_MOV, MAX_INDEX, 0, SLJIT_IMM, list_item->data);
-     break;
      }
    JUMPTO(SLJIT_JUMP, list_item->leave);
    list_item = list_item->next;
-Line 1175 
 while (list_item)
+Line 1280 
 while (list_item)
  common->stubs = NULL;
  }
+ static SLJIT_INLINE void decrease_call_count(compiler_common *common)
+ {
+ DEFINE_COMPILER;
+ OP2(SLJIT_SUB | SLJIT_SET_E, CALL_COUNT, 0, CALL_COUNT, 0, SLJIT_IMM, 1);
+ add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));
+ }
  static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)
  {
  /* May destroy all locals and registers except TMP2. */
-Line 1204 
 struct sljit_label *loop;
+Line 1317 
 struct sljit_label *loop;
  int i;
  /* At this point we can freely use all temporary registers. */
  /* TMP1 returns with begin - 1. */
- OP1(SLJIT_MOV, MAX_INDEX, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
- OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_GENERAL_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, 1);
  if (length < 8)
    {
    for (i = 0; i < length; i++)
-Line 1222 
 else
+Line 1334 
 else
    }
  }
- static SLJIT_INLINE void copy_ovector(compiler_common *common)
+ static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
  {
  DEFINE_COMPILER;
  struct sljit_label *loop;
  struct sljit_jump *earlyexit;
  /* At this point we can freely use all registers. */
+ OP1(SLJIT_MOV, SLJIT_SAVED_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1), STR_PTR, 0);
  OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, ARGUMENTS, 0);
+ if (common->mark_ptr != 0)
+   OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
  OP1(SLJIT_MOV_SI, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsetcount));
+ if (common->mark_ptr != 0)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_TEMPORARY_REG3, 0);
  OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
  OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, begin));
- OP2(SLJIT_ADD, SLJIT_GENERAL_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START);
+ OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START);
  /* Unlikely, but possible */
  earlyexit = CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 0);
  loop = LABEL();
- OP2(SLJIT_SUB, SLJIT_GENERAL_REG2, 0, SLJIT_MEM1(SLJIT_GENERAL_REG1), 0, SLJIT_TEMPORARY_REG1, 0);
+ OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_TEMPORARY_REG1, 0);
- OP2(SLJIT_ADD, SLJIT_GENERAL_REG1, 0, SLJIT_GENERAL_REG1, 0, SLJIT_IMM, sizeof(sljit_w));
+ OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_w));
  /* Copy the integer value to the output buffer */
- OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG3), sizeof(int), SLJIT_GENERAL_REG2, 0);
+ #ifdef COMPILE_PCRE16
+ OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);
+ #endif
+ OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG3), sizeof(int), SLJIT_SAVED_REG2, 0);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
  JUMPTO(SLJIT_C_NOT_ZERO, loop);
  JUMPHERE(earlyexit);
+ /* Calculate the return value, which is the maximum ovector value. */
+ if (topbracket > 1)
+   {
+   OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START + topbracket * 2 * sizeof(sljit_w));
+   OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, topbracket + 1);
+   /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */
+   loop = LABEL();
+   OP1(SLJIT_MOVU, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), -(2 * (sljit_w)sizeof(sljit_w)));
+   OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
+   CMPTO(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG3, 0, loop);
+   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_TEMPORARY_REG2, 0);
+   }
+ else
+   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
+ }
+ static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *leave)
+ {
+ DEFINE_COMPILER;
+ SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);
+ SLJIT_ASSERT(common->start_used_ptr != 0 && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
+ OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);
+ OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
+ OP1(SLJIT_MOV_SI, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, offsetcount));
+ CMPTO(SLJIT_C_LESS, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 2, leave);
+ /* Store match begin and end. */
+ OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, begin));
+ OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));
+ OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
+ OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);
+ #ifdef COMPILE_PCRE16
+ OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);
+ #endif
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(int), SLJIT_SAVED_REG2, 0);
+ OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG1, 0);
+ #ifdef COMPILE_PCRE16
+ OP2(SLJIT_ASHR, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 1);
+ #endif
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), 0, SLJIT_TEMPORARY_REG3, 0);
+ JUMPTO(SLJIT_JUMP, leave);
+ }
+ static SLJIT_INLINE void check_start_used_ptr(compiler_common *common)
+ {
+ /* May destroy TMP1. */
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   {
+   /* The value of -1 must be kept for start_used_ptr! */
+   OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, 1);
+   /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting
+   is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */
+   jump = CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   JUMPHERE(jump);
+   }
+ else if (common->mode == JIT_PARTIAL_HARD_COMPILE)
+   {
+   jump = CMP(SLJIT_C_LESS_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   JUMPHERE(jump);
+   }
  }
- static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, uschar* cc)
+ static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar* cc)
  {
  /* Detects if the character has an othercase. */
  unsigned int c;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8)
+ if (common->utf)
    {
    GETCHAR(c, cc);
    if (c > 127)
-Line 1263 
 if (common->utf8)
+Line 1456 
 if (common->utf8)
      return FALSE;
  #endif
      }
+ #ifndef COMPILE_PCRE8
+   return common->fcc[c] != c;
+ #endif
    }
  else
  #endif
    c = *cc;
- return common->fcc[c] != c;
+ return MAX_255(c) ? common->fcc[c] != c : FALSE;
  }
  static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigned int c)
  {
  /* Returns with the othercase. */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8 && c > 127)
+ if (common->utf && c > 127)
    {
  #ifdef SUPPORT_UCP
    return UCD_OTHERCASE(c);
-Line 1283 
 if (common->utf8 && c > 127)
+Line 1479 
 if (common->utf8 && c > 127)
  #endif
    }
  #endif
- return common->fcc[c];
+ return TABLE_GET(c, common->fcc, c);
  }
- static unsigned int char_get_othercase_bit(compiler_common *common, uschar* cc)
+ static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar* cc)
  {
  /* Detects if the character and its othercase has only 1 bit difference. */
  unsigned int c, oc, bit;
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
  int n;
  #endif
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8)
+ if (common->utf)
    {
    GETCHAR(c, cc);
    if (c <= 127)
-Line 1312 
 if (common->utf8)
+Line 1508 
 if (common->utf8)
  else
    {
    c = *cc;
-   oc = common->fcc[c];
+   oc = TABLE_GET(c, common->fcc, c);
    }
  #else
  c = *cc;
- oc = common->fcc[c];
+ oc = TABLE_GET(c, common->fcc, c);
  #endif
  SLJIT_ASSERT(c != oc);
-Line 1330 
 if (c <= 127 && bit == 0x20)
+Line 1526 
 if (c <= 127 && bit == 0x20)
  if (!ispowerof2(bit))
    return 0;
- #ifdef SUPPORT_UTF8
+ #ifdef COMPILE_PCRE8
- if (common->utf8 && c > 127)
+ #ifdef SUPPORT_UTF
+ if (common->utf && c > 127)
    {
-   n = _pcre_utf8_table4[*cc & 0x3f];
+   n = GET_EXTRALEN(*cc);
    while ((bit & 0x3f) == 0)
      {
      n--;
-Line 1341 
 if (common->utf8 && c > 127)
+Line 1539 
 if (common->utf8 && c > 127)
      }
    return (n << 8) | bit;
    }
- #endif
+ #endif /* SUPPORT_UTF */
  return (0 << 8) | bit;
+ #else /* COMPILE_PCRE8 */
+ #ifdef COMPILE_PCRE16
+ #ifdef SUPPORT_UTF
+ if (common->utf && c > 65535)
+   {
+   if (bit >= (1 << 10))
+     bit >>= 10;
+   else
+     return (bit < 256) ? ((2 << 8) | bit) : ((3 << 8) | (bit >> 8));
+   }
+ #endif /* SUPPORT_UTF */
+ return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));
+ #endif /* COMPILE_PCRE16 */
+ #endif /* COMPILE_PCRE8 */
+ }
+ static void check_partial(compiler_common *common, BOOL force)
+ {
+ /* Checks whether a partial matching is occured. Does not modify registers. */
+ DEFINE_COMPILER;
+ struct sljit_jump *jump = NULL;
+ SLJIT_ASSERT(!force || common->mode != JIT_COMPILE);
+ if (common->mode == JIT_COMPILE)
+   return;
+ if (!force)
+   jump = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+ else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
+ else
+   {
+   if (common->partialmatchlabel != NULL)
+     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+   else
+     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+   }
+ if (jump != NULL)
+   JUMPHERE(jump);
+ }
+ static struct sljit_jump *check_str_end(compiler_common *common)
+ {
+ /* Does not affect registers. Usually used in a tight spot. */
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ struct sljit_jump *nohit;
+ struct sljit_jump *return_value;
+ if (common->mode == JIT_COMPILE)
+   return CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   {
+   nohit = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
+   JUMPHERE(nohit);
+   return_value = JUMP(SLJIT_JUMP);
+   }
+ else
+   {
+   return_value = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   if (common->partialmatchlabel != NULL)
+     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+   else
+     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+   }
+ JUMPHERE(jump);
+ return return_value;
  }
- static SLJIT_INLINE void check_input_end(compiler_common *common, jump_list **fallbacks)
+ static void fallback_at_str_end(compiler_common *common, jump_list **fallbacks)
  {
  DEFINE_COMPILER;
- add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+ struct sljit_jump *jump;
+ if (common->mode == JIT_COMPILE)
+   {
+   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+   return;
+   }
+ /* Partial matching mode. */
+ jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
+ add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   {
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
+   add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+   }
+ else
+   {
+   if (common->partialmatchlabel != NULL)
+     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+   else
+     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+   }
+ JUMPHERE(jump);
  }
  static void read_char(compiler_common *common)
-Line 1356 
 static void read_char(compiler_common *c
+Line 1655 
 static void read_char(compiler_common *c
  /* Reads the character into TMP1, updates STR_PTR.
  Does not check STR_END. TMP2 Destroyed. */
  DEFINE_COMPILER;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
  struct sljit_jump *jump;
  #endif
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8)
+ if (common->utf)
    {
-   /* Should not found a value between 128 and 192 here. */
+ #ifdef COMPILE_PCRE8
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 192);
+   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-   add_jump(compiler, &common->utf8readchar, JUMP(SLJIT_FAST_CALL));
+ #else
+ #ifdef COMPILE_PCRE16
+   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+ #endif
+ #endif /* COMPILE_PCRE8 */
+   add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
    JUMPHERE(jump);
    }
  #endif
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  }
  static void peek_char(compiler_common *common)
-Line 1378 
 static void peek_char(compiler_common *c
+Line 1682 
 static void peek_char(compiler_common *c
  /* Reads the character into TMP1, keeps STR_PTR.
  Does not check STR_END. TMP2 Destroyed. */
  DEFINE_COMPILER;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
  struct sljit_jump *jump;
  #endif
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8)
+ if (common->utf)
    {
-   /* Should not found a value between 128 and 192 here. */
+ #ifdef COMPILE_PCRE8
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 192);
+   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-   add_jump(compiler, &common->utf8readchar, JUMP(SLJIT_FAST_CALL));
+ #else
+ #ifdef COMPILE_PCRE16
+   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+ #endif
+ #endif /* COMPILE_PCRE8 */
+   add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
    JUMPHERE(jump);
    }
-Line 1399 
 static void read_char8_type(compiler_com
+Line 1708 
 static void read_char8_type(compiler_com
  {
  /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
  DEFINE_COMPILER;
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16
  struct sljit_jump *jump;
  #endif
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8)
+ if (common->utf)
    {
-   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+   OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #ifdef COMPILE_PCRE8
    /* This can be an extra read in some situations, but hopefully
-   it is a clever early read in most cases. */
+   it is needed in most cases. */
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
-   /* Should not found a value between 128 and 192 here. */
+   jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
-   jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 192);
+   add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, &common->utf8readtype8, JUMP(SLJIT_FAST_CALL));
    JUMPHERE(jump);
+ #else
+ #ifdef COMPILE_PCRE16
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+   JUMPHERE(jump);
+   /* Skip low surrogate if necessary. */
+   OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);
+   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+ #endif
+ #endif /* COMPILE_PCRE8 */
    return;
    }
  #endif
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);
+ #ifdef COMPILE_PCRE16
+ /* The ctypes array contains only 256 values. */
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+ jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
+ #endif
+ OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+ #ifdef COMPILE_PCRE16
+ JUMPHERE(jump);
+ #endif
  }
  static void skip_char_back(compiler_common *common)
  {
- /* Goes one character back. Only affects STR_PTR. Does not check begin. */
+ /* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */
  DEFINE_COMPILER;
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
  struct sljit_label *label;
- if (common->utf8)
+ if (common->utf)
    {
    label = LABEL();
-   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
    CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
    return;
    }
  #endif
- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
+   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   /* Skip low surrogate if necessary. */
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);
+   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   return;
+   }
+ #endif
+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  }
  static void check_newlinechar(compiler_common *common, int nltype, jump_list **fallbacks, BOOL jumpiftrue)
-Line 1463 
 else if (nltype == NLTYPE_ANYCRLF)
+Line 1808 
 else if (nltype == NLTYPE_ANYCRLF)
    }
  else
    {
-   SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline <= 255);
+   SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);
    add_jump(compiler, fallbacks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
    }
  }
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- static void do_utf8readchar(compiler_common *common)
+ #ifdef COMPILE_PCRE8
+ static void do_utfreadchar(compiler_common *common)
  {
- /* Fast decoding an utf8 character. TMP1 contains the first byte
+ /* Fast decoding a UTF-8 character. TMP1 contains the first byte
- of the character (>= 192). Return char value in TMP1, length - 1 in TMP2. */
+ of the character (>= 0xc0). Return char value in TMP1, length - 1 in TMP2. */
  DEFINE_COMPILER;
  struct sljit_jump *jump;
-Line 1480 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 1827 
 sljit_emit_fast_enter(compiler, RETURN_A
  /* Searching for the first zero. */
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
  jump = JUMP(SLJIT_C_NOT_ZERO);
- /* 2 byte sequence */
+ /* Two byte sequence. */
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1f);
  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(jump);
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10);
  jump = JUMP(SLJIT_C_NOT_ZERO);
- /* 3 byte sequence */
+ /* Three byte sequence. */
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0f);
  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12);
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 2);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 2);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(jump);
- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x08);
+ /* Four byte sequence. */
- jump = JUMP(SLJIT_C_NOT_ZERO);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
- /* 4 byte sequence */
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x07);
  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 18);
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 3);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(3));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 3);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 3);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));
- sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
- JUMPHERE(jump);
- /* 5 byte sequence */
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x03);
- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 24);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 18);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 3);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 4);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 4);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 4);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
- static void do_utf8readtype8(compiler_common *common)
+ static void do_utfreadtype8(compiler_common *common)
  {
- /* Fast decoding an utf8 character type. TMP2 contains the first byte
+ /* Fast decoding a UTF-8 character type. TMP2 contains the first byte
- of the character (>= 192) and TMP1 is destroyed. Return value in TMP1. */
+ of the character (>= 0xc0). Return value in TMP1. */
  DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_jump *compare;
-Line 1564 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 1886 
 sljit_emit_fast_enter(compiler, RETURN_A
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
  jump = JUMP(SLJIT_C_NOT_ZERO);
- /* 2 byte sequence */
+ /* Two byte sequence. */
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
-Line 1581 
 sljit_emit_fast_return(compiler, RETURN_
+Line 1903 
 sljit_emit_fast_return(compiler, RETURN_
  JUMPHERE(jump);
  /* We only have types for characters less than 256. */
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_w)_pcre_utf8_char_sizes);
+ OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_w)PRIV(utf8_table4) - 0xc0);
- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
- #endif
+ #else /* COMPILE_PCRE8 */
+ #ifdef COMPILE_PCRE16
+ static void do_utfreadchar(compiler_common *common)
+ {
+ /* Fast decoding a UTF-16 character. TMP1 contains the first 16 bit char
+ of the character (>= 0xd800). Return char value in TMP1, length - 1 in TMP2. */
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xdc00);
+ /* Do nothing, only return. */
+ sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+ JUMPHERE(jump);
+ /* Combine two 16 bit characters. */
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 10);
+ OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3ff);
+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
+ sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+ }
+ #endif /* COMPILE_PCRE16 */
+ #endif /* COMPILE_PCRE8 */
+ #endif /* SUPPORT_UTF */
  #ifdef SUPPORT_UCP
-Line 1606 
 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && si
+Line 1958 
 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && si
  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
  OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_w)_pcre_ucd_stage1);
+ OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_w)PRIV(ucd_stage1));
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_w)_pcre_ucd_stage2);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_stage2));
  OP1(SLJIT_MOV_UH, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)_pcre_ucd_records + SLJIT_OFFSETOF(ucd_record, chartype));
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 1626 
 struct sljit_label *newlinelabel = NULL;
+Line 1978 
 struct sljit_label *newlinelabel = NULL;
  struct sljit_jump *start;
  struct sljit_jump *end = NULL;
  struct sljit_jump *nl = NULL;
+ #ifdef SUPPORT_UTF
+ struct sljit_jump *singlechar;
+ #endif
  jump_list *newline = NULL;
  BOOL newlinecheck = FALSE;
- BOOL readbyte = FALSE;
+ BOOL readuchar = FALSE;
  if (!(hascrorlf || firstline) && (common->nltype == NLTYPE_ANY ||
      common->nltype == NLTYPE_ANYCRLF || common->newline > 255))
-Line 1637 
 if (!(hascrorlf || firstline) && (common
+Line 1992 
 if (!(hascrorlf || firstline) && (common
  if (firstline)
    {
    /* Search for the end of the first line. */
+   SLJIT_ASSERT(common->first_line_end != 0);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_END, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_END, 0);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      mainloop = LABEL();
-     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -1);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
-     OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
      CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
      CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
-     OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0, SLJIT_IMM, 1);
+     OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      }
    else
      {
      end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
      mainloop = LABEL();
      /* Continual stores does not cause data dependency. */
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
      read_char(common);
      check_newlinechar(common, common->nltype, &newline, TRUE);
      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
      set_jumps(newline, LABEL());
      }
-Line 1673 
 start = JUMP(SLJIT_JUMP);
+Line 2029 
 start = JUMP(SLJIT_JUMP);
  if (newlinecheck)
    {
    newlinelabel = LABEL();
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);
    COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+ #ifdef COMPILE_PCRE16
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+ #endif
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    nl = JUMP(SLJIT_JUMP);
    }
-Line 1685 
 if (newlinecheck)
+Line 2044 
 if (newlinecheck)
  mainloop = LABEL();
  /* Increasing the STR_PTR here requires one less jump in the most common case. */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8) readbyte = TRUE;
+ if (common->utf) readuchar = TRUE;
  #endif
- if (newlinecheck) readbyte = TRUE;
+ if (newlinecheck) readuchar = TRUE;
- if (readbyte)
+ if (readuchar)
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
  if (newlinecheck)
    CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
- #ifdef SUPPORT_UTF8
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- if (common->utf8)
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ if (common->utf)
    {
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes);
+   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   JUMPHERE(singlechar);
+   }
+ #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   JUMPHERE(singlechar);
    }
- else
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
- #else
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
  #endif
  JUMPHERE(start);
-Line 1718 
 if (newlinecheck)
+Line 2088 
 if (newlinecheck)
  return mainloop;
  }
- static SLJIT_INLINE void fast_forward_first_byte(compiler_common *common, pcre_uint16 firstbyte, BOOL firstline)
+ static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)
  {
  DEFINE_COMPILER;
  struct sljit_label *start;
  struct sljit_jump *leave;
  struct sljit_jump *found;
- pcre_uint16 oc, bit;
+ pcre_uchar oc, bit;
  if (firstline)
    {
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
  start = LABEL();
  leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- if ((firstbyte & REQ_CASELESS) == 0)
+ oc = first_char;
-   found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, firstbyte & 0xff);
+ if (caseless)
+   {
+   oc = TABLE_GET(first_char, common->fcc, first_char);
+ #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+   if (first_char > 127 && common->utf)
+     oc = UCD_OTHERCASE(first_char);
+ #endif
+   }
+ if (first_char == oc)
+   found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, first_char);
  else
    {
-   firstbyte &= 0xff;
+   bit = first_char ^ oc;
-   oc = common->fcc[firstbyte];
-   bit = firstbyte ^ oc;
    if (ispowerof2(bit))
      {
      OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);
-     found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, firstbyte | bit);
+     found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, first_char | bit);
      }
    else
      {
-     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, firstbyte);
+     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, first_char);
      COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);
      COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
-Line 1758 
 else
+Line 2135 
 else
      }
    }
- #ifdef SUPPORT_UTF8
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- if (common->utf8)
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ if (common->utf)
    {
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes);
+   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   }
+ #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    }
- else
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
- #else
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
  #endif
  JUMPTO(SLJIT_JUMP, start);
  JUMPHERE(found);
-Line 1791 
 jump_list *newline = NULL;
+Line 2177 
 jump_list *newline = NULL;
  if (firstline)
    {
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
-Line 1802 
 if (common->nltype == NLTYPE_FIXED && co
+Line 2188 
 if (common->nltype == NLTYPE_FIXED && co
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
    firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
-   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2);
+   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);
    COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_GREATER_EQUAL);
+ #ifdef COMPILE_PCRE16
+   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+ #endif
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
    loop = LABEL();
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -2);
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
-   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), -1);
+   OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);
    CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);
-Line 1842 
 if (common->nltype == NLTYPE_ANY || comm
+Line 2231 
 if (common->nltype == NLTYPE_ANY || comm
    leave = JUMP(SLJIT_JUMP);
    JUMPHERE(foundcr);
    notfoundnl = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
    COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+ #ifdef COMPILE_PCRE16
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+ #endif
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    JUMPHERE(notfoundnl);
    JUMPHERE(leave);
-Line 1862 
 DEFINE_COMPILER;
+Line 2254 
 DEFINE_COMPILER;
  struct sljit_label *start;
  struct sljit_jump *leave;
  struct sljit_jump *found;
+ #ifndef COMPILE_PCRE8
+ struct sljit_jump *jump;
+ #endif
  if (firstline)
    {
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
  start = LABEL();
  leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8)
+ if (common->utf)
-   OP1(SLJIT_MOV_UB, TMP3, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes);
+   OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
+ #endif
+ #ifndef COMPILE_PCRE8
+ jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 255);
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);
+ JUMPHERE(jump);
  #endif
  OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
  OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
-Line 1883 
 OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TM
+Line 2283 
 OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TM
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
  found = JUMP(SLJIT_C_NOT_ZERO);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- if (common->utf8)
+ if (common->utf)
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP3, 0);
+   OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
- else
+ #endif
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #else
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ if (common->utf)
+   {
+   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   }
+ #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   }
  #endif
  JUMPTO(SLJIT_JUMP, start);
  JUMPHERE(found);
-Line 1899 
 if (firstline)
+Line 2315 
 if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
  }
- static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uint16 reqbyte, BOOL has_firstbyte)
+ static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uchar req_char, BOOL caseless, BOOL has_firstchar)
  {
  DEFINE_COMPILER;
  struct sljit_label *loop;
-Line 1908 
 struct sljit_jump *alreadyfound;
+Line 2324 
 struct sljit_jump *alreadyfound;
  struct sljit_jump *found;
  struct sljit_jump *foundoc = NULL;
  struct sljit_jump *notfound;
- pcre_uint16 oc, bit;
+ pcre_uchar oc, bit;
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_BYTE_PTR);
+ SLJIT_ASSERT(common->req_char_ptr != 0);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr);
  OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);
  toolong = CMP(SLJIT_C_LESS, TMP1, 0, STR_END, 0);
  alreadyfound = CMP(SLJIT_C_LESS, STR_PTR, 0, TMP2, 0);
- if (has_firstbyte)
+ if (has_firstchar)
-   OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  else
    OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);
  loop = LABEL();
  notfound = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, STR_END, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), 0);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);
- if ((reqbyte & REQ_CASELESS) == 0)
+ oc = req_char;
-   found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, reqbyte & 0xff);
+ if (caseless)
+   {
+   oc = TABLE_GET(req_char, common->fcc, req_char);
+ #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+   if (req_char > 127 && common->utf)
+     oc = UCD_OTHERCASE(req_char);
+ #endif
+   }
+ if (req_char == oc)
+   found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
  else
    {
-   reqbyte &= 0xff;
+   bit = req_char ^ oc;
-   oc = common->fcc[reqbyte];
-   bit = reqbyte ^ oc;
    if (ispowerof2(bit))
      {
      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
-     found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, reqbyte | bit);
+     found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
      }
    else
      {
-     found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, reqbyte);
+     found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
      foundoc = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, oc);
      }
    }
- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
  JUMPTO(SLJIT_JUMP, loop);
  JUMPHERE(found);
  if (foundoc)
    JUMPHERE(foundoc);
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_BYTE_PTR, TMP1, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr, TMP1, 0);
  JUMPHERE(alreadyfound);
  JUMPHERE(toolong);
  return notfound;
-Line 1957 
 return notfound;
+Line 2381 
 return notfound;
  static void do_revertframes(compiler_common *common)
  {
  DEFINE_COMPILER;
- struct sljit_jump *earlyexit;
  struct sljit_jump *jump;
  struct sljit_label *mainloop;
  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD);
+ OP1(SLJIT_MOV, TMP1, 0, STACK_TOP, 0);
  /* Drop frames until we reach STACK_TOP. */
- earlyexit = CMP(SLJIT_C_LESS, TMP1, 0, STACK_TOP, 0);
  mainloop = LABEL();
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
  jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
-Line 1978 
 JUMPTO(SLJIT_JUMP, mainloop);
+Line 2400 
 JUMPTO(SLJIT_JUMP, mainloop);
  JUMPHERE(jump);
  jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
  /* End of dropping frames. */
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD, TMP1, 0);
- CMPTO(SLJIT_C_GREATER_EQUAL, TMP1, 0, STACK_TOP, 0, mainloop);
- JUMPHERE(earlyexit);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(jump);
- jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setmaxindex);
- /* Set max index. */
- OP1(SLJIT_MOV, MAX_INDEX, 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
- JUMPTO(SLJIT_JUMP, mainloop);
- JUMPHERE(jump);
  jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setstrbegin);
- /* Set max index. */
+ /* Set string begin. */
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);
  JUMPTO(SLJIT_JUMP, mainloop);
  JUMPHERE(jump);
+ if (common->mark_ptr != 0)
+   {
+   jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setmark);
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
+   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
+   JUMPTO(SLJIT_JUMP, mainloop);
+   JUMPHERE(jump);
+   }
  /* Unknown command. */
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
  JUMPTO(SLJIT_JUMP, mainloop);
-Line 2008 
 JUMPTO(SLJIT_JUMP, mainloop);
+Line 2430 
 JUMPTO(SLJIT_JUMP, mainloop);
  static void check_wordboundary(compiler_common *common)
  {
  DEFINE_COMPILER;
- struct sljit_jump *beginend;
+ struct sljit_jump *skipread;
+ #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF
  struct sljit_jump *jump;
+ #endif
- SLJIT_ASSERT(ctype_word == 0x10);
+ SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);
  sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, 1, 5, 5, common->localsize);
  /* Get type of the previous char, and put it to LOCALS1. */
  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, 0);
- beginend = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
+ skipread = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
  skip_char_back(common);
+ check_start_used_ptr(common);
  read_char(common);
  /* Testing char type. */
  #ifdef SUPPORT_UCP
- if (common->useucp)
+ if (common->use_ucp)
    {
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
    jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
-Line 2041 
 if (common->useucp)
+Line 2466 
 if (common->useucp)
  else
  #endif
    {
- #ifdef SUPPORT_UTF8
+ #ifndef COMPILE_PCRE8
+   jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+ #elif defined SUPPORT_UTF
    /* Here LOCALS1 has already been zeroed. */
    jump = NULL;
-   if (common->utf8)
+   if (common->utf)
      jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
- #endif
+ #endif /* COMPILE_PCRE8 */
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);
    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);
    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);
- #ifdef SUPPORT_UTF8
+ #ifndef COMPILE_PCRE8
+   JUMPHERE(jump);
+ #elif defined SUPPORT_UTF
    if (jump != NULL)
      JUMPHERE(jump);
- #endif
+ #endif /* COMPILE_PCRE8 */
    }
- JUMPHERE(beginend);
+ JUMPHERE(skipread);
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
- beginend = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ skipread = check_str_end(common);
  peek_char(common);
  /* Testing char type. This is a code duplication. */
  #ifdef SUPPORT_UCP
- if (common->useucp)
+ if (common->use_ucp)
    {
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
    jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
-Line 2080 
 if (common->useucp)
+Line 2509 
 if (common->useucp)
  else
  #endif
    {
- #ifdef SUPPORT_UTF8
+ #ifndef COMPILE_PCRE8
+   /* TMP2 may be destroyed by peek_char. */
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
+   jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+ #elif defined SUPPORT_UTF
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
    jump = NULL;
-   if (common->utf8)
+   if (common->utf)
      jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
  #endif
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);
    OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);
    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
- #ifdef SUPPORT_UTF8
+ #ifndef COMPILE_PCRE8
+   JUMPHERE(jump);
+ #elif defined SUPPORT_UTF
    if (jump != NULL)
      JUMPHERE(jump);
- #endif
+ #endif /* COMPILE_PCRE8 */
    }
- JUMPHERE(beginend);
+ JUMPHERE(skipread);
  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
-Line 2111 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
+Line 2546 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
  COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16
- if (common->utf8)
+ #ifdef COMPILE_PCRE8
+ if (common->utf)
    {
+ #endif
    COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
+ #ifdef COMPILE_PCRE8
    }
  #endif
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
  COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 2135 
 COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_E
+Line 2574 
 COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_E
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
  COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16
- if (common->utf8)
+ #ifdef COMPILE_PCRE8
+ if (common->utf)
    {
+ #endif
    COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);
    COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
-Line 2151 
 if (common->utf8)
+Line 2592 
 if (common->utf8)
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);
    COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);
+ #ifdef COMPILE_PCRE8
    }
  #endif
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
  COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
-Line 2169 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
+Line 2612 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
  COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16
- if (common->utf8)
+ #ifdef COMPILE_PCRE8
+ if (common->utf)
    {
+ #endif
    COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
+ #ifdef COMPILE_PCRE8
    }
  #endif
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
  COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
-Line 2195 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 2642 
 sljit_emit_fast_enter(compiler, RETURN_A
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
  OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR2, 0);
- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  label = LABEL();
- OP1(SLJIT_MOVU_UB, CHAR1, 0, SLJIT_MEM1(TMP1), 1);
+ OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));
- OP1(SLJIT_MOVU_UB, CHAR2, 0, SLJIT_MEM1(STR_PTR), 1);
+ OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
  jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);
- OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
  JUMPTO(SLJIT_C_NOT_ZERO, label);
  JUMPHERE(jump);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  OP1(SLJIT_MOV, CHAR1, 0, TMP3, 0);
  OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
-Line 2227 
 OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);
+Line 2674 
 OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR1, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, CHAR2, 0);
  OP1(SLJIT_MOV, LCC_TABLE, 0, SLJIT_IMM, common->lcc);
- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  label = LABEL();
- OP1(SLJIT_MOVU_UB, CHAR1, 0, SLJIT_MEM1(TMP1), 1);
+ OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));
- OP1(SLJIT_MOVU_UB, CHAR2, 0, SLJIT_MEM1(STR_PTR), 1);
+ OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ #ifndef COMPILE_PCRE8
+ jump = CMP(SLJIT_C_GREATER, CHAR1, 0, SLJIT_IMM, 255);
+ #endif
  OP1(SLJIT_MOV_UB, CHAR1, 0, SLJIT_MEM2(LCC_TABLE, CHAR1), 0);
+ #ifndef COMPILE_PCRE8
+ JUMPHERE(jump);
+ jump = CMP(SLJIT_C_GREATER, CHAR2, 0, SLJIT_IMM, 255);
+ #endif
  OP1(SLJIT_MOV_UB, CHAR2, 0, SLJIT_MEM2(LCC_TABLE, CHAR2), 0);
+ #ifndef COMPILE_PCRE8
+ JUMPHERE(jump);
+ #endif
  jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);
- OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
  JUMPTO(SLJIT_C_NOT_ZERO, label);
  JUMPHERE(jump);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  OP1(SLJIT_MOV, LCC_TABLE, 0, TMP3, 0);
  OP1(SLJIT_MOV, CHAR1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
  OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
-Line 2251 
 sljit_emit_fast_return(compiler, RETURN_
+Line 2708 
 sljit_emit_fast_return(compiler, RETURN_
  #undef CHAR1
  #undef CHAR2
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF && defined SUPPORT_UCP
- #ifdef SUPPORT_UCP
- static uschar * SLJIT_CALL do_utf8caselesscmp(uschar *src1, jit_arguments *args, uschar *end1)
+ static const pcre_uchar *SLJIT_CALL do_utf_caselesscmp(pcre_uchar *src1, jit_arguments *args, pcre_uchar *end1)
  {
  /* This function would be ineffective to do in JIT level. */
  int c1, c2;
- uschar *src2 = args->ptr;
+ const pcre_uchar *src2 = args->uchar_ptr;
- uschar *end2 = (uschar*)args->end;
+ const pcre_uchar *end2 = args->end;
  while (src1 < end1)
    {
    if (src2 >= end2)
-     return 0;
+     return (pcre_uchar*)1;
    GETCHARINC(c1, src1);
    GETCHARINC(c2, src2);
-   if (c1 != c2 && c1 != UCD_OTHERCASE(c2)) return 0;
+   if (c1 != c2 && c1 != UCD_OTHERCASE(c2)) return NULL;
    }
  return src2;
  }
- #endif
+ #endif /* SUPPORT_UTF && SUPPORT_UCP */
- #endif
- static uschar *byte_sequence_compare(compiler_common *common, BOOL caseless, uschar *cc,
+ static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,
      compare_context* context, jump_list **fallbacks)
  {
  DEFINE_COMPILER;
  unsigned int othercasebit = 0;
- uschar *othercasebyte = NULL;
+ pcre_uchar *othercasechar = NULL;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- int utf8length;
+ int utflength;
  #endif
  if (caseless && char_has_othercase(common, cc))
-Line 2290 
 if (caseless && char_has_othercase(commo
+Line 2745 
 if (caseless && char_has_othercase(commo
    othercasebit = char_get_othercase_bit(common, cc);
    SLJIT_ASSERT(othercasebit);
    /* Extracting bit difference info. */
-   othercasebyte = cc + (othercasebit >> 8);
+ #ifdef COMPILE_PCRE8
+   othercasechar = cc + (othercasebit >> 8);
    othercasebit &= 0xff;
+ #else
+ #ifdef COMPILE_PCRE16
+   othercasechar = cc + (othercasebit >> 9);
+   if ((othercasebit & 0x100) != 0)
+     othercasebit = (othercasebit & 0xff) << 8;
+   else
+     othercasebit &= 0xff;
+ #endif
+ #endif
    }
  if (context->sourcereg == -1)
    {
+ #ifdef COMPILE_PCRE8
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    if (context->length >= 4)
      OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
    else if (context->length >= 2)
-     OP1(SLJIT_MOV_SH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+     OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
    else
  #endif
      OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #else
+ #ifdef COMPILE_PCRE16
+ #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
+   if (context->length >= 4)
+     OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+   else
+ #endif
+     OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #endif
+ #endif /* COMPILE_PCRE8 */
    context->sourcereg = TMP2;
    }
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- utf8length = 1;
+ utflength = 1;
- if (common->utf8 && *cc >= 0xc0)
+ if (common->utf && HAS_EXTRALEN(*cc))
-   utf8length += _pcre_utf8_table4[*cc & 0x3f];
+   utflength += GET_EXTRALEN(*cc);
  do
    {
  #endif
-   context->length--;
+   context->length -= IN_UCHARS(1);
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    /* Unaligned read is supported. */
-   if (othercasebit != 0 && othercasebyte == cc)
+   if (othercasebit != 0 && othercasechar == cc)
      {
-     context->c.asbytes[context->byteptr] = *cc | othercasebit;
+     context->c.asuchars[context->ucharptr] = *cc | othercasebit;
-     context->oc.asbytes[context->byteptr] = othercasebit;
+     context->oc.asuchars[context->ucharptr] = othercasebit;
      }
    else
      {
-     context->c.asbytes[context->byteptr] = *cc;
+     context->c.asuchars[context->ucharptr] = *cc;
-     context->oc.asbytes[context->byteptr] = 0;
+     context->oc.asuchars[context->ucharptr] = 0;
      }
-   context->byteptr++;
+   context->ucharptr++;
-   if (context->byteptr >= 4 || context->length == 0 || (context->byteptr == 2 && context->length == 1))
+ #ifdef COMPILE_PCRE8
+   if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1))
+ #else
+   if (context->ucharptr >= 2 || context->length == 0)
+ #endif
      {
      if (context->length >= 4)
        OP1(SLJIT_MOV_SI, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #ifdef COMPILE_PCRE8
      else if (context->length >= 2)
-       OP1(SLJIT_MOV_SH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+       OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
      else if (context->length >= 1)
        OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #else
+     else if (context->length >= 2)
+       OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #endif
      context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
-     switch(context->byteptr)
+     switch(context->ucharptr)
        {
-       case 4:
+       case 4 / sizeof(pcre_uchar):
        if (context->oc.asint != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);
        add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
        break;
-       case 2:
+       case 2 / sizeof(pcre_uchar):
-       if (context->oc.asshort != 0)
+       if (context->oc.asushort != 0)
-         OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asshort);
+         OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asshort | context->oc.asshort));
+       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));
        break;
+ #ifdef COMPILE_PCRE8
        case 1:
        if (context->oc.asbyte != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);
        add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
        break;
+ #endif
        default:
        SLJIT_ASSERT_STOP();
        break;
        }
-     context->byteptr = 0;
+     context->ucharptr = 0;
      }
  #else
    /* Unaligned read is unsupported. */
+ #ifdef COMPILE_PCRE8
    if (context->length > 0)
      OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #else
+   if (context->length > 0)
+     OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #endif
    context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
-   if (othercasebit != 0 && othercasebyte == cc)
+   if (othercasebit != 0 && othercasechar == cc)
      {
      OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
-Line 2387 
 do
+Line 2879 
 do
  #endif
    cc++;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   utf8length--;
+   utflength--;
    }
- while (utf8length > 0);
+ while (utflength > 0);
  #endif
  return cc;
  }
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
  #define SET_TYPE_OFFSET(value) \
    if ((value) != typeoffset) \
-Line 2418 
 return cc;
+Line 2910 
 return cc;
      } \
    charoffset = (value);
- static void compile_xclass_hotpath(compiler_common *common, uschar *cc, jump_list **fallbacks)
+ static void compile_xclass_hotpath(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks)
  {
  DEFINE_COMPILER;
  jump_list *found = NULL;
-Line 2426 
 jump_list **list = (*cc & XCL_NOT) == 0
+Line 2918 
 jump_list **list = (*cc & XCL_NOT) == 0
  unsigned int c;
  int compares;
  struct sljit_jump *jump = NULL;
- uschar *ccbegin;
+ pcre_uchar *ccbegin;
  #ifdef SUPPORT_UCP
  BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
  BOOL charsaved = FALSE;
- int typereg = TMP1, scriptreg = TMP1, typeoffset;
+ int typereg = TMP1, scriptreg = TMP1;
+ unsigned int typeoffset;
  #endif
- int charoffset, invertcmp, numberofcmps;
+ int invertcmp, numberofcmps;
+ unsigned int charoffset;
- /* Although SUPPORT_UTF8 must be defined, we are not necessary in utf8 mode. */
+ /* Although SUPPORT_UTF must be defined, we are not necessary in utf mode. */
- check_input_end(common, fallbacks);
+ fallback_at_str_end(common, fallbacks);
  read_char(common);
  if ((*cc++ & XCL_MAP) != 0)
    {
    OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
-   if (common->utf8)
+ #ifndef COMPILE_PCRE8
+   jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+ #elif defined SUPPORT_UTF
+   if (common->utf)
      jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+ #endif
    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
-Line 2451 
 if ((*cc++ & XCL_MAP) != 0)
+Line 2949 
 if ((*cc++ & XCL_MAP) != 0)
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
    add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));
-   if (common->utf8)
+ #ifndef COMPILE_PCRE8
+   JUMPHERE(jump);
+ #elif defined SUPPORT_UTF
+   if (common->utf)
      JUMPHERE(jump);
+ #endif
    OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
  #ifdef SUPPORT_UCP
    charsaved = TRUE;
  #endif
-   cc += 32;
+   cc += 32 / sizeof(pcre_uchar);
    }
  /* Scanning the necessary info. */
-Line 2469 
 while (*cc != XCL_END)
+Line 2971 
 while (*cc != XCL_END)
    if (*cc == XCL_SINGLE)
      {
      cc += 2;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
  #ifdef SUPPORT_UCP
      needschar = TRUE;
-Line 2479 
 while (*cc != XCL_END)
+Line 2981 
 while (*cc != XCL_END)
    else if (*cc == XCL_RANGE)
      {
      cc += 2;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      cc++;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
  #ifdef SUPPORT_UCP
      needschar = TRUE;
-Line 2554 
 if (needstype || needsscript)
+Line 3056 
 if (needstype || needsscript)
      {
      if (scriptreg == TMP1)
        {
-       OP1(SLJIT_MOV, scriptreg, 0, SLJIT_IMM, (sljit_w)_pcre_ucd_records + SLJIT_OFFSETOF(ucd_record, script));
+       OP1(SLJIT_MOV, scriptreg, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
        OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM2(scriptreg, TMP2), 3);
        }
      else
        {
        OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
-       OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_w)_pcre_ucd_records + SLJIT_OFFSETOF(ucd_record, script));
+       OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
        OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM1(TMP2), 0);
        }
      }
-Line 2584 
 while (*cc != XCL_END)
+Line 3086 
 while (*cc != XCL_END)
    if (*cc == XCL_SINGLE)
      {
      cc ++;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (common->utf8)
+     if (common->utf)
        {
        GETCHARINC(c, cc);
        }
-Line 2615 
 while (*cc != XCL_END)
+Line 3117 
 while (*cc != XCL_END)
    else if (*cc == XCL_RANGE)
      {
      cc ++;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (common->utf8)
+     if (common->utf)
        {
        GETCHARINC(c, cc);
        }
-Line 2624 
 while (*cc != XCL_END)
+Line 3126 
 while (*cc != XCL_END)
  #endif
        c = *cc++;
      SET_CHAR_OFFSET(c);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (common->utf8)
+     if (common->utf)
        {
        GETCHARINC(c, cc);
        }
-Line 2681 
 while (*cc != XCL_END)
+Line 3183 
 while (*cc != XCL_END)
        break;
        case PT_GC:
-       c = _pcre_ucp_typerange[(int)cc[1] * 2];
+       c = PRIV(ucp_typerange)[(int)cc[1] * 2];
        SET_TYPE_OFFSET(c);
-       jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, _pcre_ucp_typerange[(int)cc[1] * 2 + 1] - c);
+       jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c);
        break;
        case PT_PC:
-Line 2745 
 if (found != NULL)
+Line 3247 
 if (found != NULL)
  #endif
- static uschar *compile_char1_hotpath(compiler_common *common, uschar type, uschar *cc, jump_list **fallbacks)
+ static pcre_uchar *compile_char1_hotpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **fallbacks)
  {
  DEFINE_COMPILER;
  int length;
  unsigned int c, oc, bit;
  compare_context context;
- struct sljit_label *label;
  struct sljit_jump *jump[4];
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
+ struct sljit_label *label;
  #ifdef SUPPORT_UCP
- uschar propdata[5];
+ pcre_uchar propdata[5];
  #endif
  #endif
-Line 2781 
 switch(type)
+Line 3283 
 switch(type)
    case OP_NOT_DIGIT:
    case OP_DIGIT:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char8_type(common);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
    add_jump(compiler, fallbacks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
-Line 2789 
 switch(type)
+Line 3291 
 switch(type)
    case OP_NOT_WHITESPACE:
    case OP_WHITESPACE:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char8_type(common);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);
    add_jump(compiler, fallbacks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
-Line 2797 
 switch(type)
+Line 3299 
 switch(type)
    case OP_NOT_WORDCHAR:
    case OP_WORDCHAR:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char8_type(common);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);
    add_jump(compiler, fallbacks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
    return cc;
    case OP_ANY:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char(common);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
-     jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+     if (common->mode != JIT_PARTIAL_HARD_COMPILE)
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+       jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+     else
+       jump[1] = check_str_end(common);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
      add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
-     JUMPHERE(jump[1]);
+     if (jump[1] != NULL)
+       JUMPHERE(jump[1]);
      JUMPHERE(jump[0]);
      }
    else
-Line 2820 
 switch(type)
+Line 3327 
 switch(type)
    return cc;
    case OP_ALLANY:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   if (common->utf8)
+   if (common->utf)
      {
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #ifdef COMPILE_PCRE8
+     jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+ #else /* COMPILE_PCRE8 */
+ #ifdef COMPILE_PCRE16
+     jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+     COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+ #endif /* COMPILE_PCRE16 */
+ #endif /* COMPILE_PCRE8 */
+     JUMPHERE(jump[0]);
      return cc;
      }
  #endif
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   return cc;
+   case OP_ANYBYTE:
+   fallback_at_str_end(common, fallbacks);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    return cc;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
  #ifdef SUPPORT_UCP
    case OP_NOTPROP:
    case OP_PROP:
-Line 2848 
 switch(type)
+Line 3374 
 switch(type)
  #endif
    case OP_ANYNL:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char(common);
    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
-   jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   /* We don't need to handle soft partial matching case. */
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+   if (common->mode != JIT_PARTIAL_HARD_COMPILE)
+     jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   else
+     jump[1] = check_str_end(common);
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
    jump[2] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    jump[3] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[0]);
    check_newlinechar(common, common->bsr_nltype, fallbacks, FALSE);
-Line 2865 
 switch(type)
+Line 3395 
 switch(type)
    case OP_NOT_HSPACE:
    case OP_HSPACE:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char(common);
    add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));
    add_jump(compiler, fallbacks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
-Line 2873 
 switch(type)
+Line 3403 
 switch(type)
    case OP_NOT_VSPACE:
    case OP_VSPACE:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char(common);
    add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));
    add_jump(compiler, fallbacks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
-Line 2881 
 switch(type)
+Line 3411 
 switch(type)
  #ifdef SUPPORT_UCP
    case OP_EXTUNI:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char(common);
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Mc);
-Line 2897 
 switch(type)
+Line 3427 
 switch(type)
    OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
    JUMPHERE(jump[0]);
+   if (common->mode == JIT_PARTIAL_HARD_COMPILE)
+     {
+     jump[0] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
+     /* Since we successfully read a char above, partial matching must occure. */
+     check_partial(common, TRUE);
+     JUMPHERE(jump[0]);
+     }
    return cc;
  #endif
    case OP_EODN:
+   /* Requires rather complex checks. */
    jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
-     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 2);
+     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
+     if (common->mode == JIT_COMPILE)
-     OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
+       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
+     else
+       {
+       jump[1] = CMP(SLJIT_C_EQUAL, TMP2, 0, STR_END, 0);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
+       COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
+       COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_NOT_EQUAL);
+       add_jump(compiler, fallbacks, JUMP(SLJIT_C_NOT_EQUAL));
+       check_partial(common, TRUE);
+       add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+       JUMPHERE(jump[1]);
+       }
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
    else if (common->nltype == NLTYPE_FIXED)
      {
-     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 1);
+     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
      }
    else
      {
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
      jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
-     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 2);
+     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
      OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
      jump[2] = JUMP(SLJIT_C_GREATER);
      add_jump(compiler, fallbacks, JUMP(SLJIT_C_LESS));
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 1);
+     /* Equal. */
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
      jump[3] = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
      add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
      JUMPHERE(jump[1]);
      if (common->nltype == NLTYPE_ANYCRLF)
        {
-       OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 1);
+       OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
        add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));
        add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
        }
-Line 2950 
 switch(type)
+Line 3502 
 switch(type)
      JUMPHERE(jump[3]);
      }
    JUMPHERE(jump[0]);
+   check_partial(common, FALSE);
    return cc;
    case OP_EOD:
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
+   check_partial(common, FALSE);
    return cc;
    case OP_CIRC:
-Line 2973 
 switch(type)
+Line 3527 
 switch(type)
    jump[0] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[1]);
-   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, end));
+   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP2, 0, STR_PTR, 0));
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
-     OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 2);
+     OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, TMP1, 0));
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -2);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
-     OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), -1);
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
-Line 3002 
 switch(type)
+Line 3554 
 switch(type)
    if (!common->endonly)
      compile_char1_hotpath(common, OP_EODN, cc, fallbacks);
    else
+     {
      add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
+     check_partial(common, FALSE);
+     }
    return cc;
    case OP_DOLLM:
-Line 3010 
 switch(type)
+Line 3565 
 switch(type)
    OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
    add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   check_partial(common, FALSE);
    jump[0] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[1]);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
-     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 2);
+     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+     if (common->mode == JIT_COMPILE)
-     OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
+       add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));
+     else
+       {
+       jump[1] = CMP(SLJIT_C_LESS_EQUAL, TMP2, 0, STR_END, 0);
+       /* STR_PTR = STR_END - IN_UCHARS(1) */
+       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+       check_partial(common, TRUE);
+       add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+       JUMPHERE(jump[1]);
+       }
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
-Line 3033 
 switch(type)
+Line 3600 
 switch(type)
    case OP_CHAR:
    case OP_CHARI:
    length = 1;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   if (common->utf8 && *cc >= 0xc0) length += _pcre_utf8_table4[*cc & 0x3f];
+   if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);
  #endif
-   if (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0)
+   if (common->mode == JIT_COMPILE && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))
      {
-     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, length);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
      add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
-     context.length = length;
+     context.length = IN_UCHARS(length);
      context.sourcereg = -1;
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
-     context.byteptr = 0;
+     context.ucharptr = 0;
  #endif
      return byte_sequence_compare(common, type == OP_CHARI, cc, &context, fallbacks);
      }
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+   fallback_at_str_end(common, fallbacks);
    read_char(common);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   if (common->utf8)
+   if (common->utf)
      {
      GETCHAR(c, cc);
      }
    else
  #endif
      c = *cc;
+   if (type == OP_CHAR || !char_has_othercase(common, cc))
+     {
+     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
+     return cc + length;
+     }
+   oc = char_othercase(common, c);
+   bit = c ^ oc;
+   if (ispowerof2(bit))
+     {
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
+     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
+     return cc + length;
+     }
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);
    COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char_othercase(common, c));
-Line 3067 
 switch(type)
+Line 3647 
 switch(type)
    case OP_NOT:
    case OP_NOTI:
+   fallback_at_str_end(common, fallbacks);
    length = 1;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   if (common->utf8)
+   if (common->utf)
      {
-     if (*cc >= 0xc0) length += _pcre_utf8_table4[*cc & 0x3f];
+ #ifdef COMPILE_PCRE8
+     c = *cc;
-     check_input_end(common, fallbacks);
+     if (c < 128)
-     GETCHAR(c, cc);
-     if (c <= 127)
        {
        OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
-       OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes);
        if (type == OP_NOT || !char_has_othercase(common, cc))
          add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
        else
          {
          /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */
-         OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x20);
+         OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20);
-         add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | 0x20));
+         add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));
          }
        /* Skip the variable-length character. */
-       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-       return cc + length;
+       jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+       OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+       JUMPHERE(jump[0]);
+       return cc + 1;
        }
      else
+ #endif /* COMPILE_PCRE8 */
+       {
+       GETCHARLEN(c, cc, length);
        read_char(common);
+       }
      }
    else
- #endif
+ #endif /* SUPPORT_UTF */
      {
-     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+     read_char(common);
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -1);
      c = *cc;
      }
-Line 3125 
 switch(type)
+Line 3708 
 switch(type)
    case OP_CLASS:
    case OP_NCLASS:
-   check_input_end(common, fallbacks);
+   fallback_at_str_end(common, fallbacks);
    read_char(common);
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    jump[0] = NULL;
-   if (common->utf8)
+ #ifdef COMPILE_PCRE8
+   /* This check only affects 8 bit mode. In other modes, we
+   always need to compare the value with 255. */
+   if (common->utf)
+ #endif /* COMPILE_PCRE8 */
      {
      jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
      if (type == OP_CLASS)
-Line 3138 
 switch(type)
+Line 3725 
 switch(type)
        jump[0] = NULL;
        }
      }
- #endif
+ #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
    add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    if (jump[0] != NULL)
      JUMPHERE(jump[0]);
- #endif
+ #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
-   return cc + 32;
+   return cc + 32 / sizeof(pcre_uchar);
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16
    case OP_XCLASS:
    compile_xclass_hotpath(common, cc + LINK_SIZE, fallbacks);
    return cc + GET(cc, 0) - 1;
-Line 3159 
 switch(type)
+Line 3746 
 switch(type)
    case OP_REVERSE:
    length = GET(cc, 0);
-   SLJIT_ASSERT(length > 0);
+   if (length == 0)
+     return cc + LINK_SIZE;
    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
+ #ifdef SUPPORT_UTF
- #ifdef SUPPORT_UTF8
+   if (common->utf)
-   if (common->utf8)
      {
+     OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);
      label = LABEL();
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0));
+     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP3, 0));
      skip_char_back(common);
      OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
      JUMPTO(SLJIT_C_NOT_ZERO, label);
-     return cc + LINK_SIZE;
      }
+   else
  #endif
-   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, length);
+     {
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
+     OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
+     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
+     }
+   check_start_used_ptr(common);
    return cc + LINK_SIZE;
    }
  SLJIT_ASSERT_STOP();
  return cc;
  }
- static SLJIT_INLINE uschar *compile_charn_hotpath(compiler_common *common, uschar *cc, uschar *ccend, jump_list **fallbacks)
+ static SLJIT_INLINE pcre_uchar *compile_charn_hotpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **fallbacks)
  {
  /* This function consumes at least one input character. */
  /* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */
  DEFINE_COMPILER;
- uschar *ccbegin = cc;
+ pcre_uchar *ccbegin = cc;
  compare_context context;
  int size;
-Line 3200 
 do
+Line 3792 
 do
    if (*cc == OP_CHAR)
      {
      size = 1;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (common->utf8 && cc[1] >= 0xc0)
+     if (common->utf && HAS_EXTRALEN(cc[1]))
-       size += _pcre_utf8_table4[cc[1] & 0x3f];
+       size += GET_EXTRALEN(cc[1]);
  #endif
      }
    else if (*cc == OP_CHARI)
      {
      size = 1;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (common->utf8)
+     if (common->utf)
        {
        if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
          size = 0;
-       else if (cc[1] >= 0xc0)
+       else if (HAS_EXTRALEN(cc[1]))
-         size += _pcre_utf8_table4[cc[1] & 0x3f];
+         size += GET_EXTRALEN(cc[1]);
        }
      else
  #endif
      if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
        size = 0;
-Line 3225 
 do
+Line 3817 
 do
      size = 0;
    cc += 1 + size;
-   context.length += size;
+   context.length += IN_UCHARS(size);
    }
  while (size > 0 && context.length <= 128);
-Line 3238 
 if (context.length > 0)
+Line 3830 
 if (context.length > 0)
    context.sourcereg = -1;
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
-   context.byteptr = 0;
+   context.ucharptr = 0;
  #endif
    do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, fallbacks); while (context.length > 0);
    return cc;
-Line 3248 
 if (context.length > 0)
+Line 3840 
 if (context.length > 0)
  return compile_char1_hotpath(common, *cc, cc + 1, fallbacks);
  }
- static struct sljit_jump *compile_ref_checks(compiler_common *common, uschar *cc, jump_list **fallbacks)
+ static struct sljit_jump *compile_ref_checks(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1) << 1;
-Line 3258 
 if (!common->jscript_compat)
+Line 3850 
 if (!common->jscript_compat)
    {
    if (fallbacks == NULL)
      {
+     /* OVECTOR(1) contains the "string begin - 1" constant. */
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
      COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
-Line 3270 
 return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT
+Line 3863 
 return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT
  }
  /* Forward definitions. */
- static void compile_hotpath(compiler_common *, uschar *, uschar *, fallback_common *);
+ static void compile_hotpath(compiler_common *, pcre_uchar *, pcre_uchar *, fallback_common *);
  static void compile_fallbackpath(compiler_common *, struct fallback_common *);
  #define PUSH_FALLBACK(size, ccstart, error) \
-Line 3299 
 static void compile_fallbackpath(compile
+Line 3892 
 static void compile_fallbackpath(compile
      } \
    while (0)
- #define FALLBACK_AS(type) ((type*)fallback)
+ #define FALLBACK_AS(type) ((type *)fallback)
- static uschar *compile_ref_hotpath(compiler_common *common, uschar *cc, jump_list **fallbacks, BOOL withchecks, BOOL emptyfail)
+ static pcre_uchar *compile_ref_hotpath(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks, BOOL withchecks, BOOL emptyfail)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1) << 1;
  struct sljit_jump *jump = NULL;
+ struct sljit_jump *partial;
+ struct sljit_jump *nopartial;
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
+ /* OVECTOR(1) contains the "string begin - 1" constant. */
  if (withchecks && !common->jscript_compat)
    add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF && defined SUPPORT_UCP
- #ifdef SUPPORT_UCP
+ if (common->utf && *cc == OP_REFI)
- if (common->utf8 && *cc == OP_REFI)
    {
    SLJIT_ASSERT(TMP1 == SLJIT_TEMPORARY_REG1 && STACK_TOP == SLJIT_TEMPORARY_REG2 && TMP2 == SLJIT_TEMPORARY_REG3);
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
-Line 3323 
 if (common->utf8 && *cc == OP_REFI)
+Line 3918 
 if (common->utf8 && *cc == OP_REFI)
    /* Needed to save important temporary registers. */
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
    OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, ptr), STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, uchar_ptr), STR_PTR, 0);
-   sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf8caselesscmp));
+   sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));
    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
+   if (common->mode == JIT_COMPILE)
+     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));
+   else
+     {
+     add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
+     nopartial = CMP(SLJIT_C_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
+     check_partial(common, FALSE);
+     add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+     JUMPHERE(nopartial);
+     }
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);
    }
  else
- #endif
+ #endif /* SUPPORT_UTF && SUPPORT_UCP */
- #endif
    {
    OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
    if (withchecks)
      jump = JUMP(SLJIT_C_ZERO);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+   partial = CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0);
+   if (common->mode == JIT_COMPILE)
+     add_jump(compiler, fallbacks, partial);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
    add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
    add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   if (common->mode != JIT_COMPILE)
+     {
+     nopartial = JUMP(SLJIT_JUMP);
+     JUMPHERE(partial);
+     /* TMP2 -= STR_END - STR_PTR */
+     OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, STR_PTR, 0);
+     OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, STR_END, 0);
+     partial = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0);
+     OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);
+     add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
+     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+     JUMPHERE(partial);
+     check_partial(common, FALSE);
+     add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+     JUMPHERE(nopartial);
+     }
    }
  if (jump != NULL)
-Line 3350 
 if (jump != NULL)
+Line 3973 
 if (jump != NULL)
    else
      JUMPHERE(jump);
    }
- return cc + 3;
+ return cc + 1 + IMM2_SIZE;
  }
- static SLJIT_INLINE uschar *compile_ref_iterator_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_ref_iterator_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
  {
  DEFINE_COMPILER;
  fallback_common *fallback;
- uschar type;
+ pcre_uchar type;
  struct sljit_label *label;
  struct sljit_jump *zerolength;
  struct sljit_jump *jump = NULL;
- uschar *ccbegin = cc;
+ pcre_uchar *ccbegin = cc;
  int min = 0, max = 0;
  BOOL minimize;
  PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);
- type = cc[3];
+ type = cc[1 + IMM2_SIZE];
  minimize = (type & 0x1) != 0;
  switch(type)
    {
-Line 3375 
 switch(type)
+Line 3998 
 switch(type)
    case OP_CRMINSTAR:
    min = 0;
    max = 0;
-   cc += 4;
+   cc += 1 + IMM2_SIZE + 1;
    break;
    case OP_CRPLUS:
    case OP_CRMINPLUS:
    min = 1;
    max = 0;
-   cc += 4;
+   cc += 1 + IMM2_SIZE + 1;
    break;
    case OP_CRQUERY:
    case OP_CRMINQUERY:
    min = 0;
    max = 1;
-   cc += 4;
+   cc += 1 + IMM2_SIZE + 1;
    break;
    case OP_CRRANGE:
    case OP_CRMINRANGE:
-   min = GET2(cc, 3 + 1);
+   min = GET2(cc, 1 + IMM2_SIZE + 1);
-   max = GET2(cc, 3 + 3);
+   max = GET2(cc, 1 + IMM2_SIZE + 1 + IMM2_SIZE);
-   cc += 8;
+   cc += 1 + IMM2_SIZE + 1 + 2 * IMM2_SIZE;
    break;
    default:
    SLJIT_ASSERT_STOP();
-Line 3453 
 if (!minimize)
+Line 4076 
 if (!minimize)
    JUMPHERE(zerolength);
    FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   decrease_call_count(common);
    return cc;
    }
-Line 3490 
 else if (max > 0)
+Line 4115 
 else if (max > 0)
  if (jump != NULL)
    JUMPHERE(jump);
  JUMPHERE(zerolength);
+ decrease_call_count(common);
  return cc;
  }
- static SLJIT_INLINE uschar *compile_recurse_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_recurse_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
  {
  DEFINE_COMPILER;
  fallback_common *fallback;
-Line 3526 
 if (entry == NULL)
+Line 4153 
 if (entry == NULL)
      common->entries = entry;
    }
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+ if (common->has_set_som && common->mark_ptr != 0)
- allocate_stack(common, 1);
+   {
- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+   allocate_stack(common, 2);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+   }
+ else if (common->has_set_som || common->mark_ptr != 0)
+   {
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr);
+   allocate_stack(common, 1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+   }
  if (entry->entry == NULL)
    add_jump(compiler, &entry->calls, JUMP(SLJIT_FAST_CALL));
-Line 3539 
 add_jump(compiler, &fallback->topfallbac
+Line 4177 
 add_jump(compiler, &fallback->topfallbac
  return cc + 1 + LINK_SIZE;
  }
- static uschar *compile_assert_hotpath(compiler_common *common, uschar *cc, assert_fallback *fallback, BOOL conditional)
+ static pcre_uchar *compile_assert_hotpath(compiler_common *common, pcre_uchar *cc, assert_fallback *fallback, BOOL conditional)
  {
  DEFINE_COMPILER;
  int framesize;
  int localptr;
  fallback_common altfallback;
- uschar *ccbegin;
+ pcre_uchar *ccbegin;
- uschar opcode;
+ pcre_uchar opcode;
- uschar bra = OP_BRA;
+ pcre_uchar bra = OP_BRA;
  jump_list *tmp = NULL;
  jump_list **target = (conditional) ? &fallback->condfailed : &fallback->common.topfallbacks;
  jump_list **found;
  /* Saving previous accept variables. */
+ struct sljit_label *save_leavelabel = common->leavelabel;
  struct sljit_label *save_acceptlabel = common->acceptlabel;
+ jump_list *save_leave = common->leave;
+ jump_list *save_accept = common->accept;
  struct sljit_jump *jump;
  struct sljit_jump *brajump = NULL;
- jump_list *save_accept = common->accept;
  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
    {
-Line 3563 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 4203 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
    bra = *cc;
    cc++;
    }
- localptr = PRIV(cc);
+ localptr = PRIV_DATA(cc);
  SLJIT_ASSERT(localptr != 0);
  framesize = get_framesize(common, cc, FALSE);
  fallback->framesize = framesize;
-Line 3600 
 else
+Line 4240 
 else
    }
  memset(&altfallback, 0, sizeof(fallback_common));
+ common->leavelabel = NULL;
+ common->leave = NULL;
  while (1)
    {
    common->acceptlabel = NULL;
-Line 3614 
 while (1)
+Line 4256 
 while (1)
    compile_hotpath(common, ccbegin + 1 + LINK_SIZE, cc, &altfallback);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
+     common->leavelabel = save_leavelabel;
      common->acceptlabel = save_acceptlabel;
+     common->leave = save_leave;
      common->accept = save_accept;
      return NULL;
      }
-Line 3622 
 while (1)
+Line 4266 
 while (1)
    if (common->accept != NULL)
      set_jumps(common->accept, common->acceptlabel);
+   /* Reset stack. */
    if (framesize < 0)
      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+   else {
+     if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)
+       {
+       /* We don't need to keep the STR_PTR, only the previous localptr. */
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
+       }
+     else
+       {
+       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+       add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+       }
+   }
    if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
      {
      /* We know that STR_PTR was stored on the top of the stack. */
      if (conditional)
-       {
+       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
-       if (framesize < 0)
-         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
-       else
-         {
-         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), (framesize + 1) * sizeof(sljit_w));
-         }
-       }
      else if (bra == OP_BRAZERO)
        {
        if (framesize < 0)
          OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
        else
          {
-         OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-         add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
          OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_w));
          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
-Line 3653 
 while (1)
+Line 4300 
 while (1)
        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
        }
-     else if (bra == OP_BRAMINZERO)
+     else if (framesize >= 0)
        {
-       if (framesize >= 0)
+       /* For OP_BRA and OP_BRAMINZERO. */
-         {
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
-         OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-         add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
-         }
        }
      }
    add_jump(compiler, found, JUMP(SLJIT_JUMP));
-Line 3668 
 while (1)
+Line 4311 
 while (1)
    compile_fallbackpath(common, altfallback.top);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
+     common->leavelabel = save_leavelabel;
      common->acceptlabel = save_acceptlabel;
+     common->leave = save_leave;
      common->accept = save_accept;
      return NULL;
      }
-Line 3681 
 while (1)
+Line 4326 
 while (1)
    cc += GET(cc, 1);
    }
  /* None of them matched. */
+ if (common->leave != NULL)
+   set_jumps(common->leave, LABEL());
  if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
    {
    /* Assert is failed. */
    if (conditional || bra == OP_BRAZERO)
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    if (framesize < 0)
      {
      /* The topmost item should be 0. */
-Line 3698 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4346 
 if (opcode == OP_ASSERT || opcode == OP_
    else
      {
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
-     if (framesize > 0)
-       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
      /* The topmost item should be 0. */
      if (bra == OP_BRAZERO)
        {
-Line 3709 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4355 
 if (opcode == OP_ASSERT || opcode == OP_
      else
        free_stack(common, framesize + 2);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
-     if (framesize > 0)
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD, TMP2, 0);
      }
    jump = JUMP(SLJIT_JUMP);
    if (bra != OP_BRAZERO)
-Line 3733 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4377 
 if (opcode == OP_ASSERT || opcode == OP_
      }
    else
      {
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+     if (bra == OP_BRA)
-     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), (framesize + 1) * sizeof(sljit_w));
+       {
-     if (bra == OP_BRAZERO)
+       /* We don't need to keep the STR_PTR, only the previous localptr. */
-       {
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
-       allocate_stack(common, 1);
+       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
        }
-     else if (bra == OP_BRAMINZERO)
+     else
        {
-       allocate_stack(common, 1);
+       /* We don't need to keep the STR_PTR, only the previous localptr. */
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_w));
+       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
        }
      }
-Line 3780 
 else
+Line 4425 
 else
      {
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
-     if (framesize > 0)
-       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
      /* The topmost item should be 0. */
      if (bra != OP_BRA)
        {
-Line 3791 
 else
+Line 4434 
 else
      else
        free_stack(common, framesize + 2);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
-     if (framesize > 0)
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD, TMP2, 0);
      }
    if (bra == OP_BRAZERO)
-Line 3811 
 else
+Line 4452 
 else
      }
    }
+ common->leavelabel = save_leavelabel;
  common->acceptlabel = save_acceptlabel;
+ common->leave = save_leave;
  common->accept = save_accept;
  return cc + 1 + LINK_SIZE;
  }
+ static sljit_w SLJIT_CALL do_searchovector(sljit_w refno, sljit_w* locals, pcre_uchar *name_table)
+ {
+ int condition = FALSE;
+ pcre_uchar *slotA = name_table;
+ pcre_uchar *slotB;
+ sljit_w name_count = locals[LOCALS0 / sizeof(sljit_w)];
+ sljit_w name_entry_size = locals[LOCALS1 / sizeof(sljit_w)];
+ sljit_w no_capture;
+ int i;
+ locals += refno & 0xff;
+ refno >>= 8;
+ no_capture = locals[1];
+ for (i = 0; i < name_count; i++)
+   {
+   if (GET2(slotA, 0) == refno) break;
+   slotA += name_entry_size;
+   }
+ if (i < name_count)
+   {
+   /* Found a name for the number - there can be only one; duplicate names
+   for different numbers are allowed, but not vice versa. First scan down
+   for duplicates. */
+   slotB = slotA;
+   while (slotB > name_table)
+     {
+     slotB -= name_entry_size;
+     if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
+       {
+       condition = locals[GET2(slotB, 0) << 1] != no_capture;
+       if (condition) break;
+       }
+     else break;
+     }
+   /* Scan up for duplicates */
+   if (!condition)
+     {
+     slotB = slotA;
+     for (i++; i < name_count; i++)
+       {
+       slotB += name_entry_size;
+       if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
+         {
+         condition = locals[GET2(slotB, 0) << 1] != no_capture;
+         if (condition) break;
+         }
+       else break;
+       }
+     }
+   }
+ return condition;
+ }
+ static sljit_w SLJIT_CALL do_searchgroups(sljit_w recno, sljit_w* locals, pcre_uchar *name_table)
+ {
+ int condition = FALSE;
+ pcre_uchar *slotA = name_table;
+ pcre_uchar *slotB;
+ sljit_w name_count = locals[LOCALS0 / sizeof(sljit_w)];
+ sljit_w name_entry_size = locals[LOCALS1 / sizeof(sljit_w)];
+ sljit_w group_num = locals[POSSESSIVE0 / sizeof(sljit_w)];
+ int i;
+ for (i = 0; i < name_count; i++)
+   {
+   if (GET2(slotA, 0) == recno) break;
+   slotA += name_entry_size;
+   }
+ if (i < name_count)
+   {
+   /* Found a name for the number - there can be only one; duplicate
+   names for different numbers are allowed, but not vice versa. First
+   scan down for duplicates. */
+   slotB = slotA;
+   while (slotB > name_table)
+     {
+     slotB -= name_entry_size;
+     if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
+       {
+       condition = GET2(slotB, 0) == group_num;
+       if (condition) break;
+       }
+     else break;
+     }
+   /* Scan up for duplicates */
+   if (!condition)
+     {
+     slotB = slotA;
+     for (i++; i < name_count; i++)
+       {
+       slotB += name_entry_size;
+       if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
+         {
+         condition = GET2(slotB, 0) == group_num;
+         if (condition) break;
+         }
+       else break;
+       }
+     }
+   }
+ return condition;
+ }
  /*
    Handling bracketed expressions is probably the most complex part.
-Line 3825 
 return cc + 1 + LINK_SIZE;
+Line 4578 
 return cc + 1 + LINK_SIZE;
      A - Push the current STR_PTR. Needed for restoring the STR_PTR
          before the next alternative. Not pushed if there are no alternatives.
      M - Any values pushed by the current alternative. Can be empty, or anything.
-     C - Push the previous OVECTOR(i), OVECTOR(i+1), MAX_INDEX and OVECTOR_PRIV(i) to the stack.
+     C - Push the previous OVECTOR(i), OVECTOR(i+1) and OVECTOR_PRIV(i) to the stack.
      L - Push the previous local (pointed by localptr) to the stack
     () - opional values stored on the stack
    ()* - optonal, can be stored multiple times
-Line 3863 
 return cc + 1 + LINK_SIZE;
+Line 4616 
 return cc + 1 + LINK_SIZE;
      M - Any values pushed by the current alternative. Can be empty, or anything.
    The next list shows the possible content of a bracket:
-   (|)     OP_*BRA  | OP_ALT ...         M A
+   (|)     OP_*BRA    | OP_ALT ...         M A
-   (?()|)  OP_*COND | OP_ALT             M A
+   (?()|)  OP_*COND   | OP_ALT             M A
-   (?>|)   OP_ONCE  | OP_ALT ...         [stack trace] M A
+   (?>|)   OP_ONCE    | OP_ALT ...         [stack trace] M A
-                                         Or nothing, if trace is unnecessary
+   (?>|)   OP_ONCE_NC | OP_ALT ...         [stack trace] M A
+                                           Or nothing, if trace is unnecessary
  */
- static uschar *compile_bracket_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
+ static pcre_uchar *compile_bracket_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
  {
  DEFINE_COMPILER;
  fallback_common *fallback;
- uschar opcode;
+ pcre_uchar opcode;
  int localptr = 0;
  int offset = 0;
  int stacksize;
- uschar *ccbegin;
+ pcre_uchar *ccbegin;
- uschar *hotpath;
+ pcre_uchar *hotpath;
- uschar bra = OP_BRA;
+ pcre_uchar bra = OP_BRA;
- uschar ket;
+ pcre_uchar ket;
  assert_fallback *assert;
  BOOL has_alternatives;
  struct sljit_jump *jump;
-Line 3899 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 4653 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
  opcode = *cc;
  ccbegin = cc;
+ hotpath = ccbegin + 1 + LINK_SIZE;
  if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
    {
    /* Drop this bracket_fallback. */
-Line 3910 
 ket = *(bracketend(cc) - 1 - LINK_SIZE);
+Line 4666 
 ket = *(bracketend(cc) - 1 - LINK_SIZE);
  SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);
  SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));
  cc += GET(cc, 1);
- has_alternatives = *cc == OP_ALT || opcode == OP_COND || opcode == OP_SCOND;
+ has_alternatives = *cc == OP_ALT;
+ if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
+   {
+   has_alternatives = (*hotpath == OP_RREF) ? FALSE : TRUE;
+   if (*hotpath == OP_NRREF)
+     {
+     stacksize = GET2(hotpath, 1);
+     if (common->currententry == NULL || stacksize == RREF_ANY)
+       has_alternatives = FALSE;
+     else if (common->currententry->start == 0)
+       has_alternatives = stacksize != 0;
+     else
+       has_alternatives = stacksize != GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
+     }
+   }
  if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
    opcode = OP_SCOND;
+ if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
+   opcode = OP_ONCE;
  if (opcode == OP_CBRA || opcode == OP_SCBRA)
    {
-Line 3921 
 if (opcode == OP_CBRA || opcode == OP_SC
+Line 4695 
 if (opcode == OP_CBRA || opcode == OP_SC
    localptr = OVECTOR_PRIV(offset);
    offset <<= 1;
    FALLBACK_AS(bracket_fallback)->localptr = localptr;
+   hotpath += IMM2_SIZE;
    }
  else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)
    {
    /* Other brackets simply allocate the next entry. */
-   localptr = PRIV(ccbegin);
+   localptr = PRIV_DATA(ccbegin);
    SLJIT_ASSERT(localptr != 0);
    FALLBACK_AS(bracket_fallback)->localptr = localptr;
    if (opcode == OP_ONCE)
-Line 4052 
 if (opcode == OP_ONCE)
+Line 4827 
 if (opcode == OP_ONCE)
  else if (opcode == OP_CBRA || opcode == OP_SCBRA)
    {
    /* Saving the previous values. */
-   allocate_stack(common, 4);
+   allocate_stack(common, 3);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), MAX_INDEX, 0);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(3), TMP1, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
-   /* Update MAX_INDEX if necessary. */
-   add_stub(common, max_index, (offset >> 1) + 1, CMP(SLJIT_C_LESS, MAX_INDEX, 0, SLJIT_IMM, (offset >> 1) + 1));
    }
  else if (opcode == OP_SBRA || opcode == OP_SCOND)
    {
-Line 4080 
 else if (has_alternatives)
+Line 4852 
 else if (has_alternatives)
    }
  /* Generating code for the first alternative. */
- hotpath = ccbegin + 1 + LINK_SIZE;
- if (offset != 0)
-   hotpath += 2;
  if (opcode == OP_COND || opcode == OP_SCOND)
    {
    if (*hotpath == OP_CREF)
      {
+     SLJIT_ASSERT(has_alternatives);
      add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed),
-       CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR((GET2(hotpath, 1) << 1)), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+       CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(hotpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
-     hotpath += 3;
+     hotpath += 1 + IMM2_SIZE;
+     }
+   else if (*hotpath == OP_NCREF)
+     {
+     SLJIT_ASSERT(has_alternatives);
+     stacksize = GET2(hotpath, 1);