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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1275 by zherczeg,
Sun Mar 10 05:32:10 2013 UTC
+revision 1367 by zherczeg,
Mon Oct  7 07:41:44 2013 UTC
 Line 168 
 typedef struct jit_arguments {
    pcre_uchar *mark_ptr;
    void *callout_data;
    /* Everything else after. */
+   pcre_uint32 limit_match;
    int real_offset_count;
    int offset_count;
-   int call_limit;
    pcre_uint8 notbol;
    pcre_uint8 noteol;
    pcre_uint8 notempty;
 Line 182 
 typedef struct executable_functions {
    PUBL(jit_callback) callback;
    void *userdata;
    pcre_uint32 top_bracket;
+   pcre_uint32 limit_match;
    sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
  } executable_functions;
-Line 202 
 enum frame_types {
+Line 203 
 enum frame_types {
  };
  enum control_types {
-   type_commit = 0,
+   type_mark = 0,
-   type_prune = 1,
+   type_then_trap = 1
-   type_skip = 2
  };
  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
  /* The following structure is the key data type for the recursive
  code generator. It is allocated by compile_matchingpath, and contains
- the aguments for compile_backtrackingpath. Must be the first member
+ the arguments for compile_backtrackingpath. Must be the first member
  of its descendants. */
  typedef struct backtrack_common {
    /* Concatenation stack. */
 Line 227 
 typedef struct backtrack_common {
  typedef struct assert_backtrack {
    backtrack_common common;
    jump_list *condfailed;
-   /* Less than 0 (-1) if a frame is not needed. */
+   /* Less than 0 if a frame is not needed. */
    int framesize;
    /* Points to our private memory word on the stack. */
    int private_data_ptr;
 Line 248 
 typedef struct bracket_backtrack {
      /* Both for OP_COND, OP_SCOND. */
      jump_list *condfailed;
      assert_backtrack *assert;
-     /* For OP_ONCE. -1 if not needed. */
+     /* For OP_ONCE. Less than 0 if not needed. */
      int framesize;
    } u;
    /* Points to our private memory word on the stack. */
 Line 283 
 typedef struct recurse_entry {
    /* Collects the calls until the function is not created. */
    jump_list *calls;
    /* Points to the starting opcode. */
-   int start;
+   sljit_sw start;
  } recurse_entry;
  typedef struct recurse_backtrack {
 Line 291 
 typedef struct recurse_backtrack {
    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 {
-Line 299 
 typedef struct compiler_common {
+Line 314 
 typedef struct compiler_common {
    /* First byte code. */
    pcre_uchar *start;
    /* Maps private data offset to each opcode. */
-   int *private_data_ptrs;
+   sljit_si *private_data_ptrs;
    /* Tells whether the capturing bracket is optimized. */
    pcre_uint8 *optimized_cbracket;
+   /* Tells whether the starting offset is a target of then. */
+   pcre_uint8 *then_offsets;
+   /* Current position where a THEN must jump. */
+   then_trap_backtrack *then_trap;
    /* Starting offset of private data for capturing brackets. */
    int cbra_ptr;
    /* Output vector starting point. Must be divisible by 2. */
-Line 330 
 typedef struct compiler_common {
+Line 349 
 typedef struct compiler_common {
    sljit_sw lcc;
    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
    int mode;
-   /* \K is in the pattern. */
+   /* \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 assert. */
+   /* Currently in recurse or negative assert. */
    BOOL local_exit;
+   /* Currently in a positive assert. */
+   BOOL positive_assert;
    /* Newline control. */
    int nltype;
    int newline;
-Line 346 
 typedef struct compiler_common {
+Line 371 
 typedef struct compiler_common {
    sljit_sw ctypes;
    int digits[2 + MAX_RANGE_SIZE];
    /* Named capturing brackets. */
-   sljit_uw name_table;
+   pcre_uchar *name_table;
    sljit_sw name_count;
    sljit_sw name_entry_size;
-Line 360 
 typedef struct compiler_common {
+Line 385 
 typedef struct compiler_common {
    recurse_entry *currententry;
    jump_list *partialmatch;
    jump_list *quit;
+   jump_list *positive_assert_quit;
    jump_list *forced_quit;
    jump_list *accept;
    jump_list *calllimit;
-Line 438 
 typedef struct compare_context {
+Line 464 
 typedef struct compare_context {
  #define STACK_TOP     SLJIT_SCRATCH_REG2
  #define STACK_LIMIT   SLJIT_SAVED_REG3
  #define ARGUMENTS     SLJIT_SAVED_EREG1
- #define CALL_COUNT    SLJIT_SAVED_EREG2
+ #define COUNT_MATCH   SLJIT_SAVED_EREG2
  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1
  /* Local space layout. */
-Line 449 
 typedef struct compare_context {
+Line 475 
 typedef struct compare_context {
  #define POSSESSIVE0      (2 * sizeof(sljit_sw))
  #define POSSESSIVE1      (3 * sizeof(sljit_sw))
  /* Max limit of recursions. */
- #define CALL_LIMIT       (4 * sizeof(sljit_sw))
+ #define LIMIT_MATCH      (4 * sizeof(sljit_sw))
  /* The output vector is stored on the stack, and contains pointers
  to characters. The vector data is divided into two groups: the first
  group contains the start / end character pointers, and the second is
  the start pointers when the end of the capturing group has not yet reached. */
  #define OVECTOR_START    (common->ovector_start)
- #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_sw))
+ #define OVECTOR(i)       (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw))
- #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * sizeof(sljit_sw))
+ #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))
  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
  #if defined COMPILE_PCRE8
-Line 509 
 return cc;
+Line 535 
 return cc;
  /* Functions whose might need modification for all new supported opcodes:
   next_opcode
-  get_private_data_length
+  check_opcode_types
   set_private_data_ptrs
   get_framesize
   init_frame
-  get_private_data_length_for_copy
+  get_private_data_copy_length
   copy_private_data
   compile_matchingpath
   compile_backtrackingpath
-Line 588 
 switch(*cc)
+Line 614 
 switch(*cc)
    case OP_SCBRAPOS:
    case OP_SCOND:
    case OP_CREF:
-   case OP_NCREF:
+   case OP_DNCREF:
    case OP_RREF:
-   case OP_NRREF:
+   case OP_DNRREF:
    case OP_DEF:
    case OP_BRAZERO:
    case OP_BRAMINZERO:
    case OP_BRAPOSZERO:
    case OP_PRUNE:
    case OP_SKIP:
+   case OP_THEN:
    case OP_COMMIT:
    case OP_FAIL:
    case OP_ACCEPT:
-Line 696 
 switch(*cc)
+Line 723 
 switch(*cc)
    case OP_MARK:
    case OP_PRUNE_ARG:
+   case OP_SKIP_ARG:
+   case OP_THEN_ARG:
    return cc + 1 + 2 + cc[1];
    default:
+   /* All opcodes are supported now! */
+   SLJIT_ASSERT_STOP();
    return NULL;
    }
  }
- #define CASE_ITERATOR_PRIVATE_DATA_1 \
+ static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
-     case OP_MINSTAR: \
-     case OP_MINPLUS: \
-     case OP_QUERY: \
-     case OP_MINQUERY: \
-     case OP_MINSTARI: \
-     case OP_MINPLUSI: \
-     case OP_QUERYI: \
-     case OP_MINQUERYI: \
-     case OP_NOTMINSTAR: \
-     case OP_NOTMINPLUS: \
-     case OP_NOTQUERY: \
-     case OP_NOTMINQUERY: \
-     case OP_NOTMINSTARI: \
-     case OP_NOTMINPLUSI: \
-     case OP_NOTQUERYI: \
-     case OP_NOTMINQUERYI:
- #define CASE_ITERATOR_PRIVATE_DATA_2A \
-     case OP_STAR: \
-     case OP_PLUS: \
-     case OP_STARI: \
-     case OP_PLUSI: \
-     case OP_NOTSTAR: \
-     case OP_NOTPLUS: \
-     case OP_NOTSTARI: \
-     case OP_NOTPLUSI:
- #define CASE_ITERATOR_PRIVATE_DATA_2B \
-     case OP_UPTO: \
-     case OP_MINUPTO: \
-     case OP_UPTOI: \
-     case OP_MINUPTOI: \
-     case OP_NOTUPTO: \
-     case OP_NOTMINUPTO: \
-     case OP_NOTUPTOI: \
-     case OP_NOTMINUPTOI:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
-     case OP_TYPEMINSTAR: \
-     case OP_TYPEMINPLUS: \
-     case OP_TYPEQUERY: \
-     case OP_TYPEMINQUERY:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
-     case OP_TYPESTAR: \
-     case OP_TYPEPLUS:
- #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
-     case OP_TYPEUPTO: \
-     case OP_TYPEMINUPTO:
- static int get_class_iterator_size(pcre_uchar *cc)
  {
- switch(*cc)
+ pcre_uchar *slot;
-   {
+ int i;
-   case OP_CRSTAR:
-   case OP_CRPLUS:
-   return 2;
-   case OP_CRMINSTAR:
-   case OP_CRMINPLUS:
-   case OP_CRQUERY:
-   case OP_CRMINQUERY:
-   return 1;
-   case OP_CRRANGE:
-   case OP_CRMINRANGE:
-   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
-     return 0;
-   return 2;
-   default:
-   return 0;
-   }
- }
- static int get_private_data_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
- {
- int private_data_length = 0;
- pcre_uchar *alternative;
- pcre_uchar *name;
- pcre_uchar *end = NULL;
- int space, size, i;
- pcre_uint32 bracketlen;
  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
    {
-   space = 0;
-   size = 0;
-   bracketlen = 0;
    switch(*cc)
      {
      case OP_SET_SOM:
-Line 808 
 while (cc < ccend)
+Line 755 
 while (cc < ccend)
      cc += 1 + IMM2_SIZE;
      break;
-     case OP_ASSERT:
-     case OP_ASSERT_NOT:
-     case OP_ASSERTBACK:
-     case OP_ASSERTBACK_NOT:
-     case OP_ONCE:
-     case OP_ONCE_NC:
-     case OP_BRAPOS:
-     case OP_SBRA:
-     case OP_SBRAPOS:
-     private_data_length += sizeof(sljit_sw);
-     bracketlen = 1 + LINK_SIZE;
-     break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     private_data_length += sizeof(sljit_sw);
      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
-     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
+     cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-Line 833 
 while (cc < ccend)
+Line 766 
 while (cc < ccend)
      /* Only AUTO_CALLOUT can insert this opcode. We do
         not intend to support this case. */
      if (cc[1 + LINK_SIZE] == OP_CALLOUT)
-       return -1;
+       return FALSE;
+     cc += 1 + LINK_SIZE;
-     if (*cc == OP_COND)
-       {
-       /* Might be a hidden SCOND. */
-       alternative = cc + GET(cc, 1);
-       if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
-         private_data_length += sizeof(sljit_sw);
-       }
-     else
-       private_data_length += sizeof(sljit_sw);
-     bracketlen = 1 + LINK_SIZE;
      break;
      case OP_CREF:
-Line 853 
 while (cc < ccend)
+Line 776 
 while (cc < ccend)
      cc += 1 + IMM2_SIZE;
      break;
-     case OP_NCREF:
+     case OP_DNCREF:
-     bracketlen = GET2(cc, 1);
+     i = GET2(cc, 1 + IMM2_SIZE);
-     name = (pcre_uchar *)common->name_table;
+     slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
-     alternative = name;
+     while (i-- > 0)
-     for (i = 0; i < common->name_count; i++)
        {
-       if (GET2(name, 0) == bracketlen) break;
+       common->optimized_cbracket[GET2(slot, 0)] = 0;
-       name += common->name_entry_size;
+       slot += common->name_entry_size;
        }
-     SLJIT_ASSERT(i != common->name_count);
+     cc += 1 + 2 * IMM2_SIZE;
-     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;
-     case OP_CBRA:
-     case OP_SCBRA:
-     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
-     break;
-     CASE_ITERATOR_PRIVATE_DATA_1
-     space = 1;
-     size = -2;
-     break;
-     CASE_ITERATOR_PRIVATE_DATA_2A
-     space = 2;
-     size = -2;
-     break;
-     CASE_ITERATOR_PRIVATE_DATA_2B
-     space = 2;
-     size = -(2 + IMM2_SIZE);
-     break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
-     space = 1;
-     size = 1;
-     break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
-     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
-       space = 2;
-     size = 1;
-     break;
-     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
-     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
-       space = 2;
-     size = 1 + IMM2_SIZE;
-     break;
-     case OP_CLASS:
-     case OP_NCLASS:
-     size += 1 + 32 / sizeof(pcre_uchar);
-     space = get_class_iterator_size(cc + size);
-     break;
- #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
-     case OP_XCLASS:
-     size = GET(cc, 1);
-     space = get_class_iterator_size(cc + size);
-     break;
- #endif
      case OP_RECURSE:
      /* Set its value only once. */
      if (common->recursive_head_ptr == 0)
-Line 947 
 while (cc < ccend)
+Line 806 
 while (cc < ccend)
      cc += 2 + 2 * LINK_SIZE;
      break;
+     case OP_THEN_ARG:
+     common->has_then = TRUE;
+     common->control_head_ptr = 1;
+     /* Fall through. */
      case OP_PRUNE_ARG:
      common->needs_start_ptr = TRUE;
-     common->control_head_ptr = 1;
      /* Fall through. */
      case OP_MARK:
-Line 961 
 while (cc < ccend)
+Line 824 
 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;
-     /* Fall through. */
+     cc += 1;
+     break;
-     case OP_COMMIT:
+     case OP_SKIP_ARG:
      common->control_head_ptr = 1;
-     cc += 1;
+     common->has_skip_arg = TRUE;
+     cc += 1 + 2 + cc[1];
      break;
      default:
      cc = next_opcode(common, cc);
      if (cc == NULL)
-       return -1;
+       return FALSE;
      break;
      }
+   }
+ return TRUE;
+ }
-   if (space > 0 && cc >= end)
+ static int get_class_iterator_size(pcre_uchar *cc)
-     private_data_length += sizeof(sljit_sw) * space;
+ {
+ switch(*cc)
+   {
+   case OP_CRSTAR:
+   case OP_CRPLUS:
+   return 2;
-   if (size != 0)
+   case OP_CRMINSTAR:
+   case OP_CRMINPLUS:
+   case OP_CRQUERY:
+   case OP_CRMINQUERY:
+   return 1;
+   case OP_CRRANGE:
+   case OP_CRMINRANGE:
+   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
+     return 0;
+   return 2;
+   default:
+   return 0;
+   }
+ }
+ static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
+ {
+ pcre_uchar *end = bracketend(begin);
+ pcre_uchar *next;
+ pcre_uchar *next_end;
+ pcre_uchar *max_end;
+ pcre_uchar type;
+ sljit_sw length = end - begin;
+ int min, max, i;
+ /* Detect fixed iterations first. */
+ if (end[-(1 + LINK_SIZE)] != OP_KET)
+   return FALSE;
+ /* Already detected repeat. */
+ if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)
+   return TRUE;
+ next = end;
+ min = 1;
+ while (1)
+   {
+   if (*next != *begin)
+     break;
+   next_end = bracketend(next);
+   if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)
+     break;
+   next = next_end;
+   min++;
+   }
+ if (min == 2)
+   return FALSE;
+ max = 0;
+ max_end = next;
+ if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)
+   {
+   type = *next;
+   while (1)
      {
-     if (size < 0)
+     if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
-       {
+       break;
-       cc += -size;
+     next_end = bracketend(next + 2 + LINK_SIZE);
- #ifdef SUPPORT_UTF
+     if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)
-       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+       break;
- #endif
+     next = next_end;
-       }
+     max++;
-     else
-       cc += size;
      }
-   if (bracketlen != 0)
+   if (next[0] == type && next[1] == *begin && max >= 1)
      {
-     if (cc >= end)
+     next_end = bracketend(next + 1);
+     if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)
        {
-       end = bracketend(cc);
+       for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
-       if (end[-1 - LINK_SIZE] == OP_KET)
+         if (*next_end != OP_KET)
-         end = NULL;
+           break;
+       if (i == max)
+         {
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
+         /* +2 the original and the last. */
+         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;
+         if (min == 1)
+           return TRUE;
+         min--;
+         max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);
+         }
        }
-     cc += bracketlen;
      }
    }
- return private_data_length;
+ if (min >= 3)
+   {
+   common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;
+   common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;
+   common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;
+   return TRUE;
+   }
+ return FALSE;
  }
- static void set_private_data_ptrs(compiler_common *common, int private_data_ptr, pcre_uchar *ccend)
+ #define CASE_ITERATOR_PRIVATE_DATA_1 \
+     case OP_MINSTAR: \
+     case OP_MINPLUS: \
+     case OP_QUERY: \
+     case OP_MINQUERY: \
+     case OP_MINSTARI: \
+     case OP_MINPLUSI: \
+     case OP_QUERYI: \
+     case OP_MINQUERYI: \
+     case OP_NOTMINSTAR: \
+     case OP_NOTMINPLUS: \
+     case OP_NOTQUERY: \
+     case OP_NOTMINQUERY: \
+     case OP_NOTMINSTARI: \
+     case OP_NOTMINPLUSI: \
+     case OP_NOTQUERYI: \
+     case OP_NOTMINQUERYI:
+ #define CASE_ITERATOR_PRIVATE_DATA_2A \
+     case OP_STAR: \
+     case OP_PLUS: \
+     case OP_STARI: \
+     case OP_PLUSI: \
+     case OP_NOTSTAR: \
+     case OP_NOTPLUS: \
+     case OP_NOTSTARI: \
+     case OP_NOTPLUSI:
+ #define CASE_ITERATOR_PRIVATE_DATA_2B \
+     case OP_UPTO: \
+     case OP_MINUPTO: \
+     case OP_UPTOI: \
+     case OP_MINUPTOI: \
+     case OP_NOTUPTO: \
+     case OP_NOTMINUPTO: \
+     case OP_NOTUPTOI: \
+     case OP_NOTMINUPTOI:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
+     case OP_TYPEMINSTAR: \
+     case OP_TYPEMINPLUS: \
+     case OP_TYPEQUERY: \
+     case OP_TYPEMINQUERY:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
+     case OP_TYPESTAR: \
+     case OP_TYPEPLUS:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
+     case OP_TYPEUPTO: \
+     case OP_TYPEMINUPTO:
+ static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)
  {
  pcre_uchar *cc = common->start;
  pcre_uchar *alternative;
  pcre_uchar *end = NULL;
+ int private_data_ptr = *private_data_start;
  int space, size, bracketlen;
  while (cc < ccend)
-Line 1020 
 while (cc < ccend)
+Line 1026 
 while (cc < ccend)
    space = 0;
    size = 0;
    bracketlen = 0;
+   if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
+     return;
+   if (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND)
+     if (detect_repeat(common, cc))
+       {
+       /* These brackets are converted to repeats, so no global
+       based single character repeat is allowed. */
+       if (cc >= end)
+         end = bracketend(cc);
+       }
    switch(*cc)
      {
+     case OP_KET:
+     if (common->private_data_ptrs[cc + 1 - common->start] != 0)
+       {
+       common->private_data_ptrs[cc - common->start] = private_data_ptr;
+       private_data_ptr += sizeof(sljit_sw);
+       cc += common->private_data_ptrs[cc + 1 - common->start];
+       }
+     cc += 1 + LINK_SIZE;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 1115 
 while (cc < ccend)
+Line 1143 
 while (cc < ccend)
      break;
      }
+   /* Character iterators, which are not inside a repeated bracket,
+      gets a private slot instead of allocating it on the stack. */
    if (space > 0 && cc >= end)
      {
      common->private_data_ptrs[cc - common->start] = private_data_ptr;
-Line 1145 
 while (cc < ccend)
+Line 1175 
 while (cc < ccend)
      cc += bracketlen;
      }
    }
+ *private_data_start = private_data_ptr;
  }
  /* 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) - (1 + LINK_SIZE);
  int length = 0;
  int possessive = 0;
  BOOL stack_restore = FALSE;
-Line 1159 
 BOOL setmark_found = recursive;
+Line 1189 
 BOOL setmark_found = recursive;
  /* The last capture is a local variable even for recursions. */
  BOOL capture_last_found = FALSE;
- if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
+ #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
+ SLJIT_ASSERT(common->control_head_ptr != 0);
+ *needs_control_head = TRUE;
+ #else
+ *needs_control_head = FALSE;
+ #endif
+ if (ccend == NULL)
    {
-   possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
+   ccend = bracketend(cc) - (1 + LINK_SIZE);
-   /* This is correct regardless of common->capture_last_ptr. */
+   if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
-   capture_last_found = TRUE;
+     {
+     possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
+     /* This is correct regardless of common->capture_last_ptr. */
+     capture_last_found = TRUE;
+     }
+   cc = next_opcode(common, cc);
    }
- cc = next_opcode(common, cc);
  SLJIT_ASSERT(cc != NULL);
  while (cc < ccend)
    switch(*cc)
-Line 1184 
 while (cc < ccend)
+Line 1225 
 while (cc < ccend)
      case OP_MARK:
      case OP_PRUNE_ARG:
+     case OP_THEN_ARG:
      SLJIT_ASSERT(common->mark_ptr != 0);
      stack_restore = TRUE;
      if (!setmark_found)
-Line 1191 
 while (cc < ccend)
+Line 1233 
 while (cc < ccend)
        length += 2;
        setmark_found = TRUE;
        }
+     if (common->control_head_ptr != 0)
+       *needs_control_head = TRUE;
      cc += 1 + 2 + cc[1];
      break;
-Line 1310 
 if (length > 0)
+Line 1354 
 if (length > 0)
  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) - (1 + LINK_SIZE);
  BOOL setsom_found = recursive;
  BOOL setmark_found = recursive;
  /* The last capture is a local variable even for recursions. */
-Line 1325 
 SLJIT_UNUSED_ARG(stacktop);
+Line 1368 
 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 1347 
 while (cc < ccend)
+Line 1395 
 while (cc < ccend)
      case OP_MARK:
      case OP_PRUNE_ARG:
+     case OP_THEN_ARG:
      SLJIT_ASSERT(common->mark_ptr != 0);
      if (!setmark_found)
        {
-Line 1427 
 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), st
+Line 1476 
 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), st
  SLJIT_ASSERT(stackpos == STACK(stacktop));
  }
- static SLJIT_INLINE int get_private_data_length_for_copy(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
+ static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)
  {
- int private_data_length = common->control_head_ptr ? 3 : 2;
+ int private_data_length = needs_control_head ? 3 : 2;
  int size;
  pcre_uchar *alternative;
  /* Calculate the sum of the private machine words. */
-Line 1438 
 while (cc < ccend)
+Line 1487 
 while (cc < ccend)
    size = 0;
    switch(*cc)
      {
+     case OP_KET:
+     if (PRIVATE_DATA(cc) != 0)
+       private_data_length++;
+     cc += 1 + LINK_SIZE;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 1542 
 return private_data_length;
+Line 1597 
 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 1563 
 stacktop = STACK(stacktop - 1);
+Line 1618 
 stacktop = STACK(stacktop - 1);
  if (!save)
    {
-   stackptr += (common->control_head_ptr ? 2 : 1) * 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 1588 
 do
+Line 1643 
 do
      SLJIT_ASSERT(save && common->recursive_head_ptr != 0);
      count = 1;
      srcw[0] = common->recursive_head_ptr;
-     if (common->control_head_ptr != 0)
+     if (needs_control_head)
        {
+       SLJIT_ASSERT(common->control_head_ptr != 0);
        count = 2;
        srcw[1] = common->control_head_ptr;
        }
-Line 1605 
 do
+Line 1661 
 do
      switch(*cc)
        {
+       case OP_KET:
+       if (PRIVATE_DATA(cc) != 0)
+         {
+         count = 1;
+         srcw[0] = PRIVATE_DATA(cc);
+         }
+       cc += 1 + LINK_SIZE;
+       break;
        case OP_ASSERT:
        case OP_ASSERT_NOT:
        case OP_ASSERTBACK:
-Line 1851 
 if (save)
+Line 1916 
 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 1914 
 while (list_item)
+Line 2012 
 while (list_item)
  common->stubs = NULL;
  }
- static SLJIT_INLINE void decrease_call_count(compiler_common *common)
+ static SLJIT_INLINE void count_match(compiler_common *common)
  {
  DEFINE_COMPILER;
- OP2(SLJIT_SUB | SLJIT_SET_E, CALL_COUNT, 0, CALL_COUNT, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_SUB | SLJIT_SET_E, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);
  add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));
  }
-Line 1998 
 else
+Line 2096 
 else
  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);
- SLJIT_ASSERT(common->control_head_ptr != 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, 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 do_check_control_chain(sljit_sw *current)
+ static sljit_sw SLJIT_CALL do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)
  {
- sljit_sw return_value = 0;
+ while (current != NULL)
- SLJIT_ASSERT(current != NULL);
- do
    {
    switch (current[-2])
      {
-     case type_commit:
+     case type_then_trap:
-     /* Commit overwrites all. */
-     return -1;
-     case type_prune:
      break;
-     case type_skip:
+     case type_mark:
-     /* Overwrites prune, but not other skips. */
+     if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[-3]) == 0)
-     if (return_value == 0)
+       return current[-4];
-       return_value = current[-3];
      break;
      default:
-Line 2033 
 do
+Line 2123 
 do
      }
    current = (sljit_sw*)current[-1];
    }
- while (current != NULL);
+ return -1;
- return return_value;
  }
  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
-Line 2106 
 OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJI
+Line 2195 
 OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJI
  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));
  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 + sizeof(sljit_sw)), SLJIT_SAVED_REG1, 0);
