/[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 860 by zherczeg,
Mon Jan  9 20:12:58 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 {
    void *executable_func;
-   pcre_jit_callback callback;
+   PUBL(jit_callback) callback;
    void *userdata;
+   sljit_uw executable_size;
  } executable_function;
  typedef struct jump_list {
-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 nltype;
-Line 276 
 typedef struct compiler_common {
+Line 280 
 typedef struct compiler_common {
    int bsr_nltype;
    int endonly;
    sljit_w ctypes;
+   sljit_uw name_table;
+   sljit_w name_count;
+   sljit_w name_entry_size;
    struct sljit_label *acceptlabel;
    stub_list *stubs;
    recurse_entry *entries;
-Line 291 
 typedef struct compiler_common {
+Line 298 
 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 319 
 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 352 
 enum {
+Line 373 
 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. */
- #define REQ_BYTE_PTR     (8 * sizeof(sljit_w))
+ #define REQ_CHAR_PTR     (6 * sizeof(sljit_w))
  /* End pointer of the first line. */
- #define FIRSTLINE_END    (9 * sizeof(sljit_w))
+ #define FIRSTLINE_END    (7 * sizeof(sljit_w))
  /* The output vector is stored on the stack, and contains pointers
  to characters. The vector data is divided into two groups: the first
  group contains the start / end character pointers, and the second is
  the start pointers when the end of the capturing group has not yet reached. */
- #define OVECTOR_START    (10 * sizeof(sljit_w))
+ #define OVECTOR_START    (8 * 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 424 
 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 445 
 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 500 
 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 547 
 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 568 
 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 585 
 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 612 
 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 630 
 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 651 
 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 663 
 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 684 
 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 697 
 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 711 
 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 734 
 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 762 
 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 777 
 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_ASSERT(stackpos >= stacktop + 2);
-   SLJIT_ASSERT(stackpos + 1 == stacktop);
-   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 816 
 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 830 
 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 840 
 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 857 
 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 869 
 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 896 
 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 905 
 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 960 
 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 975 
 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 993 
 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 1201 
 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_GENERAL_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
  if (length < 8)
    {
    for (i = 0; i < length; i++)
-Line 1233 
 loop = LABEL();
+Line 1239 
 loop = LABEL();
  OP2(SLJIT_SUB, SLJIT_GENERAL_REG2, 0, SLJIT_MEM1(SLJIT_GENERAL_REG1), 0, SLJIT_TEMPORARY_REG1, 0);
  OP2(SLJIT_ADD, SLJIT_GENERAL_REG1, 0, SLJIT_GENERAL_REG1, 0, SLJIT_IMM, sizeof(sljit_w));
  /* Copy the integer value to the output buffer */
+ #ifdef COMPILE_PCRE16
+ OP2(SLJIT_ASHR, SLJIT_GENERAL_REG2, 0, SLJIT_GENERAL_REG2, 0, SLJIT_IMM, 1);
+ #endif
  OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG3), sizeof(int), SLJIT_GENERAL_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);
-Line 1246 
 if (topbracket > 1)
+Line 1255 
 if (topbracket > 1)
    /* OVECTOR(0) is never equal to SLJIT_GENERAL_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);
    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_TEMPORARY_REG2, 0);
-Line 1255 
 else
+Line 1264 
 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 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 1281 
 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 1304 
 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 1333 
 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 1351 
 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 1364 
 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)
-Line 1365 
 static void read_char(compiler_common *c
+Line 1396 
 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 1423 
 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 1449 
 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 1549 
 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 1568 
 sljit_emit_fast_enter(compiler, RETURN_A
  /* Searching for the first zero. */
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
  jump = JUMP(SLJIT_C_NOT_ZERO);
- /* 2 byte sequence */
+ /* Two byte sequence. */
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1f);
  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(jump);
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10);
  jump = JUMP(SLJIT_C_NOT_ZERO);
- /* 3 byte sequence */
+ /* Three byte sequence. */
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0f);
  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12);
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 2);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 2);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(jump);
- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x08);
+ /* Four byte sequence. */
- jump = JUMP(SLJIT_C_NOT_ZERO);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
- /* 4 byte sequence */
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x07);
  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 18);
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 3);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(3));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 3);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 3);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));
- sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
- JUMPHERE(jump);
- /* 5 byte sequence */
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x03);
- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 24);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 18);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 3);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 4);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 4);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 4);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
- static void do_utf8readtype8(compiler_common *common)
+ static void do_utfreadtype8(compiler_common *common)
  {
- /* Fast decoding an utf8 character type. TMP2 contains the first byte
+ /* Fast decoding a UTF-8 character type. TMP2 contains the first byte
- of the character (>= 192) and TMP1 is destroyed. Return value in TMP1. */
+ of the character (>= 0xc0). Return value in TMP1. */
  DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_jump *compare;
-Line 1573 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 1627 
 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 1644 
 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 1699 
 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 1719 
 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 1739 
 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 1769 
 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 1784 
 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 1828 
 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 1844 
 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 1875 
 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 1928 
 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 1971 
 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 1994 
 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 2006 
 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 2023 
 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 2055 
 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 2064 
 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 2120 
 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 2139 
 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 2011 
 static void check_wordboundary(compiler_
+Line 2159 
 static void check_wordboundary(compiler_
  {
  DEFINE_COMPILER;
  struct sljit_jump *beginend;
- #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. */
-Line 2028 
 read_char(common);
+Line 2176 
 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 2193 
 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);
-Line 2068 
 peek_char(common);
+Line 2220 
 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 2236 
 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);
-Line 2115 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
+Line 2273 
 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 2301 
 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 2319 
 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 2339 
 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 2369 
 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 2401 
 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 2435 
 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)
    {
-Line 2276 
 while (src1 < end1)
+Line 2455 
 while (src1 < end1)
  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 2472 
 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 2606 
 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 2637 
 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 2645 
 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);
  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 2676 
 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 2698 
 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 2708 
 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 2783 
 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 2813 
 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 2844 
 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 2853 
 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 2910 
 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 2974 
 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 2814 
 switch(type)
+Line 3039 
 switch(type)
      {
      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 2825 
 switch(type)
+Line 3050 
 switch(type)
    case OP_ALLANY:
    check_input_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:
+   check_input_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 2856 
 switch(type)
+Line 3100 
 switch(type)
    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 2908 
 switch(type)
+Line 3152 
 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 2977 
 switch(type)
+Line 3222 
 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_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 3019 
 switch(type)
+Line 3262 
 switch(type)
    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 3280 
 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)
      {
-     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));
+   check_input_end(common, fallbacks);
    read_char(common);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   if (common->utf8)
