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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1247 by zherczeg,
Mon Feb 11 21:37:46 2013 UTC
+revision 1624 by zherczeg,
Fri Feb  5 13:47:43 2016 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2012 University of Cambridge
+            Copyright (c) 1997-2013 University of Cambridge
    The machine code generator part (this module) was written by Zoltan Herczeg
-                       Copyright (c) 2010-2012
+                       Copyright (c) 2010-2013
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 52 
 POSSIBILITY OF SUCH DAMAGE.
  we just include it. This way we don't need to touch the build
  system files. */
- #define SLJIT_MALLOC(size) (PUBL(malloc))(size)
+ #define SLJIT_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 71 
 system files. */
 - Enable capture_last_ptr (includes option 1). */
  /* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */
+ /* 1 - Always have a control head. */
+ /* #define DEBUG_FORCE_CONTROL_HEAD 1 */
  /* Allocate memory for the regex stack on the real machine stack.
  Fast, but limited size. */
  #define MACHINE_STACK_SIZE 32768
-Line 165 
 typedef struct jit_arguments {
+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 175 
 typedef struct jit_arguments {
+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_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
+   pcre_uint32 limit_match;
  } executable_functions;
  typedef struct jump_list {
-Line 186 
 typedef struct jump_list {
+Line 192 
 typedef struct jump_list {
    struct jump_list *next;
  } jump_list;
- enum stub_types { stack_alloc };
  typedef struct stub_list {
-   enum stub_types type;
-   int data;
    struct sljit_jump *start;
    struct sljit_label *quit;
    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
+ };
+ enum control_types {
+   type_mark = 0,
+   type_then_trap = 1
+ };
  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
  /* 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 216 
 typedef struct backtrack_common {
+Line 234 
 typedef struct backtrack_common {
  typedef struct assert_backtrack {
    backtrack_common common;
    jump_list *condfailed;
-   /* Less than 0 (-1) if a frame is not needed. */
+   /* Less than 0 if a frame is not needed. */
    int framesize;
    /* Points to our private memory word on the stack. */
    int private_data_ptr;
-Line 237 
 typedef struct bracket_backtrack {
+Line 255 
 typedef struct bracket_backtrack {
      /* Both for OP_COND, OP_SCOND. */
      jump_list *condfailed;
      assert_backtrack *assert;
-     /* For OP_ONCE. -1 if not needed. */
+     /* For OP_ONCE. Less than 0 if not needed. */
      int framesize;
    } u;
    /* Points to our private memory word on the stack. */
-Line 272 
 typedef struct recurse_entry {
+Line 290 
 typedef struct recurse_entry {
    /* Collects the calls until the function is not created. */
    jump_list *calls;
    /* Points to the starting opcode. */
-   int start;
+   sljit_sw start;
  } recurse_entry;
  typedef struct recurse_backtrack {
    backtrack_common common;
+   BOOL inlined_pattern;
  } recurse_backtrack;
- #define MAX_RANGE_SIZE 6
+ #define OP_THEN_TRAP OP_TABLE_LENGTH
+ typedef struct then_trap_backtrack {
+   backtrack_common common;
+   /* If then_trap is not NULL, this structure contains the real
+   then_trap for the backtracking path. */
+   struct then_trap_backtrack *then_trap;
+   /* Points to the starting opcode. */
+   sljit_sw start;
+   /* Exit point for the then opcodes of this alternative. */
+   jump_list *quit;
+   /* Frame size of the current alternative. */
+   int framesize;
+ } then_trap_backtrack;
+ #define MAX_RANGE_SIZE 4
  typedef struct compiler_common {
+   /* The sljit ceneric compiler. */
    struct sljit_compiler *compiler;
+   /* First byte code. */
    pcre_uchar *start;
    /* Maps private data offset to each opcode. */
-   int *private_data_ptrs;
+   sljit_si *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;
+   /* Tells whether the starting offset is a target of then. */
+   pcre_uint8 *then_offsets;
+   /* Current position where a THEN must jump. */
+   then_trap_backtrack *then_trap;
    /* Starting offset of private data for capturing brackets. */
-   int cbraptr;
+   int cbra_ptr;
-   /* OVector starting point. Must be divisible by 2. */
+   /* Output vector starting point. Must be divisible by 2. */
    int ovector_start;
    /* Last known position of the requested byte. */
    int req_char_ptr;
-Line 305 
 typedef struct compiler_common {
+Line 346 
 typedef struct compiler_common {
    int first_line_end;
    /* Points to the marked string. */
    int mark_ptr;
+   /* Recursive control verb management chain. */
+   int control_head_ptr;
    /* Points to the last matched capture block index. */
    int capture_last_ptr;
+   /* Points to the starting position of the current match. */
+   int start_ptr;
    /* Flipped and lower case tables. */
    const pcre_uint8 *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. */
+   BOOL needs_start_ptr;
+   /* Currently in recurse or negative assert. */
+   BOOL local_exit;
+   /* Currently in a positive assert. */
+   BOOL positive_assert;
    /* Newline control. */
    int nltype;
+   pcre_uint32 nlmax;
+   pcre_uint32 nlmin;
    int newline;
    int bsr_nltype;
+   pcre_uint32 bsr_nlmax;
+   pcre_uint32 bsr_nlmin;
    /* Dollar endonly. */
    int endonly;
-   BOOL has_set_som;
    /* 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 333 
 typedef struct compiler_common {
+Line 394 
 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;
    jump_list *quit;
+   jump_list *positive_assert_quit;
    jump_list *forced_quit;
    jump_list *accept;
    jump_list *calllimit;
-Line 349 
 typedef struct compiler_common {
+Line 413 
 typedef struct compiler_common {
    jump_list *vspace;
    jump_list *casefulcmp;
    jump_list *caselesscmp;
+   jump_list *reset_match;
    BOOL jscript_compat;
  #ifdef SUPPORT_UTF
    BOOL utf;
  #ifdef SUPPORT_UCP
    BOOL use_ucp;
  #endif
- #ifndef COMPILE_PCRE32
-   jump_list *utfreadchar;
- #endif
  #ifdef COMPILE_PCRE8
+   jump_list *utfreadchar;
+   jump_list *utfreadchar16;
    jump_list *utfreadtype8;
  #endif
  #endif /* SUPPORT_UTF */
-Line 407 
 typedef struct compare_context {
+Line 471 
 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 426 
 typedef struct compare_context {
+Line 490 
 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->cbraptr + (i) * sizeof(sljit_sw))
+ #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))
  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
  #if defined COMPILE_PCRE8
-Line 475 
 the start pointers when the end of the c
+Line 539 
 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 484 
 cc += 1 + LINK_SIZE;
+Line 550 
 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;
+ }
+ static int ones_in_half_byte[16] = {
+   /* 0 */ 0, 1, 1, 2, /* 4 */ 1, 2, 2, 3,
+   /* 8 */ 1, 2, 2, 3, /* 12 */ 2, 3, 3, 4
+ };
  /* Functions whose might need modification for all new supported opcodes:
   next_opcode
-  get_private_data_length
+  check_opcode_types
   set_private_data_ptrs
   get_framesize
   init_frame
-  get_private_data_length_for_copy
+  get_private_data_copy_length
   copy_private_data
   compile_matchingpath
   compile_backtrackingpath
-Line 514 
 switch(*cc)
+Line 599 
 switch(*cc)
    case OP_WORDCHAR:
    case OP_ANY:
    case OP_ALLANY:
+   case OP_NOTPROP:
+   case OP_PROP:
    case OP_ANYNL:
    case OP_NOT_HSPACE:
    case OP_HSPACE:
-Line 526 
 switch(*cc)
+Line 613 
 switch(*cc)
    case OP_CIRCM:
    case OP_DOLL:
    case OP_DOLLM:
-   case OP_TYPESTAR:
-   case OP_TYPEMINSTAR:
-   case OP_TYPEPLUS:
-   case OP_TYPEMINPLUS:
-   case OP_TYPEQUERY:
-   case OP_TYPEMINQUERY:
-   case OP_TYPEPOSSTAR:
-   case OP_TYPEPOSPLUS:
-   case OP_TYPEPOSQUERY:
    case OP_CRSTAR:
    case OP_CRMINSTAR:
    case OP_CRPLUS:
    case OP_CRMINPLUS:
    case OP_CRQUERY:
    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:
+   case OP_KET:
+   case OP_KETRMAX:
+   case OP_KETRMIN:
+   case OP_KETRPOS:
+   case OP_REVERSE:
+   case OP_ASSERT:
+   case OP_ASSERT_NOT:
+   case OP_ASSERTBACK:
+   case OP_ASSERTBACK_NOT:
+   case OP_ONCE:
+   case OP_ONCE_NC:
+   case OP_BRA:
+   case OP_BRAPOS:
+   case OP_CBRA:
+   case OP_CBRAPOS:
+   case OP_COND:
+   case OP_SBRA:
+   case OP_SBRAPOS:
+   case OP_SCBRA:
+   case OP_SCBRAPOS:
+   case OP_SCOND:
+   case OP_CREF:
+   case OP_DNCREF:
+   case OP_RREF:
+   case OP_DNRREF:
    case OP_DEF:
    case OP_BRAZERO:
    case OP_BRAMINZERO:
    case OP_BRAPOSZERO:
+   case OP_PRUNE:
+   case OP_SKIP:
+   case OP_THEN:
    case OP_COMMIT:
    case OP_FAIL:
    case OP_ACCEPT:
    case OP_ASSERT_ACCEPT:
+   case OP_CLOSE:
    case OP_SKIPZERO:
-   return cc + 1;
+   return cc + PRIV(OP_lengths)[*cc];
-   case OP_ANYBYTE:
- #ifdef SUPPORT_UTF
-   if (common->utf) return NULL;
- #endif
-   return cc + 1;
    case OP_CHAR:
    case OP_CHARI:
-Line 568 
 switch(*cc)
+Line 684 
 switch(*cc)
    case OP_MINPLUS:
    case OP_QUERY:
    case OP_MINQUERY:
+   case OP_UPTO:
+   case OP_MINUPTO:
+   case OP_EXACT:
    case OP_POSSTAR:
    case OP_POSPLUS:
    case OP_POSQUERY:
+   case OP_POSUPTO:
    case OP_STARI:
    case OP_MINSTARI:
    case OP_PLUSI:
    case OP_MINPLUSI:
    case OP_QUERYI:
    case OP_MINQUERYI:
+   case OP_UPTOI:
+   case OP_MINUPTOI:
+   case OP_EXACTI:
    case OP_POSSTARI:
    case OP_POSPLUSI:
    case OP_POSQUERYI:
+   case OP_POSUPTOI:
    case OP_NOTSTAR:
    case OP_NOTMINSTAR:
    case OP_NOTPLUS:
    case OP_NOTMINPLUS:
    case OP_NOTQUERY:
    case OP_NOTMINQUERY:
+   case OP_NOTUPTO:
+   case OP_NOTMINUPTO:
+   case OP_NOTEXACT:
    case OP_NOTPOSSTAR:
    case OP_NOTPOSPLUS:
    case OP_NOTPOSQUERY:
+   case OP_NOTPOSUPTO:
    case OP_NOTSTARI:
    case OP_NOTMINSTARI:
    case OP_NOTPLUSI:
    case OP_NOTMINPLUSI:
    case OP_NOTQUERYI:
    case OP_NOTMINQUERYI:
-   case OP_NOTPOSSTARI:
-   case OP_NOTPOSPLUSI:
-   case OP_NOTPOSQUERYI:
-   cc += 2;
- #ifdef SUPPORT_UTF
-   if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
- #endif
-   return cc;
-   case OP_UPTO:
-   case OP_MINUPTO:
-   case OP_EXACT:
-   case OP_POSUPTO:
-   case OP_UPTOI:
-   case OP_MINUPTOI:
-   case OP_EXACTI:
-   case OP_POSUPTOI:
-   case OP_NOTUPTO:
-   case OP_NOTMINUPTO:
-   case OP_NOTEXACT:
-   case OP_NOTPOSUPTO:
    case OP_NOTUPTOI:
    case OP_NOTMINUPTOI:
    case OP_NOTEXACTI:
+   case OP_NOTPOSSTARI:
+   case OP_NOTPOSPLUSI:
+   case OP_NOTPOSQUERYI:
    case OP_NOTPOSUPTOI:
-   cc += 2 + IMM2_SIZE;
+   cc += PRIV(OP_lengths)[*cc];
  #ifdef SUPPORT_UTF
    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
    return cc;
-   case OP_NOTPROP:
+   /* Special cases. */
-   case OP_PROP:
+   case OP_TYPESTAR:
-   return cc + 1 + 2;
+   case OP_TYPEMINSTAR:
+   case OP_TYPEPLUS:
+   case OP_TYPEMINPLUS:
+   case OP_TYPEQUERY:
+   case OP_TYPEMINQUERY:
    case OP_TYPEUPTO:
    case OP_TYPEMINUPTO:
    case OP_TYPEEXACT:
+   case OP_TYPEPOSSTAR:
+   case OP_TYPEPOSPLUS:
+   case OP_TYPEPOSQUERY:
    case OP_TYPEPOSUPTO:
-   case OP_REF:
+   return cc + PRIV(OP_lengths)[*cc] - 1;
-   case OP_REFI:
-   case OP_CREF:
-   case OP_NCREF:
-   case OP_RREF:
-   case OP_NRREF:
-   case OP_CLOSE:
-   cc += 1 + IMM2_SIZE;
-   return cc;
-   case OP_CRRANGE:
+   case OP_ANYBYTE:
-   case OP_CRMINRANGE:
+ #ifdef SUPPORT_UTF
-   return cc + 1 + 2 * IMM2_SIZE;
+   if (common->utf) return NULL;
+ #endif
-   case OP_CLASS:
+   return cc + 1;
-   case OP_NCLASS:
-   return cc + 1 + 32 / sizeof(pcre_uchar);
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    case OP_XCLASS:
    return cc + GET(cc, 1);
  #endif
-   case OP_RECURSE:
-   case OP_ASSERT:
-   case OP_ASSERT_NOT:
-   case OP_ASSERTBACK:
-   case OP_ASSERTBACK_NOT:
-   case OP_REVERSE:
-   case OP_ONCE:
-   case OP_ONCE_NC:
-   case OP_BRA:
-   case OP_BRAPOS:
-   case OP_COND:
-   case OP_SBRA:
-   case OP_SBRAPOS:
-   case OP_SCOND:
-   case OP_ALT:
-   case OP_KET:
-   case OP_KETRMAX:
-   case OP_KETRMIN:
-   case OP_KETRPOS:
-   return cc + 1 + LINK_SIZE;
-   case OP_CBRA:
-   case OP_CBRAPOS:
-   case OP_SCBRA:
-   case OP_SCBRAPOS:
-   return cc + 1 + LINK_SIZE + IMM2_SIZE;
    case OP_MARK:
+   case OP_PRUNE_ARG:
+   case OP_SKIP_ARG:
+   case OP_THEN_ARG:
    return cc + 1 + 2 + cc[1];
-   case OP_CALLOUT:
-   return cc + 2 + 2 * LINK_SIZE;
    default:
+   /* All opcodes are supported now! */
+   SLJIT_ASSERT_STOP();
    return NULL;
    }
  }
- #define CASE_ITERATOR_PRIVATE_DATA_1 \
+ static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
-     case OP_MINSTAR: \
-     case OP_MINPLUS: \
-     case OP_QUERY: \
-     case OP_MINQUERY: \
-     case OP_MINSTARI: \
-     case OP_MINPLUSI: \
-     case OP_QUERYI: \
-     case OP_MINQUERYI: \
-     case OP_NOTMINSTAR: \
-     case OP_NOTMINPLUS: \
-     case OP_NOTQUERY: \
-     case OP_NOTMINQUERY: \
-     case OP_NOTMINSTARI: \
-     case OP_NOTMINPLUSI: \
-     case OP_NOTQUERYI: \
-     case OP_NOTMINQUERYI:
- #define CASE_ITERATOR_PRIVATE_DATA_2A \
-     case OP_STAR: \
-     case OP_PLUS: \
-     case OP_STARI: \
-     case OP_PLUSI: \
-     case OP_NOTSTAR: \
-     case OP_NOTPLUS: \
-     case OP_NOTSTARI: \
-     case OP_NOTPLUSI:
- #define CASE_ITERATOR_PRIVATE_DATA_2B \
-     case OP_UPTO: \
-     case OP_MINUPTO: \
-     case OP_UPTOI: \
-     case OP_MINUPTOI: \
-     case OP_NOTUPTO: \
-     case OP_NOTMINUPTO: \
-     case OP_NOTUPTOI: \
-     case OP_NOTMINUPTOI:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
-     case OP_TYPEMINSTAR: \
-     case OP_TYPEMINPLUS: \
-     case OP_TYPEQUERY: \
-     case OP_TYPEMINQUERY:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
-     case OP_TYPESTAR: \
-     case OP_TYPEPLUS:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
-     case OP_TYPEUPTO: \
-     case OP_TYPEMINUPTO:
- static int get_class_iterator_size(pcre_uchar *cc)
- {
- switch(*cc)
-   {
-   case OP_CRSTAR:
-   case OP_CRPLUS:
-   return 2;
-   case OP_CRMINSTAR:
-   case OP_CRMINPLUS:
-   case OP_CRQUERY:
-   case OP_CRMINQUERY:
-   return 1;
-   case OP_CRRANGE:
-   case OP_CRMINRANGE:
-   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
-     return 0;
-   return 2;
-   default:
-   return 0;
-   }
- }
- static int get_private_data_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
  {
- int private_data_length = 0;
+ int count;
- pcre_uchar *alternative;
+ pcre_uchar *slot;
- pcre_uchar *name;
- pcre_uchar *end = NULL;
- int space, size, i;
- pcre_uint32 bracketlen;
  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
    {
-   space = 0;
-   size = 0;
-   bracketlen = 0;
    switch(*cc)
      {
      case OP_SET_SOM:
      common->has_set_som = TRUE;
+     common->might_be_empty = TRUE;
      cc += 1;
      break;
-Line 800 
 while (cc < ccend)
+Line 798 
 while (cc < ccend)
      cc += 1 + IMM2_SIZE;
      break;
-     case OP_ASSERT:
-     case OP_ASSERT_NOT:
-     case OP_ASSERTBACK:
-     case OP_ASSERTBACK_NOT:
-     case OP_ONCE:
-     case OP_ONCE_NC:
-     case OP_BRAPOS:
-     case OP_SBRA:
-     case OP_SBRAPOS:
-     private_data_length += sizeof(sljit_sw);
-     bracketlen = 1 + LINK_SIZE;
-     break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     private_data_length += sizeof(sljit_sw);
      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
-     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-Line 825 
 while (cc < ccend)
+Line 809 
 while (cc < ccend)
      /* Only AUTO_CALLOUT can insert this opcode. We do
         not intend to support this case. */
      if (cc[1 + LINK_SIZE] == OP_CALLOUT)
-       return -1;
+       return FALSE;
+     cc += 1 + LINK_SIZE;
-     if (*cc == OP_COND)
-       {
-       /* Might be a hidden SCOND. */
-       alternative = cc + GET(cc, 1);
-       if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
-         private_data_length += sizeof(sljit_sw);
-       }
-     else
-       private_data_length += sizeof(sljit_sw);
-     bracketlen = 1 + LINK_SIZE;
      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:
-     bracketlen = GET2(cc, 1);
+     case OP_DNREFI:
-     name = (pcre_uchar *)common->name_table;
+     case OP_DNCREF:
-     alternative = 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) == bracketlen) break;
-       name += common->name_entry_size;
-       }
-     SLJIT_ASSERT(i != common->name_count);
-     for (i = 0; i < common->name_count; i++)
        {
-       if (STRCMP_UC_UC(alternative + IMM2_SIZE, name + IMM2_SIZE) == 0)
+       common->optimized_cbracket[GET2(slot, 0)] = 0;
-         common->optimized_cbracket[GET2(alternative, 0)] = 0;
+       slot += common->name_entry_size;
-       alternative += common->name_entry_size;
        }
-     bracketlen = 0;
+     cc += 1 + 2 * IMM2_SIZE;
-     cc += 1 + IMM2_SIZE;
-     break;
-     case OP_BRA:
-     bracketlen = 1 + LINK_SIZE;
-     break;
-     case OP_CBRA:
-     case OP_SCBRA:
-     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
-     break;
-     CASE_ITERATOR_PRIVATE_DATA_1
-     space = 1;
-     size = -2;
-     break;
-     CASE_ITERATOR_PRIVATE_DATA_2A
-     space = 2;
-     size = -2;
-     break;
-     CASE_ITERATOR_PRIVATE_DATA_2B
-     space = 2;
-     size = -(2 + IMM2_SIZE);
-     break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
-     space = 1;
-     size = 1;
-     break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
-     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
-       space = 2;
-     size = 1;
-     break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
-     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
-       space = 2;
-     size = 1 + IMM2_SIZE;
-     break;
-     case OP_CLASS:
-     case OP_NCLASS:
-     size += 1 + 32 / sizeof(pcre_uchar);
-     space = get_class_iterator_size(cc + size);
-     break;
- #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
-     case OP_XCLASS:
-     size = GET(cc, 1);
-     space = get_class_iterator_size(cc + size);
      break;
- #endif
      case OP_RECURSE:
      /* Set its value only once. */
-Line 939 
 while (cc < ccend)
+Line 850 
 while (cc < ccend)
      cc += 2 + 2 * 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 948 
 while (cc < ccend)
+Line 868 
 while (cc < ccend)
      cc += 1 + 2 + cc[1];
      break;
+     case OP_THEN:
+     common->has_then = TRUE;
+     common->control_head_ptr = 1;
+     /* Fall through. */
+     case OP_PRUNE:
+     case OP_SKIP:
+     common->needs_start_ptr = TRUE;
+     cc += 1;
+     break;
+     case OP_SKIP_ARG:
+     common->control_head_ptr = 1;
+     common->has_skip_arg = TRUE;
+     cc += 1 + 2 + cc[1];
+     break;
      default:
      cc = next_opcode(common, cc);
      if (cc == NULL)
-       return -1;
+       return FALSE;
      break;
      }
+   }
+ return TRUE;
+ }
-   if (space > 0 && cc >= end)
+ static int get_class_iterator_size(pcre_uchar *cc)
-     private_data_length += sizeof(sljit_sw) * space;
+ {
+ switch(*cc)
+   {
+   case OP_CRSTAR:
+   case OP_CRPLUS:
+   return 2;
-   if (size != 0)
+   case OP_CRMINSTAR:
+   case OP_CRMINPLUS:
+   case OP_CRQUERY:
+   case OP_CRMINQUERY:
+   return 1;
+   case OP_CRRANGE:
+   case OP_CRMINRANGE:
+   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
+     return 0;
+   return 2;
+   default:
+   return 0;
+   }
+ }
+ static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
+ {
+ pcre_uchar *end = bracketend(begin);
+ pcre_uchar *next;
+ pcre_uchar *next_end;
+ pcre_uchar *max_end;
+ pcre_uchar type;
+ sljit_sw length = end - begin;
+ int min, max, i;
+ /* Detect fixed iterations first. */
+ if (end[-(1 + LINK_SIZE)] != OP_KET)
+   return FALSE;
+ /* Already detected repeat. */
+ if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)
+   return TRUE;
+ next = end;
+ min = 1;
+ while (1)
+   {
+   if (*next != *begin)
+     break;
+   next_end = bracketend(next);
+   if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)
+     break;
+   next = next_end;
+   min++;
+   }
+ if (min == 2)
+   return FALSE;
+ max = 0;
+ max_end = next;
+ if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)
+   {
+   type = *next;
+   while (1)
      {
-     if (size < 0)
+     if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
-       {
+       break;
-       cc += -size;
+     next_end = bracketend(next + 2 + LINK_SIZE);
- #ifdef SUPPORT_UTF
+     if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)
-       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+       break;
- #endif
+     next = next_end;
-       }
+     max++;
-     else
-       cc += size;
      }
-   if (bracketlen != 0)
+   if (next[0] == type && next[1] == *begin && max >= 1)
      {
-     if (cc >= end)
+     next_end = bracketend(next + 1);
+     if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)
        {
-       end = bracketend(cc);
+       for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
-       if (end[-1 - LINK_SIZE] == OP_KET)
+         if (*next_end != OP_KET)
-         end = NULL;
+           break;
+       if (i == max)
+         {
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
+         /* +2 the original and the last. */
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;
+         if (min == 1)
+           return TRUE;
+         min--;
+         max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);
+         }
        }