+ 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
-Line 2274 
 return (bit < 256) ? ((0 << 8) | bit) :
+Line 2363 
 return (bit < 256) ? ((0 << 8) | bit) :
  static void check_partial(compiler_common *common, BOOL force)
  {
- /* Checks whether a partial matching is occured. Does not modify registers. */
+ /* Checks whether a partial matching is occurred. Does not modify registers. */
  DEFINE_COMPILER;
  struct sljit_jump *jump = NULL;
-Line 4217 
 while (*cc != XCL_END)
+Line 4306 
 while (*cc != XCL_END)
        case PT_SPACE:
        case PT_PXSPACE:
-       if (*cc == PT_SPACE)
-         {
-         OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
-         jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 11 - charoffset);
-         }
        SET_CHAR_OFFSET(9);
        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 13 - 9);
        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);
-Line 5193 
 if (!minimize)
+Line 5275 
 if (!minimize)
    JUMPHERE(zerolength);
    BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
-   decrease_call_count(common);
+   count_match(common);
    return cc;
    }
-Line 5232 
 if (jump != NULL)
+Line 5314 
 if (jump != NULL)
    JUMPHERE(jump);
  JUMPHERE(zerolength);
- decrease_call_count(common);
+ count_match(common);
  return cc;
  }
-Line 5242 
 DEFINE_COMPILER;
