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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1306 by zherczeg,
Mon Apr  1 17:04:17 2013 UTC
+revision 1640 by zherczeg,
Mon Feb 29 09:21:21 2016 UTC
 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_MALLOC(size, allocator_data) (PUBL(malloc))(size)
- #define SLJIT_FREE(ptr) (PUBL(free))(ptr)
+ #define SLJIT_FREE(ptr, allocator_data) (PUBL(free))(ptr)
  #define SLJIT_CONFIG_AUTO 1
  #define SLJIT_CONFIG_STATIC 1
  #define SLJIT_VERBOSE 0
 Line 168 
 typedef struct jit_arguments {
    pcre_uchar *mark_ptr;
    void *callout_data;
    /* Everything else after. */
+   pcre_uint32 limit_match;
    int real_offset_count;
    int offset_count;
-   int call_limit;
    pcre_uint8 notbol;
    pcre_uint8 noteol;
    pcre_uint8 notempty;
 Line 179 
 typedef struct jit_arguments {
  typedef struct executable_functions {
    void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];
+   void *read_only_data_heads[JIT_NUMBER_OF_COMPILE_MODES];
+   sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
    PUBL(jit_callback) callback;
    void *userdata;
-   pcre_uint32 top_bracket;
+   sljit_u32 top_bracket;
-   sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
+   sljit_u32 limit_match;
  } executable_functions;
  typedef struct jump_list {
-Line 196 
 typedef struct stub_list {
+Line 198 
 typedef struct stub_list {
    struct stub_list *next;
  } stub_list;
+ typedef struct label_addr_list {
+   struct sljit_label *label;
+   sljit_uw *update_addr;
+   struct label_addr_list *next;
+ } label_addr_list;
  enum frame_types {
    no_frame = -1,
    no_stack = -2
-Line 210 
 typedef int (SLJIT_CALL *jit_function)(j
+Line 218 
 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 269 
 typedef struct braminzero_backtrack {
+Line 277 
 typedef struct braminzero_backtrack {
    struct sljit_label *matchingpath;
  } braminzero_backtrack;
- typedef struct iterator_backtrack {
+ typedef struct char_iterator_backtrack {
+   backtrack_common common;
+   /* Next iteration. */
+   struct sljit_label *matchingpath;
+   union {
+     jump_list *backtracks;
+     struct {
+       unsigned int othercasebit;
+       pcre_uchar chr;
+       BOOL enabled;
+     } charpos;
+   } u;
+ } char_iterator_backtrack;
+ typedef struct ref_iterator_backtrack {
    backtrack_common common;
    /* Next iteration. */
    struct sljit_label *matchingpath;
- } iterator_backtrack;
+ } ref_iterator_backtrack;
  typedef struct recurse_entry {
    struct recurse_entry *next;
-Line 305 
 typedef struct then_trap_backtrack {
+Line 327 
 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 313 
 typedef struct compiler_common {
+Line 335 
 typedef struct compiler_common {
    /* First byte code. */
    pcre_uchar *start;
    /* Maps private data offset to each opcode. */
-   sljit_si *private_data_ptrs;
+   sljit_s32 *private_data_ptrs;
+   /* Chain list of read-only data ptrs. */
+   void *read_only_data_head;
    /* Tells whether the capturing bracket is optimized. */
-   pcre_uint8 *optimized_cbracket;
+   sljit_u8 *optimized_cbracket;
    /* Tells whether the starting offset is a target of then. */
-   pcre_uint8 *then_offsets;
+   sljit_u8 *then_offsets;
    /* Current position where a THEN must jump. */
    then_trap_backtrack *then_trap;
    /* Starting offset of private data for capturing brackets. */
-   int cbra_ptr;
+   sljit_s32 cbra_ptr;
    /* Output vector starting point. Must be divisible by 2. */
-   int ovector_start;
+   sljit_s32 ovector_start;
+   /* Points to the starting character of the current match. */
+   sljit_s32 start_ptr;
    /* Last known position of the requested byte. */
-   int req_char_ptr;
+   sljit_s32 req_char_ptr;
    /* Head of the last recursion. */
-   int recursive_head_ptr;
+   sljit_s32 recursive_head_ptr;
-   /* First inspected character for partial matching. */
+   /* First inspected character for partial matching.
-   int start_used_ptr;
+      (Needed for avoiding zero length partial matches.) */
+   sljit_s32 start_used_ptr;
    /* Starting pointer for partial soft matches. */
-   int hit_start;
+   sljit_s32 hit_start;
-   /* End pointer of the first line. */
+   /* Pointer of the match end position. */
-   int first_line_end;
+   sljit_s32 match_end_ptr;
    /* Points to the marked string. */
-   int mark_ptr;
+   sljit_s32 mark_ptr;
    /* Recursive control verb management chain. */
-   int control_head_ptr;
+   sljit_s32 control_head_ptr;
    /* Points to the last matched capture block index. */
-   int capture_last_ptr;
+   sljit_s32 capture_last_ptr;
-   /* Points to the starting position of the current match. */
+   /* Fast forward skipping byte code pointer. */
-   int start_ptr;
+   pcre_uchar *fast_forward_bc_ptr;
+   /* Locals used by fast fail optimization. */
+   sljit_s32 fast_fail_start_ptr;
+   sljit_s32 fast_fail_end_ptr;
    /* Flipped and lower case tables. */
-   const pcre_uint8 *fcc;
+   const sljit_u8 *fcc;
    sljit_sw lcc;
    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
    int mode;
+   /* TRUE, when minlength is greater than 0. */
+   BOOL might_be_empty;
    /* \K is found in the pattern. */
    BOOL has_set_som;
    /* (*SKIP:arg) is found in the pattern. */
    BOOL has_skip_arg;
    /* (*THEN) is found in the pattern. */
    BOOL has_then;
-   /* Needs to know the start position anytime. */
+   /* (*SKIP) or (*SKIP:arg) is found in lookbehind assertion. */
-   BOOL needs_start_ptr;
+   BOOL has_skip_in_assert_back;
    /* Currently in recurse or negative assert. */
    BOOL local_exit;
    /* Currently in a positive assert. */
    BOOL positive_assert;
    /* Newline control. */
    int nltype;
+   sljit_u32 nlmax;
+   sljit_u32 nlmin;
    int newline;
    int bsr_nltype;
+   sljit_u32 bsr_nlmax;
+   sljit_u32 bsr_nlmin;
    /* Dollar endonly. */
    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 379 
 typedef struct compiler_common {
+Line 414 
 typedef struct compiler_common {
    struct sljit_label *quit_label;
    struct sljit_label *forced_quit_label;
    struct sljit_label *accept_label;
+   struct sljit_label *ff_newline_shortcut;
    stub_list *stubs;
+   label_addr_list *label_addrs;
    recurse_entry *entries;
    recurse_entry *currententry;
    jump_list *partialmatch;
-Line 402 
 typedef struct compiler_common {
+Line 439 
 typedef struct compiler_common {
    BOOL utf;
  #ifdef SUPPORT_UCP
    BOOL use_ucp;
- #endif
+   jump_list *getucd;
- #ifndef COMPILE_PCRE32
-   jump_list *utfreadchar;
  #endif
  #ifdef COMPILE_PCRE8
+   jump_list *utfreadchar;
+   jump_list *utfreadchar16;
    jump_list *utfreadtype8;
  #endif
  #endif /* SUPPORT_UTF */
- #ifdef SUPPORT_UCP
-   jump_list *getucd;
- #endif
  } compiler_common;
  /* For byte_sequence_compare. */
-Line 423 
 typedef struct compare_context {
+Line 457 
 typedef struct compare_context {
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    int ucharptr;
    union {
-     sljit_si asint;
+     sljit_s32 asint;
-     sljit_uh asushort;
+     sljit_u16 asushort;
  #if defined COMPILE_PCRE8
-     sljit_ub asbyte;
+     sljit_u8 asbyte;
-     sljit_ub asuchars[4];
+     sljit_u8 asuchars[4];
  #elif defined COMPILE_PCRE16
-     sljit_uh asuchars[2];
+     sljit_u16 asuchars[2];
  #elif defined COMPILE_PCRE32
-     sljit_ui asuchars[1];
+     sljit_u32 asuchars[1];
  #endif
    } c;
    union {
-     sljit_si asint;
+     sljit_s32 asint;
-     sljit_uh asushort;
+     sljit_u16 asushort;
  #if defined COMPILE_PCRE8
-     sljit_ub asbyte;
+     sljit_u8 asbyte;
-     sljit_ub asuchars[4];
+     sljit_u8 asuchars[4];
  #elif defined COMPILE_PCRE16
-     sljit_uh asuchars[2];
+     sljit_u16 asuchars[2];
  #elif defined COMPILE_PCRE32
-     sljit_ui asuchars[1];
+     sljit_u32 asuchars[1];
  #endif
    } oc;
  #endif
-Line 455 
 typedef struct compare_context {
+Line 489 
 typedef struct compare_context {
  /* Used for accessing the elements of the stack. */
  #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_sw))
- #define TMP1          SLJIT_SCRATCH_REG1
+ #define TMP1          SLJIT_R0
- #define TMP2          SLJIT_SCRATCH_REG3
+ #define TMP2          SLJIT_R2
- #define TMP3          SLJIT_TEMPORARY_EREG2
+ #define TMP3          SLJIT_R3
- #define STR_PTR       SLJIT_SAVED_REG1
+ #define STR_PTR       SLJIT_S0
- #define STR_END       SLJIT_SAVED_REG2
+ #define STR_END       SLJIT_S1
- #define STACK_TOP     SLJIT_SCRATCH_REG2
+ #define STACK_TOP     SLJIT_R1
- #define STACK_LIMIT   SLJIT_SAVED_REG3
+ #define STACK_LIMIT   SLJIT_S2
- #define ARGUMENTS     SLJIT_SAVED_EREG1
+ #define COUNT_MATCH   SLJIT_S3
- #define CALL_COUNT    SLJIT_SAVED_EREG2
+ #define ARGUMENTS     SLJIT_S4
- #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1
+ #define RETURN_ADDR   SLJIT_R4
  /* Local space layout. */
  /* These two locals can be used by the current opcode. */
-Line 474 
 typedef struct compare_context {
+Line 508 
 typedef struct compare_context {
  #define POSSESSIVE0      (2 * sizeof(sljit_sw))
  #define POSSESSIVE1      (3 * sizeof(sljit_sw))
  /* Max limit of recursions. */
- #define CALL_LIMIT       (4 * sizeof(sljit_sw))
+ #define LIMIT_MATCH      (4 * sizeof(sljit_sw))
  /* 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    (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
- #define MOV_UCHAR  SLJIT_MOV_UB
+ #define MOV_UCHAR  SLJIT_MOV_U8
- #define MOVU_UCHAR SLJIT_MOVU_UB
+ #define MOVU_UCHAR SLJIT_MOVU_U8
  #elif defined COMPILE_PCRE16
- #define MOV_UCHAR  SLJIT_MOV_UH
+ #define MOV_UCHAR  SLJIT_MOV_U16
- #define MOVU_UCHAR SLJIT_MOVU_UH
+ #define MOVU_UCHAR SLJIT_MOVU_U16
  #elif defined COMPILE_PCRE32
- #define MOV_UCHAR  SLJIT_MOV_UI
+ #define MOV_UCHAR  SLJIT_MOV_U32
- #define MOVU_UCHAR SLJIT_MOVU_UI
+ #define MOVU_UCHAR SLJIT_MOVU_U32
  #else
  #error Unsupported compiling mode
  #endif
-Line 523 
 the start pointers when the end of the c
+Line 557 
 the start pointers when the end of the c
  #define GET_LOCAL_BASE(dst, dstw, offset) \
    sljit_get_local_base(compiler, (dst), (dstw), (offset))
- static pcre_uchar* bracketend(pcre_uchar* cc)
+ #define READ_CHAR_MAX 0x7fffffff
+ 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 532 
 cc += 1 + LINK_SIZE;
+Line 568 
 cc += 1 + LINK_SIZE;
  return cc;
  }
+ static int no_alternatives(pcre_uchar *cc)
+ {
+ int count = 0;
+ SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
+ do
+   {
+   cc += GET(cc, 1);
+   count++;
+   }
+ while (*cc == OP_ALT);
+ SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
+ return count;
+ }
  /* Functions whose might need modification for all new supported opcodes:
   next_opcode
   check_opcode_types
-Line 584 
 switch(*cc)
+Line 634 
 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 613 
 switch(*cc)
+Line 669 
 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 735 
 switch(*cc)
+Line 791 
 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;
- int i, cbra_index;
+ pcre_uchar *assert_back_end = cc - 1;
  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
-Line 746 
 while (cc < ccend)
+Line 802 
 while (cc < ccend)
      {
      case OP_SET_SOM:
      common->has_set_som = TRUE;
+     common->might_be_empty = TRUE;
      cc += 1;
      break;
-Line 771 
 while (cc < ccend)
+Line 828 
 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 815 
 while (cc < ccend)
+Line 864 
 while (cc < ccend)
      cc += 2 + 2 * LINK_SIZE;
      break;
+     case OP_ASSERTBACK:
+     slot = bracketend(cc);
+     if (slot > assert_back_end)
+       assert_back_end = slot;
+     cc += 1 + LINK_SIZE;
+     break;
      case OP_THEN_ARG:
      common->has_then = TRUE;
      common->control_head_ptr = 1;
      /* Fall through. */
      case OP_PRUNE_ARG:
-     common->needs_start_ptr = TRUE;
-     /* Fall through. */
      case OP_MARK:
      if (common->mark_ptr == 0)
        {
-Line 836 
 while (cc < ccend)
+Line 889 
 while (cc < ccend)
      case OP_THEN:
      common->has_then = TRUE;
      common->control_head_ptr = 1;
-     /* Fall through. */
+     cc += 1;
+     break;
-     case OP_PRUNE:
      case OP_SKIP:
-     common->needs_start_ptr = TRUE;
+     if (cc < assert_back_end)
+       common->has_skip_in_assert_back = TRUE;
      cc += 1;
      break;
      case OP_SKIP_ARG:
      common->control_head_ptr = 1;
      common->has_skip_arg = TRUE;
+     if (cc < assert_back_end)
+       common->has_skip_in_assert_back = TRUE;
      cc += 1 + 2 + cc[1];
      break;
-Line 860 
 while (cc < ccend)
+Line 916 
 while (cc < ccend)
  return TRUE;
  }
+ static BOOL is_accelerated_repeat(pcre_uchar *cc)
+ {
+ switch(*cc)
+   {
+   case OP_TYPESTAR:
+   case OP_TYPEMINSTAR:
+   case OP_TYPEPLUS:
+   case OP_TYPEMINPLUS:
+   case OP_TYPEPOSSTAR:
+   case OP_TYPEPOSPLUS:
+   return (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI);
+   case OP_STAR:
+   case OP_MINSTAR:
+   case OP_PLUS:
+   case OP_MINPLUS:
+   case OP_POSSTAR:
+   case OP_POSPLUS:
+   case OP_STARI:
+   case OP_MINSTARI:
+   case OP_PLUSI:
+   case OP_MINPLUSI:
+   case OP_POSSTARI:
+   case OP_POSPLUSI:
+   case OP_NOTSTAR:
+   case OP_NOTMINSTAR:
+   case OP_NOTPLUS:
+   case OP_NOTMINPLUS:
+   case OP_NOTPOSSTAR:
+   case OP_NOTPOSPLUS:
+   case OP_NOTSTARI:
+   case OP_NOTMINSTARI:
+   case OP_NOTPLUSI:
+   case OP_NOTMINPLUSI:
+   case OP_NOTPOSSTARI:
+   case OP_NOTPOSPLUSI:
+   return TRUE;
+   case OP_CLASS:
+   case OP_NCLASS:
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+   case OP_XCLASS:
+   cc += (*cc == OP_XCLASS) ? GET(cc, 1) : (int)(1 + (32 / sizeof(pcre_uchar)));
+ #else
+   cc += (1 + (32 / sizeof(pcre_uchar)));
+ #endif
+   switch(*cc)
+     {
+     case OP_CRSTAR:
+     case OP_CRMINSTAR:
+     case OP_CRPLUS:
+     case OP_CRMINPLUS:
+     case OP_CRPOSSTAR:
+     case OP_CRPOSPLUS:
+     return TRUE;
+     }
+   break;
+   }
+ return FALSE;
+ }
+ static SLJIT_INLINE BOOL detect_fast_forward_skip(compiler_common *common, int *private_data_start)
+ {
+ pcre_uchar *cc = common->start;
+ pcre_uchar *end;
+ /* Skip not repeated brackets. */
+ while (TRUE)
+   {
+   switch(*cc)
+     {
+     case OP_SOD:
+     case OP_SOM:
+     case OP_SET_SOM:
+     case OP_NOT_WORD_BOUNDARY:
+     case OP_WORD_BOUNDARY:
+     case OP_EODN:
+     case OP_EOD:
+     case OP_CIRC:
+     case OP_CIRCM:
+     case OP_DOLL:
+     case OP_DOLLM:
+     /* Zero width assertions. */
+     cc++;
+     continue;
+     }
+   if (*cc != OP_BRA && *cc != OP_CBRA)
+     break;
+   end = cc + GET(cc, 1);
+   if (*end != OP_KET || PRIVATE_DATA(end) != 0)
+     return FALSE;
+   if (*cc == OP_CBRA)
+     {
+     if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+       return FALSE;
+     cc += IMM2_SIZE;
+     }
+   cc += 1 + LINK_SIZE;
+   }
+ if (is_accelerated_repeat(cc))
+   {
+   common->fast_forward_bc_ptr = cc;
+   common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;
+   *private_data_start += sizeof(sljit_sw);
+   return TRUE;
+   }
+ return FALSE;
+ }
+ static SLJIT_INLINE void detect_fast_fail(compiler_common *common, pcre_uchar *cc, int *private_data_start, sljit_s32 depth)
+ {
+   pcre_uchar *next_alt;
+   SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA);
+   if (*cc == OP_CBRA && common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+     return;
+   next_alt = bracketend(cc) - (1 + LINK_SIZE);
+   if (*next_alt != OP_KET || PRIVATE_DATA(next_alt) != 0)
+     return;
+   do
+     {
+     next_alt = cc + GET(cc, 1);
+     cc += 1 + LINK_SIZE + ((*cc == OP_CBRA) ? IMM2_SIZE : 0);
+     while (TRUE)
+       {
+       switch(*cc)
+         {
+         case OP_SOD:
+         case OP_SOM:
+         case OP_SET_SOM:
+         case OP_NOT_WORD_BOUNDARY:
+         case OP_WORD_BOUNDARY:
+         case OP_EODN:
+         case OP_EOD:
+         case OP_CIRC:
+         case OP_CIRCM:
+         case OP_DOLL:
+         case OP_DOLLM:
+         /* Zero width assertions. */
+         cc++;
+         continue;
+         }
+       break;
+       }
+     if (depth > 0 && (*cc == OP_BRA || *cc == OP_CBRA))
+       detect_fast_fail(common, cc, private_data_start, depth - 1);
+     if (is_accelerated_repeat(cc))
+       {
+       common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;
+       if (common->fast_fail_start_ptr == 0)
+         common->fast_fail_start_ptr = *private_data_start;
+       *private_data_start += sizeof(sljit_sw);
+       common->fast_fail_end_ptr = *private_data_start;
+       if (*private_data_start > SLJIT_MAX_LOCAL_SIZE)
+         return;
+       }
+     cc = next_alt;
+     }
+   while (*cc == OP_ALT);
+ }
  static int get_class_iterator_size(pcre_uchar *cc)
  {
+ sljit_u32 min;
+ sljit_u32 max;
  switch(*cc)
    {
    case OP_CRSTAR:
-Line 876 
 switch(*cc)
+Line 1113 
 switch(*cc)
    case OP_CRRANGE:
    case OP_CRMINRANGE:
-   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
+   min = GET2(cc, 1);
-     return 0;
+   max = GET2(cc, 1 + IMM2_SIZE);
-   return 2;
+   if (max == 0)
+     return (*cc == OP_CRRANGE) ? 2 : 1;
+   max -= min;
+   if (max > 2)
+     max = 2;
+   return max;
    default:
    return 0;
-Line 892 
 pcre_uchar *next;
+Line 1134 
 pcre_uchar *next;
  pcre_uchar *next_end;
  pcre_uchar *max_end;
  pcre_uchar type;
- sljit_uw length = end - begin;
+ sljit_sw length = end - begin;
  int min, max, i;
  /* Detect fixed iterations first. */
-Line 1029 
 pcre_uchar *alternative;
+Line 1271 
 pcre_uchar *alternative;
  pcre_uchar *end = NULL;
  int private_data_ptr = *private_data_start;
  int space, size, bracketlen;
+ BOOL repeat_check = TRUE;
  while (cc < ccend)
    {
-Line 1036 
 while (cc < ccend)
+Line 1279 
 while (cc < ccend)
    size = 0;
    bracketlen = 0;
    if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
-     return;
+     break;
-   if (*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_ONCE || *cc == OP_ONCE_NC)
+   if (repeat_check && (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND))
+     {
      if (detect_repeat(common, cc))
        {
        /* These brackets are converted to repeats, so no global
-Line 1046 
 while (cc < ccend)
+Line 1290 
 while (cc < ccend)
        if (cc >= end)
          end = bracketend(cc);
        }
+     }
+   repeat_check = TRUE;
    switch(*cc)
      {
-Line 1101 
 while (cc < ccend)
+Line 1347 
 while (cc < ccend)
      bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
+     case OP_BRAZERO:
+     case OP_BRAMINZERO:
+     case OP_BRAPOSZERO:
+     repeat_check = FALSE;
+     size = 1;
+     break;
      CASE_ITERATOR_PRIVATE_DATA_1
      space = 1;
      size = -2;
-Line 1127 
 while (cc < ccend)
+Line 1380 
 while (cc < ccend)
      size = 1;
      break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+     case OP_TYPEUPTO:
      if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
        space = 2;
      size = 1 + IMM2_SIZE;
      break;
+     case OP_TYPEMINUPTO:
+     space = 2;
+     size = 1 + IMM2_SIZE;
+     break;
      case OP_CLASS:
      case OP_NCLASS:
      size += 1 + 32 / sizeof(pcre_uchar);
-Line 1188 
 while (cc < ccend)
+Line 1446 
 while (cc < ccend)
  }
  /* Returns with a frame_types (always < 0) if no need for frame. */
- static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL* needs_control_head)
+ static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL *needs_control_head)
  {
  int length = 0;
  int possessive = 0;
-Line 1281 
 while (cc < ccend)
+Line 1539 
 while (cc < ccend)
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
+     case OP_THEN:
+     stack_restore = TRUE;
+     if (common->control_head_ptr != 0)
+       *needs_control_head = TRUE;
+     cc ++;
+     break;
      default:
      stack_restore = TRUE;
      /* Fall through. */
-Line 1348 
 while (cc < ccend)
+Line 1613 
 while (cc < ccend)
      case OP_CLASS:
      case OP_NCLASS:
      case OP_XCLASS:
+     case OP_CALLOUT:
      cc = next_opcode(common, cc);
      SLJIT_ASSERT(cc != NULL);
-Line 1392 
 while (cc < ccend)
+Line 1658 
 while (cc < ccend)
      SLJIT_ASSERT(common->has_set_som);
      if (!setsom_found)
        {
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
        stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-Line 1408 
 while (cc < ccend)
+Line 1674 
 while (cc < ccend)
      SLJIT_ASSERT(common->mark_ptr != 0);
      if (!setmark_found)
        {
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
        stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-Line 1421 
 while (cc < ccend)
+Line 1687 
 while (cc < ccend)
      case OP_RECURSE:
      if (common->has_set_som && !setsom_found)
        {
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
        stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-Line 1430 
 while (cc < ccend)
+Line 1696 
 while (cc < ccend)
        }
      if (common->mark_ptr != 0 && !setmark_found)
        {
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
        stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-Line 1439 
 while (cc < ccend)
+Line 1705 
 while (cc < ccend)
        }
      if (common->capture_last_ptr != 0 && !capture_last_found)
        {
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
        stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-Line 1455 
 while (cc < ccend)
+Line 1721 
 while (cc < ccend)
      case OP_SCBRAPOS:
      if (common->capture_last_ptr != 0 && !capture_last_found)
        {
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
        stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-Line 1465 
 while (cc < ccend)
+Line 1731 
 while (cc < ccend)
      offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));
      stackpos += (int)sizeof(sljit_sw);
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
-     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
      stackpos += (int)sizeof(sljit_sw);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);
-Line 1496 
 while (cc < ccend)
+Line 1762 
 while (cc < ccend)
    size = 0;
    switch(*cc)
      {
+     case OP_KET:
+     if (PRIVATE_DATA(cc) != 0)
+       {
+       private_data_length++;
+       SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
+       cc += PRIVATE_DATA(cc + 1);
+       }
+     cc += 1 + LINK_SIZE;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 1507 
 while (cc < ccend)
+Line 1783 
 while (cc < ccend)
      case OP_SBRAPOS:
      case OP_SCOND:
      private_data_length++;
+     SLJIT_ASSERT(PRIVATE_DATA(cc) != 0);
      cc += 1 + LINK_SIZE;
      break;
-Line 1664 
 do
+Line 1941 
 do
      switch(*cc)
        {
+       case OP_KET:
+       if (PRIVATE_DATA(cc) != 0)
+         {
+         count = 1;
+         srcw[0] = PRIVATE_DATA(cc);
+         SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
+         cc += PRIVATE_DATA(cc + 1);
+         }
+       cc += 1 + LINK_SIZE;
+       break;
        case OP_ASSERT:
        case OP_ASSERT_NOT:
        case OP_ASSERTBACK:
-Line 1831 
 do
+Line 2119 
 do
            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
            stackptr += sizeof(sljit_sw);
            }
-         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);
+         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);
          tmp1empty = FALSE;
          tmp1next = FALSE;
          }
-Line 1842 
 do
+Line 2130 
 do
            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
            stackptr += sizeof(sljit_sw);
            }
-         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);
+         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);
          tmp2empty = FALSE;
          tmp1next = TRUE;
          }
-Line 1852 
 do
+Line 2140 
 do
        if (tmp1next)
          {
          SLJIT_ASSERT(!tmp1empty);
-         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP1, 0);
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP1, 0);
          tmp1empty = stackptr >= stacktop;
          if (!tmp1empty)
            {
-Line 1864 
 do
+Line 2152 
 do
        else
          {
          SLJIT_ASSERT(!tmp2empty);
-         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP2, 0);
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP2, 0);
          tmp2empty = stackptr >= stacktop;
          if (!tmp2empty)
            {
-Line 1966 
 while (list)
+Line 2254 
 while (list)
    }
  }
- static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump* jump)
+ static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump *jump)
  {
  jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));
  if (list_item)
-Line 1980 
 if (list_item)
+Line 2268 
 if (list_item)
  static void add_stub(compiler_common *common, struct sljit_jump *start)
  {
  DEFINE_COMPILER;
- stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
+ stub_list *list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
  if (list_item)
    {
-Line 1994 
 if (list_item)
+Line 2282 
 if (list_item)
  static void flush_stubs(compiler_common *common)
  {
  DEFINE_COMPILER;
- stub_list* list_item = common->stubs;
+ stub_list *list_item = common->stubs;
  while (list_item)
    {
-Line 2006 
 while (list_item)
+Line 2294 
 while (list_item)
  common->stubs = NULL;
  }
- static SLJIT_INLINE void decrease_call_count(compiler_common *common)
+ static void add_label_addr(compiler_common *common, sljit_uw *update_addr)
+ {
+ DEFINE_COMPILER;
+ label_addr_list *label_addr;
+ label_addr = sljit_alloc_memory(compiler, sizeof(label_addr_list));
+ if (label_addr == NULL)
+   return;
+ label_addr->label = LABEL();
+ label_addr->update_addr = update_addr;
+ label_addr->next = common->label_addrs;
+ common->label_addrs = label_addr;
+ }
+ static SLJIT_INLINE void count_match(compiler_common *common)
  {
  DEFINE_COMPILER;
- OP2(SLJIT_SUB | SLJIT_SET_E, CALL_COUNT, 0, CALL_COUNT, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB | SLJIT_SET_E, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);
- add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));
+ add_jump(compiler, &common->calllimit, JUMP(SLJIT_ZERO));
  }
  static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)
-Line 2019 
 static SLJIT_INLINE void allocate_stack(
+Line 2321 
 static SLJIT_INLINE void allocate_stack(
  /* May destroy all locals and registers except TMP2. */
  DEFINE_COMPILER;
+ SLJIT_ASSERT(size > 0);
  OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
  #ifdef DESTROY_REGISTERS
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);
  OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, TMP1, 0);
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);
  #endif
- add_stub(common, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));
+ add_stub(common, CMP(SLJIT_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));
  }
  static SLJIT_INLINE void free_stack(compiler_common *common, int size)
  {
  DEFINE_COMPILER;
+ SLJIT_ASSERT(size > 0);
  OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
  }
+ static sljit_uw * allocate_read_only_data(compiler_common *common, sljit_uw size)
+ {
+ DEFINE_COMPILER;
+ sljit_uw *result;
+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+   return NULL;
+ result = (sljit_uw *)SLJIT_MALLOC(size + sizeof(sljit_uw), compiler->allocator_data);
+ if (SLJIT_UNLIKELY(result == NULL))
+   {
+   sljit_set_compiler_memory_error(compiler);
+   return NULL;
+   }
+ *(void**)result = common->read_only_data_head;
+ common->read_only_data_head = (void *)result;
+ return result + 1;
+ }
+ static void free_read_only_data(void *current, void *allocator_data)
+ {
+ void *next;
+ SLJIT_UNUSED_ARG(allocator_data);
+ while (current != NULL)
+   {
+   next = *(void**)current;
+   SLJIT_FREE(current, allocator_data);
+   current = next;
+   }
+ }
  static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)
  {
  DEFINE_COMPILER;
-Line 2045 
 int i;
+Line 2384 
 int i;
  /* At this point we can freely use all temporary registers. */
  SLJIT_ASSERT(length > 1);
  /* TMP1 returns with begin - 1. */
- OP2(SLJIT_SUB, SLJIT_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
+ OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
  if (length < 8)
    {
    for (i = 1; i < length; i++)
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_SCRATCH_REG1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), SLJIT_R0, 0);
    }
  else
    {
-   GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, OVECTOR_START);
+   GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START);
-   OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, length - 1);
+   OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1);
    loop = LABEL();
-   OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(sljit_sw), SLJIT_SCRATCH_REG1, 0);
+   OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R0, 0);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);
-   JUMPTO(SLJIT_C_NOT_ZERO, loop);
+   JUMPTO(SLJIT_NOT_ZERO, loop);
    }
  }
+ static SLJIT_INLINE void reset_fast_fail(compiler_common *common)
+ {
+ DEFINE_COMPILER;
+ sljit_s32 i;
+ SLJIT_ASSERT(common->fast_fail_start_ptr < common->fast_fail_end_ptr);
+ OP2(SLJIT_SUB, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ for (i = common->fast_fail_start_ptr; i < common->fast_fail_end_ptr; i += sizeof(sljit_sw))
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), i, TMP1, 0);
+ }
  static SLJIT_INLINE void do_reset_match(compiler_common *common, int length)
  {
  DEFINE_COMPILER;
-Line 2071 
 int i;
+Line 2422 
 int i;
  SLJIT_ASSERT(length > 1);
  /* OVECTOR(1) contains the "string begin - 1" constant. */
  if (length > 2)
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
  if (length < 8)
    {
    for (i = 2; i < length; i++)
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), TMP1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), TMP1, 0);
    }
  else
    {
-Line 2084 
 else
+Line 2435 
 else
    loop = LABEL();
    OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
    OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);
