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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1195 by zherczeg,
Thu Nov  1 15:21:27 2012 UTC
+revision 1491 by zherczeg,
Mon Jul  7 07:11:16 2014 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 65 
 system files. */
  #error Unsupported architecture
  #endif
+ /* Defines for debugging purposes. */
+ /* 1 - Use unoptimized capturing brackets.
+- 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 157 
 typedef struct jit_arguments {
+Line 166 
 typedef struct jit_arguments {
    int *offsets;
    pcre_uchar *uchar_ptr;
    pcre_uchar *mark_ptr;
+   void *callout_data;
    /* Everything else after. */
-   int offsetcount;
+   pcre_uint32 limit_match;
-   int calllimit;
+   int real_offset_count;
+   int offset_count;
    pcre_uint8 notbol;
    pcre_uint8 noteol;
    pcre_uint8 notempty;
-Line 168 
 typedef struct jit_arguments {
+Line 179 
 typedef struct jit_arguments {
  typedef struct executable_functions {
    void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];
+   sljit_uw *read_only_data[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 179 
 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 209 
 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 230 
 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 265 
 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;
+   /* This read-only data is available during runtime. */
+   sljit_uw *read_only_data;
+   /* The total size of the read-only data. */
+   sljit_uw read_only_data_size;
+   /* The next free entry of the read_only_data. */
+   sljit_uw *read_only_data_ptr;
    /* 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;
    /* Head of the last recursion. */
-   int recursive_head;
+   int recursive_head_ptr;
    /* First inspected character for partial matching. */
    int start_used_ptr;
    /* Starting pointer for partial soft matches. */
-Line 298 
 typedef struct compiler_common {
+Line 350 
 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;
    /* Labels and jump lists. */
    struct sljit_label *partialmatchlabel;
-   struct sljit_label *quitlabel;
+   struct sljit_label *quit_label;
-   struct sljit_label *acceptlabel;
+   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;
    jump_list *stackalloc;
-Line 338 
 typedef struct compiler_common {
+Line 417 
 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 390 
 typedef struct compare_context {
+Line 469 
 typedef struct compare_context {
  #endif
  } compare_context;
- enum {
-   frame_end = 0,
-   frame_setstrbegin = -1,
-   frame_setmark = -2
- };
  /* Undefine sljit macros. */
  #undef CMP
  /* Used for accessing the elements of the stack. */
  #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_sw))
- #define TMP1          SLJIT_TEMPORARY_REG1
+ #define TMP1          SLJIT_R0
- #define TMP2          SLJIT_TEMPORARY_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_TEMPORARY_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 421 
 enum {
+Line 494 
 enum {
  #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 459 
 the start pointers when the end of the c
+Line 532 
 the start pointers when the end of the c
    sljit_set_label(sljit_emit_jump(compiler, (type)), (label))
  #define JUMPHERE(jump) \
    sljit_set_label((jump), sljit_emit_label(compiler))
+ #define SET_LABEL(jump, label) \
+   sljit_set_label((jump), (label))
  #define CMP(type, src1, src1w, src2, src2w) \
    sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))
  #define CMPTO(type, src1, src1w, src2, src2w, label) \
    sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))
- #define COND_VALUE(op, dst, dstw, type) \
+ #define OP_FLAGS(op, dst, dstw, src, srcw, type) \
-   sljit_emit_cond_value(compiler, (op), (dst), (dstw), (type))
+   sljit_emit_op_flags(compiler, (op), (dst), (dstw), (src), (srcw), (type))
  #define GET_LOCAL_BASE(dst, dstw, offset) \
    sljit_get_local_base(compiler, (dst), (dstw), (offset))
+ #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));
-Line 477 
 cc += 1 + LINK_SIZE;
+Line 554 
 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 507 
 switch(*cc)
+Line 603 
 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 519 
 switch(*cc)
+Line 617 
 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 561 
 switch(*cc)
+Line 688 
 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];
    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: \
+ int count;
-     case OP_QUERY: \
+ pcre_uchar *slot;
-     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 \
+ /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
-     case OP_STAR: \
+ while (cc < ccend)
-     case OP_PLUS: \
+   {
-     case OP_STARI: \
+   switch(*cc)
-     case OP_PLUSI: \
+     {
-     case OP_NOTSTAR: \
+     case OP_SET_SOM:
-     case OP_NOTPLUS: \
+     common->has_set_som = TRUE;
-     case OP_NOTSTARI: \
+     common->might_be_empty = TRUE;
-     case OP_NOTPLUSI:
+     cc += 1;
+     break;
- #define CASE_ITERATOR_PRIVATE_DATA_2B \
+     case OP_REF:
-     case OP_UPTO: \
+     case OP_REFI:
-     case OP_MINUPTO: \
+     common->optimized_cbracket[GET2(cc, 1)] = 0;
-     case OP_UPTOI: \
+     cc += 1 + IMM2_SIZE;
-     case OP_MINUPTOI: \
+     break;
-     case OP_NOTUPTO: \
-     case OP_NOTMINUPTO: \
-     case OP_NOTUPTOI: \
-     case OP_NOTMINUPTOI:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
+     case OP_BRA:
-     case OP_TYPEMINSTAR: \
+     case OP_CBRA:
-     case OP_TYPEMINPLUS: \
+     case OP_SBRA:
-     case OP_TYPEQUERY: \
+     case OP_SCBRA:
-     case OP_TYPEMINQUERY:
+     count = no_alternatives(cc);
+     if (count > 4)
+       common->read_only_data_size += count * sizeof(sljit_uw);
+     cc += 1 + LINK_SIZE + (*cc == OP_CBRA || *cc == OP_SCBRA ? IMM2_SIZE : 0);
+     break;
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
+     case OP_CBRAPOS:
-     case OP_TYPESTAR: \
+     case OP_SCBRAPOS:
-     case OP_TYPEPLUS:
+     common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
+     break;
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
+     case OP_COND:
-     case OP_TYPEUPTO: \
+     case OP_SCOND:
-     case OP_TYPEMINUPTO:
+     /* Only AUTO_CALLOUT can insert this opcode. We do
+        not intend to support this case. */
+     if (cc[1 + LINK_SIZE] == OP_CALLOUT)
+       return FALSE;
+     cc += 1 + LINK_SIZE;
+     break;
- static int get_class_iterator_size(pcre_uchar *cc)
+     case OP_CREF:
- {
+     common->optimized_cbracket[GET2(cc, 1)] = 0;
+     cc += 1 + IMM2_SIZE;
+     break;
+     case OP_DNREF:
+     case OP_DNREFI:
+     case OP_DNCREF:
+     count = GET2(cc, 1 + IMM2_SIZE);
+     slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
+     while (count-- > 0)
+       {
+       common->optimized_cbracket[GET2(slot, 0)] = 0;
+       slot += common->name_entry_size;
+       }
+     cc += 1 + 2 * IMM2_SIZE;
+     break;
+     case OP_RECURSE:
+     /* Set its value only once. */
+     if (common->recursive_head_ptr == 0)
+       {
+       common->recursive_head_ptr = common->ovector_start;
+       common->ovector_start += sizeof(sljit_sw);
+       }
+     cc += 1 + LINK_SIZE;
+     break;
+     case OP_CALLOUT:
+     if (common->capture_last_ptr == 0)
+       {
+       common->capture_last_ptr = common->ovector_start;
+       common->ovector_start += sizeof(sljit_sw);
+       }
+     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)
+       {
+       common->mark_ptr = common->ovector_start;
+       common->ovector_start += sizeof(sljit_sw);
+       }
+     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 FALSE;
+     break;
+     }
+   }
+ return TRUE;
+ }
+ static int get_class_iterator_size(pcre_uchar *cc)
+ {
  switch(*cc)
    {
    case OP_CRSTAR:
-Line 762 
 switch(*cc)
+Line 934 
 switch(*cc)
    }
  }
- static int get_private_data_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
+ 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 (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
+       break;
+     next_end = bracketend(next + 2 + LINK_SIZE);
+     if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)
+       break;
+     next = next_end;
+     max++;
+     }
+   if (next[0] == type && next[1] == *begin && max >= 1)
+     {
+     next_end = bracketend(next + 1);
+     if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)
+       {
+       for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
+         if (*next_end != OP_KET)
+           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);
+         }
+       }
+     }
+   }
+ 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;
+ }
+ #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)
  {
- int private_data_length = 0;
+ pcre_uchar *cc = common->start;
  pcre_uchar *alternative;
- pcre_uchar *name;
  pcre_uchar *end = NULL;
- int space, size, i;
+ int private_data_ptr = *private_data_start;
- pcre_uint32 bracketlen;
+ int space, size, bracketlen;
- /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
    {
    space = 0;
    size = 0;
    bracketlen = 0;
+   if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
+     return;
+   if (*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);
+       }
    switch(*cc)
      {
-     case OP_SET_SOM:
+     case OP_KET:
-     common->has_set_som = TRUE;
+     if (common->private_data_ptrs[cc + 1 - common->start] != 0)
-     cc += 1;
+       {
-     break;
+       common->private_data_ptrs[cc - common->start] = private_data_ptr;
+       private_data_ptr += sizeof(sljit_sw);
-     case OP_REF:
+       cc += common->private_data_ptrs[cc + 1 - common->start];
-     case OP_REFI:
+       }
-     common->optimized_cbracket[GET2(cc, 1)] = 0;
+     cc += 1 + LINK_SIZE;
-     cc += 1 + IMM2_SIZE;
      break;
      case OP_ASSERT:
-Line 799 
 while (cc < ccend)
+Line 1117 
 while (cc < ccend)
      case OP_BRAPOS:
      case OP_SBRA:
      case OP_SBRAPOS:
-     private_data_length += sizeof(sljit_sw);
+     case OP_SCOND:
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
+     private_data_ptr += sizeof(sljit_sw);
      bracketlen = 1 + LINK_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     private_data_length += sizeof(sljit_sw);
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
+     private_data_ptr += sizeof(sljit_sw);
      bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-     case OP_SCOND:
+     /* Might be a hidden SCOND. */
-     bracketlen = cc[1 + LINK_SIZE];
+     alternative = cc + GET(cc, 1);
-     if (bracketlen == OP_CREF)
+     if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
-       {
-       bracketlen = GET2(cc, 1 + LINK_SIZE + 1);
-       common->optimized_cbracket[bracketlen] = 0;
-       }
-     else if (bracketlen == OP_NCREF)
-       {
-       bracketlen = GET2(cc, 1 + LINK_SIZE + 1);
-       name = (pcre_uchar *)common->name_table;
-       alternative = name;
-       for (i = 0; i < common->name_count; i++)
-         {
-         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(alternative, 0)] = 0;
-         alternative += common->name_entry_size;
-         }
-       }
-     if (*cc == OP_COND)
        {
-       /* Might be a hidden SCOND. */
+       common->private_data_ptrs[cc - common->start] = private_data_ptr;
-       alternative = cc + GET(cc, 1);
+       private_data_ptr += sizeof(sljit_sw);
-       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;
-Line 904 
 while (cc < ccend)
+Line 1195 
 while (cc < ccend)
      break;
  #endif
-     case OP_RECURSE:
-     /* Set its value only once. */
-     if (common->recursive_head == 0)
-       {
-       common->recursive_head = common->ovector_start;
-       common->ovector_start += sizeof(sljit_sw);
-       }
-     cc += 1 + LINK_SIZE;
-     break;
-     case OP_MARK:
-     if (common->mark_ptr == 0)
-       {
-       common->mark_ptr = common->ovector_start;
-       common->ovector_start += sizeof(sljit_sw);
-       }
-     cc += 1 + 2 + cc[1];
-     break;
      default:
      cc = next_opcode(common, cc);
-     if (cc == NULL)
+     SLJIT_ASSERT(cc != NULL);
-       return -1;
      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)
-     private_data_length += sizeof(sljit_sw) * space;
+     {
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
+     private_data_ptr += sizeof(sljit_sw) * space;
+     }
    if (size != 0)
      {
-Line 946 
 while (cc < ccend)
+Line 1222 
 while (cc < ccend)
        cc += size;
      }
-   if (bracketlen != 0)
+   if (bracketlen > 0)
      {
      if (cc >= end)
        {
-Line 957 
 while (cc < ccend)
+Line 1233 
 while (cc < ccend)
      cc += bracketlen;
      }
    }
- return private_data_length;
+ *private_data_start = private_data_ptr;
  }