+Line 5324 
 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, TRUE) == no_stack)
+ 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);
-Line 5408 
 static pcre_uchar *compile_assert_matchi
+Line 5491 
 static pcre_uchar *compile_assert_matchi
  DEFINE_COMPILER;
  int framesize;
  int extrasize;
- BOOL needs_control_head = common->control_head_ptr != 0;
+ BOOL needs_control_head;
  int private_data_ptr;
  backtrack_common altbacktrack;
  pcre_uchar *ccbegin;
-Line 5418 
 jump_list *tmp = NULL;
+Line 5501 
 jump_list *tmp = NULL;
  jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
  jump_list **found;
  /* Saving previous accept variables. */
+ BOOL save_local_exit = common->local_exit;
+ 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;
- BOOL save_local_exit = common->local_exit;
  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 5434 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 5523 
 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 5454 
 if (bra == OP_BRAMINZERO)
+Line 5543 
 if (bra == OP_BRAMINZERO)
  if (framesize < 0)
    {
    extrasize = needs_control_head ? 2 : 1;
-   if (framesize != no_stack)
+   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)
-Line 5484 
 else
+Line 5573 
 else
      }
    else
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
-   init_frame(common, ccbegin, framesize + extrasize - 1, extrasize, FALSE);
+   init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);
    }
  memset(&altbacktrack, 0, sizeof(backtrack_common));
