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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1195 by zherczeg,
Thu Nov  1 15:21:27 2012 UTC
+revision 1303 by zherczeg,
Fri Mar 29 09:01:20 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 65 
 system files. */
  #error Unsupported architecture
  #endif
+ /* Defines for debugging purposes. */
+ /* 1 - Use unoptimized capturing brackets.
+- Enable capture_last_ptr (includes option 1). */
+ /* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */
+ /* 1 - Always have a control head. */
+ /* #define DEBUG_FORCE_CONTROL_HEAD 1 */
  /* Allocate memory for the regex stack on the real machine stack.
  Fast, but limited size. */
  #define MACHINE_STACK_SIZE 32768
-Line 157 
 typedef struct jit_arguments {
+Line 166 
 typedef struct jit_arguments {
    int *offsets;
    pcre_uchar *uchar_ptr;
    pcre_uchar *mark_ptr;
+   void *callout_data;
    /* Everything else after. */
-   int offsetcount;
+   int real_offset_count;
-   int calllimit;
+   int offset_count;
+   int call_limit;
    pcre_uint8 notbol;
    pcre_uint8 noteol;
    pcre_uint8 notempty;
-Line 179 
 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
-Line 209 
 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 private_data_ptr;
-Line 230 
 typedef struct bracket_backtrack {
+Line 247 
 typedef struct bracket_backtrack {
      /* Both for OP_COND, OP_SCOND. */
      jump_list *condfailed;
      assert_backtrack *assert;
-     /* For OP_ONCE. -1 if not needed. */
+     /* For OP_ONCE. Less than 0 if not needed. */
      int framesize;
    } u;
    /* Points to our private memory word on the stack. */
-Line 265 
 typedef struct recurse_entry {
+Line 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. */
    int *private_data_ptrs;
    /* Tells whether the capturing bracket is optimized. */
    pcre_uint8 *optimized_cbracket;
+   /* Tells whether the starting offset is a target of then. */
+   pcre_uint8 *then_offsets;
+   /* Current position where a THEN must jump. */
+   then_trap_backtrack *then_trap;
    /* Starting offset of private data for capturing brackets. */
-   int cbraptr;
+   int cbra_ptr;
-   /* OVector starting point. Must be divisible by 2. */
+   /* Output vector starting point. Must be divisible by 2. */
    int ovector_start;
    /* Last known position of the requested byte. */
    int req_char_ptr;
    /* Head of the last recursion. */
-   int recursive_head;
+   int recursive_head_ptr;
    /* First inspected character for partial matching. */
    int start_used_ptr;
    /* Starting pointer for partial soft matches. */
-Line 298 
 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_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_sw ctypes;
    int digits[2 + MAX_RANGE_SIZE];
-Line 321 
 typedef struct compiler_common {
+Line 376 
 typedef struct compiler_common {
    /* 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 338 
 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;
-Line 390 
 typedef struct compare_context {
+Line 449 
 typedef struct compare_context {
  #endif
  } compare_context;
- enum {
-   frame_end = 0,
-   frame_setstrbegin = -1,
-   frame_setmark = -2
- };
  /* Undefine sljit macros. */
  #undef CMP
  /* Used for accessing the elements of the stack. */
  #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_sw))
- #define TMP1          SLJIT_TEMPORARY_REG1
+ #define TMP1          SLJIT_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
-Line 428 
 group contains the start / end character
+Line 481 
 group contains the start / end character
  the start pointers when the end of the capturing group has not yet reached. */
  #define OVECTOR_START    (common->ovector_start)
  #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_sw))
- #define OVECTOR_PRIV(i)  (common->cbraptr + (i) * sizeof(sljit_sw))
+ #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * sizeof(sljit_sw))
  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
  #if defined COMPILE_PCRE8
-Line 459 
 the start pointers when the end of the c
+Line 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 483 
 return cc;
+Line 538 
 return cc;
   set_private_data_ptrs
   get_framesize
   init_frame
-  get_private_data_length_for_copy
+  get_private_data_copy_length
   copy_private_data
   compile_matchingpath
   compile_backtrackingpath
-Line 507 
 switch(*cc)
+Line 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 519 
 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 561 
 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_CRMINRANGE:
-   return cc + 1 + 2 * IMM2_SIZE;
-   case OP_CLASS:
+   case OP_ANYBYTE:
-   case OP_NCLASS:
+ #ifdef SUPPORT_UTF
-   return cc + 1 + 32 / sizeof(pcre_uchar);
+   if (common->utf) return NULL;
+ #endif
+   return cc + 1;
  #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;
    }
  }
-Line 812 
 while (cc < ccend)
+Line 860 
 while (cc < ccend)
      case OP_COND:
      case OP_SCOND:
-     bracketlen = cc[1 + LINK_SIZE];
+     /* Only AUTO_CALLOUT can insert this opcode. We do
-     if (bracketlen == OP_CREF)
+        not intend to support this case. */
-       {
+     if (cc[1 + LINK_SIZE] == OP_CALLOUT)
-       bracketlen = GET2(cc, 1 + LINK_SIZE + 1);
+       return -1;
-       common->optimized_cbracket[bracketlen] = 0;
-       }
-     else if (bracketlen == OP_NCREF)
-       {
-       bracketlen = GET2(cc, 1 + LINK_SIZE + 1);
-       name = (pcre_uchar *)common->name_table;
-       alternative = name;
-       for (i = 0; i < common->name_count; i++)
-         {
-         if (GET2(name, 0) == bracketlen) break;
-         name += common->name_entry_size;
-         }
-       SLJIT_ASSERT(i != common->name_count);
-       for (i = 0; i < common->name_count; i++)
-         {
-         if (STRCMP_UC_UC(alternative + IMM2_SIZE, name + IMM2_SIZE) == 0)
-           common->optimized_cbracket[GET2(alternative, 0)] = 0;
-         alternative += common->name_entry_size;
-         }
-       }
      if (*cc == OP_COND)
        {
-Line 850 
 while (cc < ccend)
+Line 877 
 while (cc < ccend)
      bracketlen = 1 + LINK_SIZE;
      break;
+     case OP_CREF:
+     i = GET2(cc, 1);
+     common->optimized_cbracket[i] = 0;
+     cc += 1 + IMM2_SIZE;
+     break;
+     case OP_NCREF:
+     bracketlen = GET2(cc, 1);
+     name = (pcre_uchar *)common->name_table;
+     alternative = name;
+     for (i = 0; i < common->name_count; i++)
+       {
+       if (GET2(name, 0) == bracketlen) break;
+       name += common->name_entry_size;
+       }
+     SLJIT_ASSERT(i != common->name_count);
+     for (i = 0; i < common->name_count; i++)
+       {
+       if (STRCMP_UC_UC(alternative + IMM2_SIZE, name + IMM2_SIZE) == 0)
+         common->optimized_cbracket[GET2(alternative, 0)] = 0;
+       alternative += common->name_entry_size;
+       }
+     bracketlen = 0;
+     cc += 1 + IMM2_SIZE;
+     break;
      case OP_BRA:
      bracketlen = 1 + LINK_SIZE;
      break;
-Line 906 
 while (cc < ccend)
+Line 960 
 while (cc < ccend)
      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_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)
        {
-Line 923 
 while (cc < ccend)
+Line 995 
 while (cc < ccend)
      cc += 1 + 2 + cc[1];
      break;
+     case OP_THEN:
+     common->has_then = TRUE;
+     common->control_head_ptr = 1;
+     /* Fall through. */
+     case OP_PRUNE:
+     case OP_SKIP:
+     common->needs_start_ptr = TRUE;
+     cc += 1;
+     break;
+     case OP_SKIP_ARG:
+     common->control_head_ptr = 1;
+     common->has_skip_arg = TRUE;
+     cc += 1 + 2 + cc[1];
+     break;
      default:
      cc = next_opcode(common, cc);
      if (cc == NULL)
-Line 1099 
 while (cc < ccend)
+Line 1188 
 while (cc < ccend)
    }
  }
- /* 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 1130 
 while (cc < ccend)
+Line 1234 
 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 1150 
 while (cc < ccend)
+Line 1260 
 while (cc < ccend)
        length += 2;
        setmark_found = TRUE;
        }
+     if (common->capture_last_ptr != 0 && !capture_last_found)
+       {
+       length += 2;
+       capture_last_found = TRUE;
+       }
      cc += 1 + LINK_SIZE;
      break;
-Line 1157 
 while (cc < ccend)
+Line 1272 
 while (cc < ccend)
      case OP_CBRAPOS:
      case OP_SCBRA:
      case OP_SCBRAPOS:
+     stack_restore = TRUE;
+     if (common->capture_last_ptr != 0 && !capture_last_found)
+       {
+       length += 2;
+       capture_last_found = TRUE;
+       }
      length += 3;
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      default:
+     stack_restore = TRUE;
+     /* Fall through. */
+     case OP_NOT_WORD_BOUNDARY:
+     case OP_WORD_BOUNDARY:
+     case OP_NOT_DIGIT:
+     case OP_DIGIT:
+     case OP_NOT_WHITESPACE:
+     case OP_WHITESPACE:
+     case OP_NOT_WORDCHAR:
+     case OP_WORDCHAR:
+     case OP_ANY:
+     case OP_ALLANY:
+     case OP_ANYBYTE:
+     case OP_NOTPROP:
+     case OP_PROP:
+     case OP_ANYNL:
+     case OP_NOT_HSPACE:
+     case OP_HSPACE:
+     case OP_NOT_VSPACE:
+     case OP_VSPACE:
+     case OP_EXTUNI:
+     case OP_EODN:
+     case OP_EOD:
+     case OP_CIRC:
+     case OP_CIRCM:
+     case OP_DOLL:
+     case OP_DOLLM:
+     case OP_CHAR:
+     case OP_CHARI:
+     case OP_NOT:
+     case OP_NOTI:
+     case OP_EXACT:
+     case OP_POSSTAR:
+     case OP_POSPLUS:
+     case OP_POSQUERY:
+     case OP_POSUPTO:
+     case OP_EXACTI:
+     case OP_POSSTARI:
+     case OP_POSPLUSI:
+     case OP_POSQUERYI:
+     case OP_POSUPTOI:
+     case OP_NOTEXACT:
+     case OP_NOTPOSSTAR:
+     case OP_NOTPOSPLUS:
+     case OP_NOTPOSQUERY:
+     case OP_NOTPOSUPTO:
+     case OP_NOTEXACTI:
+     case OP_NOTPOSSTARI:
+     case OP_NOTPOSPLUSI:
+     case OP_NOTPOSQUERYI:
+     case OP_NOTPOSUPTOI:
+     case OP_TYPEEXACT:
+     case OP_TYPEPOSSTAR:
+     case OP_TYPEPOSPLUS:
+     case OP_TYPEPOSQUERY:
+     case OP_TYPEPOSUPTO:
+     case OP_CLASS:
+     case OP_NCLASS:
+     case OP_XCLASS:
      cc = next_opcode(common, cc);
      SLJIT_ASSERT(cc != NULL);
      break;
      }
  /* Possessive quantifiers can use a special case. */
- if (SLJIT_UNLIKELY(possessive) && length == 3)
+ if (SLJIT_UNLIKELY(possessive == length))
-   return -1;
+   return stack_restore ? no_frame : no_stack;
  if (length > 0)
    return length + 1;
- return -1;
+ return stack_restore ? no_frame : no_stack;
  }
- static void init_frame(compiler_common *common, pcre_uchar *cc, int stackpos, int stacktop, BOOL recursive)
+ static void init_frame(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, int stackpos, int stacktop, BOOL recursive)
  {
  DEFINE_COMPILER;
- pcre_uchar *ccend = bracketend(cc);
  BOOL setsom_found = recursive;
  BOOL setmark_found = recursive;
+ /* The last capture is a local variable even for recursions. */
+ BOOL capture_last_found = FALSE;
  int offset;
  /* >= 1 + shortest item size (2) */
-Line 1189 
 SLJIT_UNUSED_ARG(stacktop);
+Line 1378 
 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 1200 
 while (cc < ccend)
+Line 1394 
 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_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
        stackpos += (int)sizeof(sljit_sw);
-Line 1210 
 while (cc < ccend)
+Line 1404 
 while (cc < ccend)
      break;
      case OP_MARK:
+     case OP_PRUNE_ARG:
+     case OP_THEN_ARG:
      SLJIT_ASSERT(common->mark_ptr != 0);
      if (!setmark_found)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
        stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
        stackpos += (int)sizeof(sljit_sw);
-Line 1227 
 while (cc < ccend)
+Line 1423 
 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_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
        stackpos += (int)sizeof(sljit_sw);
-Line 1236 
 while (cc < ccend)
+Line 1432 
 while (cc < ccend)
      if (common->mark_ptr != 0 && !setmark_found)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
        stackpos += (int)sizeof(sljit_sw);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
        stackpos += (int)sizeof(sljit_sw);
        setmark_found = TRUE;
        }
+     if (common->capture_last_ptr != 0 && !capture_last_found)
+       {
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_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 1249 
 while (cc < ccend)
+Line 1454 
 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_sw);
-Line 1268 
 while (cc < ccend)
+Line 1482 
 while (cc < ccend)
      break;
      }
- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_end);
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0);
  SLJIT_ASSERT(stackpos == STACK(stacktop));
  }
- static SLJIT_INLINE int get_private_data_length_for_copy(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
+ static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)
  {
- int private_data_length = 2;
+ int private_data_length = needs_control_head ? 3 : 2;
  int size;
  pcre_uchar *alternative;
  /* Calculate the sum of the private machine words. */
-Line 1387 
 return private_data_length;
+Line 1601 
 return private_data_length;
  }
  static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
-   BOOL save, int stackptr, int stacktop)
+   BOOL save, int stackptr, int stacktop, BOOL needs_control_head)
  {
  DEFINE_COMPILER;
  int srcw[2];
-Line 1408 
 stacktop = STACK(stacktop - 1);
+Line 1622 
 stacktop = STACK(stacktop - 1);
  if (!save)
    {
-   stackptr += sizeof(sljit_sw);
+   stackptr += (needs_control_head ? 2 : 1) * sizeof(sljit_sw);
    if (stackptr < stacktop)
      {
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
-Line 1424 
 if (!save)
+Line 1638 
 if (!save)
    /* The tmp1next must be TRUE in either way. */
    }
- while (status != end)
+ do
    {
    count = 0;
    switch(status)
      {
      case start:
-     SLJIT_ASSERT(save && common->recursive_head != 0);
+     SLJIT_ASSERT(save && common->recursive_head_ptr != 0);
      count = 1;
-     srcw[0] = common->recursive_head;
+     srcw[0] = common->recursive_head_ptr;
+     if (needs_control_head)
+       {
+       SLJIT_ASSERT(common->control_head_ptr != 0);
+       count = 2;
+       srcw[1] = common->control_head_ptr;
+       }
      status = loop;
      break;
-Line 1657 
 while (status != end)
+Line 1877 
 while (status != end)
        }
      }
    }
+ while (status != end);
  if (save)
    {
-Line 1690 
 if (save)
+Line 1911 
 if (save)
  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
  }
+ static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)
+ {
+ pcre_uchar *end = bracketend(cc);
+ BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
+ /* Assert captures then. */
+ if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
+   current_offset = NULL;
+ /* Conditional block does not. */
+ if (*cc == OP_COND || *cc == OP_SCOND)
+   has_alternatives = FALSE;
+ cc = next_opcode(common, cc);
+ if (has_alternatives)
+   current_offset = common->then_offsets + (cc - common->start);
+ while (cc < end)
+   {
+   if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
+     cc = set_then_offsets(common, cc, current_offset);
+   else
+     {
+     if (*cc == OP_ALT && has_alternatives)
+       current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);
+     if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)
+       *current_offset = 1;
+     cc = next_opcode(common, cc);
+     }
+   }
+ return end;
+ }
  #undef CASE_ITERATOR_PRIVATE_DATA_1
  #undef CASE_ITERATOR_PRIVATE_DATA_2A
  #undef CASE_ITERATOR_PRIVATE_DATA_2B
-Line 1708 
 while (list)
+Line 1962 
 while (list)
    {
    /* sljit_set_label is clever enough to do nothing
    if either the jump or the label is NULL. */
-   sljit_set_label(list->jump, label);
+   SET_LABEL(list->jump, label);
    list = list->next;
    }
  }
-Line 1724 
 if (list_item)
+Line 1978 
 if (list_item)
    }
  }
- static void add_stub(compiler_common *common, enum stub_types type, int data, struct sljit_jump *start)
+ static void add_stub(compiler_common *common, struct sljit_jump *start)
  {
  DEFINE_COMPILER;
  stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
  if (list_item)
    {
-   list_item->type = type;
-   list_item->data = data;
    list_item->start = start;
    list_item->quit = LABEL();
    list_item->next = common->stubs;
-Line 1748 
 stub_list* list_item = common->stubs;
+Line 2000 
 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 1781 
 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
+Line 2028 
 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)
-Line 1795 
 static SLJIT_INLINE void reset_ovector(c
+Line 2042 
 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_sw));
+   GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw));
-   OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, length);
+   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);
    loop = LABEL();
-   OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(sljit_sw), SLJIT_TEMPORARY_REG1, 0);
+   OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);
    JUMPTO(SLJIT_C_NOT_ZERO, loop);
    }
+ OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);
+ if (common->mark_ptr != 0)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_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_sw));
  /* Copy the integer value to the output buffer */
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #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_sw));
+   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_sw)sizeof(sljit_sw)));
+   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 1867 
 else
+Line 2174 
 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);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  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);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);
+ OP2(SLJIT_ASHR, SLJIT_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 2055 
 else if (common->mode == JIT_PARTIAL_SOF
+Line 2373 
 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 2068 
 if (jump != NULL)
+Line 2386 
 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 2115 
 jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR
+Line 2432 
 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 2206 
 if (common->utf)
+Line 2523 
 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);
  #elif defined COMPILE_PCRE32
-Line 2256 
 if (common->utf)
+Line 2573 
 if (common->utf)
    /* Skip low surrogate if necessary. */
    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    return;
-Line 2279 
 if (nltype == NLTYPE_ANY)
+Line 2596 
 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 2509 
 if (newlinecheck)
+Line 2826 
 if (newlinecheck)
    end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
-Line 2547 
 if (common->utf)
+Line 2864 
 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);