-   JUMPTO(SLJIT_C_NOT_ZERO, loop);
+   JUMPTO(SLJIT_NOT_ZERO, loop);
    }
  OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);
  if (common->mark_ptr != 0)
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, SLJIT_IMM, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0);
  if (common->control_head_ptr != 0)
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr);
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_ptr);
  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, base));
  }
-Line 2115 
 while (current != NULL)
+Line 2466 
 while (current != NULL)
      SLJIT_ASSERT_STOP();
      break;
      }
+   SLJIT_ASSERT(current > (sljit_sw*)current[-1]);
    current = (sljit_sw*)current[-1];
    }
  return -1;
-Line 2127 
 struct sljit_label *loop;
+Line 2479 
 struct sljit_label *loop;
  struct sljit_jump *early_quit;
  /* At this point we can freely use all registers. */
- OP1(SLJIT_MOV, SLJIT_SAVED_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+ OP1(SLJIT_MOV, SLJIT_S2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1), STR_PTR, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(1), STR_PTR, 0);
- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, ARGUMENTS, 0);
+ OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0);
  if (common->mark_ptr != 0)
-   OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
+   OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
- OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, offset_count));
+ OP1(SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offset_count));
  if (common->mark_ptr != 0)
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_SCRATCH_REG3, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_R2, 0);
- OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
+ OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, begin));
+ OP1(SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, begin));
- GET_LOCAL_BASE(SLJIT_SAVED_REG1, 0, OVECTOR_START);
+ GET_LOCAL_BASE(SLJIT_S0, 0, OVECTOR_START);
  /* Unlikely, but possible */