- common->local_exit = TRUE;
+ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
- common->quit_label = NULL;
+   {
- 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->accept_label = NULL;
-Line 5505 
 while (1)
+Line 5603 
 while (1)
    compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
-     common->local_exit = save_local_exit;
+     if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
-     common->quit_label = save_quit_label;
+       {
+       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->quit = save_quit;
+     common->positive_assert_quit = save_positive_assert_quit;
      common->accept = save_accept;
      return NULL;
      }
-Line 5519 
 while (1)
+Line 5623 
 while (1)
    /* Reset stack. */
    if (framesize < 0)
      {
-     if (framesize != no_stack)
+     if (framesize == no_frame)
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
      else
        free_stack(common, extrasize);
-Line 5573 
 while (1)
+Line 5677 
 while (1)
    compile_backtrackingpath(common, altbacktrack.top);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
-     common->local_exit = save_local_exit;
+     if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
-     common->quit_label = save_quit_label;
+       {
+       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->quit = save_quit;
+     common->positive_assert_quit = save_positive_assert_quit;
      common->accept = save_accept;
      return NULL;
      }
-Line 5589 
 while (1)
+Line 5699 
 while (1)
    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)
    {
    jump = JUMP(SLJIT_JUMP);
-   set_jumps(common->quit, LABEL());
+   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));
-Line 5753 
 else
+Line 5870 
 else
      }
    }
- common->local_exit = save_local_exit;
+ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
- common->quit_label = save_quit_label;
+   {
+   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->quit = save_quit;
+ common->positive_assert_quit = save_positive_assert_quit;
  common->accept = save_accept;
  return cc + 1 + LINK_SIZE;
  }
- static sljit_sw SLJIT_CALL do_searchovector(sljit_uw refno, sljit_sw* locals, pcre_uchar *name_table)
+ 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)
  {
- int condition = FALSE;
+ DEFINE_COMPILER;
- pcre_uchar *slotA = name_table;
+ int stacksize;
- pcre_uchar *slotB;
- sljit_sw name_count = locals[LOCALS0 / sizeof(sljit_sw)];
- sljit_sw name_entry_size = locals[LOCALS1 / sizeof(sljit_sw)];
- sljit_sw no_capture;
- int i;
- locals += refno & 0xff;
- refno >>= 8;
- no_capture = locals[1];
- for (i = 0; i < name_count; i++)
+ if (framesize < 0)
    {
-   if (GET2(slotA, 0) == refno) break;
+   if (framesize == no_frame)
-   slotA += name_entry_size;
+     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 (i < name_count)
+   if (needs_control_head)
-   {
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (ket != OP_KET || has_alternatives) ? sizeof(sljit_sw) : 0);
-   /* Found a name for the number - there can be only one; duplicate names
-   for different numbers are allowed, but not vice versa. First scan down
-   for duplicates. */
-   slotB = slotA;
+   /* TMP2 which is set here used by OP_KETRMAX below. */
-   while (slotB > name_table)
+   if (ket == OP_KETRMAX)
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
+   else if (ket == OP_KETRMIN)
      {
-     slotB -= name_entry_size;
+     /* Move the STR_PTR to the private_data_ptr. */
-     if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), 0);
-       {
-       condition = locals[GET2(slotB, 0) << 1] != no_capture;
-       if (condition) break;
-       }
-     else break;
      }
+   }
+ 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);
-   /* Scan up for duplicates */
+   if (ket == OP_KETRMAX)
-   if (!condition)
      {
-     slotB = slotA;
+     /* TMP2 which is set here used by OP_KETRMAX below. */
-     for (i++; i < name_count; i++)
+     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-       {
-       slotB += name_entry_size;
-       if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
-         {
-         condition = locals[GET2(slotB, 0) << 1] != no_capture;
-         if (condition) break;
-         }
-       else break;
-       }
      }
    }
- return condition;
+ if (needs_control_head)
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP1, 0);
  }
- static sljit_sw SLJIT_CALL do_searchgroups(sljit_uw recno, sljit_uw* locals, pcre_uchar *name_table)
+ static SLJIT_INLINE int match_capture_common(compiler_common *common, int stacksize, int offset, int private_data_ptr)
  {
- int condition = FALSE;
+ DEFINE_COMPILER;
- pcre_uchar *slotA = name_table;
- pcre_uchar *slotB;
- sljit_uw name_count = locals[LOCALS0 / sizeof(sljit_sw)];
- sljit_uw name_entry_size = locals[LOCALS1 / sizeof(sljit_sw)];
- sljit_uw group_num = locals[POSSESSIVE0 / sizeof(sljit_sw)];
- sljit_uw i;
- for (i = 0; i < name_count; i++)
+ if (common->capture_last_ptr != 0)
    {
-   if (GET2(slotA, 0) == recno) break;
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
-   slotA += name_entry_size;
+   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)
- if (i < name_count)
    {
-   /* Found a name for the number - there can be only one; duplicate
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
-   names for different numbers are allowed, but not vice versa. First
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
-   scan down for duplicates. */
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-   slotB = slotA;
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
-   while (slotB > name_table)
+   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);
-     slotB -= name_entry_size;
+   stacksize += 2;
-     if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
-       {
-       condition = GET2(slotB, 0) == group_num;
-       if (condition) break;
-       }
-     else break;
-     }
-   /* Scan up for duplicates */
-   if (!condition)
-     {
-     slotB = slotA;
-     for (i++; i < name_count; i++)
-       {
-       slotB += name_entry_size;
-       if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
-         {
-         condition = GET2(slotB, 0) == group_num;
-         if (condition) break;
-         }
-       else break;
-       }
-     }
    }
- return condition;
+ return stacksize;
  }
  /*
-Line 5932 
 backtrack_common *backtrack;
+Line 6016 
 backtrack_common *backtrack;
  pcre_uchar opcode;
  int private_data_ptr = 0;
  int offset = 0;
- int stacksize;
+ int i, stacksize;
+ int repeat_ptr = 0, repeat_length = 0;
+ int repeat_type = 0, repeat_count = 0;
  pcre_uchar *ccbegin;
  pcre_uchar *matchingpath;
+ pcre_uchar *slot;
  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;
+ struct sljit_label *rmax_label = NULL;
- struct sljit_jump *braminzerojump = NULL;
+ struct sljit_jump *braminzero = NULL;
  PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
-Line 5955 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 6043 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
  opcode = *cc;
  ccbegin = cc;
- matchingpath = ccbegin + 1 + LINK_SIZE;
+ matchingpath = bracketend(cc) - 1 - LINK_SIZE;
+ ket = *matchingpath;
+ if (ket == OP_KET && PRIVATE_DATA(matchingpath) != 0)
+   {
+   repeat_ptr = PRIVATE_DATA(matchingpath);
+   repeat_length = PRIVATE_DATA(matchingpath + 1);
+   repeat_type = PRIVATE_DATA(matchingpath + 2);
+   repeat_count = PRIVATE_DATA(matchingpath + 3);
+   SLJIT_ASSERT(repeat_length != 0 && repeat_type != 0 && repeat_count != 0);
+   if (repeat_type == OP_UPTO)
+     ket = OP_KETRMAX;
+   if (repeat_type == OP_MINUPTO)
+     ket = OP_KETRMIN;
+   }
  if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
    {
    /* Drop this bracket_backtrack. */
    parent->top = backtrack->prev;