+   if (common->utf)
      {
      GETCHAR(c, cc);
      }
-Line 3071 
 switch(type)
+Line 3314 
 switch(type)
    case OP_NOT:
    case OP_NOTI:
+   check_input_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 3371 
 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);
    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 3392 
 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 3415 
 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;
      }
  #endif
-   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, length);
+   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));
    return cc + LINK_SIZE;
    }
-Line 3186 
 SLJIT_ASSERT_STOP();
+Line 3437 
 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 3455 
 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 3480 
 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 3493 
 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 3503 
 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 3274 
 return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT
+Line 3525 
 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 3305 
 static void compile_fallbackpath(compile
+Line 3556 
 static void compile_fallbackpath(compile
  #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;
-Line 3315 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT
+Line 3566 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT
  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 3578 
 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));
    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)
-Line 3354 
 if (jump != NULL)
+Line 3603 
 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 3628 
 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 3750 
 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 3796 
 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 3820 
 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 3879 
 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 3913 
 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 3943 
 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 3955 
 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 3964 
 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 3986 
 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 4034 
 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 4043 
 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 4066 
 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 4222 
 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 4259 
 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 4272 
 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 4301 
 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 4458 
 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 4567 
 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 4225 
 cc += 1 + LINK_SIZE;
+Line 4668 
 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 4692 
 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 4707 
 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 4809 
 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 4818 
 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 4827 
 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 4854 
 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 4886 
 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 4925 
 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) ? (1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
    *opcode = cc[class_len - 1];
    if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)
      {
-Line 4493 
 else
+Line 4936 
 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 4948 
 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 4956 
 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 4971 
 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 5147 
 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 5191 
 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 5228 
 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 4889 
 while (cc < ccend)
+Line 5333 
 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 5350 
 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->nextfallbacks : &parent->topfallbacks, TRUE, FALSE);
