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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1015 by ph10,
Sun Aug 26 16:07:14 2012 UTC
+revision 1316 by zherczeg,
Sun Apr 28 08:54:42 2013 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 46 
 POSSIBILITY OF SUCH DAMAGE.
  #include "pcre_internal.h"
- #ifdef SUPPORT_JIT
+ #if defined SUPPORT_JIT
  /* All-in-one: Since we use the JIT compiler only from here,
  we just include it. This way we don't need to touch the build
 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 170 
 typedef struct executable_functions {
+Line 181 
 typedef struct executable_functions {
    void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];
    PUBL(jit_callback) callback;
    void *userdata;
+   pcre_uint32 top_bracket;
+   pcre_uint32 limit_match;
    sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
  } executable_functions;
-Line 178 
 typedef struct jump_list {
+Line 191 
 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;
+ 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
-Line 208 
 typedef struct backtrack_common {
+Line 227 
 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 229 
 typedef struct bracket_backtrack {
+Line 248 
 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 264 
 typedef struct recurse_entry {
+Line 283 
 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 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 6
  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;
    /* 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 297 
 typedef struct compiler_common {
+Line 337 
 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_w lcc;
+   sljit_sw lcc;
    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
    int mode;
+   /* \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;
    int newline;
    int bsr_nltype;
    /* Dollar endonly. */
    int endonly;
-   BOOL has_set_som;
    /* Tables. */
-   sljit_w ctypes;
+   sljit_sw ctypes;
    int digits[2 + MAX_RANGE_SIZE];
    /* Named capturing brackets. */
    sljit_uw name_table;
-   sljit_w name_count;
+   sljit_sw name_count;
-   sljit_w name_entry_size;
+   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;
    stub_list *stubs;
    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 337 
 typedef struct compiler_common {
+Line 397 
 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 *utfreadtype8;
  #endif
-Line 361 
 typedef struct compare_context {
+Line 424 
 typedef struct compare_context {
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    int ucharptr;
    union {
-     sljit_i asint;
+     sljit_si asint;
      sljit_uh asushort;
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
      sljit_ub asbyte;
      sljit_ub asuchars[4];
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
      sljit_uh asuchars[2];
- #endif
+ #elif defined COMPILE_PCRE32
+     sljit_ui asuchars[1];
  #endif
    } c;
    union {
-     sljit_i asint;
+     sljit_si asint;
      sljit_uh asushort;
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
      sljit_ub asbyte;
      sljit_ub asuchars[4];
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
      sljit_uh asuchars[2];
- #endif
+ #elif defined COMPILE_PCRE32
+     sljit_ui asuchars[1];
  #endif
    } oc;
  #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_w))
+ #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_sw))
- #define TMP1          SLJIT_TEMPORARY_REG1
+ #define TMP1          SLJIT_SCRATCH_REG1
- #define TMP2          SLJIT_TEMPORARY_REG3
+ #define TMP2          SLJIT_SCRATCH_REG3
  #define TMP3          SLJIT_TEMPORARY_EREG2
  #define STR_PTR       SLJIT_SAVED_REG1
  #define STR_END       SLJIT_SAVED_REG2
- #define STACK_TOP     SLJIT_TEMPORARY_REG2
+ #define STACK_TOP     SLJIT_SCRATCH_REG2
  #define STACK_LIMIT   SLJIT_SAVED_REG3
  #define ARGUMENTS     SLJIT_SAVED_EREG1
- #define CALL_COUNT    SLJIT_SAVED_EREG2
+ #define COUNT_MATCH   SLJIT_SAVED_EREG2
  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1
  /* Local space layout. */
  /* These two locals can be used by the current opcode. */
- #define LOCALS0          (0 * sizeof(sljit_w))
+ #define LOCALS0          (0 * sizeof(sljit_sw))
- #define LOCALS1          (1 * sizeof(sljit_w))
+ #define LOCALS1          (1 * sizeof(sljit_sw))
  /* Two local variables for possessive quantifiers (char1 cannot use them). */
- #define POSSESSIVE0      (2 * sizeof(sljit_w))
+ #define POSSESSIVE0      (2 * sizeof(sljit_sw))
- #define POSSESSIVE1      (3 * sizeof(sljit_w))
+ #define POSSESSIVE1      (3 * sizeof(sljit_sw))
  /* Max limit of recursions. */
- #define CALL_LIMIT       (4 * sizeof(sljit_w))
+ #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_w))
+ #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_sw))
- #define OVECTOR_PRIV(i)  (common->cbraptr + (i) * sizeof(sljit_w))
+ #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * sizeof(sljit_sw))
  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  #define MOV_UCHAR  SLJIT_MOV_UB
  #define MOVU_UCHAR SLJIT_MOVU_UB
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
  #define MOV_UCHAR  SLJIT_MOV_UH
  #define MOVU_UCHAR SLJIT_MOVU_UH
+ #elif defined COMPILE_PCRE32
+ #define MOV_UCHAR  SLJIT_MOV_UI
+ #define MOVU_UCHAR SLJIT_MOVU_UI
  #else
  #error Unsupported compiling mode
  #endif
- #endif
  /* Shortcuts. */
  #define DEFINE_COMPILER \
-Line 455 
 the start pointers when the end of the c
+Line 513 
 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))
-Line 475 
 return cc;
+Line 535 
 return cc;
  /* 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 503 
 switch(*cc)
+Line 563 
 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 515 
 switch(*cc)
+Line 577 
 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_CLASS:
+   case OP_NCLASS:
+   case OP_REF:
+   case OP_REFI:
+   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_NCREF:
+   case OP_RREF:
+   case OP_NRREF:
    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 557 
 switch(*cc)
+Line 642 
 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: \
-     case OP_QUERY: \
-     case OP_MINQUERY: \
-     case OP_MINSTARI: \
-     case OP_MINPLUSI: \
-     case OP_QUERYI: \
-     case OP_MINQUERYI: \
-     case OP_NOTMINSTAR: \
-     case OP_NOTMINPLUS: \
-     case OP_NOTQUERY: \
-     case OP_NOTMINQUERY: \
-     case OP_NOTMINSTARI: \
-     case OP_NOTMINPLUSI: \
-     case OP_NOTQUERYI: \
-     case OP_NOTMINQUERYI:
- #define CASE_ITERATOR_PRIVATE_DATA_2A \
-     case OP_STAR: \
-     case OP_PLUS: \
-     case OP_STARI: \
-     case OP_PLUSI: \
-     case OP_NOTSTAR: \
-     case OP_NOTPLUS: \
-     case OP_NOTSTARI: \
-     case OP_NOTPLUSI:
- #define CASE_ITERATOR_PRIVATE_DATA_2B \
-     case OP_UPTO: \
-     case OP_MINUPTO: \
-     case OP_UPTOI: \
-     case OP_MINUPTOI: \
-     case OP_NOTUPTO: \
-     case OP_NOTMINUPTO: \
-     case OP_NOTUPTOI: \
-     case OP_NOTMINUPTOI:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
-     case OP_TYPEMINSTAR: \
-     case OP_TYPEMINPLUS: \
-     case OP_TYPEQUERY: \
-     case OP_TYPEMINQUERY:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
-     case OP_TYPESTAR: \
-     case OP_TYPEPLUS:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
-     case OP_TYPEUPTO: \
-     case OP_TYPEMINUPTO:
- static int get_class_iterator_size(pcre_uchar *cc)
  {
- switch(*cc)
-   {
-   case OP_CRSTAR:
-   case OP_CRPLUS:
-   return 2;
-   case OP_CRMINSTAR:
-   case OP_CRMINPLUS:
-   case OP_CRQUERY:
-   case OP_CRMINQUERY:
-   return 1;
-   case OP_CRRANGE:
-   case OP_CRMINRANGE:
-   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
-     return 0;
-   return 2;
-   default:
-   return 0;
-   }
- }
- static int get_private_data_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
- {
- int private_data_length = 0;
- pcre_uchar *alternative;
  pcre_uchar *name;
- pcre_uchar *end = NULL;
+ pcre_uchar *name2;
- int space, size, bracketlen, i;
+ unsigned int cbra_index;
+ int i;
  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
    {
-   space = 0;
-   size = 0;
-   bracketlen = 0;
    switch(*cc)
      {
      case OP_SET_SOM:
-Line 785 
 while (cc < ccend)
+Line 757 
 while (cc < ccend)
      cc += 1 + IMM2_SIZE;
      break;
-     case OP_ASSERT:
-     case OP_ASSERT_NOT:
-     case OP_ASSERTBACK:
-     case OP_ASSERTBACK_NOT:
-     case OP_ONCE:
-     case OP_ONCE_NC:
-     case OP_BRAPOS:
-     case OP_SBRA:
-     case OP_SBRAPOS:
-     private_data_length += sizeof(sljit_w);
-     bracketlen = 1 + LINK_SIZE;
-     break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     private_data_length += sizeof(sljit_w);
      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
-     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
      case OP_SCOND:
-     bracketlen = cc[1 + LINK_SIZE];
+     /* Only AUTO_CALLOUT can insert this opcode. We do
-     if (bracketlen == OP_CREF)
+        not intend to support this case. */
-       {
+     if (cc[1 + LINK_SIZE] == OP_CALLOUT)
-       bracketlen = GET2(cc, 1 + LINK_SIZE + 1);
+       return FALSE;
-       common->optimized_cbracket[bracketlen] = 0;
+     cc += 1 + LINK_SIZE;
-       }
+     break;
-     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++)
+     case OP_CREF:
-         {
+     i = GET2(cc, 1);
-         if (STRCMP_UC_UC(alternative + IMM2_SIZE, name + IMM2_SIZE) == 0)
+     common->optimized_cbracket[i] = 0;
-           common->optimized_cbracket[GET2(alternative, 0)] = 0;
+     cc += 1 + IMM2_SIZE;
-         alternative += common->name_entry_size;
+     break;
-         }
+     case OP_NCREF:
+     cbra_index = GET2(cc, 1);
+     name = (pcre_uchar *)common->name_table;
+     name2 = name;
+     for (i = 0; i < common->name_count; i++)
+       {
+       if (GET2(name, 0) == cbra_index) break;
+       name += common->name_entry_size;
+       }
+     SLJIT_ASSERT(i != common->name_count);
+     for (i = 0; i < common->name_count; i++)
+       {
+       if (STRCMP_UC_UC(name2 + IMM2_SIZE, name + IMM2_SIZE) == 0)
+         common->optimized_cbracket[GET2(name2, 0)] = 0;
+       name2 += common->name_entry_size;
        }
