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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 708 by ph10,
Fri Sep 23 11:03:03 2011 UTC
+revision 915 by zherczeg,
Tue Feb 14 13:05:39 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 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 *ptr;
    /* Everything else after. */
    int offsetcount;
    int calllimit;
-   uschar notbol;
+   pcre_uint8 notbol;
-   uschar noteol;
+   pcre_uint8 noteol;
-   uschar notempty;
+   pcre_uint8 notempty;
-   uschar notempty_atstart;
+   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;
-Line 194 
 typedef struct fallback_common {
+Line 198 
 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 265 
 typedef struct recurse_fallback {
+Line 269 
 typedef struct recurse_fallback {
  typedef struct compiler_common {
    struct sljit_compiler *compiler;
-   uschar *start;
+   pcre_uchar *start;
    int localsize;
    int *localptrs;
-   const uschar *fcc;
+   const pcre_uint8 *fcc;
    sljit_w lcc;
    int cbraptr;
+   int mode;
    int nltype;
    int newline;
    int bsr_nltype;
    int endonly;
    sljit_w ctypes;
+   sljit_uw name_table;
+   sljit_w name_count;
+   sljit_w name_entry_size;
+   struct sljit_label *partialmatchlabel;
    struct sljit_label *acceptlabel;
    stub_list *stubs;
    recurse_entry *entries;
    recurse_entry *currententry;
+   jump_list *partialmatch;
    jump_list *accept;
    jump_list *calllimit;
    jump_list *stackalloc;
-Line 291 
 typedef struct compiler_common {
+Line 301 
 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 310 
 typedef struct compare_context {
+Line 322 
 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;
-Line 331 
 enum {
+Line 355 
 enum {
    frame_setstrbegin = -1
  };
+ /* 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 CALL_COUNT    SLJIT_GENERAL_EREG2
+ #define CALL_COUNT    SLJIT_SAVED_EREG2
  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1
  /* Locals layout. */
-Line 352 
 enum {
+Line 379 
 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 */
- #define LOCALS_HEAD      (4 * sizeof(sljit_w))
  /* Head of the last recursion. */
- #define RECURSIVE_HEAD   (5 * sizeof(sljit_w))
+ #define RECURSIVE_HEAD   (4 * sizeof(sljit_w))
  /* Max limit of recursions. */
- #define CALL_LIMIT       (7 * sizeof(sljit_w))
+ #define CALL_LIMIT       (5 * sizeof(sljit_w))
- /* Last known position of the requested byte. */
+ /* Last known position of the requested byte.
- #define REQ_BYTE_PTR     (8 * sizeof(sljit_w))
+ Same as START_USED_PTR. (Partial matching and req_char are exclusive) */
+ #define REQ_CHAR_PTR     (6 * sizeof(sljit_w))
+ /* First inspected character for partial matching.
+ Same as REQ_CHAR_PTR. (Partial matching and req_char are exclusive) */
+ #define START_USED_PTR   (6 * sizeof(sljit_w))
+ /* Starting pointer for partial soft matches. */
+ #define HIT_START        (8 * sizeof(sljit_w))
  /* End pointer of the first line. */
  #define FIRSTLINE_END    (9 * sizeof(sljit_w))
  /* The output vector is stored on the stack, and contains pointers
-Line 369 
 the start pointers when the end of the c
+Line 400 
 the start pointers when the end of the c
  #define OVECTOR_START    (10 * sizeof(sljit_w))
  #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 393 
 the start pointers when the end of the c
+Line 436 
 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 414 
 return cc;
+Line 457 
 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 469 
 switch(*cc)
+Line 512 
 switch(*cc)
    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 511 
 switch(*cc)
+Line 559 
 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 532 
 switch(*cc)
+Line 580 
 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 547 
 switch(*cc)
+Line 597 
 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 571 
 switch(*cc)
+Line 624 
 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 588 
 switch(*cc)
+Line 642 
 switch(*cc)
    case OP_CBRAPOS:
    case OP_SCBRA:
    case OP_SCBRAPOS:
-   return cc + 1 + LINK_SIZE + 2;
+   return cc + 1 + LINK_SIZE + IMM2_SIZE;
    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)
    {
-Line 609 
 while (cc < ccend)
+Line 663 
 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 620 
 while (cc < ccend)
+Line 675 
 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 641 
 while (cc < ccend)
+Line 696 
 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 654 
 while (cc < ccend)
+Line 709 
 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 667 
 while (cc < ccend)
+Line 723 
 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 690 
 while (cc < ccend)
+Line 746 
 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 = FALSE;
  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
-Line 720 
 while (cc < ccend)
+Line 774 
 while (cc < ccend)
      cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;
      break;
-     case OP_ASSERT:
-     case OP_ASSERT_NOT:
-     case OP_ASSERTBACK:
-     case OP_ASSERTBACK_NOT:
-     case OP_ONCE:
-     if (needs_frame || length > 0)
-       {
-       cc = bracketend(cc);
-       break;
-       }
-     /* Check whether a frame must be created. */
-     end = bracketend(cc);
-     while (cc < end)
-       {
-       if (*cc == OP_SET_SOM || *cc == OP_CBRA || *cc == OP_CBRAPOS
-           || *cc == OP_SCBRA || *cc == OP_SCBRAPOS || *cc == OP_RECURSE)
-         needs_frame = TRUE;
-       cc = next_opcode(common, cc);
-       SLJIT_ASSERT(cc != NULL);
-       }
-     break;
      case OP_CBRA:
      case OP_CBRAPOS:
      case OP_SCBRA:
      case OP_SCBRAPOS:
      length += 3;
-     cc += 1 + LINK_SIZE + 2;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      default:
-Line 757 
 while (cc < ccend)
+Line 789 
 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 setsom_found = FALSE;
  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 804 
 while (cc < ccend)
+Line 829 
 while (cc < ccend)
      cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;
      break;
-     case OP_ASSERT:
-     case OP_ASSERT_NOT:
-     case OP_ASSERTBACK:
-     case OP_ASSERTBACK_NOT:
-     case OP_ONCE:
-     cc = bracketend(cc);
-     break;
      case OP_CBRA:
      case OP_CBRAPOS:
      case OP_SCBRA:
-Line 826 
 while (cc < ccend)
+Line 843 
 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 836 
 while (cc < ccend)
+Line 853 
 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 853 
 while (cc < ccend)
+Line 870 
 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 864 
 while (cc < ccend)
+Line 882 
 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 891 
 SLJIT_ASSERT(cc == ccend);
+Line 909 
 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 900 
 int count;
+Line 918 
 int count;
  BOOL tmp1next = TRUE;
  BOOL tmp1empty = TRUE;
  BOOL tmp2empty = TRUE;
- uschar *alternative;
+ pcre_uchar *alternative;
  enum {
    start,
    loop,
-Line 955 
 while (status != end)
+Line 973 
 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 969 
 while (status != end)
+Line 988 
 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 987 
 while (status != end)
+Line 1006 
 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 1195 
 struct sljit_label *loop;
+Line 1214 
 struct sljit_label *loop;
  int i;
  /* At this point we can freely use all temporary registers. */
  /* TMP1 returns with begin - 1. */
- OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_GENERAL_REG1), SLJIT_OFFSETOF(jit_arguments, begin), 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));
  if (length < 8)
    {
    for (i = 0; i < length; i++)
-Line 1219 
 struct sljit_label *loop;
+Line 1238 
 struct sljit_label *loop;
  struct sljit_jump *earlyexit;
  /* At this point we can freely use all registers. */
- OP1(SLJIT_MOV, SLJIT_GENERAL_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+ 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);
  OP1(SLJIT_MOV_SI, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsetcount));
  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);
-Line 1244 
 if (topbracket > 1)
+Line 1266 
 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_GENERAL_REG3. */
+   /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */
    loop = LABEL();
-   OP1(SLJIT_MOVU, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), -(2 * sizeof(sljit_w)));
+   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_GENERAL_REG3, 0, loop);
+   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 BOOL char_has_othercase(compiler_common *common, uschar* cc)
+ 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);
+ 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 ? START_USED_PTR : 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), 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), 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), START_USED_PTR, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), START_USED_PTR, STR_PTR, 0);
+   JUMPHERE(jump);
+   }
+ }
+ 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 1272 
 if (common->utf8)