-     cc += bracketlen;
      }
    }
- return private_data_length;
+ if (min >= 3)
+   {
+   common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;
+   common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;
+   common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;
+   return TRUE;
+   }
+ return FALSE;
  }
- static void set_private_data_ptrs(compiler_common *common, int private_data_ptr, pcre_uchar *ccend)
+ #define CASE_ITERATOR_PRIVATE_DATA_1 \
+     case OP_MINSTAR: \
+     case OP_MINPLUS: \
+     case OP_QUERY: \
+     case OP_MINQUERY: \
+     case OP_MINSTARI: \
+     case OP_MINPLUSI: \
+     case OP_QUERYI: \
+     case OP_MINQUERYI: \
+     case OP_NOTMINSTAR: \
+     case OP_NOTMINPLUS: \
+     case OP_NOTQUERY: \
+     case OP_NOTMINQUERY: \
+     case OP_NOTMINSTARI: \
+     case OP_NOTMINPLUSI: \
+     case OP_NOTQUERYI: \
+     case OP_NOTMINQUERYI:
+ #define CASE_ITERATOR_PRIVATE_DATA_2A \
+     case OP_STAR: \
+     case OP_PLUS: \
+     case OP_STARI: \
+     case OP_PLUSI: \
+     case OP_NOTSTAR: \
+     case OP_NOTPLUS: \
+     case OP_NOTSTARI: \
+     case OP_NOTPLUSI:
+ #define CASE_ITERATOR_PRIVATE_DATA_2B \
+     case OP_UPTO: \
+     case OP_MINUPTO: \
+     case OP_UPTOI: \
+     case OP_MINUPTOI: \
+     case OP_NOTUPTO: \
+     case OP_NOTMINUPTO: \
+     case OP_NOTUPTOI: \
+     case OP_NOTMINUPTOI:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
+     case OP_TYPEMINSTAR: \
+     case OP_TYPEMINPLUS: \
+     case OP_TYPEQUERY: \
+     case OP_TYPEMINQUERY:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
+     case OP_TYPESTAR: \
+     case OP_TYPEPLUS:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
+     case OP_TYPEUPTO: \
+     case OP_TYPEMINUPTO:
+ static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)
  {
  pcre_uchar *cc = common->start;
  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)
    {
    space = 0;
    size = 0;
    bracketlen = 0;
+   if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
+     break;
+   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
+       based single character repeat is allowed. */
+       if (cc >= end)
+         end = bracketend(cc);
+       }
+     }
+   repeat_check = TRUE;
    switch(*cc)
      {
+     case OP_KET:
+     if (common->private_data_ptrs[cc + 1 - common->start] != 0)
+       {
+       common->private_data_ptrs[cc - common->start] = private_data_ptr;
+       private_data_ptr += sizeof(sljit_sw);
+       cc += common->private_data_ptrs[cc + 1 - common->start];
+       }
+     cc += 1 + LINK_SIZE;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 1041 
 while (cc < ccend)
+Line 1140 
 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 1067 
 while (cc < ccend)
+Line 1173 
 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 1092 
 while (cc < ccend)
+Line 1203 
 while (cc < ccend)
      break;
      }