+     cc += 1 + IMM2_SIZE;
+     break;
-     if (*cc == OP_COND)
+     case OP_RECURSE:
+     /* Set its value only once. */
+     if (common->recursive_head_ptr == 0)
        {
-       /* Might be a hidden SCOND. */
+       common->recursive_head_ptr = common->ovector_start;
-       alternative = cc + GET(cc, 1);
+       common->ovector_start += sizeof(sljit_sw);
-       if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
-         private_data_length += sizeof(sljit_w);
        }
-     else
+     cc += 1 + LINK_SIZE;
-       private_data_length += sizeof(sljit_w);
-     bracketlen = 1 + LINK_SIZE;
      break;
-     case OP_BRA:
+     case OP_CALLOUT:
-     bracketlen = 1 + LINK_SIZE;
+     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_CBRA:
+     case OP_THEN_ARG:
-     case OP_SCBRA:
+     common->has_then = TRUE;
-     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
+     common->control_head_ptr = 1;
-     break;
+     /* Fall through. */
-     CASE_ITERATOR_PRIVATE_DATA_1
+     case OP_PRUNE_ARG:
-     space = 1;
+     common->needs_start_ptr = TRUE;
-     size = -2;
+     /* Fall through. */
-     break;
-     CASE_ITERATOR_PRIVATE_DATA_2A
+     case OP_MARK:
-     space = 2;
+     if (common->mark_ptr == 0)
-     size = -2;
+       {
+       common->mark_ptr = common->ovector_start;
+       common->ovector_start += sizeof(sljit_sw);
+       }
+     cc += 1 + 2 + cc[1];
      break;
-     CASE_ITERATOR_PRIVATE_DATA_2B
+     case OP_THEN:
-     space = 2;
+     common->has_then = TRUE;
-     size = -(2 + IMM2_SIZE);
+     common->control_head_ptr = 1;
+     /* Fall through. */
+     case OP_PRUNE:
+     case OP_SKIP:
+     common->needs_start_ptr = TRUE;
+     cc += 1;
      break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+     case OP_SKIP_ARG:
-     space = 1;
+     common->control_head_ptr = 1;
-     size = 1;
+     common->has_skip_arg = TRUE;
+     cc += 1 + 2 + cc[1];
      break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+     default:
-     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
+     cc = next_opcode(common, cc);
-       space = 2;
+     if (cc == NULL)
-     size = 1;
+       return FALSE;
      break;
+     }
+   }
+ return TRUE;
+ }
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+ static int get_class_iterator_size(pcre_uchar *cc)
-     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
+ {
-       space = 2;
+ switch(*cc)
-     size = 1 + IMM2_SIZE;
+   {
-     break;
+   case OP_CRSTAR:
+   case OP_CRPLUS:
+   return 2;
-     case OP_CLASS:
+   case OP_CRMINSTAR:
-     case OP_NCLASS:
+   case OP_CRMINPLUS:
-     size += 1 + 32 / sizeof(pcre_uchar);
+   case OP_CRQUERY:
-     space = get_class_iterator_size(cc + size);
+   case OP_CRMINQUERY:
-     break;
+   return 1;
- #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+   case OP_CRRANGE:
-     case OP_XCLASS:
+   case OP_CRMINRANGE:
-     size = GET(cc, 1);
+   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
-     space = get_class_iterator_size(cc + size);
+     return 0;
-     break;
+   return 2;
- #endif
-     case OP_RECURSE:
+   default:
-     /* Set its value only once. */
+   return 0;
-     if (common->recursive_head == 0)
+   }
-       {
+ }
-       common->recursive_head = common->ovector_start;
-       common->ovector_start += sizeof(sljit_w);
+ static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
-       }
+ {
-     cc += 1 + LINK_SIZE;
+ 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++;
+   }
-     case OP_MARK:
+ if (min == 2)
-     if (common->mark_ptr == 0)
+   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)
        {
-       common->mark_ptr = common->ovector_start;
+       for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
-       common->ovector_start += sizeof(sljit_w);
+         if (*next_end != OP_KET)
-       }
+           break;
-     cc += 1 + 2 + cc[1];
-     break;
-     default:
+       if (i == max)
-     cc = next_opcode(common, cc);
+         {
-     if (cc == NULL)
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
-       return -1;
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
-     break;
+         /* +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:
-   if (space > 0 && cc >= end)
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
-     private_data_length += sizeof(sljit_w) * space;
+     case OP_TYPEMINSTAR: \
+     case OP_TYPEMINPLUS: \
+     case OP_TYPEQUERY: \
+     case OP_TYPEMINQUERY:
-   if (size != 0)
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
-     {
+     case OP_TYPESTAR: \
-     if (size < 0)
+     case OP_TYPEPLUS:
-       {
-       cc += -size;
- #ifdef SUPPORT_UTF
-       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
- #endif
-       }
-     else
-       cc += size;
-     }
-   if (bracketlen > 0)
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
-     {
+     case OP_TYPEUPTO: \
-     if (cc >= end)
+     case OP_TYPEMINUPTO:
-       {
-       end = bracketend(cc);
-       if (end[-1 - LINK_SIZE] == OP_KET)
-         end = NULL;
-       }
-     cc += bracketlen;
-     }
-   }
- return private_data_length;
- }
- static void set_private_data_ptrs(compiler_common *common, int private_data_ptr, pcre_uchar *ccend)
+ static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)
  {
  pcre_uchar *cc = common->start;
  pcre_uchar *alternative;
  pcre_uchar *end = NULL;
+ int private_data_ptr = *private_data_start;
  int space, size, bracketlen;
  while (cc < ccend)
-Line 967 
 while (cc < ccend)
+Line 1037 
 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_KET:
+     if (common->private_data_ptrs[cc + 1 - common->start] != 0)
+       {
+       common->private_data_ptrs[cc - common->start] = private_data_ptr;
+       private_data_ptr += sizeof(sljit_sw);
+       cc += common->private_data_ptrs[cc + 1 - common->start];
+       }
+     cc += 1 + LINK_SIZE;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 980 
 while (cc < ccend)
+Line 1072 
 while (cc < ccend)
      case OP_SBRAPOS:
      case OP_SCOND:
      common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     private_data_ptr += sizeof(sljit_w);
+     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_w);
+     private_data_ptr += sizeof(sljit_sw);
      bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
-Line 997 
 while (cc < ccend)
+Line 1089 
 while (cc < ccend)
      if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
        {
        common->private_data_ptrs[cc - common->start] = private_data_ptr;
-       private_data_ptr += sizeof(sljit_w);
+       private_data_ptr += sizeof(sljit_sw);
        }
      bracketlen = 1 + LINK_SIZE;
      break;
-Line 1062 
 while (cc < ccend)
+Line 1154 
 while (cc < ccend)
      break;
      }
+   /* Character iterators, which are not inside a repeated bracket,
+      gets a private slot instead of allocating it on the stack. */
    if (space > 0 && cc >= end)
      {
      common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     private_data_ptr += sizeof(sljit_w) * space;
+     private_data_ptr += sizeof(sljit_sw) * space;
      }
    if (size != 0)
-Line 1092 
 while (cc < ccend)
+Line 1186 
 while (cc < ccend)
      cc += bracketlen;
      }
    }