-Line 2573 
 DEFINE_COMPILER;
+Line 2890 
 DEFINE_COMPILER;
  struct sljit_label *start;
  struct sljit_jump *quit;
  pcre_uint32 chars[MAX_N_CHARS * 2];
- pcre_uchar *cc = common->start + 1 + IMM2_SIZE;
+ pcre_uchar *cc = common->start + 1 + LINK_SIZE;
  int location = 0;
  pcre_int32 len, c, bit, caseless;
  int must_stop;
-Line 2696 
 if (firstline)
+Line 3013 
 if (firstline)
    {
    SLJIT_ASSERT(common->first_line_end != 0);
    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
-   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, (location >> 1) - 1);
+   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
    }
  else
-   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, (location >> 1) - 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);
-Line 2728 
 JUMPHERE(quit);
+Line 3045 
 JUMPHERE(quit);
  if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  else
-   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, (location >> 1) - 1);
+   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));
  return TRUE;
  }
-Line 2775 
 else
+Line 3092 
 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 2819 
 if (common->nltype == NLTYPE_FIXED && co
+Line 3136 
 if (common->nltype == NLTYPE_FIXED && co
    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);
-   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_GREATER_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
-Line 2862 
 if (common->nltype == NLTYPE_ANY || comm
+Line 3179 
 if (common->nltype == NLTYPE_ANY || comm
    notfoundnl = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
-Line 2877 
 if (firstline)
+Line 3194 
 if (firstline)
    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
+ static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks);
  static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline)
  {
  DEFINE_COMPILER;
  struct sljit_label *start;
  struct sljit_jump *quit;
- struct sljit_jump *found;
+ struct sljit_jump *found = NULL;
+ jump_list *matches = NULL;
+ pcre_uint8 inverted_start_bits[32];
+ int i;
  #ifndef COMPILE_PCRE8
  struct sljit_jump *jump;
  #endif
+ for (i = 0; i < 32; ++i)
+   inverted_start_bits[i] = ~(((pcre_uint8*)start_bits)[i]);
  if (firstline)
    {
    SLJIT_ASSERT(common->first_line_end != 0);
-Line 2901 
 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_P
+Line 3226 
 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)
-Line 2932 
 if (common->utf)
+Line 3261 
 if (common->utf)
    CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    }
  #endif /* COMPILE_PCRE[8|16] */
  #endif /* SUPPORT_UTF */
  JUMPTO(SLJIT_JUMP, start);
- JUMPHERE(found);
+ if (found != NULL)
+   JUMPHERE(found);
+ if (matches != NULL)
+   set_jumps(matches, LABEL());
  JUMPHERE(quit);
  if (firstline)
-Line 3022 
 GET_LOCAL_BASE(TMP3, 0, 0);
+Line 3354 
 GET_LOCAL_BASE(TMP3, 0, 0);
  /* Drop frames until we reach STACK_TOP. */
  mainloop = LABEL();
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
- jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
+ OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);
+ jump = JUMP(SLJIT_C_SIG_LESS_EQUAL);
  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));
-Line 3030 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
+Line 3364 
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
  JUMPTO(SLJIT_JUMP, mainloop);
  JUMPHERE(jump);
- jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
+ jump = JUMP(SLJIT_C_SIG_LESS);
  /* End of dropping frames. */
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  JUMPHERE(jump);
- jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setstrbegin);
+ OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);
- /* Set string begin. */
+ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
+ OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);
- JUMPTO(SLJIT_JUMP, mainloop);
- JUMPHERE(jump);
- if (common->mark_ptr != 0)
-   {
-   jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setmark);
-   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
-   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
-   JUMPTO(SLJIT_JUMP, mainloop);
-   JUMPHERE(jump);
-   }
- /* Unknown command. */
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
  JUMPTO(SLJIT_JUMP, mainloop);
  }
-Line 3063 
 static void check_wordboundary(compiler_
+Line 3380 
 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 3088 
 if (common->use_ucp)
+Line 3406 
 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 3120 
 else
+Line 3438 
 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 3132 
 if (common->use_ucp)
+Line 3450 
 if (common->use_ucp)
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
-   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
-   COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
+   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
    JUMPHERE(jump);
    }
  else
-Line 3161 
 else
+Line 3479 
 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 3315 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 3633 
 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 || 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 || 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 3341 
 DEFINE_COMPILER;
+Line 3659 
 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 || 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 || 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 3381 
 sljit_emit_fast_enter(compiler, RETURN_A
+Line 3699 
 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 || 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 || 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 3481 
 sljit_emit_fast_return(compiler, RETURN_
+Line 3799 
 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. */
  pcre_uint32 c1, c2;
-Line 3532 
 if (caseless && char_has_othercase(commo
+Line 3850 
 if (caseless && char_has_othercase(commo
    othercasebit &= 0xff;
  #elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    /* 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);
-Line 3577 
 do
+Line 3895 
 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 3594 
 do
+Line 3912 
 do
  #if defined COMPILE_PCRE8
    if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1))
- #elif defined COMPILE_PCRE16
+ #else
    if (context->ucharptr >= 2 || context->length == 0)
- #elif defined COMPILE_PCRE32
-   if (1 /* context->ucharptr >= 1 || context->length == 0 */)
  #endif
      {
- #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
      if (context->length >= 4)
        OP1(SLJIT_MOV_SI, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #if defined 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);
- #elif defined COMPILE_PCRE16
+ #endif /* COMPILE_PCRE8 */
-     else if (context->length >= 2)
-       OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #endif /* COMPILE_PCRE[8|16] */
- #elif defined COMPILE_PCRE32
-     OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #endif /* COMPILE_PCRE[8|16|32] */
      context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
      switch(context->ucharptr)
-Line 3625 
 do
+Line 3934 
 do
        add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
        break;
- #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
        case 2 / sizeof(pcre_uchar):
        if (context->oc.asushort != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);
-Line 3640 
 do
+Line 3948 
 do
        break;
  #endif
- #endif /* COMPILE_PCRE[8|16] */
        default:
        SLJIT_ASSERT_STOP();
        break;
-Line 3651 
 do
+Line 3957 
 do
  #else
-   /* Unaligned read is unsupported. */
+   /* Unaligned read is unsupported or in 32 bit mode. */
-   if (context->length > 0)
+   if (context->length >= 1)
      OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
    context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
-Line 3813 
 while (*cc != XCL_END)
+Line 4119 
 while (*cc != XCL_END)
        break;
        case PT_CLIST:
+       case PT_UCNC:
        needschar = TRUE;
        break;
-Line 3894 
 while (*cc != XCL_END)
+Line 4201 
 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 3933 
 while (*cc != XCL_END)
+Line 4240 
 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 3970 
 while (*cc != XCL_END)
+Line 4277 
 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 4001 
 while (*cc != XCL_END)
+Line 4308 
 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;
-Line 4045 
 while (*cc != XCL_END)
+Line 4352 
 while (*cc != XCL_END)
            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]);
-         COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+         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]))
-Line 4058 
 while (*cc != XCL_END)
+Line 4365 
 while (*cc != XCL_END)
            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]);
-         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, other_cases[0] - charoffset);
-         COND_VALUE(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, SLJIT_C_EQUAL);
+         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);
-         COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+         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);
-         COND_VALUE(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, SLJIT_C_EQUAL);
+         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;
        }
      cc += 2;
      }
-Line 4103 
 int length;
+Line 4427 
 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 4171 
 switch(type)
+Line 4496 
 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 4202 
 switch(type)
+Line 4527 
 switch(type)
      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
-Line 4238 
 switch(type)
+Line 4563 
 switch(type)
    read_char(common);
    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
    /* We don't need to handle soft partial matching case. */
+   end_list = NULL;
    if (common->mode != JIT_PARTIAL_HARD_COMPILE)
-     jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+     add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
    else
-     jump[1] = check_str_end(common);
+     check_str_end(common, &end_list);
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
-   jump[2] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
+   jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-   jump[3] = JUMP(SLJIT_JUMP);
+   jump[2] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[0]);
    check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);
+   set_jumps(end_list, LABEL());
    JUMPHERE(jump[1]);
    JUMPHERE(jump[2]);
-   JUMPHERE(jump[3]);
    return cc;
    case OP_NOT_HSPACE:
-Line 4321 
 switch(type)
+Line 4647 
 switch(type)
        {
        jump[1] = CMP(SLJIT_C_EQUAL, TMP2, 0, STR_END, 0);
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
-       COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS);
+       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS);
        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
-       COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_NOT_EQUAL);
+       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_NOT_EQUAL);
        add_jump(compiler, backtracks, JUMP(SLJIT_C_NOT_EQUAL));
        check_partial(common, TRUE);
        add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
-Line 4510 
 switch(type)
+Line 4836 
 switch(type)
      return cc + length;
      }
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);
-   COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);
-   COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
+   OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
    add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
    return cc + length;
