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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1316 by zherczeg,
Sun Apr 28 08:54:42 2013 UTC
+revision 1421 by zherczeg,
Mon Dec 30 13:25:20 2013 UTC
 Line 211 
 typedef int (SLJIT_CALL *jit_function)(j
  /* The following structure is the key data type for the recursive
  code generator. It is allocated by compile_matchingpath, and contains
- the aguments for compile_backtrackingpath. Must be the first member
+ the arguments for compile_backtrackingpath. Must be the first member
  of its descendants. */
  typedef struct backtrack_common {
    /* Concatenation stack. */
 Line 306 
 typedef struct then_trap_backtrack {
    int framesize;
  } then_trap_backtrack;
- #define MAX_RANGE_SIZE 6
+ #define MAX_RANGE_SIZE 4
  typedef struct compiler_common {
    /* The sljit ceneric compiler. */
 Line 369 
 typedef struct compiler_common {
    int endonly;
    /* Tables. */
    sljit_sw ctypes;
-   int digits[2 + MAX_RANGE_SIZE];
    /* Named capturing brackets. */
-   sljit_uw name_table;
+   pcre_uchar *name_table;
    sljit_sw name_count;
    sljit_sw name_entry_size;
-Line 408 
 typedef struct compiler_common {
+Line 407 
 typedef struct compiler_common {
    jump_list *utfreadchar;
  #endif
  #ifdef COMPILE_PCRE8
+   jump_list *utfreadchar11;
    jump_list *utfreadtype8;
  #endif
  #endif /* SUPPORT_UTF */
 Line 481 
 to characters. The vector data is divide
  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    (common->ovector_start)
- #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_sw))
+ #define OVECTOR(i)       (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw))
- #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * sizeof(sljit_sw))
+ #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))
  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
  #if defined COMPILE_PCRE8
 Line 533 
 cc += 1 + LINK_SIZE;
  return cc;
  }
+ static int ones_in_half_byte[16] = {
+   /* 0 */ 0, 1, 1, 2, /* 4 */ 1, 2, 2, 3,
+   /* 8 */ 1, 2, 2, 3, /* 12 */ 2, 3, 3, 4
+ };
  /* Functions whose might need modification for all new supported opcodes:
   next_opcode
   check_opcode_types
-Line 585 
 switch(*cc)
+Line 590 
 switch(*cc)
    case OP_CRMINQUERY:
    case OP_CRRANGE:
    case OP_CRMINRANGE:
+   case OP_CRPOSSTAR:
+   case OP_CRPOSPLUS:
+   case OP_CRPOSQUERY:
+   case OP_CRPOSRANGE:
    case OP_CLASS:
    case OP_NCLASS:
    case OP_REF:
    case OP_REFI:
+   case OP_DNREF:
+   case OP_DNREFI:
    case OP_RECURSE:
    case OP_CALLOUT:
    case OP_ALT:
-Line 614 
 switch(*cc)
+Line 625 
 switch(*cc)
    case OP_SCBRAPOS:
    case OP_SCOND:
    case OP_CREF:
-   case OP_NCREF:
+   case OP_DNCREF:
    case OP_RREF:
-   case OP_NRREF:
+   case OP_DNRREF:
    case OP_DEF:
    case OP_BRAZERO:
    case OP_BRAMINZERO:
-Line 736 
 switch(*cc)
+Line 747 
 switch(*cc)
  static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
  {
- pcre_uchar *name;
+ int count;
- pcre_uchar *name2;
+ pcre_uchar *slot;
- unsigned int cbra_index;
- int i;
  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
-Line 773 
 while (cc < ccend)
+Line 782 
 while (cc < ccend)
      break;
      case OP_CREF:
-     i = GET2(cc, 1);
+     common->optimized_cbracket[GET2(cc, 1)] = 0;
-     common->optimized_cbracket[i] = 0;
      cc += 1 + IMM2_SIZE;
      break;
-     case OP_NCREF:
+     case OP_DNREF:
-     cbra_index = GET2(cc, 1);
+     case OP_DNREFI:
-     name = (pcre_uchar *)common->name_table;
+     case OP_DNCREF:
-     name2 = name;
+     count = GET2(cc, 1 + IMM2_SIZE);
-     for (i = 0; i < common->name_count; i++)
+     slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
-       {
+     while (count-- > 0)
-       if (GET2(name, 0) == cbra_index) break;
+       {
-       name += common->name_entry_size;
+       common->optimized_cbracket[GET2(slot, 0)] = 0;
-       }
+       slot += common->name_entry_size;
-     SLJIT_ASSERT(i != common->name_count);
-     for (i = 0; i < common->name_count; i++)
-       {
-       if (STRCMP_UC_UC(name2 + IMM2_SIZE, name + IMM2_SIZE) == 0)
-         common->optimized_cbracket[GET2(name2, 0)] = 0;
-       name2 += common->name_entry_size;
        }
-     cc += 1 + IMM2_SIZE;
+     cc += 1 + 2 * IMM2_SIZE;
      break;
      case OP_RECURSE:
-Line 2374 
 return (bit < 256) ? ((0 << 8) | bit) :
+Line 2375 
 return (bit < 256) ? ((0 << 8) | bit) :
  static void check_partial(compiler_common *common, BOOL force)
  {
- /* Checks whether a partial matching is occured. Does not modify registers. */
+ /* Checks whether a partial matching is occurred. Does not modify registers. */
  DEFINE_COMPILER;
  struct sljit_jump *jump = NULL;
-Line 2471 
 struct sljit_jump *jump;
+Line 2472 
 struct sljit_jump *jump;
  #endif
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  if (common->utf)
    {
-Line 2483 
 if (common->utf)
+Line 2485 
 if (common->utf)
    JUMPHERE(jump);
    }
  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  }
  static void peek_char(compiler_common *common)
-Line 2504 
 if (common->utf)
+Line 2505 
 if (common->utf)
  #elif defined COMPILE_PCRE16
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
  #endif /* COMPILE_PCRE[8|16] */
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
    JUMPHERE(jump);
-Line 2511 
 if (common->utf)
+Line 2513 
 if (common->utf)
  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  }
- static void read_char8_type(compiler_common *common)
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ static BOOL is_char7_bitset(const pcre_uint8* bitset, BOOL nclass)
+ {
+ const pcre_uint8 value = nclass ? 0xff : 0;
+ const pcre_uint8* end = bitset + 32;
+ bitset += 16;
+ do
+   {
+   if (*bitset++ != value)
+     return FALSE;
+   }
+ while (bitset < end);
+ return TRUE;
+ }
+ static void read_char7_type(compiler_common *common, BOOL full_read)
+ {
+ /* Reads the precise character type of a character into TMP1, if the character is
+ less than 128. Otherwise it returns with zero. */
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ SLJIT_ASSERT(common->utf);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+ if (full_read)
+   {
+   jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
+   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+   JUMPHERE(jump);
+   }
+ }
+ #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
+ static void read_char_max(compiler_common *common, pcre_uint32 max, BOOL full_read)
+ {
+ /* Reads the precise value of a character into TMP1, if the character is
+ less than or equal to max. Otherwise it returns with a value greater than max. */
+ DEFINE_COMPILER;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ struct sljit_jump *jump;
+ #endif
+ SLJIT_UNUSED_ARG(full_read);
+ SLJIT_UNUSED_ARG(max);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ if (common->utf)
+   {
+   if (max < 128 && !full_read)
+     return;
+   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+   if (max < 128)
+     {
+     OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+     }
+   else if (max < 0x400)
+     {
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+     if (!full_read)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+     else
+       OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+     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);
+     if (full_read)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+     }
+   else
+     add_jump(compiler, (max < 0x800) ? &common->utfreadchar11 : &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
+   JUMPHERE(jump);
+   }
+ #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   if (max < 0xd800 && !full_read)
+     return;
+   if (max >= 0x10000)
+     {
+     jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+     add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
+     JUMPHERE(jump);
+     return;
+     }
+   /* Skip low surrogate if necessary. */
+   OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+   if (full_read)
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   if (max >= 0xd800)
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000);
+   JUMPHERE(jump);
+   }
+ #endif
+ }
+ static void read_char8_type(compiler_common *common, BOOL full_read)
  {
  /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
  DEFINE_COMPILER;
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
  struct sljit_jump *jump;
  #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ struct sljit_jump *jump2;
+ #endif
- #ifdef SUPPORT_UTF
+ SLJIT_UNUSED_ARG(full_read);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
  if (common->utf)
    {
-   OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #if defined COMPILE_PCRE8
    /* This can be an extra read in some situations, but hopefully
    it is needed in most cases. */
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
    jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
-   add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
+   if (!full_read)
-   JUMPHERE(jump);
+     {
- #elif defined COMPILE_PCRE16
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
+     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
-   JUMPHERE(jump);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
-   /* Skip low surrogate if necessary. */
+     OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
-   OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);
+     jump2 = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
-   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
-   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+     JUMPHERE(jump2);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+     }
- #elif defined COMPILE_PCRE32
+   else
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+     add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
-   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
    JUMPHERE(jump);
- #endif /* COMPILE_PCRE[8|16|32] */
    return;
    }
- #endif /* SUPPORT_UTF */
+ #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if !defined COMPILE_PCRE8
- #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  /* 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);
- #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+ #if !defined COMPILE_PCRE8
  JUMPHERE(jump);
  #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf && full_read)
+   {
+   /* Skip low surrogate if necessary. */
+   OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800);
+   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   JUMPHERE(jump);
+   }
+ #endif /* SUPPORT_UTF && COMPILE_PCRE16 */
  }
  static void skip_char_back(compiler_common *common)
