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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1245 by zherczeg, Sat Feb 9 11:30:51 2013 UTC revision 1310 by zherczeg, Sat Apr 6 06:51:09 2013 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2012 University of Cambridge             Copyright (c) 1997-2013 University of Cambridge
10    
11    The machine code generator part (this module) was written by Zoltan Herczeg    The machine code generator part (this module) was written by Zoltan Herczeg
12                        Copyright (c) 2010-2012                        Copyright (c) 2010-2013
13    
14  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
15  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 65  system files. */ Line 65  system files. */
65  #error Unsupported architecture  #error Unsupported architecture
66  #endif  #endif
67    
68    /* Defines for debugging purposes. */
69    
70    /* 1 - Use unoptimized capturing brackets.
71       2 - Enable capture_last_ptr (includes option 1). */
72    /* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */
73    
74    /* 1 - Always have a control head. */
75    /* #define DEBUG_FORCE_CONTROL_HEAD 1 */
76    
77  /* Allocate memory for the regex stack on the real machine stack.  /* Allocate memory for the regex stack on the real machine stack.
78  Fast, but limited size. */  Fast, but limited size. */
79  #define MACHINE_STACK_SIZE 32768  #define MACHINE_STACK_SIZE 32768
# Line 159  typedef struct jit_arguments { Line 168  typedef struct jit_arguments {
168    pcre_uchar *mark_ptr;    pcre_uchar *mark_ptr;
169    void *callout_data;    void *callout_data;
170    /* Everything else after. */    /* Everything else after. */
171      int real_offset_count;
172    int offset_count;    int offset_count;
173    int call_limit;    int call_limit;
174    pcre_uint8 notbol;    pcre_uint8 notbol;
# Line 180  typedef struct jump_list { Line 190  typedef struct jump_list {
190    struct jump_list *next;    struct jump_list *next;
191  } jump_list;  } jump_list;
192    
 enum stub_types { stack_alloc };  
   
193  typedef struct stub_list {  typedef struct stub_list {
   enum stub_types type;  
   int data;  
194    struct sljit_jump *start;    struct sljit_jump *start;
195    struct sljit_label *quit;    struct sljit_label *quit;
196    struct stub_list *next;    struct stub_list *next;
197  } stub_list;  } stub_list;
198    
199    enum frame_types {
200      no_frame = -1,
201      no_stack = -2
202    };
203    
204    enum control_types {
205      type_mark = 0,
206      type_then_trap = 1
207    };
208    
209  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
210    
211  /* The following structure is the key data type for the recursive  /* The following structure is the key data type for the recursive
# Line 210  typedef struct backtrack_common { Line 226  typedef struct backtrack_common {
226  typedef struct assert_backtrack {  typedef struct assert_backtrack {
227    backtrack_common common;    backtrack_common common;
228    jump_list *condfailed;    jump_list *condfailed;
229    /* Less than 0 (-1) if a frame is not needed. */    /* Less than 0 if a frame is not needed. */
230    int framesize;    int framesize;
231    /* Points to our private memory word on the stack. */    /* Points to our private memory word on the stack. */
232    int private_data_ptr;    int private_data_ptr;
# Line 231  typedef struct bracket_backtrack { Line 247  typedef struct bracket_backtrack {
247      /* Both for OP_COND, OP_SCOND. */      /* Both for OP_COND, OP_SCOND. */
248      jump_list *condfailed;      jump_list *condfailed;
249      assert_backtrack *assert;      assert_backtrack *assert;
250      /* For OP_ONCE. -1 if not needed. */      /* For OP_ONCE. Less than 0 if not needed. */
251      int framesize;      int framesize;
252    } u;    } u;
253    /* Points to our private memory word on the stack. */    /* Points to our private memory word on the stack. */
# Line 266  typedef struct recurse_entry { Line 282  typedef struct recurse_entry {
282    /* Collects the calls until the function is not created. */    /* Collects the calls until the function is not created. */
283    jump_list *calls;    jump_list *calls;
284    /* Points to the starting opcode. */    /* Points to the starting opcode. */
285    int start;    sljit_sw start;
286  } recurse_entry;  } recurse_entry;
287    
288  typedef struct recurse_backtrack {  typedef struct recurse_backtrack {
289    backtrack_common common;    backtrack_common common;
290      BOOL inlined_pattern;
291  } recurse_backtrack;  } recurse_backtrack;
292    
293    #define OP_THEN_TRAP OP_TABLE_LENGTH
294    
295    typedef struct then_trap_backtrack {
296      backtrack_common common;
297      /* If then_trap is not NULL, this structure contains the real
298      then_trap for the backtracking path. */
299      struct then_trap_backtrack *then_trap;
300      /* Points to the starting opcode. */
301      sljit_sw start;
302      /* Exit point for the then opcodes of this alternative. */
303      jump_list *quit;
304      /* Frame size of the current alternative. */
305      int framesize;
306    } then_trap_backtrack;
307    
308  #define MAX_RANGE_SIZE 6  #define MAX_RANGE_SIZE 6
309    
310  typedef struct compiler_common {  typedef struct compiler_common {
311      /* The sljit ceneric compiler. */
312    struct sljit_compiler *compiler;    struct sljit_compiler *compiler;
313      /* First byte code. */
314    pcre_uchar *start;    pcre_uchar *start;
   
315    /* Maps private data offset to each opcode. */    /* Maps private data offset to each opcode. */
316    int *private_data_ptrs;    sljit_si *private_data_ptrs;
317    /* Tells whether the capturing bracket is optimized. */    /* Tells whether the capturing bracket is optimized. */
318    pcre_uint8 *optimized_cbracket;    pcre_uint8 *optimized_cbracket;
319      /* Tells whether the starting offset is a target of then. */
320      pcre_uint8 *then_offsets;
321      /* Current position where a THEN must jump. */
322      then_trap_backtrack *then_trap;
323    /* Starting offset of private data for capturing brackets. */    /* Starting offset of private data for capturing brackets. */
324    int cbraptr;    int cbra_ptr;
325    /* OVector starting point. Must be divisible by 2. */    /* Output vector starting point. Must be divisible by 2. */
326    int ovector_start;    int ovector_start;
327    /* Last known position of the requested byte. */    /* Last known position of the requested byte. */
328    int req_char_ptr;    int req_char_ptr;
# Line 299  typedef struct compiler_common { Line 336  typedef struct compiler_common {
336    int first_line_end;    int first_line_end;
337    /* Points to the marked string. */    /* Points to the marked string. */
338    int mark_ptr;    int mark_ptr;
339      /* Recursive control verb management chain. */
340      int control_head_ptr;
341    /* Points to the last matched capture block index. */    /* Points to the last matched capture block index. */
342    int capture_last_ptr;    int capture_last_ptr;
343      /* Points to the starting position of the current match. */
344      int start_ptr;
345    
346    /* Flipped and lower case tables. */    /* Flipped and lower case tables. */
347    const pcre_uint8 *fcc;    const pcre_uint8 *fcc;
348    sljit_sw lcc;    sljit_sw lcc;
349    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
350    int mode;    int mode;
351      /* \K is found in the pattern. */
352      BOOL has_set_som;
353      /* (*SKIP:arg) is found in the pattern. */
354      BOOL has_skip_arg;
355      /* (*THEN) is found in the pattern. */
356      BOOL has_then;
357      /* Needs to know the start position anytime. */
358      BOOL needs_start_ptr;
359      /* Currently in recurse or negative assert. */
360      BOOL local_exit;
361      /* Currently in a positive assert. */
362      BOOL positive_assert;
363    /* Newline control. */    /* Newline control. */
364    int nltype;    int nltype;
365    int newline;    int newline;
366    int bsr_nltype;    int bsr_nltype;
367    /* Dollar endonly. */    /* Dollar endonly. */
368    int endonly;    int endonly;
   BOOL has_set_som;  
369    /* Tables. */    /* Tables. */
370    sljit_sw ctypes;    sljit_sw ctypes;
371    int digits[2 + MAX_RANGE_SIZE];    int digits[2 + MAX_RANGE_SIZE];
# Line 332  typedef struct compiler_common { Line 384  typedef struct compiler_common {
384    recurse_entry *currententry;    recurse_entry *currententry;
385    jump_list *partialmatch;    jump_list *partialmatch;
386    jump_list *quit;    jump_list *quit;
387      jump_list *positive_assert_quit;
388    jump_list *forced_quit;    jump_list *forced_quit;
389    jump_list *accept;    jump_list *accept;
390    jump_list *calllimit;    jump_list *calllimit;
# Line 343  typedef struct compiler_common { Line 396  typedef struct compiler_common {
396    jump_list *vspace;    jump_list *vspace;
397    jump_list *casefulcmp;    jump_list *casefulcmp;
398    jump_list *caselesscmp;    jump_list *caselesscmp;
399      jump_list *reset_match;
400    BOOL jscript_compat;    BOOL jscript_compat;
401  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
402    BOOL utf;    BOOL utf;
# Line 395  typedef struct compare_context { Line 449  typedef struct compare_context {
449  #endif  #endif
450  } compare_context;  } compare_context;
451    
 enum {  
   frame_end = 0,  
   frame_setstrbegin = -1,  
   frame_setmark = -2  
 };  
   
452  /* Undefine sljit macros. */  /* Undefine sljit macros. */
453  #undef CMP  #undef CMP
454    
# Line 433  group contains the start / end character Line 481  group contains the start / end character
481  the start pointers when the end of the capturing group has not yet reached. */  the start pointers when the end of the capturing group has not yet reached. */
482  #define OVECTOR_START    (common->ovector_start)  #define OVECTOR_START    (common->ovector_start)
483  #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_sw))  #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_sw))
484  #define OVECTOR_PRIV(i)  (common->cbraptr + (i) * sizeof(sljit_sw))  #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * sizeof(sljit_sw))
485  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
486    
487  #if defined COMPILE_PCRE8  #if defined COMPILE_PCRE8
# Line 464  the start pointers when the end of the c Line 512  the start pointers when the end of the c
512    sljit_set_label(sljit_emit_jump(compiler, (type)), (label))    sljit_set_label(sljit_emit_jump(compiler, (type)), (label))
513  #define JUMPHERE(jump) \  #define JUMPHERE(jump) \
514    sljit_set_label((jump), sljit_emit_label(compiler))    sljit_set_label((jump), sljit_emit_label(compiler))
515    #define SET_LABEL(jump, label) \
516      sljit_set_label((jump), (label))
517  #define CMP(type, src1, src1w, src2, src2w) \  #define CMP(type, src1, src1w, src2, src2w) \
518    sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))    sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))
519  #define CMPTO(type, src1, src1w, src2, src2w, label) \  #define CMPTO(type, src1, src1w, src2, src2w, label) \
# Line 484  return cc; Line 534  return cc;
534    
535  /* Functions whose might need modification for all new supported opcodes:  /* Functions whose might need modification for all new supported opcodes:
536   next_opcode   next_opcode
537   get_private_data_length   check_opcode_types
538   set_private_data_ptrs   set_private_data_ptrs
539   get_framesize   get_framesize
540   init_frame   init_frame
541   get_private_data_length_for_copy   get_private_data_copy_length
542   copy_private_data   copy_private_data
543   compile_matchingpath   compile_matchingpath
544   compile_backtrackingpath   compile_backtrackingpath
# Line 512  switch(*cc) Line 562  switch(*cc)
562    case OP_WORDCHAR:    case OP_WORDCHAR:
563    case OP_ANY:    case OP_ANY:
564    case OP_ALLANY:    case OP_ALLANY:
565      case OP_NOTPROP:
566      case OP_PROP:
567    case OP_ANYNL:    case OP_ANYNL:
568    case OP_NOT_HSPACE:    case OP_NOT_HSPACE:
569    case OP_HSPACE:    case OP_HSPACE:
# Line 524  switch(*cc) Line 576  switch(*cc)
576    case OP_CIRCM:    case OP_CIRCM:
577    case OP_DOLL:    case OP_DOLL:
578    case OP_DOLLM:    case OP_DOLLM:
   case OP_TYPESTAR:  
   case OP_TYPEMINSTAR:  
   case OP_TYPEPLUS:  
   case OP_TYPEMINPLUS:  
   case OP_TYPEQUERY:  
   case OP_TYPEMINQUERY:  
   case OP_TYPEPOSSTAR:  
   case OP_TYPEPOSPLUS:  
   case OP_TYPEPOSQUERY:  
579    case OP_CRSTAR:    case OP_CRSTAR:
580    case OP_CRMINSTAR:    case OP_CRMINSTAR:
581    case OP_CRPLUS:    case OP_CRPLUS:
582    case OP_CRMINPLUS:    case OP_CRMINPLUS:
583    case OP_CRQUERY:    case OP_CRQUERY:
584    case OP_CRMINQUERY:    case OP_CRMINQUERY:
585      case OP_CRRANGE:
586      case OP_CRMINRANGE:
587      case OP_CLASS:
588      case OP_NCLASS:
589      case OP_REF:
590      case OP_REFI:
591      case OP_RECURSE:
592      case OP_CALLOUT:
593      case OP_ALT:
594      case OP_KET:
595      case OP_KETRMAX:
596      case OP_KETRMIN:
597      case OP_KETRPOS:
598      case OP_REVERSE:
599      case OP_ASSERT:
600      case OP_ASSERT_NOT:
601      case OP_ASSERTBACK:
602      case OP_ASSERTBACK_NOT:
603      case OP_ONCE:
604      case OP_ONCE_NC:
605      case OP_BRA:
606      case OP_BRAPOS:
607      case OP_CBRA:
608      case OP_CBRAPOS:
609      case OP_COND:
610      case OP_SBRA:
611      case OP_SBRAPOS:
612      case OP_SCBRA:
613      case OP_SCBRAPOS:
614      case OP_SCOND:
615      case OP_CREF:
616      case OP_NCREF:
617      case OP_RREF:
618      case OP_NRREF:
619    case OP_DEF:    case OP_DEF:
620    case OP_BRAZERO:    case OP_BRAZERO:
621    case OP_BRAMINZERO:    case OP_BRAMINZERO:
622    case OP_BRAPOSZERO:    case OP_BRAPOSZERO:
623      case OP_PRUNE:
624      case OP_SKIP:
625      case OP_THEN:
626    case OP_COMMIT:    case OP_COMMIT:
627    case OP_FAIL:    case OP_FAIL:
628    case OP_ACCEPT:    case OP_ACCEPT:
629    case OP_ASSERT_ACCEPT:    case OP_ASSERT_ACCEPT:
630      case OP_CLOSE:
631    case OP_SKIPZERO:    case OP_SKIPZERO:
632    return cc + 1;    return cc + PRIV(OP_lengths)[*cc];
   
   case OP_ANYBYTE:  
 #ifdef SUPPORT_UTF  
   if (common->utf) return NULL;  
 #endif  
   return cc + 1;  
633    
634    case OP_CHAR:    case OP_CHAR:
635    case OP_CHARI:    case OP_CHARI:
# Line 566  switch(*cc) Line 641  switch(*cc)
641    case OP_MINPLUS:    case OP_MINPLUS:
642    case OP_QUERY:    case OP_QUERY:
643    case OP_MINQUERY:    case OP_MINQUERY:
644      case OP_UPTO:
645      case OP_MINUPTO:
646      case OP_EXACT:
647    case OP_POSSTAR:    case OP_POSSTAR:
648    case OP_POSPLUS:    case OP_POSPLUS:
649    case OP_POSQUERY:    case OP_POSQUERY:
650      case OP_POSUPTO:
651    case OP_STARI:    case OP_STARI:
652    case OP_MINSTARI:    case OP_MINSTARI:
653    case OP_PLUSI:    case OP_PLUSI:
654    case OP_MINPLUSI:    case OP_MINPLUSI:
655    case OP_QUERYI:    case OP_QUERYI:
656    case OP_MINQUERYI:    case OP_MINQUERYI:
657      case OP_UPTOI:
658      case OP_MINUPTOI:
659      case OP_EXACTI:
660    case OP_POSSTARI:    case OP_POSSTARI:
661    case OP_POSPLUSI:    case OP_POSPLUSI:
662    case OP_POSQUERYI:    case OP_POSQUERYI:
663      case OP_POSUPTOI:
664    case OP_NOTSTAR:    case OP_NOTSTAR:
665    case OP_NOTMINSTAR:    case OP_NOTMINSTAR:
666    case OP_NOTPLUS:    case OP_NOTPLUS:
667    case OP_NOTMINPLUS:    case OP_NOTMINPLUS:
668    case OP_NOTQUERY:    case OP_NOTQUERY:
669    case OP_NOTMINQUERY:    case OP_NOTMINQUERY:
670      case OP_NOTUPTO:
671      case OP_NOTMINUPTO:
672      case OP_NOTEXACT:
673    case OP_NOTPOSSTAR:    case OP_NOTPOSSTAR:
674    case OP_NOTPOSPLUS:    case OP_NOTPOSPLUS:
675    case OP_NOTPOSQUERY:    case OP_NOTPOSQUERY:
676      case OP_NOTPOSUPTO:
677    case OP_NOTSTARI:    case OP_NOTSTARI:
678    case OP_NOTMINSTARI:    case OP_NOTMINSTARI:
679    case OP_NOTPLUSI:    case OP_NOTPLUSI:
680    case OP_NOTMINPLUSI:    case OP_NOTMINPLUSI:
681    case OP_NOTQUERYI:    case OP_NOTQUERYI:
682    case OP_NOTMINQUERYI:    case OP_NOTMINQUERYI:
   case OP_NOTPOSSTARI:  
   case OP_NOTPOSPLUSI:  
   case OP_NOTPOSQUERYI:  
   cc += 2;  
 #ifdef SUPPORT_UTF  
   if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);  
 #endif  
   return cc;  
   
   case OP_UPTO:  
   case OP_MINUPTO:  
   case OP_EXACT:  
   case OP_POSUPTO:  
   case OP_UPTOI:  
   case OP_MINUPTOI:  
   case OP_EXACTI:  
   case OP_POSUPTOI:  
   case OP_NOTUPTO:  
   case OP_NOTMINUPTO:  
   case OP_NOTEXACT:  
   case OP_NOTPOSUPTO:  
683    case OP_NOTUPTOI:    case OP_NOTUPTOI:
684    case OP_NOTMINUPTOI:    case OP_NOTMINUPTOI:
685    case OP_NOTEXACTI:    case OP_NOTEXACTI:
686      case OP_NOTPOSSTARI:
687      case OP_NOTPOSPLUSI:
688      case OP_NOTPOSQUERYI:
689    case OP_NOTPOSUPTOI:    case OP_NOTPOSUPTOI:
690    cc += 2 + IMM2_SIZE;    cc += PRIV(OP_lengths)[*cc];
691  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
692    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
693  #endif  #endif
694    return cc;    return cc;
695    
696    case OP_NOTPROP:    /* Special cases. */
697    case OP_PROP:    case OP_TYPESTAR:
698    return cc + 1 + 2;    case OP_TYPEMINSTAR:
699      case OP_TYPEPLUS:
700      case OP_TYPEMINPLUS:
701      case OP_TYPEQUERY:
702      case OP_TYPEMINQUERY:
703    case OP_TYPEUPTO:    case OP_TYPEUPTO:
704    case OP_TYPEMINUPTO:    case OP_TYPEMINUPTO:
705    case OP_TYPEEXACT:    case OP_TYPEEXACT:
706      case OP_TYPEPOSSTAR:
707      case OP_TYPEPOSPLUS:
708      case OP_TYPEPOSQUERY:
709    case OP_TYPEPOSUPTO:    case OP_TYPEPOSUPTO:
710    case OP_REF:    return cc + PRIV(OP_lengths)[*cc] - 1;
   case OP_REFI:  
   case OP_CREF:  
   case OP_NCREF:  
   case OP_RREF:  
   case OP_NRREF:  
   case OP_CLOSE:  
   cc += 1 + IMM2_SIZE;  
   return cc;  
