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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 991 by zherczeg,
Sun Jul  8 16:44:39 2012 UTC
+revision 1306 by zherczeg,
Mon Apr  1 17:04:17 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
- /* Allocate memory on the stack. Fast, but limited size. */
+ /* Defines for debugging purposes. */
- #define LOCAL_SPACE_SIZE 32768
+ /* 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
+ /* Growth rate for stack allocated by the OS. Should be the multiply
+ of page size. */
  #define STACK_GROWTH_RATE 8192
  /* Enable to check that the allocation could destroy temporaries. */
-Line 89 
 vertical (sub-expression) (See struct ba
+Line 101 
 vertical (sub-expression) (See struct ba
  The condition checkers are boolean (true/false) checkers. Machine code is generated
  for the checker itself and for the actions depending on the result of the checker.
- The 'true' case is called as the try path (expected path), and the other is called as
+ The 'true' case is called as the matching path (expected path), and the other is called as
  the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken
- branches on the try path.
+ branches on the matching path.
   Greedy star operator (*) :
-    Try path: match happens.
+    Matching path: match happens.
     Backtrack path: match failed.
   Non-greedy star operator (*?) :
-    Try path: no need to perform a match.
+    Matching path: no need to perform a match.
     Backtrack path: match is required.
  The following example shows how the code generated for a capturing bracket
-Line 108 
 we have the following regular expression
+Line 120 
 we have the following regular expression
  The generated code will be the following:
-  A try path
+  A matching path
-  '(' try path (pushing arguments to the stack)
+  '(' matching path (pushing arguments to the stack)
-  B try path
+  B matching path
-  ')' try path (pushing arguments to the stack)
+  ')' matching path (pushing arguments to the stack)
-  D try path
+  D matching path
   return with successful match
   D backtrack path
   ')' backtrack path (If we arrived from "C" jump to the backtrack of "C")
   B backtrack path
   C expected path
-  jump to D try path
+  jump to D matching path
   C backtrack path
   A backtrack path
-Line 127 
 The generated code will be the following
+Line 139 
 The generated code will be the following
   code paths. In this way the topmost value on the stack is always belong
   to the current backtrack code path. The backtrack path must check
   whether there is a next alternative. If so, it needs to jump back to
-  the try path eventually. Otherwise it needs to clear out its own stack
+  the matching path eventually. Otherwise it needs to clear out its own stack
   frame and continue the execution on the backtrack code paths.
  */
  /*
  Saved stack frames:
- Atomic blocks and asserts require reloading the values of local variables
+ Atomic blocks and asserts require reloading the values of private data
- when the backtrack mechanism performed. Because of OP_RECURSE, the locals
+ when the backtrack mechanism performed. Because of OP_RECURSE, the data
  are not necessarly known in compile time, thus we need a dynamic restore
  mechanism.
  The stack frames are stored in a chain list, and have the following format:
  ([ capturing bracket offset ][ start value ][ end value ])+ ... [ 0 ] [ previous head ]
- Thus we can restore the locals to a particular point in the stack.
+ Thus we can restore the private data to a particular point in the stack.
  */
  typedef struct jit_arguments {
-Line 154 
 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;
+   int real_offset_count;
-   int calllimit;
+   int offset_count;
+   int call_limit;
    pcre_uint8 notbol;
    pcre_uint8 noteol;
    pcre_uint8 notempty;
-Line 167 
 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;
    sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
  } executable_functions;
-Line 175 
 typedef struct jump_list {
+Line 190 
 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
- code generator. It is allocated by compile_trypath, and contains
+ code generator. It is allocated by compile_matchingpath, and contains
- the aguments for compile_backtrackpath. Must be the first member
+ the aguments for compile_backtrackingpath. Must be the first member
  of its descendants. */
  typedef struct backtrack_common {
    /* Concatenation stack. */
-Line 205 
 typedef struct backtrack_common {
+Line 226 
 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 localptr;
+   int private_data_ptr;
    /* For iterators. */
-   struct sljit_label *trypath;
+   struct sljit_label *matchingpath;
  } assert_backtrack;
  typedef struct bracket_backtrack {
    backtrack_common common;
    /* Where to coninue if an alternative is successfully matched. */
-   struct sljit_label *alttrypath;
+   struct sljit_label *alternative_matchingpath;
    /* For rmin and rmax iterators. */
-   struct sljit_label *recursivetrypath;
+   struct sljit_label *recursive_matchingpath;
    /* For greedy ? operator. */
-   struct sljit_label *zerotrypath;
+   struct sljit_label *zero_matchingpath;
    /* Contains the branches of a failed condition. */
    union {
      /* 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. */
-   int localptr;
+   int private_data_ptr;
  } bracket_backtrack;
  typedef struct bracketpos_backtrack {
    backtrack_common common;
    /* Points to our private memory word on the stack. */
-   int localptr;
+   int private_data_ptr;
    /* Reverting stack is needed. */
    int framesize;
    /* Allocated stack size. */
-Line 245 
 typedef struct bracketpos_backtrack {
+Line 266 
 typedef struct bracketpos_backtrack {
  typedef struct braminzero_backtrack {
    backtrack_common common;
-   struct sljit_label *trypath;
+   struct sljit_label *matchingpath;
  } braminzero_backtrack;
  typedef struct iterator_backtrack {
    backtrack_common common;
    /* Next iteration. */
-   struct sljit_label *trypath;
+   struct sljit_label *matchingpath;
  } iterator_backtrack;
  typedef struct recurse_entry {
-Line 261 
 typedef struct recurse_entry {
+Line 282 
 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. */
-   /* Opcode local area direct map. */
+   sljit_si *private_data_ptrs;
-   int *localptrs;
+   /* Tells whether the capturing bracket is optimized. */
-   int cbraptr;
+   pcre_uint8 *optimized_cbracket;
-   /* OVector starting point. Must be divisible by 2. */
+   /* 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 cbra_ptr;
+   /* 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 291 
 typedef struct compiler_common {
+Line 336 
 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 331 
 typedef struct compiler_common {
+Line 396 
 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 355 
 typedef struct compare_context {
+Line 423 
 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 RETURN_ADDR   SLJIT_TEMPORARY_EREG1
- /* Locals layout. */
+ /* 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 CALL_LIMIT       (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 PRIV_DATA(cc)    (common->localptrs[(cc) - common->start])
+ #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 449 
 the start pointers when the end of the c
+Line 512 
 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 469 
 return cc;
+Line 534 
 return cc;
  /* Functions whose might need modification for all new supported opcodes:
   next_opcode
-  get_localspace
+  check_opcode_types
-  set_localptrs
+  set_private_data_ptrs
   get_framesize
   init_frame
-  get_localsize
+  get_private_data_copy_length
-  copy_locals
+  copy_private_data
-  compile_trypath
+  compile_matchingpath
-  compile_backtrackpath
+  compile_backtrackingpath
  */
  static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
-Line 497 
 switch(*cc)
+Line 562 
 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 509 
 switch(*cc)
+Line 576 
 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 551 
 switch(*cc)
+Line 641 
 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_LOCAL1 \
+ 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_LOCAL2A \
-     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_LOCAL2B \
-     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_LOCAL1 \
-     case OP_TYPEMINSTAR: \
-     case OP_TYPEMINPLUS: \
-     case OP_TYPEQUERY: \
-     case OP_TYPEMINQUERY:
- #define CASE_ITERATOR_TYPE_LOCAL2A \
-     case OP_TYPESTAR: \
-     case OP_TYPEPLUS:
- #define CASE_ITERATOR_TYPE_LOCAL2B \
-     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_localspace(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
  {
- int localspace = 0;
+ pcre_uchar *name;
- pcre_uchar *alternative;
+ pcre_uchar *name2;
- pcre_uchar *end = NULL;
+ int i, cbra_index;
- int space, size, bracketlen;
  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
    {
-   space = 0;
-   size = 0;
-   bracketlen = 0;
    switch(*cc)
      {
      case OP_SET_SOM:
-Line 772 
 while (cc < ccend)
+Line 749 
 while (cc < ccend)
      cc += 1;
      break;
-     case OP_ASSERT:
+     case OP_REF:
-     case OP_ASSERT_NOT:
+     case OP_REFI:
-     case OP_ASSERTBACK:
+     common->optimized_cbracket[GET2(cc, 1)] = 0;
-     case OP_ASSERTBACK_NOT:
+     cc += 1 + IMM2_SIZE;
-     case OP_ONCE:
-     case OP_ONCE_NC:
-     case OP_BRAPOS:
-     case OP_SBRA:
-     case OP_SBRAPOS:
-     case OP_SCOND:
-     localspace += sizeof(sljit_w);
-     bracketlen = 1 + LINK_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     localspace += 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:
-     /* Might be a hidden SCOND. */
+     case OP_SCOND:
-     alternative = cc + GET(cc, 1);
+     /* Only AUTO_CALLOUT can insert this opcode. We do
-     if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
+        not intend to support this case. */
-       localspace += sizeof(sljit_w);
+     if (cc[1 + LINK_SIZE] == OP_CALLOUT)
-     bracketlen = 1 + LINK_SIZE;
+       return FALSE;
-     break;
+     cc += 1 + LINK_SIZE;
-     case OP_BRA:
-     bracketlen = 1 + LINK_SIZE;
-     break;
-     case OP_CBRA:
-     case OP_SCBRA:
-     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
-     break;
-     CASE_ITERATOR_LOCAL1
-     space = 1;
-     size = -2;
-     break;
-     CASE_ITERATOR_LOCAL2A
-     space = 2;
-     size = -2;
-     break;
-     CASE_ITERATOR_LOCAL2B
-     space = 2;
-     size = -(2 + IMM2_SIZE);
-     break;
-     CASE_ITERATOR_TYPE_LOCAL1
-     space = 1;
-     size = 1;
-     break;
-     CASE_ITERATOR_TYPE_LOCAL2A
-     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
-       space = 2;
-     size = 1;
-     break;
-     CASE_ITERATOR_TYPE_LOCAL2B
-     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
-       space = 2;
-     size = 1 + IMM2_SIZE;
      break;
-     case OP_CLASS:
+     case OP_CREF:
-     case OP_NCLASS:
+     i = GET2(cc, 1);
-     size += 1 + 32 / sizeof(pcre_uchar);
+     common->optimized_cbracket[i] = 0;
-     space = get_class_iterator_size(cc + size);
+     cc += 1 + IMM2_SIZE;
      break;
- #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_NCREF:
-     case OP_XCLASS:
+     cbra_index = GET2(cc, 1);
-     size = GET(cc, 1);
+     name = (pcre_uchar *)common->name_table;
-     space = get_class_iterator_size(cc + size);
+     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;
- #endif
      case OP_RECURSE:
      /* Set its value only once. */
-     if (common->recursive_head == 0)
+     if (common->recursive_head_ptr == 0)
        {
-       common->recursive_head = common->ovector_start;
+       common->recursive_head_ptr = common->ovector_start;
-       common->ovector_start += sizeof(sljit_w);
+       common->ovector_start += sizeof(sljit_sw);
        }
      cc += 1 + LINK_SIZE;
      break;
+     case OP_CALLOUT:
+     if (common->capture_last_ptr == 0)
+       {
+       common->capture_last_ptr = common->ovector_start;
+       common->ovector_start += sizeof(sljit_sw);
+       }
+     cc += 2 + 2 * LINK_SIZE;
+     break;
+     case OP_THEN_ARG:
+     common->has_then = TRUE;
+     common->control_head_ptr = 1;
+     /* Fall through. */
+     case OP_PRUNE_ARG:
+     common->needs_start_ptr = TRUE;
+     /* Fall through. */
      case OP_MARK:
      if (common->mark_ptr == 0)
        {
        common->mark_ptr = common->ovector_start;
-       common->ovector_start += sizeof(sljit_w);
+       common->ovector_start += sizeof(sljit_sw);
        }
      cc += 1 + 2 + cc[1];
      break;
+     case OP_THEN:
+     common->has_then = TRUE;
+     common->control_head_ptr = 1;
+     /* Fall through. */
+     case OP_PRUNE:
+     case OP_SKIP:
+     common->needs_start_ptr = TRUE;
+     cc += 1;
+     break;
+     case OP_SKIP_ARG:
+     common->control_head_ptr = 1;
+     common->has_skip_arg = TRUE;
+     cc += 1 + 2 + cc[1];
+     break;
      default:
      cc = next_opcode(common, cc);
      if (cc == NULL)
-       return -1;
+       return FALSE;
      break;
      }
+   }
+ return TRUE;
+ }
-   if (space > 0 && cc >= end)
+ static int get_class_iterator_size(pcre_uchar *cc)
-     localspace += sizeof(sljit_w) * space;
+ {
+ switch(*cc)
+   {
+   case OP_CRSTAR:
+   case OP_CRPLUS:
+   return 2;
-   if (size != 0)
+   case OP_CRMINSTAR:
+   case OP_CRMINPLUS:
+   case OP_CRQUERY:
+   case OP_CRMINQUERY:
+   return 1;
+   case OP_CRRANGE:
+   case OP_CRMINRANGE:
+   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
+     return 0;
+   return 2;
+   default:
+   return 0;
+   }
+ }
+ static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
+ {
+ pcre_uchar *end = bracketend(begin);
+ pcre_uchar *next;
+ pcre_uchar *next_end;
+ pcre_uchar *max_end;
+ pcre_uchar type;
+ sljit_uw length = end - begin;
+ int min, max, i;
+ /* Detect fixed iterations first. */
+ if (end[-(1 + LINK_SIZE)] != OP_KET)
+   return FALSE;
+ /* Already detected repeat. */
+ if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)
+   return TRUE;
+ next = end;
+ min = 1;
+ while (1)
+   {
+   if (*next != *begin)
+     break;
+   next_end = bracketend(next);
+   if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)
+     break;
+   next = next_end;
+   min++;
+   }
+ if (min == 2)
+   return FALSE;
+ max = 0;
+ max_end = next;
+ if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)
+   {
+   type = *next;
+   while (1)
      {
-     if (size < 0)
+     if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
+       break;
+     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)
        {
-       cc += -size;
+       for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
- #ifdef SUPPORT_UTF
+         if (*next_end != OP_KET)
-       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+           break;
- #endif
+       if (i == max)
+         {
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
+         /* +2 the original and the last. */
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;
+         if (min == 1)
+           return TRUE;
+         min--;
+         max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);
+         }
        }
-     else
-       cc += size;
      }
+   }
+ if (min >= 3)
+   {
+   common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;
+   common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;
+   common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;
+   return TRUE;
+   }
+ return FALSE;
+ }
+ #define CASE_ITERATOR_PRIVATE_DATA_1 \
+     case OP_MINSTAR: \
+     case OP_MINPLUS: \
+     case OP_QUERY: \
+     case OP_MINQUERY: \
+     case OP_MINSTARI: \
+     case OP_MINPLUSI: \
+     case OP_QUERYI: \
+     case OP_MINQUERYI: \
+     case OP_NOTMINSTAR: \
+     case OP_NOTMINPLUS: \
+     case OP_NOTQUERY: \
+     case OP_NOTMINQUERY: \
+     case OP_NOTMINSTARI: \
+     case OP_NOTMINPLUSI: \
+     case OP_NOTQUERYI: \
+     case OP_NOTMINQUERYI:
+ #define CASE_ITERATOR_PRIVATE_DATA_2A \
+     case OP_STAR: \
+     case OP_PLUS: \
+     case OP_STARI: \
+     case OP_PLUSI: \
+     case OP_NOTSTAR: \
+     case OP_NOTPLUS: \
+     case OP_NOTSTARI: \
+     case OP_NOTPLUSI:
+ #define CASE_ITERATOR_PRIVATE_DATA_2B \
+     case OP_UPTO: \
+     case OP_MINUPTO: \
+     case OP_UPTOI: \
+     case OP_MINUPTOI: \
+     case OP_NOTUPTO: \
+     case OP_NOTMINUPTO: \
+     case OP_NOTUPTOI: \
+     case OP_NOTMINUPTOI:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
+     case OP_TYPEMINSTAR: \
+     case OP_TYPEMINPLUS: \
+     case OP_TYPEQUERY: \
+     case OP_TYPEMINQUERY:
-   if (bracketlen > 0)
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
-     {
+     case OP_TYPESTAR: \
-     if (cc >= end)
+     case OP_TYPEPLUS:
-       {
-       end = bracketend(cc);
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
-       if (end[-1 - LINK_SIZE] == OP_KET)
+     case OP_TYPEUPTO: \
-         end = NULL;
+     case OP_TYPEMINUPTO:
-       }
-     cc += bracketlen;
-     }
-   }
- return localspace;
- }
- static void set_localptrs(compiler_common *common, int localptr, 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 922 
 while (cc < ccend)
+Line 1035 
 while (cc < ccend)
    space = 0;
    size = 0;
    bracketlen = 0;
+   if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
+     return;
+   if (*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_ONCE || *cc == OP_ONCE_NC)
+     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 934 
 while (cc < ccend)
+Line 1069 
 while (cc < ccend)
      case OP_SBRA:
      case OP_SBRAPOS:
      case OP_SCOND:
-     common->localptrs[cc - common->start] = localptr;
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     localptr += sizeof(sljit_w);
+     private_data_ptr += sizeof(sljit_sw);
      bracketlen = 1 + LINK_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     common->localptrs[cc - common->start] = localptr;
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     localptr += sizeof(sljit_w);
+     private_data_ptr += sizeof(sljit_sw);
      bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
-Line 951 
 while (cc < ccend)
+Line 1086 
 while (cc < ccend)
      alternative = cc + GET(cc, 1);
      if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
        {
-       common->localptrs[cc - common->start] = localptr;
+       common->private_data_ptrs[cc - common->start] = private_data_ptr;
-       localptr += sizeof(sljit_w);
+       private_data_ptr += sizeof(sljit_sw);
        }
      bracketlen = 1 + LINK_SIZE;
      break;
-Line 966 
 while (cc < ccend)
+Line 1101 
 while (cc < ccend)
      bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
-     CASE_ITERATOR_LOCAL1
+     CASE_ITERATOR_PRIVATE_DATA_1
      space = 1;
      size = -2;
      break;
-     CASE_ITERATOR_LOCAL2A
+     CASE_ITERATOR_PRIVATE_DATA_2A
      space = 2;
      size = -2;
      break;
-     CASE_ITERATOR_LOCAL2B
+     CASE_ITERATOR_PRIVATE_DATA_2B
      space = 2;
      size = -(2 + IMM2_SIZE);
      break;
-     CASE_ITERATOR_TYPE_LOCAL1
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
      space = 1;
      size = 1;
      break;
-     CASE_ITERATOR_TYPE_LOCAL2A
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
      if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
        space = 2;
      size = 1;
      break;
-     CASE_ITERATOR_TYPE_LOCAL2B
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
      if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
        space = 2;
      size = 1 + IMM2_SIZE;
-Line 1017 
 while (cc < ccend)
+Line 1152 
 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->localptrs[cc - common->start] = localptr;
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     localptr += sizeof(sljit_w) * space;
+     private_data_ptr += sizeof(sljit_sw) * space;
      }
    if (size != 0)
-Line 1047 
 while (cc < ccend)
+Line 1184 
 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 (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
+ #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
+ SLJIT_ASSERT(common->control_head_ptr != 0);
+ *needs_control_head = TRUE;
+ #else
+ *needs_control_head = FALSE;
+ #endif
+ if (ccend == NULL)
    {
-   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 1080 
 while (cc < ccend)
+Line 1233 
 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 1100 
 while (cc < ccend)
+Line 1259 
 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 1107 
 while (cc < ccend)
+Line 1271 
 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 1139 
 SLJIT_UNUSED_ARG(stacktop);
+Line 1377 
 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 1150 
 while (cc < ccend)
+Line 1393 
 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 1177 
 while (cc < ccend)
+Line 1422 
 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 1199 
 while (cc < ccend)
+Line 1453 
 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 1218 
 while (cc < ccend)
+Line 1481 
 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_localsize(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 localsize = 2;
+ int private_data_length = needs_control_head ? 3 : 2;
  int size;
  pcre_uchar *alternative;
- /* Calculate the sum of the local variables. */
+ /* Calculate the sum of the private machine words. */
  while (cc < ccend)
    {
    size = 0;
-Line 1243 
 while (cc < ccend)
+Line 1506 
 while (cc < ccend)
      case OP_SBRA:
      case OP_SBRAPOS:
      case OP_SCOND:
-     localsize++;
+     private_data_length++;
      cc += 1 + LINK_SIZE;
      break;
      case OP_CBRA:
      case OP_SCBRA:
-     localsize++;
+     if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+       private_data_length++;
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     localsize += 2;
+     private_data_length += 2;
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
-Line 1263 
 while (cc < ccend)
+Line 1527 
 while (cc < ccend)
      /* Might be a hidden SCOND. */
      alternative = cc + GET(cc, 1);
      if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
-       localsize++;
+       private_data_length++;
      cc += 1 + LINK_SIZE;
      break;
-     CASE_ITERATOR_LOCAL1
+     CASE_ITERATOR_PRIVATE_DATA_1
-     if (PRIV_DATA(cc))
+     if (PRIVATE_DATA(cc))
-       localsize++;
+       private_data_length++;
      cc += 2;
  #ifdef SUPPORT_UTF
      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      break;
-     CASE_ITERATOR_LOCAL2A
+     CASE_ITERATOR_PRIVATE_DATA_2A
-     if (PRIV_DATA(cc))
+     if (PRIVATE_DATA(cc))
-       localsize += 2;
+       private_data_length += 2;
      cc += 2;
  #ifdef SUPPORT_UTF
      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      break;
-     CASE_ITERATOR_LOCAL2B
+     CASE_ITERATOR_PRIVATE_DATA_2B
-     if (PRIV_DATA(cc))
+     if (PRIVATE_DATA(cc))
-       localsize += 2;
+       private_data_length += 2;
      cc += 2 + IMM2_SIZE;
  #ifdef SUPPORT_UTF
      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      break;
-     CASE_ITERATOR_TYPE_LOCAL1
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
-     if (PRIV_DATA(cc))
+     if (PRIVATE_DATA(cc))
-       localsize++;
+       private_data_length++;
      cc += 1;
      break;
-     CASE_ITERATOR_TYPE_LOCAL2A
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
-     if (PRIV_DATA(cc))
+     if (PRIVATE_DATA(cc))
-       localsize += 2;
+       private_data_length += 2;
      cc += 1;
      break;
-     CASE_ITERATOR_TYPE_LOCAL2B
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
-     if (PRIV_DATA(cc))
+     if (PRIVATE_DATA(cc))
-       localsize += 2;
+       private_data_length += 2;
      cc += 1 + IMM2_SIZE;
      break;
-Line 1320 
 while (cc < ccend)
+Line 1584 
 while (cc < ccend)
  #else
      size = 1 + 32 / (int)sizeof(pcre_uchar);
  #endif
-     if (PRIV_DATA(cc))
+     if (PRIVATE_DATA(cc))
-       localsize += get_class_iterator_size(cc + size);
+       private_data_length += get_class_iterator_size(cc + size);
      cc += size;
      break;
-Line 1332 
 while (cc < ccend)
+Line 1596 
 while (cc < ccend)
      }
    }
  SLJIT_ASSERT(cc == ccend);
- return localsize;
+ return private_data_length;
  }
- static void copy_locals(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
+ 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 1357 
 stacktop = STACK(stacktop - 1);
+Line 1621 
 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 1405 
 while (status != end)
+Line 1675 
 while (status != end)
        case OP_SBRAPOS:
        case OP_SCOND:
        count = 1;
-       srcw[0] = PRIV_DATA(cc);
+       srcw[0] = PRIVATE_DATA(cc);
        SLJIT_ASSERT(srcw[0] != 0);
        cc += 1 + LINK_SIZE;
        break;
        case OP_CBRA:
        case OP_SCBRA:
-       count = 1;
+       if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
-       srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
+         {
+         count = 1;
+         srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
+         }
        cc += 1 + LINK_SIZE + IMM2_SIZE;
        break;
        case OP_CBRAPOS:
        case OP_SCBRAPOS:
        count = 2;
-       srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
+       srcw[0] = PRIVATE_DATA(cc);
-       srcw[1] = PRIV_DATA(cc);
+       srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
-       SLJIT_ASSERT(srcw[0] != 0);
+       SLJIT_ASSERT(srcw[0] != 0 && srcw[1] != 0);
        cc += 1 + LINK_SIZE + IMM2_SIZE;
        break;
-Line 1432 
 while (status != end)
+Line 1705 
 while (status != end)
        if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
          {
          count = 1;
-         srcw[0] = PRIV_DATA(cc);
+         srcw[0] = PRIVATE_DATA(cc);
          SLJIT_ASSERT(srcw[0] != 0);
          }
        cc += 1 + LINK_SIZE;
        break;
-       CASE_ITERATOR_LOCAL1
+       CASE_ITERATOR_PRIVATE_DATA_1
-       if (PRIV_DATA(cc))
+       if (PRIVATE_DATA(cc))
          {
          count = 1;
-         srcw[0] = PRIV_DATA(cc);
+         srcw[0] = PRIVATE_DATA(cc);
          }
        cc += 2;
  #ifdef SUPPORT_UTF
-Line 1450 
 while (status != end)
+Line 1723 
 while (status != end)
  #endif
        break;
-       CASE_ITERATOR_LOCAL2A
+       CASE_ITERATOR_PRIVATE_DATA_2A
-       if (PRIV_DATA(cc))
+       if (PRIVATE_DATA(cc))
          {
          count = 2;
-         srcw[0] = PRIV_DATA(cc);
+         srcw[0] = PRIVATE_DATA(cc);
-         srcw[1] = PRIV_DATA(cc) + sizeof(sljit_w);
+         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
          }
        cc += 2;
  #ifdef SUPPORT_UTF
-Line 1463 
 while (status != end)
+Line 1736 
 while (status != end)
  #endif
        break;
-       CASE_ITERATOR_LOCAL2B
+       CASE_ITERATOR_PRIVATE_DATA_2B
-       if (PRIV_DATA(cc))
+       if (PRIVATE_DATA(cc))
          {
          count = 2;
-         srcw[0] = PRIV_DATA(cc);
+         srcw[0] = PRIVATE_DATA(cc);
-         srcw[1] = PRIV_DATA(cc) + sizeof(sljit_w);
+         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
          }
        cc += 2 + IMM2_SIZE;
  #ifdef SUPPORT_UTF
-Line 1476 
 while (status != end)
+Line 1749 
 while (status != end)
  #endif
        break;
-       CASE_ITERATOR_TYPE_LOCAL1
+       CASE_ITERATOR_TYPE_PRIVATE_DATA_1
-       if (PRIV_DATA(cc))
+       if (PRIVATE_DATA(cc))
          {
          count = 1;
-         srcw[0] = PRIV_DATA(cc);
+         srcw[0] = PRIVATE_DATA(cc);
          }
        cc += 1;
        break;
-       CASE_ITERATOR_TYPE_LOCAL2A
+       CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
-       if (PRIV_DATA(cc))
+       if (PRIVATE_DATA(cc))
          {
          count = 2;
-         srcw[0] = PRIV_DATA(cc);
+         srcw[0] = PRIVATE_DATA(cc);
-         srcw[1] = srcw[0] + sizeof(sljit_w);
+         srcw[1] = srcw[0] + sizeof(sljit_sw);
          }
        cc += 1;
        break;
-       CASE_ITERATOR_TYPE_LOCAL2B
+       CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
-       if (PRIV_DATA(cc))
+       if (PRIVATE_DATA(cc))
          {
          count = 2;
-         srcw[0] = PRIV_DATA(cc);
+         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 1513 
 while (status != end)
+Line 1786 
 while (status != end)
  #else
        size = 1 + 32 / (int)sizeof(pcre_uchar);
  #endif
-       if (PRIV_DATA(cc))
+       if (PRIVATE_DATA(cc))
          switch(get_class_iterator_size(cc + size))
            {
            case 1:
            count = 1;
-           srcw[0] = PRIV_DATA(cc);
+           srcw[0] = PRIVATE_DATA(cc);
            break;
            case 2:
            count = 2;
-           srcw[0] = PRIV_DATA(cc);
+           srcw[0] = PRIVATE_DATA(cc);
-           srcw[1] = srcw[0] + sizeof(sljit_w);
+           srcw[1] = srcw[0] + sizeof(sljit_sw);
            break;
            default:
-Line 1556 
 while (status != end)
+Line 1829 
 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 1567 
 while (status != end)
+Line 1840 
 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 1584 
 while (status != end)
+Line 1857 
 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 1596 
 while (status != end)
+Line 1869 
 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 1611 
 if (save)
+Line 1885 
 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 1624 
 if (save)
+Line 1898 
 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)));
  }
- #undef CASE_ITERATOR_LOCAL1
+ static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)
- #undef CASE_ITERATOR_LOCAL2A
+ {
- #undef CASE_ITERATOR_LOCAL2B
+ pcre_uchar *end = bracketend(cc);
- #undef CASE_ITERATOR_TYPE_LOCAL1
+ BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
- #undef CASE_ITERATOR_TYPE_LOCAL2A
- #undef CASE_ITERATOR_TYPE_LOCAL2B
+ /* 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
+ #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+ #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 1653 
 static SLJIT_INLINE void set_jumps(jump_
+Line 1960 
 static SLJIT_INLINE void set_jumps(jump_
  while (list)
    {
    /* sljit_set_label is clever enough to do nothing
-   if either the jump or the label is NULL */
+   if either the jump or the label is NULL. */
-   sljit_set_label(list->jump, label);
+   SET_LABEL(list->jump, label);
    list = list->next;
    }
  }
-Line 1670 
 if (list_item)
+Line 1977 
 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 1694 
 stub_list* list_item = common->stubs;
+Line 1999 
 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;
    }
-Line 1719 
 static SLJIT_INLINE void allocate_stack(
+Line 2019 
 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 1727 
 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
+Line 2027 
 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 1741 
 static SLJIT_INLINE void reset_ovector(c
+Line 2041 
 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 1813 
 else
+Line 2173 
 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 1949 
 if (c <= 127 && bit == 0x20)
+Line 2320 
 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 1968 
 if (common->utf && c > 127)
+Line 2339 
 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 1981 
 if (common->utf && c > 65535)
+Line 2351 
 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 2003 
 else if (common->mode == JIT_PARTIAL_SOF
+Line 2372 
 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 2016 
 if (jump != NULL)
+Line 2385 
 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 2063 
 jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR
+Line 2431 
 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 2081 
 static void read_char(compiler_common *c
+Line 2449 
 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 2108 
 static void peek_char(compiler_common *c
+Line 2474 
 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 2143 
 if (common->utf)
+Line 2507 
 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 2159 
 if (common->utf)
+Line 2522 
 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 2184 
 static void skip_char_back(compiler_comm
+Line 2551 
 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 2196 
 if (common->utf)
+Line 2564 
 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 2205 
 if (common->utf)
+Line 2572 
 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 2227 
 if (nltype == NLTYPE_ANY)
+Line 2595 
 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 2241 
 else
+Line 2609 
 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 2329 
 sljit_emit_fast_return(compiler, RETURN_
+Line 2697 
 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 2362 
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UC
+Line 2729 
 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 2384 
 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && si
+Line 2750 
 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 2404 
 struct sljit_label *newlinelabel = NULL;
+Line 2770 
 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 2419 
 if (firstline)
+Line 2785 
 if (firstline)
    {
    /* Search for the end of the first line. */
    SLJIT_ASSERT(common->first_line_end != 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STR_PTR, 0);
+   OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_END, 0);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
-Line 2431 
 if (firstline)
+Line 2796 
 if (firstline)
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
      CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
      CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
+     JUMPHERE(end);
      OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      }
    else
-Line 2442 
 if (firstline)
+Line 2808 
 if (firstline)
      read_char(common);
      check_newlinechar(common, common->nltype, &newline, TRUE);
      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
+     JUMPHERE(end);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
      set_jumps(newline, LABEL());
      }
-   JUMPHERE(end);
+   OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
-   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
    }
  start = JUMP(SLJIT_JUMP);
-Line 2459 
 if (newlinecheck)
+Line 2825 
 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 2482 
 if (newlinecheck)
+Line 2848 
 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 2514 
 if (newlinecheck)
+Line 2881 
 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 2596 
 while (TRUE)
+Line 2953 
 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 2621 
 while (TRUE)
+Line 2982 
 while (TRUE)
    else
      caseless = 0;
-   while (len > 0 && location < 2 * 2)
+   while (len > 0 && location < MAX_N_CHARS * 2)
      {
      c = *cc;
      bit = 0;
-Line 2639 
 while (TRUE)
+Line 3000 
 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)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
+   SLJIT_ASSERT(common->first_line_end != 0);
-   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, 1);
+   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
+   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
    }
  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 */
- #if defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
- 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, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
- OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, 1);
+ else
+   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 2713 
 pcre_uchar oc, bit;
+Line 3060 
 pcre_uchar oc, bit;
  if (firstline)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
+   SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
-Line 2735 
 if (first_char == oc)
+Line 3083 
 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 2743 
 else
+Line 3091 
 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 2756 
 JUMPHERE(found);
+Line 3104 
 JUMPHERE(found);
  JUMPHERE(quit);
  if (firstline)
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
  static SLJIT_INLINE void fast_forward_newline(compiler_common *common, BOOL firstline)
-Line 2772 
 jump_list *newline = NULL;
+Line 3120 
 jump_list *newline = NULL;
  if (firstline)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
+   SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
-Line 2786 
 if (common->nltype == NLTYPE_FIXED && co
+Line 3135 
 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 2829 
 if (common->nltype == NLTYPE_ANY || comm
+Line 3178 
 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 2841 
 JUMPHERE(lastchar);
+Line 3190 
 JUMPHERE(lastchar);
  JUMPHERE(firstchar);
  if (firstline)
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+   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)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
+   SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);
    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
-Line 2867 
 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_P
+Line 3225 
 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)
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+   OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0);
  }
  static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uchar req_char, BOOL caseless, BOOL has_firstchar)