+   /* Character iterators, which are not inside a repeated bracket,
+      gets a private slot instead of allocating it on the stack. */
    if (space > 0 && cc >= end)
      {
      common->private_data_ptrs[cc - common->start] = private_data_ptr;
-Line 1122 
 while (cc < ccend)
+Line 1235 
 while (cc < ccend)
      cc += bracketlen;
      }
    }
+ *private_data_start = private_data_ptr;
  }
- /* Returns with -1 if no need for frame. */
+ /* Returns with a frame_types (always < 0) if no need for frame. */
- static int get_framesize(compiler_common *common, pcre_uchar *cc, BOOL recursive)
+ static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL *needs_control_head)
  {
- pcre_uchar *ccend = bracketend(cc);
  int length = 0;
  int possessive = 0;
+ BOOL stack_restore = FALSE;
  BOOL setsom_found = recursive;
  BOOL setmark_found = recursive;
  /* The last capture is a local variable even for recursions. */
  BOOL capture_last_found = FALSE;
- if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
+ #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
+ SLJIT_ASSERT(common->control_head_ptr != 0);
+ *needs_control_head = TRUE;
+ #else
+ *needs_control_head = FALSE;
+ #endif
+ if (ccend == NULL)
    {
-   possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
+   ccend = bracketend(cc) - (1 + LINK_SIZE);
-   /* This is correct regardless of common->capture_last_ptr. */
+   if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
-   capture_last_found = TRUE;
+     {
+     possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
+     /* This is correct regardless of common->capture_last_ptr. */
+     capture_last_found = TRUE;
+     }
+   cc = next_opcode(common, cc);
    }
- cc = next_opcode(common, cc);
  SLJIT_ASSERT(cc != NULL);
  while (cc < ccend)
    switch(*cc)
      {
      case OP_SET_SOM:
      SLJIT_ASSERT(common->has_set_som);
+     stack_restore = TRUE;
      if (!setsom_found)
        {
        length += 2;
-Line 1158 
 while (cc < ccend)
+Line 1284 
 while (cc < ccend)
      break;
      case OP_MARK:
+     case OP_PRUNE_ARG:
+     case OP_THEN_ARG:
      SLJIT_ASSERT(common->mark_ptr != 0);
+     stack_restore = TRUE;
      if (!setmark_found)
        {
        length += 2;
        setmark_found = TRUE;
        }
+     if (common->control_head_ptr != 0)
+       *needs_control_head = TRUE;
      cc += 1 + 2 + cc[1];
      break;
      case OP_RECURSE:
+     stack_restore = TRUE;
      if (common->has_set_som && !setsom_found)
        {
        length += 2;
-Line 1190 
 while (cc < ccend)
+Line 1322 
 while (cc < ccend)
      case OP_CBRAPOS:
      case OP_SCBRA:
      case OP_SCBRAPOS:
+     stack_restore = TRUE;
      if (common->capture_last_ptr != 0 && !capture_last_found)
        {
        length += 2;
-Line 1199 
 while (cc < ccend)
+Line 1332 
 while (cc < ccend)
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
-     default:
+     case OP_THEN:
-     cc = next_opcode(common, cc);
+     stack_restore = TRUE;
-     SLJIT_ASSERT(cc != NULL);
+     if (common->control_head_ptr != 0)
+       *needs_control_head = TRUE;
+     cc ++;
      break;
-     }
- /* Possessive quantifiers can use a special case. */
+     default:
- if (SLJIT_UNLIKELY(possessive == length))
+     stack_restore = TRUE;
-   return -1;
+     /* Fall through. */
- if (length > 0)
+     case OP_NOT_WORD_BOUNDARY:
-   return length + 1;
+     case OP_WORD_BOUNDARY:
- return -1;
+     case OP_NOT_DIGIT:
+     case OP_DIGIT:
+     case OP_NOT_WHITESPACE:
+     case OP_WHITESPACE:
+     case OP_NOT_WORDCHAR:
+     case OP_WORDCHAR:
+     case OP_ANY:
+     case OP_ALLANY:
+     case OP_ANYBYTE:
+     case OP_NOTPROP:
+     case OP_PROP:
+     case OP_ANYNL:
+     case OP_NOT_HSPACE:
+     case OP_HSPACE:
+     case OP_NOT_VSPACE:
+     case OP_VSPACE:
+     case OP_EXTUNI:
+     case OP_EODN:
+     case OP_EOD:
+     case OP_CIRC:
+     case OP_CIRCM:
+     case OP_DOLL:
+     case OP_DOLLM:
+     case OP_CHAR:
+     case OP_CHARI:
+     case OP_NOT:
+     case OP_NOTI:
+     case OP_EXACT:
+     case OP_POSSTAR:
+     case OP_POSPLUS:
+     case OP_POSQUERY:
+     case OP_POSUPTO:
+     case OP_EXACTI:
+     case OP_POSSTARI:
+     case OP_POSPLUSI:
+     case OP_POSQUERYI:
+     case OP_POSUPTOI:
+     case OP_NOTEXACT:
+     case OP_NOTPOSSTAR:
+     case OP_NOTPOSPLUS:
+     case OP_NOTPOSQUERY:
+     case OP_NOTPOSUPTO:
+     case OP_NOTEXACTI:
+     case OP_NOTPOSSTARI:
+     case OP_NOTPOSPLUSI:
+     case OP_NOTPOSQUERYI:
+     case OP_NOTPOSUPTOI:
+     case OP_TYPEEXACT:
+     case OP_TYPEPOSSTAR:
+     case OP_TYPEPOSPLUS:
+     case OP_TYPEPOSQUERY:
+     case OP_TYPEPOSUPTO:
+     case OP_CLASS:
+     case OP_NCLASS:
+     case OP_XCLASS:
+     case OP_CALLOUT:
+     cc = next_opcode(common, cc);
+     SLJIT_ASSERT(cc != NULL);
+     break;
+     }
+ /* Possessive quantifiers can use a special case. */
+ if (SLJIT_UNLIKELY(possessive == length))
+   return stack_restore ? no_frame : no_stack;
+ if (length > 0)
+   return length + 1;
+ return stack_restore ? no_frame : no_stack;
  }
- static void init_frame(compiler_common *common, pcre_uchar *cc, int stackpos, int stacktop, BOOL recursive)
+ static void init_frame(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, int stackpos, int stacktop, BOOL recursive)
  {
  DEFINE_COMPILER;
- pcre_uchar *ccend = bracketend(cc);
  BOOL setsom_found = recursive;
  BOOL setmark_found = recursive;
  /* The last capture is a local variable even for recursions. */
-Line 1229 
 SLJIT_UNUSED_ARG(stacktop);
+Line 1436 
 SLJIT_UNUSED_ARG(stacktop);
  SLJIT_ASSERT(stackpos >= stacktop + 2);
  stackpos = STACK(stackpos);
- if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
+ if (ccend == NULL)
-   cc = next_opcode(common, cc);
+   {
+   ccend = bracketend(cc) - (1 + LINK_SIZE);
+   if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
+     cc = next_opcode(common, cc);
+   }
  SLJIT_ASSERT(cc != NULL);
  while (cc < ccend)
    switch(*cc)
-Line 1239 
 while (cc < ccend)
+Line 1451 
 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 1250 
 while (cc < ccend)
+Line 1462 
 while (cc < ccend)
      break;
      case OP_MARK:
+     case OP_PRUNE_ARG:
+     case OP_THEN_ARG:
      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 1266 
 while (cc < ccend)
+Line 1480 
 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 1275 
 while (cc < ccend)
+Line 1489 
 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 1284 
 while (cc < ccend)
+Line 1498 
 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 1300 
 while (cc < ccend)
+Line 1514 
 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 1310 
 while (cc < ccend)
+Line 1524 
 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 1330 
 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), st
+Line 1544 
 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), st
  SLJIT_ASSERT(stackpos == STACK(stacktop));
  }