- static void set_private_data_ptrs(compiler_common *common, int private_data_ptr, pcre_uchar *ccend)
+ /* Returns with a frame_types (always < 0) if no need for frame. */
+ static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL* needs_control_head)
  {
- pcre_uchar *cc = common->start;
+ int length = 0;
- pcre_uchar *alternative;
+ int possessive = 0;
- pcre_uchar *end = NULL;
+ BOOL stack_restore = FALSE;
- int space, size, bracketlen;
+ BOOL setsom_found = recursive;
+ BOOL setmark_found = recursive;
+ /* The last capture is a local variable even for recursions. */
+ BOOL capture_last_found = FALSE;
- while (cc < ccend)
+ #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)
    {
-   space = 0;
+   ccend = bracketend(cc) - (1 + LINK_SIZE);
-   size = 0;
+   if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
-   bracketlen = 0;
+     {
+     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);
+   }
+ SLJIT_ASSERT(cc != NULL);
+ while (cc < ccend)
    switch(*cc)
      {
-     case OP_ASSERT:
+     case OP_SET_SOM:
-     case OP_ASSERT_NOT:
+     SLJIT_ASSERT(common->has_set_som);
-     case OP_ASSERTBACK:
+     stack_restore = TRUE;
-     case OP_ASSERTBACK_NOT:
+     if (!setsom_found)
-     case OP_ONCE:
+       {
-     case OP_ONCE_NC:
+       length += 2;
-     case OP_BRAPOS:
+       setsom_found = TRUE;
-     case OP_SBRA:
+       }
-     case OP_SBRAPOS:
+     cc += 1;
-     case OP_SCOND:
-     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     private_data_ptr += sizeof(sljit_sw);
-     bracketlen = 1 + LINK_SIZE;
-     break;
-     case OP_CBRAPOS:
-     case OP_SCBRAPOS:
-     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     private_data_ptr += sizeof(sljit_sw);
-     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
-     break;
-     case OP_COND:
-     /* Might be a hidden SCOND. */
-     alternative = cc + GET(cc, 1);
-     if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
-       {
-       common->private_data_ptrs[cc - common->start] = private_data_ptr;
-       private_data_ptr += sizeof(sljit_sw);
-       }
-     bracketlen = 1 + LINK_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
-     default:
-     cc = next_opcode(common, cc);
-     SLJIT_ASSERT(cc != NULL);
-     break;
-     }
-   if (space > 0 && cc >= end)
-     {
-     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     private_data_ptr += sizeof(sljit_sw) * space;
-     }
-   if (size != 0)
-     {
-     if (size < 0)
-       {
-       cc += -size;
- #ifdef SUPPORT_UTF
-       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
- #endif
-       }
-     else
-       cc += size;
-     }
-   if (bracketlen > 0)
-     {
-     if (cc >= end)
-       {
-       end = bracketend(cc);
-       if (end[-1 - LINK_SIZE] == OP_KET)
-         end = NULL;
-       }
-     cc += bracketlen;
-     }
-   }
- }
- /* Returns with -1 if no need for frame. */
- static int get_framesize(compiler_common *common, pcre_uchar *cc, BOOL recursive)
- {
- pcre_uchar *ccend = bracketend(cc);
- int length = 0;
- BOOL possessive = FALSE;
- BOOL setsom_found = recursive;
- BOOL setmark_found = recursive;
- if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
-   {
-   length = 3;
-   possessive = TRUE;
-   }
- cc = next_opcode(common, cc);
- SLJIT_ASSERT(cc != NULL);
- while (cc < ccend)
-   switch(*cc)
-     {
-     case OP_SET_SOM:
-     SLJIT_ASSERT(common->has_set_som);
-     if (!setsom_found)
-       {
-       length += 2;
-       setsom_found = TRUE;
-       }
-     cc += 1;
      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 1150 
 while (cc < ccend)
+Line 1308 
 while (cc < ccend)
        length += 2;
        setmark_found = TRUE;
        }
+     if (common->capture_last_ptr != 0 && !capture_last_found)
+       {
+       length += 2;
+       capture_last_found = TRUE;
+       }
      cc += 1 + LINK_SIZE;
      break;
-Line 1157 
 while (cc < ccend)
+Line 1320 
 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;
+       capture_last_found = TRUE;
+       }
      length += 3;
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      default:
+     stack_restore = TRUE;
+     /* Fall through. */
+     case OP_NOT_WORD_BOUNDARY:
+     case OP_WORD_BOUNDARY:
+     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:
      cc = next_opcode(common, cc);
      SLJIT_ASSERT(cc != NULL);
      break;
      }
  /* Possessive quantifiers can use a special case. */