-   return bracketend(cc);
+   return matchingpath + 1 + LINK_SIZE + repeat_length;
    }
- ket = *(bracketend(cc) - 1 - LINK_SIZE);
+ matchingpath = ccbegin + 1 + LINK_SIZE;
  SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);
  SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));
  cc += GET(cc, 1);
  has_alternatives = *cc == OP_ALT;
- if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
+ if (SLJIT_UNLIKELY(opcode == OP_COND || opcode == OP_SCOND))
-   {
+   has_alternatives = (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF) ? FALSE : TRUE;
-   has_alternatives = (*matchingpath == OP_RREF) ? FALSE : TRUE;
-   if (*matchingpath == OP_NRREF)
-     {
-     stacksize = GET2(matchingpath, 1);
-     if (common->currententry == NULL || stacksize == RREF_ANY)
-       has_alternatives = FALSE;
-     else if (common->currententry->start == 0)
-       has_alternatives = stacksize != 0;
-     else
-       has_alternatives = stacksize != (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
-     }
-   }
  if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
    opcode = OP_SCOND;
-Line 6014 
 else if (opcode == OP_ONCE || opcode ==
+Line 6103 
 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 6028 
 if (stacksize > 0)
+Line 6117 
 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 6044 
 if (bra == OP_BRAMINZERO)
+Line 6133 
 if (bra == OP_BRAMINZERO)
    if (ket != OP_KETRMIN)
      {
      free_stack(common, 1);
-     braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
+     braminzero = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
      }
    else
      {
-Line 6059 
 if (bra == OP_BRAMINZERO)
+Line 6148 
 if (bra == OP_BRAMINZERO)
        if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
          {
          /* When we come from outside, private_data_ptr contains the previous STR_PTR. */
-         braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
+         braminzero = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
          }
        else
          {
          /* Except when the whole stack frame must be saved. */
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
-         braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (BACKTRACK_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw));
+         braminzero = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (BACKTRACK_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw));
          }
        JUMPHERE(skip);
        }
-Line 6078 
 if (bra == OP_BRAMINZERO)
+Line 6167 
 if (bra == OP_BRAMINZERO)
      }
    }
+ if (repeat_type != 0)
+   {
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, repeat_count);
+   if (repeat_type == OP_EXACT)
+     rmax_label = LABEL();
+   }
  if (ket == OP_KETRMIN)
    BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
  if (ket == OP_KETRMAX)
    {
-   rmaxlabel = LABEL();
+   rmax_label = LABEL();
-   if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA)
+   if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA && repeat_type == 0)
-     BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmaxlabel;
+     BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmax_label;
    }
  /* 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)
-Line 6180 
 if (opcode == OP_COND || opcode == OP_SC
+Line 6309 
 if (opcode == OP_COND || opcode == OP_SC
        CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
      matchingpath += 1 + IMM2_SIZE;
      }
-   else if (*matchingpath == OP_NCREF)
+   else if (*matchingpath == OP_DNCREF)
      {
      SLJIT_ASSERT(has_alternatives);
-     stacksize = GET2(matchingpath, 1);
-     jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(stacksize << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
-     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_SCRATCH_REG1, 0, SLJIT_IMM, (stacksize << 8) | (common->ovector_start / sizeof(sljit_sw)));
-     GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, 0);
-     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_SCRATCH_REG1, 0, SLJIT_IMM, 0));
-     JUMPHERE(jump);
+     i = GET2(matchingpath, 1 + IMM2_SIZE);
-     matchingpath += 1 + IMM2_SIZE;
+     slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
+     OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
+     OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
+     slot += common->name_entry_size;
+     i--;
+     while (i-- > 0)
+       {
+       OP2(SLJIT_SUB, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
+       OP2(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, STR_PTR, 0);
+       slot += common->name_entry_size;
+       }
+     OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
+     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), JUMP(SLJIT_C_ZERO));
+     matchingpath += 1 + 2 * IMM2_SIZE;
      }
-   else if (*matchingpath == OP_RREF || *matchingpath == OP_NRREF)
+   else if (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF)
      {
      /* Never has other case. */
      BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;
+     SLJIT_ASSERT(!has_alternatives);
-     stacksize = GET2(matchingpath, 1);
+     if (*matchingpath == OP_RREF)
-     if (common->currententry == NULL)
-       stacksize = 0;
-     else if (stacksize == RREF_ANY)
-       stacksize = 1;
-     else if (common->currententry->start == 0)
-       stacksize = stacksize == 0;
-     else
-       stacksize = stacksize == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
-     if (*matchingpath == OP_RREF || stacksize || common->currententry == NULL)
        {
-       SLJIT_ASSERT(!has_alternatives);
+       stacksize = GET2(matchingpath, 1);
+       if (common->currententry == NULL)
+         stacksize = 0;
+       else if (stacksize == RREF_ANY)
+         stacksize = 1;
+       else if (common->currententry->start == 0)
+         stacksize = stacksize == 0;
+       else
+         stacksize = stacksize == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
        if (stacksize != 0)
          matchingpath += 1 + IMM2_SIZE;
+       }
+     else
+       {
+       if (common->currententry == NULL || common->currententry->start == 0)
+         stacksize = 0;
        else
          {
+         stacksize = GET2(matchingpath, 1 + IMM2_SIZE);
+         slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
+         i = (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
+         while (stacksize > 0)
+           {
+           if (GET2(slot, 0) == i)
+             break;
+           slot += common->name_entry_size;
+           stacksize--;
+           }
+         }
+       if (stacksize != 0)
+         matchingpath += 1 + 2 * IMM2_SIZE;
+       }
+       /* The stacksize == 0 is a common "else" case. */
+       if (stacksize == 0)
+         {
          if (*cc == OP_ALT)
            {
            matchingpath = cc + 1 + LINK_SIZE;
-Line 6229 
 if (opcode == OP_COND || opcode == OP_SC
+Line 6384 
 if (opcode == OP_COND || opcode == OP_SC
          else
            matchingpath = cc;
          }
-       }
-     else
-       {
-       SLJIT_ASSERT(has_alternatives);
-       stacksize = GET2(matchingpath, 1);
-       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_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, GET2(common->start, common->currententry->start + 1 + LINK_SIZE));
-       OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, stacksize);
-       GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, 0);
-       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_SCRATCH_REG1, 0, SLJIT_IMM, 0));
-       matchingpath += 1 + IMM2_SIZE;
-       }
      }
    else
      {
-Line 6267 
 if (SLJIT_UNLIKELY(sljit_get_compiler_er
+Line 6404 
 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 (repeat_type == OP_MINUPTO)
+   {
+   /* We need to preserve the counter. TMP2 will be used below. */
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);
+   stacksize++;
+   }
  if (ket != OP_KET || bra != OP_BRA)
    stacksize++;
  if (offset != 0)
-Line 6309 
 if (stacksize > 0)
+Line 6429 
 if (stacksize > 0)
    allocate_stack(common, stacksize);
  stacksize = 0;
+ if (repeat_type == OP_MINUPTO)
+   {
+   /* TMP2 was set above. */
+   OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
+   stacksize++;
+   }
  if (ket != OP_KET || bra != OP_BRA)
    {
    if (ket != OP_KET)
-Line 6319 
 if (ket != OP_KET || bra != OP_BRA)
+Line 6446 
 if (ket != OP_KET || bra != OP_BRA)
    }
  if (offset != 0)
-   {
+   stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);
-   if (common->capture_last_ptr != 0)
-     {
-     OP1(SLJIT_MOV, TMP2, 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), TMP2, 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;
-     }
-   }
  if (has_alternatives)
    {
-Line 6357 
 if (offset != 0 && common->optimized_cbr
+Line 6465 
 if (offset != 0 && common->optimized_cbr
  if (ket == OP_KETRMAX)
    {
-   if (opcode == OP_ONCE || opcode >= OP_SBRA)
+   if (repeat_type != 0)
+     {
+     if (has_alternatives)
+       BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
+     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
+     JUMPTO(SLJIT_C_NOT_ZERO, rmax_label);
+     /* Drop STR_PTR for greedy plus quantifier. */
+     if (opcode != OP_ONCE)
+       free_stack(common, 1);
+     }
+   else if (opcode == OP_ONCE || opcode >= OP_SBRA)
      {
      if (has_alternatives)
        BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
      /* Checking zero-length iteration. */
      if (opcode != OP_ONCE)
        {
-       CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STR_PTR, 0, rmaxlabel);
+       CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STR_PTR, 0, rmax_label);
        /* Drop STR_PTR for greedy plus quantifier. */
        if (bra != OP_BRAZERO)
          free_stack(common, 1);
        }
      else
        /* TMP2 must contain the starting STR_PTR. */
-       CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmaxlabel);
+       CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmax_label);
      }
    else
-     JUMPTO(SLJIT_JUMP, rmaxlabel);
+     JUMPTO(SLJIT_JUMP, rmax_label);
    BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
    }