-Line 4726 
 if (!common->jscript_compat)
+Line 5052 
 if (!common->jscript_compat)
      {
      /* OVECTOR(1) contains the "string begin - 1" constant. */
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
-     COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+     OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
-     COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
+     OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
      return JUMP(SLJIT_C_NOT_ZERO);
      }
    add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
-Line 4784 
 if (withchecks && !common->jscript_compa
+Line 5110 
 if (withchecks && !common->jscript_compa
  #if defined SUPPORT_UTF && defined SUPPORT_UCP
  if (common->utf && *cc == OP_REFI)
    {
-   SLJIT_ASSERT(TMP1 == SLJIT_TEMPORARY_REG1 && STACK_TOP == SLJIT_TEMPORARY_REG2 && TMP2 == SLJIT_TEMPORARY_REG3);
+   SLJIT_ASSERT(TMP1 == SLJIT_SCRATCH_REG1 && STACK_TOP == SLJIT_SCRATCH_REG2 && TMP2 == SLJIT_SCRATCH_REG3);
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
    if (withchecks)
      jump = CMP(SLJIT_C_EQUAL, TMP1, 0, TMP2, 0);
    /* Needed to save important temporary registers. */
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
-   OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);
+   OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, uchar_ptr), STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, uchar_ptr), STR_PTR, 0);
    sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));
    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
    if (common->mode == JIT_COMPILE)
-Line 5000 
 DEFINE_COMPILER;
+Line 5326 
 DEFINE_COMPILER;
  backtrack_common *backtrack;
  recurse_entry *entry = common->entries;
  recurse_entry *prev = NULL;
- int start = GET(cc, 1);
+ sljit_sw start = GET(cc, 1);
+ pcre_uchar *start_cc;
+ BOOL needs_control_head;
  PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
+ /* Inlining simple patterns. */
+ if (get_framesize(common, common->start + start, NULL, TRUE, &needs_control_head) == no_stack)
+   {
+   start_cc = common->start + start;
+   compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);
+   BACKTRACK_AS(recurse_backtrack)->inlined_pattern = TRUE;
+   return cc + 1 + LINK_SIZE;
+   }
  while (entry != NULL)
    {
    if (entry->start == start)
-Line 5051 
 add_jump(compiler, &backtrack->topbacktr
+Line 5389 
 add_jump(compiler, &backtrack->topbacktr
  return cc + 1 + LINK_SIZE;
  }
+ static int SLJIT_CALL do_callout(struct jit_arguments* arguments, PUBL(callout_block) *callout_block, pcre_uchar **jit_ovector)
+ {
+ const pcre_uchar *begin = arguments->begin;
+ int *offset_vector = arguments->offsets;
+ int offset_count = arguments->offset_count;
+ int i;
+ if (PUBL(callout) == NULL)
+   return 0;
+ callout_block->version = 2;
+ callout_block->callout_data = arguments->callout_data;
+ /* Offsets in subject. */
+ callout_block->subject_length = arguments->end - arguments->begin;
+ callout_block->start_match = (pcre_uchar*)callout_block->subject - arguments->begin;
+ callout_block->current_position = (pcre_uchar*)callout_block->offset_vector - arguments->begin;
+ #if defined COMPILE_PCRE8
+ callout_block->subject = (PCRE_SPTR)begin;
+ #elif defined COMPILE_PCRE16
+ callout_block->subject = (PCRE_SPTR16)begin;
+ #elif defined COMPILE_PCRE32
+ callout_block->subject = (PCRE_SPTR32)begin;
+ #endif
+ /* Convert and copy the JIT offset vector to the offset_vector array. */
+ callout_block->capture_top = 0;
+ callout_block->offset_vector = offset_vector;
+ for (i = 2; i < offset_count; i += 2)
+   {
+   offset_vector[i] = jit_ovector[i] - begin;
+   offset_vector[i + 1] = jit_ovector[i + 1] - begin;
+   if (jit_ovector[i] >= begin)
+     callout_block->capture_top = i;
+   }
+ callout_block->capture_top = (callout_block->capture_top >> 1) + 1;
+ if (offset_count > 0)
+   offset_vector[0] = -1;
+ if (offset_count > 1)
+   offset_vector[1] = -1;
+ return (*PUBL(callout))(callout_block);
+ }
+ /* Aligning to 8 byte. */
+ #define CALLOUT_ARG_SIZE \
+     (((int)sizeof(PUBL(callout_block)) + 7) & ~7)
+ #define CALLOUT_ARG_OFFSET(arg) \
+     (-CALLOUT_ARG_SIZE + SLJIT_OFFSETOF(PUBL(callout_block), arg))
+ static SLJIT_INLINE pcre_uchar *compile_callout_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+ {
+ DEFINE_COMPILER;
+ backtrack_common *backtrack;
+ PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
+ allocate_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+ SLJIT_ASSERT(common->capture_last_ptr != 0);
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(capture_last), TMP2, 0);
+ /* These pointer sized fields temporarly stores internal variables. */
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(offset_vector), STR_PTR, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(subject), TMP2, 0);
+ if (common->mark_ptr != 0)
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr));
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 2));
+ OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(next_item_length), SLJIT_IMM, GET(cc, 2 + LINK_SIZE));
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(mark), (common->mark_ptr != 0) ? TMP2 : SLJIT_IMM, 0);
+ /* Needed to save important temporary registers. */
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
+ OP2(SLJIT_SUB, SLJIT_SCRATCH_REG2, 0, STACK_TOP, 0, SLJIT_IMM, CALLOUT_ARG_SIZE);
+ GET_LOCAL_BASE(SLJIT_SCRATCH_REG3, 0, OVECTOR_START);
+ sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_callout));
+ OP1(SLJIT_MOV_SI, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0);
+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
+ free_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));
+ /* Check return value. */
+ OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
+ add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_C_SIG_GREATER));
+ if (common->forced_quit_label == NULL)
+   add_jump(compiler, &common->forced_quit, JUMP(SLJIT_C_SIG_LESS));
+ else
+   JUMPTO(SLJIT_C_SIG_LESS, common->forced_quit_label);
+ return cc + 2 + 2 * LINK_SIZE;
+ }
+ #undef CALLOUT_ARG_SIZE
+ #undef CALLOUT_ARG_OFFSET
  static pcre_uchar *compile_assert_matchingpath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)
  {
  DEFINE_COMPILER;
  int framesize;
+ int extrasize;
+ BOOL needs_control_head;
  int private_data_ptr;
  backtrack_common altbacktrack;
  pcre_uchar *ccbegin;
-Line 5064 
 jump_list *tmp = NULL;
+Line 5503 
 jump_list *tmp = NULL;
  jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
  jump_list **found;
  /* Saving previous accept variables. */
- struct sljit_label *save_quitlabel = common->quitlabel;
+ BOOL save_local_exit = common->local_exit;
- struct sljit_label *save_acceptlabel = common->acceptlabel;
+ BOOL save_positive_assert = common->positive_assert;
+ then_trap_backtrack *save_then_trap = common->then_trap;
+ struct sljit_label *save_quit_label = common->quit_label;
+ struct sljit_label *save_accept_label = common->accept_label;
  jump_list *save_quit = common->quit;
+ jump_list *save_positive_assert_quit = common->positive_assert_quit;
  jump_list *save_accept = common->accept;
  struct sljit_jump *jump;
  struct sljit_jump *brajump = NULL;
+ /* Assert captures then. */
+ common->then_trap = NULL;
  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
    {
    SLJIT_ASSERT(!conditional);
-Line 5079 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 5525 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
    }
  private_data_ptr = PRIVATE_DATA(cc);
  SLJIT_ASSERT(private_data_ptr != 0);
- framesize = get_framesize(common, cc, FALSE);
+ framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
  backtrack->framesize = framesize;
  backtrack->private_data_ptr = private_data_ptr;
  opcode = *cc;
-Line 5098 
 if (bra == OP_BRAMINZERO)
+Line 5544 
 if (bra == OP_BRAMINZERO)
  if (framesize < 0)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
+   extrasize = needs_control_head ? 2 : 1;
-   allocate_stack(common, 1);
+   if (framesize == no_frame)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
+   allocate_stack(common, extrasize);
+   if (needs_control_head)
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+   if (needs_control_head)
+     {
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+     }
    }
  else
    {
-   allocate_stack(common, framesize + 2);
+   extrasize = needs_control_head ? 3 : 2;
+   allocate_stack(common, framesize + extrasize);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-   OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(framesize + 1));
+   OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
+   if (needs_control_head)
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+   if (needs_control_head)
-   init_frame(common, ccbegin, framesize + 1, 2, FALSE);
+     {
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
+     }
+   else
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+   init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);
    }
  memset(&altbacktrack, 0, sizeof(backtrack_common));