+ *private_data_start = private_data_ptr;
  }
- /* Returns with -1 if no need for frame. */
+ /* Returns with a frame_types (always < 0) if no need for frame. */
- static int get_framesize(compiler_common *common, pcre_uchar *cc, BOOL recursive)
+ static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL* needs_control_head)
  {
- pcre_uchar *ccend = bracketend(cc);
  int length = 0;
- BOOL possessive = FALSE;
+ int possessive = 0;
+ BOOL stack_restore = FALSE;
  BOOL setsom_found = recursive;
  BOOL setmark_found = recursive;
+ /* The last capture is a local variable even for recursions. */
+ BOOL capture_last_found = FALSE;
+ #if 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 (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
+ if (ccend == NULL)
    {
-   length = 3;
+   ccend = bracketend(cc) - (1 + LINK_SIZE);
-   possessive = TRUE;
+   if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
+     {
+     possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
+     /* This is correct regardless of common->capture_last_ptr. */
+     capture_last_found = TRUE;
+     }
+   cc = next_opcode(common, cc);
    }
- cc = next_opcode(common, cc);
  SLJIT_ASSERT(cc != NULL);
  while (cc < ccend)
    switch(*cc)
      {
      case OP_SET_SOM:
      SLJIT_ASSERT(common->has_set_som);
+     stack_restore = TRUE;
      if (!setsom_found)
        {
        length += 2;
-Line 1125 
 while (cc < ccend)
+Line 1235 
 while (cc < ccend)
      break;
      case OP_MARK:
+     case OP_PRUNE_ARG:
+     case OP_THEN_ARG:
      SLJIT_ASSERT(common->mark_ptr != 0);
+     stack_restore = TRUE;
      if (!setmark_found)
        {
        length += 2;
        setmark_found = TRUE;
        }
+     if (common->control_head_ptr != 0)
+       *needs_control_head = TRUE;
      cc += 1 + 2 + cc[1];
      break;
      case OP_RECURSE:
+     stack_restore = TRUE;
      if (common->has_set_som && !setsom_found)
        {
        length += 2;
-Line 1145 
 while (cc < ccend)
+Line 1261 
 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 1152 
 while (cc < ccend)
+Line 1273 
 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 1184 
 SLJIT_UNUSED_ARG(stacktop);
+Line 1379 
 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 1195 
 while (cc < ccend)
+Line 1395 
 while (cc < ccend)
      if (!setsom_found)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), 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_w);
+       stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-       stackpos += (int)sizeof(sljit_w);
+       stackpos += (int)sizeof(sljit_sw);
        setsom_found = TRUE;
        }
      cc += 1;
      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, 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_w);
+       stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-       stackpos += (int)sizeof(sljit_w);
+       stackpos += (int)sizeof(sljit_sw);
        setmark_found = TRUE;
        }
      cc += 1 + 2 + cc[1];
-Line 1222 
 while (cc < ccend)
+Line 1424 
 while (cc < ccend)
      if (common->has_set_som && !setsom_found)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), 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_w);
+       stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-       stackpos += (int)sizeof(sljit_w);
+       stackpos += (int)sizeof(sljit_sw);
        setsom_found = TRUE;
        }
      if (common->mark_ptr != 0 && !setmark_found)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), 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_w);
+       stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-       stackpos += (int)sizeof(sljit_w);
+       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_LOCALS_REG), 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 1244 
 while (cc < ccend)
+Line 1455 
 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_LOCALS_REG), 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_w);
+     stackpos += (int)sizeof(sljit_sw);
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
-     stackpos += (int)sizeof(sljit_w);
+     stackpos += (int)sizeof(sljit_sw);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);
-     stackpos += (int)sizeof(sljit_w);
+     stackpos += (int)sizeof(sljit_sw);
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
-Line 1263 
 while (cc < ccend)
+Line 1483 
 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 1278 
 while (cc < ccend)
+Line 1498 
 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 1382 
 return private_data_length;
+Line 1608 
 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 1403 
 stacktop = STACK(stacktop - 1);
+Line 1629 
 stacktop = STACK(stacktop - 1);
  if (!save)
    {
-   stackptr += sizeof(sljit_w);
+   stackptr += (needs_control_head ? 2 : 1) * sizeof(sljit_sw);
    if (stackptr < stacktop)
      {
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
-     stackptr += sizeof(sljit_w);
+     stackptr += sizeof(sljit_sw);
      tmp1empty = FALSE;
      }
    if (stackptr < stacktop)
      {
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);
-     stackptr += sizeof(sljit_w);
+     stackptr += sizeof(sljit_sw);
      tmp2empty = FALSE;
      }
    /* 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 1440 
 while (status != end)
+Line 1672 
 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 1504 
 while (status != end)
+Line 1745 
 while (status != end)
          {
          count = 2;
          srcw[0] = PRIVATE_DATA(cc);
-         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_w);
+         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
          }
        cc += 2;
  #ifdef SUPPORT_UTF
-Line 1517 
 while (status != end)
+Line 1758 
 while (status != end)
          {
          count = 2;
          srcw[0] = PRIVATE_DATA(cc);
-         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_w);
+         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
          }
        cc += 2 + IMM2_SIZE;
  #ifdef SUPPORT_UTF
-Line 1539 
 while (status != end)
+Line 1780 
 while (status != end)
          {
          count = 2;
          srcw[0] = PRIVATE_DATA(cc);
-         srcw[1] = srcw[0] + sizeof(sljit_w);
+         srcw[1] = srcw[0] + sizeof(sljit_sw);
          }
        cc += 1;
        break;
-Line 1549 
 while (status != end)
+Line 1790 
 while (status != end)
          {
          count = 2;
          srcw[0] = PRIVATE_DATA(cc);
-         srcw[1] = srcw[0] + sizeof(sljit_w);
+         srcw[1] = srcw[0] + sizeof(sljit_sw);
          }
        cc += 1 + IMM2_SIZE;
        break;
-Line 1573 
 while (status != end)
+Line 1814 
 while (status != end)
            case 2:
            count = 2;
            srcw[0] = PRIVATE_DATA(cc);
-           srcw[1] = srcw[0] + sizeof(sljit_w);
+           srcw[1] = srcw[0] + sizeof(sljit_sw);
            break;
            default:
-Line 1605 
 while (status != end)
+Line 1846 
 while (status != end)
          if (!tmp1empty)
            {
            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
-           stackptr += sizeof(sljit_w);
+           stackptr += sizeof(sljit_sw);
            }
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);
          tmp1empty = FALSE;
-Line 1616 
 while (status != end)
+Line 1857 
 while (status != end)
          if (!tmp2empty)
            {
            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
-           stackptr += sizeof(sljit_w);
+           stackptr += sizeof(sljit_sw);
            }
          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);
          tmp2empty = FALSE;
-Line 1633 
 while (status != end)
+Line 1874 
 while (status != end)
          if (!tmp1empty)
            {
            OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
-           stackptr += sizeof(sljit_w);
+           stackptr += sizeof(sljit_sw);
            }
          tmp1next = FALSE;
          }
-Line 1645 
 while (status != end)
+Line 1886 
 while (status != end)
          if (!tmp2empty)
            {
            OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);
-           stackptr += sizeof(sljit_w);
+           stackptr += sizeof(sljit_sw);
            }
          tmp1next = TRUE;
          }
        }
      }
    }
+ while (status != end);
  if (save)
    {
-Line 1660 
 if (save)
+Line 1902 
 if (save)
      if (!tmp1empty)
        {
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
-       stackptr += sizeof(sljit_w);
+       stackptr += sizeof(sljit_sw);
        }
      if (!tmp2empty)
        {
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
-       stackptr += sizeof(sljit_w);
+       stackptr += sizeof(sljit_sw);
        }
      }
    else
-Line 1673 
 if (save)
+Line 1915 
 if (save)
      if (!tmp2empty)
        {
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
-       stackptr += sizeof(sljit_w);
+       stackptr += sizeof(sljit_sw);
        }
      if (!tmp1empty)
        {
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
-       stackptr += sizeof(sljit_w);
+       stackptr += sizeof(sljit_sw);
        }
      }
    }
  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 1692 
 SLJIT_ASSERT(cc == ccend && stackptr ==
+Line 1967 
 SLJIT_ASSERT(cc == ccend && stackptr ==
  #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
  #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
- static SLJIT_INLINE BOOL ispowerof2(unsigned int value)
+ static SLJIT_INLINE BOOL is_powerof2(unsigned int value)
  {
  return (value & (value - 1)) == 0;
  }
-Line 1703 
 while (list)
+Line 1978 
 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 1719 
 if (list_item)
+Line 1994 
 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 1743 
 stub_list* list_item = common->stubs;
+Line 2016 
 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 SLJIT_INLINE void count_match(compiler_common *common)
  {
  DEFINE_COMPILER;
- OP2(SLJIT_SUB | SLJIT_SET_E, CALL_COUNT, 0, CALL_COUNT, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB | SLJIT_SET_E, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);
  add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));
  }
-Line 1768 
 static SLJIT_INLINE void allocate_stack(
+Line 2036 
 static SLJIT_INLINE void allocate_stack(
  /* May destroy all locals and registers except TMP2. */
  DEFINE_COMPILER;
- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_w));
+ OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
  #ifdef DESTROY_REGISTERS
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);
  OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
-Line 1776 
 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
+Line 2044 
 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_LOCALS_REG), 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)
  {
  DEFINE_COMPILER;
- OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_w));
+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
  }
  static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)
-Line 1790 
 static SLJIT_INLINE void reset_ovector(c
+Line 2058 
 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_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
+ if (length < 8)
+   {
+   for (i = 1; i < length; i++)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_SCRATCH_REG1, 0);
+   }
+ else
+   {
+   GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, OVECTOR_START);
+   OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, length - 1);
+   loop = LABEL();
+   OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(sljit_sw), SLJIT_SCRATCH_REG1, 0);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 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_LOCALS_REG), 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_LOCALS_REG), OVECTOR(i), TMP1, 0);
    }
  else
    {
-   GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, OVECTOR_START - sizeof(sljit_w));
+   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_w), 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_LOCALS_REG), common->mark_ptr, SLJIT_IMM, 0);
+ if (common->control_head_ptr != 0)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr);
+ OP1(SLJIT_MOV, 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_MEM1(SLJIT_LOCALS_REG), OVECTOR(1), STR_PTR, 0);
- OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, ARGUMENTS, 0);
+ OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 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_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), 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_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), 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_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_SCRATCH_REG3, 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_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), 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_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, begin));
  GET_LOCAL_BASE(SLJIT_SAVED_REG1, 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_SCRATCH_REG2, 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_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_SCRATCH_REG1, 0);
- OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_w));
+ OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_sw));
  /* Copy the integer value to the output buffer */
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 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_SCRATCH_REG3), sizeof(int), SLJIT_SAVED_REG2, 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_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 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_w));
+   GET_LOCAL_BASE(SLJIT_SCRATCH_REG1, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));
-   OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, topbracket + 1);
+   OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, topbracket + 1);
    /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */
    loop = LABEL();
-   OP1(SLJIT_MOVU, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), -(2 * (sljit_w)sizeof(sljit_w)));
+   OP1(SLJIT_MOVU, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), -(2 * (sljit_sw)sizeof(sljit_sw)));
-   OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 1);
-   CMPTO(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG3, 0, loop);
+   CMPTO(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG3, 0, SLJIT_SAVED_REG3, 0, loop);
-   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_TEMPORARY_REG2, 0);
+   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_SCRATCH_REG2, 0);
    }
  else
    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
-Line 1862 
 else
+Line 2190 
 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_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_SCRATCH_REG2, 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_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 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_SCRATCH_REG3, 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_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 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_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 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);
+ jump = CMP(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 3);
+ OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + (int)sizeof(sljit_sw)), SLJIT_SAVED_REG1, 0);
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+ OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);
+ #endif
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 2 * sizeof(int), SLJIT_SCRATCH_REG3, 0);
+ JUMPHERE(jump);
+ OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 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_SCRATCH_REG2), sizeof(int), SLJIT_SAVED_REG2, 0);
- OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG1, 0);
+ OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_SAVED_REG1, 0);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 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_SCRATCH_REG2), 0, SLJIT_SCRATCH_REG3, 0);
  JUMPTO(SLJIT_JUMP, quit);
  }
-Line 1998 
 if (c <= 127 && bit == 0x20)
+Line 2337 
 if (c <= 127 && bit == 0x20)
    return (0 << 8) | 0x20;
  /* Since c != oc, they must have at least 1 bit difference. */
- if (!ispowerof2(bit))
+ if (!is_powerof2(bit))
    return 0;
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  #ifdef SUPPORT_UTF
  if (common->utf && c > 127)
-Line 2017 
 if (common->utf && c > 127)
+Line 2356 
 if (common->utf && c > 127)
  #endif /* SUPPORT_UTF */
  return (0 << 8) | bit;
- #else /* COMPILE_PCRE8 */
+ #elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- #ifdef COMPILE_PCRE16
  #ifdef SUPPORT_UTF
  if (common->utf && c > 65535)
    {
-Line 2030 
 if (common->utf && c > 65535)
+Line 2368 
 if (common->utf && c > 65535)
    }
  #endif /* SUPPORT_UTF */
  return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));
- #endif /* COMPILE_PCRE16 */
- #endif /* COMPILE_PCRE8 */
+ #endif /* COMPILE_PCRE[8|16|32] */
  }
  static void check_partial(compiler_common *common, BOOL force)
-Line 2052 
 else if (common->mode == JIT_PARTIAL_SOF
+Line 2389 
 else if (common->mode == JIT_PARTIAL_SOF
    jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), 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_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
  else
    {
    if (common->partialmatchlabel != NULL)
-Line 2065 
 if (jump != NULL)
+Line 2402 
 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_LOCALS_REG), 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_LOCALS_REG), 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_LOCALS_REG), 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 
 jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR
+Line 2448 
 jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR
  add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), 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_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
    }
  else
-Line 2130 
 static void read_char(compiler_common *c
+Line 2466 
 static void read_char(compiler_common *c
  /* Reads the character into TMP1, updates STR_PTR.
  Does not check STR_END. TMP2 Destroyed. */
  DEFINE_COMPILER;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  if (common->utf)
    {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
- #endif /* COMPILE_PCRE8 */
    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
    JUMPHERE(jump);
    }
- #endif
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  }
-Line 2157 
 static void peek_char(compiler_common *c
+Line 2491 
 static void peek_char(compiler_common *c
  /* Reads the character into TMP1, keeps STR_PTR.
  Does not check STR_END. TMP2 Destroyed. */
  DEFINE_COMPILER;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  if (common->utf)
    {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
- #endif /* COMPILE_PCRE8 */
    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
    JUMPHERE(jump);
    }
- #endif
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  }
  static void read_char8_type(compiler_common *common)
  {
  /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
  DEFINE_COMPILER;
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
-Line 2192 
 if (common->utf)
+Line 2524 
 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));
- #ifdef COMPILE_PCRE8
+ #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));
    JUMPHERE(jump);
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
    jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
-Line 2208 
 if (common->utf)
+Line 2539 
 if (common->utf)
    /* Skip low surrogate if necessary. */
    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);
-   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
- #endif
+ #elif defined COMPILE_PCRE32
- #endif /* COMPILE_PCRE8 */
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+   JUMPHERE(jump);
+ #endif /* COMPILE_PCRE[8|16|32] */
    return;
    }
- #endif
+ #endif /* SUPPORT_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));
- #ifdef COMPILE_PCRE16
+ #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);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  JUMPHERE(jump);
  #endif
  }
-Line 2233 
 static void skip_char_back(compiler_comm
+Line 2568 
 static void skip_char_back(compiler_comm
  {
  /* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */
  DEFINE_COMPILER;
- #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #if defined COMPILE_PCRE8
  struct sljit_label *label;
  if (common->utf)
-Line 2245 
 if (common->utf)
+Line 2581 
 if (common->utf)
    CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
    return;
    }
- #endif
+ #elif defined COMPILE_PCRE16
- #if defined SUPPORT_UTF && defined COMPILE_PCRE16
  if (common->utf)
    {
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
-Line 2254 
 if (common->utf)
+Line 2589 
 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;
    }
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  }
-Line 2276 
 if (nltype == NLTYPE_ANY)
+Line 2612 
 if (nltype == NLTYPE_ANY)
  else if (nltype == NLTYPE_ANYCRLF)
    {
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_CR);
-   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, CHAR_NL);
-   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);
    add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    }
  else
-Line 2290 
 else
+Line 2626 
 else
  #ifdef SUPPORT_UTF
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  static void do_utfreadchar(compiler_common *common)
  {
  /* Fast decoding a UTF-8 character. TMP1 contains the first byte
-Line 2378 
 sljit_emit_fast_return(compiler, RETURN_
+Line 2714 
 sljit_emit_fast_return(compiler, RETURN_
  JUMPHERE(jump);
  /* We only have types for characters less than 256. */
- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_w)PRIV(utf8_table4) - 0xc0);
+ 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);
  }