+Line 1348 
 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 1292 
 if (common->utf8 && c > 127)
+Line 1371 
 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 1321 
 if (common->utf8)
+Line 1400 
 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 1339 
 if (c <= 127 && bit == 0x20)
+Line 1418 
 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 1350 
 if (common->utf8 && c > 127)
+Line 1431 
 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 SLJIT_INLINE void check_input_end(compiler_common *common, jump_list **fallbacks)
+ static void check_partial(compiler_common *common)
  {
  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)
+   return;
+ jump = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), START_USED_PTR, STR_PTR, 0);
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), HIT_START, SLJIT_IMM, -1);
+ else
+   {
+   if (common->partialmatchlabel != NULL)
+     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+   else
+     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+   }
+ 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), START_USED_PTR, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), 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), 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 void fallback_at_str_end(compiler_common *common, jump_list **fallbacks)
+ {
+ DEFINE_COMPILER;
+ 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), START_USED_PTR, STR_PTR, 0));
+ if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+   {
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), 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 1365 
 static void read_char(compiler_common *c
+Line 1538 
 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 1387 
 static void peek_char(compiler_common *c
+Line 1565 
 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 1408 
 static void read_char8_type(compiler_com
+Line 1591 
 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 1472 
 else if (nltype == NLTYPE_ANYCRLF)
+Line 1691 
 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 1489 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 1710 
 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);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 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);
- 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);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(3));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 4);
+ 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, 4);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));
  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 1573 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 1769 
 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 1590 
 sljit_emit_fast_return(compiler, RETURN_
+Line 1786 
 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 1615 
 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && si
+Line 1841 
 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 1635 
 struct sljit_label *newlinelabel = NULL;
+Line 1861 
 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 1652 
 if (firstline)
+Line 1881 
 if (firstline)
    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), FIRSTLINE_END, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      }
    else
      {
-Line 1682 
 start = JUMP(SLJIT_JUMP);
+Line 1911 
 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 1694 
 if (newlinecheck)
+Line 1926 
 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 1727 
 if (newlinecheck)
+Line 1970 
 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)
    {
-Line 1743 
 if (firstline)
+Line 1986 
 if (firstline)
  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 1767 
 else
+Line 2017 
 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 1811 
 if (common->nltype == NLTYPE_FIXED && co
+Line 2070 
 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 1851 
 if (common->nltype == NLTYPE_ANY || comm
+Line 2113 
 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 1871 
 DEFINE_COMPILER;
+Line 2136 
 DEFINE_COMPILER;
  struct sljit_label *start;
  struct sljit_jump *leave;
  struct sljit_jump *found;
+ #ifndef COMPILE_PCRE8
+ struct sljit_jump *jump;
+ #endif
  if (firstline)
    {
-Line 1880 
 if (firstline)
+Line 2148 
 if (firstline)
  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 1892 
 OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TM
+Line 2165 
 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 1908 
 if (firstline)
+Line 2197 
 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 1917 
 struct sljit_jump *alreadyfound;
+Line 2206 
 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);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), 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), REQ_CHAR_PTR, TMP1, 0);
  JUMPHERE(alreadyfound);
  JUMPHERE(toolong);
  return notfound;