- if (SLJIT_UNLIKELY(possessive) && length == 3)
+ if (SLJIT_UNLIKELY(possessive == length))
-   return -1;
+   return stack_restore ? no_frame : no_stack;
  if (length > 0)
    return length + 1;
- return -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. */
+ BOOL capture_last_found = FALSE;
  int offset;
  /* >= 1 + shortest item size (2) */
-Line 1189 
 SLJIT_UNUSED_ARG(stacktop);
+Line 1426 
 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 1199 
 while (cc < ccend)
+Line 1441 
 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, frame_setstrbegin);
+       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);
        stackpos += (int)sizeof(sljit_sw);
-Line 1210 
 while (cc < ccend)
+Line 1452 
 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, frame_setmark);
+       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);
        stackpos += (int)sizeof(sljit_sw);
-Line 1226 
 while (cc < ccend)
+Line 1470 
 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, frame_setstrbegin);
+       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);
        stackpos += (int)sizeof(sljit_sw);
-Line 1235 
 while (cc < ccend)
+Line 1479 
 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, frame_setmark);
+       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);
        stackpos += (int)sizeof(sljit_sw);
        setmark_found = TRUE;
        }
+     if (common->capture_last_ptr != 0 && !capture_last_found)
+       {
+       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);
+       stackpos += (int)sizeof(sljit_sw);
+       capture_last_found = TRUE;
+       }
      cc += 1 + LINK_SIZE;
      break;
-Line 1249 
 while (cc < ccend)
+Line 1502 
 while (cc < ccend)
      case OP_CBRAPOS:
      case OP_SCBRA:
      case OP_SCBRAPOS:
+     if (common->capture_last_ptr != 0 && !capture_last_found)
+       {
+       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);
+       stackpos += (int)sizeof(sljit_sw);
+       capture_last_found = TRUE;
+       }
      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 1268 
 while (cc < ccend)
+Line 1530 
 while (cc < ccend)
      break;
      }
- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_end);
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0);
  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 1283 
 while (cc < ccend)
+Line 1545 
 while (cc < ccend)
    size = 0;
    switch(*cc)
      {
+     case OP_KET:
+     if (PRIVATE_DATA(cc) != 0)
+       private_data_length++;
+     cc += 1 + LINK_SIZE;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 1387 
 return private_data_length;
+Line 1655 
 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 1408 
 stacktop = STACK(stacktop - 1);
+Line 1676 
 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 1424 
 if (!save)
+Line 1692 
 if (!save)
    /* The tmp1next must be TRUE in either way. */
    }