+ if (repeat_type == OP_EXACT)
+   {
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
+   JUMPTO(SLJIT_C_NOT_ZERO, rmax_label);
+   }
+ else if (repeat_type == OP_UPTO)
+   {
+   /* We need to preserve the counter. */
+   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);
+   allocate_stack(common, 1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+   }
  if (bra == OP_BRAZERO)
    BACKTRACK_AS(bracket_backtrack)->zero_matchingpath = LABEL();
-Line 6385 
 if (bra == OP_BRAMINZERO)
+Line 6516 
 if (bra == OP_BRAMINZERO)
    {
    /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */
    JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->matchingpath);
-   if (braminzerojump != NULL)
+   if (braminzero != NULL)
      {
-     JUMPHERE(braminzerojump);
+     JUMPHERE(braminzero);
      /* We need to release the end pointer to perform the
      backtrack for the zero-length iteration. When
      framesize is < 0, OP_ONCE will do the release itself. */
-Line 6403 
 if (bra == OP_BRAMINZERO)
+Line 6534 
 if (bra == OP_BRAMINZERO)
    }
  if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)
-   decrease_call_count(common);
+   count_match(common);
  /* Skip the other alternatives. */
  while (*cc == OP_ALT)
    cc += GET(cc, 1);
  cc += 1 + LINK_SIZE;
- return cc;
+ /* 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 + repeat_length;
  }
  static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
-Line 6419 
 backtrack_common *backtrack;
+Line 6554 
 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 6462 
 switch(opcode)
+Line 6598 
 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)
    {
-Line 6475 
 if (framesize < 0)
+Line 6611 
 if (framesize < 0)
    else
      stacksize = 1;
+   if (needs_control_head)
+     stacksize++;
    if (!zero)
      stacksize++;
-Line 6483 
 if (framesize < 0)
+Line 6621 
 if (framesize < 0)
    if (framesize == no_frame)
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
+   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);
    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 (offset != 0)
-Line 6602 
 while (*cc != OP_KETRPOS)
+Line 6768 
 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 6638 
 while (*cc != OP_KETRPOS)
+Line 6808 
 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 6649 
 if (!zero)
+Line 6821 
 if (!zero)
  /* None of them matched. */
  set_jumps(emptymatch, LABEL());
- decrease_call_count(common);
+ count_match(common);
  return cc + 1 + LINK_SIZE;
  }
-Line 6959 
 switch(opcode)
+Line 7131 
 switch(opcode)
    break;
    }
- decrease_call_count(common);
+ count_match(common);
  return end;
  }
-Line 7026 
 if (!optimized_cbracket)
+Line 7198 
 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 7210 
 while (cc < ccend)
+Line 7458 
 while (cc < ccend)
        }
      BACKTRACK_AS(braminzero_backtrack)->matchingpath = LABEL();
      if (cc[1] > OP_ASSERTBACK_NOT)
-       decrease_call_count(common);
+       count_match(common);
      break;
      case OP_ONCE:
-Line 7246 
 while (cc < ccend)
+Line 7494 
 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_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);
-     /* Fall through. */
      case OP_PRUNE:
-     case OP_COMMIT:
+     case OP_PRUNE_ARG:
-     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
-     SLJIT_ASSERT(common->control_head_ptr != 0);
-     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
-     allocate_stack(common, 2);
-     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, *cc == OP_COMMIT ? type_commit : type_prune);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
-     cc += (*cc == OP_PRUNE_ARG) ? (1 + 2 + cc[1]) : 1;
-     break;
      case OP_SKIP:
-     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
+     case OP_SKIP_ARG:
-     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
+     case OP_THEN:
-     allocate_stack(common, 3);
+     case OP_THEN_ARG:
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0);
+     case OP_COMMIT:
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, type_skip);
+     cc = compile_control_verb_matchingpath(common, cc, parent);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), STR_PTR, 0);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
-     cc += 1;
      break;
      case OP_FAIL:
-Line 7306 
 while (cc < ccend)
+Line 7543 
 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 7467 
 switch(opcode)
+Line 7713 
 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 7489 
 set_jumps(current->topbacktracks, LABEL(
+Line 7735 
 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;
-Line 7585 
 if (bra == OP_BRAZERO)
+Line 7831 
 if (bra == OP_BRAZERO)
  static void compile_bracket_backtrackingpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
- int opcode;
+ int opcode, stacksize, count;
  int offset = 0;
  int private_data_ptr = CURRENT_AS(bracket_backtrack)->private_data_ptr;
- int stacksize;
+ int repeat_ptr = 0, repeat_type = 0, repeat_count = 0;
- int count;
  pcre_uchar *cc = current->cc;
  pcre_uchar *ccbegin;
  pcre_uchar *ccprev;
-Line 7599 
 pcre_uchar bra = OP_BRA;
+Line 7844 
 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;
- struct sljit_label *rminlabel = NULL;
+ struct sljit_label *rmin_label = NULL;
+ struct sljit_label *exact_label = NULL;
  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
    {
-Line 7611 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 7858 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
    }
  opcode = *cc;
+ ccbegin = bracketend(cc) - 1 - LINK_SIZE;
+ ket = *ccbegin;
+ if (ket == OP_KET && PRIVATE_DATA(ccbegin) != 0)
+   {
+   repeat_ptr = PRIVATE_DATA(ccbegin);
+   repeat_type = PRIVATE_DATA(ccbegin + 2);
+   repeat_count = PRIVATE_DATA(ccbegin + 3);
+   SLJIT_ASSERT(repeat_type != 0 && repeat_count != 0);
+   if (repeat_type == OP_UPTO)
+     ket = OP_KETRMAX;
+   if (repeat_type == OP_MINUPTO)
+     ket = OP_KETRMIN;
+   }
  ccbegin = cc;
- ket = *(bracketend(ccbegin) - 1 - LINK_SIZE);
  cc += GET(cc, 1);
  has_alternatives = *cc == OP_ALT;
  if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
-Line 7624 
 if (SLJIT_UNLIKELY(opcode == OP_COND) &&
+Line 7883 
 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_KET && repeat_type != 0)
+   {
+   /* TMP1 is used in OP_KETRMIN below. */
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+   free_stack(common, 1);
+   if (repeat_type == OP_UPTO)
+     OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0, SLJIT_IMM, 1);
+   else
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0);
+   }
  if (ket == OP_KETRMAX)
    {
    if (bra == OP_BRAZERO)
-Line 7638 
 else if (ket == OP_KETRMIN)
+Line 7915 
 else if (ket == OP_KETRMIN)
    if (bra != OP_BRAMINZERO)
      {
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-     if (opcode >= OP_SBRA || opcode == OP_ONCE)
+     if (repeat_type != 0)
+       {
+       /* TMP1 was set a few lines above. */
+       CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
+       /* Drop STR_PTR for non-greedy plus quantifier. */
+       if (opcode != OP_ONCE)
+         free_stack(common, 1);
+       }
+     else if (opcode >= OP_SBRA || opcode == OP_ONCE)
        {
        /* Checking zero-length iteration. */
        if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)
-Line 7648 
 else if (ket == OP_KETRMIN)
+Line 7933 
 else if (ket == OP_KETRMIN)
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
          CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (CURRENT_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw), CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
          }
+       /* Drop STR_PTR for non-greedy plus quantifier. */
        if (opcode != OP_ONCE)
          free_stack(common, 1);
        }
      else
        JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
      }
-   rminlabel = LABEL();
+   rmin_label = LABEL();
+   if (repeat_type != 0)
+     OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
    }
  else if (bra == OP_BRAZERO)
    {
-Line 7662 
 else if (bra == OP_BRAZERO)
+Line 7950 
 else if (bra == OP_BRAZERO)
    free_stack(common, 1);
    brazero = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
    }
+ else if (repeat_type == OP_EXACT)
+   {
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
+   exact_label = LABEL();
+   }
  if (offset != 0)
    {
-Line 7781 
 if (has_alternatives)
+Line 8074 
 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)))
          return;
        }
-     /* Instructions after the current alternative is succesfully matched. */
+     /* Instructions after the current alternative is successfully 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 (repeat_type == OP_MINUPTO)
+       {
+       /* We need to preserve the counter. TMP2 will be used below. */
+       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);
+       stacksize++;
+       }
      if (ket != OP_KET || bra != OP_BRA)
        stacksize++;
      if (offset != 0)
-Line 7837 
 if (has_alternatives)
+Line 8120 
 if (has_alternatives)
      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);
-         allocate_stack(common, stacksize);
-       else
-         {
-         /* We know we have place at least for one item on the top of the stack. */
-         SLJIT_ASSERT(stacksize == 1);
-         OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
-         }
-     }
      stacksize = 0;