- #else /* COMPILE_PCRE8 */
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
  static void do_utfreadchar(compiler_common *common)
  {
  /* Fast decoding a UTF-16 character. TMP1 contains the first 16 bit char
-Line 2411 
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UC
+Line 2746 
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UC
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
- #endif /* COMPILE_PCRE16 */
- #endif /* COMPILE_PCRE8 */
+ #endif /* COMPILE_PCRE[8|16] */
  #endif /* SUPPORT_UTF */
-Line 2433 
 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && si
+Line 2767 
 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && si
  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_w)PRIV(ucd_stage1));
+ OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1));
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);
  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_stage2));
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2));
  OP1(SLJIT_MOV_UH, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 2453 
 struct sljit_label *newlinelabel = NULL;
+Line 2787 
 struct sljit_label *newlinelabel = NULL;
  struct sljit_jump *start;
  struct sljit_jump *end = NULL;
  struct sljit_jump *nl = NULL;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *singlechar;
  #endif
  jump_list *newline = NULL;
-Line 2508 
 if (newlinecheck)
+Line 2842 
 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);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
-   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   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);
-Line 2531 
 if (newlinecheck)
+Line 2865 
 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_PCRE8
+ #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_w)PRIV(utf8_table4) - 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);
    }
- #endif
+ #elif defined COMPILE_PCRE16
- #if defined SUPPORT_UTF && defined COMPILE_PCRE16
  if (common->utf)
    {
    singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   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
+ #endif /* COMPILE_PCRE[8|16] */
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  JUMPHERE(start);
  if (newlinecheck)
-Line 2563 
 if (newlinecheck)
+Line 2898 
 if (newlinecheck)
  return mainloop;
  }
- static SLJIT_INLINE BOOL fast_forward_first_two_chars(compiler_common *common, BOOL firstline)
+ #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;
- struct sljit_jump *found;
+ pcre_uint32 chars[MAX_N_CHARS * 2];
- pcre_int32 chars[4];
+ pcre_uchar *cc = common->start + 1 + LINK_SIZE;
- pcre_uchar *cc = common->start + 1 + IMM2_SIZE;
  int location = 0;
  pcre_int32 len, c, bit, caseless;
- BOOL must_end;
+ int must_stop;
- #ifdef COMPILE_PCRE8
- union {
-     sljit_uh ascombined;
-     sljit_ub asuchars[2];
- } pair;
- #else
- union {
-     sljit_ui ascombined;
-     sljit_uh asuchars[2];
- } pair;
- #endif
+ /* We do not support alternatives now. */
  if (*(common->start + GET(common->start, 1)) == OP_ALT)
    return FALSE;
  while (TRUE)
    {
    caseless = 0;
-   must_end = TRUE;
+   must_stop = 1;
    switch(*cc)
      {
      case OP_CHAR:
-     must_end = FALSE;
+     must_stop = 0;
      cc++;
      break;
      case OP_CHARI:
      caseless = 1;
-     must_end = FALSE;
+     must_stop = 0;
      cc++;
      break;
-Line 2645 
 while (TRUE)
+Line 2970 
 while (TRUE)
      break;
      default:
-     return FALSE;
+     must_stop = 2;
+     break;
      }
+   if (must_stop == 2)
+       break;
    len = 1;
  #ifdef SUPPORT_UTF
    if (common->utf && HAS_EXTRALEN(cc[0])) len += GET_EXTRALEN(cc[0]);
-Line 2670 
 while (TRUE)
+Line 2999 
 while (TRUE)
    else
      caseless = 0;
-   while (len > 0 && location < 2 * 2)
+   while (len > 0 && location < MAX_N_CHARS * 2)
      {
      c = *cc;
      bit = 0;
-Line 2688 
 while (TRUE)
+Line 3017 
 while (TRUE)
      cc++;
      }
-   if (location == 2 * 2)
+   if (location >= MAX_N_CHARS * 2 || must_stop != 0)
      break;
-   else if (must_end)
-     return FALSE;
    }
+ /* At least two characters are required. */
+ if (location < 2 * 2)
+     return FALSE;
  if (firstline)
    {
    SLJIT_ASSERT(common->first_line_end != 0);
    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
-   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
    }
  else
-   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
  start = LABEL();
  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
- #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
- #ifdef COMPILE_PCRE8
- OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #else /* COMPILE_PCRE8 */
- OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #endif
- #else /* SLJIT_UNALIGNED */
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
- #if defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN
- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
- #else /* SLJIT_BIG_ENDIAN */
  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #endif /* SLJIT_BIG_ENDIAN */
+ if (chars[1] != 0)
+   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
- #ifdef COMPILE_PCRE8
+ CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 8);
+ if (location > 2 * 2)
- #else /* COMPILE_PCRE8 */
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 16);
+ if (chars[3] != 0)
- #endif
+   OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[3]);
- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+ CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[2], start);
+ if (location > 2 * 2)
- #endif
+   {
+   if (chars[5] != 0)
- if (chars[1] != 0 || chars[3] != 0)
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[5]);
-   {
+   CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[4], start);
-   pair.asuchars[0] = chars[1];
-   pair.asuchars[1] = chars[3];
-   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, pair.ascombined);
    }
+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- pair.asuchars[0] = chars[0];
- pair.asuchars[1] = chars[2];
- found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, pair.ascombined);
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- JUMPTO(SLJIT_JUMP, start);
- JUMPHERE(found);
  JUMPHERE(quit);
  if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  else
-   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
  return TRUE;
  }
+ #undef MAX_N_CHARS
  static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)
  {
  DEFINE_COMPILER;
-Line 2787 
 if (first_char == oc)
+Line 3100 
 if (first_char == oc)
  else
    {
    bit = first_char ^ oc;
-   if (ispowerof2(bit))
+   if (is_powerof2(bit))
      {
      OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);
      found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, first_char | bit);
-Line 2795 
 else
+Line 3108 
 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 2839 
 if (common->nltype == NLTYPE_FIXED && co
+Line 3152 
 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);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
-   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
-Line 2882 
 if (common->nltype == NLTYPE_ANY || comm
+Line 3195 
 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);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
-   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    JUMPHERE(notfoundnl);
-Line 2897 
 if (firstline)
+Line 3210 
 if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
+ static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks);
  static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw 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;
+ pcre_uint8 inverted_start_bits[32];
+ int i;
  #ifndef COMPILE_PCRE8
  struct sljit_jump *jump;
  #endif
+ for (i = 0; i < 32; ++i)
+   inverted_start_bits[i] = ~(((pcre_uint8*)start_bits)[i]);
  if (firstline)
    {
    SLJIT_ASSERT(common->first_line_end != 0);
-Line 2921 
 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_P
+Line 3242 
 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, inverted_start_bits, (inverted_start_bits[31] & 0x80) != 0, &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), 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)
    OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
  #endif
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ #ifdef SUPPORT_UTF
+ #if defined COMPILE_PCRE8
  if (common->utf)
    {
    CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
+   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);
    }
- #endif
+ #elif defined COMPILE_PCRE16
- #if defined SUPPORT_UTF && defined COMPILE_PCRE16
  if (common->utf)
    {
    CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   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
+ #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 2974 
 struct sljit_jump *alreadyfound;
+Line 3303 
 struct sljit_jump *alreadyfound;
  struct sljit_jump *found;
  struct sljit_jump *foundoc = NULL;
  struct sljit_jump *notfound;
- pcre_uchar oc, bit;
+ 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);
-Line 3005 
 if (req_char == oc)
+Line 3334 
 if (req_char == oc)
  else
    {
    bit = req_char ^ oc;
-   if (ispowerof2(bit))
+   if (is_powerof2(bit))
      {
      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
      found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
-Line 3041 
 GET_LOCAL_BASE(TMP3, 0, 0);
+Line 3370 
 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_w));
+ OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
- OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_w), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_w));
+ OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));
- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_w));
+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_sw));
  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_w));
+ 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_w));
+ 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_w));
-   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
-   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_w));
  JUMPTO(SLJIT_JUMP, mainloop);
  }
-Line 3082 
 static void check_wordboundary(compiler_
+Line 3396 
 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
-Line 3107 
 if (common->use_ucp)
+Line 3422 
 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);
    }
-Line 3139 
 else
+Line 3454 
 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);
  /* Testing char type. This is a code duplication. */
-Line 3151 
 if (common->use_ucp)
+Line 3466 
 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 3180 
 else
+Line 3495 
 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);
-Line 3235 
 switch(ranges[0])
+Line 3550 
 switch(ranges[0])
        }
      return TRUE;
      }