-Line 2639 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 2768 
 sljit_emit_fast_enter(compiler, RETURN_A
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
  jump = JUMP(SLJIT_C_NOT_ZERO);
  /* Two byte sequence. */
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
  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, IN_UCHARS(1));
+ 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, 0x10);
  jump = JUMP(SLJIT_C_NOT_ZERO);
  /* Three byte sequence. */
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
  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(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
+ 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(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, IN_UCHARS(2));
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(jump);
  /* Four byte sequence. */
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
  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(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
  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(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(3));
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
  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, IN_UCHARS(3));
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(4));
+ sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+ }
+ static void do_utfreadchar11(compiler_common *common)
+ {
+ /* Fast decoding a UTF-8 character. TMP1 contains the first byte
+ of the character (>= 0xc0). Return value in TMP1. */
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+ OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
+ jump = JUMP(SLJIT_C_NOT_ZERO);
+ /* Two byte sequence. */
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+ 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);
+ sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+ JUMPHERE(jump);
+ OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x800);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 2701 
 jump = JUMP(SLJIT_C_NOT_ZERO);
+Line 2857 
 jump = JUMP(SLJIT_C_NOT_ZERO);
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);
+ /* The upper 5 bits are known at this point. */
+ compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0x3);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
- compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(compare);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
- JUMPHERE(jump);
  /* We only have types for characters less than 256. */
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+ JUMPHERE(jump);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+ OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 2736 
 sljit_emit_fast_return(compiler, RETURN_
+Line 2893 
 sljit_emit_fast_return(compiler, RETURN_
  JUMPHERE(jump);
  /* Combine two 16 bit characters. */
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
  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));
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 2898 
 if (newlinecheck)
+Line 3055 
 if (newlinecheck)
  return mainloop;
  }
- #define MAX_N_CHARS 3
+ static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uint32 *chars, int max_chars)
- static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
  {
- DEFINE_COMPILER;
+ /* Recursive function, which scans prefix literals. */
- struct sljit_label *start;
+ int len, repeat, len_save, consumed = 0;
- struct sljit_jump *quit;
+ pcre_uint32 caseless, chr, mask;
- pcre_uint32 chars[MAX_N_CHARS * 2];
+ pcre_uchar *alternative, *cc_save;
- pcre_uchar *cc = common->start + 1 + LINK_SIZE;
+ BOOL last, any;
- int location = 0;
- pcre_int32 len, c, bit, caseless;
- int must_stop;
- /* We do not support alternatives now. */
- if (*(common->start + GET(common->start, 1)) == OP_ALT)
-   return FALSE;
+ repeat = 1;
  while (TRUE)
    {
+   last = TRUE;
+   any = FALSE;
    caseless = 0;
-   must_stop = 1;
+   switch (*cc)
-   switch(*cc)
      {
-     case OP_CHAR:
-     must_stop = 0;
-     cc++;
-     break;
      case OP_CHARI:
      caseless = 1;
-     must_stop = 0;
+     case OP_CHAR:
+     last = FALSE;
      cc++;
      break;
-Line 2953 
 while (TRUE)
+Line 3099 
 while (TRUE)
      cc++;
      break;
+     case OP_EXACTI:
+     caseless = 1;
      case OP_EXACT:
+     repeat = GET2(cc, 1);
+     last = FALSE;
      cc += 1 + IMM2_SIZE;
      break;
-Line 2964 
 while (TRUE)
+Line 3114 
 while (TRUE)
      cc++;
      break;
-     case OP_EXACTI:
+     case OP_KET:
-     caseless = 1;
+     cc += 1 + LINK_SIZE;
-     cc += 1 + IMM2_SIZE;
+     continue;
+     case OP_ALT:
+     cc += GET(cc, 1);
+     continue;
+     case OP_ONCE:
+     case OP_ONCE_NC:
+     case OP_BRA:
+     case OP_BRAPOS:
+     case OP_CBRA:
+     case OP_CBRAPOS:
+     alternative = cc + GET(cc, 1);
+     while (*alternative == OP_ALT)
+       {
+       max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, max_chars);
+       if (max_chars == 0)
+         return consumed;
+       alternative += GET(alternative, 1);
+       }
+     if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
+       cc += IMM2_SIZE;
+     cc += 1 + LINK_SIZE;
+     continue;
+     case OP_CLASS:
+     case OP_NCLASS:
+     any = TRUE;
+     cc += 1 + 32 / sizeof(pcre_uchar);
      break;
-     default:
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
-     must_stop = 2;
+     case OP_XCLASS:
+     any = TRUE;
+     cc += GET(cc, 1);
      break;
+ #endif
+     case OP_NOT_DIGIT:
+     case OP_DIGIT:
+     case OP_NOT_WHITESPACE:
+     case OP_WHITESPACE:
+     case OP_NOT_WORDCHAR:
+     case OP_WORDCHAR:
+     case OP_ANY:
+     case OP_ALLANY:
+     any = TRUE;
+     cc++;
+     break;
+ #ifdef SUPPORT_UCP
+     case OP_NOTPROP:
+     case OP_PROP:
+     any = TRUE;
+     cc += 1 + 2;
+     break;
+ #endif
+     case OP_TYPEEXACT:
+     repeat = GET2(cc, 1);
+     cc += 1 + IMM2_SIZE;
+     continue;
+     default:
+     return consumed;
      }
-   if (must_stop == 2)
+   if (any)
-       break;
+     {
+ #ifdef SUPPORT_UTF
+     if (common->utf) return consumed;
+ #endif
+ #if defined COMPILE_PCRE8
+     mask = 0xff;
+ #elif defined COMPILE_PCRE16
+     mask = 0xffff;
+ #elif defined COMPILE_PCRE32
+     mask = 0xffffffff;
+ #else
+     SLJIT_ASSERT_STOP();
+ #endif
+     do
+       {
+       chars[0] = mask;
+       chars[1] = mask;
+       if (--max_chars == 0)
+         return consumed;
+       consumed++;
+       chars += 2;
+       }
+     while (--repeat > 0);
+     repeat = 1;
+     continue;
+     }
    len = 1;
  #ifdef SUPPORT_UTF
-   if (common->utf && HAS_EXTRALEN(cc[0])) len += GET_EXTRALEN(cc[0]);
+   if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
  #endif
-   if (caseless && char_has_othercase(common, cc))
+   if (caseless != 0 && char_has_othercase(common, cc))
      {
      caseless = char_get_othercase_bit(common, cc);
      if (caseless == 0)
-       return FALSE;
+       return consumed;
  #ifdef COMPILE_PCRE8
      caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));
  #else
-Line 2999 
 while (TRUE)
+Line 3237 
 while (TRUE)
    else
      caseless = 0;