-Line 2920 
 struct sljit_jump *alreadyfound;
+Line 3286 
 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 2951 
 if (req_char == oc)
+Line 3317 
 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 2987 
 GET_LOCAL_BASE(TMP3, 0, 0);
+Line 3353 
 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 3028 
 static void check_wordboundary(compiler_
+Line 3379 
 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 3053 
 if (common->use_ucp)
+Line 3405 
 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 3085 
 else
+Line 3437 
 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 3097 
 if (common->use_ucp)
+Line 3449 
 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 3126 
 else
+Line 3478 
 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 3181 
 switch(ranges[0])
+Line 3533 
 switch(ranges[0])
        }
      return TRUE;
      }
+   if ((ranges[3] - ranges[2]) == (ranges[5] - ranges[4]) && is_powerof2(ranges[4] - ranges[2]))
+     {
+     if (readch)
+       read_char(common);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4] - ranges[2]);
+     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4]);
+     add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[5] - ranges[4]));
+     return TRUE;
+     }
    return FALSE;
    default:
-Line 3194 
 int i, bit, length;
+Line 3555 
 int i, bit, length;
  const pcre_uint8 *ctypes = (const pcre_uint8*)common->ctypes;
  bit = ctypes[0] & flag;
+ ranges[0] = -1;
  ranges[1] = bit != 0 ? 1 : 0;
  length = 0;