-   if ((ranges[3] - ranges[2]) == (ranges[5] - ranges[4]) && ispowerof2(ranges[4] - ranges[2]))
+   if ((ranges[3] - ranges[2]) == (ranges[5] - ranges[4]) && is_powerof2(ranges[4] - ranges[2]))
      {
      if (readch)
        read_char(common);
-Line 3334 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 3649 
 sljit_emit_fast_enter(compiler, RETURN_A
  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
- COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  #ifdef COMPILE_PCRE8
  if (common->utf)
    {
  #endif
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
  #ifdef COMPILE_PCRE8
    }
  #endif
- #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
- 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);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 3360 
 DEFINE_COMPILER;
+Line 3675 
 DEFINE_COMPILER;
  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);
- 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, 0x20);
- COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+ OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  #ifdef COMPILE_PCRE8
  if (common->utf)
    {
  #endif
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);
  #ifdef COMPILE_PCRE8
    }
  #endif
- #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
- 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);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 3400 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 3715 
 sljit_emit_fast_enter(compiler, RETURN_A
  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
- COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  #ifdef COMPILE_PCRE8
  if (common->utf)
    {
  #endif
-   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);
    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
  #ifdef COMPILE_PCRE8
    }
  #endif
- #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
- 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);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 3500 
 sljit_emit_fast_return(compiler, RETURN_
+Line 3815 
 sljit_emit_fast_return(compiler, RETURN_
  #if defined SUPPORT_UTF && defined SUPPORT_UCP
- static const pcre_uchar *SLJIT_CALL do_utf_caselesscmp(pcre_uchar *src1, jit_arguments *args, pcre_uchar *end1)
+ static const pcre_uchar * SLJIT_CALL do_utf_caselesscmp(pcre_uchar *src1, jit_arguments *args, pcre_uchar *end1)
  {
  /* This function would be ineffective to do in JIT level. */
- int c1, c2;
+ pcre_uint32 c1, c2;
  const pcre_uchar *src2 = args->uchar_ptr;
  const pcre_uchar *end2 = args->end;
+ const ucd_record *ur;
+ const pcre_uint32 *pp;
  while (src1 < end1)
    {
-Line 3513 
 while (src1 < end1)
+Line 3830 
 while (src1 < end1)
      return (pcre_uchar*)1;
    GETCHARINC(c1, src1);
    GETCHARINC(c2, src2);
-   if (c1 != c2 && c1 != UCD_OTHERCASE(c2)) return NULL;
+   ur = GET_UCD(c2);
+   if (c1 != c2 && c1 != c2 + ur->other_case)
+     {
+     pp = PRIV(ucd_caseless_sets) + ur->caseset;
+     for (;;)
+       {
+       if (c1 < *pp) return NULL;
+       if (c1 == *pp++) break;
+       }
+     }
    }
  return src2;
  }
-Line 3535 
 if (caseless && char_has_othercase(commo
+Line 3861 
 if (caseless && char_has_othercase(commo
    othercasebit = char_get_othercase_bit(common, cc);
    SLJIT_ASSERT(othercasebit);
    /* Extracting bit difference info. */
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    othercasechar = cc + (othercasebit >> 8);
    othercasebit &= 0xff;
- #else
+ #elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- #ifdef COMPILE_PCRE16
+   /* Note that this code only handles characters in the BMP. If there
+   ever are characters outside the BMP whose othercase differs in only one
+   bit from itself (there currently are none), this code will need to be
+   revised for COMPILE_PCRE32. */
    othercasechar = cc + (othercasebit >> 9);
    if ((othercasebit & 0x100) != 0)
      othercasebit = (othercasebit & 0xff) << 8;
    else
      othercasebit &= 0xff;
- #endif
+ #endif /* COMPILE_PCRE[8|16|32] */
- #endif
    }
  if (context->sourcereg == -1)
    {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    if (context->length >= 4)
      OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
-Line 3560 
 if (context->sourcereg == -1)
+Line 3888 
 if (context->sourcereg == -1)
    else
  #endif
      OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    if (context->length >= 4)
      OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
    else
  #endif
-     OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #endif
+ #elif defined COMPILE_PCRE32
- #endif /* COMPILE_PCRE8 */
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #endif /* COMPILE_PCRE[8|16|32] */
    context->sourcereg = TMP2;
    }
-Line 3583 
 do
+Line 3911 
 do
  #endif
    context->length -= IN_UCHARS(1);
- #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
+ #if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED) && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)
    /* Unaligned read is supported. */
    if (othercasebit != 0 && othercasechar == cc)
-Line 3598 
 do
+Line 3926 
 do
      }
    context->ucharptr++;
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1))
  #else
    if (context->ucharptr >= 2 || context->length == 0)
-Line 3606 
 do
+Line 3934 
 do
      {
      if (context->length >= 4)
        OP1(SLJIT_MOV_SI, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #ifdef COMPILE_PCRE8
      else if (context->length >= 2)
        OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #if defined COMPILE_PCRE8
      else if (context->length >= 1)
        OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #else
+ #endif /* COMPILE_PCRE8 */
-     else if (context->length >= 2)
-       OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #endif
      context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
      switch(context->ucharptr)
-Line 3648 
 do
+Line 3973 
 do
  #else
-   /* Unaligned read is unsupported. */
+   /* Unaligned read is unsupported or in 32 bit mode. */
- #ifdef COMPILE_PCRE8
+   if (context->length >= 1)
-   if (context->length > 0)
+     OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
-     OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #else
-   if (context->length > 0)
-     OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #endif
    context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
    if (othercasebit != 0 && othercasechar == cc)
-Line 3705 
 static void compile_xclass_matchingpath(
+Line 4026 
 static void compile_xclass_matchingpath(
  DEFINE_COMPILER;
  jump_list *found = NULL;
  jump_list **list = (*cc & XCL_NOT) == 0 ? &found : backtracks;
- unsigned int c;
+ pcre_int32 c, charoffset;
- int compares;
+ const pcre_uint32 *other_cases;
  struct sljit_jump *jump = NULL;
  pcre_uchar *ccbegin;
+ int compares, invertcmp, numberofcmps;
  #ifdef SUPPORT_UCP
  BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
  BOOL charsaved = FALSE;
  int typereg = TMP1, scriptreg = TMP1;
- unsigned int typeoffset;
+ pcre_int32 typeoffset;
  #endif
- int invertcmp, numberofcmps;
- unsigned int charoffset;
  /* Although SUPPORT_UTF must be defined, we are
     not necessary in utf mode even in 8 bit mode. */
-Line 3737 
 if ((*cc++ & XCL_MAP) != 0)
+Line 4057 
 if ((*cc++ & XCL_MAP) != 0)
      {
      OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
      OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
+     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
      OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
      OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
      add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));
-Line 3814 
 while (*cc != XCL_END)
+Line 4134 
 while (*cc != XCL_END)
        needschar = TRUE;
        break;
+       case PT_CLIST:
+       case PT_UCNC:
+       needschar = TRUE;
+       break;
        default:
        SLJIT_ASSERT_STOP();
        break;
-Line 3850 
 if (needstype || needsscript)
+Line 4175 
 if (needstype || needsscript)
      {
      if (scriptreg == TMP1)
        {
-       OP1(SLJIT_MOV, scriptreg, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
+       OP1(SLJIT_MOV, scriptreg, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
        OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM2(scriptreg, TMP2), 3);
        }
      else
        {
        OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
-       OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
+       OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
        OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM1(TMP2), 0);
        }
      }
-Line 3892 
 while (*cc != XCL_END)
+Line 4217 
 while (*cc != XCL_END)
      if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
        {
        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);
-       COND_VALUE(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+       OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_EQUAL);
        numberofcmps++;
        }
      else if (numberofcmps > 0)
        {
        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);
-       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);
        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
        numberofcmps = 0;
        }
-Line 3931 
 while (*cc != XCL_END)
+Line 4256 
 while (*cc != XCL_END)
      if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
        {
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);
-       COND_VALUE(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_LESS_EQUAL);
        numberofcmps++;
        }
      else if (numberofcmps > 0)
        {
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);
-       COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
        numberofcmps = 0;
        }
-Line 3968 
 while (*cc != XCL_END)
+Line 4293 
 while (*cc != XCL_END)
        case PT_LAMP:
        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - typeoffset);
-       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, typereg, 0, SLJIT_IMM, ucp_Ll - typeoffset);
-       COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
+       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lt - typeoffset);
-       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);
        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
        break;
-Line 3999 
 while (*cc != XCL_END)
+Line 4324 
 while (*cc != XCL_END)
          }
        SET_CHAR_OFFSET(9);
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 13 - 9);
-       COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
        if (*cc == PT_SPACE)
          JUMPHERE(jump);
        SET_TYPE_OFFSET(ucp_Zl);
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);
-       COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
        break;
        case PT_WORD:
        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE - charoffset);