- while (status != end)
+ do
    {
    count = 0;
    switch(status)
      {
      case start:
-     SLJIT_ASSERT(save && common->recursive_head != 0);
+     SLJIT_ASSERT(save && common->recursive_head_ptr != 0);
      count = 1;
-     srcw[0] = common->recursive_head;
+     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 1445 
 while (status != end)
+Line 1719 
 while (status != end)
      switch(*cc)
        {
+       case OP_KET:
+       if (PRIVATE_DATA(cc) != 0)
+         {
+         count = 1;
+         srcw[0] = PRIVATE_DATA(cc);
+         }
+       cc += 1 + LINK_SIZE;
+       break;
        case OP_ASSERT:
        case OP_ASSERT_NOT:
        case OP_ASSERTBACK:
-Line 1612 
 while (status != end)
+Line 1895 
 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 1623 
 while (status != end)
+Line 1906 
 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 1633 
 while (status != end)
+Line 1916 
 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 1645 
 while (status != end)
+Line 1928 
 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 1657 
 while (status != end)
+Line 1940 
 while (status != end)
        }
      }
    }
+ while (status != end);
  if (save)
    {
-Line 1690 
 if (save)
+Line 1974 
 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 1708 
 while (list)
+Line 2025 
 while (list)
    {
    /* sljit_set_label is clever enough to do nothing
    if either the jump or the label is NULL. */
-   sljit_set_label(list->jump, label);
+   SET_LABEL(list->jump, label);
    list = list->next;
    }
  }
-Line 1724 
 if (list_item)
+Line 2041 
 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));
  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 1748 
 stub_list* list_item = common->stubs;
+Line 2063 
 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;
- OP2(SLJIT_SUB | SLJIT_SET_E, CALL_COUNT, 0, CALL_COUNT, 0, SLJIT_IMM, 1);
+ label_addr = sljit_alloc_memory(compiler, sizeof(label_addr_list));
- add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));
+ 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, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);
+ add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));
  }
  static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)
-Line 1778 
 OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP,
+Line 2102 
 OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP,
  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_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));
  }
  static SLJIT_INLINE void free_stack(compiler_common *common, int size)
-Line 1795 
 static SLJIT_INLINE void reset_ovector(c
+Line 2119 
 static SLJIT_INLINE void reset_ovector(c
  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_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
+ OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
+ if (length < 8)
+   {
+   for (i = 1; i < length; i++)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), SLJIT_R0, 0);
+   }
+ else
+   {
+   GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START);
+   OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1);
+   loop = LABEL();
+   OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R0, 0);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);
+   JUMPTO(SLJIT_C_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 = 0; i < length; i++)
+   for (i = 2; i < length; i++)
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_TEMPORARY_REG1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), TMP1, 0);
    }
  else
    {
-   GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, OVECTOR_START - sizeof(sljit_sw));
+   GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw));
-   OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, length);
+   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);
    loop = LABEL();
-   OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(sljit_sw), SLJIT_TEMPORARY_REG1, 0);
+   OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);
    JUMPTO(SLJIT_C_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;
+     }
+   current = (sljit_sw*)current[-1];
+   }
+ return -1;
  }
  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
  {
  DEFINE_COMPILER;
  struct sljit_label *loop;
- struct sljit_jump *earlyexit;
+ 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_TEMPORARY_REG1, 0, ARGUMENTS, 0);
+ OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0);
  if (common->mark_ptr != 0)
-   OP1(SLJIT_MOV, SLJIT_TEMPORARY_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_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsetcount));
+ 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_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_TEMPORARY_REG3, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_R2, 0);
- OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_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_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_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 */
- earlyexit = CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 0);
+ early_quit = CMP(SLJIT_C_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0);
  loop = LABEL();
- OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_TEMPORARY_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_TEMPORARY_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_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_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);
- JUMPHERE(earlyexit);
+ JUMPHERE(early_quit);
  /* Calculate the return value, which is the maximum ovector value. */
  if (topbracket > 1)
    {
-   GET_LOCAL_BASE(SLJIT_TEMPORARY_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_TEMPORARY_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_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_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_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
-   CMPTO(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG3, 0, loop);
+   CMPTO(SLJIT_C_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop);
-   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_TEMPORARY_REG2, 0);
+   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_R1, 0);
    }
  else
    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
-Line 1867 
 else
+Line 2251 
 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_TEMPORARY_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_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, offsetcount));
+ OP1(SLJIT_MOV_SI, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
- CMPTO(SLJIT_C_LESS, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 2, quit);
+ CMPTO(SLJIT_C_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 2, quit);
  /* Store match begin and end. */
- OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, begin));
+ OP1(SLJIT_MOV, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, begin));
- OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));
+ OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, offsets));
- OP1(SLJIT_MOV, SLJIT_TEMPORARY_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_C_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_TEMPORARY_REG2), sizeof(int), SLJIT_SAVED_REG2, 0);
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), sizeof(int), SLJIT_S1, 0);
- OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_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_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_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_TEMPORARY_REG2), 0, SLJIT_TEMPORARY_REG3, 0);
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);
  JUMPTO(SLJIT_JUMP, quit);
  }
-Line 1904 
 struct sljit_jump *jump;
+Line 2299 
 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);
-   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_C_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);
    }
  }
-Line 2040 
 return (bit < 256) ? ((0 << 8) | bit) :
+Line 2435 
 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 2050 
 if (common->mode == JIT_COMPILE)
+Line 2445 
 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_C_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_C_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 2068 
 if (jump != NULL)
+Line 2463 
 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_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+   return;