711    
712    case OP_CRRANGE:    case OP_ANYBYTE:
713    case OP_CRMINRANGE:  #ifdef SUPPORT_UTF
714    return cc + 1 + 2 * IMM2_SIZE;    if (common->utf) return NULL;
715    #endif
716    case OP_CLASS:    return cc + 1;
   case OP_NCLASS:  
   return cc + 1 + 32 / sizeof(pcre_uchar);  
717    
718  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
719    case OP_XCLASS:    case OP_XCLASS:
720    return cc + GET(cc, 1);    return cc + GET(cc, 1);
721  #endif  #endif
722    
   case OP_RECURSE:  
   case OP_ASSERT:  
   case OP_ASSERT_NOT:  
   case OP_ASSERTBACK:  
   case OP_ASSERTBACK_NOT:  
   case OP_REVERSE:  
   case OP_ONCE:  
   case OP_ONCE_NC:  
   case OP_BRA:  
   case OP_BRAPOS:  
   case OP_COND:  
   case OP_SBRA:  
   case OP_SBRAPOS:  
   case OP_SCOND:  
   case OP_ALT:  
   case OP_KET:  
   case OP_KETRMAX:  
   case OP_KETRMIN:  
   case OP_KETRPOS:  
   return cc + 1 + LINK_SIZE;  
   
   case OP_CBRA:  
   case OP_CBRAPOS:  
   case OP_SCBRA:  
   case OP_SCBRAPOS:  
   return cc + 1 + LINK_SIZE + IMM2_SIZE;  
   
723    case OP_MARK:    case OP_MARK:
724      case OP_PRUNE_ARG:
725      case OP_SKIP_ARG:
726      case OP_THEN_ARG:
727    return cc + 1 + 2 + cc[1];    return cc + 1 + 2 + cc[1];
728    
   case OP_CALLOUT:  
   return cc + 2 + 2 * LINK_SIZE;  
   
729    default:    default:
730      /* All opcodes are supported now! */
731      SLJIT_ASSERT_STOP();
732    return NULL;    return NULL;
733    }    }
734  }  }
735    
736  #define CASE_ITERATOR_PRIVATE_DATA_1 \  static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
     case OP_MINSTAR: \  
     case OP_MINPLUS: \  
     case OP_QUERY: \  
     case OP_MINQUERY: \  
     case OP_MINSTARI: \  
     case OP_MINPLUSI: \  
     case OP_QUERYI: \  
     case OP_MINQUERYI: \  
     case OP_NOTMINSTAR: \  
     case OP_NOTMINPLUS: \  
     case OP_NOTQUERY: \  
     case OP_NOTMINQUERY: \  
     case OP_NOTMINSTARI: \  
     case OP_NOTMINPLUSI: \  
     case OP_NOTQUERYI: \  
     case OP_NOTMINQUERYI:  
   
 #define CASE_ITERATOR_PRIVATE_DATA_2A \  
     case OP_STAR: \  
     case OP_PLUS: \  
     case OP_STARI: \  
     case OP_PLUSI: \  
     case OP_NOTSTAR: \  
     case OP_NOTPLUS: \  
     case OP_NOTSTARI: \  
     case OP_NOTPLUSI:  
   
 #define CASE_ITERATOR_PRIVATE_DATA_2B \  
     case OP_UPTO: \  
     case OP_MINUPTO: \  
     case OP_UPTOI: \  
     case OP_MINUPTOI: \  
     case OP_NOTUPTO: \  
     case OP_NOTMINUPTO: \  
     case OP_NOTUPTOI: \  
     case OP_NOTMINUPTOI:  
   
 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \  
     case OP_TYPEMINSTAR: \  
     case OP_TYPEMINPLUS: \  
     case OP_TYPEQUERY: \  
     case OP_TYPEMINQUERY:  
   
 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \  
     case OP_TYPESTAR: \  
     case OP_TYPEPLUS:  
   
 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \  
     case OP_TYPEUPTO: \  
     case OP_TYPEMINUPTO:  
   
 static int get_class_iterator_size(pcre_uchar *cc)  
 {  
 switch(*cc)  
   {  
   case OP_CRSTAR:  
   case OP_CRPLUS:  
   return 2;  
   
   case OP_CRMINSTAR:  
   case OP_CRMINPLUS:  
   case OP_CRQUERY:  
   case OP_CRMINQUERY:  
   return 1;  
   
   case OP_CRRANGE:  
   case OP_CRMINRANGE:  
   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))  
     return 0;  
   return 2;  
   
   default:  
   return 0;  
   }  
 }  
   
 static int get_private_data_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)  
737  {  {
 int private_data_length = 0;  
 pcre_uchar *alternative;  
738  pcre_uchar *name;  pcre_uchar *name;
739  pcre_uchar *end = NULL;  pcre_uchar *name2;
740  int space, size, i;  unsigned int cbra_index;
741  pcre_uint32 bracketlen;  int i;
742    
743  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
744  while (cc < ccend)  while (cc < ccend)
745    {    {
   space = 0;  
   size = 0;  
   bracketlen = 0;  
746    switch(*cc)    switch(*cc)
747      {      {
748      case OP_SET_SOM:      case OP_SET_SOM:
# Line 798  while (cc < ccend) Line 756  while (cc < ccend)
756      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
757      break;      break;
758    
     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;  
   
759      case OP_CBRAPOS:      case OP_CBRAPOS:
760      case OP_SCBRAPOS:      case OP_SCBRAPOS:
     private_data_length += sizeof(sljit_sw);  
761      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
762      bracketlen = 1 + LINK_SIZE + IMM2_SIZE;      cc += 1 + LINK_SIZE + IMM2_SIZE;
763      break;      break;
764    
765      case OP_COND:      case OP_COND:
# Line 823  while (cc < ccend) Line 767  while (cc < ccend)
767      /* Only AUTO_CALLOUT can insert this opcode. We do      /* Only AUTO_CALLOUT can insert this opcode. We do
768         not intend to support this case. */         not intend to support this case. */
769      if (cc[1 + LINK_SIZE] == OP_CALLOUT)      if (cc[1 + LINK_SIZE] == OP_CALLOUT)
770        return -1;        return FALSE;
771        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;  
772      break;      break;
773    
774      case OP_CREF:      case OP_CREF:
# Line 844  while (cc < ccend) Line 778  while (cc < ccend)
778      break;      break;
779    
780      case OP_NCREF:      case OP_NCREF:
781      bracketlen = GET2(cc, 1);      cbra_index = GET2(cc, 1);
782      name = (pcre_uchar *)common->name_table;      name = (pcre_uchar *)common->name_table;
783      alternative = name;      name2 = name;
784      for (i = 0; i < common->name_count; i++)      for (i = 0; i < common->name_count; i++)
785        {        {
786        if (GET2(name, 0) == bracketlen) break;        if (GET2(name, 0) == cbra_index) break;
787        name += common->name_entry_size;        name += common->name_entry_size;
788        }        }
789      SLJIT_ASSERT(i != common->name_count);      SLJIT_ASSERT(i != common->name_count);
790    
791      for (i = 0; i < common->name_count; i++)      for (i = 0; i < common->name_count; i++)
792        {        {
793        if (STRCMP_UC_UC(alternative + IMM2_SIZE, name + IMM2_SIZE) == 0)        if (STRCMP_UC_UC(name2 + IMM2_SIZE, name + IMM2_SIZE) == 0)
794          common->optimized_cbracket[GET2(alternative, 0)] = 0;          common->optimized_cbracket[GET2(name2, 0)] = 0;
795        alternative += common->name_entry_size;        name2 += common->name_entry_size;
796        }        }
     bracketlen = 0;  
797      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
798      break;      break;
799    
     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  
   
800      case OP_RECURSE:      case OP_RECURSE:
801      /* Set its value only once. */      /* Set its value only once. */
802      if (common->recursive_head_ptr == 0)      if (common->recursive_head_ptr == 0)
# Line 937  while (cc < ccend) Line 816  while (cc < ccend)
816      cc += 2 + 2 * LINK_SIZE;      cc += 2 + 2 * LINK_SIZE;
817      break;      break;
818    
819        case OP_THEN_ARG:
820        common->has_then = TRUE;
821        common->control_head_ptr = 1;
822        /* Fall through. */
823    
824        case OP_PRUNE_ARG:
825        common->needs_start_ptr = TRUE;
826        /* Fall through. */
827    
828      case OP_MARK:      case OP_MARK:
829      if (common->mark_ptr == 0)      if (common->mark_ptr == 0)
830        {        {
# Line 946  while (cc < ccend) Line 834  while (cc < ccend)
834      cc += 1 + 2 + cc[1];      cc += 1 + 2 + cc[1];
835      break;      break;
836    
837        case OP_THEN:
838        common->has_then = TRUE;
839        common->control_head_ptr = 1;
840        /* Fall through. */
841    
842        case OP_PRUNE:
843        case OP_SKIP:
844        common->needs_start_ptr = TRUE;
845        cc += 1;
846        break;
847    
848        case OP_SKIP_ARG:
849        common->control_head_ptr = 1;
850        common->has_skip_arg = TRUE;
851        cc += 1 + 2 + cc[1];
852        break;
853    
854      default:      default:
855      cc = next_opcode(common, cc);      cc = next_opcode(common, cc);
856      if (cc == NULL)      if (cc == NULL)
857        return -1;        return FALSE;
858      break;      break;
859      }      }
860      }
861    return TRUE;
862    }
863    
864    if (space > 0 && cc >= end)  static int get_class_iterator_size(pcre_uchar *cc)
865      private_data_length += sizeof(sljit_sw) * space;  {
866    switch(*cc)
867      {
868      case OP_CRSTAR:
869      case OP_CRPLUS:
870      return 2;
871    
872    if (size != 0)    case OP_CRMINSTAR:
873      case OP_CRMINPLUS:
874      case OP_CRQUERY:
875      case OP_CRMINQUERY:
876      return 1;
877    
878      case OP_CRRANGE:
879      case OP_CRMINRANGE:
880      if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
881        return 0;
882      return 2;
883    
884      default:
885      return 0;
886      }
887    }
888    
889    static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
890    {
891    pcre_uchar *end = bracketend(begin);
892    pcre_uchar *next;
893    pcre_uchar *next_end;
894    pcre_uchar *max_end;
895    pcre_uchar type;
896    sljit_sw length = end - begin;
897    int min, max, i;
898    
899    /* Detect fixed iterations first. */
900    if (end[-(1 + LINK_SIZE)] != OP_KET)
901      return FALSE;
902    
903    /* Already detected repeat. */
904    if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)
905      return TRUE;
906    
907    next = end;
908    min = 1;
909    while (1)
910      {
911      if (*next != *begin)
912        break;
913      next_end = bracketend(next);
914      if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)
915        break;
916      next = next_end;
917      min++;
918      }
919    
920    if (min == 2)
921      return FALSE;
922    
923    max = 0;
924    max_end = next;
925    if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)
926      {
927      type = *next;
928      while (1)
929      {      {
930      if (size < 0)      if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
931          break;
932        next_end = bracketend(next + 2 + LINK_SIZE);
933        if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)
934          break;
935        next = next_end;
936        max++;
937        }
938    
939      if (next[0] == type && next[1] == *begin && max >= 1)
940        {
941        next_end = bracketend(next + 1);
942        if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)
943        {        {
944        cc += -size;        for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
945  #ifdef SUPPORT_UTF          if (*next_end != OP_KET)
946        if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);            break;
947  #endif  
948          if (i == max)
949            {
950            common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
951            common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
952            /* +2 the original and the last. */
953            common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;
954            if (min == 1)
955              return TRUE;
956            min--;
957            max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);
958            }
959        }        }
     else  
       cc += size;  
960      }      }
961      }
962    
963    if (min >= 3)
964      {
965      common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;
966      common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;
967      common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;
968      return TRUE;
969      }
970    
971    return FALSE;
972    }
973    
974    #define CASE_ITERATOR_PRIVATE_DATA_1 \
975        case OP_MINSTAR: \
976        case OP_MINPLUS: \
977        case OP_QUERY: \
978        case OP_MINQUERY: \
979        case OP_MINSTARI: \
980        case OP_MINPLUSI: \
981        case OP_QUERYI: \
982        case OP_MINQUERYI: \
983        case OP_NOTMINSTAR: \
984        case OP_NOTMINPLUS: \
985        case OP_NOTQUERY: \
986        case OP_NOTMINQUERY: \
987        case OP_NOTMINSTARI: \
988        case OP_NOTMINPLUSI: \
989        case OP_NOTQUERYI: \
990        case OP_NOTMINQUERYI:
991    
992    #define CASE_ITERATOR_PRIVATE_DATA_2A \
993        case OP_STAR: \
994        case OP_PLUS: \
995        case OP_STARI: \
996        case OP_PLUSI: \
997        case OP_NOTSTAR: \
998        case OP_NOTPLUS: \
999        case OP_NOTSTARI: \
1000        case OP_NOTPLUSI:
1001    
1002    #define CASE_ITERATOR_PRIVATE_DATA_2B \
1003        case OP_UPTO: \
1004        case OP_MINUPTO: \
1005        case OP_UPTOI: \
1006        case OP_MINUPTOI: \
1007        case OP_NOTUPTO: \
1008        case OP_NOTMINUPTO: \
1009        case OP_NOTUPTOI: \
1010        case OP_NOTMINUPTOI:
1011    
1012    #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
1013        case OP_TYPEMINSTAR: \
1014        case OP_TYPEMINPLUS: \
1015        case OP_TYPEQUERY: \
1016        case OP_TYPEMINQUERY:
1017    
1018    if (bracketlen != 0)  #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
1019      {      case OP_TYPESTAR: \
1020      if (cc >= end)      case OP_TYPEPLUS:
1021        {  
1022        end = bracketend(cc);  #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
1023        if (end[-1 - LINK_SIZE] == OP_KET)      case OP_TYPEUPTO: \
1024          end = NULL;      case OP_TYPEMINUPTO:
       }  
     cc += bracketlen;  
     }  
   }  
 return private_data_length;  
 }  