- early_quit = CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 0);
+ early_quit = CMP(SLJIT_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0);
  loop = LABEL();
- OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_SCRATCH_REG1, 0);
+ OP2(SLJIT_SUB, SLJIT_S1, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
- OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_sw));
+ OP2(SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_sw));
  /* Copy the integer value to the output buffer */
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);
+ OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
- OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG3), sizeof(int), SLJIT_SAVED_REG2, 0);
+ OP1(SLJIT_MOVU_S32, SLJIT_MEM1(SLJIT_R2), sizeof(int), SLJIT_S1, 0);
- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
- JUMPTO(SLJIT_C_NOT_ZERO, loop);
+ JUMPTO(SLJIT_NOT_ZERO, loop);
  JUMPHERE(early_quit);
  /* Calculate the return value, which is the maximum ovector value. */
  if (topbracket > 1)
    {
-   GET_LOCAL_BASE(SLJIT_SCRATCH_REG1, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));
+   GET_LOCAL_BASE(SLJIT_R0, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));
-   OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, topbracket + 1);
+   OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, topbracket + 1);
-   /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */
+   /* OVECTOR(0) is never equal to SLJIT_S2. */
    loop = LABEL();
-   OP1(SLJIT_MOVU, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), -(2 * (sljit_sw)sizeof(sljit_sw)));
+   OP1(SLJIT_MOVU, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), -(2 * (sljit_sw)sizeof(sljit_sw)));
-   OP2(SLJIT_SUB, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
-   CMPTO(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG3, 0, SLJIT_SAVED_REG3, 0, loop);
+   CMPTO(SLJIT_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop);
-   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_SCRATCH_REG2, 0);
+   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_R1, 0);
    }
  else
    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