+     if (repeat_type == OP_MINUPTO)
+       {
+       /* TMP2 was set above. */
+       OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
+       stacksize++;
+       }
      if (ket != OP_KET || bra != OP_BRA)
        {
        if (ket != OP_KET)
-Line 7859 
 if (has_alternatives)
+Line 8141 
 if (has_alternatives)
        }
      if (offset != 0)
-       {
+       stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);
-       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;
-         }
-       }
      if (opcode != OP_ONCE)
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, count++);
-Line 7951 
 else if (opcode == OP_SBRA || opcode ==
+Line 8214 
 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 7976 
 else if (opcode == OP_ONCE)
+Line 8241 
 else if (opcode == OP_ONCE)
      }
    }
- if (ket == OP_KETRMAX)
+ if (repeat_type == OP_EXACT)
+   {
+   OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0);
+   CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, repeat_count, exact_label);
+   }
+ else if (ket == OP_KETRMAX)
    {
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    if (bra != OP_BRAZERO)
      free_stack(common, 1);
    CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
    if (bra == OP_BRAZERO)
      {
-Line 7999 
 else if (ket == OP_KETRMIN)
+Line 8271 
 else if (ket == OP_KETRMIN)
    affect badly the free_stack(2) above. */
    if (opcode != OP_ONCE)
      free_stack(common, 1);
-   CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rminlabel);
+   CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rmin_label);
    if (opcode == OP_ONCE)
      free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);
    else if (bra == OP_BRAMINZERO)
-Line 8013 
 else if (bra == OP_BRAZERO)
+Line 8285 
 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 8052 
 if (current->topbacktracks)
+Line 8324 
 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 8076 
 else
+Line 8348 
 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);
+     CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), -(int)(2 * sizeof(sljit_sw)), TMP1, 0, loop);
+     CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), -(int)(3 * sizeof(sljit_sw)), TMP2, 0, loop);
+     add_jump(compiler, &common->then_trap->quit, JUMP(SLJIT_JUMP));
+     return;
+     }
+   else if (common->positive_assert)
+     {
+     add_jump(compiler, &common->positive_assert_quit, JUMP(SLJIT_JUMP));
+     return;
+     }
+   }
+ if (common->local_exit)
+   {
+   if (common->quit_label == NULL)
+     add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
+   else
+     JUMPTO(SLJIT_JUMP, common->quit_label);
+   return;
+   }
+ if (opcode == OP_SKIP_ARG)
+   {
+   SLJIT_ASSERT(common->control_head_ptr != 0);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
+   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, (sljit_sw)(current->cc + 2));
+   sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_search_mark));
+   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
+   OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
+   add_jump(compiler, &common->reset_match, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, -1));
+   return;
+   }
+ if (opcode == OP_SKIP)
+   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+ else
+   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_IMM, 0);
+ add_jump(compiler, &common->reset_match, JUMP(SLJIT_JUMP));
+ }
+ static SLJIT_INLINE void compile_then_trap_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+ {
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ int size;
+ if (CURRENT_AS(then_trap_backtrack)->then_trap)
+   {
+   common->then_trap = CURRENT_AS(then_trap_backtrack)->then_trap;
+   return;
+   }
+ size = CURRENT_AS(then_trap_backtrack)->framesize;
+ size = 3 + (size < 0 ? 0 : size);
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(size - 3));
+ free_stack(common, size);
+ jump = JUMP(SLJIT_JUMP);
+ set_jumps(CURRENT_AS(then_trap_backtrack)->quit, LABEL());
+ /* STACK_TOP is set by THEN. */
+ if (CURRENT_AS(then_trap_backtrack)->framesize >= 0)
+   add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+ free_stack(common, 3);
+ JUMPHERE(jump);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP1, 0);
+ }
  static void compile_backtrackingpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
+ then_trap_backtrack *save_then_trap = common->then_trap;
  while (current)
    {
-Line 8212 
 while (current)
+Line 8578 
 while (current)
      break;
      case OP_MARK:
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0));
-     free_stack(common, 1);
+     if (common->has_skip_arg)
+       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+     free_stack(common, common->has_skip_arg ? 5 : 1);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP1, 0);
+     if (common->has_skip_arg)
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP2, 0);
      break;
+     case OP_THEN:
+     case OP_THEN_ARG:
      case OP_PRUNE:
      case OP_PRUNE_ARG:
      case OP_SKIP:
-     if (!common->local_exit)
+     case OP_SKIP_ARG:
-       {
+     compile_control_verb_backtrackingpath(common, current);
-       SLJIT_ASSERT(common->control_head_ptr != 0);
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
-       sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_check_control_chain));
-       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
-       OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
-       add_jump(compiler, &common->reset_match, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, -1));
-       OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
-       }
-     /* Commit or in recurse or accept. */
-     if (common->quit_label == NULL)
-       add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
-     else
-       JUMPTO(SLJIT_JUMP, common->quit_label);
      break;
      case OP_COMMIT:
-Line 8257 
 while (current)
+Line 8612 
 while (current)
      set_jumps(current->topbacktracks, LABEL());
      break;
+     case OP_THEN_TRAP:
+     /* A virtual opcode for then traps. */
+     compile_then_trap_backtrackingpath(common, current);
+     break;
      default:
      SLJIT_ASSERT_STOP();
      break;
      }
    current = current->prev;
    }
+ common->then_trap = save_then_trap;
  }
  static SLJIT_INLINE void compile_recurse(compiler_common *common)
-Line 8271 
 DEFINE_COMPILER;
+Line 8632 
 DEFINE_COMPILER;
  pcre_uchar *cc = common->start + common->currententry->start;
  pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);
  pcre_uchar *ccend = bracketend(cc);
- int private_data_size = get_private_data_length_for_copy(common, ccbegin, ccend);
+ BOOL needs_control_head;
- int framesize = get_framesize(common, cc, TRUE);
+ int framesize = get_framesize(common, cc, NULL, TRUE, &needs_control_head);
+ int private_data_size = get_private_data_copy_length(common, ccbegin, ccend, needs_control_head);
  int alternativesize;
  BOOL needs_frame;
  backtrack_common altbacktrack;
  struct sljit_jump *jump;
+ /* Recurse captures then. */
+ common->then_trap = NULL;
  SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);
  needs_frame = framesize >= 0;
  if (!needs_frame)
-Line 8291 
 set_jumps(common->currententry->calls, c
+Line 8656 
 set_jumps(common->currententry->calls, c
  sljit_emit_fast_enter(compiler, TMP2, 0);
  allocate_stack(common, private_data_size + framesize + alternativesize);
  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(private_data_size + framesize + alternativesize - 1), TMP2, 0);
- copy_private_data(common, ccbegin, ccend, TRUE, private_data_size + framesize + alternativesize, framesize + alternativesize);
+ copy_private_data(common, ccbegin, ccend, TRUE, private_data_size + framesize + alternativesize, framesize + alternativesize, needs_control_head);
- if (common->control_head_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(SLJIT_LOCALS_REG), common->recursive_head_ptr, STACK_TOP, 0);
  if (needs_frame)
-   init_frame(common, cc, framesize + alternativesize - 1, alternativesize, TRUE);
+   init_frame(common, cc, NULL, framesize + alternativesize - 1, alternativesize, TRUE);
  if (alternativesize > 0)
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
-Line 8366 
 OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);
+Line 8731 
 OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);
  JUMPHERE(jump);
  if (common->quit != NULL)
    set_jumps(common->quit, LABEL());
- copy_private_data(common, ccbegin, ccend, FALSE, private_data_size + framesize + alternativesize, framesize + alternativesize);
+ copy_private_data(common, ccbegin, ccend, FALSE, private_data_size + framesize + alternativesize, framesize + alternativesize, needs_control_head);
  free_stack(common, private_data_size + framesize + alternativesize);
- if (common->control_head_ptr != 0)
+ if (needs_control_head)
    {
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 2 * sizeof(sljit_sw));
    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_sw));
-Line 8462 
 else
+Line 8827 
 else
  common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
  common->ctypes = (sljit_sw)(tables + ctypes_offset);
  common->digits[0] = -2;
- common->name_table = (sljit_sw)((pcre_uchar *)re + re->name_table_offset);
+ common->name_table = ((pcre_uchar *)re) + re->name_table_offset;
  common->name_count = re->name_count;
  common->name_entry_size = re->name_entry_size;
  common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