-Line 4944 
 while (cc < ccend)
+Line 5388 
 while (cc < ccend)
      break;
      case OP_ONCE:
+     case OP_ONCE_NC:
      case OP_BRA:
      case OP_CBRA:
      case OP_COND:
-Line 5013 
 SLJIT_ASSERT(cc == ccend);
+Line 5458 
 SLJIT_ASSERT(cc == ccend);
  static void compile_iterator_fallbackpath(compiler_common *common, struct fallback_common *current)
  {
  DEFINE_COMPILER;
- uschar *cc = current->cc;
+ pcre_uchar *cc = current->cc;
- uschar opcode;
+ pcre_uchar opcode;
- uschar type;
+ pcre_uchar type;
  int arg1 = -1, arg2 = -1;
  struct sljit_label *label = NULL;
  struct sljit_jump *jump = NULL;
-Line 5140 
 switch(opcode)
+Line 5585 
 switch(opcode)
  static void compile_ref_iterator_fallbackpath(compiler_common *common, struct fallback_common *current)
  {
  DEFINE_COMPILER;
- uschar *cc = current->cc;
+ pcre_uchar *cc = current->cc;
- uschar type;
+ pcre_uchar type;
- type = cc[3];
+ type = cc[1 + IMM2_SIZE];
  if ((type & 0x1) == 0)
    {
    set_jumps(current->topfallbacks, LABEL());
-Line 5172 
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_R
+Line 5617 
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_R
  static void compile_assert_fallbackpath(compiler_common *common, struct fallback_common *current)
  {
  DEFINE_COMPILER;
- uschar *cc = current->cc;
+ pcre_uchar *cc = current->cc;
- uschar bra = OP_BRA;
+ pcre_uchar bra = OP_BRA;
- struct sljit_jump *jump;
  struct sljit_jump *brajump = NULL;
  SLJIT_ASSERT(*cc != OP_BRAMINZERO);
-Line 5220 
 if (*cc == OP_ASSERT || *cc == OP_ASSERT
+Line 5664 
 if (*cc == OP_ASSERT || *cc == OP_ASSERT
    {
    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr);
    add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(assert_fallback)->framesize * sizeof(sljit_w));
    set_jumps(current->topfallbacks, LABEL());
    }
  else
-   {
-   jump = JUMP(SLJIT_JUMP);
    set_jumps(current->topfallbacks, LABEL());
-   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr);
-   add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-   JUMPHERE(jump);
-   }
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(assert_fallback)->framesize * sizeof(sljit_w));
  if (bra == OP_BRAZERO)
    {
-Line 5252 
 int offset = 0;
+Line 5689 
 int offset = 0;
  int localptr = CURRENT_AS(bracket_fallback)->localptr;
  int stacksize;
  int count;
- uschar *cc = current->cc;
+ pcre_uchar *cc = current->cc;
- uschar *ccbegin;
+ pcre_uchar *ccbegin;
- uschar *ccprev;
+ pcre_uchar *ccprev;
  jump_list *jumplist = NULL;
  jump_list *jumplistitem = NULL;
- uschar bra = OP_BRA;
+ pcre_uchar bra = OP_BRA;
- uschar ket;
+ pcre_uchar ket;
  assert_fallback *assert;
+ BOOL has_alternatives;
  struct sljit_jump *brazero = NULL;
  struct sljit_jump *once = NULL;
  struct sljit_jump *cond = NULL;
-Line 5275 
 opcode = *cc;
+Line 5713 
 opcode = *cc;
  ccbegin = cc;
  ket = *(bracketend(ccbegin) - 1 - LINK_SIZE);
  cc += GET(cc, 1);
+ has_alternatives = *cc == OP_ALT;
+ if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
+   has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_fallback)->u.condfailed != NULL;
  if (opcode == OP_CBRA || opcode == OP_SCBRA)
    offset = (GET2(ccbegin, 1 + LINK_SIZE)) << 1;
  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 (ket == OP_KETRMAX)
    {
-Line 5321 
 else if (bra == OP_BRAZERO)
+Line 5764 
 else if (bra == OP_BRAZERO)
    brazero = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
    }
- if (opcode == OP_ONCE)
+ if (SLJIT_UNLIKELY(opcode == OP_ONCE))
    {
    if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)
      {
-Line 5330 
 if (opcode == OP_ONCE)
+Line 5773 
 if (opcode == OP_ONCE)
      }
    once = JUMP(SLJIT_JUMP);
    }
+ else if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
+   {
+   if (has_alternatives)
+     {
+     /* Always exactly one alternative. */
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+     free_stack(common, 1);
+     jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));
+     if (SLJIT_UNLIKELY(!jumplistitem))
+       return;
+     jumplist = jumplistitem;
+     jumplistitem->next = NULL;
+     jumplistitem->jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 1);
+     }
+   }
  else if (*cc == OP_ALT)
    {
    /* Build a jump list. Get the last successfully matched branch index. */
-Line 5361 
 else if (*cc == OP_ALT)
+Line 5820 
 else if (*cc == OP_ALT)
    cc = ccbegin + GET(ccbegin, 1);
    }