+   }
  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
    {
-   nohit = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
+   add_jump(compiler, end_reached, CMP(SLJIT_C_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_C_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 2112 
 if (common->mode == JIT_COMPILE)
+Line 2506 
 if (common->mode == JIT_COMPILE)
  /* Partial matching mode. */
  jump = CMP(SLJIT_C_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_C_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 2128 
 else
+Line 2522 
 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
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-   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 */
+ #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_C_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
+ }
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ static BOOL is_char7_bitset(const pcre_uint8 *bitset, BOOL nclass)
+ {
+ /* Tells whether the character codes below 128 are enough
+ 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;
+ struct sljit_jump *jump;
+ SLJIT_ASSERT(common->utf);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+ if (full_read)
+   {
+   jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
+   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+   JUMPHERE(jump);
+   }
  }
- static void peek_char(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 into TMP1, keeps STR_PTR.
+ /* Reads the precise value of a character into TMP1, if the character is
- Does not check STR_END. TMP2 Destroyed. */
+ between min and max (c >= min && c <= max). Otherwise it returns with a value
+ outside the range. Does not check STR_END. */
  DEFINE_COMPILER;
  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ struct sljit_jump *jump2;
+ #endif
- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ SLJIT_UNUSED_ARG(update_str_ptr);
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ SLJIT_UNUSED_ARG(min);
+ SLJIT_UNUSED_ARG(max);
+ SLJIT_ASSERT(min <= max);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
  if (common->utf)
    {
- #if defined COMPILE_PCRE8
+   if (max < 128 && !update_str_ptr) return;
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
- #elif defined COMPILE_PCRE16
+   if (min >= 0x10000)
-   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+     {
- #endif /* COMPILE_PCRE[8|16] */
+     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xf0);
-   add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
+     if (update_str_ptr)
-   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+       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_C_GREATER, TMP2, 0, SLJIT_IMM, 0x7);
+     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
+     if (!update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
+     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+     JUMPHERE(jump2);
+     if (update_str_ptr)
+       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+     }
+   else if (min >= 0x800 && max <= 0xffff)
+     {
+     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xe0);
+     if (update_str_ptr)
+       OP1(SLJIT_MOV_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_C_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 /* SUPPORT_UTF && !COMPILE_PCRE32 */
+ #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   if (max >= 0x10000)
+     {
+     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+     jump = CMP(SLJIT_C_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_C_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+   if (update_str_ptr)
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   if (max >= 0xd800)
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000);
+   JUMPHERE(jump);
+   }
+ #endif
+ }
+ static SLJIT_INLINE void read_char(compiler_common *common)
+ {
+ read_char_range(common, 0, READ_CHAR_MAX, TRUE);
  }
- static void read_char8_type(compiler_common *common)
+ static void read_char8_type(compiler_common *common, BOOL update_str_ptr)
  {
  /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
  DEFINE_COMPILER;
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
  struct sljit_jump *jump;
  #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ struct sljit_jump *jump2;
+ #endif
- #ifdef SUPPORT_UTF
+ SLJIT_UNUSED_ARG(update_str_ptr);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
  if (common->utf)
    {
-   OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #if defined COMPILE_PCRE8
    /* This can be an extra read in some situations, but hopefully
    it is needed in most cases. */
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
    jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
-   add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
+   if (!update_str_ptr)
-   JUMPHERE(jump);
+     {
- #elif defined COMPILE_PCRE16
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
+     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
-   JUMPHERE(jump);
+     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
-   /* Skip low surrogate if necessary. */
+     OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
-   OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);
+     jump2 = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
-   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
-   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+     JUMPHERE(jump2);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+     }
- #elif defined COMPILE_PCRE32
+   else
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+     add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
-   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
    JUMPHERE(jump);
- #endif /* COMPILE_PCRE[8|16|32] */
    return;
    }
- #endif /* SUPPORT_UTF */
+ #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if !defined COMPILE_PCRE8
- #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  /* The ctypes array contains only 256 values. */
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
  jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
  #endif
  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
- #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+ #if !defined COMPILE_PCRE8
  JUMPHERE(jump);
  #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf && update_str_ptr)
+   {
+   /* Skip low surrogate if necessary. */
+   OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800);
+   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+   JUMPHERE(jump);
+   }
+ #endif /* SUPPORT_UTF && COMPILE_PCRE16 */
  }
  static void skip_char_back(compiler_common *common)
-Line 2256 
 if (common->utf)
+Line 2833 
 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);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    return;
-Line 2266 
 if (common->utf)
+Line 2843 
 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_C_NOT_ZERO : SLJIT_C_ZERO));
    }
  else if (nltype == NLTYPE_ANYCRLF)
    {
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_CR);
+   if (jumpifmatch)
-   COND_VALUE(SLJIT_MOV, TMP2, 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_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR));
-   COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
-   add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+     }
+   else
+     {
+     jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
+     add_jump(compiler, backtracks, CMP(SLJIT_C_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_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
    }
  }
-Line 2297 
 else
+Line 2881 
 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);
+ 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_OR, TMP1, 0, TMP1, 0, TMP2, 0);
  /* Searching for the first zero. */
- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
+ OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
  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);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
+ sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+ JUMPHERE(jump);
+ 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(1));
- sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
- JUMPHERE(jump);
- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10);
+ OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10000);
  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_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12);
- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
  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_C_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_C_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 2368 
 jump = JUMP(SLJIT_C_NOT_ZERO);
+Line 2978 
 jump = JUMP(SLJIT_C_NOT_ZERO);
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);
+ /* The upper 5 bits are known at this point. */
+ compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0x3);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
  OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
- compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(compare);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
- JUMPHERE(jump);
  /* We only have types for characters less than 256. */
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
- 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 2481 
 if (firstline)
+Line 3065 
 if (firstline)
      CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
      CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
      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);
      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);
      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 2509 
 if (newlinecheck)
+Line 3093 
 if (newlinecheck)
    end = CMP(SLJIT_C_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);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    nl = JUMP(SLJIT_JUMP);
    }