-   while (len > 0 && location < MAX_N_CHARS * 2)
+   len_save = len;
-     {
+   cc_save = cc;
-     c = *cc;
+   while (TRUE)
-     bit = 0;
+     {
-     if (len == (caseless & 0xff))
+     do
        {
-       bit = caseless >> 8;
+       chr = *cc;
-       c |= bit;
+ #ifdef COMPILE_PCRE32
+       if (SLJIT_UNLIKELY(chr == NOTACHAR))
+         return consumed;
+ #endif
+       mask = 0;
+       if (len == (caseless & 0xff))
+         {
+         mask = caseless >> 8;
+         chr |= mask;
+         }
+       if (chars[0] == NOTACHAR)
+         {
+         chars[0] = chr;
+         chars[1] = mask;
+         }
+       else
+         {
+         mask |= chars[0] ^ chr;
+         chr |= mask;
+         chars[0] = chr;
+         chars[1] |= mask;
+         }
+       len--;
+       if (--max_chars == 0)
+         return consumed;
+       consumed++;
+       chars += 2;
+       cc++;
        }
+     while (len > 0);
-     chars[location] = c;
+     if (--repeat == 0)
-     chars[location + 1] = bit;
+       break;
-     len--;
+     len = len_save;
-     location += 2;
+     cc = cc_save;
-     cc++;
      }
-   if (location >= MAX_N_CHARS * 2 || must_stop != 0)
+   repeat = 1;
+   if (last)
+     return consumed;
+   }
+ }
+ #define MAX_N_CHARS 16
+ static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
+ {
+ DEFINE_COMPILER;
+ struct sljit_label *start;
+ struct sljit_jump *quit;
+ pcre_uint32 chars[MAX_N_CHARS * 2];
+ pcre_uint8 ones[MAX_N_CHARS];
+ pcre_uint32 mask;
+ int i, max;
+ int offsets[3];
+ for (i = 0; i < MAX_N_CHARS; i++)
+   {
+   chars[i << 1] = NOTACHAR;
+   chars[(i << 1) + 1] = 0;
+   }
+ max = scan_prefix(common, common->start, chars, MAX_N_CHARS);
+ if (max <= 1)
+   return FALSE;
+ for (i = 0; i < max; i++)
+   {
+   mask = chars[(i << 1) + 1];
+   ones[i] = ones_in_half_byte[mask & 0xf];
+   mask >>= 4;
+   while (mask != 0)
+     {
+     ones[i] += ones_in_half_byte[mask & 0xf];
+     mask >>= 4;
+     }
+   }
+ offsets[0] = -1;
+ /* Scan forward. */
+ for (i = 0; i < max; i++)
+   if (ones[i] <= 2) {
+     offsets[0] = i;
      break;
    }
- /* At least two characters are required. */
+ if (offsets[0] == -1)
- if (location < 2 * 2)
+   return FALSE;
-     return FALSE;
+ /* Scan backward. */
+ offsets[1] = -1;
+ for (i = max - 1; i > offsets[0]; i--)
+   if (ones[i] <= 2) {
+     offsets[1] = i;
+     break;
+   }
+ offsets[2] = -1;
+ if (offsets[1] >= 0)
+   {
+   /* Scan from middle. */
+   for (i = (offsets[0] + offsets[1]) / 2 + 1; i < offsets[1]; i++)
+     if (ones[i] <= 2)
+       {
+       offsets[2] = i;
+       break;
+       }
+   if (offsets[2] == -1)
+     {
+     for (i = (offsets[0] + offsets[1]) / 2; i > offsets[0]; i--)
+       if (ones[i] <= 2)
+         {
+         offsets[2] = i;
+         break;
+         }
+     }
+   }
+ SLJIT_ASSERT(offsets[1] == -1 || (offsets[0] < offsets[1]));
+ SLJIT_ASSERT(offsets[2] == -1 || (offsets[0] < offsets[2] && offsets[1] > offsets[2]));
+ chars[0] = chars[offsets[0] << 1];
+ chars[1] = chars[(offsets[0] << 1) + 1];
+ if (offsets[2] >= 0)
+   {
+   chars[2] = chars[offsets[2] << 1];
+   chars[3] = chars[(offsets[2] << 1) + 1];
+   }
+ if (offsets[1] >= 0)
+   {
+   chars[4] = chars[offsets[1] << 1];
+   chars[5] = chars[(offsets[1] << 1) + 1];
+   }
+ max -= 1;
  if (firstline)
    {
    SLJIT_ASSERT(common->first_line_end != 0);
    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
-   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
+   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, IN_UCHARS(max));
    }
  else
-   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
+   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
  start = LABEL();
  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[0]));
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ if (offsets[1] >= 0)
+   OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[1]));
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  if (chars[1] != 0)
    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
  CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
- if (location > 2 * 2)
+ if (offsets[2] >= 0)
-   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[2] - 1));
- if (chars[3] != 0)
-   OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[3]);
+ if (offsets[1] >= 0)
- CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[2], start);
- if (location > 2 * 2)
    {
    if (chars[5] != 0)
-     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[5]);
+     OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[5]);
-   CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[4], start);
+   CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[4], start);
+   }
+ if (offsets[2] >= 0)
+   {
+   if (chars[3] != 0)
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[3]);
+   CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[2], start);
    }
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-Line 3061 
 JUMPHERE(quit);
+Line 3427 
 JUMPHERE(quit);
  if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  else
-   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
+   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
  return TRUE;
  }
-Line 3210 
 if (firstline)
+Line 3576 
 if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