-       COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
-       /* ... fall through */
+       /* Fall through. */
        case PT_ALNUM:
        SET_TYPE_OFFSET(ucp_Ll);
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
-       COND_VALUE((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       OP_FLAGS((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, (*cc == PT_ALNUM) ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_LESS_EQUAL);
        SET_TYPE_OFFSET(ucp_Nd);
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_No - ucp_Nd);
-       COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
+       break;
+       case PT_CLIST:
+       other_cases = PRIV(ucd_caseless_sets) + cc[1];
+       /* At least three characters are required.
+          Otherwise this case would be handled by the normal code path. */
+       SLJIT_ASSERT(other_cases[0] != NOTACHAR && other_cases[1] != NOTACHAR && other_cases[2] != NOTACHAR);
+       SLJIT_ASSERT(other_cases[0] < other_cases[1] && other_cases[1] < other_cases[2]);
+       /* Optimizing character pairs, if their difference is power of 2. */
+       if (is_powerof2(other_cases[1] ^ other_cases[0]))
+         {
+         if (charoffset == 0)
+           OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+         else
+           {
+           OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);
+           OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+           }
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[1]);
+         OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+         other_cases += 2;
+         }
+       else if (is_powerof2(other_cases[2] ^ other_cases[1]))
+         {
+         if (charoffset == 0)
+           OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[2] ^ other_cases[1]);
+         else
+           {
+           OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);
+           OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+           }
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]);
+         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, other_cases[0] - charoffset);
+         OP_FLAGS(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+         other_cases += 3;
+         }
+       else
+         {
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, *other_cases++ - charoffset);
+         OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+         }
+       while (*other_cases != NOTACHAR)
+         {
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, *other_cases++ - charoffset);
+         OP_FLAGS(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+         }
+       jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
+       break;
+       case PT_UCNC:
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_DOLLAR_SIGN - charoffset);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_COMMERCIAL_AT - charoffset);
+       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_GRAVE_ACCENT - charoffset);
+       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
+       SET_CHAR_OFFSET(0xa0);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd7ff - charoffset);
+       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
+       SET_CHAR_OFFSET(0);
+       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_GREATER_EQUAL);
        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
        break;
        }
-Line 4048 
 int length;
+Line 4443 
 int length;
  unsigned int c, oc, bit;
  compare_context context;
  struct sljit_jump *jump[4];
+ jump_list *end_list;
  #ifdef SUPPORT_UTF
  struct sljit_label *label;
  #ifdef SUPPORT_UCP
-Line 4116 
 switch(type)
+Line 4512 
 switch(type)
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
+     end_list = NULL;
      if (common->mode != JIT_PARTIAL_HARD_COMPILE)
-       jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+       add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
      else
-       jump[1] = check_str_end(common);
+       check_str_end(common, &end_list);
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
-     if (jump[1] != NULL)
+     set_jumps(end_list, LABEL());
-       JUMPHERE(jump[1]);
      JUMPHERE(jump[0]);
      }
    else
-Line 4138 
 switch(type)
+Line 4534 
 switch(type)
      {
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
+ #if defined COMPILE_PCRE8
      jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
+     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);
- #else /* COMPILE_PCRE8 */
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
      jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
      OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
-     COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+     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_PCRE16 */
+ #endif
- #endif /* COMPILE_PCRE8 */
      JUMPHERE(jump[0]);
+ #endif /* COMPILE_PCRE[8|16] */
      return cc;
      }
  #endif
-Line 4183 
 switch(type)
+Line 4579 
 switch(type)
    read_char(common);
    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
    /* We don't need to handle soft partial matching case. */
+   end_list = NULL;
    if (common->mode != JIT_PARTIAL_HARD_COMPILE)
-     jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+     add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
    else
-     jump[1] = check_str_end(common);
+     check_str_end(common, &end_list);
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
-   jump[2] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
+   jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-   jump[3] = JUMP(SLJIT_JUMP);
+   jump[2] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[0]);
    check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);
+   set_jumps(end_list, LABEL());
    JUMPHERE(jump[1]);
    JUMPHERE(jump[2]);
-   JUMPHERE(jump[3]);
    return cc;
    case OP_NOT_HSPACE:
-Line 4219 
 switch(type)
+Line 4616 
 switch(type)
    detect_partial_match(common, backtracks);
    read_char(common);
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
    /* Optimize register allocation: use a real register. */
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
    OP1(SLJIT_MOV_UB, STACK_TOP, 0, SLJIT_MEM2(TMP1, TMP2), 3);
-Line 4229 
 switch(type)
+Line 4626 
 switch(type)
    OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
    read_char(common);
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM2(TMP1, TMP2), 3);
    OP2(SLJIT_SHL, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 2);
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (sljit_w)PRIV(ucp_gbtable));
+   OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(STACK_TOP), (sljit_sw)PRIV(ucp_gbtable));
    OP1(SLJIT_MOV, STACK_TOP, 0, 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);
-Line 4266 
 switch(type)
+Line 4663 
 switch(type)
        {
        jump[1] = CMP(SLJIT_C_EQUAL, TMP2, 0, STR_END, 0);
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
-       COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS);
        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
-       COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_NOT_EQUAL);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_NOT_EQUAL);
        add_jump(compiler, backtracks, JUMP(SLJIT_C_NOT_EQUAL));
        check_partial(common, TRUE);
        add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
-Line 4448 
 switch(type)
+Line 4845 
 switch(type)
      }
    oc = char_othercase(common, c);
    bit = c ^ oc;
-   if (ispowerof2(bit))
+   if (is_powerof2(bit))
      {
      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
      add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
      return cc + length;
      }
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);
-   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);
    add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
    return cc + length;
-Line 4484 
 switch(type)
+Line 4881 
 switch(type)
        /* Skip the variable-length character. */
        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
        jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-       OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
+       OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
        JUMPHERE(jump[0]);
        return cc + 1;
-Line 4509 
 switch(type)
+Line 4906 
 switch(type)
      {
      oc = char_othercase(common, c);
      bit = c ^ oc;
-     if (ispowerof2(bit))
+     if (is_powerof2(bit))
        {
        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
        add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
-Line 4547 
 switch(type)
+Line 4944 
 switch(type)
  #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
    add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
-Line 4557 
 switch(type)
+Line 4954 
 switch(type)
  #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
    return cc + 32 / sizeof(pcre_uchar);
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    case OP_XCLASS:
    compile_xclass_matchingpath(common, cc + LINK_SIZE, backtracks);
    return cc + GET(cc, 0) - 1;
-Line 4671 
 if (!common->jscript_compat)
+Line 5068 
 if (!common->jscript_compat)
      {
      /* OVECTOR(1) contains the "string begin - 1" constant. */
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
-     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_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
-     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);
      return JUMP(SLJIT_C_NOT_ZERO);
      }
    add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
-Line 4729 
 if (withchecks && !common->jscript_compa
+Line 5126 
 if (withchecks && !common->jscript_compa
  #if defined SUPPORT_UTF && defined SUPPORT_UCP
  if (common->utf && *cc == OP_REFI)
    {
-   SLJIT_ASSERT(TMP1 == SLJIT_TEMPORARY_REG1 && STACK_TOP == SLJIT_TEMPORARY_REG2 && TMP2 == SLJIT_TEMPORARY_REG3);
+   SLJIT_ASSERT(TMP1 == SLJIT_SCRATCH_REG1 && STACK_TOP == SLJIT_SCRATCH_REG2 && TMP2 == SLJIT_SCRATCH_REG3);
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
    if (withchecks)
      jump = CMP(SLJIT_C_EQUAL, TMP1, 0, TMP2, 0);
    /* Needed to save important temporary registers. */
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
-   OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);
+   OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, uchar_ptr), STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, uchar_ptr), STR_PTR, 0);
    sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));
    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
    if (common->mode == JIT_COMPILE)
-Line 4850 
 if (!minimize)
+Line 5247 
 if (!minimize)
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
      /* Temporary release of STR_PTR. */
-     OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
+     OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
      zerolength = compile_ref_checks(common, ccbegin, NULL);
      /* Restore if not zero length. */
-     OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
+     OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
      }
    else
      {
-Line 4896 
 if (!minimize)
+Line 5293 
 if (!minimize)
    JUMPHERE(zerolength);
    BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
-   decrease_call_count(common);
+   count_match(common);
    return cc;
    }
-Line 4935 
 if (jump != NULL)
+Line 5332 
 if (jump != NULL)
    JUMPHERE(jump);
  JUMPHERE(zerolength);
- decrease_call_count(common);
+ count_match(common);
  return cc;
  }
-Line 4945 
 DEFINE_COMPILER;
+Line 5342 
 DEFINE_COMPILER;
  backtrack_common *backtrack;
  recurse_entry *entry = common->entries;
  recurse_entry *prev = NULL;
- int start = GET(cc, 1);
+ sljit_sw start = GET(cc, 1);
+ pcre_uchar *start_cc;
+ BOOL needs_control_head;
  PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