+ mainloop = LABEL();
+ /* Increasing the STR_PTR here requires one less jump in the most common case. */
+ #ifdef SUPPORT_UTF
+ if (common->utf) readuchar = TRUE;
+ #endif
+ if (newlinecheck) readuchar = TRUE;
+ 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);
+ 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);
+   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);
+   }
+ #elif defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   JUMPHERE(singlechar);
+   }
+ #endif /* COMPILE_PCRE[8|16] */
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
+ JUMPHERE(start);
+ if (newlinecheck)
+   {
+   JUMPHERE(end);
+   JUMPHERE(nl);
+   }
+ return mainloop;
+ }
+ #define MAX_N_CHARS 16
+ #define MAX_N_BYTES 8
+ static SLJIT_INLINE void add_prefix_byte(pcre_uint8 byte, pcre_uint8 *bytes)
+ {
+ pcre_uint8 len = bytes[0];
+ int i;
+ if (len == 255)
+   return;
+ 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)
+ {
+ /* 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)
+   {
+   last = TRUE;
+   any = FALSE;
+   caseless = FALSE;
+   switch (*cc)
+     {
+     case OP_CHARI:
+     caseless = TRUE;
+     case OP_CHAR:
+     last = FALSE;
+     cc++;
+     break;
+     case OP_SOD:
+     case OP_SOM:
+     case OP_SET_SOM:
+     case OP_NOT_WORD_BOUNDARY:
+     case OP_WORD_BOUNDARY:
+     case OP_EODN:
+     case OP_EOD:
+     case OP_CIRC:
+     case OP_CIRCM:
+     case OP_DOLL:
+     case OP_DOLLM:
+     /* Zero width assertions. */
+     cc++;
+     continue;
+     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_QUERYI:
+     case OP_MINQUERYI:
+     case OP_POSQUERYI:
+     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);
+     if (max_chars == 0)
+       return consumed;
+     last = FALSE;
+     break;
+     case OP_KET:
+     cc += 1 + LINK_SIZE;
+     continue;
+     case OP_ALT:
+     cc += GET(cc, 1);
+     continue;
+     case OP_ONCE:
+     case OP_ONCE_NC:
+     case OP_BRA:
+     case OP_BRAPOS:
+     case OP_CBRA:
+     case OP_CBRAPOS:
+     alternative = cc + GET(cc, 1);
+     while (*alternative == OP_ALT)
+       {
+       max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, bytes, max_chars);
+       if (max_chars == 0)
+         return consumed;
+       alternative += GET(alternative, 1);
+       }
+     if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
+       cc += IMM2_SIZE;
+     cc += 1 + LINK_SIZE;
+     continue;
+     case OP_CLASS:
+ #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;
+     case OP_NCLASS:
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf) return consumed;
+ #endif
+     any = TRUE;
+     cc += 1 + 32 / sizeof(pcre_uchar);
+     break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_XCLASS:
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf) return consumed;
+ #endif
+     any = TRUE;
+     cc += GET(cc, 1);
+     break;
+ #endif
+     case OP_DIGIT:
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+     if (common->utf && !is_char7_bitset((const 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;
+     case OP_WORDCHAR:
+ #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;
+     case OP_NOT:
+     case OP_NOTI:
+     cc++;
+     /* Fall through. */
+     case OP_NOT_DIGIT:
+     case OP_NOT_WHITESPACE:
+     case OP_NOT_WORDCHAR:
+     case OP_ANY:
+     case OP_ALLANY:
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf) return consumed;
+ #endif
+     any = TRUE;
+     cc++;
+     break;
+ #ifdef SUPPORT_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;
- mainloop = LABEL();
+   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);
- /* Increasing the STR_PTR here requires one less jump in the most common case. */
+       mask = 0;
- #ifdef SUPPORT_UTF
+       if (caseless)
- if (common->utf) readuchar = TRUE;
+         {
+         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
- if (newlinecheck) readuchar = TRUE;
+         {
+         chars[0] = chr;
+         chars[1] = mask;
+         }
+       else
+         {
+         mask |= chars[0] ^ chr;
+         chr |= mask;
+         chars[0] = chr;
+         chars[1] |= mask;
+         }
- if (readuchar)
+       len--;
-   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+       consumed++;
+       if (--max_chars == 0)
+         return consumed;
+       chars += 2;
+       bytes += MAX_N_BYTES;
+       cc++;
+       oc++;
+       }
+     while (len > 0);
- if (newlinecheck)
+     if (--repeat == 0)
-   CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
+       break;
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+     len = len_save;
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     cc = cc_save;
- #if defined COMPILE_PCRE8
+     }
- if (common->utf)
-   {
-   singlechar = CMP(SLJIT_C_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);
-   }
- #elif defined COMPILE_PCRE16
- if (common->utf)
-   {
-   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
-   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
-   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
-   JUMPHERE(singlechar);
-   }
- #endif /* COMPILE_PCRE[8|16] */
- #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
- JUMPHERE(start);
- if (newlinecheck)
+   repeat = 1;
-   {
+   if (last)
-   JUMPHERE(end);
+     return consumed;
-   JUMPHERE(nl);
    }
- return mainloop;
  }
- #define MAX_N_CHARS 3
  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_uchar *cc = common->start + 1 + IMM2_SIZE;
+ pcre_uint8 bytes[MAX_N_CHARS * MAX_N_BYTES];
- int location = 0;
+ pcre_uint8 ones[MAX_N_CHARS];
- pcre_int32 len, c, bit, caseless;
+ int offsets[3];
- int must_stop;
+ 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;
+ /* This is even TRUE, if both are NULL. */
+ SLJIT_ASSERT(common->read_only_data_ptr == common->read_only_data);
+ for (i = 0; i < MAX_N_CHARS; i++)
+   {
+   chars[i << 1] = NOTACHAR;
+   chars[(i << 1) + 1] = 0;
+   bytes[i * MAX_N_BYTES] = 0;
+   }
+ max = scan_prefix(common, common->start, chars, bytes, MAX_N_CHARS);
- /* We do not support alternatives now. */
+ if (max <= 1)
- if (*(common->start + GET(common->start, 1)) == OP_ALT)
    return FALSE;