1025    
1026  static void set_private_data_ptrs(compiler_common *common, int private_data_ptr, pcre_uchar *ccend)  static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)
1027  {  {
1028  pcre_uchar *cc = common->start;  pcre_uchar *cc = common->start;
1029  pcre_uchar *alternative;  pcre_uchar *alternative;
1030  pcre_uchar *end = NULL;  pcre_uchar *end = NULL;
1031    int private_data_ptr = *private_data_start;
1032  int space, size, bracketlen;  int space, size, bracketlen;
1033    
1034  while (cc < ccend)  while (cc < ccend)
# Line 995  while (cc < ccend) Line 1036  while (cc < ccend)
1036    space = 0;    space = 0;
1037    size = 0;    size = 0;
1038    bracketlen = 0;    bracketlen = 0;
1039      if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
1040        return;
1041    
1042      if (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND)
1043        if (detect_repeat(common, cc))
1044          {
1045          /* These brackets are converted to repeats, so no global
1046          based single character repeat is allowed. */
1047          if (cc >= end)
1048            end = bracketend(cc);
1049          }
1050    
1051    switch(*cc)    switch(*cc)
1052      {      {
1053        case OP_KET:
1054        if (common->private_data_ptrs[cc + 1 - common->start] != 0)
1055          {
1056          common->private_data_ptrs[cc - common->start] = private_data_ptr;
1057          private_data_ptr += sizeof(sljit_sw);
1058          cc += common->private_data_ptrs[cc + 1 - common->start];
1059          }
1060        cc += 1 + LINK_SIZE;
1061        break;
1062    
1063      case OP_ASSERT:      case OP_ASSERT:
1064      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1065      case OP_ASSERTBACK:      case OP_ASSERTBACK:
# Line 1090  while (cc < ccend) Line 1153  while (cc < ccend)
1153      break;      break;
1154      }      }
1155    
1156      /* Character iterators, which are not inside a repeated bracket,
1157         gets a private slot instead of allocating it on the stack. */
1158    if (space > 0 && cc >= end)    if (space > 0 && cc >= end)
1159      {      {
1160      common->private_data_ptrs[cc - common->start] = private_data_ptr;      common->private_data_ptrs[cc - common->start] = private_data_ptr;
# Line 1120  while (cc < ccend) Line 1185  while (cc < ccend)
1185      cc += bracketlen;      cc += bracketlen;
1186      }      }
1187    }    }
1188    *private_data_start = private_data_ptr;
1189  }  }
1190    
1191  /* Returns with -1 if no need for frame. */  /* Returns with a frame_types (always < 0) if no need for frame. */
1192  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)
1193  {  {
 pcre_uchar *ccend = bracketend(cc);  
1194  int length = 0;  int length = 0;
1195  BOOL possessive = FALSE;  int possessive = 0;
1196    BOOL stack_restore = FALSE;
1197  BOOL setsom_found = recursive;  BOOL setsom_found = recursive;
1198  BOOL setmark_found = recursive;  BOOL setmark_found = recursive;
1199    /* The last capture is a local variable even for recursions. */
1200    BOOL capture_last_found = FALSE;
1201    
1202  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))  #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
1203    SLJIT_ASSERT(common->control_head_ptr != 0);
1204    *needs_control_head = TRUE;
1205    #else
1206    *needs_control_head = FALSE;
1207    #endif
1208    
1209    if (ccend == NULL)
1210    {    {
1211    length = 3;    ccend = bracketend(cc) - (1 + LINK_SIZE);
1212    possessive = TRUE;    if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
1213        {
1214        possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
1215        /* This is correct regardless of common->capture_last_ptr. */
1216        capture_last_found = TRUE;
1217        }
1218      cc = next_opcode(common, cc);
1219    }    }
1220    
 cc = next_opcode(common, cc);  
1221  SLJIT_ASSERT(cc != NULL);  SLJIT_ASSERT(cc != NULL);
1222  while (cc < ccend)  while (cc < ccend)
1223    switch(*cc)    switch(*cc)
1224      {      {
1225      case OP_SET_SOM:      case OP_SET_SOM:
1226      SLJIT_ASSERT(common->has_set_som);      SLJIT_ASSERT(common->has_set_som);
1227        stack_restore = TRUE;
1228      if (!setsom_found)      if (!setsom_found)
1229        {        {
1230        length += 2;        length += 2;
# Line 1153  while (cc < ccend) Line 1234  while (cc < ccend)
1234      break;      break;
1235    
1236      case OP_MARK:      case OP_MARK:
1237        case OP_PRUNE_ARG:
1238        case OP_THEN_ARG:
1239      SLJIT_ASSERT(common->mark_ptr != 0);      SLJIT_ASSERT(common->mark_ptr != 0);
1240        stack_restore = TRUE;
1241      if (!setmark_found)      if (!setmark_found)
1242        {        {
1243        length += 2;        length += 2;
1244        setmark_found = TRUE;        setmark_found = TRUE;
1245        }        }
1246        if (common->control_head_ptr != 0)
1247          *needs_control_head = TRUE;
1248      cc += 1 + 2 + cc[1];      cc += 1 + 2 + cc[1];
1249      break;      break;
1250    
1251      case OP_RECURSE:      case OP_RECURSE:
1252        stack_restore = TRUE;
1253      if (common->has_set_som && !setsom_found)      if (common->has_set_som && !setsom_found)
1254        {        {
1255        length += 2;        length += 2;
# Line 1173  while (cc < ccend) Line 1260  while (cc < ccend)
1260        length += 2;        length += 2;
1261        setmark_found = TRUE;        setmark_found = TRUE;
1262        }        }
1263        if (common->capture_last_ptr != 0 && !capture_last_found)
1264          {
1265          length += 2;
1266          capture_last_found = TRUE;
1267          }
1268      cc += 1 + LINK_SIZE;      cc += 1 + LINK_SIZE;
1269      break;      break;
1270    
# Line 1180  while (cc < ccend) Line 1272  while (cc < ccend)
1272      case OP_CBRAPOS:      case OP_CBRAPOS:
1273      case OP_SCBRA:      case OP_SCBRA:
1274      case OP_SCBRAPOS:      case OP_SCBRAPOS:
1275        stack_restore = TRUE;
1276        if (common->capture_last_ptr != 0 && !capture_last_found)
1277          {
1278          length += 2;
1279          capture_last_found = TRUE;
1280          }
1281      length += 3;      length += 3;
1282      cc += 1 + LINK_SIZE + IMM2_SIZE;      cc += 1 + LINK_SIZE + IMM2_SIZE;
1283      break;      break;
1284    
1285      default:      default:
1286        stack_restore = TRUE;
1287        /* Fall through. */
1288    
1289        case OP_NOT_WORD_BOUNDARY:
1290        case OP_WORD_BOUNDARY:
1291        case OP_NOT_DIGIT:
1292        case OP_DIGIT:
1293        case OP_NOT_WHITESPACE:
1294        case OP_WHITESPACE:
1295        case OP_NOT_WORDCHAR:
1296        case OP_WORDCHAR:
1297        case OP_ANY:
1298        case OP_ALLANY:
1299        case OP_ANYBYTE:
1300        case OP_NOTPROP:
1301        case OP_PROP:
1302        case OP_ANYNL:
1303        case OP_NOT_HSPACE:
1304        case OP_HSPACE:
1305        case OP_NOT_VSPACE:
1306        case OP_VSPACE:
1307        case OP_EXTUNI:
1308        case OP_EODN:
1309        case OP_EOD:
1310        case OP_CIRC:
1311        case OP_CIRCM:
1312        case OP_DOLL:
1313        case OP_DOLLM:
1314        case OP_CHAR:
1315        case OP_CHARI:
1316        case OP_NOT:
1317        case OP_NOTI:
1318    
1319        case OP_EXACT:
1320        case OP_POSSTAR:
1321        case OP_POSPLUS:
1322        case OP_POSQUERY:
1323        case OP_POSUPTO:
1324    
1325        case OP_EXACTI:
1326        case OP_POSSTARI:
1327        case OP_POSPLUSI:
1328        case OP_POSQUERYI:
1329        case OP_POSUPTOI:
1330    
1331        case OP_NOTEXACT:
1332        case OP_NOTPOSSTAR:
1333        case OP_NOTPOSPLUS:
1334        case OP_NOTPOSQUERY:
1335        case OP_NOTPOSUPTO:
1336    
1337        case OP_NOTEXACTI:
1338        case OP_NOTPOSSTARI:
1339        case OP_NOTPOSPLUSI:
1340        case OP_NOTPOSQUERYI:
1341        case OP_NOTPOSUPTOI:
1342    
1343        case OP_TYPEEXACT:
1344        case OP_TYPEPOSSTAR:
1345        case OP_TYPEPOSPLUS:
1346        case OP_TYPEPOSQUERY:
1347        case OP_TYPEPOSUPTO:
1348    
1349        case OP_CLASS:
1350        case OP_NCLASS:
1351        case OP_XCLASS:
1352    
1353      cc = next_opcode(common, cc);      cc = next_opcode(common, cc);
1354      SLJIT_ASSERT(cc != NULL);      SLJIT_ASSERT(cc != NULL);
1355      break;      break;
1356      }      }
1357    
1358  /* Possessive quantifiers can use a special case. */  /* Possessive quantifiers can use a special case. */
1359  if (SLJIT_UNLIKELY(possessive) && length == 3)  if (SLJIT_UNLIKELY(possessive == length))
1360    return -1;    return stack_restore ? no_frame : no_stack;
1361    
1362  if (length > 0)  if (length > 0)
1363    return length + 1;    return length + 1;
1364  return -1;  return stack_restore ? no_frame : no_stack;
1365  }  }
1366    
1367  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)
1368  {  {
1369  DEFINE_COMPILER;  DEFINE_COMPILER;
 pcre_uchar *ccend = bracketend(cc);  
1370  BOOL setsom_found = recursive;  BOOL setsom_found = recursive;
1371  BOOL setmark_found = recursive;  BOOL setmark_found = recursive;
1372    /* The last capture is a local variable even for recursions. */
1373    BOOL capture_last_found = FALSE;
1374  int offset;  int offset;
1375    
1376  /* >= 1 + shortest item size (2) */  /* >= 1 + shortest item size (2) */
# Line 1212  SLJIT_UNUSED_ARG(stacktop); Line 1378  SLJIT_UNUSED_ARG(stacktop);
1378  SLJIT_ASSERT(stackpos >= stacktop + 2);  SLJIT_ASSERT(stackpos >= stacktop + 2);
1379    
1380  stackpos = STACK(stackpos);  stackpos = STACK(stackpos);
1381  if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))  if (ccend == NULL)
1382    cc = next_opcode(common, cc);    {
1383      ccend = bracketend(cc) - (1 + LINK_SIZE);
1384      if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
1385        cc = next_opcode(common, cc);
1386      }
1387    
1388  SLJIT_ASSERT(cc != NULL);  SLJIT_ASSERT(cc != NULL);
1389  while (cc < ccend)  while (cc < ccend)
1390    switch(*cc)    switch(*cc)
# Line 1223  while (cc < ccend) Line 1394  while (cc < ccend)
1394      if (!setsom_found)      if (!setsom_found)
1395        {        {
1396        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
1397        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setstrbegin);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
1398        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1399        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1400        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
# Line 1233  while (cc < ccend) Line 1404  while (cc < ccend)
1404      break;      break;
1405    
1406      case OP_MARK:      case OP_MARK:
1407        case OP_PRUNE_ARG:
1408        case OP_THEN_ARG:
1409      SLJIT_ASSERT(common->mark_ptr != 0);      SLJIT_ASSERT(common->mark_ptr != 0);
1410      if (!setmark_found)      if (!setmark_found)
1411        {        {
1412        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
1413        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
1414        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1415        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1416        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
# Line 1250  while (cc < ccend) Line 1423  while (cc < ccend)
1423      if (common->has_set_som && !setsom_found)      if (common->has_set_som && !setsom_found)
1424        {        {
1425        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
1426        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setstrbegin);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
1427        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1428        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1429        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
# Line 1259  while (cc < ccend) Line 1432  while (cc < ccend)
1432      if (common->mark_ptr != 0 && !setmark_found)      if (common->mark_ptr != 0 && !setmark_found)
1433        {        {
1434        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
1435        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
1436        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1437        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1438        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1439        setmark_found = TRUE;        setmark_found = TRUE;
1440        }        }
1441        if (common->capture_last_ptr != 0 && !capture_last_found)
1442          {
1443          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
1444          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
1445          stackpos += (int)sizeof(sljit_sw);
1446          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1447          stackpos += (int)sizeof(sljit_sw);
1448          capture_last_found = TRUE;
1449          }
1450      cc += 1 + LINK_SIZE;      cc += 1 + LINK_SIZE;
1451      break;      break;
1452    
# Line 1272  while (cc < ccend) Line 1454  while (cc < ccend)
1454      case OP_CBRAPOS:      case OP_CBRAPOS:
1455      case OP_SCBRA:      case OP_SCBRA:
1456      case OP_SCBRAPOS:      case OP_SCBRAPOS:
1457        if (common->capture_last_ptr != 0 && !capture_last_found)
1458          {
1459          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
1460          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
1461          stackpos += (int)sizeof(sljit_sw);
1462          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1463          stackpos += (int)sizeof(sljit_sw);
1464          capture_last_found = TRUE;
1465          }
1466      offset = (GET2(cc, 1 + LINK_SIZE)) << 1;      offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
1467      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));
1468      stackpos += (int)sizeof(sljit_sw);      stackpos += (int)sizeof(sljit_sw);
# Line 1291  while (cc < ccend) Line 1482  while (cc < ccend)
1482      break;      break;
1483      }      }
1484    
1485  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_end);  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0);
1486  SLJIT_ASSERT(stackpos == STACK(stacktop));  SLJIT_ASSERT(stackpos == STACK(stacktop));
1487  }  }
1488    
1489  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)
1490  {  {
1491  int private_data_length = 2;  int private_data_length = needs_control_head ? 3 : 2;
1492  int size;  int size;
1493  pcre_uchar *alternative;  pcre_uchar *alternative;
1494  /* Calculate the sum of the private machine words. */  /* Calculate the sum of the private machine words. */
# Line 1306  while (cc < ccend) Line 1497  while (cc < ccend)
1497    size = 0;    size = 0;
1498    switch(*cc)    switch(*cc)
1499      {      {
1500        case OP_KET:
1501        if (PRIVATE_DATA(cc) != 0)
1502          private_data_length++;
1503        cc += 1 + LINK_SIZE;
1504        break;
1505    
1506      case OP_ASSERT:      case OP_ASSERT:
1507      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1508      case OP_ASSERTBACK:      case OP_ASSERTBACK:
# Line 1410  return private_data_length; Line 1607  return private_data_length;
1607  }  }
1608    
1609  static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,  static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
1610    BOOL save, int stackptr, int stacktop)    BOOL save, int stackptr, int stacktop, BOOL needs_control_head)
1611  {  {
1612  DEFINE_COMPILER;  DEFINE_COMPILER;
1613  int srcw[2];  int srcw[2];
# Line 1431  stacktop = STACK(stacktop - 1); Line 1628  stacktop = STACK(stacktop - 1);
1628    
1629  if (!save)  if (!save)
1630    {    {
1631    stackptr += sizeof(sljit_sw);    stackptr += (needs_control_head ? 2 : 1) * sizeof(sljit_sw);
1632    if (stackptr < stacktop)    if (stackptr < stacktop)
1633      {      {
1634      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
# Line 1447  if (!save) Line 1644  if (!save)
1644    /* The tmp1next must be TRUE in either way. */    /* The tmp1next must be TRUE in either way. */
1645    }    }
1646    
1647  while (status != end)  do
1648    {    {
1649    count = 0;    count = 0;
1650    switch(status)    switch(status)
# Line 1456  while (status != end) Line 1653  while (status != end)
1653      SLJIT_ASSERT(save && common->recursive_head_ptr != 0);      SLJIT_ASSERT(save && common->recursive_head_ptr != 0);
1654      count = 1;      count = 1;
1655      srcw[0] = common->recursive_head_ptr;      srcw[0] = common->recursive_head_ptr;
1656        if (needs_control_head)
1657          {
1658          SLJIT_ASSERT(common->control_head_ptr != 0);
1659          count = 2;
1660          srcw[1] = common->control_head_ptr;
1661          }
1662      status = loop;      status = loop;
1663      break;      break;
1664    
# Line 1468  while (status != end) Line 1671  while (status != end)
1671    
1672      switch(*cc)      switch(*cc)
1673        {        {
1674          case OP_KET:
1675          if (PRIVATE_DATA(cc) != 0)
1676            {
1677            count = 1;
1678            srcw[0] = PRIVATE_DATA(cc);
1679            }
1680          cc += 1 + LINK_SIZE;
1681          break;
1682    
1683        case OP_ASSERT:        case OP_ASSERT:
1684        case OP_ASSERT_NOT:        case OP_ASSERT_NOT:
1685        case OP_ASSERTBACK:        case OP_ASSERTBACK:
# Line 1680  while (status != end) Line 1892  while (status != end)
1892        }        }
1893      }      }
1894    }    }
1895    while (status != end);
1896    
1897  if (save)  if (save)
1898    {    {
# Line 1713  if (save) Line 1926  if (save)
1926  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
1927  }  }
1928    
1929    static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)
1930    {
1931    pcre_uchar *end = bracketend(cc);
1932    BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
1933    
1934    /* Assert captures then. */
1935    if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
1936      current_offset = NULL;
1937    /* Conditional block does not. */
1938    if (*cc == OP_COND || *cc == OP_SCOND)
1939      has_alternatives = FALSE;
1940    
1941    cc = next_opcode(common, cc);
1942    if (has_alternatives)
1943      current_offset = common->then_offsets + (cc - common->start);
1944    
1945    while (cc < end)
1946      {
1947      if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
1948        cc = set_then_offsets(common, cc, current_offset);
1949      else
1950        {
1951        if (*cc == OP_ALT && has_alternatives)
1952          current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);
1953        if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)
1954          *current_offset = 1;
1955        cc = next_opcode(common, cc);
1956        }
1957      }
1958    
1959    return end;
1960    }
1961    
1962  #undef CASE_ITERATOR_PRIVATE_DATA_1  #undef CASE_ITERATOR_PRIVATE_DATA_1
1963  #undef CASE_ITERATOR_PRIVATE_DATA_2A  #undef CASE_ITERATOR_PRIVATE_DATA_2A
1964  #undef CASE_ITERATOR_PRIVATE_DATA_2B  #undef CASE_ITERATOR_PRIVATE_DATA_2B
# Line 1731  while (list) Line 1977  while (list)
1977    {    {
1978    /* sljit_set_label is clever enough to do nothing    /* sljit_set_label is clever enough to do nothing
1979    if either the jump or the label is NULL. */    if either the jump or the label is NULL. */
1980    sljit_set_label(list->jump, label);    SET_LABEL(list->jump, label);
1981    list = list->next;    list = list->next;
1982    }    }
1983  }  }
# Line 1747  if (list_item) Line 1993  if (list_item)
1993    }    }
1994  }  }
1995    
1996  static void add_stub(compiler_common *common, enum stub_types type, int data, struct sljit_jump *start)  static void add_stub(compiler_common *common, struct sljit_jump *start)
1997  {  {
1998  DEFINE_COMPILER;  DEFINE_COMPILER;
1999  stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));  stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
2000    
2001  if (list_item)  if (list_item)
2002    {    {
   list_item->type = type;  
   list_item->data = data;  
2003    list_item->start = start;    list_item->start = start;
2004    list_item->quit = LABEL();    list_item->quit = LABEL();
2005    list_item->next = common->stubs;    list_item->next = common->stubs;
# Line 1771  stub_list* list_item = common->stubs; Line 2015  stub_list* list_item = common->stubs;
2015  while (list_item)  while (list_item)
2016    {    {
2017    JUMPHERE(list_item->start);    JUMPHERE(list_item->start);
2018    switch(list_item->type)    add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
     {  
     case stack_alloc:  
     add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));  
     break;  
     }  
2019    JUMPTO(SLJIT_JUMP, list_item->quit);    JUMPTO(SLJIT_JUMP, list_item->quit);
2020    list_item = list_item->next;    list_item = list_item->next;
2021    }    }
# Line 1804  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0); Line 2043  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
2043  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0);
2044  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);
2045  #endif  #endif
2046  add_stub(common, stack_alloc, 0, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));  add_stub(common, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));
2047  }  }
2048    
2049  static SLJIT_INLINE void free_stack(compiler_common *common, int size)  static SLJIT_INLINE void free_stack(compiler_common *common, int size)
# Line 1818  static SLJIT_INLINE void reset_ovector(c Line 2057  static SLJIT_INLINE void reset_ovector(c
2057  DEFINE_COMPILER;  DEFINE_COMPILER;
2058  struct sljit_label *loop;  struct sljit_label *loop;
2059  int i;  int i;
2060    
2061  /* At this point we can freely use all temporary registers. */  /* At this point we can freely use all temporary registers. */
2062    SLJIT_ASSERT(length > 1);
2063  /* TMP1 returns with begin - 1. */  /* TMP1 returns with begin - 1. */
2064  OP2(SLJIT_SUB, SLJIT_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_SUB, SLJIT_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
2065  if (length < 8)  if (length < 8)
2066    {    {
2067    for (i = 0; i < length; i++)    for (i = 1; i < length; i++)
2068      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_SCRATCH_REG1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_SCRATCH_REG1, 0);
2069    }    }
2070  else  else
2071    {    {
2072    GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, OVECTOR_START - sizeof(sljit_sw));    GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, OVECTOR_START);
2073    OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, length);    OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, length - 1);
2074    loop = LABEL();    loop = LABEL();
2075    OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(sljit_sw), SLJIT_SCRATCH_REG1, 0);    OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(sljit_sw), SLJIT_SCRATCH_REG1, 0);
2076    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 1);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 1);
# Line 1837  else Line 2078  else
2078    }    }
2079  }  }
2080    
2081    static SLJIT_INLINE void do_reset_match(compiler_common *common, int length)
2082    {
2083    DEFINE_COMPILER;
2084    struct sljit_label *loop;
2085    int i;
2086    
2087    SLJIT_ASSERT(length > 1);
2088    /* OVECTOR(1) contains the "string begin - 1" constant. */
2089    if (length > 2)
2090      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
2091    if (length < 8)
2092      {
2093      for (i = 2; i < length; i++)
2094        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), TMP1, 0);
2095      }
2096    else
2097      {
2098      GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw));
2099      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);
2100      loop = LABEL();
2101      OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
2102      OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);
2103      JUMPTO(SLJIT_C_NOT_ZERO, loop);
2104      }
2105    
2106    OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);
2107    if (common->mark_ptr != 0)
2108      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, SLJIT_IMM, 0);
2109    if (common->control_head_ptr != 0)
2110      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
2111    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));
2112    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr);
2113    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, base));
2114    }
2115    
2116    static sljit_sw SLJIT_CALL do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)
2117    {
2118    while (current != NULL)
2119      {
2120      switch (current[-2])
2121        {
2122        case type_then_trap:
2123        break;
2124    
2125        case type_mark:
2126        if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[-3]) == 0)
2127          return current[-4];
2128        break;
2129    
2130        default:
2131        SLJIT_ASSERT_STOP();
2132        break;
2133        }
2134      current = (sljit_sw*)current[-1];
2135      }
2136    return -1;
2137    }
2138    
2139  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
2140  {  {
2141  DEFINE_COMPILER;  DEFINE_COMPILER;
# Line 1890  else Line 2189  else
2189  static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)  static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)
2190  {  {
2191  DEFINE_COMPILER;  DEFINE_COMPILER;
2192    struct sljit_jump *jump;
2193    
2194  SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);  SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);
2195  SLJIT_ASSERT(common->start_used_ptr != 0 && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));  SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0
2196      && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
2197    
2198  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);
2199  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
2200  OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offset_count));  OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
2201  CMPTO(SLJIT_C_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 2, quit);  CMPTO(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 2, quit);
2202    
2203  /* Store match begin and end. */  /* Store match begin and end. */
2204  OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, begin));  OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, begin));
2205  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));
2206    
2207    jump = CMP(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 3);
2208    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);
2209    #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
2210    OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);
2211    #endif
2212    OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 2 * sizeof(int), SLJIT_SCRATCH_REG3, 0);
2213    JUMPHERE(jump);
2214    
2215  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
2216  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);
2217  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
# Line 2078  else if (common->mode == JIT_PARTIAL_SOF Line 2388  else if (common->mode == JIT_PARTIAL_SOF
2388    jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);    jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);
2389    
2390  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2391    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
2392  else  else
2393    {    {
2394    if (common->partialmatchlabel != NULL)    if (common->partialmatchlabel != NULL)
# Line 2091  if (jump != NULL) Line 2401  if (jump != NULL)
2401    JUMPHERE(jump);    JUMPHERE(jump);
2402  }  }
2403    
2404  static struct sljit_jump *check_str_end(compiler_common *common)  static void check_str_end(compiler_common *common, jump_list **end_reached)
2405  {  {
2406  /* Does not affect registers. Usually used in a tight spot. */  /* Does not affect registers. Usually used in a tight spot. */
2407  DEFINE_COMPILER;  DEFINE_COMPILER;
2408  struct sljit_jump *jump;  struct sljit_jump *jump;
 struct sljit_jump *nohit;  
 struct sljit_jump *return_value;  
2409    
2410  if (common->mode == JIT_COMPILE)  if (common->mode == JIT_COMPILE)
2411    return CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);    {
2412      add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
2413      return;
2414      }
2415    
2416  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
2417  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2418    {    {
2419    nohit = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
2420    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
2421    JUMPHERE(nohit);    add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));
   return_value = JUMP(SLJIT_JUMP);  
2422    }    }
2423  else  else
2424    {    {
2425    return_value = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
2426    if (common->partialmatchlabel != NULL)    if (common->partialmatchlabel != NULL)
2427      JUMPTO(SLJIT_JUMP, common->partialmatchlabel);      JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
2428    else    else
2429      add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));      add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
2430    }    }
2431  JUMPHERE(jump);  JUMPHERE(jump);
 return return_value;  