-Line 2175 
 static SLJIT_INLINE void return_with_par
+Line 2527 
 static SLJIT_INLINE void return_with_par
  DEFINE_COMPILER;
  struct sljit_jump *jump;
- SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);
+ SLJIT_COMPILE_ASSERT(STR_END == SLJIT_S1, str_end_must_be_saved_reg2);
  SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0
    && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);
+ OP1(SLJIT_MOV, SLJIT_R1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
- OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
+ OP1(SLJIT_MOV_S32, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
- CMPTO(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 2, quit);
+ CMPTO(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 2, quit);
  /* Store match begin and end. */
- OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, begin));
+ OP1(SLJIT_MOV, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, begin));
- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));
+ OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, offsets));
- jump = CMP(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 3);
+ jump = CMP(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 3);
- OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + (int)sizeof(sljit_sw)), SLJIT_SAVED_REG1, 0);
+ OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + (int)sizeof(sljit_sw)), SLJIT_S0, 0);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);
+ OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
- OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 2 * sizeof(int), SLJIT_SCRATCH_REG3, 0);
+ OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(int), SLJIT_R2, 0);
  JUMPHERE(jump);
- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
+ OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
- OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);
+ OP2(SLJIT_SUB, SLJIT_S1, 0, STR_END, 0, SLJIT_S0, 0);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);
+ OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
- OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(int), SLJIT_SAVED_REG2, 0);
+ OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), sizeof(int), SLJIT_S1, 0);
- OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_SAVED_REG1, 0);
+ OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_S0, 0);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);
+ OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
- OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 0, SLJIT_SCRATCH_REG3, 0);
+ OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);
  JUMPTO(SLJIT_JUMP, quit);
  }
-Line 2221 
 struct sljit_jump *jump;
+Line 2573 
 struct sljit_jump *jump;
  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
    {
    /* The value of -1 must be kept for start_used_ptr! */
-   OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, 1);
    /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting
    is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */
-   jump = CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, STR_PTR, 0);
+   jump = CMP(SLJIT_LESS_EQUAL, TMP1, 0, STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
    JUMPHERE(jump);
    }
  else if (common->mode == JIT_PARTIAL_HARD_COMPILE)
    {
-   jump = CMP(SLJIT_C_LESS_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   jump = CMP(SLJIT_LESS_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
    JUMPHERE(jump);
    }
  }
- static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar* cc)
+ static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar *cc)
  {
  /* Detects if the character has an othercase. */
  unsigned int c;
-Line 2279 
 if (common->utf && c > 127)
+Line 2631 
 if (common->utf && c > 127)
  return TABLE_GET(c, common->fcc, c);
  }
- static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar* 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;
-Line 2357 
 return (bit < 256) ? ((0 << 8) | bit) :
+Line 2709 
 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 2367 
 if (common->mode == JIT_COMPILE)
+Line 2719 
 if (common->mode == JIT_COMPILE)
    return;
  if (!force)
-   jump = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   jump = CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
  else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
-   jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);
+   jump = CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1);
  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
  else
    {
    if (common->partialmatchlabel != NULL)
-Line 2393 
 struct sljit_jump *jump;
+Line 2745 
 struct sljit_jump *jump;
  if (common->mode == JIT_COMPILE)
    {
-   add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
    return;
    }
- jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
+ jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
    {
-   add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
+   add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
    add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));
    }
  else
    {
-   add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
+   add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
    if (common->partialmatchlabel != NULL)
      JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
    else
-Line 2422 
 struct sljit_jump *jump;
+Line 2774 
 struct sljit_jump *jump;
  if (common->mode == JIT_COMPILE)
    {
-   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
    return;
    }
  /* Partial matching mode. */
- jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
+ jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
- add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
+ add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
    }
  else
-Line 2444 
 else
+Line 2796 
 else
  JUMPHERE(jump);
  }
- static void read_char(compiler_common *common)
+ static void peek_char(compiler_common *common, sljit_u32 max)
  {
- /* Reads the character into TMP1, updates STR_PTR.
+ /* Reads the character into TMP1, keeps STR_PTR.
  Does not check STR_END. TMP2 Destroyed. */
  DEFINE_COMPILER;
  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
+ SLJIT_UNUSED_ARG(max);
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
  if (common->utf)
    {
- #if defined COMPILE_PCRE8
+   if (max < 128) return;
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
- #elif defined COMPILE_PCRE16
+   jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #endif /* COMPILE_PCRE[8|16] */
    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
+   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
    JUMPHERE(jump);
    }
  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   if (max < 0xd800) return;
+   OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+   jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+   /* TMP2 contains the high surrogate. */
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+   OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
+   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
+   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+   JUMPHERE(jump);
+   }
+ #endif
  }
- static void peek_char(compiler_common *common)
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ static BOOL is_char7_bitset(const sljit_u8 *bitset, BOOL nclass)
  {
- /* Reads the character into TMP1, keeps STR_PTR.
+ /* Tells whether the character codes below 128 are enough
- Does not check STR_END. TMP2 Destroyed. */
+ to determine a match. */
+ const sljit_u8 value = nclass ? 0xff : 0;
+ const sljit_u8 *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. Does not check STR_END. The
+ full_read argument tells whether characters above max are accepted or not. */
+ 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_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+ if (full_read)
+   {
+   jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
+   OP1(SLJIT_MOV_U8, 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_range(compiler_common *common, sljit_u32 min, sljit_u32 max, BOOL update_str_ptr)
+ {
+ /* Reads the precise value of a character into TMP1, if the character is
+ between min and max (c >= min && c <= max). Otherwise it returns with a value
+ outside the range. Does not check STR_END. */
  DEFINE_COMPILER;
  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ struct sljit_jump *jump2;
+ #endif
- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ SLJIT_UNUSED_ARG(update_str_ptr);
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ SLJIT_UNUSED_ARG(min);
+ SLJIT_UNUSED_ARG(max);
+ SLJIT_ASSERT(min <= max);
+ 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));
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
  if (common->utf)
    {
- #if defined COMPILE_PCRE8
+   if (max < 128 && !update_str_ptr) return;
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
- #elif defined COMPILE_PCRE16
+   jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+   if (min >= 0x10000)
- #endif /* COMPILE_PCRE[8|16] */
+     {
-   add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
+     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xf0);
-   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+     if (update_str_ptr)
+       OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+     jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x7);
+     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+     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(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
+     if (!update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
+     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);
+     JUMPHERE(jump2);
+     if (update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+     }
+   else if (min >= 0x800 && max <= 0xffff)
+     {
+     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xe0);
+     if (update_str_ptr)
+       OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+     jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xf);
+     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+     if (!update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
+     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);
+     JUMPHERE(jump2);
+     if (update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+     }
+   else if (max >= 0x800)
+     add_jump(compiler, (max < 0x10000) ? &common->utfreadchar16 : &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
+   else if (max < 128)
+     {
+     OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+     }
+   else
+     {
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+     if (!update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+     else
+       OP1(SLJIT_MOV_U8, 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 (update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+     }
    JUMPHERE(jump);
    }
- #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
+ #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   if (max >= 0x10000)
+     {
+     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+     jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+     /* TMP2 contains the high surrogate. */
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+     OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
+     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
+     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_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+     JUMPHERE(jump);
+     return;
+     }
+   if (max < 0xd800 && !update_str_ptr) return;
+   /* Skip low surrogate if necessary. */
+   OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+   jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+   if (update_str_ptr)
+     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 SLJIT_INLINE void read_char(compiler_common *common)
+ {
+ read_char_range(common, 0, READ_CHAR_MAX, TRUE);
  }
- static void read_char8_type(compiler_common *common)
+ static void read_char8_type(compiler_common *common, BOOL update_str_ptr)
  {
  /* 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(update_str_ptr);
+ 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);
+   OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
-   jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
+   jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
-   add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
+   if (!update_str_ptr)
-   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_GREATER, TMP2, 0, SLJIT_IMM, 255);
-   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+     OP1(SLJIT_MOV_U8, 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);
+ jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);
  #endif
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+ OP1(SLJIT_MOV_U8, 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 && update_str_ptr)
+   {
+   /* Skip low surrogate if necessary. */
+   OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800);
+   jump = CMP(SLJIT_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 2561 
 if (common->utf)
+Line 3096 
 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));
    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
-   CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
+   CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
    return;
    }
  #elif defined COMPILE_PCRE16
-Line 2572 
 if (common->utf)
+Line 3107 
 if (common->utf)
    /* 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);
-   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    return;
-Line 2582 
 if (common->utf)
+Line 3117 
 if (common->utf)
  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 **backtracks, BOOL jumpiftrue)
+ static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpifmatch)
  {
  /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */
  DEFINE_COMPILER;
+ struct sljit_jump *jump;
  if (nltype == NLTYPE_ANY)
    {
    add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(jumpifmatch ? SLJIT_NOT_ZERO : SLJIT_ZERO));
    }
  else if (nltype == NLTYPE_ANYCRLF)
    {
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_CR);
+   if (jumpifmatch)
-   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+     {
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
+     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR));
-   OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
-   add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+     }
+   else
+     {
+     jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
+     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
+     JUMPHERE(jump);
+     }
    }
  else
    {
    SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);