- while (TRUE)
+ for (i = 0; i < max; i++)
    {
-   caseless = 0;
+   mask = chars[(i << 1) + 1];
-   must_stop = 1;
+   ones[i] = ones_in_half_byte[mask & 0xf];
-   switch(*cc)
+   mask >>= 4;
+   while (mask != 0)
      {
-     case OP_CHAR:
+     ones[i] += ones_in_half_byte[mask & 0xf];
-     must_stop = 0;
+     mask >>= 4;
-     cc++;
+     }
-     break;
+   }
-     case OP_CHARI:
+ in_range = FALSE;
-     caseless = 1;
+ from = 0;   /* Prevent compiler "uninitialized" warning */
-     must_stop = 0;
+ for (i = 0; i <= max; i++)
-     cc++;
+   {
-     break;
+   if (in_range && (i - from) > range_len && (bytes[(i - 1) * MAX_N_BYTES] <= 4))
+     {
+     range_len = i - from;
+     range_right = i - 1;
+     }
-     case OP_SOD:
+   if (i < max && bytes[i * MAX_N_BYTES] < 255)
-     case OP_SOM:
+     {
-     case OP_SET_SOM:
+     if (!in_range)
-     case OP_NOT_WORD_BOUNDARY:
+       {
-     case OP_WORD_BOUNDARY:
+       in_range = TRUE;
-     case OP_EODN:
+       from = i;
-     case OP_EOD:
+       }
-     case OP_CIRC:
+     }
-     case OP_CIRCM:
+   else if (in_range)
-     case OP_DOLL:
+     in_range = FALSE;
-     case OP_DOLLM:
+   }
-     /* Zero width assertions. */
-     cc++;
-     continue;
-     case OP_PLUS:
+ if (range_right >= 0)
-     case OP_MINPLUS:
+   {
-     case OP_POSPLUS:
+   /* Since no data is consumed (see the assert in the beginning
-     cc++;
+   of this function), this space can be reallocated. */
-     break;
+   if (common->read_only_data)
+     SLJIT_FREE(common->read_only_data);
-     case OP_EXACT:
+   common->read_only_data_size += 256;
-     cc += 1 + IMM2_SIZE;
+   common->read_only_data = (sljit_uw *)SLJIT_MALLOC(common->read_only_data_size);
-     break;
+   if (common->read_only_data == NULL)
+     return TRUE;
-     case OP_PLUSI:
+   update_table = (sljit_ub *)common->read_only_data;
-     case OP_MINPLUSI:
+   common->read_only_data_ptr = (sljit_uw *)(update_table + 256);
-     case OP_POSPLUSI:
+   memset(update_table, IN_UCHARS(range_len), 256);
-     caseless = 1;
-     cc++;
-     break;
-     case OP_EXACTI:
+   for (i = 0; i < range_len; i++)
-     caseless = 1;
+     {
-     cc += 1 + IMM2_SIZE;
+     byte_set = bytes + ((range_right - i) * MAX_N_BYTES);
-     break;
+     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++;
+       }
+     }
+   }
-     default:
+ offsets[0] = -1;
-     must_stop = 2;
+ /* Scan forward. */
+ for (i = 0; i < max; i++)
+   if (ones[i] <= 2) {
+     offsets[0] = i;
      break;
-     }
+   }
-   if (must_stop == 2)
+ if (offsets[0] < 0 && range_right < 0)
+   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;
+       }
-   len = 1;
+   /* This case is handled better by fast_forward_first_char. */
- #ifdef SUPPORT_UTF
+   if (offsets[1] == -1 && offsets[0] == 0 && range_right < 0)
-   if (common->utf && HAS_EXTRALEN(cc[0])) len += GET_EXTRALEN(cc[0]);
+     return FALSE;
- #endif
-   if (caseless && char_has_othercase(common, cc))
+   offsets[2] = -1;
-     {
+   /* We only search for a middle character if there is no range check. */
-     caseless = char_get_othercase_bit(common, cc);
+   if (offsets[1] >= 0 && range_right == -1)
-     if (caseless == 0)
+     {
-       return FALSE;
+     /* Scan from middle. */
- #ifdef COMPILE_PCRE8
+     for (i = (offsets[0] + offsets[1]) / 2 + 1; i < offsets[1]; i++)
-     caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));
+       if (ones[i] <= 2)
- #else
+         {
-     if ((caseless & 0x100) != 0)
+         offsets[2] = i;
-       caseless = ((caseless & 0xff) << 16) | (len - (caseless >> 9));
+         break;
-     else
+         }
-       caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 9));
- #endif
-     }
-   else
-     caseless = 0;
-   while (len > 0 && location < MAX_N_CHARS * 2)
+     if (offsets[2] == -1)
-     {
-     c = *cc;
-     bit = 0;
-     if (len == (caseless & 0xff))
        {
-       bit = caseless >> 8;
+       for (i = (offsets[0] + offsets[1]) / 2; i > offsets[0]; i--)
-       c |= bit;
+         if (ones[i] <= 2)
+           {
+           offsets[2] = i;
+           break;
+           }
        }
+     }
-     chars[location] = c;
+   SLJIT_ASSERT(offsets[1] == -1 || (offsets[0] < offsets[1]));
-     chars[location + 1] = bit;
+   SLJIT_ASSERT(offsets[2] == -1 || (offsets[0] < offsets[2] && offsets[1] > offsets[2]));
-     len--;
+   chars[0] = chars[offsets[0] << 1];
-     location += 2;
+   chars[1] = chars[(offsets[0] << 1) + 1];
-     cc++;
+   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];
      }
-   if (location >= MAX_N_CHARS * 2 || must_stop != 0)
-     break;
    }
- /* At least two characters are required. */
+ max -= 1;
- if (location < 2 * 2)
-     return FALSE;
  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, (location >> 1) - 1);
+   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
+   quit = CMP(SLJIT_C_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, (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);
- 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_C_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_C_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_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[4], start);
+     }
+   if (offsets[2] >= 0)
+     {
+     if (chars[3] != 0)
+       OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[3]);
+     CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[2], start);
+     }
+   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    }
- 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_C_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, (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 2746 
 if (firstline)
+Line 3780 
 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();
-Line 2775 
 else
+Line 3809 
 else
    else
      {
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, first_char);
-     COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+     OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);
-     COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
+     OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
      found = JUMP(SLJIT_C_NOT_ZERO);
      }
    }
-Line 2806 
 if (firstline)
+Line 3840 
 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)
-Line 2819 
 if (common->nltype == NLTYPE_FIXED && co
+Line 3853 
 if (common->nltype == NLTYPE_FIXED && co
    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);
-   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_GREATER_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
-Line 2838 
 if (common->nltype == NLTYPE_FIXED && co
+Line 3872 
 if (common->nltype == NLTYPE_FIXED && co
    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;
    }
-Line 2848 
 firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_
+Line 3882 
 firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_
  skip_char_back(common);
  loop = LABEL();
- read_char(common);
+ common->ff_newline_shortcut = loop;
+ read_char_range(common, common->nlmin, common->nlmax, TRUE);
  lastchar = CMP(SLJIT_C_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);
-Line 2862 
 if (common->nltype == NLTYPE_ANY || comm
+Line 3898 
 if (common->nltype == NLTYPE_ANY || comm
    notfoundnl = CMP(SLJIT_C_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);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
-Line 2877 
 if (firstline)
+Line 3913 
 if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
- static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline)
+ 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, pcre_uint8 *start_bits, BOOL firstline)
  {
  DEFINE_COMPILER;
  struct sljit_label *start;
  struct sljit_jump *quit;
- struct sljit_jump *found;
+ struct sljit_jump *found = NULL;
+ jump_list *matches = NULL;
  #ifndef COMPILE_PCRE8
  struct sljit_jump *jump;
  #endif
-Line 2891 
 if (firstline)
+Line 3930 
 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();
-Line 2901 
 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_P
+Line 3940 
 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_P
  if (common->utf)
    OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
  #endif
+ 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_C_LESS, TMP1, 0, SLJIT_IMM, 255);
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);
- JUMPHERE(jump);
+   JUMPHERE(jump);
  #endif
- OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
+   OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
- OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
+   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_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
- found = JUMP(SLJIT_C_NOT_ZERO);
+   found = JUMP(SLJIT_C_NOT_ZERO);
+   }
  #ifdef SUPPORT_UTF
  if (common->utf)
-Line 2932 
 if (common->utf)
+Line 3975 
 if (common->utf)
    CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    }
  #endif /* COMPILE_PCRE[8|16] */
  #endif /* SUPPORT_UTF */
  JUMPTO(SLJIT_JUMP, start);