2432  }  }
2433    
2434  static void detect_partial_match(compiler_common *common, jump_list **backtracks)  static void detect_partial_match(compiler_common *common, jump_list **backtracks)
# Line 2138  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR Line 2447  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR
2447  add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));  add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
2448  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2449    {    {
2450    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
2451    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
2452    }    }
2453  else  else
# Line 3060  GET_LOCAL_BASE(TMP3, 0, 0); Line 3369  GET_LOCAL_BASE(TMP3, 0, 0);
3369  /* Drop frames until we reach STACK_TOP. */  /* Drop frames until we reach STACK_TOP. */
3370  mainloop = LABEL();  mainloop = LABEL();
3371  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
3372  jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);  OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);
3373    jump = JUMP(SLJIT_C_SIG_LESS_EQUAL);
3374    
3375  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
3376  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
3377  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));
# Line 3068  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I Line 3379  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
3379  JUMPTO(SLJIT_JUMP, mainloop);  JUMPTO(SLJIT_JUMP, mainloop);
3380    
3381  JUMPHERE(jump);  JUMPHERE(jump);
3382  jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);  jump = JUMP(SLJIT_C_SIG_LESS);
3383  /* End of dropping frames. */  /* End of dropping frames. */
3384  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
3385    
3386  JUMPHERE(jump);  JUMPHERE(jump);
3387  jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setstrbegin);  OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);
3388  /* Set string begin. */  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
3389  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));  
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);  
 JUMPTO(SLJIT_JUMP, mainloop);  
   
 JUMPHERE(jump);  
 if (common->mark_ptr != 0)  
   {  
   jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setmark);  
   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));  
   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));  
   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);  
   JUMPTO(SLJIT_JUMP, mainloop);  
   
   JUMPHERE(jump);  
   }  
   
 /* Unknown command. */  
3390  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
3391  JUMPTO(SLJIT_JUMP, mainloop);  JUMPTO(SLJIT_JUMP, mainloop);
3392  }  }
# Line 3101  static void check_wordboundary(compiler_ Line 3395  static void check_wordboundary(compiler_
3395  {  {
3396  DEFINE_COMPILER;  DEFINE_COMPILER;
3397  struct sljit_jump *skipread;  struct sljit_jump *skipread;
3398    jump_list *skipread_list = NULL;
3399  #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF  #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF
3400  struct sljit_jump *jump;  struct sljit_jump *jump;
3401  #endif  #endif
# Line 3158  else Line 3453  else
3453  JUMPHERE(skipread);  JUMPHERE(skipread);
3454    
3455  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
3456  skipread = check_str_end(common);  check_str_end(common, &skipread_list);
3457  peek_char(common);  peek_char(common);
3458    
3459  /* Testing char type. This is a code duplication. */  /* Testing char type. This is a code duplication. */
# Line 3199  else Line 3494  else
3494      JUMPHERE(jump);      JUMPHERE(jump);
3495  #endif /* COMPILE_PCRE8 */  #endif /* COMPILE_PCRE8 */
3496    }    }
3497  JUMPHERE(skipread);  set_jumps(skipread_list, LABEL());
3498    
3499  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
3500  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
# Line 3839  while (*cc != XCL_END) Line 4134  while (*cc != XCL_END)
4134        break;        break;
4135    
4136        case PT_CLIST:        case PT_CLIST:
4137          case PT_UCNC:
4138        needschar = TRUE;        needschar = TRUE;
4139        break;        break;
4140    
# Line 4040  while (*cc != XCL_END) Line 4336  while (*cc != XCL_END)
4336        case PT_WORD:        case PT_WORD:
4337        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE - charoffset);
4338        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
4339        /* ... fall through */        /* Fall through. */
4340    
4341        case PT_ALNUM:        case PT_ALNUM:
4342        SET_TYPE_OFFSET(ucp_Ll);        SET_TYPE_OFFSET(ucp_Ll);
# Line 4104  while (*cc != XCL_END) Line 4400  while (*cc != XCL_END)
4400          }          }
4401        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4402        break;        break;
4403    
4404          case PT_UCNC:
4405          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_DOLLAR_SIGN - charoffset);
4406          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
4407          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_COMMERCIAL_AT - charoffset);
4408          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4409          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_GRAVE_ACCENT - charoffset);
4410          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4411    
4412          SET_CHAR_OFFSET(0xa0);
4413          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd7ff - charoffset);
4414          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
4415          SET_CHAR_OFFSET(0);
4416          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);
4417          OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_GREATER_EQUAL);
4418          jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4419          break;
4420        }        }
4421      cc += 2;      cc += 2;
4422      }      }
# Line 4129  int length; Line 4442  int length;
4442  unsigned int c, oc, bit;  unsigned int c, oc, bit;
4443  compare_context context;  compare_context context;
4444  struct sljit_jump *jump[4];  struct sljit_jump *jump[4];
4445    jump_list *end_list;
4446  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
4447  struct sljit_label *label;  struct sljit_label *label;
4448  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 4197  switch(type) Line 4511  switch(type)
4511    if (common->nltype == NLTYPE_FIXED && common->newline > 255)    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
4512      {      {
4513      jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);      jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
4514        end_list = NULL;
4515      if (common->mode != JIT_PARTIAL_HARD_COMPILE)      if (common->mode != JIT_PARTIAL_HARD_COMPILE)
4516        jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);        add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
4517      else      else
4518        jump[1] = check_str_end(common);        check_str_end(common, &end_list);
4519    
4520      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
4521      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
4522      if (jump[1] != NULL)      set_jumps(end_list, LABEL());
       JUMPHERE(jump[1]);  
4523      JUMPHERE(jump[0]);      JUMPHERE(jump[0]);
4524      }      }
4525    else    else
# Line 4264  switch(type) Line 4578  switch(type)
4578    read_char(common);    read_char(common);
4579    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
4580    /* We don't need to handle soft partial matching case. */    /* We don't need to handle soft partial matching case. */
4581      end_list = NULL;
4582    if (common->mode != JIT_PARTIAL_HARD_COMPILE)    if (common->mode != JIT_PARTIAL_HARD_COMPILE)
4583      jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);      add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
4584    else    else
4585      jump[1] = check_str_end(common);      check_str_end(common, &end_list);
4586    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
4587    jump[2] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);    jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
4588    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
4589    jump[3] = JUMP(SLJIT_JUMP);    jump[2] = JUMP(SLJIT_JUMP);
4590    JUMPHERE(jump[0]);    JUMPHERE(jump[0]);
4591    check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);    check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);
4592      set_jumps(end_list, LABEL());
4593    JUMPHERE(jump[1]);    JUMPHERE(jump[1]);
4594    JUMPHERE(jump[2]);    JUMPHERE(jump[2]);
   JUMPHERE(jump[3]);  