- common->quitlabel = NULL;
+ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
- common->quit = NULL;
+   {
+   /* Negative assert is stronger than positive assert. */
+   common->local_exit = TRUE;
+   common->quit_label = NULL;
+   common->quit = NULL;
+   common->positive_assert = FALSE;
+   }
+ else
+   common->positive_assert = TRUE;
+ common->positive_assert_quit = NULL;
  while (1)
    {
-   common->acceptlabel = NULL;
+   common->accept_label = NULL;
    common->accept = NULL;
    altbacktrack.top = NULL;
    altbacktrack.topbacktracks = NULL;
-Line 5130 
 while (1)
+Line 5605 
 while (1)
    compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
-     common->quitlabel = save_quitlabel;
+     if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
-     common->acceptlabel = save_acceptlabel;
+       {
-     common->quit = save_quit;
+       common->local_exit = save_local_exit;
+       common->quit_label = save_quit_label;
+       common->quit = save_quit;
+       }
+     common->positive_assert = save_positive_assert;
+     common->then_trap = save_then_trap;
+     common->accept_label = save_accept_label;
+     common->positive_assert_quit = save_positive_assert_quit;
      common->accept = save_accept;
      return NULL;
      }
-   common->acceptlabel = LABEL();
+   common->accept_label = LABEL();
    if (common->accept != NULL)
-     set_jumps(common->accept, common->acceptlabel);
+     set_jumps(common->accept, common->accept_label);
    /* Reset stack. */
    if (framesize < 0)
-     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+     {
-   else {
+     if (framesize == no_frame)
+       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+     else
+       free_stack(common, extrasize);
+     if (needs_control_head)
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);
+     }
+   else
+     {
      if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)
        {
        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
+       if (needs_control_head)
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);
        }
      else
        {
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+       if (needs_control_head)
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_sw));
        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
        }
-   }
+     }
    if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
      {
      /* We know that STR_PTR was stored on the top of the stack. */
      if (conditional)
-       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
+       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), needs_control_head ? sizeof(sljit_sw) : 0);
      else if (bra == OP_BRAZERO)
        {
        if (framesize < 0)
-         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
+         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 1) * sizeof(sljit_sw));
        else
          {
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));
-         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_sw));
+         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + extrasize - 1) * sizeof(sljit_sw));
          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
          }
        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
-Line 5185 
 while (1)
+Line 5679 
 while (1)
    compile_backtrackingpath(common, altbacktrack.top);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
-     common->quitlabel = save_quitlabel;
+     if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
-     common->acceptlabel = save_acceptlabel;
+       {
-     common->quit = save_quit;
+       common->local_exit = save_local_exit;
+       common->quit_label = save_quit_label;
+       common->quit = save_quit;
+       }
+     common->positive_assert = save_positive_assert;
+     common->then_trap = save_then_trap;
+     common->accept_label = save_accept_label;
+     common->positive_assert_quit = save_positive_assert_quit;
      common->accept = save_accept;
      return NULL;
      }
-Line 5199 
 while (1)
+Line 5700 
 while (1)
    ccbegin = cc;
    cc += GET(cc, 1);
    }
+ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
+   {
+   SLJIT_ASSERT(common->positive_assert_quit == NULL);
+   /* Makes the check less complicated below. */
+   common->positive_assert_quit = common->quit;
+   }
  /* None of them matched. */
- if (common->quit != NULL)
+ if (common->positive_assert_quit != NULL)
-   set_jumps(common->quit, LABEL());
+   {
+   jump = JUMP(SLJIT_JUMP);
+   set_jumps(common->positive_assert_quit, LABEL());
+   SLJIT_ASSERT(framesize != no_stack);
+   if (framesize < 0)
+     OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, extrasize * sizeof(sljit_sw));
+   else
+     {
+     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+     add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+     OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
+     }
+   JUMPHERE(jump);
+   }
+ if (needs_control_head)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(1));
  if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
    {
-Line 5213 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 5738 
 if (opcode == OP_ASSERT || opcode == OP_
      {
      /* The topmost item should be 0. */
      if (bra == OP_BRAZERO)
+       {
+       if (extrasize == 2)
+         free_stack(common, 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+       }
      else
-       free_stack(common, 1);
+       free_stack(common, extrasize);
      }
    else
      {
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));
      /* The topmost item should be 0. */
      if (bra == OP_BRAZERO)
        {
-       free_stack(common, framesize + 1);
+       free_stack(common, framesize + extrasize - 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
        }
      else
-       free_stack(common, framesize + 2);
+       free_stack(common, framesize + extrasize);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
      }
    jump = JUMP(SLJIT_JUMP);
-Line 5239 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 5768 
 if (opcode == OP_ASSERT || opcode == OP_
    if (framesize < 0)
      {
      /* We know that STR_PTR was stored on the top of the stack. */
-     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
+     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 1) * sizeof(sljit_sw));
      /* Keep the STR_PTR on the top of the stack. */
      if (bra == OP_BRAZERO)
+       {
        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
+       if (extrasize == 2)
+         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+       }
      else if (bra == OP_BRAMINZERO)
        {
        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
-Line 5255 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 5788 
 if (opcode == OP_ASSERT || opcode == OP_
        {
        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
-       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
+       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 2) * sizeof(sljit_sw));
        }
      else
        {
        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_sw));
-       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+       if (extrasize == 2)
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
+         {
+         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+         if (bra == OP_BRAMINZERO)
+           OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+         }
+       else
+         {
+         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
+         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
+         }
        }
      }
    if (bra == OP_BRAZERO)
      {
      backtrack->matchingpath = LABEL();
-     sljit_set_label(jump, backtrack->matchingpath);
+     SET_LABEL(jump, backtrack->matchingpath);
      }
    else if (bra == OP_BRAMINZERO)
      {
-Line 5291 
 else
+Line 5833 
 else
      {
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      if (bra != OP_BRA)
+       {
+       if (extrasize == 2)
+         free_stack(common, 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+       }
      else
-       free_stack(common, 1);
+       free_stack(common, extrasize);
      }
    else
      {
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));
      /* The topmost item should be 0. */
      if (bra != OP_BRA)
        {
-       free_stack(common, framesize + 1);
+       free_stack(common, framesize + extrasize - 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
        }
      else
-       free_stack(common, framesize + 2);
+       free_stack(common, framesize + extrasize);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
      }
-Line 5326 
 else
+Line 5872 
 else
      }
    }
- common->quitlabel = save_quitlabel;
+ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
- common->acceptlabel = save_acceptlabel;
+   {
- common->quit = save_quit;
+   common->local_exit = save_local_exit;
+   common->quit_label = save_quit_label;
+   common->quit = save_quit;
+   }
+ common->positive_assert = save_positive_assert;
+ common->then_trap = save_then_trap;
+ common->accept_label = save_accept_label;
+ common->positive_assert_quit = save_positive_assert_quit;
  common->accept = save_accept;
  return cc + 1 + LINK_SIZE;
  }
-Line 5443 
 if (i < name_count)
+Line 5996 
 if (i < name_count)
  return condition;
  }
+ static SLJIT_INLINE void match_once_common(compiler_common *common, pcre_uchar ket, int framesize, int private_data_ptr, BOOL has_alternatives, BOOL needs_control_head)
+ {
+ DEFINE_COMPILER;
+ int stacksize;
+ if (framesize < 0)
+   {
+   if (framesize == no_frame)
+     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+   else
+     {
+     stacksize = needs_control_head ? 1 : 0;
+     if (ket != OP_KET || has_alternatives)
+       stacksize++;
+     free_stack(common, stacksize);
+     }
+   if (needs_control_head)
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (ket != OP_KET || has_alternatives) ? sizeof(sljit_sw) : 0);
+   /* TMP2 which is set here used by OP_KETRMAX below. */
+   if (ket == OP_KETRMAX)
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
+   else if (ket == OP_KETRMIN)
+     {
+     /* Move the STR_PTR to the private_data_ptr. */
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), 0);
+     }
+   }
+ else
+   {
+   stacksize = (ket != OP_KET || has_alternatives) ? 2 : 1;
+   OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + stacksize) * sizeof(sljit_sw));
+   if (needs_control_head)
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 0);
+   if (ket == OP_KETRMAX)
+     {
+     /* TMP2 which is set here used by OP_KETRMAX below. */
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+     }
+   }
+ if (needs_control_head)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP1, 0);
+ }
+ static SLJIT_INLINE int match_capture_common(compiler_common *common, int stacksize, int offset, int private_data_ptr)
+ {
+ DEFINE_COMPILER;
+ if (common->capture_last_ptr != 0)
+   {
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
+   stacksize++;
+   }
+ if (common->optimized_cbracket[offset >> 1] == 0)
+   {
+   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), STACK(stacksize), TMP1, 0);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
+   stacksize += 2;
+   }
+ return stacksize;
+ }
  /*
    Handling bracketed expressions is probably the most complex part.
-Line 5511 
 pcre_uchar bra = OP_BRA;
+Line 6135 
 pcre_uchar bra = OP_BRA;
  pcre_uchar ket;
  assert_backtrack *assert;
  BOOL has_alternatives;
+ BOOL needs_control_head = FALSE;
  struct sljit_jump *jump;
  struct sljit_jump *skip;
  struct sljit_label *rmaxlabel = NULL;
-Line 5586 
 else if (opcode == OP_ONCE || opcode ==
+Line 6211 
 else if (opcode == OP_ONCE || opcode ==
    SLJIT_ASSERT(private_data_ptr != 0);
    BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
    if (opcode == OP_ONCE)
-     BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, FALSE);
+     BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, NULL, FALSE, &needs_control_head);
    }
  /* Instructions before the first alternative. */
  stacksize = 0;