- else if (opcode == OP_COND || opcode == OP_SCOND)
-   {
-   /* Always one. */
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-   free_stack(common, 1);
-   jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));
-   if (SLJIT_UNLIKELY(!jumplistitem))
-     return;
-   jumplist = jumplistitem;
-   jumplistitem->next = NULL;
-   jumplistitem->jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 1);
-   }
  COMPILE_FALLBACKPATH(current->top);
  if (current->topfallbacks)
    set_jumps(current->topfallbacks, LABEL());
- if (opcode == OP_COND || opcode == OP_SCOND)
+ if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
    {
    /* Conditional block always has at most one alternative. */
    if (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT)
      {
+     SLJIT_ASSERT(has_alternatives);
      assert = CURRENT_AS(bracket_fallback)->u.assert;
      if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK))
        {
-Line 5394 
 if (opcode == OP_COND || opcode == OP_SC
+Line 5841 
 if (opcode == OP_COND || opcode == OP_SC
      cond = JUMP(SLJIT_JUMP);
      set_jumps(CURRENT_AS(bracket_fallback)->u.assert->condfailed, LABEL());
      }
-   else
+   else if (CURRENT_AS(bracket_fallback)->u.condfailed != NULL)
      {
+     SLJIT_ASSERT(has_alternatives);
      cond = JUMP(SLJIT_JUMP);
      set_jumps(CURRENT_AS(bracket_fallback)->u.condfailed, LABEL());
      }
+   else
+     SLJIT_ASSERT(!has_alternatives);
    }
- if (*cc == OP_ALT || opcode == OP_COND || opcode == OP_SCOND)
+ if (has_alternatives)
    {
    count = 1;
    do
-Line 5429 
 if (*cc == OP_ALT || opcode == OP_COND |
+Line 5879 
 if (*cc == OP_ALT || opcode == OP_COND |
      /* There is a similar code in compile_bracket_hotpath. */
      if (opcode == OP_ONCE)
        {
-       if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)
+       if (CURRENT_AS(bracket_fallback)->u.framesize < 0)
          {
+         OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+         /* TMP2 which is set here used by OP_KETRMAX below. */
          if (ket == OP_KETRMAX)
+           OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
+         else if (ket == OP_KETRMIN)
            {
-           OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+           /* Move the STR_PTR to the localptr. */
-           OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), (CURRENT_AS(bracket_fallback)->u.framesize + 1) * sizeof(sljit_w));
+           OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), 0);
            }
          }
        else
          {
-         OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+         OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (CURRENT_AS(bracket_fallback)->u.framesize + 2) * sizeof(sljit_w));
-         /* The register which is set here used by OP_KETRMAX below. */
          if (ket == OP_KETRMAX)
-           OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
+           {
-         else if (ket == OP_KETRMIN)
+           /* TMP2 which is set here used by OP_KETRMAX below. */
-           OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), 0);
+           OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+           }
          }
        }