4595    return cc;    return cc;
4596    
4597    case OP_NOT_HSPACE:    case OP_NOT_HSPACE:
# Line 5026  DEFINE_COMPILER; Line 5341  DEFINE_COMPILER;
5341  backtrack_common *backtrack;  backtrack_common *backtrack;
5342  recurse_entry *entry = common->entries;  recurse_entry *entry = common->entries;
5343  recurse_entry *prev = NULL;  recurse_entry *prev = NULL;
5344  int start = GET(cc, 1);  sljit_sw start = GET(cc, 1);
5345    pcre_uchar *start_cc;
5346    BOOL needs_control_head;
5347    
5348  PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);  PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
5349    
5350    /* Inlining simple patterns. */
5351    if (get_framesize(common, common->start + start, NULL, TRUE, &needs_control_head) == no_stack)
5352      {
5353      start_cc = common->start + start;
5354      compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);
5355      BACKTRACK_AS(recurse_backtrack)->inlined_pattern = TRUE;
5356      return cc + 1 + LINK_SIZE;
5357      }
5358    
5359  while (entry != NULL)  while (entry != NULL)
5360    {    {
5361    if (entry->start == start)    if (entry->start == start)
# Line 5140  allocate_stack(common, CALLOUT_ARG_SIZE Line 5467  allocate_stack(common, CALLOUT_ARG_SIZE
5467  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
5468  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
5469  SLJIT_ASSERT(common->capture_last_ptr != 0);  SLJIT_ASSERT(common->capture_last_ptr != 0);
5470  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);  OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);
5471  OP1(SLJIT_MOV_UI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(capture_last), TMP2, 0);  OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(capture_last), TMP2, 0);
5472    
5473  /* These pointer sized fields temporarly stores internal variables. */  /* These pointer sized fields temporarly stores internal variables. */
5474  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
# Line 5150  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CA Line 5477  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CA
5477    
5478  if (common->mark_ptr != 0)  if (common->mark_ptr != 0)
5479    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr));    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr));
5480  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 2));  OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 2));
5481  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(next_item_length), SLJIT_IMM, GET(cc, 2 + LINK_SIZE));  OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(next_item_length), SLJIT_IMM, GET(cc, 2 + LINK_SIZE));
5482  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(mark), (common->mark_ptr != 0) ? TMP2 : SLJIT_IMM, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(mark), (common->mark_ptr != 0) ? TMP2 : SLJIT_IMM, 0);
5483    
5484  /* Needed to save important temporary registers. */  /* Needed to save important temporary registers. */
# Line 5180  static pcre_uchar *compile_assert_matchi Line 5507  static pcre_uchar *compile_assert_matchi
5507  {  {
5508  DEFINE_COMPILER;  DEFINE_COMPILER;
5509  int framesize;  int framesize;
5510    int extrasize;
5511    BOOL needs_control_head;
5512  int private_data_ptr;  int private_data_ptr;
5513  backtrack_common altbacktrack;  backtrack_common altbacktrack;
5514  pcre_uchar *ccbegin;  pcre_uchar *ccbegin;
# Line 5189  jump_list *tmp = NULL; Line 5518  jump_list *tmp = NULL;
5518  jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;  jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
5519  jump_list **found;  jump_list **found;
5520  /* Saving previous accept variables. */  /* Saving previous accept variables. */
5521    BOOL save_local_exit = common->local_exit;
5522    BOOL save_positive_assert = common->positive_assert;
5523    then_trap_backtrack *save_then_trap = common->then_trap;
5524  struct sljit_label *save_quit_label = common->quit_label;  struct sljit_label *save_quit_label = common->quit_label;
5525  struct sljit_label *save_accept_label = common->accept_label;  struct sljit_label *save_accept_label = common->accept_label;
5526  jump_list *save_quit = common->quit;  jump_list *save_quit = common->quit;
5527    jump_list *save_positive_assert_quit = common->positive_assert_quit;
5528  jump_list *save_accept = common->accept;  jump_list *save_accept = common->accept;
5529  struct sljit_jump *jump;  struct sljit_jump *jump;
5530  struct sljit_jump *brajump = NULL;  struct sljit_jump *brajump = NULL;
5531    
5532    /* Assert captures then. */
5533    common->then_trap = NULL;
5534    
5535  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
5536    {    {
5537    SLJIT_ASSERT(!conditional);    SLJIT_ASSERT(!conditional);
# Line 5204  if (*cc == OP_BRAZERO || *cc == OP_BRAMI Line 5540  if (*cc == OP_BRAZERO || *cc == OP_BRAMI
5540    }    }
5541  private_data_ptr = PRIVATE_DATA(cc);  private_data_ptr = PRIVATE_DATA(cc);
5542  SLJIT_ASSERT(private_data_ptr != 0);  SLJIT_ASSERT(private_data_ptr != 0);
5543  framesize = get_framesize(common, cc, FALSE);  framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
5544  backtrack->framesize = framesize;  backtrack->framesize = framesize;
5545  backtrack->private_data_ptr = private_data_ptr;  backtrack->private_data_ptr = private_data_ptr;
5546  opcode = *cc;  opcode = *cc;
# Line 5223  if (bra == OP_BRAMINZERO) Line 5559  if (bra == OP_BRAMINZERO)
5559    
5560  if (framesize < 0)  if (framesize < 0)
5561    {    {
5562    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);    extrasize = needs_control_head ? 2 : 1;
5563    allocate_stack(common, 1);    if (framesize == no_frame)
5564        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
5565      allocate_stack(common, extrasize);
5566      if (needs_control_head)
5567        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
5568    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5569      if (needs_control_head)
5570        {
5571        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
5572        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
5573        }
5574    }    }
5575  else  else
5576    {    {
5577    allocate_stack(common, framesize + 2);    extrasize = needs_control_head ? 3 : 2;
5578      allocate_stack(common, framesize + extrasize);
5579    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
5580    OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(framesize + 1));    OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
5581    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
5582      if (needs_control_head)
5583        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
5584    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5585    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);    if (needs_control_head)
5586    init_frame(common, ccbegin, framesize + 1, 2, FALSE);      {
5587        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
5588        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
5589        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
5590        }
5591      else
5592        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
5593      init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);
5594    }    }
5595    
5596  memset(&altbacktrack, 0, sizeof(backtrack_common));  memset(&altbacktrack, 0, sizeof(backtrack_common));
5597  common->quit_label = NULL;  if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
5598  common->quit = NULL;    {
5599      /* Negative assert is stronger than positive assert. */
5600      common->local_exit = TRUE;
5601      common->quit_label = NULL;
5602      common->quit = NULL;
5603      common->positive_assert = FALSE;
5604      }
5605    else
5606      common->positive_assert = TRUE;
5607    common->positive_assert_quit = NULL;
5608    
5609  while (1)  while (1)
5610    {    {
5611    common->accept_label = NULL;    common->accept_label = NULL;
# Line 5255  while (1) Line 5620  while (1)
5620    compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);    compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
5621    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
5622      {      {
5623      common->quit_label = save_quit_label;      if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
5624          {
5625          common->local_exit = save_local_exit;
5626          common->quit_label = save_quit_label;
5627          common->quit = save_quit;
5628          }
5629        common->positive_assert = save_positive_assert;
5630        common->then_trap = save_then_trap;
5631      common->accept_label = save_accept_label;      common->accept_label = save_accept_label;
5632      common->quit = save_quit;      common->positive_assert_quit = save_positive_assert_quit;
5633      common->accept = save_accept;      common->accept = save_accept;
5634      return NULL;      return NULL;
5635      }      }
# Line 5267  while (1) Line 5639  while (1)
5639    
5640    /* Reset stack. */    /* Reset stack. */
5641    if (framesize < 0)    if (framesize < 0)
5642      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);      {
5643    else {      if (framesize == no_frame)
5644          OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
5645        else
5646          free_stack(common, extrasize);
5647        if (needs_control_head)
5648          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);
5649        }
5650      else
5651        {
5652      if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)      if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)
5653        {        {
5654        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
5655        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
5656          if (needs_control_head)
5657            OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);
5658        }        }
5659      else      else
5660        {        {
5661        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
5662          if (needs_control_head)
5663            OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_sw));
5664        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
5665        }        }
5666    }      }
5667    
5668    if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)    if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
5669      {      {
5670      /* We know that STR_PTR was stored on the top of the stack. */      /* We know that STR_PTR was stored on the top of the stack. */
5671      if (conditional)      if (conditional)
5672        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), needs_control_head ? sizeof(sljit_sw) : 0);
5673      else if (bra == OP_BRAZERO)      else if (bra == OP_BRAZERO)
5674        {        {
5675        if (framesize < 0)        if (framesize < 0)
5676          OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);          OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 1) * sizeof(sljit_sw));
5677        else        else
5678          {          {
5679          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));
5680          OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_sw));          OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + extrasize - 1) * sizeof(sljit_sw));
5681          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
5682          }          }
5683        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
# Line 5310  while (1) Line 5694  while (1)
5694    compile_backtrackingpath(common, altbacktrack.top);    compile_backtrackingpath(common, altbacktrack.top);
5695    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
5696      {      {
5697      common->quit_label = save_quit_label;      if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
5698          {
5699          common->local_exit = save_local_exit;
5700          common->quit_label = save_quit_label;
5701          common->quit = save_quit;
5702          }
5703        common->positive_assert = save_positive_assert;
5704        common->then_trap = save_then_trap;
5705      common->accept_label = save_accept_label;      common->accept_label = save_accept_label;
5706      common->quit = save_quit;      common->positive_assert_quit = save_positive_assert_quit;
5707      common->accept = save_accept;      common->accept = save_accept;
5708      return NULL;      return NULL;
5709      }      }
# Line 5324  while (1) Line 5715  while (1)
5715    ccbegin = cc;    ccbegin = cc;
5716    cc += GET(cc, 1);    cc += GET(cc, 1);
5717    }    }
5718    
5719    if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
5720      {
5721      SLJIT_ASSERT(common->positive_assert_quit == NULL);
5722      /* Makes the check less complicated below. */
5723      common->positive_assert_quit = common->quit;
5724      }
5725    
5726  /* None of them matched. */  /* None of them matched. */
5727  if (common->quit != NULL)  if (common->positive_assert_quit != NULL)
5728    set_jumps(common->quit, LABEL());    {
5729      jump = JUMP(SLJIT_JUMP);
5730      set_jumps(common->positive_assert_quit, LABEL());
5731      SLJIT_ASSERT(framesize != no_stack);
5732      if (framesize < 0)
5733        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, extrasize * sizeof(sljit_sw));
5734      else
5735        {
5736        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
5737        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
5738        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
5739        }
5740      JUMPHERE(jump);
5741      }
5742    
5743    if (needs_control_head)
5744      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(1));
5745    
5746  if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)  if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
5747    {    {
# Line 5338  if (opcode == OP_ASSERT || opcode == OP_ Line 5753  if (opcode == OP_ASSERT || opcode == OP_
5753      {      {
5754      /* The topmost item should be 0. */      /* The topmost item should be 0. */
5755      if (bra == OP_BRAZERO)      if (bra == OP_BRAZERO)
5756          {
5757          if (extrasize == 2)
5758            free_stack(common, 1);
5759        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5760          }
5761      else      else
5762        free_stack(common, 1);        free_stack(common, extrasize);
5763      }      }
5764    else    else
5765      {      {
5766      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));
5767      /* The topmost item should be 0. */      /* The topmost item should be 0. */
5768      if (bra == OP_BRAZERO)      if (bra == OP_BRAZERO)
5769        {        {
5770        free_stack(common, framesize + 1);        free_stack(common, framesize + extrasize - 1);
5771        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5772        }        }
5773      else      else
5774        free_stack(common, framesize + 2);        free_stack(common, framesize + extrasize);
5775      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
5776      }      }
5777    jump = JUMP(SLJIT_JUMP);    jump = JUMP(SLJIT_JUMP);
# Line 5364  if (opcode == OP_ASSERT || opcode == OP_ Line 5783  if (opcode == OP_ASSERT || opcode == OP_
5783    if (framesize < 0)    if (framesize < 0)
5784      {      {
5785      /* We know that STR_PTR was stored on the top of the stack. */      /* We know that STR_PTR was stored on the top of the stack. */
5786      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 1) * sizeof(sljit_sw));
5787      /* Keep the STR_PTR on the top of the stack. */      /* Keep the STR_PTR on the top of the stack. */
5788      if (bra == OP_BRAZERO)      if (bra == OP_BRAZERO)
5789          {
5790        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
5791          if (extrasize == 2)
5792            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5793          }
5794      else if (bra == OP_BRAMINZERO)      else if (bra == OP_BRAMINZERO)
5795        {        {
5796        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
# Line 5380  if (opcode == OP_ASSERT || opcode == OP_ Line 5803  if (opcode == OP_ASSERT || opcode == OP_
5803        {        {
5804        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
5805        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
5806        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 2) * sizeof(sljit_sw));
5807        }        }
5808      else      else
5809        {        {
5810        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */        /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
5811        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_sw));        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_sw));
5812        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));        if (extrasize == 2)
5813        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);          {
5814            OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5815            if (bra == OP_BRAMINZERO)
5816              OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5817            }
5818          else
5819            {
5820            OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
5821            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
5822            }
5823        }        }
5824      }      }
5825    
5826    if (bra == OP_BRAZERO)    if (bra == OP_BRAZERO)
5827      {      {
5828      backtrack->matchingpath = LABEL();      backtrack->matchingpath = LABEL();
5829      sljit_set_label(jump, backtrack->matchingpath);      SET_LABEL(jump, backtrack->matchingpath);
5830      }      }
5831    else if (bra == OP_BRAMINZERO)    else if (bra == OP_BRAMINZERO)
5832      {      {
# Line 5416  else Line 5848  else
5848      {      {
5849      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5850      if (bra != OP_BRA)      if (bra != OP_BRA)
5851          {
5852          if (extrasize == 2)
5853            free_stack(common, 1);
5854        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5855          }
5856      else      else
5857        free_stack(common, 1);        free_stack(common, extrasize);
5858      }      }
5859    else    else
5860      {      {
5861      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5862      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));
5863      /* The topmost item should be 0. */      /* The topmost item should be 0. */
5864      if (bra != OP_BRA)      if (bra != OP_BRA)
5865        {        {
5866        free_stack(common, framesize + 1);        free_stack(common, framesize + extrasize - 1);
5867        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5868        }        }
5869      else      else
5870        free_stack(common, framesize + 2);        free_stack(common, framesize + extrasize);
5871      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
5872      }      }
5873    
# Line 5451  else Line 5887  else
5887      }      }
5888    }    }
5889    
5890  common->quit_label = save_quit_label;  if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
5891      {
5892      common->local_exit = save_local_exit;
5893      common->quit_label = save_quit_label;
5894      common->quit = save_quit;
5895      }
5896    common->positive_assert = save_positive_assert;
5897    common->then_trap = save_then_trap;
5898  common->accept_label = save_accept_label;  common->accept_label = save_accept_label;
5899  common->quit = save_quit;  common->positive_assert_quit = save_positive_assert_quit;
5900  common->accept = save_accept;  common->accept = save_accept;
5901  return cc + 1 + LINK_SIZE;  return cc + 1 + LINK_SIZE;
5902  }  }
# Line 5568  if (i < name_count) Line 6011  if (i < name_count)
6011  return condition;  return condition;
6012  }  }
6013    
6014    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)
6015    {
6016    DEFINE_COMPILER;
6017    int stacksize;
6018    
6019    if (framesize < 0)
6020      {
6021      if (framesize == no_frame)
6022        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6023      else
6024        {
6025        stacksize = needs_control_head ? 1 : 0;
6026        if (ket != OP_KET || has_alternatives)
6027          stacksize++;
6028        free_stack(common, stacksize);
6029        }
6030    
6031      if (needs_control_head)
6032        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (ket != OP_KET || has_alternatives) ? sizeof(sljit_sw) : 0);
6033    
6034      /* TMP2 which is set here used by OP_KETRMAX below. */
6035      if (ket == OP_KETRMAX)
6036        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
6037      else if (ket == OP_KETRMIN)
6038        {
6039        /* Move the STR_PTR to the private_data_ptr. */
6040        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), 0);
6041        }
6042      }
6043    else
6044      {
6045      stacksize = (ket != OP_KET || has_alternatives) ? 2 : 1;
6046      OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + stacksize) * sizeof(sljit_sw));
6047      if (needs_control_head)
6048        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 0);
6049    
6050      if (ket == OP_KETRMAX)
6051        {
6052        /* TMP2 which is set here used by OP_KETRMAX below. */
6053        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
6054        }
6055      }
6056    if (needs_control_head)
6057      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP1, 0);
6058    }
6059    
6060    static SLJIT_INLINE int match_capture_common(compiler_common *common, int stacksize, int offset, int private_data_ptr)
6061    {
6062    DEFINE_COMPILER;
6063    
6064    if (common->capture_last_ptr != 0)
6065      {
6066      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
6067      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
6068      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
6069      stacksize++;
6070      }
6071    if (common->optimized_cbracket[offset >> 1] == 0)
6072      {
6073      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
6074      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
6075      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
6076      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6077      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
6078      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
6079      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
6080      stacksize += 2;
6081      }
6082    return stacksize;
6083    }
6084    
6085  /*  /*
6086    Handling bracketed expressions is probably the most complex part.    Handling bracketed expressions is probably the most complex part.
6087    
# Line 5630  pcre_uchar opcode; Line 6144  pcre_uchar opcode;
6144  int private_data_ptr = 0;  int private_data_ptr = 0;
6145  int offset = 0;  int offset = 0;
6146  int stacksize;  int stacksize;
6147    int repeat_ptr = 0, repeat_length = 0;
6148    int repeat_type = 0, repeat_count = 0;
6149  pcre_uchar *ccbegin;  pcre_uchar *ccbegin;
6150  pcre_uchar *matchingpath;  pcre_uchar *matchingpath;
6151  pcre_uchar bra = OP_BRA;  pcre_uchar bra = OP_BRA;
6152  pcre_uchar ket;  pcre_uchar ket;
6153  assert_backtrack *assert;  assert_backtrack *assert;
6154  BOOL has_alternatives;  BOOL has_alternatives;
6155    BOOL needs_control_head = FALSE;
6156  struct sljit_jump *jump;  struct sljit_jump *jump;
6157  struct sljit_jump *skip;  struct sljit_jump *skip;
6158  struct sljit_label *rmaxlabel = NULL;  struct sljit_label *rmax_label = NULL;
6159  struct sljit_jump *braminzerojump = NULL;  struct sljit_jump *braminzero = NULL;
6160    
6161  PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);  PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
6162    
# Line 5652  if (*cc == OP_BRAZERO || *cc == OP_BRAMI Line 6169  if (*cc == OP_BRAZERO || *cc == OP_BRAMI
6169    
6170  opcode = *cc;  opcode = *cc;
6171  ccbegin = cc;  ccbegin = cc;
6172  matchingpath = ccbegin + 1 + LINK_SIZE;  matchingpath = bracketend(cc) - 1 - LINK_SIZE;
6173    ket = *matchingpath;
6174    if (ket == OP_KET && PRIVATE_DATA(matchingpath) != 0)
6175      {
6176      repeat_ptr = PRIVATE_DATA(matchingpath);
6177      repeat_length = PRIVATE_DATA(matchingpath + 1);
6178      repeat_type = PRIVATE_DATA(matchingpath + 2);
6179      repeat_count = PRIVATE_DATA(matchingpath + 3);
6180      SLJIT_ASSERT(repeat_length != 0 && repeat_type != 0 && repeat_count != 0);
6181      if (repeat_type == OP_UPTO)
6182        ket = OP_KETRMAX;
6183      if (repeat_type == OP_MINUPTO)
6184        ket = OP_KETRMIN;
6185      }
6186    
6187  if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)  if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
6188    {    {
6189    /* Drop this bracket_backtrack. */    /* Drop this bracket_backtrack. */
6190    parent->top = backtrack->prev;    parent->top = backtrack->prev;
6191    return bracketend(cc);    return matchingpath + 1 + LINK_SIZE + repeat_length;
6192    }    }
6193    
6194  ket = *(bracketend(cc) - 1 - LINK_SIZE);  matchingpath = ccbegin + 1 + LINK_SIZE;
6195  SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);  SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);
6196  SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));  SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));
6197  cc += GET(cc, 1);  cc += GET(cc, 1);
# Line 5711  else if (opcode == OP_ONCE || opcode == Line 6241  else if (opcode == OP_ONCE || opcode ==
6241    SLJIT_ASSERT(private_data_ptr != 0);    SLJIT_ASSERT(private_data_ptr != 0);
6242    BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;    BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
6243    if (opcode == OP_ONCE)    if (opcode == OP_ONCE)
6244      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);
6245    }    }
6246    
6247  /* Instructions before the first alternative. */  /* Instructions before the first alternative. */
6248  stacksize = 0;  stacksize = 0;
6249  if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))  if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
6250    stacksize++;    stacksize++;
6251  if (bra == OP_BRAZERO)  if (bra == OP_BRAZERO)
6252    stacksize++;    stacksize++;
# Line 5725  if (stacksize > 0) Line 6255  if (stacksize > 0)
6255    allocate_stack(common, stacksize);    allocate_stack(common, stacksize);
6256    
6257  stacksize = 0;  stacksize = 0;
6258  if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))  if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
6259    {    {
6260    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
6261    stacksize++;    stacksize++;
# Line 5741  if (bra == OP_BRAMINZERO) Line 6271  if (bra == OP_BRAMINZERO)
6271    if (ket != OP_KETRMIN)    if (ket != OP_KETRMIN)
6272      {      {
6273      free_stack(common, 1);      free_stack(common, 1);
6274      braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);      braminzero = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
6275      }      }
6276    else    else
6277      {      {
# Line 5756  if (bra == OP_BRAMINZERO) Line 6286  if (bra == OP_BRAMINZERO)
6286        if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)        if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
6287          {          {
6288          /* When we come from outside, private_data_ptr contains the previous STR_PTR. */          /* When we come from outside, private_data_ptr contains the previous STR_PTR. */
6289          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);
6290          }          }
6291        else        else
6292          {          {
6293          /* Except when the whole stack frame must be saved. */          /* Except when the whole stack frame must be saved. */
6294          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6295          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));
6296          }          }
6297        JUMPHERE(skip);        JUMPHERE(skip);
6298        }        }
# Line 5775  if (bra == OP_BRAMINZERO) Line 6305  if (bra == OP_BRAMINZERO)
6305      }      }
6306    }    }
6307    
6308    if (repeat_type != 0)
6309      {
6310      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, repeat_count);
6311      if (repeat_type == OP_EXACT)
6312        rmax_label = LABEL();
6313      }
6314    
6315  if (ket == OP_KETRMIN)  if (ket == OP_KETRMIN)
6316    BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();    BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
6317    
6318  if (ket == OP_KETRMAX)  if (ket == OP_KETRMAX)
6319    {    {
6320    rmaxlabel = LABEL();    rmax_label = LABEL();
6321    if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA)    if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA && repeat_type == 0)
6322      BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmaxlabel;      BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmax_label;
6323    }    }
6324    
6325  /* Handling capturing brackets and alternatives. */  /* Handling capturing brackets and alternatives. */
6326  if (opcode == OP_ONCE)  if (opcode == OP_ONCE)
6327    {    {
6328      stacksize = 0;
6329      if (needs_control_head)
6330        {
6331        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
6332        stacksize++;
6333        }
6334    
6335    if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)    if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
6336      {      {
6337      /* Neither capturing brackets nor recursions are not found in the block. */      /* Neither capturing brackets nor recursions are found in the block. */
6338      if (ket == OP_KETRMIN)      if (ket == OP_KETRMIN)
6339        {        {
6340        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);        stacksize += 2;
6341        allocate_stack(common, 2);        if (!needs_control_head)
6342        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));  
6343        }        }
6344      else if (ket == OP_KETRMAX || has_alternatives)      else
6345        {        {
6346        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);        if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
6347        allocate_stack(common, 1);          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
6348        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);        if (ket == OP_KETRMAX || has_alternatives)
6349            stacksize++;
6350        }        }
6351      else  
6352        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);      if (stacksize > 0)
6353          allocate_stack(common, stacksize);
6354    
6355        stacksize = 0;
6356        if (needs_control_head)
6357          {
6358          stacksize++;
6359          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
6360          }
6361    
6362        if (ket == OP_KETRMIN)
6363          {
6364          if (needs_control_head)
6365            OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6366          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
6367          if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
6368            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));
6369          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
6370          }
6371        else if (ket == OP_KETRMAX || has_alternatives)
6372          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
6373      }      }
6374    else    else
6375      {      {
6376      if (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives)      if (ket != OP_KET || has_alternatives)
6377          stacksize++;
6378    
6379        stacksize += BACKTRACK_AS(bracket_backtrack)->u.framesize + 1;
6380        allocate_stack(common, stacksize);
6381    
6382        if (needs_control_head)
6383          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
6384    
6385        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6386        OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));
6387    
6388        stacksize = needs_control_head ? 1 : 0;
6389        if (ket != OP_KET || has_alternatives)
6390        {        {
6391        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);  
6392        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
6393        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);        stacksize++;
6394        init_frame(common, ccbegin, BACKTRACK_AS(bracket_backtrack)->u.framesize + 1, 2, FALSE);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
6395        }        }
6396      else      else
6397        {        {
       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));  