- static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks);
+ static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks);
- static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline)
+ static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, pcre_uint8 *start_bits, BOOL firstline)
  {
  DEFINE_COMPILER;
  struct sljit_label *start;
  struct sljit_jump *quit;
  struct sljit_jump *found = NULL;
  jump_list *matches = NULL;
- pcre_uint8 inverted_start_bits[32];
- int i;
  #ifndef COMPILE_PCRE8
  struct sljit_jump *jump;
  #endif
- for (i = 0; i < 32; ++i)
-   inverted_start_bits[i] = ~(((pcre_uint8*)start_bits)[i]);
  if (firstline)
    {
    SLJIT_ASSERT(common->first_line_end != 0);
-Line 3243 
 if (common->utf)
+Line 3604 
 if (common->utf)
    OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
  #endif
- if (!check_class_ranges(common, inverted_start_bits, (inverted_start_bits[31] & 0x80) != 0, &matches))
+ if (!check_class_ranges(common, start_bits, (start_bits[31] & 0x80) != 0, TRUE, &matches))
    {
  #ifndef COMPILE_PCRE8
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 255);
-Line 3252 
 if (!check_class_ranges(common, inverted
+Line 3613 
 if (!check_class_ranges(common, inverted
  #endif
    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), start_bits);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)start_bits);
    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
    found = JUMP(SLJIT_C_NOT_ZERO);
-Line 3501 
 OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSE
+Line 3862 
 OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSE
  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
  }
- /*
+ static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks)
-   range format:
-   ranges[0] = length of the range (max MAX_RANGE_SIZE, -1 means invalid range).
-   ranges[1] = first bit (0 or 1)
-   ranges[2-length] = position of the bit change (when the current bit is not equal to the previous)
- */
- static BOOL check_ranges(compiler_common *common, int *ranges, jump_list **backtracks, BOOL readch)
  {
  DEFINE_COMPILER;
- struct sljit_jump *jump;
+ int ranges[MAX_RANGE_SIZE];
- if (ranges[0] < 0)
-   return FALSE;
- switch(ranges[0])
-   {
-   case 1:
-   if (readch)
-     read_char(common);
-   add_jump(compiler, backtracks, CMP(ranges[1] == 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
-   return TRUE;
-   case 2:
-   if (readch)
-     read_char(common);
-   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);
-   add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
-   return TRUE;
-   case 4:
-   if (ranges[2] + 1 == ranges[3] && ranges[4] + 1 == ranges[5])
-     {
-     if (readch)
-       read_char(common);
-     if (ranges[1] != 0)
-       {
-       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
-       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));
-       }
-     else
-       {
-       jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]);
-       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));
-       JUMPHERE(jump);
-       }
-     return TRUE;
-     }
-   if ((ranges[3] - ranges[2]) == (ranges[5] - ranges[4]) && is_powerof2(ranges[4] - ranges[2]))
-     {
-     if (readch)
-       read_char(common);
-     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4] - ranges[2]);
-     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4]);
-     add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[5] - ranges[4]));
-     return TRUE;
-     }
-   return FALSE;
-   default:
-   return FALSE;
-   }
- }
- static void get_ctype_ranges(compiler_common *common, int flag, int *ranges)
- {
- int i, bit, length;
- const pcre_uint8 *ctypes = (const pcre_uint8*)common->ctypes;
- bit = ctypes[0] & flag;
- ranges[0] = -1;
- ranges[1] = bit != 0 ? 1 : 0;
- length = 0;
- for (i = 1; i < 256; i++)
-   if ((ctypes[i] & flag) != bit)
-     {
-     if (length >= MAX_RANGE_SIZE)
-       return;
-     ranges[2 + length] = i;
-     length++;
-     bit ^= flag;
-     }
- if (bit != 0)
-   {
-   if (length >= MAX_RANGE_SIZE)
-     return;
-   ranges[2 + length] = 256;
-   length++;
-   }
- ranges[0] = length;
- }
- static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks)
- {
- int ranges[2 + MAX_RANGE_SIZE];
  pcre_uint8 bit, cbit, all;
  int i, byte, length = 0;
  bit = bits[0] & 0x1;
- ranges[1] = bit;
+ /* All bits will be zero or one (since bit is zero or one). */
- /* Can be 0 or 255. */
  all = -bit;
  for (i = 0; i < 256; )
-Line 3619 
 for (i = 0; i < 256; )
+Line 3885 
 for (i = 0; i < 256; )
        {
        if (length >= MAX_RANGE_SIZE)
          return FALSE;
-       ranges[2 + length] = i;
+       ranges[length] = i;
        length++;
        bit = cbit;
        all = -cbit;
-Line 3632 
 if (((bit == 0) && nclass) || ((bit == 1
+Line 3898 
 if (((bit == 0) && nclass) || ((bit == 1
    {
    if (length >= MAX_RANGE_SIZE)
      return FALSE;
-   ranges[2 + length] = 256;
+   ranges[length] = 256;
    length++;
    }
- ranges[0] = length;
- return check_ranges(common, ranges, backtracks, FALSE);
+ if (length < 0 || length > 4)
+   return FALSE;
+ bit = bits[0] & 0x1;
+ if (invert) bit ^= 0x1;
+ /* No character is accepted. */
+ if (length == 0 && bit == 0)
+   add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+ switch(length)
+   {
+   case 0:
+   /* When bit != 0, all characters are accepted. */
+   return TRUE;
+   case 1:
+   add_jump(compiler, backtracks, CMP(bit == 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+   return TRUE;
+   case 2:
+   if (ranges[0] + 1 != ranges[1])
+     {
+     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+     add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+     }
+   else
+     add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+   return TRUE;
+   case 3:
+   if (bit != 0)
+     {
+     add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
+     if (ranges[0] + 1 != ranges[1])
+       {
+       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+       add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+       }
+     else
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+     return TRUE;
+     }
+   add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[0]));
+   if (ranges[1] + 1 != ranges[2])
+     {
+     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1]);
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
+     }
+   else
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1]));
+   return TRUE;
+   case 4:
+   if ((ranges[1] - ranges[0]) == (ranges[3] - ranges[2])
+       && (ranges[0] | (ranges[2] - ranges[0])) == ranges[2]
+       && is_powerof2(ranges[2] - ranges[0]))
+     {
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[0]);
+     if (ranges[2] + 1 != ranges[3])
+       {
+       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);
+       add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
+       }
+     else
+       add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
+     return TRUE;
+     }
+   if (bit != 0)
+     {
+     i = 0;
+     if (ranges[0] + 1 != ranges[1])
+       {
+       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+       add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+       i = ranges[0];
+       }
+     else
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+     if (ranges[2] + 1 != ranges[3])
+       {
+       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - i);
+       add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
+       }
+     else
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2] - i));
+     return TRUE;
+     }
+   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[0]));
+   if (ranges[1] + 1 != ranges[2])
+     {
+     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]);
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
+     }
+   else
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+   return TRUE;
+   default:
+   SLJIT_ASSERT_STOP();
+   return FALSE;
+   }
  }
  static void check_anynewline(compiler_common *common)
-Line 4025 
 static void compile_xclass_matchingpath(
+Line 4396 
 static void compile_xclass_matchingpath(
  {
  DEFINE_COMPILER;
  jump_list *found = NULL;
- jump_list **list = (*cc & XCL_NOT) == 0 ? &found : backtracks;
+ jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks;
  pcre_int32 c, charoffset;
- const pcre_uint32 *other_cases;
  struct sljit_jump *jump = NULL;
  pcre_uchar *ccbegin;
  int compares, invertcmp, numberofcmps;
  #ifdef SUPPORT_UCP
  BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
  BOOL charsaved = FALSE;
  int typereg = TMP1, scriptreg = TMP1;
+ const pcre_uint32 *other_cases;
  pcre_int32 typeoffset;
  #endif
-Line 4043 
 pcre_int32 typeoffset;
+Line 4415 
 pcre_int32 typeoffset;
  detect_partial_match(common, backtracks);
  read_char(common);
- if ((*cc++ & XCL_MAP) != 0)
+ cc++;
+ if ((cc[-1] & XCL_HASPROP) == 0)
    {
-   OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
+   if ((cc[-1] & XCL_MAP) != 0)
- #ifndef COMPILE_PCRE8
+     {
-   jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+     OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
- #elif defined SUPPORT_UTF
+ #ifdef SUPPORT_UCP
-   if (common->utf)
+     charsaved = TRUE;
-     jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
  #endif
+     if (!check_class_ranges(common, (const pcre_uint8 *)cc, TRUE, FALSE, backtracks))
+       {
+       jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+       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_sw)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, &found, JUMP(SLJIT_C_NOT_ZERO));
+       add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
-   if (!check_class_ranges(common, (const pcre_uint8 *)cc, TRUE, list))
+       JUMPHERE(jump);
+       }
+     else
+       add_jump(compiler, &found, CMP(SLJIT_C_LESS_EQUAL, TMP3, 0, SLJIT_IMM, 0xff));
+     OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
+     cc += 32 / sizeof(pcre_uchar);
+     }
+   else
+     add_jump(compiler, (cc[-1] & XCL_NOT) == 0 ? backtracks : &found, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, 0xff));
+   }
+ else if ((cc[-1] & XCL_MAP) != 0)
+   {
+   OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
+ #ifdef SUPPORT_UCP
+   charsaved = TRUE;
+ #endif
+   if (!check_class_ranges(common, (const pcre_uint8 *)cc, FALSE, TRUE, list))
      {
+ #ifdef COMPILE_PCRE8
+     SLJIT_ASSERT(common->utf);
+ #endif
+     jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
      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_sw)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, list, JUMP(SLJIT_C_NOT_ZERO));
-     }
- #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 / sizeof(pcre_uchar);
    }
-Line 4130 
 while (*cc != XCL_END)
+Line 4528 
 while (*cc != XCL_END)
        case PT_SPACE:
        case PT_PXSPACE:
        case PT_WORD:
+       case PT_PXGRAPH:
+       case PT_PXPRINT:
+       case PT_PXPUNCT:
        needstype = TRUE;
        needschar = TRUE;
        break;
-Line 4317 
 while (*cc != XCL_END)
+Line 4718 
 while (*cc != XCL_END)
        case PT_SPACE:
        case PT_PXSPACE:
-       if (*cc == PT_SPACE)
-         {
-         OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
-         jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 11 - charoffset);
-         }
        SET_CHAR_OFFSET(9);
-       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 13 - 9);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd - 0x9);
        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
-       if (*cc == PT_SPACE)
-         JUMPHERE(jump);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x9);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x9);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
        SET_TYPE_OFFSET(ucp_Zl);
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);
-Line 4418 
 while (*cc != XCL_END)
+Line 4818 
 while (*cc != XCL_END)
        OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_GREATER_EQUAL);
        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
        break;