- static SLJIT_INLINE int get_private_data_length_for_copy(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
+ static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)
  {
- int private_data_length = 2;
+ int private_data_length = needs_control_head ? 3 : 2;
  int size;
  pcre_uchar *alternative;
  /* Calculate the sum of the private machine words. */
-Line 1341 
 while (cc < ccend)
+Line 1555 
 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 1352 
 while (cc < ccend)
+Line 1576 
 while (cc < ccend)
      case OP_SBRAPOS:
      case OP_SCOND:
      private_data_length++;
+     SLJIT_ASSERT(PRIVATE_DATA(cc) != 0);
      cc += 1 + LINK_SIZE;
      break;
-Line 1445 
 return private_data_length;
+Line 1670 
 return private_data_length;
  }
  static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
-   BOOL save, int stackptr, int stacktop)
+   BOOL save, int stackptr, int stacktop, BOOL needs_control_head)
  {
  DEFINE_COMPILER;
  int srcw[2];
-Line 1466 
 stacktop = STACK(stacktop - 1);
+Line 1691 
 stacktop = STACK(stacktop - 1);
  if (!save)
    {
-   stackptr += sizeof(sljit_sw);
+   stackptr += (needs_control_head ? 2 : 1) * sizeof(sljit_sw);
    if (stackptr < stacktop)
      {
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
-Line 1482 
 if (!save)
+Line 1707 
 if (!save)
    /* The tmp1next must be TRUE in either way. */
    }
- while (status != end)
+ do
    {
    count = 0;
    switch(status)
-Line 1491 
 while (status != end)
+Line 1716 
 while (status != end)
      SLJIT_ASSERT(save && common->recursive_head_ptr != 0);
      count = 1;
      srcw[0] = common->recursive_head_ptr;
+     if (needs_control_head)
+       {
+       SLJIT_ASSERT(common->control_head_ptr != 0);
+       count = 2;
+       srcw[1] = common->control_head_ptr;
+       }
      status = loop;
      break;
-Line 1503 
 while (status != end)
+Line 1734 
 while (status != end)
      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 1670 
 while (status != end)
+Line 1912 
 while (status != end)
            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 1681 
 while (status != end)
+Line 1923 
 while (status != end)
            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 1691 
 while (status != end)
+Line 1933 
 while (status != end)
        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 1703 
 while (status != end)
+Line 1945 
 while (status != end)
        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 1715 
 while (status != end)
+Line 1957 
 while (status != end)
        }
      }
    }