- JUMPHERE(found);
+ if (found != NULL)
+   JUMPHERE(found);
+ if (matches != NULL)
+   set_jumps(matches, LABEL());
  JUMPHERE(quit);
  if (firstline)
-Line 2958 
 struct sljit_jump *notfound;
+Line 4004 
 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);
  alreadyfound = CMP(SLJIT_C_LESS, STR_PTR, 0, TMP2, 0);
-Line 3003 
 JUMPTO(SLJIT_JUMP, loop);
+Line 4049 
 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 3022 
 GET_LOCAL_BASE(TMP3, 0, 0);
+Line 4068 
 GET_LOCAL_BASE(TMP3, 0, 0);
  /* Drop frames until we reach STACK_TOP. */
  mainloop = LABEL();
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
- jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
+ OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);
+ jump = JUMP(SLJIT_C_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));
  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));
-Line 3030 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
+Line 4078 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
  JUMPTO(SLJIT_JUMP, mainloop);
  JUMPHERE(jump);
- jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
+ jump = JUMP(SLJIT_C_SIG_LESS);
  /* End of dropping frames. */
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(jump);
- jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setstrbegin);
+ OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);
- /* Set string begin. */
+ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
+ OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);
- JUMPTO(SLJIT_JUMP, mainloop);
- JUMPHERE(jump);
- if (common->mark_ptr != 0)
-   {
-   jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setmark);
-   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
-   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
-   JUMPTO(SLJIT_JUMP, mainloop);
-   JUMPHERE(jump);
-   }
- /* Unknown command. */
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
  JUMPTO(SLJIT_JUMP, mainloop);
  }
-Line 3063 
 static void check_wordboundary(compiler_
+Line 4094 
 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);
  skip_char_back(common);
  check_start_used_ptr(common);
-Line 3088 
 if (common->use_ucp)
+Line 4120 
 if (common->use_ucp)
    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);
-   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_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);
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_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
-Line 3109 
 else
+Line 4141 
 else
    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 3120 
 else
+Line 4152 
 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
-Line 3132 
 if (common->use_ucp)
+Line 4164 
 if (common->use_ucp)
    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);
-   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_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);
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
    JUMPHERE(jump);
    }
  else
-Line 3161 
 else
+Line 4193 
 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);
- sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
- }
- /*
-   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;
- if (ranges[0] < 0)
-   return FALSE;
- switch(ranges[0])
-   {
-   case 1:
-   if (readch)
-     read_char(common);
-   add_jump(compiler, backtracks, CMP(ranges[1] == 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
-   return TRUE;
-   case 2:
-   if (readch)
-     read_char(common);
-   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);
-   add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
-   return TRUE;
-   case 4:
-   if (ranges[2] + 1 == ranges[3] && ranges[4] + 1 == ranges[5])
-     {
-     if (readch)
-       read_char(common);
-     if (ranges[1] != 0)
-       {
-       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
-       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));
-       }
-     else
-       {
-       jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]);
-       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));
-       JUMPHERE(jump);
-       }
-     return TRUE;
-     }
-   if ((ranges[3] - ranges[2]) == (ranges[5] - ranges[4]) && is_powerof2(ranges[4] - ranges[2]))
-     {
-     if (readch)
-       read_char(common);
-     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4] - ranges[2]);
-     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4]);
-     add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[5] - ranges[4]));
-     return TRUE;
-     }
-   return FALSE;
-   default:
-   return FALSE;
-   }
- }
- static void get_ctype_ranges(compiler_common *common, int flag, int *ranges)
- {
- int i, bit, length;
- const pcre_uint8 *ctypes = (const pcre_uint8*)common->ctypes;
- bit = ctypes[0] & flag;
- ranges[0] = -1;
- ranges[1] = bit != 0 ? 1 : 0;
- length = 0;
- for (i = 1; i < 256; i++)
+ OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
-   if ((ctypes[i] & flag) != bit)
+ sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
-     {
-     if (length >= MAX_RANGE_SIZE)
-       return;
-     ranges[2 + length] = i;
-     length++;
-     bit ^= flag;
-     }
- if (bit != 0)
-   {
-   if (length >= MAX_RANGE_SIZE)
-     return;
-   ranges[2 + length] = 256;
-   length++;
-   }
- ranges[0] = length;
  }
- static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks)
+ static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks)
  {
- int ranges[2 + MAX_RANGE_SIZE];
+ DEFINE_COMPILER;
+ int ranges[MAX_RANGE_SIZE];
  pcre_uint8 bit, cbit, all;
  int i, byte, length = 0;
  bit = bits[0] & 0x1;
- ranges[1] = bit;
+ /* All bits will be zero or one (since bit is zero or one). */
- /* Can be 0 or 255. */
  all = -bit;
  for (i = 0; i < 256; )
-Line 3285 
 for (i = 0; i < 256; )
+Line 4222 
 for (i = 0; i < 256; )
        {
        if (length >= MAX_RANGE_SIZE)
          return FALSE;
-       ranges[2 + length] = i;
+       ranges[length] = i;
        length++;
        bit = cbit;
        all = -cbit;
-Line 3298 
 if (((bit == 0) && nclass) || ((bit == 1
+Line 4235 
 if (((bit == 0) && nclass) || ((bit == 1
    {
    if (length >= MAX_RANGE_SIZE)
      return FALSE;
-   ranges[2 + length] = 256;
+   ranges[length] = 256;
    length++;
    }
- ranges[0] = length;
- return check_ranges(common, ranges, backtracks, FALSE);
+ if (length < 0 || length > 4)
+   return FALSE;
+ bit = bits[0] & 0x1;
+ if (invert) bit ^= 0x1;
+ /* No character is accepted. */
+ if (length == 0 && bit == 0)
+   add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+ switch(length)
+   {
+   case 0:
+   /* When bit != 0, all characters are accepted. */
+   return TRUE;
+   case 1:
+   add_jump(compiler, backtracks, CMP(bit == 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+   return TRUE;
+   case 2:
+   if (ranges[0] + 1 != ranges[1])
+     {
+     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+     add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+     }
+   else
+     add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+   return TRUE;
+   case 3:
+   if (bit != 0)
+     {
+     add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
+     if (ranges[0] + 1 != ranges[1])
+       {
+       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+       add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+       }
+     else
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+     return TRUE;
+     }
+   add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[0]));
+   if (ranges[1] + 1 != ranges[2])
+     {
+     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1]);
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
+     }
+   else
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1]));
+   return TRUE;