-   add_jump(compiler, backtracks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
+   add_jump(compiler, backtracks, CMP(jumpifmatch ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
    }
  }
-Line 2613 
 else
+Line 3155 
 else
  static void do_utfreadchar(compiler_common *common)
  {
  /* Fast decoding a UTF-8 character. TMP1 contains the first byte
- of the character (>= 0xc0). Return char value in TMP1, length - 1 in TMP2. */
+ of the character (>= 0xc0). Return char value in TMP1, length in TMP2. */
  DEFINE_COMPILER;
  struct sljit_jump *jump;
  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
- /* Searching for the first zero. */
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
- jump = JUMP(SLJIT_C_NOT_ZERO);
- /* Two byte sequence. */
- 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, 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));
+ /* Searching for the first zero. */
+ OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
+ jump = JUMP(SLJIT_NOT_ZERO);
+ /* Two byte sequence. */
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 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);
+ JUMPHERE(jump);
- jump = JUMP(SLJIT_C_NOT_ZERO);
- /* Three byte sequence. */
  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0f);
+ OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12);
+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
  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));
+ OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10000);
+ jump = JUMP(SLJIT_NOT_ZERO);
+ /* Three byte sequence. */
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
  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));
+ JUMPHERE(jump);
- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x07);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 18);
+ OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+ 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_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(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(4));
+ sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+ }
+ static void do_utfreadchar16(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);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+ 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_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));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
+ /* Searching for the first zero. */
+ OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
+ jump = JUMP(SLJIT_NOT_ZERO);
+ /* Two byte sequence. */
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 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, 0x400);
+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_NOT_ZERO);
+ /* This code runs only in 8 bit mode. No need to shift the value. */
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
+ 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(3));
+ /* Three byte sequence. */
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 2679 
 struct sljit_jump *compare;
+Line 3247 
 struct sljit_jump *compare;
  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
- jump = JUMP(SLJIT_C_NOT_ZERO);
+ jump = JUMP(SLJIT_NOT_ZERO);
  /* Two byte sequence. */
  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_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_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
- 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);
- 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);
- }
- #elif defined 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);
- 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(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
- 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_PCRE[8|16] */
+ #endif /* COMPILE_PCRE8 */
  #endif /* SUPPORT_UTF */
-Line 2750 
 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && si
+Line 3292 
 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && si
  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1));
+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)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_sw)PRIV(ucd_stage2));
- OP1(SLJIT_MOV_UH, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
+ OP1(SLJIT_MOV_U16, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
  #endif
- static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf, BOOL firstline)
+ static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf)
  {
  DEFINE_COMPILER;
  struct sljit_label *mainloop;
  struct sljit_label *newlinelabel = NULL;
  struct sljit_jump *start;
  struct sljit_jump *end = NULL;
- struct sljit_jump *nl = NULL;
+ struct sljit_jump *end2 = NULL;
  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *singlechar;
  #endif
-Line 2777 
 jump_list *newline = NULL;
+Line 3319 
 jump_list *newline = NULL;
  BOOL newlinecheck = FALSE;
  BOOL readuchar = FALSE;
- if (!(hascrorlf || firstline) && (common->nltype == NLTYPE_ANY ||
+ if (!(hascrorlf || (common->match_end_ptr != 0)) &&
-     common->nltype == NLTYPE_ANYCRLF || common->newline > 255))
+     (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF || common->newline > 255))
    newlinecheck = TRUE;
- if (firstline)
+ if (common->match_end_ptr != 0)
    {
    /* Search for the end of the first line. */
-   SLJIT_ASSERT(common->first_line_end != 0);
    OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      mainloop = LABEL();
      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);
+     end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
      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_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
-     CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
+     CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
      JUMPHERE(end);
-     OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+     OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      }
    else
      {
-     end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+     end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
      mainloop = LABEL();
      /* Continual stores does not cause data dependency. */
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0);
-     read_char(common);
+     read_char_range(common, common->nlmin, common->nlmax, TRUE);
      check_newlinechar(common, common->nltype, &newline, TRUE);
-     CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
+     CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, mainloop);
      JUMPHERE(end);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0);
      set_jumps(newline, LABEL());
      }
-Line 2822 
 if (newlinecheck)
+Line 3363 
 if (newlinecheck)
    {
    newlinelabel = LABEL();
    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);
+   end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 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);
-   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
-   nl = JUMP(SLJIT_JUMP);
+   end2 = JUMP(SLJIT_JUMP);
    }
  mainloop = LABEL();
-Line 2845 
 if (readuchar)
+Line 3386 
 if (readuchar)
    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);
+   CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  #if defined COMPILE_PCRE8
  if (common->utf)
    {
-   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+   singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+   OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    JUMPHERE(singlechar);
    }
  #elif defined COMPILE_PCRE16
  if (common->utf)
    {
-   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+   singlechar = CMP(SLJIT_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);
-   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    JUMPHERE(singlechar);
-Line 2875 
 JUMPHERE(start);
+Line 3416 
 JUMPHERE(start);
  if (newlinecheck)
    {
    JUMPHERE(end);
-   JUMPHERE(nl);
+   JUMPHERE(end2);
    }
  return mainloop;
  }
- #define MAX_N_CHARS 3
+ #define MAX_N_CHARS 16
+ #define MAX_DIFF_CHARS 6
- static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
+ static SLJIT_INLINE void add_prefix_char(pcre_uchar chr, pcre_uchar *chars)
  {
- DEFINE_COMPILER;
+ pcre_uchar i, len;
- struct sljit_label *start;
- struct sljit_jump *quit;
- pcre_uint32 chars[MAX_N_CHARS * 2];
- pcre_uchar *cc = common->start + 1 + LINK_SIZE;
- int location = 0;
- pcre_int32 len, c, bit, caseless;
- int must_stop;
- /* We do not support alternatives now. */
+ len = chars[0];
- if (*(common->start + GET(common->start, 1)) == OP_ALT)
+ if (len == 255)
-   return FALSE;
+   return;
+ if (len == 0)
+   {
+   chars[0] = 1;
+   chars[1] = chr;
+   return;
+   }
+ for (i = len; i > 0; i--)
+   if (chars[i] == chr)
+     return;
+ if (len >= MAX_DIFF_CHARS - 1)
+   {
+   chars[0] = 255;
+   return;
+   }
+ len++;
+ chars[len] = chr;
+ chars[0] = len;
+ }
+ static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uchar *chars, int max_chars, pcre_uint32 *rec_count)
+ {
+ /* Recursive function, which scans prefix literals. */
+ BOOL last, any, class, caseless;
+ int len, repeat, len_save, consumed = 0;
+ sljit_u32 chr;
+ sljit_u8 *bytes, *bytes_end, byte;
+ pcre_uchar *alternative, *cc_save, *oc;
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ pcre_uchar othercase[8];
+ #elif defined SUPPORT_UTF && defined COMPILE_PCRE16
+ pcre_uchar othercase[2];
+ #else
+ pcre_uchar othercase[1];
+ #endif
+ repeat = 1;
  while (TRUE)
    {
-   caseless = 0;
+   if (*rec_count == 0)
-   must_stop = 1;
+     return 0;
-   switch(*cc)
+   (*rec_count)--;
-     {
-     case OP_CHAR:
-     must_stop = 0;
-     cc++;
-     break;
+   last = TRUE;
+   any = FALSE;
+   class = FALSE;
+   caseless = FALSE;
+   switch (*cc)
+     {
      case OP_CHARI:
-     caseless = 1;
+     caseless = TRUE;
-     must_stop = 0;
+     case OP_CHAR:
+     last = FALSE;
      cc++;
      break;
-Line 2930 
 while (TRUE)
+Line 3507 
 while (TRUE)
      cc++;
      continue;
+     case OP_ASSERT:
+     case OP_ASSERT_NOT:
+     case OP_ASSERTBACK:
+     case OP_ASSERTBACK_NOT:
+     cc = bracketend(cc);
+     continue;
+     case OP_PLUSI:
+     case OP_MINPLUSI:
+     case OP_POSPLUSI:
+     caseless = TRUE;
      case OP_PLUS:
      case OP_MINPLUS:
      case OP_POSPLUS:
      cc++;
      break;
+     case OP_EXACTI:
+     caseless = TRUE;
      case OP_EXACT:
+     repeat = GET2(cc, 1);
+     last = FALSE;
      cc += 1 + IMM2_SIZE;
      break;
-     case OP_PLUSI:
+     case OP_QUERYI:
-     case OP_MINPLUSI:
+     case OP_MINQUERYI:
-     case OP_POSPLUSI:
+     case OP_POSQUERYI:
-     caseless = 1;
+     caseless = TRUE;
+     case OP_QUERY:
+     case OP_MINQUERY:
+     case OP_POSQUERY:
+     len = 1;
      cc++;
+ #ifdef SUPPORT_UTF
+     if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
+ #endif
+     max_chars = scan_prefix(common, cc + len, chars, max_chars, rec_count);
+     if (max_chars == 0)
+       return consumed;
+     last = FALSE;
      break;
-     case OP_EXACTI:
+     case OP_KET:
-     caseless = 1;
+     cc += 1 + LINK_SIZE;
-     cc += 1 + IMM2_SIZE;
+     continue;
-     break;
-     default:
+     case OP_ALT:
-     must_stop = 2;
+     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, rec_count);
+       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:
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+     if (common->utf && !is_char7_bitset((const sljit_u8 *)(cc + 1), FALSE))
+       return consumed;
+ #endif
+     class = TRUE;
+     break;
+     case OP_NCLASS:
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf) return consumed;
+ #endif
+     class = TRUE;
+     break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_XCLASS:
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf) return consumed;
+ #endif
+     any = TRUE;
+     cc += GET(cc, 1);
+     break;
+ #endif
+     case OP_DIGIT:
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+     if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_digit, FALSE))
+       return consumed;
+ #endif
+     any = TRUE;
+     cc++;
+     break;
+     case OP_WHITESPACE:
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+     if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_space, FALSE))
+       return consumed;
+ #endif
+     any = TRUE;
+     cc++;
+     break;
+     case OP_WORDCHAR:
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+     if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_word, FALSE))
+       return consumed;
+ #endif
+     any = TRUE;
+     cc++;
+     break;
+     case OP_NOT:
+     case OP_NOTI:
+     cc++;
+     /* Fall through. */
+     case OP_NOT_DIGIT:
+     case OP_NOT_WHITESPACE:
+     case OP_NOT_WORDCHAR:
+     case OP_ANY:
+     case OP_ALLANY:
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf) return consumed;
+ #endif
+     any = TRUE;
+     cc++;
+     break;
+ #ifdef SUPPORT_UTF
+     case OP_NOTPROP:
+     case OP_PROP:
+ #ifndef COMPILE_PCRE32
+     if (common->utf) return consumed;
+ #endif
+     any = TRUE;
+     cc += 1 + 2;
+     break;
+ #endif
+     case OP_TYPEEXACT:
+     repeat = GET2(cc, 1);
+     cc += 1 + IMM2_SIZE;
+     continue;
+     case OP_NOTEXACT:
+     case OP_NOTEXACTI:
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf) return consumed;
+ #endif
+     any = TRUE;
+     repeat = GET2(cc, 1);
+     cc += 1 + IMM2_SIZE + 1;
      break;