+ /* Inlining simple patterns. */
+ if (get_framesize(common, common->start + start, NULL, TRUE, &needs_control_head) == no_stack)
+   {
+   start_cc = common->start + start;
+   compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);
+   BACKTRACK_AS(recurse_backtrack)->inlined_pattern = TRUE;
+   return cc + 1 + LINK_SIZE;
+   }
  while (entry != NULL)
    {
    if (entry->start == start)
-Line 4996 
 add_jump(compiler, &backtrack->topbacktr
+Line 5405 
 add_jump(compiler, &backtrack->topbacktr
  return cc + 1 + LINK_SIZE;
  }
+ static int SLJIT_CALL do_callout(struct jit_arguments* arguments, PUBL(callout_block) *callout_block, pcre_uchar **jit_ovector)
+ {
+ const pcre_uchar *begin = arguments->begin;
+ int *offset_vector = arguments->offsets;
+ int offset_count = arguments->offset_count;
+ int i;
+ if (PUBL(callout) == NULL)
+   return 0;
+ callout_block->version = 2;
+ callout_block->callout_data = arguments->callout_data;
+ /* Offsets in subject. */
+ callout_block->subject_length = arguments->end - arguments->begin;
+ callout_block->start_match = (pcre_uchar*)callout_block->subject - arguments->begin;
+ callout_block->current_position = (pcre_uchar*)callout_block->offset_vector - arguments->begin;
+ #if defined COMPILE_PCRE8
+ callout_block->subject = (PCRE_SPTR)begin;
+ #elif defined COMPILE_PCRE16
+ callout_block->subject = (PCRE_SPTR16)begin;
+ #elif defined COMPILE_PCRE32
+ callout_block->subject = (PCRE_SPTR32)begin;
+ #endif
+ /* Convert and copy the JIT offset vector to the offset_vector array. */
+ callout_block->capture_top = 0;
+ callout_block->offset_vector = offset_vector;
+ for (i = 2; i < offset_count; i += 2)
+   {
+   offset_vector[i] = jit_ovector[i] - begin;
+   offset_vector[i + 1] = jit_ovector[i + 1] - begin;
+   if (jit_ovector[i] >= begin)
+     callout_block->capture_top = i;
+   }
+ callout_block->capture_top = (callout_block->capture_top >> 1) + 1;
+ if (offset_count > 0)
+   offset_vector[0] = -1;
+ if (offset_count > 1)
+   offset_vector[1] = -1;
+ return (*PUBL(callout))(callout_block);
+ }
+ /* Aligning to 8 byte. */
+ #define CALLOUT_ARG_SIZE \
+     (((int)sizeof(PUBL(callout_block)) + 7) & ~7)
+ #define CALLOUT_ARG_OFFSET(arg) \
+     (-CALLOUT_ARG_SIZE + SLJIT_OFFSETOF(PUBL(callout_block), arg))
+ static SLJIT_INLINE pcre_uchar *compile_callout_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+ {
+ DEFINE_COMPILER;
+ backtrack_common *backtrack;
+ PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
+ allocate_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+ SLJIT_ASSERT(common->capture_last_ptr != 0);
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(capture_last), TMP2, 0);
+ /* These pointer sized fields temporarly stores internal variables. */
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(offset_vector), STR_PTR, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(subject), TMP2, 0);
+ if (common->mark_ptr != 0)
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr));
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 2));
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(next_item_length), SLJIT_IMM, GET(cc, 2 + LINK_SIZE));
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(mark), (common->mark_ptr != 0) ? TMP2 : SLJIT_IMM, 0);
+ /* Needed to save important temporary registers. */
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
+ OP2(SLJIT_SUB, SLJIT_SCRATCH_REG2, 0, STACK_TOP, 0, SLJIT_IMM, CALLOUT_ARG_SIZE);
+ GET_LOCAL_BASE(SLJIT_SCRATCH_REG3, 0, OVECTOR_START);
+ sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_callout));
+ OP1(SLJIT_MOV_SI, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0);
+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
+ free_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));
+ /* Check return value. */
+ OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
+ add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_C_SIG_GREATER));
+ if (common->forced_quit_label == NULL)
+   add_jump(compiler, &common->forced_quit, JUMP(SLJIT_C_SIG_LESS));
+ else
+   JUMPTO(SLJIT_C_SIG_LESS, common->forced_quit_label);
+ return cc + 2 + 2 * LINK_SIZE;
+ }
+ #undef CALLOUT_ARG_SIZE
+ #undef CALLOUT_ARG_OFFSET
  static pcre_uchar *compile_assert_matchingpath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)
  {
  DEFINE_COMPILER;
  int framesize;
+ int extrasize;
+ BOOL needs_control_head;
  int private_data_ptr;
  backtrack_common altbacktrack;
  pcre_uchar *ccbegin;
-Line 5009 
 jump_list *tmp = NULL;
+Line 5519 
 jump_list *tmp = NULL;
  jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
  jump_list **found;
  /* Saving previous accept variables. */
- struct sljit_label *save_quitlabel = common->quitlabel;
+ BOOL save_local_exit = common->local_exit;
- struct sljit_label *save_acceptlabel = common->acceptlabel;
+ BOOL save_positive_assert = common->positive_assert;
+ then_trap_backtrack *save_then_trap = common->then_trap;
+ struct sljit_label *save_quit_label = common->quit_label;
+ struct sljit_label *save_accept_label = common->accept_label;
  jump_list *save_quit = common->quit;
+ jump_list *save_positive_assert_quit = common->positive_assert_quit;
  jump_list *save_accept = common->accept;
  struct sljit_jump *jump;
  struct sljit_jump *brajump = NULL;
+ /* Assert captures then. */
+ common->then_trap = NULL;
  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
    {
    SLJIT_ASSERT(!conditional);
-Line 5024 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 5541 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
    }
  private_data_ptr = PRIVATE_DATA(cc);
  SLJIT_ASSERT(private_data_ptr != 0);
- framesize = get_framesize(common, cc, FALSE);
+ framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
  backtrack->framesize = framesize;
  backtrack->private_data_ptr = private_data_ptr;
  opcode = *cc;
-Line 5043 
 if (bra == OP_BRAMINZERO)
+Line 5560 
 if (bra == OP_BRAMINZERO)
  if (framesize < 0)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
+   extrasize = needs_control_head ? 2 : 1;
-   allocate_stack(common, 1);
+   if (framesize == no_frame)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
+   allocate_stack(common, extrasize);
+   if (needs_control_head)
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+   if (needs_control_head)
+     {
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+     }
    }
  else
    {
-   allocate_stack(common, framesize + 2);
+   extrasize = needs_control_head ? 3 : 2;
+   allocate_stack(common, framesize + extrasize);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-   OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(framesize + 1));
+   OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
+   if (needs_control_head)
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+   if (needs_control_head)
-   init_frame(common, ccbegin, framesize + 1, 2, FALSE);
+     {
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
+     }
+   else
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+   init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);
    }
  memset(&altbacktrack, 0, sizeof(backtrack_common));
- common->quitlabel = NULL;
+ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
- common->quit = NULL;
+   {
+   /* Negative assert is stronger than positive assert. */
+   common->local_exit = TRUE;
+   common->quit_label = NULL;
+   common->quit = NULL;
+   common->positive_assert = FALSE;
+   }
+ else
+   common->positive_assert = TRUE;
+ common->positive_assert_quit = NULL;
  while (1)
    {
-   common->acceptlabel = NULL;
+   common->accept_label = NULL;
    common->accept = NULL;
    altbacktrack.top = NULL;
    altbacktrack.topbacktracks = NULL;
-Line 5075 
 while (1)
+Line 5621 
 while (1)
    compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
-     common->quitlabel = save_quitlabel;
+     if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
-     common->acceptlabel = save_acceptlabel;
+       {
-     common->quit = save_quit;
+       common->local_exit = save_local_exit;
+       common->quit_label = save_quit_label;
+       common->quit = save_quit;
+       }
+     common->positive_assert = save_positive_assert;
+     common->then_trap = save_then_trap;
+     common->accept_label = save_accept_label;
+     common->positive_assert_quit = save_positive_assert_quit;
      common->accept = save_accept;
      return NULL;
      }
-   common->acceptlabel = LABEL();
+   common->accept_label = LABEL();
    if (common->accept != NULL)
-     set_jumps(common->accept, common->acceptlabel);
+     set_jumps(common->accept, common->accept_label);
    /* Reset stack. */
    if (framesize < 0)
-     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+     {
-   else {
+     if (framesize == no_frame)
+       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+     else
+       free_stack(common, extrasize);
+     if (needs_control_head)
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);
+     }
+   else
+     {
      if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)
        {
        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
-       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
+       if (needs_control_head)
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);
        }
      else
        {