+ while (status != end);
  if (save)
    {
-Line 1748 
 if (save)
+Line 1991 
 if (save)
  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
  }
+ static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)
+ {
+ pcre_uchar *end = bracketend(cc);
+ BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
+ /* Assert captures then. */
+ if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
+   current_offset = NULL;
+ /* Conditional block does not. */
+ if (*cc == OP_COND || *cc == OP_SCOND)
+   has_alternatives = FALSE;
+ cc = next_opcode(common, cc);
+ if (has_alternatives)
+   current_offset = common->then_offsets + (cc - common->start);
+ while (cc < end)
+   {
+   if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
+     cc = set_then_offsets(common, cc, current_offset);
+   else
+     {
+     if (*cc == OP_ALT && has_alternatives)
+       current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);
+     if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)
+       *current_offset = 1;
+     cc = next_opcode(common, cc);
+     }
+   }
+ return end;
+ }
  #undef CASE_ITERATOR_PRIVATE_DATA_1
  #undef CASE_ITERATOR_PRIVATE_DATA_2A
  #undef CASE_ITERATOR_PRIVATE_DATA_2B
-Line 1771 
 while (list)
+Line 2047 
 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 1782 
 if (list_item)
+Line 2058 
 if (list_item)
    }
  }
- static void add_stub(compiler_common *common, enum stub_types type, int data, struct sljit_jump *start)
+ 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)
    {
-   list_item->type = type;
-   list_item->data = data;
    list_item->start = start;
    list_item->quit = LABEL();
    list_item->next = common->stubs;
-Line 1801 
 if (list_item)
+Line 2075 
 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)
    {
    JUMPHERE(list_item->start);
-   switch(list_item->type)
+   add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
-     {
-     case stack_alloc:
-     add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
-     break;
-     }
    JUMPTO(SLJIT_JUMP, list_item->quit);
    list_item = list_item->next;
    }
  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 1831 
 static SLJIT_INLINE void allocate_stack(
+Line 2114 
 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, stack_alloc, 0, 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;
  struct sljit_label *loop;
  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 = 0; i < length; i++)