-Line 5506 
 if (*cc == OP_ALT || opcode == OP_COND |
+Line 5960 
 if (*cc == OP_ALT || opcode == OP_COND |
      {
      SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);
      assert = CURRENT_AS(bracket_fallback)->u.assert;
-     if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT))
+     if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)
        {
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr);
        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-Line 5542 
 else if (opcode == OP_ONCE)
+Line 5997 
 else if (opcode == OP_ONCE)
      {
      /* Reset head and drop saved frame. */
      stacksize = (ket == OP_KETRMAX || ket == OP_KETRMIN || *cc == OP_ALT) ? 2 : 1;
-     if (CURRENT_AS(bracket_fallback)->u.framesize > 0)
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(stacksize));
      free_stack(common, CURRENT_AS(bracket_fallback)->u.framesize + stacksize);
-     if (CURRENT_AS(bracket_fallback)->u.framesize > 0)
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD, TMP1, 0);
      }
    else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
      {
-Line 5630 
 if (current->topfallbacks)
+Line 6081 
 if (current->topfallbacks)
    {
    jump = JUMP(SLJIT_JUMP);
    set_jumps(current->topfallbacks, LABEL());
-   /* Drop the stack frame and restore LOCALS_HEAD. */
+   /* Drop the stack frame. */
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(CURRENT_AS(bracketpos_fallback)->stacksize - CURRENT_AS(bracketpos_fallback)->framesize));
    free_stack(common, CURRENT_AS(bracketpos_fallback)->stacksize);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD, TMP1, 0);
    JUMPHERE(jump);
    }
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_fallback)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracketpos_fallback)->framesize * sizeof(sljit_w));
-Line 5746 
 while (current)
+Line 6195 
 while (current)
      case OP_TYPEPOSUPTO:
      case OP_CLASS:
      case OP_NCLASS:
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
      case OP_XCLASS:
+ #endif
      compile_iterator_fallbackpath(common, current);
      break;
-Line 5767 
 while (current)
+Line 6218 
 while (current)
      break;
      case OP_ONCE:
+     case OP_ONCE_NC:
      case OP_BRA:
      case OP_CBRA:
      case OP_COND:
-Line 5812 
 while (current)
+Line 6264 
 while (current)
  static SLJIT_INLINE void compile_recurse(compiler_common *common)
  {
  DEFINE_COMPILER;
- uschar *cc = common->start + common->currententry->start;
+ pcre_uchar *cc = common->start + common->currententry->start;
- uschar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : 2);
+ pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);
- uschar *ccend = bracketend(cc);
+ pcre_uchar *ccend = bracketend(cc);
  int localsize = get_localsize(common, ccbegin, ccend);
  int framesize = get_framesize(common, cc, TRUE);
  int alternativesize;
-Line 5838 
 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), ST
+Line 6290 
 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), ST
  copy_locals(common, ccbegin, ccend, TRUE, localsize + framesize + alternativesize, framesize + alternativesize);
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), RECURSIVE_HEAD, STACK_TOP, 0);
  if (needsframe)
-   {
-   OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(framesize + alternativesize - 1));
    init_frame(common, cc, framesize + alternativesize - 1, alternativesize, FALSE);
-   }
  if (alternativesize > 0)
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
-Line 5878 
 while (1)
+Line 6327 
 while (1)
    }
  /* None of them matched. */
  OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
- if (needsframe)
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD, SLJIT_MEM1(STACK_TOP), STACK(alternativesize));
  jump = JUMP(SLJIT_JUMP);
  set_jumps(common->accept, LABEL());
-Line 5887 
 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(
+Line 6334 
 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(
  if (needsframe)
    {
    OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
-   OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (localsize + framesize + alternativesize) * sizeof(sljit_w));
+   OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_w));
    add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-   OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (localsize + framesize + alternativesize) * sizeof(sljit_w));
+   OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_w));
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP3, 0);
    }
  OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);