+     default:
+     return consumed;
+     }
+   if (any)
+     {
+     do
+       {
+       chars[0] = 255;
+       consumed++;
+       if (--max_chars == 0)
+         return consumed;
+       chars += MAX_DIFF_CHARS;
+       }
+     while (--repeat > 0);
+     repeat = 1;
+     continue;
      }
-   if (must_stop == 2)
+   if (class)
+     {
+     bytes = (sljit_u8*) (cc + 1);
+     cc += 1 + 32 / sizeof(pcre_uchar);
+     switch (*cc)
+       {
+       case OP_CRSTAR:
+       case OP_CRMINSTAR:
+       case OP_CRPOSSTAR:
+       case OP_CRQUERY:
+       case OP_CRMINQUERY:
+       case OP_CRPOSQUERY:
+       max_chars = scan_prefix(common, cc + 1, chars, max_chars, rec_count);
+       if (max_chars == 0)
+         return consumed;
+       break;
+       default:
+       case OP_CRPLUS:
+       case OP_CRMINPLUS:
+       case OP_CRPOSPLUS:
+       break;
+       case OP_CRRANGE:
+       case OP_CRMINRANGE:
+       case OP_CRPOSRANGE:
+       repeat = GET2(cc, 1);
+       if (repeat <= 0)
+         return consumed;
+       break;
+       }
+     do
+       {
+       if (bytes[31] & 0x80)
+         chars[0] = 255;
+       else if (chars[0] != 255)
+         {
+         bytes_end = bytes + 32;
+         chr = 0;
+         do
+           {
+           byte = *bytes++;
+           SLJIT_ASSERT((chr & 0x7) == 0);
+           if (byte == 0)
+             chr += 8;
+           else
+             {
+             do
+               {
+               if ((byte & 0x1) != 0)
+                 add_prefix_char(chr, chars);
+               byte >>= 1;
+               chr++;
+               }
+             while (byte != 0);
+             chr = (chr + 7) & ~7;
+             }
+           }
+         while (chars[0] != 255 && bytes < bytes_end);
+         bytes = bytes_end - 32;
+         }
+       consumed++;
+       if (--max_chars == 0)
+         return consumed;
+       chars += MAX_DIFF_CHARS;
+       }
+     while (--repeat > 0);
+     switch (*cc)
+       {
+       case OP_CRSTAR:
+       case OP_CRMINSTAR:
+       case OP_CRPOSSTAR:
+       return consumed;
+       case OP_CRQUERY:
+       case OP_CRMINQUERY:
+       case OP_CRPOSQUERY:
+       cc++;
        break;
+       case OP_CRRANGE:
+       case OP_CRMINRANGE:
+       case OP_CRPOSRANGE:
+       if (GET2(cc, 1) != GET2(cc, 1 + IMM2_SIZE))
+         return consumed;
+       cc += 1 + 2 * IMM2_SIZE;
+       break;
+       }
+     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))
      {
-     caseless = char_get_othercase_bit(common, cc);
+ #ifdef SUPPORT_UTF
-     if (caseless == 0)
+     if (common->utf)
-       return FALSE;
+       {
- #ifdef COMPILE_PCRE8
+       GETCHAR(chr, cc);
-     caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));
+       if ((int)PRIV(ord2utf)(char_othercase(common, chr), othercase) != len)
- #else
+         return consumed;
-     if ((caseless & 0x100) != 0)
+       }
-       caseless = ((caseless & 0xff) << 16) | (len - (caseless >> 9));
      else
-       caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 9));
  #endif
+       {
+       chr = *cc;
+       othercase[0] = TABLE_GET(chr, common->fcc, chr);
+       }
      }
    else
-     caseless = 0;
+     {
+     caseless = FALSE;
+     othercase[0] = 0; /* Stops compiler warning - PH */
+     }
-   while (len > 0 && location < MAX_N_CHARS * 2)
+   len_save = len;
+   cc_save = cc;
+   while (TRUE)
      {
-     c = *cc;
+     oc = othercase;
-     bit = 0;
+     do
-     if (len == (caseless & 0xff))
        {
-       bit = caseless >> 8;
+       chr = *cc;
-       c |= bit;
+       add_prefix_char(*cc, chars);
+       if (caseless)
+         add_prefix_char(*oc, chars);
+       len--;
+       consumed++;
+       if (--max_chars == 0)
+         return consumed;
+       chars += MAX_DIFF_CHARS;
+       cc++;
+       oc++;
        }
+     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;
-     break;
+   if (last)
+     return consumed;
+   }
+ }
+ #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
+ static sljit_s32 character_to_int32(pcre_uchar chr)
+ {
+ sljit_s32 value = (sljit_s32)chr;
+ #if defined COMPILE_PCRE8
+ #define SSE2_COMPARE_TYPE_INDEX 0
+ return (value << 24) | (value << 16) | (value << 8) | value;
+ #elif defined COMPILE_PCRE16
+ #define SSE2_COMPARE_TYPE_INDEX 1
+ return (value << 16) | value;
+ #elif defined COMPILE_PCRE32
+ #define SSE2_COMPARE_TYPE_INDEX 2
+ return value;
+ #else
+ #error "Unsupported unit width"
+ #endif
+ }
+ static SLJIT_INLINE void fast_forward_first_char2_sse2(compiler_common *common, pcre_uchar char1, pcre_uchar char2)
+ {
+ DEFINE_COMPILER;
+ struct sljit_label *start;
+ struct sljit_jump *quit[3];
+ struct sljit_jump *nomatch;
+ sljit_u8 instruction[8];
+ sljit_s32 tmp1_ind = sljit_get_register_index(TMP1);
+ sljit_s32 tmp2_ind = sljit_get_register_index(TMP2);
+ sljit_s32 str_ptr_ind = sljit_get_register_index(STR_PTR);
+ BOOL load_twice = FALSE;
+ pcre_uchar bit;
+ bit = char1 ^ char2;
+ if (!is_powerof2(bit))
+   bit = 0;
+ if ((char1 != char2) && bit == 0)
+   load_twice = TRUE;
+ quit[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ /* First part (unaligned start) */
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, character_to_int32(char1 | bit));
+ SLJIT_ASSERT(tmp1_ind < 8 && tmp2_ind == 1);
+ /* MOVD xmm, r/m32 */
+ instruction[0] = 0x66;
+ instruction[1] = 0x0f;
+ instruction[2] = 0x6e;
+ instruction[3] = 0xc0 | (2 << 3) | tmp1_ind;
+ sljit_emit_op_custom(compiler, instruction, 4);
+ if (char1 != char2)
+   {
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, character_to_int32(bit != 0 ? bit : char2));
+   /* MOVD xmm, r/m32 */
+   instruction[3] = 0xc0 | (3 << 3) | tmp1_ind;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   }
+ /* PSHUFD xmm1, xmm2/m128, imm8 */
+ instruction[2] = 0x70;
+ instruction[3] = 0xc0 | (2 << 3) | 2;
+ instruction[4] = 0;
+ sljit_emit_op_custom(compiler, instruction, 5);
+ if (char1 != char2)
+   {
+   /* PSHUFD xmm1, xmm2/m128, imm8 */
+   instruction[3] = 0xc0 | (3 << 3) | 3;
+   instruction[4] = 0;
+   sljit_emit_op_custom(compiler, instruction, 5);
+   }
+ OP2(SLJIT_AND, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 0xf);
+ OP2(SLJIT_AND, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, ~0xf);
+ /* MOVDQA xmm1, xmm2/m128 */
+ #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
+ if (str_ptr_ind < 8)
+   {
+   instruction[2] = 0x6f;
+   instruction[3] = (0 << 3) | str_ptr_ind;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   if (load_twice)
+     {
+     instruction[3] = (1 << 3) | str_ptr_ind;
+     sljit_emit_op_custom(compiler, instruction, 4);
+     }
+   }
+ else
+   {
+   instruction[1] = 0x41;
+   instruction[2] = 0x0f;
+   instruction[3] = 0x6f;
+   instruction[4] = (0 << 3) | (str_ptr_ind & 0x7);
+   sljit_emit_op_custom(compiler, instruction, 5);
+   if (load_twice)
+     {
+     instruction[4] = (1 << 3) | str_ptr_ind;
+     sljit_emit_op_custom(compiler, instruction, 5);
+     }
+   instruction[1] = 0x0f;
+   }
+ #else
+ instruction[2] = 0x6f;
+ instruction[3] = (0 << 3) | str_ptr_ind;
+ sljit_emit_op_custom(compiler, instruction, 4);
+ if (load_twice)
+   {
+   instruction[3] = (1 << 3) | str_ptr_ind;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   }
+ #endif
+ if (bit != 0)
+   {
+   /* POR xmm1, xmm2/m128 */
+   instruction[2] = 0xeb;
+   instruction[3] = 0xc0 | (0 << 3) | 3;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   }
+ /* PCMPEQB/W/D xmm1, xmm2/m128 */
+ instruction[2] = 0x74 + SSE2_COMPARE_TYPE_INDEX;
+ instruction[3] = 0xc0 | (0 << 3) | 2;
+ sljit_emit_op_custom(compiler, instruction, 4);
+ if (load_twice)
+   {
+   instruction[3] = 0xc0 | (1 << 3) | 3;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   }
+ /* PMOVMSKB reg, xmm */
+ instruction[2] = 0xd7;
+ instruction[3] = 0xc0 | (tmp1_ind << 3) | 0;
+ sljit_emit_op_custom(compiler, instruction, 4);
+ if (load_twice)
+   {
+   OP1(SLJIT_MOV, TMP3, 0, TMP2, 0);
+   instruction[3] = 0xc0 | (tmp2_ind << 3) | 1;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+   OP1(SLJIT_MOV, TMP2, 0, TMP3, 0);
    }