-Line 1966 
 return notfound;
+Line 2262 
 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 1987 
 JUMPTO(SLJIT_JUMP, mainloop);
+Line 2281 
 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);
-Line 2010 
 JUMPTO(SLJIT_JUMP, mainloop);
+Line 2300 
 JUMPTO(SLJIT_JUMP, mainloop);
  static void check_wordboundary(compiler_common *common)
  {
  DEFINE_COMPILER;
- struct sljit_jump *beginend;
+ struct sljit_jump *skipread;
- #ifdef SUPPORT_UTF8
+ #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 2045 
 if (common->useucp)
+Line 2336 
 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 2084 
 if (common->useucp)
+Line 2379 
 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 2115 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
+Line 2416 
 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 2139 
 COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_E
+Line 2444 
 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 2155 
 if (common->utf8)
+Line 2462 
 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 2173 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
+Line 2482 
 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 2199 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 2512 
 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 2231 
 OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);
+Line 2544 
 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 2255 
 sljit_emit_fast_return(compiler, RETURN_
+Line 2578 
 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->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 2294 
 if (caseless && char_has_othercase(commo
+Line 2615 
 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 2391 
 do
+Line 2749 
 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 2422 
 return cc;
+Line 2780 
 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 2430 
 jump_list **list = (*cc & XCL_NOT) == 0
+Line 2788 
 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 2455 
 if ((*cc++ & XCL_MAP) != 0)
+Line 2819 
 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 2473 
 while (*cc != XCL_END)
+Line 2841 
 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 2483 
 while (*cc != XCL_END)
+Line 2851 
 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 2558 
 if (needstype || needsscript)
+Line 2926 
 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 2588 
 while (*cc != XCL_END)
+Line 2956 
 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 2619 
 while (*cc != XCL_END)
+Line 2987 
 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 2628 
 while (*cc != XCL_END)
+Line 2996 
 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 2685 
 while (*cc != XCL_END)
+Line 3053 
 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 2749 
 if (found != NULL)
+Line 3117 
 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_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 2785 
 switch(type)
+Line 3153 
 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 2793 
 switch(type)
+Line 3161 
 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 2801 
 switch(type)
+Line 3169 
 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);
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+     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]);
      JUMPHERE(jump[0]);