6398        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
6399        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);  
6400        }        }
6401        init_frame(common, ccbegin, NULL, BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize, stacksize + 1, FALSE);
6402      }      }
6403    }    }
6404  else if (opcode == OP_CBRA || opcode == OP_SCBRA)  else if (opcode == OP_CBRA || opcode == OP_SCBRA)
# Line 5964  if (SLJIT_UNLIKELY(sljit_get_compiler_er Line 6534  if (SLJIT_UNLIKELY(sljit_get_compiler_er
6534    return NULL;    return NULL;
6535    
6536  if (opcode == OP_ONCE)  if (opcode == OP_ONCE)
6537    {    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));  
       }  
     }  
   }  
6538    
6539  stacksize = 0;  stacksize = 0;
6540    if (repeat_type == OP_MINUPTO)
6541      {
6542      /* We need to preserve the counter. TMP2 will be used below. */
6543      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);
6544      stacksize++;
6545      }
6546  if (ket != OP_KET || bra != OP_BRA)  if (ket != OP_KET || bra != OP_BRA)
6547    stacksize++;    stacksize++;
6548  if (offset != 0)  if (offset != 0)
# Line 6006  if (stacksize > 0) Line 6559  if (stacksize > 0)
6559    allocate_stack(common, stacksize);    allocate_stack(common, stacksize);
6560    
6561  stacksize = 0;  stacksize = 0;
6562    if (repeat_type == OP_MINUPTO)
6563      {
6564      /* TMP2 was set above. */
6565      OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
6566      stacksize++;
6567      }
6568    
6569  if (ket != OP_KET || bra != OP_BRA)  if (ket != OP_KET || bra != OP_BRA)
6570    {    {
6571    if (ket != OP_KET)    if (ket != OP_KET)
# Line 6016  if (ket != OP_KET || bra != OP_BRA) Line 6576  if (ket != OP_KET || bra != OP_BRA)
6576    }    }
6577    
6578  if (offset != 0)  if (offset != 0)
6579    {    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;  
     }  
   }  
6580    
6581  if (has_alternatives)  if (has_alternatives)
6582    {    {
# Line 6054  if (offset != 0 && common->optimized_cbr Line 6595  if (offset != 0 && common->optimized_cbr
6595    
6596  if (ket == OP_KETRMAX)  if (ket == OP_KETRMAX)
6597    {    {
6598    if (opcode == OP_ONCE || opcode >= OP_SBRA)    if (repeat_type != 0)
6599        {
6600        if (has_alternatives)
6601          BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
6602        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
6603        JUMPTO(SLJIT_C_NOT_ZERO, rmax_label);
6604        /* Drop STR_PTR for greedy plus quantifier. */
6605        if (opcode != OP_ONCE)
6606          free_stack(common, 1);
6607        }
6608      else if (opcode == OP_ONCE || opcode >= OP_SBRA)
6609      {      {
6610      if (has_alternatives)      if (has_alternatives)
6611        BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();        BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
6612      /* Checking zero-length iteration. */      /* Checking zero-length iteration. */
6613      if (opcode != OP_ONCE)      if (opcode != OP_ONCE)
6614        {        {
6615        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);
6616        /* Drop STR_PTR for greedy plus quantifier. */        /* Drop STR_PTR for greedy plus quantifier. */
6617        if (bra != OP_BRAZERO)        if (bra != OP_BRAZERO)
6618          free_stack(common, 1);          free_stack(common, 1);
6619        }        }
6620      else      else
6621        /* TMP2 must contain the starting STR_PTR. */        /* TMP2 must contain the starting STR_PTR. */
6622        CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmaxlabel);        CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmax_label);
6623      }      }
6624    else    else
6625      JUMPTO(SLJIT_JUMP, rmaxlabel);      JUMPTO(SLJIT_JUMP, rmax_label);
6626    BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();    BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
6627    }    }
6628    
6629    if (repeat_type == OP_EXACT)
6630      {
6631      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
6632      JUMPTO(SLJIT_C_NOT_ZERO, rmax_label);
6633      }
6634    else if (repeat_type == OP_UPTO)
6635      {
6636      /* We need to preserve the counter. */
6637      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);
6638      allocate_stack(common, 1);
6639      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
6640      }
6641    
6642  if (bra == OP_BRAZERO)  if (bra == OP_BRAZERO)
6643    BACKTRACK_AS(bracket_backtrack)->zero_matchingpath = LABEL();    BACKTRACK_AS(bracket_backtrack)->zero_matchingpath = LABEL();
6644    
# Line 6082  if (bra == OP_BRAMINZERO) Line 6646  if (bra == OP_BRAMINZERO)
6646    {    {
6647    /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */    /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */
6648    JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->matchingpath);    JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->matchingpath);
6649    if (braminzerojump != NULL)    if (braminzero != NULL)
6650      {      {
6651      JUMPHERE(braminzerojump);      JUMPHERE(braminzero);
6652      /* We need to release the end pointer to perform the      /* We need to release the end pointer to perform the
6653      backtrack for the zero-length iteration. When      backtrack for the zero-length iteration. When
6654      framesize is < 0, OP_ONCE will do the release itself. */      framesize is < 0, OP_ONCE will do the release itself. */
# Line 6106  if ((ket != OP_KET && bra != OP_BRAMINZE Line 6670  if ((ket != OP_KET && bra != OP_BRAMINZE
6670  while (*cc == OP_ALT)  while (*cc == OP_ALT)
6671    cc += GET(cc, 1);    cc += GET(cc, 1);
6672  cc += 1 + LINK_SIZE;  cc += 1 + LINK_SIZE;
6673  return cc;  
6674    /* Temporarily encoding the needs_control_head in framesize. */
6675    if (opcode == OP_ONCE)
6676      BACKTRACK_AS(bracket_backtrack)->u.framesize = (BACKTRACK_AS(bracket_backtrack)->u.framesize << 1) | (needs_control_head ? 1 : 0);
6677    return cc + repeat_length;
6678  }  }
6679    
6680  static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)  static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
# Line 6116  backtrack_common *backtrack; Line 6684  backtrack_common *backtrack;
6684  pcre_uchar opcode;  pcre_uchar opcode;
6685  int private_data_ptr;  int private_data_ptr;
6686  int cbraprivptr = 0;  int cbraprivptr = 0;
6687    BOOL needs_control_head;
6688  int framesize;  int framesize;
6689  int stacksize;  int stacksize;
6690  int offset = 0;  int offset = 0;
6691  BOOL zero = FALSE;  BOOL zero = FALSE;
6692  pcre_uchar *ccbegin = NULL;  pcre_uchar *ccbegin = NULL;
6693  int stack;  int stack; /* Also contains the offset of control head. */
6694  struct sljit_label *loop = NULL;  struct sljit_label *loop = NULL;
6695  struct jump_list *emptymatch = NULL;  struct jump_list *emptymatch = NULL;
6696    
# Line 6159  switch(opcode) Line 6728  switch(opcode)
6728    break;    break;
6729    }    }
6730    
6731  framesize = get_framesize(common, cc, FALSE);  framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
6732  BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;  BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;
6733  if (framesize < 0)  if (framesize < 0)
6734    {    {
6735    stacksize = (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS) ? 2 : 1;    if (offset != 0)
6736        {
6737        stacksize = 2;
6738        if (common->capture_last_ptr != 0)
6739          stacksize++;
6740        }
6741      else
6742        stacksize = 1;
6743    
6744      if (needs_control_head)
6745        stacksize++;
6746    if (!zero)    if (!zero)
6747      stacksize++;      stacksize++;
6748    
6749    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
6750    allocate_stack(common, stacksize);    allocate_stack(common, stacksize);
6751    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);    if (framesize == no_frame)
6752        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
6753    
6754    if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)    stack = 0;
6755      if (offset != 0)
6756      {      {
6757        stack = 2;
6758      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
6759      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
6760      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
6761        if (common->capture_last_ptr != 0)
6762          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
6763      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
6764        if (needs_control_head)
6765          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
6766        if (common->capture_last_ptr != 0)
6767          {
6768          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
6769          stack = 3;
6770          }
6771      }      }
6772    else    else
6773        {
6774        if (needs_control_head)
6775          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
6776      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
6777        stack = 1;
6778        }
6779    
6780      if (needs_control_head)
6781        stack++;
6782    if (!zero)    if (!zero)
6783      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);
6784      if (needs_control_head)
6785        {
6786        stack--;
6787        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);
6788        }
6789    }    }
6790  else  else
6791    {    {
6792    stacksize = framesize + 1;    stacksize = framesize + 1;
6793    if (!zero)    if (!zero)
6794      stacksize++;      stacksize++;
6795    if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)    if (needs_control_head)
6796        stacksize++;
6797      if (offset == 0)
6798      stacksize++;      stacksize++;
6799    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
   allocate_stack(common, stacksize);  
6800    
6801      allocate_stack(common, stacksize);
6802    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6803    OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));    if (needs_control_head)
6804    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);
6805      OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));
6806    
6807    stack = 0;    stack = 0;
6808    if (!zero)    if (!zero)
6809      {      {
6810      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);
6811        stack = 1;
6812        }
6813      if (needs_control_head)
6814        {
6815        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);
6816      stack++;      stack++;
6817      }      }
6818    if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)    if (offset == 0)
6819      {      {
6820      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);
6821      stack++;      stack++;
6822      }      }
6823    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);
6824    init_frame(common, cc, stacksize - 1, stacksize - framesize, FALSE);    init_frame(common, cc, NULL, stacksize - 1, stacksize - framesize, FALSE);
6825      stack -= 1 + (offset == 0);
6826    }    }
6827    
6828  if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)  if (offset != 0)
6829    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
6830    
6831  loop = LABEL();  loop = LABEL();
# Line 6227  while (*cc != OP_KETRPOS) Line 6841  while (*cc != OP_KETRPOS)
6841    
6842    if (framesize < 0)    if (framesize < 0)
6843      {      {
6844      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);      if (framesize == no_frame)
6845          OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6846    
6847      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)      if (offset != 0)
6848        {        {
6849        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
6850        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
6851        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
6852          if (common->capture_last_ptr != 0)
6853            OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
6854        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
6855        }        }
6856      else      else
# Line 6251  while (*cc != OP_KETRPOS) Line 6868  while (*cc != OP_KETRPOS)
6868      }      }
6869    else    else
6870      {      {
6871      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)      if (offset != 0)
6872        {        {
6873        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));
6874        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
6875        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
6876        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
6877          if (common->capture_last_ptr != 0)
6878            OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
6879        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
6880        }        }
6881      else      else
# Line 6279  while (*cc != OP_KETRPOS) Line 6898  while (*cc != OP_KETRPOS)
6898          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
6899        }        }
6900      }      }
6901    
6902      if (needs_control_head)
6903        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));
6904    
6905    JUMPTO(SLJIT_JUMP, loop);    JUMPTO(SLJIT_JUMP, loop);
6906    flush_stubs(common);    flush_stubs(common);
6907    
# Line 6289  while (*cc != OP_KETRPOS) Line 6912  while (*cc != OP_KETRPOS)
6912    
6913    if (framesize < 0)    if (framesize < 0)
6914      {      {
6915      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)      if (offset != 0)
6916        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
6917      else      else
6918        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
6919      }      }
6920    else    else
6921      {      {
6922      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)      if (offset != 0)
6923        {        {
6924        /* Last alternative. */        /* Last alternative. */
6925        if (*cc == OP_KETRPOS)        if (*cc == OP_KETRPOS)
# Line 6315  while (*cc != OP_KETRPOS) Line 6938  while (*cc != OP_KETRPOS)
6938    ccbegin = cc + 1 + LINK_SIZE;    ccbegin = cc + 1 + LINK_SIZE;
6939    }    }
6940    
6941    /* We don't have to restore the control head in case of a failed match. */
6942    
6943  backtrack->topbacktracks = NULL;  backtrack->topbacktracks = NULL;
6944  if (!zero)  if (!zero)
6945    {    {
# Line 6443  PUSH_BACKTRACK(sizeof(iterator_backtrack Line 7068  PUSH_BACKTRACK(sizeof(iterator_backtrack
7068    
7069  cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);  cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);
7070    
7071  switch (type)  switch(type)
7072    {    {
7073    case OP_NOT_DIGIT:    case OP_NOT_DIGIT:
7074    case OP_DIGIT:    case OP_DIGIT:
# Line 6684  add_jump(compiler, &backtrack->topbacktr Line 7309  add_jump(compiler, &backtrack->topbacktr
7309  return cc + 1;  return cc + 1;
7310  }  }
7311    
7312  static SLJIT_INLINE pcre_uchar *compile_close_matchingpath(compiler_common *common, pcre_uchar *cc)  static SLJIT_INLINE pcre_uchar *compile_close_matchingpath(compiler_common *common, pcre_uchar *cc)
7313    {
7314    DEFINE_COMPILER;
7315    int offset = GET2(cc, 1);
7316    BOOL optimized_cbracket = common->optimized_cbracket[offset] != 0;
7317    
7318    /* Data will be discarded anyway... */
7319    if (common->currententry != NULL)
7320      return cc + 1 + IMM2_SIZE;
7321    
7322    if (!optimized_cbracket)
7323      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR_PRIV(offset));
7324    offset <<= 1;
7325    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
7326    if (!optimized_cbracket)
7327      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
7328    return cc + 1 + IMM2_SIZE;
7329    }
7330    
7331    static SLJIT_INLINE pcre_uchar *compile_control_verb_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
7332    {
7333    DEFINE_COMPILER;
7334    backtrack_common *backtrack;
7335    pcre_uchar opcode = *cc;
7336    pcre_uchar *ccend = cc + 1;
7337    
7338    if (opcode == OP_PRUNE_ARG || opcode == OP_SKIP_ARG || opcode == OP_THEN_ARG)
7339      ccend += 2 + cc[1];
7340    
7341    PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
7342    
7343    if (opcode == OP_SKIP)
7344      {
7345      allocate_stack(common, 1);
7346      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
7347      return ccend;
7348      }
7349    
7350    if (opcode == OP_PRUNE_ARG || opcode == OP_THEN_ARG)
7351      {
7352      OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
7353      OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
7354      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
7355      OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
7356      }
7357    
7358    return ccend;
7359    }
7360    
7361    static pcre_uchar then_trap_opcode[1] = { OP_THEN_TRAP };
7362    
7363    static SLJIT_INLINE void compile_then_trap_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
7364  {  {
7365  DEFINE_COMPILER;  DEFINE_COMPILER;
7366  int offset = GET2(cc, 1);  backtrack_common *backtrack;
7367  BOOL optimized_cbracket = common->optimized_cbracket[offset] != 0;  BOOL needs_control_head;
7368    int size;
 /* Data will be discarded anyway... */  
 if (common->currententry != NULL)  
   return cc + 1 + IMM2_SIZE;  
7369    
7370  if (!optimized_cbracket)  PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
7371    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR_PRIV(offset));  common->then_trap = BACKTRACK_AS(then_trap_backtrack);
7372  offset <<= 1;  BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
7373  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);  BACKTRACK_AS(then_trap_backtrack)->start = (sljit_sw)(cc - common->start);
7374  if (!optimized_cbracket)  BACKTRACK_AS(then_trap_backtrack)->framesize = get_framesize(common, cc, ccend, FALSE, &needs_control_head);
7375    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);  
7376  return cc + 1 + IMM2_SIZE;  size = BACKTRACK_AS(then_trap_backtrack)->framesize;
7377    size = 3 + (size < 0 ? 0 : size);
7378    
7379    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
7380    allocate_stack(common, size);
7381    if (size > 3)
7382      OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0, SLJIT_IMM, (size - 3) * sizeof(sljit_sw));
7383    else
7384      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0);
7385    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 1), SLJIT_IMM, BACKTRACK_AS(then_trap_backtrack)->start);
7386    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 2), SLJIT_IMM, type_then_trap);
7387    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 3), TMP2, 0);
7388    
7389    size = BACKTRACK_AS(then_trap_backtrack)->framesize;
7390    if (size >= 0)
7391      init_frame(common, cc, ccend, size - 1, 0, FALSE);
7392  }  }
7393    
7394  static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)  static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
7395  {  {
7396  DEFINE_COMPILER;  DEFINE_COMPILER;
7397  backtrack_common *backtrack;  backtrack_common *backtrack;
7398    BOOL has_then_trap = FALSE;
7399    then_trap_backtrack *save_then_trap = NULL;
7400    
7401    SLJIT_ASSERT(*ccend == OP_END || (*ccend >= OP_ALT && *ccend <= OP_KETRPOS));
7402    
7403    if (common->has_then && common->then_offsets[cc - common->start] != 0)
7404      {
7405      SLJIT_ASSERT(*ccend != OP_END && common->control_head_ptr != 0);
7406      has_then_trap = TRUE;
7407      save_then_trap = common->then_trap;
7408      /* Tail item on backtrack. */
7409      compile_then_trap_matchingpath(common, cc, ccend, parent);
7410      }
7411    
7412  while (cc < ccend)  while (cc < ccend)
7413    {    {
# Line 6923  while (cc < ccend) Line 7624  while (cc < ccend)
7624      PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);      PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
7625      SLJIT_ASSERT(common->mark_ptr != 0);      SLJIT_ASSERT(common->mark_ptr != 0);
7626      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
7627      allocate_stack(common, 1);      allocate_stack(common, common->has_skip_arg ? 5 : 1);
7628      OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);      OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
7629      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);
7630      OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));      OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
7631      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);
7632      OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
7633        if (common->has_skip_arg)
7634          {
7635          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
7636          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0);
7637          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, type_mark);
7638          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), SLJIT_IMM, (sljit_sw)(cc + 2));
7639          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(3), STR_PTR, 0);
7640          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
7641          }
7642      cc += 1 + 2 + cc[1];      cc += 1 + 2 + cc[1];
7643      break;      break;
7644    
7645        case OP_PRUNE:
7646        case OP_PRUNE_ARG:
7647        case OP_SKIP:
7648        case OP_SKIP_ARG:
7649        case OP_THEN:
7650        case OP_THEN_ARG:
7651      case OP_COMMIT:      case OP_COMMIT:
7652      PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);      cc = compile_control_verb_matchingpath(common, cc, parent);
     cc += 1;  