- /* At least two characters are required. */
+ OP2(SLJIT_ASHR, TMP1, 0, TMP1, 0, TMP2, 0);
- if (location < 2 * 2)
+ /* BSF r32, r/m32 */
+ instruction[0] = 0x0f;
+ instruction[1] = 0xbc;
+ instruction[2] = 0xc0 | (tmp1_ind << 3) | tmp1_ind;
+ sljit_emit_op_custom(compiler, instruction, 3);
+ nomatch = JUMP(SLJIT_ZERO);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+ quit[1] = JUMP(SLJIT_JUMP);
+ JUMPHERE(nomatch);
+ start = LABEL();
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 16);
+ quit[2] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ /* Second part (aligned) */
+ instruction[0] = 0x66;
+ instruction[1] = 0x0f;
+ /* MOVDQA xmm1, xmm2/m128 */
+ #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
+ if (str_ptr_ind < 8)
+   {
+   instruction[2] = 0x6f;
+   instruction[3] = (0 << 3) | str_ptr_ind;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   if (load_twice)
+     {
+     instruction[3] = (1 << 3) | str_ptr_ind;
+     sljit_emit_op_custom(compiler, instruction, 4);
+     }
+   }
+ else
+   {
+   instruction[1] = 0x41;
+   instruction[2] = 0x0f;
+   instruction[3] = 0x6f;
+   instruction[4] = (0 << 3) | (str_ptr_ind & 0x7);
+   sljit_emit_op_custom(compiler, instruction, 5);
+   if (load_twice)
+     {
+     instruction[4] = (1 << 3) | str_ptr_ind;
+     sljit_emit_op_custom(compiler, instruction, 5);
+     }
+   instruction[1] = 0x0f;
+   }
+ #else
+ instruction[2] = 0x6f;
+ instruction[3] = (0 << 3) | str_ptr_ind;
+ sljit_emit_op_custom(compiler, instruction, 4);
+ if (load_twice)
+   {
+   instruction[3] = (1 << 3) | str_ptr_ind;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   }
+ #endif
+ if (bit != 0)
+   {
+   /* POR xmm1, xmm2/m128 */
+   instruction[2] = 0xeb;
+   instruction[3] = 0xc0 | (0 << 3) | 3;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   }
+ /* PCMPEQB/W/D xmm1, xmm2/m128 */
+ instruction[2] = 0x74 + SSE2_COMPARE_TYPE_INDEX;
+ instruction[3] = 0xc0 | (0 << 3) | 2;
+ sljit_emit_op_custom(compiler, instruction, 4);
+ if (load_twice)
+   {
+   instruction[3] = 0xc0 | (1 << 3) | 3;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   }
+ /* PMOVMSKB reg, xmm */
+ instruction[2] = 0xd7;
+ instruction[3] = 0xc0 | (tmp1_ind << 3) | 0;
+ sljit_emit_op_custom(compiler, instruction, 4);
+ if (load_twice)
+   {
+   instruction[3] = 0xc0 | (tmp2_ind << 3) | 1;
+   sljit_emit_op_custom(compiler, instruction, 4);
+   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+   }
+ /* BSF r32, r/m32 */
+ instruction[0] = 0x0f;
+ instruction[1] = 0xbc;
+ instruction[2] = 0xc0 | (tmp1_ind << 3) | tmp1_ind;
+ sljit_emit_op_custom(compiler, instruction, 3);
+ JUMPTO(SLJIT_ZERO, start);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+ start = LABEL();
+ SET_LABEL(quit[0], start);
+ SET_LABEL(quit[1], start);
+ SET_LABEL(quit[2], start);
+ }
+ #undef SSE2_COMPARE_TYPE_INDEX
+ #endif
+ static void fast_forward_first_char2(compiler_common *common, pcre_uchar char1, pcre_uchar char2, sljit_s32 offset)
+ {
+ DEFINE_COMPILER;
+ struct sljit_label *start;
+ struct sljit_jump *quit;
+ struct sljit_jump *found;
+ pcre_uchar mask;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ struct sljit_label *utf_start = NULL;
+ struct sljit_jump *utf_quit = NULL;
+ #endif
+ BOOL has_match_end_ptr = (common->match_end_ptr != 0);
+ if (offset > 0)
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));
+ if (has_match_end_ptr)
+   {
+   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
+   OP2(SLJIT_ADD, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, SLJIT_IMM, IN_UCHARS(offset + 1));
+ #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
+   if (sljit_x86_is_cmov_available())
+     {
+     OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_END, 0, TMP3, 0);
+     sljit_x86_emit_cmov(compiler, SLJIT_GREATER, STR_END, TMP3, 0);
+     }
+ #endif
+     {
+     quit = CMP(SLJIT_LESS_EQUAL, STR_END, 0, TMP3, 0);
+     OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+     JUMPHERE(quit);
+     }
+   }
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ if (common->utf && offset > 0)
+   utf_start = LABEL();
+ #endif
+ #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
+ /* SSE2 accelerated first character search. */
+ if (sljit_x86_is_sse2_available())
+   {
+   fast_forward_first_char2_sse2(common, char1, char2);
+   SLJIT_ASSERT(common->mode == JIT_COMPILE || offset == 0);
+   if (common->mode == JIT_COMPILE)
+     {
+     /* In complete mode, we don't need to run a match when STR_PTR == STR_END. */
+     SLJIT_ASSERT(common->forced_quit_label == NULL);
+     OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
+     add_jump(compiler, &common->forced_quit, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf && offset > 0)
+       {
+       SLJIT_ASSERT(common->mode == JIT_COMPILE);
+       OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-offset));
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if defined COMPILE_PCRE8
+       OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
+       CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, utf_start);
+ #elif defined COMPILE_PCRE16
+       OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+       CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, utf_start);
+ #else
+ #error "Unknown code width"
+ #endif
+       OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+       }
+ #endif
+     if (offset > 0)
+       OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));
+     }
+   else if (sljit_x86_is_cmov_available())
+     {
+     OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, STR_END, 0);
+     sljit_x86_emit_cmov(compiler, SLJIT_GREATER_EQUAL, STR_PTR, has_match_end_ptr ? SLJIT_MEM1(SLJIT_SP) : STR_END, has_match_end_ptr ? common->match_end_ptr : 0);
+     }
+   else
+     {
+     quit = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
+     OP1(SLJIT_MOV, STR_PTR, 0, has_match_end_ptr ? SLJIT_MEM1(SLJIT_SP) : STR_END, has_match_end_ptr ? common->match_end_ptr : 0);
+     JUMPHERE(quit);
+     }
+   if (has_match_end_ptr)
+     OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+   return;
+   }
+ #endif
+ quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ start = LABEL();
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ if (char1 == char2)
+   found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, char1);
+ else
+   {
+   mask = char1 ^ char2;
+   if (is_powerof2(mask))
+     {
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, mask);
+     found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, char1 | mask);
+     }
+   else
+     {
+     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char1);
+     OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
+     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char2);
+     OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
+     found = JUMP(SLJIT_NOT_ZERO);
+     }
+   }
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, start);
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ if (common->utf && offset > 0)
+   utf_quit = JUMP(SLJIT_JUMP);
+ #endif
+ JUMPHERE(found);
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ if (common->utf && offset > 0)
+   {
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-offset));
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if defined COMPILE_PCRE8
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
+   CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, utf_start);
+ #elif defined COMPILE_PCRE16
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+   CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, utf_start);
+ #else
+ #error "Unknown code width"
+ #endif
+   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   JUMPHERE(utf_quit);
+   }
+ #endif
+ JUMPHERE(quit);
+ if (has_match_end_ptr)
+   {
+   quit = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
+   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
+   if (offset > 0)
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));
+   JUMPHERE(quit);
+   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+   }
+ if (offset > 0)
+   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));
+ }
+ static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common)
+ {
+ DEFINE_COMPILER;
+ struct sljit_label *start;
+ struct sljit_jump *quit;
+ struct sljit_jump *match;
+ /* bytes[0] represent the number of characters between 0
+ and MAX_N_BYTES - 1, 255 represents any character. */
+ pcre_uchar chars[MAX_N_CHARS * MAX_DIFF_CHARS];
+ sljit_s32 offset;
+ pcre_uchar mask;
+ pcre_uchar *char_set, *char_set_end;
+ int i, max, from;
+ int range_right = -1, range_len;
+ sljit_u8 *update_table = NULL;
+ BOOL in_range;
+ sljit_u32 rec_count;
+ for (i = 0; i < MAX_N_CHARS; i++)
+   chars[i * MAX_DIFF_CHARS] = 0;
+ rec_count = 10000;
+ max = scan_prefix(common, common->start, chars, MAX_N_CHARS, &rec_count);
+ if (max < 1)
+   return FALSE;
+ in_range = FALSE;
+ /* Prevent compiler "uninitialized" warning */
+ from = 0;
+ range_len = 4 /* minimum length */ - 1;
+ for (i = 0; i <= max; i++)
+   {
+   if (in_range && (i - from) > range_len && (chars[(i - 1) * MAX_DIFF_CHARS] < 255))
+     {
+     range_len = i - from;
+     range_right = i - 1;
+     }
+   if (i < max && chars[i * MAX_DIFF_CHARS] < 255)
+     {
+     SLJIT_ASSERT(chars[i * MAX_DIFF_CHARS] > 0);
+     if (!in_range)
+       {
+       in_range = TRUE;
+       from = i;
+       }
+     }
+   else
+     in_range = FALSE;
+   }
+ if (range_right >= 0)
+   {
+   update_table = (sljit_u8 *)allocate_read_only_data(common, 256);
+   if (update_table == NULL)
+     return TRUE;
+   memset(update_table, IN_UCHARS(range_len), 256);
+   for (i = 0; i < range_len; i++)
+     {
+     char_set = chars + ((range_right - i) * MAX_DIFF_CHARS);
+     SLJIT_ASSERT(char_set[0] > 0 && char_set[0] < 255);
+     char_set_end = char_set + char_set[0];
+     char_set++;
+     while (char_set <= char_set_end)
+       {
+       if (update_table[(*char_set) & 0xff] > IN_UCHARS(i))
+         update_table[(*char_set) & 0xff] = IN_UCHARS(i);
+       char_set++;
+       }
+     }
+   }
+ offset = -1;
+ /* Scan forward. */
+ for (i = 0; i < max; i++)
+   {
+   if (offset == -1)
+     {
+     if (chars[i * MAX_DIFF_CHARS] <= 2)
+       offset = i;
+     }
+   else if (chars[offset * MAX_DIFF_CHARS] == 2 && chars[i * MAX_DIFF_CHARS] <= 2)
+     {
+     if (chars[i * MAX_DIFF_CHARS] == 1)
+       offset = i;
+     else
+       {
+       mask = chars[offset * MAX_DIFF_CHARS + 1] ^ chars[offset * MAX_DIFF_CHARS + 2];
+       if (!is_powerof2(mask))
+         {
+         mask = chars[i * MAX_DIFF_CHARS + 1] ^ chars[i * MAX_DIFF_CHARS + 2];
+         if (is_powerof2(mask))
+           offset = i;
+         }
+       }
+     }
+   }
+ if (range_right < 0)
+   {
+   if (offset < 0)
      return FALSE;
+   SLJIT_ASSERT(chars[offset * MAX_DIFF_CHARS] >= 1 && chars[offset * MAX_DIFF_CHARS] <= 2);
+   /* Works regardless the value is 1 or 2. */
+   mask = chars[offset * MAX_DIFF_CHARS + chars[offset * MAX_DIFF_CHARS]];
+   fast_forward_first_char2(common, chars[offset * MAX_DIFF_CHARS + 1], mask, offset);
+   return TRUE;
+   }
+ if (range_right == offset)
+   offset = -1;
- if (firstline)
+ SLJIT_ASSERT(offset == -1 || (chars[offset * MAX_DIFF_CHARS] >= 1 && chars[offset * MAX_DIFF_CHARS] <= 2));
+ max -= 1;
+ SLJIT_ASSERT(max > 0);
+ if (common->match_end_ptr != 0)
    {
-   SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
    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, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
+   quit = CMP(SLJIT_LESS_EQUAL, STR_END, 0, TMP1, 0);
+   OP1(SLJIT_MOV, STR_END, 0, TMP1, 0);
+   JUMPHERE(quit);
    }
  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));