-Line 2824 
 switch(type)
+Line 3192 
 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 2852 
 switch(type)
+Line 3239 
 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);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+   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 2869 
 switch(type)
+Line 3256 
 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 2877 
 switch(type)
+Line 3264 
 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 2885 
 switch(type)
+Line 3272 
 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 2901 
 switch(type)
+Line 3288 
 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);
+     check_partial(common);
+     JUMPHERE(jump[0]);
+     }
    return cc;
  #endif
-Line 2908 
 switch(type)
+Line 3301 
 switch(type)
    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));
-     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));
      }
    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 2954 
 switch(type)
+Line 3348 
 switch(type)
      JUMPHERE(jump[3]);
      }
    JUMPHERE(jump[0]);
+   check_partial(common);
    return cc;
    case OP_EOD:
    add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
+   check_partial(common);
    return cc;
    case OP_CIRC:
-Line 2977 
 switch(type)
+Line 3373 
 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 3006 
 switch(type)
+Line 3400 
 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);
+     }
    return cc;
    case OP_DOLLM:
-Line 3014 
 switch(type)
+Line 3411 
 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);
    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(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
-     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 3037 
 switch(type)
+Line 3435 
 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 3071 
 switch(type)
+Line 3482 
 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 3539 
 switch(type)
        add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));
        }
      }
-   return cc + length;
+   return cc + 1;
    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 3142 
 switch(type)
+Line 3560 
 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 3165 
 switch(type)
+Line 3583 
 switch(type)
    length = GET(cc, 0);
    SLJIT_ASSERT(length > 0);
    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 3204 
 do
+Line 3626 
 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
-Line 3229 
 do
+Line 3651 
 do
      size = 0;
    cc += 1 + size;
-   context.length += size;
+   context.length += IN_UCHARS(size);
    }
  while (size > 0 && context.length <= 128);
-Line 3242 
 if (context.length > 0)
+Line 3664 
 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 3252 
 if (context.length > 0)
+Line 3674 
 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 3262 
 if (!common->jscript_compat)
+Line 3684 
 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 3274 
 return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT
+Line 3697 
 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 3303 
 static void compile_fallbackpath(compile
+Line 3726 
 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 3328 
 if (common->utf8 && *cc == OP_REFI)
+Line 3753 
 if (common->utf8 && *cc == OP_REFI)
    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);
-   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);
+     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);
+     add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+     JUMPHERE(nopartial);
+     }
    }
  if (jump != NULL)
-Line 3354 
 if (jump != NULL)
+Line 3807 
 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 3379 
 switch(type)
+Line 3832 
 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 3501 
 decrease_call_count(common);