7653      break;      break;
7654    
7655      case OP_FAIL:      case OP_FAIL:
# Line 6958  while (cc < ccend) Line 7673  while (cc < ccend)
7673    if (cc == NULL)    if (cc == NULL)
7674      return;      return;
7675    }    }
7676    
7677    if (has_then_trap)
7678      {
7679      /* Head item on backtrack. */
7680      PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
7681      BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
7682      BACKTRACK_AS(then_trap_backtrack)->then_trap = common->then_trap;
7683      common->then_trap = save_then_trap;
7684      }
7685  SLJIT_ASSERT(cc == ccend);  SLJIT_ASSERT(cc == ccend);
7686  }  }
7687    
# Line 7119  switch(opcode) Line 7843  switch(opcode)
7843    }    }
7844  }  }
7845    
7846  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)
7847  {  {
7848  DEFINE_COMPILER;  DEFINE_COMPILER;
7849  pcre_uchar *cc = current->cc;  pcre_uchar *cc = current->cc;
# Line 7141  set_jumps(current->topbacktracks, LABEL( Line 7865  set_jumps(current->topbacktracks, LABEL(
7865  free_stack(common, 2);  free_stack(common, 2);
7866  }  }
7867    
7868  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)
7869  {  {
7870  DEFINE_COMPILER;  DEFINE_COMPILER;
7871    
7872    if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
7873      compile_backtrackingpath(common, current->top);
7874  set_jumps(current->topbacktracks, LABEL());  set_jumps(current->topbacktracks, LABEL());
7875    if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
7876      return;
7877    
7878  if (common->has_set_som && common->mark_ptr != 0)  if (common->has_set_som && common->mark_ptr != 0)
7879    {    {
# Line 7233  if (bra == OP_BRAZERO) Line 7961  if (bra == OP_BRAZERO)
7961  static void compile_bracket_backtrackingpath(compiler_common *common, struct backtrack_common *current)  static void compile_bracket_backtrackingpath(compiler_common *common, struct backtrack_common *current)
7962  {  {
7963  DEFINE_COMPILER;  DEFINE_COMPILER;
7964  int opcode;  int opcode, stacksize, count;
7965  int offset = 0;  int offset = 0;
7966  int private_data_ptr = CURRENT_AS(bracket_backtrack)->private_data_ptr;  int private_data_ptr = CURRENT_AS(bracket_backtrack)->private_data_ptr;
7967  int stacksize;  int repeat_ptr = 0, repeat_type = 0, repeat_count = 0;
 int count;  
7968  pcre_uchar *cc = current->cc;  pcre_uchar *cc = current->cc;
7969  pcre_uchar *ccbegin;  pcre_uchar *ccbegin;
7970  pcre_uchar *ccprev;  pcre_uchar *ccprev;
# Line 7247  pcre_uchar bra = OP_BRA; Line 7974  pcre_uchar bra = OP_BRA;
7974  pcre_uchar ket;  pcre_uchar ket;
7975  assert_backtrack *assert;  assert_backtrack *assert;
7976  BOOL has_alternatives;  BOOL has_alternatives;
7977    BOOL needs_control_head = FALSE;
7978  struct sljit_jump *brazero = NULL;  struct sljit_jump *brazero = NULL;
7979  struct sljit_jump *once = NULL;  struct sljit_jump *once = NULL;
7980  struct sljit_jump *cond = NULL;  struct sljit_jump *cond = NULL;
7981  struct sljit_label *rminlabel = NULL;  struct sljit_label *rmin_label = NULL;
7982    struct sljit_label *exact_label = NULL;
7983    
7984  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
7985    {    {
# Line 7259  if (*cc == OP_BRAZERO || *cc == OP_BRAMI Line 7988  if (*cc == OP_BRAZERO || *cc == OP_BRAMI
7988    }    }
7989    
7990  opcode = *cc;  opcode = *cc;
7991    ccbegin = bracketend(cc) - 1 - LINK_SIZE;
7992    ket = *ccbegin;
7993    if (ket == OP_KET && PRIVATE_DATA(ccbegin) != 0)
7994      {
7995      repeat_ptr = PRIVATE_DATA(ccbegin);
7996      repeat_type = PRIVATE_DATA(ccbegin + 2);
7997      repeat_count = PRIVATE_DATA(ccbegin + 3);
7998      SLJIT_ASSERT(repeat_type != 0 && repeat_count != 0);
7999      if (repeat_type == OP_UPTO)
8000        ket = OP_KETRMAX;
8001      if (repeat_type == OP_MINUPTO)
8002        ket = OP_KETRMIN;
8003      }
8004  ccbegin = cc;  ccbegin = cc;
 ket = *(bracketend(ccbegin) - 1 - LINK_SIZE);  
8005  cc += GET(cc, 1);  cc += GET(cc, 1);
8006  has_alternatives = *cc == OP_ALT;  has_alternatives = *cc == OP_ALT;
8007  if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))  if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
# Line 7272  if (SLJIT_UNLIKELY(opcode == OP_COND) && Line 8013  if (SLJIT_UNLIKELY(opcode == OP_COND) &&
8013  if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))  if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
8014    opcode = OP_ONCE;    opcode = OP_ONCE;
8015    
8016    /* Decoding the needs_control_head in framesize. */
8017    if (opcode == OP_ONCE)
8018      {
8019      needs_control_head = (CURRENT_AS(bracket_backtrack)->u.framesize & 0x1) != 0;
8020      CURRENT_AS(bracket_backtrack)->u.framesize >>= 1;
8021      }
8022    
8023    if (ket != OP_KET && repeat_type != 0)
8024      {
8025      /* TMP1 is used in OP_KETRMIN below. */
8026      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8027      free_stack(common, 1);
8028      if (repeat_type == OP_UPTO)
8029        OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0, SLJIT_IMM, 1);
8030      else
8031        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0);
8032      }
8033    
8034  if (ket == OP_KETRMAX)  if (ket == OP_KETRMAX)
8035    {    {
8036    if (bra == OP_BRAZERO)    if (bra == OP_BRAZERO)
# Line 7286  else if (ket == OP_KETRMIN) Line 8045  else if (ket == OP_KETRMIN)
8045    if (bra != OP_BRAMINZERO)    if (bra != OP_BRAMINZERO)
8046      {      {
8047      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8048      if (opcode >= OP_SBRA || opcode == OP_ONCE)      if (repeat_type != 0)
8049          {
8050          /* TMP1 was set a few lines above. */
8051          CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
8052          /* Drop STR_PTR for non-greedy plus quantifier. */
8053          if (opcode != OP_ONCE)
8054            free_stack(common, 1);
8055          }
8056        else if (opcode >= OP_SBRA || opcode == OP_ONCE)
8057        {        {
8058        /* Checking zero-length iteration. */        /* Checking zero-length iteration. */
8059        if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)        if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)
# Line 7296  else if (ket == OP_KETRMIN) Line 8063  else if (ket == OP_KETRMIN)
8063          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
8064          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);          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);
8065          }          }
8066          /* Drop STR_PTR for non-greedy plus quantifier. */
8067        if (opcode != OP_ONCE)        if (opcode != OP_ONCE)
8068          free_stack(common, 1);          free_stack(common, 1);
8069        }        }
8070      else      else
8071        JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);        JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
8072      }      }
8073    rminlabel = LABEL();    rmin_label = LABEL();
8074      if (repeat_type != 0)
8075        OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
8076    }    }
8077  else if (bra == OP_BRAZERO)  else if (bra == OP_BRAZERO)
8078    {    {
# Line 7310  else if (bra == OP_BRAZERO) Line 8080  else if (bra == OP_BRAZERO)
8080    free_stack(common, 1);    free_stack(common, 1);
8081    brazero = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);    brazero = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
8082    }    }
8083    else if (repeat_type == OP_EXACT)
8084      {
8085      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
8086      exact_label = LABEL();
8087      }
8088    
8089  if (offset != 0)  if (offset != 0)
8090    {    {
8091    if (common->capture_last_ptr != 0)    if (common->capture_last_ptr != 0)
8092      {      {
8093        SLJIT_ASSERT(common->optimized_cbracket[offset >> 1] == 0);
8094      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8095      free_stack(common, 1);      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
8096      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);
8097        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
8098        free_stack(common, 3);
8099        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP2, 0);
8100        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
8101      }      }
8102    if (common->optimized_cbracket[offset >> 1] == 0)    else if (common->optimized_cbracket[offset >> 1] == 0)
8103      {      {
8104      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8105      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
# Line 7424  if (has_alternatives) Line 8204  if (has_alternatives)
8204      current->top = NULL;      current->top = NULL;
8205      current->topbacktracks = NULL;      current->topbacktracks = NULL;
8206      current->nextbacktracks = NULL;      current->nextbacktracks = NULL;
8207        /* Conditional blocks always have an additional alternative, even if it is empty. */
8208      if (*cc == OP_ALT)      if (*cc == OP_ALT)
8209        {        {
8210        ccprev = cc + 1 + LINK_SIZE;        ccprev = cc + 1 + LINK_SIZE;
8211        cc += GET(cc, 1);        cc += GET(cc, 1);
8212        if (opcode != OP_COND && opcode != OP_SCOND)        if (opcode != OP_COND && opcode != OP_SCOND)
8213          {          {
8214          if (private_data_ptr != 0 && opcode != OP_ONCE)          if (opcode != OP_ONCE)
8215            OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);            {
8216              if (private_data_ptr != 0)
8217                OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
8218              else
8219                OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8220              }
8221          else          else
8222            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));
8223          }          }
8224        compile_matchingpath(common, ccprev, cc, current);        compile_matchingpath(common, ccprev, cc, current);
8225        if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))        if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
# Line 7443  if (has_alternatives) Line 8229  if (has_alternatives)
8229      /* Instructions after the current alternative is succesfully matched. */      /* Instructions after the current alternative is succesfully matched. */
8230      /* There is a similar code in compile_bracket_matchingpath. */      /* There is a similar code in compile_bracket_matchingpath. */
8231      if (opcode == OP_ONCE)      if (opcode == OP_ONCE)
8232        {        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));  
           }  
         }  
       }  