-Line 5907 
 sljit_emit_fast_return(compiler, SLJIT_M
+Line 6354 
 sljit_emit_fast_return(compiler, SLJIT_M
  #undef CURRENT_AS
  void
- _pcre_jit_compile(const real_pcre *re, pcre_extra *extra)
+ PRIV(jit_compile)(const REAL_PCRE *re, PUBL(extra) *extra)
  {
  struct sljit_compiler *compiler;
  fallback_common rootfallback;
  compiler_common common_data;
  compiler_common *common = &common_data;
- const unsigned char *tables = re->tables;
+ const pcre_uint8 *tables = re->tables;
  pcre_study_data *study;
- uschar *ccend;
+ pcre_uchar *ccend;
  executable_function *function;
  void *executable_func;
+ sljit_uw executable_size;
  struct sljit_label *leave;
  struct sljit_label *mainloop = NULL;
  struct sljit_label *empty_match_found;
-Line 5930 
 SLJIT_ASSERT((extra->flags & PCRE_EXTRA_
+Line 6378 
 SLJIT_ASSERT((extra->flags & PCRE_EXTRA_
  study = extra->study_data;
  if (!tables)
-   tables = _pcre_default_tables;
+   tables = PRIV(default_tables);
  memset(&rootfallback, 0, sizeof(fallback_common));
- rootfallback.cc = (uschar *)re + re->name_table_offset + re->name_count * re->name_entry_size;
+ rootfallback.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;
  common->compiler = NULL;
  common->start = rootfallback.cc;
-Line 5974 
 else
+Line 6422 
 else
    }
  common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
  common->ctypes = (sljit_w)(tables + ctypes_offset);
+ common->name_table = (sljit_w)((pcre_uchar *)re + re->name_table_offset);
+ common->name_count = re->name_count;
+ common->name_entry_size = re->name_entry_size;
  common->acceptlabel = NULL;
  common->stubs = NULL;
  common->entries = NULL;
-Line 5989 
 common->vspace = NULL;
+Line 6440 
 common->vspace = NULL;
  common->casefulcmp = NULL;
  common->caselesscmp = NULL;
  common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- common->utf8 = (re->options & PCRE_UTF8) != 0;
+ /* PCRE_UTF16 has the same value as PCRE_UTF8. */
+ common->utf = (re->options & PCRE_UTF8) != 0;
  #ifdef SUPPORT_UCP
- common->useucp = (re->options & PCRE_UCP) != 0;
+ common->use_ucp = (re->options & PCRE_UCP) != 0;
  #endif
- common->utf8readchar = NULL;
+ common->utfreadchar = NULL;
- common->utf8readtype8 = NULL;
+ #ifdef COMPILE_PCRE8
+ common->utfreadtype8 = NULL;
  #endif
+ #endif /* SUPPORT_UTF */
  #ifdef SUPPORT_UCP
  common->getucd = NULL;
  #endif
-Line 6028 
 sljit_emit_enter(compiler, 1, 5, 5, comm
+Line 6482 
 sljit_emit_enter(compiler, 1, 5, 5, comm
  /* Register init. */
  reset_ovector(common, (re->top_bracket + 1) * 2);
  if ((re->flags & PCRE_REQCHSET) != 0)
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_BYTE_PTR, SLJIT_TEMPORARY_REG1, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_CHAR_PTR, SLJIT_TEMPORARY_REG1, 0);
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS_HEAD, SLJIT_IMM, 0);
  OP1(SLJIT_MOV, ARGUMENTS, 0, SLJIT_GENERAL_REG1, 0);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_GENERAL_REG1, 0);
-Line 6047 
 if ((re->options & PCRE_ANCHORED) == 0)
+Line 6500 
 if ((re->options & PCRE_ANCHORED) == 0)
    mainloop = mainloop_entry(common, (re->flags & PCRE_HASCRORLF) != 0, (re->options & PCRE_FIRSTLINE) != 0);
    /* Forward search if possible. */
    if ((re->flags & PCRE_FIRSTSET) != 0)
-     fast_forward_first_byte(common, re->first_byte, (re->options & PCRE_FIRSTLINE) != 0);
+     fast_forward_first_char(common, re->first_char, (re->flags & PCRE_FCH_CASELESS) != 0, (re->options & PCRE_FIRSTLINE) != 0);
    else if ((re->flags & PCRE_STARTLINE) != 0)