+       case PT_PXGRAPH:
+       /* C and Z groups are the farthest two groups. */
+       SET_TYPE_OFFSET(ucp_Ll);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER);
+       jump = CMP(SLJIT_C_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);
+       /* In case of ucp_Cf, we overwrite the result. */
+       SET_CHAR_OFFSET(0x2066);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);
+       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x2066);
+       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+       JUMPHERE(jump);
+       jump = CMP(SLJIT_C_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);
+       break;
+       case PT_PXPRINT:
+       /* C and Z groups are the farthest two groups. */
+       SET_TYPE_OFFSET(ucp_Ll);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Ll);
+       OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_C_NOT_EQUAL);
+       jump = CMP(SLJIT_C_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);
+       /* In case of ucp_Cf, we overwrite the result. */
+       SET_CHAR_OFFSET(0x2066);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);
+       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+       JUMPHERE(jump);
+       jump = CMP(SLJIT_C_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);
+       break;
+       case PT_PXPUNCT:
+       SET_TYPE_OFFSET(ucp_Sc);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Sc);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
+       SET_CHAR_OFFSET(0);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xff);
+       OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       SET_TYPE_OFFSET(ucp_Pc);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ps - ucp_Pc);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
+       break;
        }
      cc += 2;
      }
-Line 4449 
 struct sljit_label *label;
+Line 4910 
 struct sljit_label *label;
  #ifdef SUPPORT_UCP
  pcre_uchar propdata[5];
  #endif
- #endif
+ #endif /* SUPPORT_UTF */
  switch(type)
    {
-Line 4474 
 switch(type)
+Line 4935 
 switch(type)
    case OP_NOT_DIGIT:
    case OP_DIGIT:
    /* Digits are usually 0-9, so it is worth to optimize them. */
-   if (common->digits[0] == -2)
-     get_ctype_ranges(common, ctype_digit, common->digits);
    detect_partial_match(common, backtracks);
-   /* Flip the starting bit in the negative case. */
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
-   if (type == OP_NOT_DIGIT)
+   if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_digit, FALSE))
-     common->digits[1] ^= 1;
+     read_char7_type(common, type == OP_NOT_DIGIT);
-   if (!check_ranges(common, common->digits, backtracks, TRUE))
+   else
-     {
+ #endif
-     read_char8_type(common);
+     read_char8_type(common, type == OP_NOT_DIGIT);
-     OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
+     /* Flip the starting bit in the negative case. */
-     add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
+   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
-     }
+   add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
-   if (type == OP_NOT_DIGIT)
-     common->digits[1] ^= 1;
    return cc;
    case OP_NOT_WHITESPACE:
    case OP_WHITESPACE:
    detect_partial_match(common, backtracks);
-   read_char8_type(common);
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+   if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_space, FALSE))
+     read_char7_type(common, type == OP_NOT_WHITESPACE);
+   else
+ #endif
+     read_char8_type(common, type == OP_NOT_WHITESPACE);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);
    add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
    return cc;
-Line 4501 
 switch(type)
+Line 4963 
 switch(type)
    case OP_NOT_WORDCHAR:
    case OP_WORDCHAR:
    detect_partial_match(common, backtracks);
-   read_char8_type(common);
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+   if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_word, FALSE))
+     read_char7_type(common, type == OP_NOT_WORDCHAR);
+   else
+ #endif
+     read_char8_type(common, type == OP_NOT_WORDCHAR);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);
    add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
    return cc;
-Line 4564 
 switch(type)
+Line 5031 
 switch(type)
  #ifdef SUPPORT_UCP
    case OP_NOTPROP:
    case OP_PROP:
-   propdata[0] = 0;
+   propdata[0] = XCL_HASPROP;
    propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;
    propdata[2] = cc[0];
    propdata[3] = cc[1];
-Line 4922 
 switch(type)
+Line 5389 
 switch(type)
    case OP_CLASS:
    case OP_NCLASS:
    detect_partial_match(common, backtracks);
-   read_char(common);
-   if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, backtracks))
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+   bit = (common->utf && is_char7_bitset((const pcre_uint8 *)cc, type == OP_NCLASS)) ? 127 : 255;
+   read_char_max(common, bit, type == OP_NCLASS);
+ #else
+   read_char_max(common, 255, type == OP_NCLASS);
+ #endif
+   if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, FALSE, backtracks))
      return cc + 32 / sizeof(pcre_uchar);
- #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
    jump[0] = NULL;
- #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);
+     jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, bit);
      if (type == OP_CLASS)
        {
        add_jump(compiler, backtracks, jump[0]);
        jump[0] = NULL;
        }
      }
- #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
+ #elif !defined COMPILE_PCRE8
+   jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+   if (type == OP_CLASS)
+     {
+     add_jump(compiler, backtracks, jump[0]);
+     jump[0] = NULL;
+     }
+ #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_sw)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, backtracks, JUMP(SLJIT_C_ZERO));
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    if (jump[0] != NULL)
      JUMPHERE(jump[0]);
- #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
+ #endif
    return cc + 32 / sizeof(pcre_uchar);
  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
-Line 5056 
 if (context.length > 0)
+Line 5536 
 if (context.length > 0)
  return compile_char1_matchingpath(common, *cc, cc + 1, backtracks);
  }
- static struct sljit_jump *compile_ref_checks(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
- {
- DEFINE_COMPILER;
- int offset = GET2(cc, 1) << 1;
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
- if (!common->jscript_compat)
-   {
-   if (backtracks == NULL)
-     {
-     /* OVECTOR(1) contains the "string begin - 1" constant. */
-     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
-     OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
-     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
-     OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
-     return JUMP(SLJIT_C_NOT_ZERO);
-     }
-   add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
-   }
- return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
- }
  /* Forward definitions. */
  static void compile_matchingpath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);
  static void compile_backtrackingpath(compiler_common *, struct backtrack_common *);
-Line 5110 
 static void compile_backtrackingpath(com
+Line 5568 
 static void compile_backtrackingpath(com
  #define BACKTRACK_AS(type) ((type *)backtrack)
- static pcre_uchar *compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
+ static void compile_dnref_search(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
+ {
+ /* The OVECTOR offset goes to TMP2. */
+ DEFINE_COMPILER;
+ int count = GET2(cc, 1 + IMM2_SIZE);
+ pcre_uchar *slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
+ unsigned int offset;
+ jump_list *found = NULL;
+ SLJIT_ASSERT(*cc == OP_DNREF || *cc == OP_DNREFI);
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+ count--;
+ while (count-- > 0)
+   {
+   offset = GET2(slot, 0) << 1;
+   GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));
+   add_jump(compiler, &found, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0));
+   slot += common->name_entry_size;
+   }
+ offset = GET2(slot, 0) << 1;
+ GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));
+ if (backtracks != NULL && !common->jscript_compat)
+   add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0));
+ set_jumps(found, LABEL());
+ }
+ static void compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
  {
  DEFINE_COMPILER;
- int offset = GET2(cc, 1) << 1;
+ BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
+ int offset = 0;
  struct sljit_jump *jump = NULL;
  struct sljit_jump *partial;
  struct sljit_jump *nopartial;
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
+ if (ref)
- /* OVECTOR(1) contains the "string begin - 1" constant. */
+   {
- if (withchecks && !common->jscript_compat)
+   offset = GET2(cc, 1) << 1;
-   add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
+   /* OVECTOR(1) contains the "string begin - 1" constant. */
+   if (withchecks && !common->jscript_compat)
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+   }
+ else
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
  #if defined SUPPORT_UTF && defined SUPPORT_UCP
  if (common->utf && *cc == OP_REFI)
    {
    SLJIT_ASSERT(TMP1 == SLJIT_SCRATCH_REG1 && STACK_TOP == SLJIT_SCRATCH_REG2 && TMP2 == SLJIT_SCRATCH_REG3);
-   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
+   if (ref)
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
+   else
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
    if (withchecks)
      jump = CMP(SLJIT_C_EQUAL, TMP1, 0, TMP2, 0);
-Line 5152 
 if (common->utf && *cc == OP_REFI)
+Line 5651 
 if (common->utf && *cc == OP_REFI)
  else
  #endif /* SUPPORT_UTF && SUPPORT_UCP */
    {
-   OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
+   if (ref)
+     OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
+   else
+     OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
    if (withchecks)
      jump = JUMP(SLJIT_C_ZERO);
-Line 5189 
 if (jump != NULL)
+Line 5692 
 if (jump != NULL)
    else
      JUMPHERE(jump);
    }
- return cc + 1 + IMM2_SIZE;
  }
  static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
+ BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
  backtrack_common *backtrack;
  pcre_uchar type;
+ int offset = 0;
  struct sljit_label *label;
  struct sljit_jump *zerolength;
  struct sljit_jump *jump = NULL;
-Line 5206 
 BOOL minimize;
+Line 5710 
 BOOL minimize;
  PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
+ if (ref)
+   offset = GET2(cc, 1) << 1;
+ else
+   cc += IMM2_SIZE;
  type = cc[1 + IMM2_SIZE];
+ SLJIT_COMPILE_ASSERT((OP_CRSTAR & 0x1) == 0, crstar_opcode_must_be_even);
  minimize = (type & 0x1) != 0;
  switch(type)
    {
-Line 5244 
 if (!minimize)
+Line 5754 
 if (!minimize)
    if (min == 0)
      {
      allocate_stack(common, 2);
+     if (ref)
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
      /* Temporary release of STR_PTR. */
      OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
-     zerolength = compile_ref_checks(common, ccbegin, NULL);
+     /* Handles both invalid and empty cases. Since the minimum repeat,
+     is zero the invalid case is basically the same as an empty case. */
+     if (ref)
+       zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
+     else
+       {
+       compile_dnref_search(common, ccbegin, NULL);
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, TMP2, 0);
+       zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+       }
      /* Restore if not zero length. */
      OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
      }
    else
      {
      allocate_stack(common, 1);
+     if (ref)
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-     zerolength = compile_ref_checks(common, ccbegin, &backtrack->topbacktracks);
+     if (ref)
+       {
+       add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+       zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
+       }
+     else
+       {
+       compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, TMP2, 0);
+       zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+       }
      }
    if (min > 1 || max > 1)
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);
    label = LABEL();