+Line 3954 
 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 3547 
 add_jump(compiler, &fallback->topfallbac
+Line 4000 
 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;
-Line 3571 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 4024 
 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 3630 
 while (1)
+Line 4083 
 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 3661 
 while (1)
+Line 4117 
 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 3695 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4147 
 if (opcode == OP_ASSERT || opcode == OP_
    /* 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 3706 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4159 
 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 3717 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4168 
 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 3741 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 4190 
 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)
        {
-       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), STR_PTR, 0);
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
+       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 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 3788 
 else
+Line 4238 
 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 3799 
 else
+Line 4247 
 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 3824 
 common->accept = save_accept;
+Line 4270 
 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 += OVECTOR_START / sizeof(sljit_w);
+ 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 3871 
 return cc + 1 + LINK_SIZE;
+Line 4426 
 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 3907 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 4463 
 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 3918 
 ket = *(bracketend(cc) - 1 - LINK_SIZE);
+Line 4476 
 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 3929 
 if (opcode == OP_CBRA || opcode == OP_SC
+Line 4505 
 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 4085 
 else if (has_alternatives)
+Line 4662 
 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);
+     jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(stacksize << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
+     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);
+     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);
+     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
+     sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchovector));
+     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
+     add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+     JUMPHERE(jump);
+     hotpath += 1 + IMM2_SIZE;
+     }
+   else if (*hotpath == OP_RREF || *hotpath == OP_NRREF)
+     {
+     /* Never has other case. */
+     FALLBACK_AS(bracket_fallback)->u.condfailed = NULL;
+     stacksize = GET2(hotpath, 1);
+     if (common->currententry == NULL)
+       stacksize = 0;
+     else if (stacksize == RREF_ANY)
+       stacksize = 1;
+     else if (common->currententry->start == 0)
+       stacksize = stacksize == 0;
+     else
+       stacksize = stacksize == GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
+     if (*hotpath == OP_RREF || stacksize || common->currententry == NULL)
+       {
+       SLJIT_ASSERT(!has_alternatives);
+       if (stacksize != 0)
+         hotpath += 1 + IMM2_SIZE;
+       else
+         {
+         if (*cc == OP_ALT)
+           {
+           hotpath = cc + 1 + LINK_SIZE;
+           cc += GET(cc, 1);
+           }
+         else
+           hotpath = cc;
+         }
+       }
+     else
+       {
+       SLJIT_ASSERT(has_alternatives);
+       stacksize = GET2(hotpath, 1);
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, GET2(common->start, common->currententry->start + 1 + LINK_SIZE));
+       OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);
+       OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);
+       OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
+       sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchgroups));
+       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
+       add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+       hotpath += 1 + IMM2_SIZE;
+       }
      }
    else
      {
-     SLJIT_ASSERT(*hotpath >= OP_ASSERT && *hotpath <= OP_ASSERTBACK_NOT);
+     SLJIT_ASSERT(has_alternatives && *hotpath >= OP_ASSERT && *hotpath <= OP_ASSERTBACK_NOT);
      /* Similar code as PUSH_FALLBACK macro. */
      assert = sljit_alloc_memory(compiler, sizeof(assert_fallback));
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
-Line 4128 
 if (opcode == OP_ONCE)
+Line 4771 
 if (opcode == OP_ONCE)
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), 0);
        }
      }
-   else if (ket == OP_KETRMAX)
+   else
      {
-     /* TMP2 which is set here used by OP_KETRMAX below. */
+     stacksize = (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives) ? 2 : 1;
-     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+     OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (FALLBACK_AS(bracket_fallback)->u.framesize + stacksize) * sizeof(sljit_w));
-     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), (FALLBACK_AS(bracket_fallback)->u.framesize + 1) * sizeof(sljit_w));
+     if (ket == OP_KETRMAX)
+       {
+       /* TMP2 which is set here used by OP_KETRMAX below. */
+       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+       }
      }
    }
-Line 4197 
 if (bra == OP_BRAZERO)