8233    
8234      stacksize = 0;      stacksize = 0;
8235        if (repeat_type == OP_MINUPTO)
8236          {
8237          /* We need to preserve the counter. TMP2 will be used below. */
8238          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);
8239          stacksize++;
8240          }
8241      if (ket != OP_KET || bra != OP_BRA)      if (ket != OP_KET || bra != OP_BRA)
8242        stacksize++;        stacksize++;
8243      if (offset != 0)      if (offset != 0)
# Line 7480  if (has_alternatives) Line 8250  if (has_alternatives)
8250      if (opcode != OP_ONCE)      if (opcode != OP_ONCE)
8251        stacksize++;        stacksize++;
8252    
8253      if (stacksize > 0) {      if (stacksize > 0)
8254        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));  
         }  
     }  
8255    
8256      stacksize = 0;      stacksize = 0;
8257        if (repeat_type == OP_MINUPTO)
8258          {
8259          /* TMP2 was set above. */
8260          OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
8261          stacksize++;
8262          }
8263    
8264      if (ket != OP_KET || bra != OP_BRA)      if (ket != OP_KET || bra != OP_BRA)
8265        {        {
8266        if (ket != OP_KET)        if (ket != OP_KET)
# Line 7502  if (has_alternatives) Line 8271  if (has_alternatives)
8271        }        }
8272    
8273      if (offset != 0)      if (offset != 0)
8274        {        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;  
         }  
       }  
8275    
8276      if (opcode != OP_ONCE)      if (opcode != OP_ONCE)
8277        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, count++);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, count++);
# Line 7555  if (has_alternatives) Line 8305  if (has_alternatives)
8305      SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);      SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);
8306      assert = CURRENT_AS(bracket_backtrack)->u.assert;      assert = CURRENT_AS(bracket_backtrack)->u.assert;
8307      if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)      if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)
   
8308        {        {
8309        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->private_data_ptr);        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->private_data_ptr);
8310        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
# Line 7595  else if (opcode == OP_SBRA || opcode == Line 8344  else if (opcode == OP_SBRA || opcode ==
8344  else if (opcode == OP_ONCE)  else if (opcode == OP_ONCE)
8345    {    {
8346    cc = ccbegin + GET(ccbegin, 1);    cc = ccbegin + GET(ccbegin, 1);
8347      stacksize = needs_control_head ? 1 : 0;
8348    
8349    if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)    if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
8350      {      {
8351      /* Reset head and drop saved frame. */      /* Reset head and drop saved frame. */
8352      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);  
8353      }      }
8354    else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))    else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
8355      {      {
8356      /* The STR_PTR must be released. */      /* The STR_PTR must be released. */
8357      free_stack(common, 1);      stacksize++;
8358      }      }
8359      free_stack(common, stacksize);
8360    
8361    JUMPHERE(once);    JUMPHERE(once);
8362    /* Restore previous private_data_ptr */    /* Restore previous private_data_ptr */
# Line 7620  else if (opcode == OP_ONCE) Line 8371  else if (opcode == OP_ONCE)
8371      }      }
8372    }    }
8373    
8374  if (ket == OP_KETRMAX)  if (repeat_type == OP_EXACT)
8375      {
8376      OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);
8377      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0);
8378      CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, repeat_count, exact_label);
8379      }
8380    else if (ket == OP_KETRMAX)
8381    {    {
8382    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8383    if (bra != OP_BRAZERO)    if (bra != OP_BRAZERO)
8384      free_stack(common, 1);      free_stack(common, 1);
8385    
8386    CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);    CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
8387    if (bra == OP_BRAZERO)    if (bra == OP_BRAZERO)
8388      {      {
# Line 7643  else if (ket == OP_KETRMIN) Line 8401  else if (ket == OP_KETRMIN)
8401    affect badly the free_stack(2) above. */    affect badly the free_stack(2) above. */
8402    if (opcode != OP_ONCE)    if (opcode != OP_ONCE)
8403      free_stack(common, 1);      free_stack(common, 1);
8404    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rminlabel);    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rmin_label);
8405    if (opcode == OP_ONCE)    if (opcode == OP_ONCE)
8406      free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);      free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);
8407    else if (bra == OP_BRAMINZERO)    else if (bra == OP_BRAMINZERO)
# Line 7657  else if (bra == OP_BRAZERO) Line 8415  else if (bra == OP_BRAZERO)
8415    }    }
8416  }  }
8417    
8418  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)
8419  {  {
8420  DEFINE_COMPILER;  DEFINE_COMPILER;
8421  int offset;  int offset;
# Line 7671  if (CURRENT_AS(bracketpos_backtrack)->fr Line 8429  if (CURRENT_AS(bracketpos_backtrack)->fr
8429      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8430      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
8431      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
8432        if (common->capture_last_ptr != 0)
8433          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
8434      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
8435        if (common->capture_last_ptr != 0)
8436          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);
8437      }      }
8438    set_jumps(current->topbacktracks, LABEL());    set_jumps(current->topbacktracks, LABEL());
8439    free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);    free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
# Line 7692  if (current->topbacktracks) Line 8454  if (current->topbacktracks)
8454  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));  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));
8455  }  }
8456    
8457  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)
8458  {  {
8459  assert_backtrack backtrack;  assert_backtrack backtrack;
8460    
# Line 7716  else Line 8478  else
8478  SLJIT_ASSERT(!current->nextbacktracks && !current->topbacktracks);  SLJIT_ASSERT(!current->nextbacktracks && !current->topbacktracks);
8479  }  }
8480    
8481    static SLJIT_INLINE void compile_control_verb_backtrackingpath(compiler_common *common, struct backtrack_common *current)
8482    {
8483    DEFINE_COMPILER;
8484    pcre_uchar opcode = *current->cc;
8485    struct sljit_label *loop;
8486    struct sljit_jump *jump;
8487    
8488    if (opcode == OP_THEN || opcode == OP_THEN_ARG)
8489      {
8490      if (common->then_trap != NULL)
8491        {
8492        SLJIT_ASSERT(common->control_head_ptr != 0);
8493    
8494        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
8495        OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, type_then_trap);
8496        OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, common->then_trap->start);
8497        jump = JUMP(SLJIT_JUMP);
8498    
8499        loop = LABEL();
8500        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), -(int)sizeof(sljit_sw));
8501        JUMPHERE(jump);
8502        CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), -(int)(2 * sizeof(sljit_sw)), TMP1, 0, loop);
8503        CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), -(int)(3 * sizeof(sljit_sw)), TMP2, 0, loop);
8504        add_jump(compiler, &common->then_trap->quit, JUMP(SLJIT_JUMP));
8505        return;
8506        }
8507      else if (common->positive_assert)
8508        {
8509        add_jump(compiler, &common->positive_assert_quit, JUMP(SLJIT_JUMP));
8510        return;
8511        }
8512      }
8513    
8514    if (common->local_exit)
8515      {
8516      if (common->quit_label == NULL)
8517        add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
8518      else
8519        JUMPTO(SLJIT_JUMP, common->quit_label);
8520      return;
8521      }
8522    
8523    if (opcode == OP_SKIP_ARG)
8524      {
8525      SLJIT_ASSERT(common->control_head_ptr != 0);
8526      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
8527      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
8528      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, (sljit_sw)(current->cc + 2));
8529      sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_search_mark));
8530      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
8531    
8532      OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
8533      add_jump(compiler, &common->reset_match, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, -1));
8534      return;
8535      }
8536    
8537    if (opcode == OP_SKIP)
8538      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8539    else
8540      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_IMM, 0);
8541    add_jump(compiler, &common->reset_match, JUMP(SLJIT_JUMP));
8542    }
8543    
8544    static SLJIT_INLINE void compile_then_trap_backtrackingpath(compiler_common *common, struct backtrack_common *current)
8545    {
8546    DEFINE_COMPILER;
8547    struct sljit_jump *jump;
8548    int size;
8549    
8550    if (CURRENT_AS(then_trap_backtrack)->then_trap)
8551      {
8552      common->then_trap = CURRENT_AS(then_trap_backtrack)->then_trap;
8553      return;
8554      }
8555    
8556    size = CURRENT_AS(then_trap_backtrack)->framesize;
8557    size = 3 + (size < 0 ? 0 : size);
8558    
8559    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(size - 3));
8560    free_stack(common, size);
8561    jump = JUMP(SLJIT_JUMP);
8562    
8563    set_jumps(CURRENT_AS(then_trap_backtrack)->quit, LABEL());
8564    /* STACK_TOP is set by THEN. */
8565    if (CURRENT_AS(then_trap_backtrack)->framesize >= 0)
8566      add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
8567    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8568    free_stack(common, 3);
8569    
8570    JUMPHERE(jump);
8571    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP1, 0);
8572    }
8573    
8574  static void compile_backtrackingpath(compiler_common *common, struct backtrack_common *current)  static void compile_backtrackingpath(compiler_common *common, struct backtrack_common *current)
8575  {  {
8576  DEFINE_COMPILER;  DEFINE_COMPILER;
8577    then_trap_backtrack *save_then_trap = common->then_trap;
8578    
8579  while (current)  while (current)
8580    {    {
# Line 7852  while (current) Line 8708  while (current)
8708      break;      break;
8709    
8710      case OP_MARK:      case OP_MARK:
8711      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));
8712      free_stack(common, 1);      if (common->has_skip_arg)
8713          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
8714        free_stack(common, common->has_skip_arg ? 5 : 1);
8715      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP1, 0);
8716        if (common->has_skip_arg)
8717          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP2, 0);
8718        break;
8719    
8720        case OP_THEN:
8721        case OP_THEN_ARG:
8722        case OP_PRUNE:
8723        case OP_PRUNE_ARG:
8724        case OP_SKIP:
8725        case OP_SKIP_ARG:
8726        compile_control_verb_backtrackingpath(common, current);
8727      break;      break;
8728    
8729      case OP_COMMIT:      case OP_COMMIT:
8730      OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);      if (!common->local_exit)
8731          OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
8732      if (common->quit_label == NULL)      if (common->quit_label == NULL)
8733        add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));        add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
8734      else      else
# Line 7872  while (current) Line 8742  while (current)
8742      set_jumps(current->topbacktracks, LABEL());      set_jumps(current->topbacktracks, LABEL());
8743      break;      break;
8744    
8745        case OP_THEN_TRAP:
8746        /* A virtual opcode for then traps. */
8747        compile_then_trap_backtrackingpath(common, current);
8748        break;
8749    
8750      default:      default:
8751      SLJIT_ASSERT_STOP();      SLJIT_ASSERT_STOP();
8752      break;      break;
8753      }      }
8754    current = current->prev;    current = current->prev;
8755    }    }
8756    common->then_trap = save_then_trap;
8757  }  }
8758    
8759  static SLJIT_INLINE void compile_recurse(compiler_common *common)  static SLJIT_INLINE void compile_recurse(compiler_common *common)
# Line 7886  DEFINE_COMPILER; Line 8762  DEFINE_COMPILER;
8762  pcre_uchar *cc = common->start + common->currententry->start;  pcre_uchar *cc = common->start + common->currententry->start;
8763  pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);  pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);
8764  pcre_uchar *ccend = bracketend(cc);  pcre_uchar *ccend = bracketend(cc);
8765  int private_data_size = get_private_data_length_for_copy(common, ccbegin, ccend);  BOOL needs_control_head;
8766  int framesize = get_framesize(common, cc, TRUE);  int framesize = get_framesize(common, cc, NULL, TRUE, &needs_control_head);
8767    int private_data_size = get_private_data_copy_length(common, ccbegin, ccend, needs_control_head);
8768  int alternativesize;  int alternativesize;
8769  BOOL needsframe;  BOOL needs_frame;
8770  backtrack_common altbacktrack;  backtrack_common altbacktrack;
 struct sljit_label *save_quit_label = common->quit_label;  
 jump_list *save_quit = common->quit;  
8771  struct sljit_jump *jump;  struct sljit_jump *jump;
8772    
8773    /* Recurse captures then. */
8774    common->then_trap = NULL;
8775    
8776  SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);  SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);
8777  needsframe = framesize >= 0;  needs_frame = framesize >= 0;
8778  if (!needsframe)  if (!needs_frame)
8779    framesize = 0;    framesize = 0;
8780  alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;  alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;
8781    
# Line 7908  set_jumps(common->currententry->calls, c Line 8786  set_jumps(common->currententry->calls, c
8786  sljit_emit_fast_enter(compiler, TMP2, 0);  sljit_emit_fast_enter(compiler, TMP2, 0);
8787  allocate_stack(common, private_data_size + framesize + alternativesize);  allocate_stack(common, private_data_size + framesize + alternativesize);
8788  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(private_data_size + framesize + alternativesize - 1), TMP2, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(private_data_size + framesize + alternativesize - 1), TMP2, 0);
8789  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);
8790    if (needs_control_head)
8791      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
8792  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr, STACK_TOP, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr, STACK_TOP, 0);
8793  if (needsframe)  if (needs_frame)
8794    init_frame(common, cc, framesize + alternativesize - 1, alternativesize, TRUE);    init_frame(common, cc, NULL, framesize + alternativesize - 1, alternativesize, TRUE);
8795    
8796  if (alternativesize > 0)  if (alternativesize > 0)
8797    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
# Line 7933  while (1) Line 8813  while (1)
8813    
8814    compile_matchingpath(common, altbacktrack.cc, cc, &altbacktrack);    compile_matchingpath(common, altbacktrack.cc, cc, &altbacktrack);
8815    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
     {  
     common->quit_label = save_quit_label;  
     common->quit = save_quit;  
8816      return;      return;
     }  
8817    
8818    add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));    add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));
8819    
8820    compile_backtrackingpath(common, altbacktrack.top);    compile_backtrackingpath(common, altbacktrack.top);
8821    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
     {  
     common->quit_label = save_quit_label;  
     common->quit = save_quit;  
8822      return;      return;
     }  
8823    set_jumps(altbacktrack.topbacktracks, LABEL());    set_jumps(altbacktrack.topbacktracks, LABEL());
8824    
8825    if (*cc != OP_ALT)    if (*cc != OP_ALT)
# Line 7956  while (1) Line 8828  while (1)
8828    altbacktrack.cc = cc + 1 + LINK_SIZE;    altbacktrack.cc = cc + 1 + LINK_SIZE;
8829    cc += GET(cc, 1);    cc += GET(cc, 1);
8830    }    }
 /* None of them matched. */  
 if (common->quit != NULL)  
   set_jumps(common->quit, LABEL());  
8831    
8832    /* None of them matched. */
8833  OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);  OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
8834  jump = JUMP(SLJIT_JUMP);  jump = JUMP(SLJIT_JUMP);
8835    
8836    if (common->quit != NULL)
8837      {
8838      set_jumps(common->quit, LABEL());
8839      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr);
8840      if (needs_frame)
8841        {
8842        OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
8843        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
8844        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
8845        }
8846      OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
8847      common->quit = NULL;
8848      add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
8849      }
8850    
8851  set_jumps(common->accept, LABEL());  set_jumps(common->accept, LABEL());
8852  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr);  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr);
8853  if (needsframe)  if (needs_frame)
8854    {    {
8855    OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));    OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
8856    add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
# Line 7974  if (needsframe) Line 8859  if (needsframe)
8859  OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);  OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);
8860    
8861  JUMPHERE(jump);  JUMPHERE(jump);
8862  copy_private_data(common, ccbegin, ccend, FALSE, private_data_size + framesize + alternativesize, framesize + alternativesize);  if (common->quit != NULL)
8863      set_jumps(common->quit, LABEL());
8864    copy_private_data(common, ccbegin, ccend, FALSE, private_data_size + framesize + alternativesize, framesize + alternativesize, needs_control_head);
8865  free_stack(common, private_data_size + framesize + alternativesize);  free_stack(common, private_data_size + framesize + alternativesize);
8866  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_sw));  if (needs_control_head)
8867  OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);    {
8868  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr, TMP2, 0);    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 2 * sizeof(sljit_sw));
8869      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_sw));
8870      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr, TMP1, 0);
8871      OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
8872      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP2, 0);
8873      }
8874    else
8875      {
8876      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_sw));
8877      OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
8878      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr, TMP2, 0);
8879      }
8880  sljit_emit_fast_return(compiler, SLJIT_MEM1(STACK_TOP), 0);  sljit_emit_fast_return(compiler, SLJIT_MEM1(STACK_TOP), 0);
   
 common->quit_label = save_quit_label;  
 common->quit = save_quit;  
8881  }  }
8882    
8883  #undef COMPILE_BACKTRACKINGPATH  #undef COMPILE_BACKTRACKINGPATH
# Line 8002  pcre_uchar *ccend; Line 8897  pcre_uchar *ccend;
8897  executable_functions *functions;  executable_functions *functions;
8898  void *executable_func;  void *executable_func;
8899  sljit_uw executable_size;  sljit_uw executable_size;
8900  struct sljit_label *mainloop = NULL;  struct sljit_label *mainloop_label = NULL;
8901  struct sljit_label *empty_match_found;  struct sljit_label *continue_match_label;
8902  struct sljit_label *empty_match_backtrack;  struct sljit_label *empty_match_found_label;
8903    struct sljit_label *empty_match_backtrack_label;
8904    struct sljit_label *reset_match_label;
8905  struct sljit_jump *jump;  struct sljit_jump *jump;
8906  struct sljit_jump *minlength_check_failed = NULL;  struct sljit_jump *minlength_check_failed = NULL;
8907  struct sljit_jump *reqbyte_notfound = NULL;  struct sljit_jump *reqbyte_notfound = NULL