+   if (!ref)
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
    compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);
    if (min > 1 || max > 1)
-Line 5297 
 if (!minimize)
+Line 5834 
 if (!minimize)
    return cc;
    }
- allocate_stack(common, 2);
+ allocate_stack(common, ref ? 2 : 3);
+ if (ref)
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
  if (type != OP_CRMINSTAR)
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
  if (min == 0)
    {
-   zerolength = compile_ref_checks(common, ccbegin, NULL);
+   /* Handles both invalid and empty cases. Since the minimum repeat,
+   is zero the invalid case is basically the same as an empty case. */
+   if (ref)
+     zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
+   else
+     {
+     compile_dnref_search(common, ccbegin, NULL);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);
+     zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+     }
+   /* Length is non-zero, we can match real repeats. */
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
    jump = JUMP(SLJIT_JUMP);
    }
  else
-   zerolength = compile_ref_checks(common, ccbegin, &backtrack->topbacktracks);
+   {
+   if (ref)
+     {
+     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+     zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
+     }
+   else
+     {
+     compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);
+     zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+     }
+   }
  BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
  if (max > 0)
    add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
+ if (!ref)
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
  compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);
  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
-Line 5902 
 common->accept = save_accept;
+Line 6467 
 common->accept = save_accept;
  return cc + 1 + LINK_SIZE;
  }