+Line 4844 
 if (bra == OP_BRAZERO)
  if (bra == OP_BRAMINZERO)
    {
    /* This is a fallback path! (From the viewpoint of OP_BRAMINZERO) */
-   JUMPTO(SLJIT_JUMP, ((braminzero_fallback*)parent)->hotpath);
+   JUMPTO(SLJIT_JUMP, ((braminzero_fallback *)parent)->hotpath);
    if (braminzerojump != NULL)
      {
      JUMPHERE(braminzerojump);
-Line 4225 
 cc += 1 + LINK_SIZE;
+Line 4872 
 cc += 1 + LINK_SIZE;
  return cc;
  }
- static uschar *compile_bracketpos_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
+ static pcre_uchar *compile_bracketpos_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
  {
  DEFINE_COMPILER;
  fallback_common *fallback;
- uschar opcode;
+ pcre_uchar opcode;
  int localptr;
  int cbraprivptr = 0;
  int framesize;
  int stacksize;
  int offset = 0;
  BOOL zero = FALSE;
- uschar *ccbegin = NULL;
+ pcre_uchar *ccbegin = NULL;
  int stack;
  struct sljit_label *loop = NULL;
  struct jump_list *emptymatch = NULL;
-Line 4249 
 if (*cc == OP_BRAPOSZERO)
+Line 4896 
 if (*cc == OP_BRAPOSZERO)
    }
  opcode = *cc;
- localptr = PRIV(cc);
+ localptr = PRIV_DATA(cc);
  SLJIT_ASSERT(localptr != 0);
  FALLBACK_AS(bracketpos_fallback)->localptr = localptr;
  switch(opcode)
-Line 4264 
 switch(opcode)
+Line 4911 
 switch(opcode)
    offset = GET2(cc, 1 + LINK_SIZE);
    cbraprivptr = OVECTOR_PRIV(offset);
    offset <<= 1;
-   ccbegin = cc + 1 + LINK_SIZE + 2;
+   ccbegin = cc + 1 + LINK_SIZE + IMM2_SIZE;
    break;
    default:
-Line 4366 
 while (*cc != OP_KETRPOS)
+Line 5013 
 while (*cc != OP_KETRPOS)
      {
      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
        {
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, stacksize * sizeof(sljit_w));
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
-       if (!zero)
-         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
-Line 4376 
 while (*cc != OP_KETRPOS)
+Line 5022 
 while (*cc != OP_KETRPOS)
      else
        {
        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+       OP2(SLJIT_ADD, STACK_TOP, 0, TMP2, 0, SLJIT_IMM, stacksize * sizeof(sljit_w));
        if (opcode == OP_SBRAPOS)
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_w));
        OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_w), STR_PTR, 0);
-Line 4384 
 while (*cc != OP_KETRPOS)
+Line 5031 
 while (*cc != OP_KETRPOS)
      if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)
        add_jump(compiler, &emptymatch, CMP(SLJIT_C_EQUAL, TMP1, 0, STR_PTR, 0));
-     /* TMP2 must be set above. */
      if (!zero)
        {
        if (framesize < 0)
          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);
        else
-         OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_w), SLJIT_IMM, 0);
+         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
        }
      }
    JUMPTO(SLJIT_JUMP, loop);
-Line 4412 
 while (*cc != OP_KETRPOS)
+Line 5058 
 while (*cc != OP_KETRPOS)
      {
      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
        {
+       /* Last alternative. */
        if (*cc == OP_KETRPOS)
          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
-Line 4443 
 decrease_call_count(common);
+Line 5090 
 decrease_call_count(common);
  return cc + 1 + LINK_SIZE;
  }
- static SLJIT_INLINE uschar *get_iterator_parameters(compiler_common *common, uschar *cc, uschar *opcode, uschar *type, int *arg1, int *arg2, uschar **end)
+ static SLJIT_INLINE pcre_uchar *get_iterator_parameters(compiler_common *common, pcre_uchar *cc, pcre_uchar *opcode, pcre_uchar *type, int *arg1, int *arg2, pcre_uchar **end)
  {
  int class_len;
-Line 4482 
 else
+Line 5129 
 else
    SLJIT_ASSERT(*opcode >= OP_CLASS || *opcode <= OP_XCLASS);
    *type = *opcode;
    cc++;
-   class_len = (*type < OP_XCLASS) ? 33 : GET(cc, 0);
+   class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
    *opcode = cc[class_len - 1];
    if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)
      {
-Line 4493 
 else
+Line 5140 
 else
    else
      {
      SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE);
-     *arg1 = GET2(cc, (class_len + 2));
+     *arg1 = GET2(cc, (class_len + IMM2_SIZE));
      *arg2 = GET2(cc, class_len);
      if (*arg2 == 0)
-Line 4505 
 else
+Line 5152 
 else
        *opcode = OP_EXACT;
      if (end != NULL)
-       *end = cc + class_len + 4;
+       *end = cc + class_len + 2 * IMM2_SIZE;
      }
    return cc;
    }