+   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 - sizeof(sljit_sw));
+   GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START);
-   OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, length);
+   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 do_reset_match(compiler_common *common, int length)
+ {
+ DEFINE_COMPILER;
+ struct sljit_label *loop;
+ 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_SP), OVECTOR(1));
+ if (length < 8)
+   {
+   for (i = 2; i < length; i++)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), TMP1, 0);
+   }
+ else
+   {
+   GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw));
+   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);
+   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_NOT_ZERO, loop);
+   }
+ OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);
+ if (common->mark_ptr != 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_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_SP), common->start_ptr);
+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, base));
+ }
+ static sljit_sw SLJIT_CALL do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)
+ {
+ while (current != NULL)
+   {
+   switch (current[-2])
+     {
+     case type_then_trap:
+     break;
+     case type_mark:
+     if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[-3]) == 0)
+       return current[-4];
+     break;
+     default:
+     SLJIT_ASSERT_STOP();
+     break;
+     }
+   SLJIT_ASSERT(current > (sljit_sw*)current[-1]);
+   current = (sljit_sw*)current[-1];
    }
+ return -1;
  }
  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
-Line 1879 
 struct sljit_label *loop;
+Line 2260 
 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_SI, 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_SI, 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 1925 
 else
+Line 2306 
 else
  static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)
  {
  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->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
+ 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, offset_count));
+ OP1(SLJIT_MOV_SI, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
- CMPTO(SLJIT_C_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));
- 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);
- OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);
+ jump = CMP(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 3);
+ 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_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
+ #endif
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(int), SLJIT_R2, 0);
+ JUMPHERE(jump);
+ 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_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_SI, 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_SI, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);
  JUMPTO(SLJIT_JUMP, quit);
  }
-Line 1962 
 struct sljit_jump *jump;
+Line 2354 
 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 2020 
 if (common->utf && c > 127)
+Line 2412 
 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 2098 
 return (bit < 256) ? ((0 << 8) | bit) :
+Line 2490 
 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 2108 
 if (common->mode == JIT_COMPILE)
+Line 2500 
 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, -1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
  else
    {
    if (common->partialmatchlabel != NULL)
-Line 2126 
 if (jump != NULL)
+Line 2518 
 if (jump != NULL)
    JUMPHERE(jump);
  }
- static struct sljit_jump *check_str_end(compiler_common *common)
+ static void check_str_end(compiler_common *common, jump_list **end_reached)
  {
  /* Does not affect registers. Usually used in a tight spot. */
  DEFINE_COMPILER;
  struct sljit_jump *jump;
- struct sljit_jump *nohit;
- struct sljit_jump *return_value;
  if (common->mode == JIT_COMPILE)
-   return CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   {
+   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)
    {
-   nohit = 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, -1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
-   JUMPHERE(nohit);
+   add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));
-   return_value = JUMP(SLJIT_JUMP);
    }
  else
    {
-   return_value = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   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
      add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
    }
  JUMPHERE(jump);
- return return_value;
  }
  static void detect_partial_match(compiler_common *common, jump_list **backtracks)
-Line 2164 
 struct sljit_jump *jump;
+Line 2555 
 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, -1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
    }
  else
-Line 2186 
 else
+Line 2577 
 else
  JUMPHERE(jump);
  }
- static void read_char(compiler_common *common)
+ static void peek_char(compiler_common *common, pcre_uint32 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 pcre_uint8 *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 pcre_uint8 value = nclass ? 0xff : 0;
+ const pcre_uint8 *end = bitset + 32;
+ bitset += 16;
+ do
+   {
+   if (*bitset++ != value)
+     return FALSE;
+   }
+ while (bitset < end);
+ return TRUE;
+ }
+ static void read_char7_type(compiler_common *common, BOOL full_read)
+ {
+ /* Reads the precise character type of a character into TMP1, if the character
+ is less than 128. Otherwise it returns with zero. Does not check STR_END. The
+ full_read argument tells whether characters above max are accepted or not. */
  DEFINE_COMPILER;
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *jump;
- #endif
- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ SLJIT_ASSERT(common->utf);
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
- 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));
+ OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+ if (full_read)
    {
- #if defined COMPILE_PCRE8
+   jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
- #elif defined COMPILE_PCRE16
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
- #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 */
  }
- static void read_char8_type(compiler_common *common)
+ #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
+ static void read_char_range(compiler_common *common, pcre_uint32 min, pcre_uint32 max, BOOL update_str_ptr)
  {
- /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
+ /* 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_PCRE16 || defined COMPILE_PCRE32
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  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);
+ 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)
    {
-   OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+   if (max < 128 && !update_str_ptr) return;
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #if defined COMPILE_PCRE8
+   jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-   /* This can be an extra read in some situations, but hopefully
+   if (min >= 0x10000)
-   it is needed in most cases. */
+     {
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xf0);
-   jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
+     if (update_str_ptr)
-   add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
+       OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
-   JUMPHERE(jump);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
- #elif defined COMPILE_PCRE16
+     jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x7);
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
-   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
-   JUMPHERE(jump);
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
-   /* Skip low surrogate if necessary. */
+     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
-   OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);
+     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
-   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
-   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+     if (!update_str_ptr)
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
- #elif defined COMPILE_PCRE32
+     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
-   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+     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_UB, 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_UB, 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_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+     if (update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+     }
    JUMPHERE(jump);
- #endif /* COMPILE_PCRE[8|16|32] */
-   return;
    }
- #endif /* SUPPORT_UTF */
+ #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, 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_PCRE8
+ struct sljit_jump *jump;
+ #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ struct sljit_jump *jump2;
+ #endif
+ 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 COMPILE_PCRE16 || defined COMPILE_PCRE32
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ if (common->utf)
+   {
+   /* This can be an extra read in some situations, but hopefully
+   it is needed in most cases. */
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+   jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
+   if (!update_str_ptr)
+     {
+     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, 0x3f);
+     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);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+     jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);
+     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+     JUMPHERE(jump2);
+     }
+   else
+     add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
+   JUMPHERE(jump);
+   return;
+   }
+ #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
+ #if !defined COMPILE_PCRE8
  /* 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);
- #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 2303 
 if (common->utf)
+Line 2877 
 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 2314 
 if (common->utf)
+Line 2888 
 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 2324 
 if (common->utf)
+Line 2898 
 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 2355 
 else
+Line 2936 
 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 2421 
 struct sljit_jump *compare;
+Line 3028 
 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_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_UB, 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 2533 
 if (firstline)
+Line 3114 
 if (firstline)
      {
      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->first_line_end, 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->first_line_end, 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->first_line_end, STR_PTR, 0);
      set_jumps(newline, LABEL());
      }
-Line 2564 
 if (newlinecheck)
+Line 3145 
 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
-Line 2587 
 if (readuchar)
+Line 3168 
 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);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    JUMPHERE(singlechar);
-Line 2602 
 if (common->utf)
+Line 3183 
 if (common->utf)
  #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 2623 
 if (newlinecheck)
+Line 3204 
 if (newlinecheck)
  return mainloop;
  }
- #define MAX_N_CHARS 3
+ #define MAX_N_CHARS 16
+ #define MAX_N_BYTES 8
- static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
+ static SLJIT_INLINE void add_prefix_byte(pcre_uint8 byte, pcre_uint8 *bytes)
  {
- DEFINE_COMPILER;
+ pcre_uint8 len = bytes[0];
- struct sljit_label *start;
+ int i;
- 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. */
+ if (len == 255)
- if (*(common->start + GET(common->start, 1)) == OP_ALT)
+   return;
-   return FALSE;
+ if (len == 0)
+   {
+   bytes[0] = 1;
+   bytes[1] = byte;
+   return;
+   }
+ for (i = len; i > 0; i--)
+   if (bytes[i] == byte)
+     return;
+ if (len >= MAX_N_BYTES - 1)
+   {
+   bytes[0] = 255;
+   return;
+   }
+ len++;
+ bytes[len] = byte;
+ bytes[0] = len;
+ }
+ static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uint32 *chars, pcre_uint8 *bytes, int max_chars, pcre_uint32 *rec_count)
+ {
+ /* Recursive function, which scans prefix literals. */
+ BOOL last, any, caseless;
+ int len, repeat, len_save, consumed = 0;
+ pcre_uint32 chr, mask;
+ 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;
+   caseless = FALSE;
+   switch (*cc)
+     {
      case OP_CHARI:
-     caseless = 1;
+     caseless = TRUE;
-     must_stop = 0;
+     case OP_CHAR:
+     last = FALSE;
      cc++;
      break;
-Line 2672 
 while (TRUE)
+Line 3287 
 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, bytes, 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);
-     break;
+     continue;
-     }
-   if (must_stop == 2)
+     case OP_ONCE:
-       break;
+     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, bytes, max_chars, rec_count);
+       if (max_chars == 0)
+         return consumed;
+       alternative += GET(alternative, 1);
+       }
-   len = 1;
+     if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
- #ifdef SUPPORT_UTF
+       cc += IMM2_SIZE;
-   if (common->utf && HAS_EXTRALEN(cc[0])) len += GET_EXTRALEN(cc[0]);
+     cc += 1 + LINK_SIZE;
+     continue;
+     case OP_CLASS:
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+     if (common->utf && !is_char7_bitset((const pcre_uint8 *)(cc + 1), FALSE)) return consumed;
  #endif