- static sljit_sw SLJIT_CALL do_searchovector(sljit_uw refno, sljit_sw* locals, pcre_uchar *name_table)
- {
- int condition = FALSE;
- pcre_uchar *slotA = name_table;
- pcre_uchar *slotB;
- sljit_sw name_count = locals[LOCALS0 / sizeof(sljit_sw)];
- sljit_sw name_entry_size = locals[LOCALS1 / sizeof(sljit_sw)];
- sljit_sw no_capture;
- int i;
- locals += refno & 0xff;
- refno >>= 8;
- no_capture = locals[1];
- for (i = 0; i < name_count; i++)
-   {
-   if (GET2(slotA, 0) == refno) break;
-   slotA += name_entry_size;
-   }
- if (i < name_count)
-   {
-   /* Found a name for the number - there can be only one; duplicate names
-   for different numbers are allowed, but not vice versa. First scan down
-   for duplicates. */
-   slotB = slotA;
-   while (slotB > name_table)
-     {
-     slotB -= name_entry_size;
-     if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
-       {
-       condition = locals[GET2(slotB, 0) << 1] != no_capture;
-       if (condition) break;
-       }
-     else break;
-     }
-   /* Scan up for duplicates */
-   if (!condition)
-     {
-     slotB = slotA;
-     for (i++; i < name_count; i++)
-       {
-       slotB += name_entry_size;
-       if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
-         {
-         condition = locals[GET2(slotB, 0) << 1] != no_capture;
-         if (condition) break;
-         }
-       else break;
-       }
-     }
-   }
- return condition;
- }
- static sljit_sw SLJIT_CALL do_searchgroups(sljit_uw recno, sljit_uw* locals, pcre_uchar *name_table)
- {
- int condition = FALSE;
- pcre_uchar *slotA = name_table;
- pcre_uchar *slotB;
- sljit_uw name_count = locals[LOCALS0 / sizeof(sljit_sw)];
- sljit_uw name_entry_size = locals[LOCALS1 / sizeof(sljit_sw)];
- sljit_uw group_num = locals[POSSESSIVE0 / sizeof(sljit_sw)];
- sljit_uw 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;
- }
  static SLJIT_INLINE void match_once_common(compiler_common *common, pcre_uchar ket, int framesize, int private_data_ptr, BOOL has_alternatives, BOOL needs_control_head)
  {
  DEFINE_COMPILER;
-Line 6144 
 backtrack_common *backtrack;
+Line 6599 
 backtrack_common *backtrack;
  pcre_uchar opcode;
  int private_data_ptr = 0;
  int offset = 0;
- int stacksize;
+ int i, stacksize;
  int repeat_ptr = 0, repeat_length = 0;
  int repeat_type = 0, repeat_count = 0;
  pcre_uchar *ccbegin;
  pcre_uchar *matchingpath;
+ pcre_uchar *slot;
  pcre_uchar bra = OP_BRA;
  pcre_uchar ket;
  assert_backtrack *assert;
-Line 6198 
 SLJIT_ASSERT(!((bra == OP_BRAZERO && ket
+Line 6654 
 SLJIT_ASSERT(!((bra == OP_BRAZERO && ket
  cc += GET(cc, 1);
  has_alternatives = *cc == OP_ALT;
- if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
+ if (SLJIT_UNLIKELY(opcode == OP_COND || opcode == OP_SCOND))
-   {
+   has_alternatives = (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF) ? FALSE : TRUE;
-   has_alternatives = (*matchingpath == OP_RREF) ? FALSE : TRUE;
-   if (*matchingpath == OP_NRREF)
-     {
-     stacksize = GET2(matchingpath, 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 != (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
-     }
-   }
  if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
    opcode = OP_SCOND;
-Line 6448 
 if (opcode == OP_COND || opcode == OP_SC
+Line 6892 
 if (opcode == OP_COND || opcode == OP_SC
        CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
      matchingpath += 1 + IMM2_SIZE;
      }
-   else if (*matchingpath == OP_NCREF)
+   else if (*matchingpath == OP_DNCREF)
      {
      SLJIT_ASSERT(has_alternatives);
-     stacksize = GET2(matchingpath, 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_SCRATCH_REG1, 0, SLJIT_IMM, (stacksize << 8) | (common->ovector_start / sizeof(sljit_sw)));
-     GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, 0);
-     OP1(SLJIT_MOV, SLJIT_SCRATCH_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, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, 0));
-     JUMPHERE(jump);
+     i = GET2(matchingpath, 1 + IMM2_SIZE);
-     matchingpath += 1 + IMM2_SIZE;
+     slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
+     OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+     OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
+     slot += common->name_entry_size;
+     i--;
+     while (i-- > 0)
+       {
+       OP2(SLJIT_SUB, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
+       OP2(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, STR_PTR, 0);
+       slot += common->name_entry_size;
+       }
+     OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
+     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), JUMP(SLJIT_C_ZERO));
+     matchingpath += 1 + 2 * IMM2_SIZE;
      }
-   else if (*matchingpath == OP_RREF || *matchingpath == OP_NRREF)
+   else if (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF)
      {
      /* Never has other case. */
      BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;
+     SLJIT_ASSERT(!has_alternatives);
-     stacksize = GET2(matchingpath, 1);
+     if (*matchingpath == OP_RREF)
-     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 == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
-     if (*matchingpath == OP_RREF || stacksize || common->currententry == NULL)
        {
-       SLJIT_ASSERT(!has_alternatives);
+       stacksize = GET2(matchingpath, 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 == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
        if (stacksize != 0)
          matchingpath += 1 + IMM2_SIZE;
+       }
+     else
+       {
+       if (common->currententry == NULL || common->currententry->start == 0)
+         stacksize = 0;
        else
          {
+         stacksize = GET2(matchingpath, 1 + IMM2_SIZE);
+         slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
+         i = (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
+         while (stacksize > 0)
+           {
+           if ((int)GET2(slot, 0) == i)
+             break;
+           slot += common->name_entry_size;
+           stacksize--;
+           }
+         }
+       if (stacksize != 0)
+         matchingpath += 1 + 2 * IMM2_SIZE;
+       }
+       /* The stacksize == 0 is a common "else" case. */
+       if (stacksize == 0)
+         {
          if (*cc == OP_ALT)
            {
            matchingpath = cc + 1 + LINK_SIZE;
-Line 6497 
 if (opcode == OP_COND || opcode == OP_SC
+Line 6967 
 if (opcode == OP_COND || opcode == OP_SC
          else
            matchingpath = cc;
          }
-       }
-     else
-       {
-       SLJIT_ASSERT(has_alternatives);
-       stacksize = GET2(matchingpath, 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_SCRATCH_REG1, 0, SLJIT_IMM, stacksize);
-       GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, 0);
-       OP1(SLJIT_MOV, SLJIT_SCRATCH_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, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, 0));
-       matchingpath += 1 + IMM2_SIZE;
-       }
      }
    else
      {
-Line 6956 
 count_match(common);
+Line 7408 
 count_match(common);
  return cc + 1 + LINK_SIZE;
  }
- 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)
+ static SLJIT_INLINE pcre_uchar *get_iterator_parameters(compiler_common *common, pcre_uchar *cc, pcre_uchar *opcode, pcre_uchar *type, int *max, int *min, pcre_uchar **end)
  {
  int class_len;
-Line 6992 
 else if (*opcode >= OP_TYPESTAR && *opco
+Line 7444 
 else if (*opcode >= OP_TYPESTAR && *opco
    }
  else
    {
-   SLJIT_ASSERT(*opcode >= OP_CLASS || *opcode <= OP_XCLASS);
+   SLJIT_ASSERT(*opcode == OP_CLASS || *opcode == OP_NCLASS || *opcode == OP_XCLASS);
    *type = *opcode;
    cc++;
    class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
-Line 7003 
 else
+Line 7455 
 else
      if (end != NULL)
        *end = cc + class_len;
      }
+   else if (*opcode >= OP_CRPOSSTAR && *opcode <= OP_CRPOSQUERY)
+     {
+     *opcode -= OP_CRPOSSTAR - OP_POSSTAR;
+     if (end != NULL)
+       *end = cc + class_len;
+     }
    else
      {
-     SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE);
+     SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE || *opcode == OP_CRPOSRANGE);
-     *arg1 = GET2(cc, (class_len + IMM2_SIZE));
+     *max = GET2(cc, (class_len + IMM2_SIZE));
-     *arg2 = GET2(cc, class_len);
+     *min = GET2(cc, class_len);
-     if (*arg2 == 0)
+     if (*min == 0)
        {
-       SLJIT_ASSERT(*arg1 != 0);
+       SLJIT_ASSERT(*max != 0);
-       *opcode = (*opcode == OP_CRRANGE) ? OP_UPTO : OP_MINUPTO;
+       *opcode = (*opcode == OP_CRRANGE) ? OP_UPTO : (*opcode == OP_CRMINRANGE ? OP_MINUPTO : OP_POSUPTO);
        }
-     if (*arg1 == *arg2)
+     if (*max == *min)
        *opcode = OP_EXACT;
      if (end != NULL)
-Line 7025 
 else
+Line 7483 
 else
  if (*opcode == OP_UPTO || *opcode == OP_MINUPTO || *opcode == OP_EXACT || *opcode == OP_POSUPTO)
    {
-   *arg1 = GET2(cc, 0);
+   *max = GET2(cc, 0);
    cc += IMM2_SIZE;
    }
-Line 7054 
 DEFINE_COMPILER;
+Line 7512 
 DEFINE_COMPILER;
  backtrack_common *backtrack;
  pcre_uchar opcode;
  pcre_uchar type;
- int arg1 = -1, arg2 = -1;
+ int max = -1, min = -1;
  pcre_uchar* end;
  jump_list *nomatch = NULL;
  struct sljit_jump *jump = NULL;
-Line 7067 
 int tmp_base, tmp_offset;
+Line 7525 
 int tmp_base, tmp_offset;
  PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
- cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);
+ cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, &end);
  switch(type)
    {
-Line 7138 
 switch(opcode)
+Line 7596 
 switch(opcode)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
        OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
-       if (opcode == OP_CRRANGE && arg2 > 0)
+       if (opcode == OP_CRRANGE && min > 0)
-         CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg2, label);
+         CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, label);
-       if (opcode == OP_UPTO || (opcode == OP_CRRANGE && arg1 > 0))
+       if (opcode == OP_UPTO || (opcode == OP_CRRANGE && max > 0))
-         jump = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, arg1);
+         jump = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
        }
-Line 7168 
 switch(opcode)
+Line 7626 
 switch(opcode)
      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
      if (opcode <= OP_PLUS)
        JUMPTO(SLJIT_JUMP, label);
-     else if (opcode == OP_CRRANGE && arg1 == 0)
+     else if (opcode == OP_CRRANGE && max == 0)
        {
        OP2(SLJIT_ADD, base, offset1, base, offset1, SLJIT_IMM, 1);
        JUMPTO(SLJIT_JUMP, label);
-Line 7178 
 switch(opcode)
+Line 7636 
 switch(opcode)
        OP1(SLJIT_MOV, TMP1, 0, base, offset1);
        OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
        OP1(SLJIT_MOV, base, offset1, TMP1, 0);
-       CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);
+       CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, max + 1, label);
        }
      set_jumps(nomatch, LABEL());
      if (opcode == OP_CRRANGE)
-       add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_LESS, base, offset1, SLJIT_IMM, arg2 + 1));
+       add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_LESS, base, offset1, SLJIT_IMM, min + 1));
      OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
      }
    BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
-Line 7220 
 switch(opcode)
+Line 7678 
 switch(opcode)
    break;
    case OP_EXACT:
-   OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, arg1);
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
    label = LABEL();
    compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
    OP2(SLJIT_SUB | SLJIT_SET_E, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
-Line 7233 
 switch(opcode)
+Line 7691 
 switch(opcode)
    if (opcode == OP_POSPLUS)
      compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
    if (opcode == OP_POSUPTO)
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, arg1);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, max);
    OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
    label = LABEL();
    compile_char1_matchingpath(common, type, cc, &nomatch);
-Line 7257 
 switch(opcode)
+Line 7715 
 switch(opcode)
    OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
    break;
+   case OP_CRPOSRANGE:
+   /* Combination of OP_EXACT and OP_POSSTAR or OP_POSUPTO */
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, min);
+   label = LABEL();
+   compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
+   OP2(SLJIT_SUB | SLJIT_SET_E, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+   JUMPTO(SLJIT_C_NOT_ZERO, label);
+   if (max != 0)
+     {
+     SLJIT_ASSERT(max - min > 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, max - min);
+     }
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
+   label = LABEL();
+   compile_char1_matchingpath(common, type, cc, &nomatch);
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
+   if (max == 0)
+     JUMPTO(SLJIT_JUMP, label);
+   else
+     {
+     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, 1);
+     JUMPTO(SLJIT_C_NOT_ZERO, label);
+     }
+   set_jumps(nomatch, LABEL());
+   OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
+   break;
    default:
    SLJIT_ASSERT_STOP();
    break;
-Line 7534 
 while (cc < ccend)
+Line 8020 
 while (cc < ccend)
      case OP_CLASS:
      case OP_NCLASS:
-     if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRMINRANGE)
+     if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRPOSRANGE)
        cc = compile_iterator_matchingpath(common, cc, parent);
      else
        cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
-Line 7542 
 while (cc < ccend)
+Line 8028 
 while (cc < ccend)
  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
      case OP_XCLASS:
-     if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRMINRANGE)
+     if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRPOSRANGE)
        cc = compile_iterator_matchingpath(common, cc, parent);
      else
        cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
-Line 7551 
 while (cc < ccend)
+Line 8037 
 while (cc < ccend)
      case OP_REF:
      case OP_REFI:
-     if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRMINRANGE)
+     if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRPOSRANGE)
+       cc = compile_ref_iterator_matchingpath(common, cc, parent);
+     else
+       {
+       compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
+       cc += 1 + IMM2_SIZE;
+       }
+     break;
+     case OP_DNREF:
+     case OP_DNREFI:
+     if (cc[1 + 2 * IMM2_SIZE] >= OP_CRSTAR && cc[1 + 2 * IMM2_SIZE] <= OP_CRPOSRANGE)
        cc = compile_ref_iterator_matchingpath(common, cc, parent);
      else
-       cc = compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
+       {
+       compile_dnref_search(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
+       compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
+       cc += 1 + 2 * IMM2_SIZE;
+       }
      break;
      case OP_RECURSE:
-Line 7707 
 DEFINE_COMPILER;
+Line 8208 
 DEFINE_COMPILER;
  pcre_uchar *cc = current->cc;
  pcre_uchar opcode;
  pcre_uchar type;
- int arg1 = -1, arg2 = -1;
+ int max = -1, min = -1;
  struct sljit_label *label = NULL;
  struct sljit_jump *jump = NULL;
  jump_list *jumplist = NULL;
-Line 7716 
 int base = (private_data_ptr == 0) ? SLJ
+Line 8217 
 int base = (private_data_ptr == 0) ? SLJ
  int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;
  int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);
- cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, NULL);
+ cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, NULL);
  switch(opcode)
    {
-Line 7735 
 switch(opcode)
+Line 8236 
 switch(opcode)
    else
      {
      if (opcode == OP_UPTO)
-       arg2 = 0;
+       min = 0;
      if (opcode <= OP_PLUS)
        {
        OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
-Line 7745 
 switch(opcode)
+Line 8246 
 switch(opcode)
        {
        OP1(SLJIT_MOV, TMP1, 0, base, offset1);
        OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
-       jump = CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, arg2 + 1);
+       jump = CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, min + 1);
        OP2(SLJIT_SUB, base, offset1, TMP1, 0, SLJIT_IMM, 1);
        }
      skip_char_back(common);
-Line 7790 
 switch(opcode)
+Line 8291 
 switch(opcode)
    OP1(SLJIT_MOV, base, offset1, TMP1, 0);
    if (opcode == OP_CRMINRANGE)
-     CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg2 + 1, label);
+     CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min + 1, label);
-   if (opcode == OP_CRMINRANGE && arg1 == 0)
+   if (opcode == OP_CRMINRANGE && max == 0)
      JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);
    else
-     CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 2, CURRENT_AS(iterator_backtrack)->matchingpath);
+     CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, max + 2, CURRENT_AS(iterator_backtrack)->matchingpath);
    set_jumps(jumplist, LABEL());
    if (private_data_ptr == 0)
-Line 7830 
 switch(opcode)
+Line 8331 
 switch(opcode)
    case OP_EXACT:
    case OP_POSPLUS:
+   case OP_CRPOSRANGE:
    set_jumps(current->topbacktracks, LABEL());
    break;
-Line 7848 
 static SLJIT_INLINE void compile_ref_ite
+Line 8350 
 static SLJIT_INLINE void compile_ref_ite
  {
  DEFINE_COMPILER;
  pcre_uchar *cc = current->cc;
+ BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
  pcre_uchar type;
- type = cc[1 + IMM2_SIZE];
+ type = cc[ref ? 1 + IMM2_SIZE : 1 + 2 * IMM2_SIZE];
  if ((type & 0x1) == 0)
    {
+   /* Maximize case. */
    set_jumps(current->topbacktracks, LABEL());
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    free_stack(common, 1);
-Line 7863 
 if ((type & 0x1) == 0)
+Line 8368 
 if ((type & 0x1) == 0)
  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
  CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);
  set_jumps(current->topbacktracks, LABEL());
- free_stack(common, 2);
+ free_stack(common, ref ? 2 : 3);
  }
  static SLJIT_INLINE void compile_recurse_backtrackingpath(compiler_common *common, struct backtrack_common *current)
-Line 8227 
 if (has_alternatives)
+Line 8732 
 if (has_alternatives)
          return;
        }
-     /* Instructions after the current alternative is succesfully matched. */
+     /* Instructions after the current alternative is successfully matched. */
      /* There is a similar code in compile_bracket_matchingpath. */
      if (opcode == OP_ONCE)
        match_once_common(common, ket, CURRENT_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
-Line 8664 
 while (current)
+Line 9169 
 while (current)
      case OP_REF:
      case OP_REFI:
+     case OP_DNREF:
+     case OP_DNREFI:
      compile_ref_iterator_backtrackingpath(common, current);
      break;
-Line 8957 
 else
+Line 9464 
 else
    }
  common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
  common->ctypes = (sljit_sw)(tables + ctypes_offset);
- common->digits[0] = -2;
+ common->name_table = ((pcre_uchar *)re) + re->name_table_offset;
- common->name_table = (sljit_sw)((pcre_uchar *)re + re->name_table_offset);
  common->name_count = re->name_count;
  common->name_entry_size = re->name_entry_size;
  common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
-Line 9131 
 if ((re->options & PCRE_ANCHORED) == 0)
+Line 9637 
 if ((re->options & PCRE_ANCHORED) == 0)
      else if ((re->flags & PCRE_STARTLINE) != 0)
        fast_forward_newline(common, (re->options & PCRE_FIRSTLINE) != 0);
      else if ((re->flags & PCRE_STARTLINE) == 0 && study != NULL && (study->flags & PCRE_STUDY_MAPPED) != 0)
-       fast_forward_start_bits(common, (sljit_uw)study->start_bits, (re->options & PCRE_FIRSTLINE) != 0);
+       fast_forward_start_bits(common, study->start_bits, (re->options & PCRE_FIRSTLINE) != 0);
      }
    }
  else
-Line 9377 
 if (common->utfreadchar != NULL)
+Line 9883 
 if (common->utfreadchar != NULL)
    }
  #endif /* !COMPILE_PCRE32 */
  #ifdef COMPILE_PCRE8
+ if (common->utfreadchar11 != NULL)
+   {
+   set_jumps(common->utfreadchar11, LABEL());
+   do_utfreadchar11(common);
+   }
  if (common->utfreadtype8 != NULL)
    {
    set_jumps(common->utfreadtype8, LABEL());
-Line 9696 
 if (extra != NULL &&
+Line 10207 
 if (extra != NULL &&
    }
  }
+ #if defined COMPILE_PCRE8
+ PCRE_EXP_DECL void
+ pcre_jit_free_unused_memory(void)
+ #elif defined COMPILE_PCRE16
+ PCRE_EXP_DECL void
+ pcre16_jit_free_unused_memory(void)
+ #elif defined COMPILE_PCRE32
+ PCRE_EXP_DECL void
+ pcre32_jit_free_unused_memory(void)
+ #endif
+ {
+ sljit_free_unused_memory_exec();
+ }
  #else  /* SUPPORT_JIT */
  /* These are dummy functions to avoid linking errors when JIT support is not
-Line 9747 
 pcre32_assign_jit_stack(pcre32_extra *ex
+Line 10272 
 pcre32_assign_jit_stack(pcre32_extra *ex
  (void)userdata;
  }
+ #if defined COMPILE_PCRE8
+ PCRE_EXP_DECL void
+ pcre_jit_free_unused_memory(void)
+ #elif defined COMPILE_PCRE16
+ PCRE_EXP_DECL void
+ pcre16_jit_free_unused_memory(void)
+ #elif defined COMPILE_PCRE32
+ PCRE_EXP_DECL void
+ pcre32_jit_free_unused_memory(void)
+ #endif
+ {
+ }
  #endif
  /* End of pcre_jit_compile.c */

 Legend:



Removed from v.1316
 


changed lines


 
Added in v.1421
 Legend:



Removed from v.1316
 


changed lines


 
Added in v.1421
-Removed from v.1316
+Added in v.1421

	ViewVC Help
Powered by ViewVC 1.1.5