-Line 4513 
 else
+Line 5160 
 else
  if (*opcode == OP_UPTO || *opcode == OP_MINUPTO || *opcode == OP_EXACT || *opcode == OP_POSUPTO)
    {
    *arg1 = GET2(cc, 0);
-   cc += 2;
+   cc += IMM2_SIZE;
    }
  if (*type == 0)
-Line 4528 
 if (*type == 0)
+Line 5175 
 if (*type == 0)
  if (end != NULL)
    {
    *end = cc + 1;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   if (common->utf8 && *cc >= 0xc0) *end += _pcre_utf8_table4[*cc & 0x3f];
+   if (common->utf && HAS_EXTRALEN(*cc)) *end += GET_EXTRALEN(*cc);
  #endif
    }
  return cc;
  }
- static uschar *compile_iterator_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
+ static pcre_uchar *compile_iterator_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
  {
  DEFINE_COMPILER;
  fallback_common *fallback;
- uschar opcode;
+ pcre_uchar opcode;
- uschar type;
+ pcre_uchar type;
  int arg1 = -1, arg2 = -1;
- uschar* end;
+ pcre_uchar* end;
  jump_list *nomatch = NULL;
  struct sljit_jump *jump = NULL;
  struct sljit_label *label;
-Line 4704 
 decrease_call_count(common);
+Line 5351 
 decrease_call_count(common);
  return end;
  }
- static SLJIT_INLINE uschar *compile_fail_accept_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_fail_accept_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
  {
  DEFINE_COMPILER;
  fallback_common *fallback;
-Line 4748 
 add_jump(compiler, &fallback->topfallbac
+Line 5395 
 add_jump(compiler, &fallback->topfallbac
  return cc + 1;
  }
- static SLJIT_INLINE uschar *compile_close_hotpath(compiler_common *common, uschar *cc)
+ static SLJIT_INLINE pcre_uchar *compile_close_hotpath(compiler_common *common, pcre_uchar *cc)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1);
  /* Data will be discarded anyway... */
  if (common->currententry != NULL)
-   return cc + 3;
+   return cc + 1 + IMM2_SIZE;
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR_PRIV(offset));
  offset <<= 1;
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
- return cc + 3;
+ return cc + 1 + IMM2_SIZE;
  }
- static void compile_hotpath(compiler_common *common, uschar *cc, uschar *ccend, fallback_common *parent)
+ static void compile_hotpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, fallback_common *parent)
  {
  DEFINE_COMPILER;
  fallback_common *fallback;
-Line 4785 
 while (cc < ccend)
+Line 5432 
 while (cc < ccend)
      case OP_WORDCHAR:
      case OP_ANY:
      case OP_ALLANY:
+     case OP_ANYBYTE:
      case OP_NOTPROP:
      case OP_PROP:
      case OP_ANYNL:
-Line 4816 
 while (cc < ccend)
+Line 5464 
 while (cc < ccend)
      case OP_CHAR:
      case OP_CHARI:
-     cc = compile_charn_hotpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+     if (common->mode == JIT_COMPILE)
+       cc = compile_charn_hotpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+     else
+       cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
      break;
      case OP_STAR:
-Line 4889 
 while (cc < ccend)
+Line 5540 
 while (cc < ccend)
      case OP_CLASS:
      case OP_NCLASS:
-     if (cc[33] >= OP_CRSTAR && cc[33] <= OP_CRMINRANGE)
+     if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRMINRANGE)
        cc = compile_iterator_hotpath(common, cc, parent);
      else
        cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
      break;
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16
      case OP_XCLASS:
      if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRMINRANGE)
        cc = compile_iterator_hotpath(common, cc, parent);
-Line 4906 
 while (cc < ccend)
+Line 5557 
 while (cc < ccend)
      case OP_REF:
      case OP_REFI:
-     if (cc[3] >= OP_CRSTAR && cc[3] <= OP_CRMINRANGE)
+     if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRMINRANGE)
        cc = compile_ref_iterator_hotpath(common, cc, parent);
      else
        cc = compile_ref_hotpath(common, cc, parent->top != NULL ? &parent->top->next