+     any = TRUE;
+     cc += 1 + 32 / sizeof(pcre_uchar);
+     break;
-   if (caseless && char_has_othercase(common, cc))
+     case OP_NCLASS:
-     {
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
-     caseless = char_get_othercase_bit(common, cc);
+     if (common->utf) return consumed;
-     if (caseless == 0)
-       return FALSE;
- #ifdef COMPILE_PCRE8
-     caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));
- #else
-     if ((caseless & 0x100) != 0)
-       caseless = ((caseless & 0xff) << 16) | (len - (caseless >> 9));
-     else
-       caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 9));
  #endif
-     }
+     any = TRUE;
-   else
+     cc += 1 + 32 / sizeof(pcre_uchar);
-     caseless = 0;
+     break;
-   while (len > 0 && location < MAX_N_CHARS * 2)
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
-     {
+     case OP_XCLASS:
-     c = *cc;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
-     bit = 0;
+     if (common->utf) return consumed;
-     if (len == (caseless & 0xff))
+ #endif
-       {
+     any = TRUE;
-       bit = caseless >> 8;
+     cc += GET(cc, 1);
-       c |= bit;
+     break;
-       }
+ #endif
+     case OP_DIGIT:
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+     if (common->utf && !is_char7_bitset((const pcre_uint8 *)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 pcre_uint8 *)common->ctypes - cbit_length + cbit_space, FALSE))
+       return consumed;
+ #endif
+     any = TRUE;
+     cc++;
+     break;
-     chars[location] = c;
+     case OP_WORDCHAR:
-     chars[location + 1] = bit;
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+     if (common->utf && !is_char7_bitset((const pcre_uint8 *)common->ctypes - cbit_length + cbit_word, FALSE))
+       return consumed;
+ #endif
+     any = TRUE;
+     cc++;
+     break;
-     len--;
+     case OP_NOT:
-     location += 2;
+     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_UCP
+     case OP_NOTPROP:
+     case OP_PROP:
+ #if defined SUPPORT_UTF && !defined 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)
+     {
+ #if defined COMPILE_PCRE8
+     mask = 0xff;
+ #elif defined COMPILE_PCRE16
+     mask = 0xffff;
+ #elif defined COMPILE_PCRE32
+     mask = 0xffffffff;
+ #else
+     SLJIT_ASSERT_STOP();
+ #endif
+     do
+       {
+       chars[0] = mask;
+       chars[1] = mask;
+       bytes[0] = 255;
+       consumed++;
+       if (--max_chars == 0)
+         return consumed;
+       chars += 2;
+       bytes += MAX_N_BYTES;
+       }
+     while (--repeat > 0);
+     repeat = 1;
+     continue;
+     }
+   len = 1;
+ #ifdef SUPPORT_UTF
+   if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
+ #endif
+   if (caseless && char_has_othercase(common, cc))
+     {
+ #ifdef SUPPORT_UTF
+     if (common->utf)
+       {
+       GETCHAR(chr, cc);
+       if ((int)PRIV(ord2utf)(char_othercase(common, chr), othercase) != len)
+         return consumed;
+       }
+     else
+ #endif
+       {
+       chr = *cc;
+       othercase[0] = TABLE_GET(chr, common->fcc, chr);
+       }
+     }
+   else
+     caseless = FALSE;
+   len_save = len;
+   cc_save = cc;
+   while (TRUE)
+     {
+     oc = othercase;
+     do
+       {
+       chr = *cc;
+ #ifdef COMPILE_PCRE32
+       if (SLJIT_UNLIKELY(chr == NOTACHAR))
+         return consumed;
+ #endif
+       add_prefix_byte((pcre_uint8)chr, bytes);
+       mask = 0;
+       if (caseless)
+         {
+         add_prefix_byte((pcre_uint8)*oc, bytes);
+         mask = *cc ^ *oc;
+         chr |= mask;
+         }
+ #ifdef COMPILE_PCRE32
+       if (chars[0] == NOTACHAR && chars[1] == 0)
+ #else
+       if (chars[0] == NOTACHAR)
+ #endif
+         {
+         chars[0] = chr;
+         chars[1] = mask;
+         }
+       else
+         {
+         mask |= chars[0] ^ chr;
+         chr |= mask;
+         chars[0] = chr;
+         chars[1] |= mask;
+         }
+       len--;
+       consumed++;
+       if (--max_chars == 0)
+         return consumed;
+       chars += 2;
+       bytes += MAX_N_BYTES;
+       cc++;
+       oc++;
+       }
+     while (len > 0);
+     if (--repeat == 0)
+       break;
+     len = len_save;
+     cc = cc_save;
+     }
+   repeat = 1;
+   if (last)
+     return consumed;
+   }
+ }
+ static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
+ {
+ DEFINE_COMPILER;
+ struct sljit_label *start;
+ struct sljit_jump *quit;
+ pcre_uint32 chars[MAX_N_CHARS * 2];
+ pcre_uint8 bytes[MAX_N_CHARS * MAX_N_BYTES];
+ pcre_uint8 ones[MAX_N_CHARS];
+ int offsets[3];
+ pcre_uint32 mask;
+ pcre_uint8 *byte_set, *byte_set_end;
+ int i, max, from;
+ int range_right = -1, range_len = 3 - 1;
+ sljit_ub *update_table = NULL;
+ BOOL in_range;
+ pcre_uint32 rec_count;
+ for (i = 0; i < MAX_N_CHARS; i++)
+   {
+   chars[i << 1] = NOTACHAR;
+   chars[(i << 1) + 1] = 0;
+   bytes[i * MAX_N_BYTES] = 0;
+   }
+ rec_count = 10000;
+ max = scan_prefix(common, common->start, chars, bytes, MAX_N_CHARS, &rec_count);
+ if (max <= 1)
+   return FALSE;
+ for (i = 0; i < max; i++)
+   {
+   mask = chars[(i << 1) + 1];
+   ones[i] = ones_in_half_byte[mask & 0xf];
+   mask >>= 4;
+   while (mask != 0)
+     {
+     ones[i] += ones_in_half_byte[mask & 0xf];
+     mask >>= 4;
+     }
+   }
+ in_range = FALSE;
+ from = 0;   /* Prevent compiler "uninitialized" warning */
+ for (i = 0; i <= max; i++)
+   {
+   if (in_range && (i - from) > range_len && (bytes[(i - 1) * MAX_N_BYTES] <= 4))
+     {
+     range_len = i - from;
+     range_right = i - 1;
+     }
+   if (i < max && bytes[i * MAX_N_BYTES] < 255)
+     {
+     if (!in_range)
+       {
+       in_range = TRUE;
+       from = i;
+       }
+     }
+   else if (in_range)
+     in_range = FALSE;
+   }
+ if (range_right >= 0)
+   {
+   update_table = (sljit_ub *)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++)
+     {
+     byte_set = bytes + ((range_right - i) * MAX_N_BYTES);
+     SLJIT_ASSERT(byte_set[0] > 0 && byte_set[0] < 255);
+     byte_set_end = byte_set + byte_set[0];
+     byte_set++;
+     while (byte_set <= byte_set_end)
+       {
+       if (update_table[*byte_set] > IN_UCHARS(i))
+         update_table[*byte_set] = IN_UCHARS(i);
+       byte_set++;
+       }
      }
+   }
-   if (location >= MAX_N_CHARS * 2 || must_stop != 0)
+ offsets[0] = -1;
+ /* Scan forward. */
+ for (i = 0; i < max; i++)
+   if (ones[i] <= 2) {
+     offsets[0] = i;
      break;
    }