- if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
+ if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
    stacksize++;
  if (bra == OP_BRAZERO)
    stacksize++;
-Line 5600 
 if (stacksize > 0)
+Line 6225 
 if (stacksize > 0)
    allocate_stack(common, stacksize);
  stacksize = 0;
- if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
+ if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
    {
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
    stacksize++;
-Line 5663 
 if (ket == OP_KETRMAX)
+Line 6288 
 if (ket == OP_KETRMAX)
  /* Handling capturing brackets and alternatives. */
  if (opcode == OP_ONCE)
    {
+   stacksize = 0;
+   if (needs_control_head)
+     {
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
+     stacksize++;
+     }
    if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
      {
-     /* Neither capturing brackets nor recursions are not found in the block. */
+     /* Neither capturing brackets nor recursions are found in the block. */
      if (ket == OP_KETRMIN)
        {
-       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+       stacksize += 2;
-       allocate_stack(common, 2);
+       if (!needs_control_head)
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
-       OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
        }
-     else if (ket == OP_KETRMAX || has_alternatives)
+     else
        {
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
+       if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
-       allocate_stack(common, 1);
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+       if (ket == OP_KETRMAX || has_alternatives)
+         stacksize++;
        }
-     else
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
+     if (stacksize > 0)
+       allocate_stack(common, stacksize);
+     stacksize = 0;
+     if (needs_control_head)
+       {
+       stacksize++;
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+       }
+     if (ket == OP_KETRMIN)
+       {
+       if (needs_control_head)
+         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
+       if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
+         OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, needs_control_head ? (2 * sizeof(sljit_sw)) : sizeof(sljit_sw));
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
+       }
+     else if (ket == OP_KETRMAX || has_alternatives)
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
      }
    else
      {
-     if (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives)
+     if (ket != OP_KET || has_alternatives)
+       stacksize++;
+     stacksize += BACKTRACK_AS(bracket_backtrack)->u.framesize + 1;
+     allocate_stack(common, stacksize);
+     if (needs_control_head)
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+     OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));
+     stacksize = needs_control_head ? 1 : 0;
+     if (ket != OP_KET || has_alternatives)
        {
-       allocate_stack(common, BACKTRACK_AS(bracket_backtrack)->u.framesize + 2);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(BACKTRACK_AS(bracket_backtrack)->u.framesize + 1));
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+       stacksize++;
-       init_frame(common, ccbegin, BACKTRACK_AS(bracket_backtrack)->u.framesize + 1, 2, FALSE);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
        }
      else
        {
-       allocate_stack(common, BACKTRACK_AS(bracket_backtrack)->u.framesize + 1);
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(BACKTRACK_AS(bracket_backtrack)->u.framesize));
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
-       init_frame(common, ccbegin, BACKTRACK_AS(bracket_backtrack)->u.framesize, 1, FALSE);
        }
+     init_frame(common, ccbegin, NULL, BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize, stacksize + 1, FALSE);
      }
    }
  else if (opcode == OP_CBRA || opcode == OP_SCBRA)
    {
    /* Saving the previous values. */
-   if (common->optimized_cbracket[offset >> 1] == 0)
+   if (common->optimized_cbracket[offset >> 1] != 0)
-     {
-     allocate_stack(common, 3);
-     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), STACK(0), TMP1, 0);
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STR_PTR, 0);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
-     }
-   else
      {
      SLJIT_ASSERT(private_data_ptr == OVECTOR(offset));
      allocate_stack(common, 2);
-Line 5730 
 else if (opcode == OP_CBRA || opcode ==
+Line 6377 
 else if (opcode == OP_CBRA || opcode ==
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
      }
+   else
+     {
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+     allocate_stack(common, 1);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STR_PTR, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+     }
    }
  else if (opcode == OP_SBRA || opcode == OP_SCOND)
    {
-Line 5765 
 if (opcode == OP_COND || opcode == OP_SC
+Line 6419 
 if (opcode == OP_COND || opcode == OP_SC
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
-     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, (stacksize << 8) | (common->ovector_start / sizeof(sljit_sw)));
+     OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, (stacksize << 8) | (common->ovector_start / sizeof(sljit_sw)));
-     GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, 0);
+     GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, 0);
-     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
+     OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, common->name_table);
      sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchovector));
      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
-     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, 0));
      JUMPHERE(jump);
      matchingpath += 1 + IMM2_SIZE;
-Line 5815 
 if (opcode == OP_COND || opcode == OP_SC
+Line 6469 
 if (opcode == OP_COND || opcode == OP_SC
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, GET2(common->start, common->currententry->start + 1 + LINK_SIZE));
-       OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);
+       OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, stacksize);
-       GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, 0);
+       GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, 0);
-       OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
+       OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, common->name_table);
        sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchgroups));
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
-       add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+       add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, 0));
        matchingpath += 1 + IMM2_SIZE;
        }
      }
-Line 5843 
 if (SLJIT_UNLIKELY(sljit_get_compiler_er
+Line 6497 
 if (SLJIT_UNLIKELY(sljit_get_compiler_er
    return NULL;
  if (opcode == OP_ONCE)
-   {
+   match_once_common(common, ket, BACKTRACK_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
-   if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
-     {
-     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-     /* TMP2 which is set here used by OP_KETRMAX below. */
-     if (ket == OP_KETRMAX)
-       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
-     else if (ket == OP_KETRMIN)
-       {
-       /* Move the STR_PTR to the private_data_ptr. */
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), 0);
-       }
-     }
-   else
-     {
-     stacksize = (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives) ? 2 : 1;
-     OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize) * sizeof(sljit_sw));
-     if (ket == OP_KETRMAX)
-       {
-       /* TMP2 which is set here used by OP_KETRMAX below. */
-       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-       }
-     }
-   }
  stacksize = 0;
  if (ket != OP_KET || bra != OP_BRA)
    stacksize++;
+ if (offset != 0)
+   {
+   if (common->capture_last_ptr != 0)
+     stacksize++;
+   if (common->optimized_cbracket[offset >> 1] == 0)
+     stacksize += 2;
+   }
  if (has_alternatives && opcode != OP_ONCE)
    stacksize++;
-Line 5878 
 if (stacksize > 0)
+Line 6516 
 if (stacksize > 0)
    allocate_stack(common, stacksize);
  stacksize = 0;
- if (ket != OP_KET)
+ if (ket != OP_KET || bra != OP_BRA)
-   {
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
-   stacksize++;
-   }
- else if (bra != OP_BRA)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
+   if (ket != OP_KET)
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
+   else
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
    stacksize++;
    }
+ if (offset != 0)
+   stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);
  if (has_alternatives)
    {
    if (opcode != OP_ONCE)
-Line 5898 
 if (has_alternatives)
+Line 6537 
 if (has_alternatives)
    }
  /* Must be after the matchingpath label. */
- if (offset != 0)
+ if (offset != 0 && common->optimized_cbracket[offset >> 1] != 0)
    {
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+   SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 0), TMP1, 0);
    }
  if (ket == OP_KETRMAX)
-Line 5959 
 if ((ket != OP_KET && bra != OP_BRAMINZE
+Line 6597 
 if ((ket != OP_KET && bra != OP_BRAMINZE
  while (*cc == OP_ALT)
    cc += GET(cc, 1);
  cc += 1 + LINK_SIZE;
+ /* Temporarily encoding the needs_control_head in framesize. */
+ if (opcode == OP_ONCE)
+   BACKTRACK_AS(bracket_backtrack)->u.framesize = (BACKTRACK_AS(bracket_backtrack)->u.framesize << 1) | (needs_control_head ? 1 : 0);
  return cc;
  }
-Line 5969 
 backtrack_common *backtrack;
+Line 6611 
 backtrack_common *backtrack;
  pcre_uchar opcode;
  int private_data_ptr;
  int cbraprivptr = 0;
+ BOOL needs_control_head;
  int framesize;
  int stacksize;
  int offset = 0;
  BOOL zero = FALSE;
  pcre_uchar *ccbegin = NULL;
- int stack;
+ int stack; /* Also contains the offset of control head. */
  struct sljit_label *loop = NULL;
  struct jump_list *emptymatch = NULL;
-Line 6012 
 switch(opcode)
+Line 6655 
 switch(opcode)
    break;
    }
- framesize = get_framesize(common, cc, FALSE);
+ framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
  BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;
  if (framesize < 0)
    {
-   stacksize = (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS) ? 2 : 1;
+   if (offset != 0)
+     {
+     stacksize = 2;
+     if (common->capture_last_ptr != 0)
+       stacksize++;
+     }
+   else
+     stacksize = 1;
+   if (needs_control_head)
+     stacksize++;
    if (!zero)
      stacksize++;
    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
    allocate_stack(common, stacksize);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
+   if (framesize == no_frame)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
-   if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
+   stack = 0;
+   if (offset != 0)
      {
+     stack = 2;
      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), STACK(0), TMP1, 0);
+     if (common->capture_last_ptr != 0)
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
+     if (needs_control_head)
+       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
+     if (common->capture_last_ptr != 0)
+       {
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
+       stack = 3;
+       }
      }
    else
+     {
+     if (needs_control_head)
+       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+     stack = 1;
+     }
+   if (needs_control_head)
+     stack++;
    if (!zero)
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 1);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), SLJIT_IMM, 1);
+   if (needs_control_head)
+     {
+     stack--;
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);
+     }
    }
  else
    {
    stacksize = framesize + 1;
    if (!zero)
      stacksize++;
-   if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)
+   if (needs_control_head)
+     stacksize++;
+   if (offset == 0)
      stacksize++;
    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