-Line 8476 
 common->use_ucp = (re->options & PCRE_UC
+Line 8841 
 common->use_ucp = (re->options & PCRE_UC
  ccend = bracketend(rootbacktrack.cc);
  /* Calculate the local space size on the stack. */
- common->ovector_start = CALL_LIMIT + sizeof(sljit_sw);
+ common->ovector_start = LIMIT_MATCH + sizeof(sljit_sw);
  common->optimized_cbracket = (pcre_uint8 *)SLJIT_MALLOC(re->top_bracket + 1);
  if (!common->optimized_cbracket)
    return;
-Line 8491 
 SLJIT_ASSERT(*rootbacktrack.cc == OP_BRA
+Line 8856 
 SLJIT_ASSERT(*rootbacktrack.cc == OP_BRA
  common->capture_last_ptr = common->ovector_start;
  common->ovector_start += sizeof(sljit_sw);
  #endif
- private_data_size = get_private_data_length(common, rootbacktrack.cc, ccend);
+ if (!check_opcode_types(common, rootbacktrack.cc, ccend))
- if (private_data_size < 0)
    {
    SLJIT_FREE(common->optimized_cbracket);
    return;
-Line 8554 
 if (common->capture_last_ptr != 0)
+Line 8918 
 if (common->capture_last_ptr != 0)
  SLJIT_ASSERT(!(common->req_char_ptr != 0 && common->start_used_ptr != 0));
  common->cbra_ptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_sw);
- private_data_size += common->cbra_ptr + (re->top_bracket + 1) * sizeof(sljit_sw);
- if (private_data_size > SLJIT_MAX_LOCAL_SIZE)
+ common->private_data_ptrs = (int *)SLJIT_MALLOC((ccend - rootbacktrack.cc) * sizeof(sljit_si));
+ if (!common->private_data_ptrs)
    {
    SLJIT_FREE(common->optimized_cbracket);
    return;
    }
- common->private_data_ptrs = (int *)SLJIT_MALLOC((ccend - rootbacktrack.cc) * sizeof(int));
+ memset(common->private_data_ptrs, 0, (ccend - rootbacktrack.cc) * sizeof(int));
- if (!common->private_data_ptrs)
+ private_data_size = common->cbra_ptr + (re->top_bracket + 1) * sizeof(sljit_sw);
+ set_private_data_ptrs(common, &private_data_size, ccend);
+ if (private_data_size > SLJIT_MAX_LOCAL_SIZE)
    {
+   SLJIT_FREE(common->private_data_ptrs);
    SLJIT_FREE(common->optimized_cbracket);
    return;
    }
- memset(common->private_data_ptrs, 0, (ccend - rootbacktrack.cc) * sizeof(int));
- set_private_data_ptrs(common, common->cbra_ptr + (re->top_bracket + 1) * sizeof(sljit_sw), ccend);
+ if (common->has_then)
+   {
+   common->then_offsets = (pcre_uint8 *)SLJIT_MALLOC(ccend - rootbacktrack.cc);
+   if (!common->then_offsets)
+     {
+     SLJIT_FREE(common->optimized_cbracket);
+     SLJIT_FREE(common->private_data_ptrs);
+     return;
+     }
+   memset(common->then_offsets, 0, ccend - rootbacktrack.cc);
+   set_then_offsets(common, rootbacktrack.cc, NULL);
+   }
  compiler = sljit_create_compiler();
  if (!compiler)
    {
    SLJIT_FREE(common->optimized_cbracket);
    SLJIT_FREE(common->private_data_ptrs);
+   if (common->has_then)
+     SLJIT_FREE(common->then_offsets);
    return;
    }
  common->compiler = compiler;
-Line 8591 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_SAVED_REG1
+Line 8973 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_SAVED_REG1
  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
  OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, end));
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));
- OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, call_limit));
+ OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, limit_match));
  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, base));
  OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, limit));
- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CALL_LIMIT, TMP1, 0);
+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LIMIT_MATCH, TMP1, 0);
  if (mode == JIT_PARTIAL_SOFT_COMPILE)
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
-Line 8636 
 if (common->req_char_ptr != 0)
+Line 9018 
 if (common->req_char_ptr != 0)
  /* Store the current STR_PTR in OVECTOR(0). */
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);
  /* Copy the limit of allowed recursions. */
- OP1(SLJIT_MOV, CALL_COUNT, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CALL_LIMIT);
+ OP1(SLJIT_MOV, COUNT_MATCH, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LIMIT_MATCH);
  if (common->capture_last_ptr != 0)
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, -1);
-Line 8665 
 if (SLJIT_UNLIKELY(sljit_get_compiler_er
+Line 9047 
 if (SLJIT_UNLIKELY(sljit_get_compiler_er
    sljit_free_compiler(compiler);
    SLJIT_FREE(common->optimized_cbracket);
    SLJIT_FREE(common->private_data_ptrs);
+   if (common->has_then)
+     SLJIT_FREE(common->then_offsets);
    return;
    }
-Line 8700 
 if (SLJIT_UNLIKELY(sljit_get_compiler_er
+Line 9084 
 if (SLJIT_UNLIKELY(sljit_get_compiler_er
    sljit_free_compiler(compiler);
    SLJIT_FREE(common->optimized_cbracket);
    SLJIT_FREE(common->private_data_ptrs);
+   if (common->has_then)
+     SLJIT_FREE(common->then_offsets);
    return;
    }
-Line 8767 
 while (common->currententry != NULL)
+Line 9153 
 while (common->currententry != NULL)
      sljit_free_compiler(compiler);
      SLJIT_FREE(common->optimized_cbracket);
      SLJIT_FREE(common->private_data_ptrs);
+     if (common->has_then)
+       SLJIT_FREE(common->then_offsets);
      return;
      }
    flush_stubs(common);
-Line 8875 
 if (common->getucd != NULL)
+Line 9263 
 if (common->getucd != NULL)
  SLJIT_FREE(common->optimized_cbracket);
  SLJIT_FREE(common->private_data_ptrs);
+ if (common->has_then)
+   SLJIT_FREE(common->then_offsets);
  executable_func = sljit_generate_code(compiler);
  executable_size = sljit_get_generated_code_size(compiler);
  sljit_free_compiler(compiler);
-Line 8905 
 else
+Line 9296 
 else
      }
    memset(functions, 0, sizeof(executable_functions));
    functions->top_bracket = (re->top_bracket + 1) * 2;
+   functions->limit_match = (re->flags & PCRE_MLSET) != 0 ? re->limit_match : 0;
    extra->executable_jit = functions;
    extra->flags |= PCRE_EXTRA_EXECUTABLE_JIT;
    }
-Line 8959 
 arguments.begin = subject;
+Line 9351 
 arguments.begin = subject;
  arguments.end = subject + length;
  arguments.mark_ptr = NULL;
  /* JIT decreases this value less frequently than the interpreter. */
- arguments.call_limit = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : extra_data->match_limit;
+ arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (pcre_uint32)(extra_data->match_limit);
+ if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)
+   arguments.limit_match = functions->limit_match;
  arguments.notbol = (options & PCRE_NOTBOL) != 0;
  arguments.noteol = (options & PCRE_NOTEOL) != 0;
  arguments.notempty = (options & PCRE_NOTEMPTY) != 0;
-Line 9050 
 arguments.begin = subject_ptr;
+Line 9444 
 arguments.begin = subject_ptr;
  arguments.end = subject_ptr + length;
  arguments.mark_ptr = NULL;
  /* JIT decreases this value less frequently than the interpreter. */
- arguments.call_limit = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : extra_data->match_limit;
+ arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (pcre_uint32)(extra_data->match_limit);
+ if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)
+   arguments.limit_match = functions->limit_match;
  arguments.notbol = (options & PCRE_NOTBOL) != 0;
  arguments.noteol = (options & PCRE_NOTEOL) != 0;
  arguments.notempty = (options & PCRE_NOTEMPTY) != 0;
-Line 9169 
 if (extra != NULL &&
+Line 9565 
 if (extra != NULL &&
    }
  }
+ #if defined COMPILE_PCRE8
+ PCRE_EXP_DECL void
+ pcre_jit_free_unused_memory(void)
+ #elif defined COMPILE_PCRE16
+ PCRE_EXP_DECL void
+ pcre16_jit_free_unused_memory(void)
+ #elif defined COMPILE_PCRE32
+ PCRE_EXP_DECL void
+ pcre32_jit_free_unused_memory(void)
+ #endif
+ {
+ sljit_free_unused_memory_exec();
+ }
  #else  /* SUPPORT_JIT */
  /* These are dummy functions to avoid linking errors when JIT support is not
-Line 9220 
 pcre32_assign_jit_stack(pcre32_extra *ex
+Line 9630 
 pcre32_assign_jit_stack(pcre32_extra *ex
  (void)userdata;
  }
+ #if defined COMPILE_PCRE8
+ PCRE_EXP_DECL void
+ pcre_jit_free_unused_memory(void)
+ #elif defined COMPILE_PCRE16
+ PCRE_EXP_DECL void
+ pcre16_jit_free_unused_memory(void)
+ #elif defined COMPILE_PCRE32
+ PCRE_EXP_DECL void
+ pcre32_jit_free_unused_memory(void)
+ #endif
+ {
+ }
  #endif
  /* End of pcre_jit_compile.c */

 Legend:



Removed from v.1275
 


changed lines


 
Added in v.1367
 Legend:



Removed from v.1275
 


changed lines


 
Added in v.1367
-Removed from v.1275
+Added in v.1367

	ViewVC Help
Powered by ViewVC 1.1.5