+ SLJIT_ASSERT(range_right >= 0);
+ #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
+ OP1(SLJIT_MOV, RETURN_ADDR, 0, SLJIT_IMM, (sljit_sw)update_table);
+ #endif
  start = LABEL();
- quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+ #if defined COMPILE_PCRE8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right));
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #else
- if (chars[1] != 0)
+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right + 1) - 1);
-   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
+ #endif
- CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
- if (location > 2 * 2)
+ #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
-   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(RETURN_ADDR, TMP1), 0);
- if (chars[3] != 0)
+ #else
-   OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[3]);
+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)update_table);
- CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[2], start);
+ #endif
- if (location > 2 * 2)
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
-   {
+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start);
-   if (chars[5] != 0)
-     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[5]);
+ if (offset >= 0)
-   CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[4], start);
+   {
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offset));
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   if (chars[offset * MAX_DIFF_CHARS] == 1)
+     CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1], start);
+   else
+     {
+     mask = chars[offset * MAX_DIFF_CHARS + 1] ^ chars[offset * MAX_DIFF_CHARS + 2];
+     if (is_powerof2(mask))
+       {
+       OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, mask);
+       CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1] | mask, start);
+       }
+     else
+       {
+       match = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1]);
+       CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 2], start);
+       JUMPHERE(match);
+       }
+     }
+   }
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ if (common->utf && offset != 0)
+   {
+   if (offset < 0)
+     {
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+     }
+   else
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
+ #if defined COMPILE_PCRE8
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
+   CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, start);
+ #elif defined COMPILE_PCRE16
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+   CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, start);
+ #else
+ #error "Unknown code width"
+ #endif
+   if (offset < 0)
+     OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    }
- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #endif
+ if (offset >= 0)
+   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  JUMPHERE(quit);
- if (firstline)
+ if (common->match_end_ptr != 0)
+   {
+   if (range_right >= 0)
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+   if (range_right >= 0)
+     {
+     quit = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
+     OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
+     JUMPHERE(quit);
+     }
+   }
  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;
  }
  #undef MAX_N_CHARS
+ #undef MAX_DIFF_CHARS
- static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)
+ static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless)
  {
- DEFINE_COMPILER;
+ pcre_uchar oc;
- struct sljit_label *start;
- struct sljit_jump *quit;
- struct sljit_jump *found;
- pcre_uchar oc, bit;
- if (firstline)
-   {
-   SLJIT_ASSERT(common->first_line_end != 0);
-   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
-   }
- start = LABEL();
- quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
  oc = first_char;
  if (caseless)
    {
    oc = TABLE_GET(first_char, common->fcc, first_char);
- #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+ #if defined SUPPORT_UTF && !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
-   {
-   bit = first_char ^ oc;
-   if (is_powerof2(bit))
-     {
-     OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 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, first_char);
-     OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
-     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);
-     OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
-     found = JUMP(SLJIT_C_NOT_ZERO);
-     }
-   }
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ fast_forward_first_char2(common, first_char, oc, 0);
- JUMPTO(SLJIT_JUMP, start);
- JUMPHERE(found);
- JUMPHERE(quit);
- if (firstline)
-   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
- static SLJIT_INLINE void fast_forward_newline(compiler_common *common, BOOL firstline)
+ static SLJIT_INLINE void fast_forward_newline(compiler_common *common)
  {
  DEFINE_COMPILER;
  struct sljit_label *loop;
-Line 3118 
 struct sljit_jump *foundcr = NULL;
+Line 4556 
 struct sljit_jump *foundcr = NULL;
  struct sljit_jump *notfoundnl;
  jump_list *newline = NULL;
- if (firstline)
+ if (common->match_end_ptr != 0)
    {
-   SLJIT_ASSERT(common->first_line_end != 0);
    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
    }
  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
    {
-   lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
-   firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
+   firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
    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);
-   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_GREATER_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
-Line 3143 
 if (common->nltype == NLTYPE_FIXED && co
+Line 4580 
 if (common->nltype == NLTYPE_FIXED && co
    loop = LABEL();
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-   quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
    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_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);
-   CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);
+   CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);
    JUMPHERE(quit);
    JUMPHERE(firstchar);
    JUMPHERE(lastchar);
-   if (firstline)
+   if (common->match_end_ptr != 0)
-     OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+     OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
    return;
    }
  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
- firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
+ firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
  skip_char_back(common);
  loop = LABEL();
- read_char(common);
+ common->ff_newline_shortcut = loop;
- lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ read_char_range(common, common->nlmin, common->nlmax, TRUE);
+ lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
  if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
-   foundcr = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
+   foundcr = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
  check_newlinechar(common, common->nltype, &newline, FALSE);
  set_jumps(newline, loop);
-Line 3175 
 if (common->nltype == NLTYPE_ANY || comm
+Line 4614 
 if (common->nltype == NLTYPE_ANY || comm
    {
    quit = JUMP(SLJIT_JUMP);
    JUMPHERE(foundcr);
-   notfoundnl = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   notfoundnl = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 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);
-   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
-Line 3189 
 if (common->nltype == NLTYPE_ANY || comm
+Line 4628 
 if (common->nltype == NLTYPE_ANY || comm
  JUMPHERE(lastchar);
  JUMPHERE(firstchar);
- if (firstline)
+ if (common->match_end_ptr != 0)
    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, sljit_u8 *start_bits)
  {
  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)
+ if (common->match_end_ptr != 0)
-   inverted_start_bits[i] = ~(((pcre_uint8*)start_bits)[i]);
- if (firstline)
    {
-   SLJIT_ASSERT(common->first_line_end != 0);
    OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
    }
  start = LABEL();
- quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
  #ifdef SUPPORT_UTF
  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);
+   jump = CMP(SLJIT_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);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), start_bits);
+   OP1(SLJIT_MOV_U8, 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);
+   found = JUMP(SLJIT_NOT_ZERO);
    }
  #ifdef SUPPORT_UTF
-Line 3250 
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, S
+Line 4683 
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, S
  #if defined COMPILE_PCRE8
  if (common->utf)
    {
-   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
+   CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+   OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    }
  #elif defined COMPILE_PCRE16
  if (common->utf)
    {
-   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
+   CMPTO(SLJIT_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);
-   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    }
-Line 3273 
 if (matches != NULL)
+Line 4706 
 if (matches != NULL)
    set_jumps(matches, LABEL());
  JUMPHERE(quit);
- if (firstline)
+ if (common->match_end_ptr != 0)
    OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0);
  }
-Line 3289 
 struct sljit_jump *notfound;
+Line 4722 
 struct sljit_jump *notfound;
  pcre_uint32 oc, bit;
  SLJIT_ASSERT(common->req_char_ptr != 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr);
  OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);
- toolong = CMP(SLJIT_C_LESS, TMP1, 0, STR_END, 0);
+ toolong = CMP(SLJIT_LESS, TMP1, 0, STR_END, 0);
- alreadyfound = CMP(SLJIT_C_LESS, STR_PTR, 0, TMP2, 0);
+ alreadyfound = CMP(SLJIT_LESS, STR_PTR, 0, TMP2, 0);
  if (has_firstchar)
    OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-Line 3300 
 else
+Line 4733 
 else
    OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);
  loop = LABEL();
- notfound = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, STR_END, 0);
+ notfound = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, STR_END, 0);
  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);
  oc = req_char;
-Line 3313 
 if (caseless)
+Line 4746 
 if (caseless)
  #endif
    }
  if (req_char == oc)
-   found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
+   found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
  else
    {
    bit = req_char ^ oc;
    if (is_powerof2(bit))
      {
      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
-     found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
+     found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
      }
    else
      {
-     found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
+     found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
-     foundoc = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, oc);
+     foundoc = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, oc);
      }
    }
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
-Line 3334 
 JUMPTO(SLJIT_JUMP, loop);
+Line 4767 
 JUMPTO(SLJIT_JUMP, loop);
  JUMPHERE(found);
  if (foundoc)
    JUMPHERE(foundoc);
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr, TMP1, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, TMP1, 0);
  JUMPHERE(alreadyfound);
  JUMPHERE(toolong);
  return notfound;
-Line 3354 
 GET_LOCAL_BASE(TMP3, 0, 0);
+Line 4787 
 GET_LOCAL_BASE(TMP3, 0, 0);
  mainloop = LABEL();
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
  OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);
- jump = JUMP(SLJIT_C_SIG_LESS_EQUAL);
+ jump = JUMP(SLJIT_SIG_LESS_EQUAL);
  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
-Line 3363 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
+Line 4796 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
  JUMPTO(SLJIT_JUMP, mainloop);
  JUMPHERE(jump);
- jump = JUMP(SLJIT_C_SIG_LESS);
+ jump = JUMP(SLJIT_SIG_LESS);
  /* End of dropping frames. */
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
-Line 3386 
 struct sljit_jump *jump;
+Line 4819 
 struct sljit_jump *jump;
  SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);
- sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
+ sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
  /* Get type of the previous char, and put it to LOCALS1. */
  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, SLJIT_IMM, 0);
- skipread = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
+ skipread = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
  skip_char_back(common);
  check_start_used_ptr(common);
  read_char(common);
-Line 3401 
 read_char(common);
+Line 4834 
 read_char(common);
  if (common->use_ucp)
    {
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
-   jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
+   jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
-   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
-   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
    JUMPHERE(jump);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP2, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP2, 0);
    }
  else
  #endif
    {
  #ifndef COMPILE_PCRE8
-   jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+   jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
  #elif defined SUPPORT_UTF
    /* Here LOCALS1 has already been zeroed. */
    jump = NULL;
    if (common->utf)
-     jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+     jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
  #endif /* COMPILE_PCRE8 */
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);
+   OP1(SLJIT_MOV_U8, 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);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);
  #ifndef COMPILE_PCRE8
    JUMPHERE(jump);
  #elif defined SUPPORT_UTF
-Line 3438 
 JUMPHERE(skipread);
+Line 4871 
 JUMPHERE(skipread);
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
  check_str_end(common, &skipread_list);
- peek_char(common);
+ peek_char(common, READ_CHAR_MAX);
  /* Testing char type. This is a code duplication. */
  #ifdef SUPPORT_UCP
  if (common->use_ucp)
    {
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
-   jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
+   jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
-   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
-   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
    JUMPHERE(jump);
    }
  else
-Line 3461 
 else
+Line 4894 
 else
  #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);
+   jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
  #elif defined SUPPORT_UTF
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
    jump = NULL;
    if (common->utf)
-     jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
+     jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
  #endif
-   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);
+   OP1(SLJIT_MOV_U8, 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);
  #ifndef COMPILE_PCRE8
-Line 3480 
 else
+Line 4913 
 else
    }
  set_jumps(skipread_list, LABEL());
- OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
+ OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
- sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
+ sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), 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 3602 
 for (i = 0; i < 256; )
+Line 4940 
 for (i = 0; i < 256; )
        {
        if (length >= MA