-   allocate_stack(common, stacksize);
+   allocate_stack(common, stacksize);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-   OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));
+   if (needs_control_head)
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
+   OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));
    stack = 0;
    if (!zero)
      {
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);
+     stack = 1;
+     }
+   if (needs_control_head)
+     {
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);
      stack++;
      }
-   if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)
+   if (offset == 0)
      {
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);
      stack++;
      }
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);
-   init_frame(common, cc, stacksize - 1, stacksize - framesize, FALSE);
+   init_frame(common, cc, NULL, stacksize - 1, stacksize - framesize, FALSE);
+   stack -= 1 + (offset == 0);
    }
- if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
+ if (offset != 0)
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
  loop = LABEL();
-Line 6080 
 while (*cc != OP_KETRPOS)
+Line 6768 
 while (*cc != OP_KETRPOS)
    if (framesize < 0)
      {
-     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+     if (framesize == no_frame)
+       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-     if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
+     if (offset != 0)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
+       if (common->capture_last_ptr != 0)
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
        }
      else
-Line 6104 
 while (*cc != OP_KETRPOS)
+Line 6795 
 while (*cc != OP_KETRPOS)
      }
    else
      {
-     if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
+     if (offset != 0)
        {
        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
+       if (common->capture_last_ptr != 0)
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
        }
      else
-Line 6132 
 while (*cc != OP_KETRPOS)
+Line 6825 
 while (*cc != OP_KETRPOS)
          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
        }
      }
+   if (needs_control_head)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));
    JUMPTO(SLJIT_JUMP, loop);
    flush_stubs(common);
-Line 6142 
 while (*cc != OP_KETRPOS)
+Line 6839 
 while (*cc != OP_KETRPOS)
    if (framesize < 0)
      {
-     if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
+     if (offset != 0)
        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
      else
        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      }
    else
      {
-     if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
+     if (offset != 0)
        {
        /* Last alternative. */
        if (*cc == OP_KETRPOS)
-Line 6168 
 while (*cc != OP_KETRPOS)
+Line 6865 
 while (*cc != OP_KETRPOS)
    ccbegin = cc + 1 + LINK_SIZE;
    }
+ /* We don't have to restore the control head in case of a failed match. */
  backtrack->topbacktracks = NULL;
  if (!zero)
    {
-Line 6296 
 PUSH_BACKTRACK(sizeof(iterator_backtrack
+Line 6995 
 PUSH_BACKTRACK(sizeof(iterator_backtrack
  cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);
- switch (type)
+ switch(type)
    {
    case OP_NOT_DIGIT:
    case OP_DIGIT:
-Line 6498 
 static SLJIT_INLINE pcre_uchar *compile_
+Line 7197 
 static SLJIT_INLINE pcre_uchar *compile_
  DEFINE_COMPILER;
  backtrack_common *backtrack;
- PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
+ PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
  if (*cc == OP_FAIL)
    {
-Line 6509 
 if (*cc == OP_FAIL)
+Line 7208 
 if (*cc == OP_FAIL)
  if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL)
    {
    /* No need to check notempty conditions. */
-   if (common->acceptlabel == NULL)
+   if (common->accept_label == NULL)
      add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));
    else
-     JUMPTO(SLJIT_JUMP, common->acceptlabel);
+     JUMPTO(SLJIT_JUMP, common->accept_label);
    return cc + 1;
    }
- if (common->acceptlabel == NULL)
+ if (common->accept_label == NULL)
    add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0)));
  else
-   CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), common->acceptlabel);
+   CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), common->accept_label);
  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
  add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
- if (common->acceptlabel == NULL)
+ if (common->accept_label == NULL)
    add_jump(compiler, &common->accept, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0));
  else
-   CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, common->acceptlabel);
+   CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, common->accept_label);
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
- if (common->acceptlabel == NULL)
+ if (common->accept_label == NULL)
    add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0));
  else
-   CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->acceptlabel);
+   CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->accept_label);
  add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
  return cc + 1;
  }
-Line 6556 
 if (!optimized_cbracket)
+Line 7255 
 if (!optimized_cbracket)
  return cc + 1 + IMM2_SIZE;
  }
+ static SLJIT_INLINE pcre_uchar *compile_control_verb_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+ {
+ DEFINE_COMPILER;
+ backtrack_common *backtrack;
+ pcre_uchar opcode = *cc;
+ pcre_uchar *ccend = cc + 1;
+ if (opcode == OP_PRUNE_ARG || opcode == OP_SKIP_ARG || opcode == OP_THEN_ARG)
+   ccend += 2 + cc[1];
+ PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
+ if (opcode == OP_SKIP)
+   {
+   allocate_stack(common, 1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+   return ccend;
+   }
+ if (opcode == OP_PRUNE_ARG || opcode == OP_THEN_ARG)
+   {
+   OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
+   }
+ return ccend;
+ }
+ static pcre_uchar then_trap_opcode[1] = { OP_THEN_TRAP };
+ static SLJIT_INLINE void compile_then_trap_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
+ {
+ DEFINE_COMPILER;
+ backtrack_common *backtrack;
+ BOOL needs_control_head;
+ int size;
+ PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
+ common->then_trap = BACKTRACK_AS(then_trap_backtrack);
+ BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
+ BACKTRACK_AS(then_trap_backtrack)->start = (sljit_sw)(cc - common->start);
+ BACKTRACK_AS(then_trap_backtrack)->framesize = get_framesize(common, cc, ccend, FALSE, &needs_control_head);
+ size = BACKTRACK_AS(then_trap_backtrack)->framesize;
+ size = 3 + (size < 0 ? 0 : size);
+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
+ allocate_stack(common, size);
+ if (size > 3)
+   OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0, SLJIT_IMM, (size - 3) * sizeof(sljit_sw));
+ else
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 1), SLJIT_IMM, BACKTRACK_AS(then_trap_backtrack)->start);
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 2), SLJIT_IMM, type_then_trap);
+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 3), TMP2, 0);
+ size = BACKTRACK_AS(then_trap_backtrack)->framesize;
+ if (size >= 0)
+   init_frame(common, cc, ccend, size - 1, 0, FALSE);
+ }
  static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
  {
  DEFINE_COMPILER;
  backtrack_common *backtrack;
+ BOOL has_then_trap = FALSE;
+ then_trap_backtrack *save_then_trap = NULL;
+ SLJIT_ASSERT(*ccend == OP_END || (*ccend >= OP_ALT && *ccend <= OP_KETRPOS));
+ if (common->has_then && common->then_offsets[cc - common->start] != 0)
+   {
+   SLJIT_ASSERT(*ccend != OP_END && common->control_head_ptr != 0);
+   has_then_trap = TRUE;
+   save_then_trap = common->then_trap;
+   /* Tail item on backtrack. */
+   compile_then_trap_matchingpath(common, cc, ccend, parent);
+   }
  while (cc < ccend)
    {
-Line 6712 
 while (cc < ccend)
+Line 7487 
 while (cc < ccend)
      cc = compile_recurse_matchingpath(common, cc, parent);
      break;
+     case OP_CALLOUT:
+     cc = compile_callout_matchingpath(common, cc, parent);
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 6772 
 while (cc < ccend)
+Line 7551 
 while (cc < ccend)
      PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
      SLJIT_ASSERT(common->mark_ptr != 0);
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
-     allocate_stack(common, 1);
+     allocate_stack(common, common->has_skip_arg ? 5 : 1);
      OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0), TMP2, 0);
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
+     if (common->has_skip_arg)
+       {
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, type_mark);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), SLJIT_IMM, (sljit_sw)(cc + 2));
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(3), STR_PTR, 0);
+       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
+       }
      cc += 1 + 2 + cc[1];
      break;
+     case OP_PRUNE:
+     case OP_PRUNE_ARG:
+     case OP_SKIP:
+     case OP_SKIP_ARG:
+     case OP_THEN:
+     case OP_THEN_ARG:
      case OP_COMMIT:
-     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
+     cc = compile_control_verb_matchingpath(common, cc, parent);
-     cc += 1;
      break;
      case OP_FAIL:
-Line 6807 
 while (cc < ccend)
+Line 7600 
 while (cc < ccend)
    if (cc == NULL)
      return;
    }
+ if (has_then_trap)
+   {
+   /* Head item on backtrack. */
+   PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
+   BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
+   BACKTRACK_AS(then_trap_backtrack)->then_trap = common->then_trap;
+   common->then_trap = save_then_trap;
+   }
  SLJIT_ASSERT(cc == ccend);
  }
-Line 6968 
 switch(opcode)
+Line 7770 
 switch(opcode)
    }
  }