- /* At least two characters are required. */
+ if (offsets[0] < 0 && range_right < 0)
- if (location < 2 * 2)
+   return FALSE;
+ if (offsets[0] >= 0)
+   {
+   /* Scan backward. */
+   offsets[1] = -1;
+   for (i = max - 1; i > offsets[0]; i--)
+     if (ones[i] <= 2 && i != range_right)
+       {
+       offsets[1] = i;
+       break;
+       }
+   /* This case is handled better by fast_forward_first_char. */
+   if (offsets[1] == -1 && offsets[0] == 0 && range_right < 0)
      return FALSE;
+   offsets[2] = -1;
+   /* We only search for a middle character if there is no range check. */
+   if (offsets[1] >= 0 && range_right == -1)
+     {
+     /* Scan from middle. */
+     for (i = (offsets[0] + offsets[1]) / 2 + 1; i < offsets[1]; i++)
+       if (ones[i] <= 2)
+         {
+         offsets[2] = i;
+         break;
+         }
+     if (offsets[2] == -1)
+       {
+       for (i = (offsets[0] + offsets[1]) / 2; i > offsets[0]; i--)
+         if (ones[i] <= 2)
+           {
+           offsets[2] = i;
+           break;
+           }
+       }
+     }
+   SLJIT_ASSERT(offsets[1] == -1 || (offsets[0] < offsets[1]));
+   SLJIT_ASSERT(offsets[2] == -1 || (offsets[0] < offsets[2] && offsets[1] > offsets[2]));
+   chars[0] = chars[offsets[0] << 1];
+   chars[1] = chars[(offsets[0] << 1) + 1];
+   if (offsets[2] >= 0)
+     {
+     chars[2] = chars[offsets[2] << 1];
+     chars[3] = chars[(offsets[2] << 1) + 1];
+     }
+   if (offsets[1] >= 0)
+     {
+     chars[4] = chars[offsets[1] << 1];
+     chars[5] = chars[(offsets[1] << 1) + 1];
+     }
+   }
+ max -= 1;
  if (firstline)
    {
    SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
    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));
+ #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
+ if (range_right >= 0)
+   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));
+ SLJIT_ASSERT(range_right >= 0 || offsets[0] >= 0);
- 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));
+ if (range_right >= 0)
- if (chars[1] != 0)
+   {
-   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
+ #if defined COMPILE_PCRE8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
- CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right));
- if (location > 2 * 2)
+ #else
-   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right + 1) - 1);
- if (chars[3] != 0)
+ #endif
-   OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[3]);
- CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[2], start);
+ #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
- if (location > 2 * 2)
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(RETURN_ADDR, TMP1), 0);
-   {
+ #else
-   if (chars[5] != 0)
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)update_table);
-     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[5]);
+ #endif
-   CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[4], start);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start);
+   }
+ if (offsets[0] >= 0)
+   {
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[0]));
+   if (offsets[1] >= 0)
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[1]));
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   if (chars[1] != 0)
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
+   CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
+   if (offsets[2] >= 0)
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[2] - 1));
+   if (offsets[1] >= 0)
+     {
+     if (chars[5] != 0)
+       OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[5]);
+     CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[4], start);
+     }
+   if (offsets[2] >= 0)
+     {
+     if (chars[3] != 0)
+       OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[3]);
+     CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[2], start);
+     }
+   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));
  JUMPHERE(quit);
  if (firstline)
+   {
+   if (range_right >= 0)
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
    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_N_BYTES
  static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)
  {
-Line 2804 
 if (firstline)
+Line 3830 
 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);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
    }
  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);
  oc = first_char;
-Line 2821 
 if (caseless)
+Line 3847 
 if (caseless)
  #endif
    }
  if (first_char == oc)
-   found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, first_char);
+   found = CMP(SLJIT_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);
+     found = CMP(SLJIT_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);
+     OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_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);
+     OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
-     found = JUMP(SLJIT_C_NOT_ZERO);
+     found = JUMP(SLJIT_NOT_ZERO);
      }
    }
-Line 2864 
 if (firstline)
+Line 3890 
 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);
+   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
    }
  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 2885 
 if (common->nltype == NLTYPE_FIXED && co
+Line 3911 
 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)
-     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 2917 
 if (common->nltype == NLTYPE_ANY || comm
+Line 3945 
 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 2935 
 if (firstline)
+Line 3963 
 if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
- static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks);
+ static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks);
- static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline)
+ static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, pcre_uint8 *start_bits, BOOL firstline)
  {
  DEFINE_COMPILER;
  struct sljit_label *start;
  struct sljit_jump *quit;
  struct sljit_jump *found = NULL;
  jump_list *matches = NULL;
- pcre_uint8 inverted_start_bits[32];
- int i;
  #ifndef COMPILE_PCRE8
  struct sljit_jump *jump;
  #endif
- for (i = 0; i < 32; ++i)
-   inverted_start_bits[i] = ~(((pcre_uint8*)start_bits)[i]);
  if (firstline)
    {
    SLJIT_ASSERT(common->first_line_end != 0);
    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->first_line_end);
    }
  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_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)start_bits);
    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
-   found = JUMP(SLJIT_C_NOT_ZERO);
+   found = JUMP(SLJIT_NOT_ZERO);
    }
  #ifdef SUPPORT_UTF
-Line 2992 
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, S
+Line 4015 
 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);
    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 3031 
 struct sljit_jump *notfound;
+Line 4054 
 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 3042 
 else
+Line 4065 
 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 3055 
 if (caseless)
+Line 4078 
 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 3076 
 JUMPTO(SLJIT_JUMP, loop);
+Line 4099 
 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 3096 
 GET_LOCAL_BASE(TMP3, 0, 0);
+Line 4119 
 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 3105 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
+Line 4128 
 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 3121 
 static void check_wordboundary(compiler_
+Line 4144 
 static void check_wordboundary(compiler_
  {
  DEFINE_COMPILER;
  struct sljit_jump *skipread;
+ jump_list *skipread_list = NULL;
  #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF
  struct sljit_jump *jump;
  #endif
  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 3142 
 read_char(common);
+Line 4166 
 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);
    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 3178 
 else
+Line 4202 
 else
  JUMPHERE(skipread);
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
- skipread = check_str_end(common);
+ 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 3202 
 else
+Line 4226 
 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);
    OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);
-Line 3219 
 else
+Line 4243 
 else
      JUMPHERE(jump);
  #endif /* COMPILE_PCRE8 */
    }
- JUMPHERE(skipread);
+ 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];
+ pcre_uint8 bit, cbit, all;
+ int i, byte, length = 0;
+ bit = bits[0] & 0x1;
+ /* All bits will be zero or one (since bit is zero or one). */
+ all = -bit;
+ for (i = 0; i < 256; )
+   {
+   byte = i >> 3;
+   if ((i & 0x7) == 0 && bits[byte] == all)
+     i += 8;
+   else
+     {
+     cbit = (bits[byte] >> (i & 0x7)) & 0x1;
+     if (cbit != bit)
+       {
+       if (length >= MAX_RANGE_SIZE)
+         return FALSE;
+       ranges[length] = i;
+       length++;
+       bit = cbit;
+       all = -cbit;
+       }
+     i++;
+     }
+   }
+ if (((bit == 0) && nclass) || ((bit == 1) && !nclass))
+   {
+   if (length >= MAX_RANGE_SIZE)
+     return FALSE;
+   ranges[length] = 256;
+   length++;
+   }
- if (ranges[0] < 0)
+ if (length < 0 || length > 4)
    return FALSE;
- switch(ranges[0])
+ bit = bits[0] & 0x1;
+ if (invert) bit ^= 0x1;