-Line 3201 
 for (i = 1; i < 256; i++)
+Line 3563 
 for (i = 1; i < 256; i++)
    if ((ctypes[i] & flag) != bit)
      {
      if (length >= MAX_RANGE_SIZE)
-       {
-       ranges[0] = -1;
        return;
-       }
      ranges[2 + length] = i;
      length++;
      bit ^= flag;
-Line 3213 
 for (i = 1; i < 256; i++)
+Line 3572 
 for (i = 1; i < 256; i++)
  if (bit != 0)
    {
    if (length >= MAX_RANGE_SIZE)
-     {
-     ranges[0] = -1;
      return;
-     }
    ranges[2 + length] = 256;
    length++;
    }
-Line 3276 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 3632 
 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 3302 
 DEFINE_COMPILER;
+Line 3658 
 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 3342 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 3698 
 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 3442 
 sljit_emit_fast_return(compiler, RETURN_
+Line 3798 
 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 3455 
 while (src1 < end1)
+Line 3813 
 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 3477 
 if (caseless && char_has_othercase(commo
+Line 3844 
 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 3502 
 if (context->sourcereg == -1)
+Line 3871 
 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 3525 
 do
+Line 3894 
 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 3540 
 do
+Line 3909 
 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 3548 
 do
+Line 3917 
 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 3590 
 do
+Line 3956 
 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 3642 
 return cc;
+Line 4004 
 return cc;
      } \
    charoffset = (value);
- static void compile_xclass_trypath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
+ static void compile_xclass_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
  {
  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 3679 
 if ((*cc++ & XCL_MAP) != 0)
+Line 4040 
 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 3756 
 while (*cc != XCL_END)
+Line 4117 
 while (*cc != XCL_END)
        needschar = TRUE;
        break;
+       case PT_CLIST:
+       case PT_UCNC:
+       needschar = TRUE;
+       break;
        default:
        SLJIT_ASSERT_STOP();
        break;
-Line 3792 
 if (needstype || needsscript)
+Line 4158 
 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 3834 
 while (*cc != XCL_END)
+Line 4200 
 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 3873 
 while (*cc != XCL_END)
+Line 4239 
 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 3910 
 while (*cc != XCL_END)
+Line 4276 
 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 3941 
 while (*cc != XCL_END)
+Line 4307 
 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 3983 
 if (found != NULL)
+Line 4419 
 if (found != NULL)
  #endif
- static pcre_uchar *compile_char1_trypath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)
+ static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  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 4058 
 switch(type)
+Line 4495 
 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 4080 
 switch(type)
+Line 4517 
 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;