- static void compile_ref_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+ static SLJIT_INLINE void compile_ref_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  pcre_uchar *cc = current->cc;
-Line 6990 
 set_jumps(current->topbacktracks, LABEL(
+Line 7792 
 set_jumps(current->topbacktracks, LABEL(
  free_stack(common, 2);
  }
- static void compile_recurse_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+ static SLJIT_INLINE void compile_recurse_backtrackingpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
+ if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
+   compile_backtrackingpath(common, current->top);
  set_jumps(current->topbacktracks, LABEL());
+ if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
+   return;
  if (common->has_set_som && common->mark_ptr != 0)
    {
-Line 7096 
 pcre_uchar bra = OP_BRA;
+Line 7902 
 pcre_uchar bra = OP_BRA;
  pcre_uchar ket;
  assert_backtrack *assert;
  BOOL has_alternatives;
+ BOOL needs_control_head = FALSE;
  struct sljit_jump *brazero = NULL;
  struct sljit_jump *once = NULL;
  struct sljit_jump *cond = NULL;
-Line 7121 
 if (SLJIT_UNLIKELY(opcode == OP_COND) &&
+Line 7928 
 if (SLJIT_UNLIKELY(opcode == OP_COND) &&
  if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
    opcode = OP_ONCE;
+ /* Decoding the needs_control_head in framesize. */
+ if (opcode == OP_ONCE)
+   {
+   needs_control_head = (CURRENT_AS(bracket_backtrack)->u.framesize & 0x1) != 0;
+   CURRENT_AS(bracket_backtrack)->u.framesize >>= 1;
+   }
  if (ket == OP_KETRMAX)
    {
    if (bra == OP_BRAZERO)
-Line 7160 
 else if (bra == OP_BRAZERO)
+Line 7974 
 else if (bra == OP_BRAZERO)
    brazero = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
    }
+ if (offset != 0)
+   {
+   if (common->capture_last_ptr != 0)
+     {
+     SLJIT_ASSERT(common->optimized_cbracket[offset >> 1] == 0);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
+     free_stack(common, 3);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP2, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
+     }
+   else if (common->optimized_cbracket[offset >> 1] == 0)
+     {
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+     free_stack(common, 2);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
+     }
+   }
  if (SLJIT_UNLIKELY(opcode == OP_ONCE))
    {
    if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
-Line 7255 
 if (has_alternatives)
+Line 8092 
 if (has_alternatives)
      current->top = NULL;
      current->topbacktracks = NULL;
      current->nextbacktracks = NULL;
+     /* Conditional blocks always have an additional alternative, even if it is empty. */
      if (*cc == OP_ALT)
        {
        ccprev = cc + 1 + LINK_SIZE;
        cc += GET(cc, 1);
        if (opcode != OP_COND && opcode != OP_SCOND)
          {
-         if (private_data_ptr != 0 && opcode != OP_ONCE)
+         if (opcode != OP_ONCE)
-           OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+           {
+           if (private_data_ptr != 0)
+             OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+           else
+             OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+           }
          else
-           OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+           OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(needs_control_head ? 1 : 0));
          }
        compile_matchingpath(common, ccprev, cc, current);
        if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
-Line 7274 
 if (has_alternatives)
+Line 8117 
 if (has_alternatives)
      /* Instructions after the current alternative is succesfully matched. */
      /* There is a similar code in compile_bracket_matchingpath. */
      if (opcode == OP_ONCE)
-       {
+       match_once_common(common, ket, CURRENT_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
-       if (CURRENT_AS(bracket_backtrack)->u.framesize < 0)
-         {
-         OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-         /* TMP2 which is set here used by OP_KETRMAX below. */
-         if (ket == OP_KETRMAX)
-           OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
-         else if (ket == OP_KETRMIN)
-           {
-           /* Move the STR_PTR to the private_data_ptr. */
-           OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), 0);
-           }
-         }
-       else
-         {
-         OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (CURRENT_AS(bracket_backtrack)->u.framesize + 2) * sizeof(sljit_sw));
-         if (ket == OP_KETRMAX)
-           {
-           /* TMP2 which is set here used by OP_KETRMAX below. */
-           OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-           }
-         }
-       }
      stacksize = 0;
-     if (opcode != OP_ONCE)
-       stacksize++;
      if (ket != OP_KET || bra != OP_BRA)
        stacksize++;
+     if (offset != 0)
+       {
+       if (common->capture_last_ptr != 0)
+         stacksize++;
+       if (common->optimized_cbracket[offset >> 1] == 0)
+         stacksize += 2;
+       }
+     if (opcode != OP_ONCE)
+       stacksize++;
-     if (stacksize > 0) {
+     if (stacksize > 0)
+       {
        if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
          allocate_stack(common, stacksize);
        else
-Line 7313 
 if (has_alternatives)
+Line 8142 
 if (has_alternatives)
          SLJIT_ASSERT(stacksize == 1);
          OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
          }
-     }
+       }
      stacksize = 0;
      if (ket != OP_KET || bra != OP_BRA)
-Line 7325 
 if (has_alternatives)
+Line 8154 
 if (has_alternatives)
        stacksize++;
        }
+     if (offset != 0)
+       stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);
      if (opcode != OP_ONCE)
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, count++);
-     if (offset != 0)
+     if (offset != 0 && ket == OP_KETRMAX && common->optimized_cbracket[offset >> 1] != 0)
        {
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+       /* If ket is not OP_KETRMAX, this code path is executed after the jump to alternative_matchingpath. */
+       SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 0), TMP1, 0);
        }
      JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->alternative_matchingpath);
-Line 7357 
 if (has_alternatives)
+Line 8189 
 if (has_alternatives)
      SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);
      assert = CURRENT_AS(bracket_backtrack)->u.assert;
      if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)
        {
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->private_data_ptr);
        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-Line 7374 
 if (has_alternatives)
+Line 8205 
 if (has_alternatives)
  if (offset != 0)
    {
    /* Using both tmp register is better for instruction scheduling. */
-   if (common->optimized_cbracket[offset >> 1] == 0)
+   if (common->optimized_cbracket[offset >> 1] != 0)
      {
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+     free_stack(common, 2);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
-     free_stack(common, 3);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
      }
    else
      {
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+     free_stack(common, 1);
-     free_stack(common, 2);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
      }
    }
  else if (opcode == OP_SBRA || opcode == OP_SCOND)
-Line 7401 
 else if (opcode == OP_SBRA || opcode ==
+Line 8228 
 else if (opcode == OP_SBRA || opcode ==
  else if (opcode == OP_ONCE)
    {
    cc = ccbegin + GET(ccbegin, 1);
+   stacksize = needs_control_head ? 1 : 0;
    if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
      {
      /* Reset head and drop saved frame. */
-     stacksize = (ket == OP_KETRMAX || ket == OP_KETRMIN || *cc == OP_ALT) ? 2 : 1;
+     stacksize += CURRENT_AS(bracket_backtrack)->u.framesize + ((ket != OP_KET || *cc == OP_ALT) ? 2 : 1);
-     free_stack(common, CURRENT_AS(bracket_backtrack)->u.framesize + stacksize);
      }
    else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
      {
      /* The STR_PTR must be released. */
-     free_stack(common, 1);
+     stacksize++;
      }
+   free_stack(common, stacksize);
    JUMPHERE(once);
    /* Restore previous private_data_ptr */
-Line 7463 
 else if (bra == OP_BRAZERO)
+Line 8292 
 else if (bra == OP_BRAZERO)
    }
  }
- static void compile_bracketpos_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+ static SLJIT_INLINE void compile_bracketpos_backtrackingpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  int offset;
-Line 7477 
 if (CURRENT_AS(bracketpos_backtrack)->fr
+Line 8306 
 if (CURRENT_AS(bracketpos_backtrack)->fr
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
+     if (common->capture_last_ptr != 0)
+       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
+     if (common->capture_last_ptr != 0)
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);
      }
    set_jumps(current->topbacktracks, LABEL());
    free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
-Line 7498 
 if (current->topbacktracks)
+Line 8331 
 if (current->topbacktracks)
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracketpos_backtrack)->framesize * sizeof(sljit_sw));
  }
- static void compile_braminzero_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+ static SLJIT_INLINE void compile_braminzero_backtrackingpath(compiler_common *common, struct backtrack_common *current)
  {
  assert_backtrack backtrack;
-Line 7522 
 else
+Line 8355 
 else
  SLJIT_ASSERT(!current->nextbacktracks && !current->topbacktracks);
  }
+ static SLJIT_INLINE void compile_control_verb_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+ {
+ DEFINE_COMPILER;
+ pcre_uchar opcode = *current->cc;
+ struct sljit_label *loop;
+ struct sljit_jump *jump;
+ if (opcode == OP_THEN || opcode == OP_THEN_ARG)
+   {
+   if (common->then_trap != NULL)
+     {
+     SLJIT_ASSERT(common->control_head_ptr != 0);
+     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, type_then_trap);
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, common->then_trap->start);
+     jump = JUMP(SLJIT_JUMP);
+     loop = LABEL();
+     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), -(int)sizeof(sljit_sw));
+     JUMPHERE(jump);