/[pcre]/code/tags/pcre-8.37/pcre_jit_compile.c
ViewVC logotype

Diff of /code/tags/pcre-8.37/pcre_jit_compile.c

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

revision 1276 by zherczeg, Sun Mar 10 17:35:23 2013 UTC revision 1424 by zherczeg, Tue Dec 31 11:22:31 2013 UTC
# Line 168  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      pcre_uint32 limit_match;
172    int real_offset_count;    int real_offset_count;
173    int offset_count;    int offset_count;
   int call_limit;  
174    pcre_uint8 notbol;    pcre_uint8 notbol;
175    pcre_uint8 noteol;    pcre_uint8 noteol;
176    pcre_uint8 notempty;    pcre_uint8 notempty;
# Line 182  typedef struct executable_functions { Line 182  typedef struct executable_functions {
182    PUBL(jit_callback) callback;    PUBL(jit_callback) callback;
183    void *userdata;    void *userdata;
184    pcre_uint32 top_bracket;    pcre_uint32 top_bracket;
185      pcre_uint32 limit_match;
186    sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];    sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
187  } executable_functions;  } executable_functions;
188    
# Line 202  enum frame_types { Line 203  enum frame_types {
203  };  };
204    
205  enum control_types {  enum control_types {
206    type_commit = 0,    type_mark = 0,
207    type_prune = 1,    type_then_trap = 1
   type_skip = 2  
208  };  };
209    
210  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
211    
212  /* The following structure is the key data type for the recursive  /* The following structure is the key data type for the recursive
213  code generator. It is allocated by compile_matchingpath, and contains  code generator. It is allocated by compile_matchingpath, and contains
214  the aguments for compile_backtrackingpath. Must be the first member  the arguments for compile_backtrackingpath. Must be the first member
215  of its descendants. */  of its descendants. */
216  typedef struct backtrack_common {  typedef struct backtrack_common {
217    /* Concatenation stack. */    /* Concatenation stack. */
# Line 283  typedef struct recurse_entry { Line 283  typedef struct recurse_entry {
283    /* Collects the calls until the function is not created. */    /* Collects the calls until the function is not created. */
284    jump_list *calls;    jump_list *calls;
285    /* Points to the starting opcode. */    /* Points to the starting opcode. */
286    int start;    sljit_sw start;
287  } recurse_entry;  } recurse_entry;
288    
289  typedef struct recurse_backtrack {  typedef struct recurse_backtrack {
# Line 291  typedef struct recurse_backtrack { Line 291  typedef struct recurse_backtrack {
291    BOOL inlined_pattern;    BOOL inlined_pattern;
292  } recurse_backtrack;  } recurse_backtrack;
293    
294  #define MAX_RANGE_SIZE 6  #define OP_THEN_TRAP OP_TABLE_LENGTH
295    
296    typedef struct then_trap_backtrack {
297      backtrack_common common;
298      /* If then_trap is not NULL, this structure contains the real
299      then_trap for the backtracking path. */
300      struct then_trap_backtrack *then_trap;
301      /* Points to the starting opcode. */
302      sljit_sw start;
303      /* Exit point for the then opcodes of this alternative. */
304      jump_list *quit;
305      /* Frame size of the current alternative. */
306      int framesize;
307    } then_trap_backtrack;
308    
309    #define MAX_RANGE_SIZE 4
310    
311  typedef struct compiler_common {  typedef struct compiler_common {
312    /* The sljit ceneric compiler. */    /* The sljit ceneric compiler. */
# Line 299  typedef struct compiler_common { Line 314  typedef struct compiler_common {
314    /* First byte code. */    /* First byte code. */
315    pcre_uchar *start;    pcre_uchar *start;
316    /* Maps private data offset to each opcode. */    /* Maps private data offset to each opcode. */
317    int *private_data_ptrs;    sljit_si *private_data_ptrs;
318    /* Tells whether the capturing bracket is optimized. */    /* Tells whether the capturing bracket is optimized. */
319    pcre_uint8 *optimized_cbracket;    pcre_uint8 *optimized_cbracket;
320      /* Tells whether the starting offset is a target of then. */
321      pcre_uint8 *then_offsets;
322      /* Current position where a THEN must jump. */
323      then_trap_backtrack *then_trap;
324    /* Starting offset of private data for capturing brackets. */    /* Starting offset of private data for capturing brackets. */
325    int cbra_ptr;    int cbra_ptr;
326    /* Output vector starting point. Must be divisible by 2. */    /* Output vector starting point. Must be divisible by 2. */
# Line 330  typedef struct compiler_common { Line 349  typedef struct compiler_common {
349    sljit_sw lcc;    sljit_sw lcc;
350    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
351    int mode;    int mode;
352    /* \K is in the pattern. */    /* \K is found in the pattern. */
353    BOOL has_set_som;    BOOL has_set_som;
354      /* (*SKIP:arg) is found in the pattern. */
355      BOOL has_skip_arg;
356      /* (*THEN) is found in the pattern. */
357      BOOL has_then;
358    /* Needs to know the start position anytime. */    /* Needs to know the start position anytime. */
359    BOOL needs_start_ptr;    BOOL needs_start_ptr;
360    /* Currently in recurse or assert. */    /* Currently in recurse or negative assert. */
361    BOOL local_exit;    BOOL local_exit;
362      /* Currently in a positive assert. */
363      BOOL positive_assert;
364    /* Newline control. */    /* Newline control. */
365    int nltype;    int nltype;
366      pcre_uint32 nlmax;
367    int newline;    int newline;
368    int bsr_nltype;    int bsr_nltype;
369      pcre_uint32 bsr_nlmax;
370    /* Dollar endonly. */    /* Dollar endonly. */
371    int endonly;    int endonly;
372    /* Tables. */    /* Tables. */
373    sljit_sw ctypes;    sljit_sw ctypes;
   int digits[2 + MAX_RANGE_SIZE];  
374    /* Named capturing brackets. */    /* Named capturing brackets. */
375    sljit_uw name_table;    pcre_uchar *name_table;
376    sljit_sw name_count;    sljit_sw name_count;
377    sljit_sw name_entry_size;    sljit_sw name_entry_size;
378    
# Line 360  typedef struct compiler_common { Line 386  typedef struct compiler_common {
386    recurse_entry *currententry;    recurse_entry *currententry;
387    jump_list *partialmatch;    jump_list *partialmatch;
388    jump_list *quit;    jump_list *quit;
389      jump_list *positive_assert_quit;
390    jump_list *forced_quit;    jump_list *forced_quit;
391    jump_list *accept;    jump_list *accept;
392    jump_list *calllimit;    jump_list *calllimit;
# Line 378  typedef struct compiler_common { Line 405  typedef struct compiler_common {
405  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
406    BOOL use_ucp;    BOOL use_ucp;
407  #endif  #endif
 #ifndef COMPILE_PCRE32  
   jump_list *utfreadchar;  
 #endif  
408  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
409      jump_list *utfreadchar;
410      jump_list *utfreadchar16;
411    jump_list *utfreadtype8;    jump_list *utfreadtype8;
412  #endif  #endif
413  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
# Line 438  typedef struct compare_context { Line 464  typedef struct compare_context {
464  #define STACK_TOP     SLJIT_SCRATCH_REG2  #define STACK_TOP     SLJIT_SCRATCH_REG2
465  #define STACK_LIMIT   SLJIT_SAVED_REG3  #define STACK_LIMIT   SLJIT_SAVED_REG3
466  #define ARGUMENTS     SLJIT_SAVED_EREG1  #define ARGUMENTS     SLJIT_SAVED_EREG1
467  #define CALL_COUNT    SLJIT_SAVED_EREG2  #define COUNT_MATCH   SLJIT_SAVED_EREG2
468  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1
469    
470  /* Local space layout. */  /* Local space layout. */
# Line 449  typedef struct compare_context { Line 475  typedef struct compare_context {
475  #define POSSESSIVE0      (2 * sizeof(sljit_sw))  #define POSSESSIVE0      (2 * sizeof(sljit_sw))
476  #define POSSESSIVE1      (3 * sizeof(sljit_sw))  #define POSSESSIVE1      (3 * sizeof(sljit_sw))
477  /* Max limit of recursions. */  /* Max limit of recursions. */
478  #define CALL_LIMIT       (4 * sizeof(sljit_sw))  #define LIMIT_MATCH      (4 * sizeof(sljit_sw))
479  /* The output vector is stored on the stack, and contains pointers  /* The output vector is stored on the stack, and contains pointers
480  to characters. The vector data is divided into two groups: the first  to characters. The vector data is divided into two groups: the first
481  group contains the start / end character pointers, and the second is  group contains the start / end character pointers, and the second is
482  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. */
483  #define OVECTOR_START    (common->ovector_start)  #define OVECTOR_START    (common->ovector_start)
484  #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_sw))  #define OVECTOR(i)       (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw))
485  #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * sizeof(sljit_sw))  #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))
486  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
487    
488  #if defined COMPILE_PCRE8  #if defined COMPILE_PCRE8
# Line 498  the start pointers when the end of the c Line 524  the start pointers when the end of the c
524  #define GET_LOCAL_BASE(dst, dstw, offset) \  #define GET_LOCAL_BASE(dst, dstw, offset) \
525    sljit_get_local_base(compiler, (dst), (dstw), (offset))    sljit_get_local_base(compiler, (dst), (dstw), (offset))
526    
527    #define READ_CHAR_ANY 0x7fffffff
528    
529  static pcre_uchar* bracketend(pcre_uchar* cc)  static pcre_uchar* bracketend(pcre_uchar* cc)
530  {  {
531  SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));  SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
# Line 507  cc += 1 + LINK_SIZE; Line 535  cc += 1 + LINK_SIZE;
535  return cc;  return cc;
536  }  }
537    
538    static int ones_in_half_byte[16] = {
539      /* 0 */ 0, 1, 1, 2, /* 4 */ 1, 2, 2, 3,
540      /* 8 */ 1, 2, 2, 3, /* 12 */ 2, 3, 3, 4
541    };
542    
543  /* Functions whose might need modification for all new supported opcodes:  /* Functions whose might need modification for all new supported opcodes:
544   next_opcode   next_opcode
545   get_private_data_length   check_opcode_types
546   set_private_data_ptrs   set_private_data_ptrs
547   get_framesize   get_framesize
548   init_frame   init_frame
# Line 559  switch(*cc) Line 592  switch(*cc)
592    case OP_CRMINQUERY:    case OP_CRMINQUERY:
593    case OP_CRRANGE:    case OP_CRRANGE:
594    case OP_CRMINRANGE:    case OP_CRMINRANGE:
595      case OP_CRPOSSTAR:
596      case OP_CRPOSPLUS:
597      case OP_CRPOSQUERY:
598      case OP_CRPOSRANGE:
599    case OP_CLASS:    case OP_CLASS:
600    case OP_NCLASS:    case OP_NCLASS:
601    case OP_REF:    case OP_REF:
602    case OP_REFI:    case OP_REFI:
603      case OP_DNREF:
604      case OP_DNREFI:
605    case OP_RECURSE:    case OP_RECURSE:
606    case OP_CALLOUT:    case OP_CALLOUT:
607    case OP_ALT:    case OP_ALT:
# Line 588  switch(*cc) Line 627  switch(*cc)
627    case OP_SCBRAPOS:    case OP_SCBRAPOS:
628    case OP_SCOND:    case OP_SCOND:
629    case OP_CREF:    case OP_CREF:
630    case OP_NCREF:    case OP_DNCREF:
631    case OP_RREF:    case OP_RREF:
632    case OP_NRREF:    case OP_DNRREF:
633    case OP_DEF:    case OP_DEF:
634    case OP_BRAZERO:    case OP_BRAZERO:
635    case OP_BRAMINZERO:    case OP_BRAMINZERO:
636    case OP_BRAPOSZERO:    case OP_BRAPOSZERO:
637    case OP_PRUNE:    case OP_PRUNE:
638    case OP_SKIP:    case OP_SKIP:
639      case OP_THEN:
640    case OP_COMMIT:    case OP_COMMIT:
641    case OP_FAIL:    case OP_FAIL:
642    case OP_ACCEPT:    case OP_ACCEPT:
# Line 696  switch(*cc) Line 736  switch(*cc)
736    
737    case OP_MARK:    case OP_MARK:
738    case OP_PRUNE_ARG:    case OP_PRUNE_ARG:
739      case OP_SKIP_ARG:
740      case OP_THEN_ARG:
741    return cc + 1 + 2 + cc[1];    return cc + 1 + 2 + cc[1];
742    
743    default:    default:
744      /* All opcodes are supported now! */
745      SLJIT_ASSERT_STOP();
746    return NULL;    return NULL;
747    }    }
748  }  }
749    
750  #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)  
751  {  {
752  switch(*cc)  int count;
753    {  pcre_uchar *slot;
   case OP_CRSTAR:  
   case OP_CRPLUS:  
   return 2;  
   
   case OP_CRMINSTAR:  
   case OP_CRMINPLUS:  
   case OP_CRQUERY:  
   case OP_CRMINQUERY:  
   return 1;  
   
   case OP_CRRANGE:  
   case OP_CRMINRANGE:  
   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))  
     return 0;  
   return 2;  
   
   default:  
   return 0;  
   }  
 }  
   
 static int get_private_data_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)  
 {  
 int private_data_length = 0;  
 pcre_uchar *alternative;  
 pcre_uchar *name;  
 pcre_uchar *end = NULL;  
 int space, size, i;  
 pcre_uint32 bracketlen;  
754    
755  /* 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. */
756  while (cc < ccend)  while (cc < ccend)
757    {    {
   space = 0;  
   size = 0;  
   bracketlen = 0;  
758    switch(*cc)    switch(*cc)
759      {      {
760      case OP_SET_SOM:      case OP_SET_SOM:
# Line 808  while (cc < ccend) Line 768  while (cc < ccend)
768      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
769      break;      break;
770    
     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;  
   
771      case OP_CBRAPOS:      case OP_CBRAPOS:
772      case OP_SCBRAPOS:      case OP_SCBRAPOS:
     private_data_length += sizeof(sljit_sw);  
773      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
774      bracketlen = 1 + LINK_SIZE + IMM2_SIZE;      cc += 1 + LINK_SIZE + IMM2_SIZE;
775      break;      break;
776    
777      case OP_COND:      case OP_COND:
# Line 833  while (cc < ccend) Line 779  while (cc < ccend)
779      /* Only AUTO_CALLOUT can insert this opcode. We do      /* Only AUTO_CALLOUT can insert this opcode. We do
780         not intend to support this case. */         not intend to support this case. */
781      if (cc[1 + LINK_SIZE] == OP_CALLOUT)      if (cc[1 + LINK_SIZE] == OP_CALLOUT)
782        return -1;        return FALSE;
783        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;  
784      break;      break;
785    
786      case OP_CREF:      case OP_CREF:
787      i = GET2(cc, 1);      common->optimized_cbracket[GET2(cc, 1)] = 0;
     common->optimized_cbracket[i] = 0;  
788      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
789      break;      break;
790    
791      case OP_NCREF:      case OP_DNREF:
792      bracketlen = GET2(cc, 1);      case OP_DNREFI:
793      name = (pcre_uchar *)common->name_table;      case OP_DNCREF:
794      alternative = name;      count = GET2(cc, 1 + IMM2_SIZE);
795      for (i = 0; i < common->name_count; i++)      slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
796        {      while (count-- > 0)
       if (GET2(name, 0) == bracketlen) break;  
       name += common->name_entry_size;  
       }  
     SLJIT_ASSERT(i != common->name_count);  
   
     for (i = 0; i < common->name_count; i++)  
797        {        {
798        if (STRCMP_UC_UC(alternative + IMM2_SIZE, name + IMM2_SIZE) == 0)        common->optimized_cbracket[GET2(slot, 0)] = 0;
799          common->optimized_cbracket[GET2(alternative, 0)] = 0;        slot += common->name_entry_size;
       alternative += common->name_entry_size;  
800        }        }
801      bracketlen = 0;      cc += 1 + 2 * IMM2_SIZE;
     cc += 1 + IMM2_SIZE;  
     break;  
   
     case OP_BRA:  
     bracketlen = 1 + LINK_SIZE;  
802      break;      break;
803    
     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  
   
804      case OP_RECURSE:      case OP_RECURSE:
805      /* Set its value only once. */      /* Set its value only once. */
806      if (common->recursive_head_ptr == 0)      if (common->recursive_head_ptr == 0)
# Line 947  while (cc < ccend) Line 820  while (cc < ccend)
820      cc += 2 + 2 * LINK_SIZE;      cc += 2 + 2 * LINK_SIZE;
821      break;      break;
822    
823        case OP_THEN_ARG:
824        common->has_then = TRUE;
825        common->control_head_ptr = 1;
826        /* Fall through. */
827    
828      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
829      common->needs_start_ptr = TRUE;      common->needs_start_ptr = TRUE;
     common->control_head_ptr = 1;  
830      /* Fall through. */      /* Fall through. */
831    
832      case OP_MARK:      case OP_MARK:
# Line 961  while (cc < ccend) Line 838  while (cc < ccend)
838      cc += 1 + 2 + cc[1];      cc += 1 + 2 + cc[1];
839      break;      break;
840    
841        case OP_THEN:
842        common->has_then = TRUE;
843        common->control_head_ptr = 1;
844        /* Fall through. */
845    
846      case OP_PRUNE:      case OP_PRUNE:
847      case OP_SKIP:      case OP_SKIP:
848      common->needs_start_ptr = TRUE;      common->needs_start_ptr = TRUE;
849      /* Fall through. */      cc += 1;
850        break;
851    
852      case OP_COMMIT:      case OP_SKIP_ARG:
853      common->control_head_ptr = 1;      common->control_head_ptr = 1;
854      cc += 1;      common->has_skip_arg = TRUE;
855        cc += 1 + 2 + cc[1];
856      break;      break;
857    
858      default:      default:
859      cc = next_opcode(common, cc);      cc = next_opcode(common, cc);
860      if (cc == NULL)      if (cc == NULL)
861        return -1;        return FALSE;
862      break;      break;
863      }      }
864      }
865    return TRUE;
866    }
867    
868    if (space > 0 && cc >= end)  static int get_class_iterator_size(pcre_uchar *cc)
869      private_data_length += sizeof(sljit_sw) * space;  {
870    switch(*cc)
871      {
872      case OP_CRSTAR:
873      case OP_CRPLUS:
874      return 2;
875    
876    if (size != 0)    case OP_CRMINSTAR:
877      case OP_CRMINPLUS:
878      case OP_CRQUERY:
879      case OP_CRMINQUERY:
880      return 1;
881    
882      case OP_CRRANGE:
883      case OP_CRMINRANGE:
884      if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
885        return 0;
886      return 2;
887    
888      default:
889      return 0;
890      }
891    }
892    
893    static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
894    {
895    pcre_uchar *end = bracketend(begin);
896    pcre_uchar *next;
897    pcre_uchar *next_end;
898    pcre_uchar *max_end;
899    pcre_uchar type;
900    sljit_sw length = end - begin;
901    int min, max, i;
902    
903    /* Detect fixed iterations first. */
904    if (end[-(1 + LINK_SIZE)] != OP_KET)
905      return FALSE;
906    
907    /* Already detected repeat. */
908    if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)
909      return TRUE;
910    
911    next = end;
912    min = 1;
913    while (1)
914      {
915      if (*next != *begin)
916        break;
917      next_end = bracketend(next);
918      if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)
919        break;
920      next = next_end;
921      min++;
922      }
923    
924    if (min == 2)
925      return FALSE;
926    
927    max = 0;
928    max_end = next;
929    if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)
930      {
931      type = *next;
932      while (1)
933      {      {
934      if (size < 0)      if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
935        {        break;
936        cc += -size;      next_end = bracketend(next + 2 + LINK_SIZE);
937  #ifdef SUPPORT_UTF      if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)
938        if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);        break;
939  #endif      next = next_end;
940        }      max++;
     else  
       cc += size;  
941      }      }
942    
943    if (bracketlen != 0)    if (next[0] == type && next[1] == *begin && max >= 1)
944      {      {
945      if (cc >= end)      next_end = bracketend(next + 1);
946        if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)
947        {        {
948        end = bracketend(cc);        for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
949        if (end[-1 - LINK_SIZE] == OP_KET)          if (*next_end != OP_KET)
950          end = NULL;            break;
951    
952          if (i == max)
953            {
954            common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
955            common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
956            /* +2 the original and the last. */
957            common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;
958            if (min == 1)
959              return TRUE;
960            min--;
961            max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);
962            }
963        }        }
     cc += bracketlen;  
964      }      }
965    }    }
966  return private_data_length;  
967    if (min >= 3)
968      {
969      common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;
970      common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;
971      common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;
972      return TRUE;
973      }
974    
975    return FALSE;
976  }  }
977    
978  static void set_private_data_ptrs(compiler_common *common, int private_data_ptr, pcre_uchar *ccend)  #define CASE_ITERATOR_PRIVATE_DATA_1 \
979        case OP_MINSTAR: \
980        case OP_MINPLUS: \
981        case OP_QUERY: \
982        case OP_MINQUERY: \
983        case OP_MINSTARI: \
984        case OP_MINPLUSI: \
985        case OP_QUERYI: \
986        case OP_MINQUERYI: \
987        case OP_NOTMINSTAR: \
988        case OP_NOTMINPLUS: \
989        case OP_NOTQUERY: \
990        case OP_NOTMINQUERY: \
991        case OP_NOTMINSTARI: \
992        case OP_NOTMINPLUSI: \
993        case OP_NOTQUERYI: \
994        case OP_NOTMINQUERYI:
995    
996    #define CASE_ITERATOR_PRIVATE_DATA_2A \
997        case OP_STAR: \
998        case OP_PLUS: \
999        case OP_STARI: \
1000        case OP_PLUSI: \
1001        case OP_NOTSTAR: \
1002        case OP_NOTPLUS: \
1003        case OP_NOTSTARI: \
1004        case OP_NOTPLUSI:
1005    
1006    #define CASE_ITERATOR_PRIVATE_DATA_2B \
1007        case OP_UPTO: \
1008        case OP_MINUPTO: \
1009        case OP_UPTOI: \
1010        case OP_MINUPTOI: \
1011        case OP_NOTUPTO: \
1012        case OP_NOTMINUPTO: \
1013        case OP_NOTUPTOI: \
1014        case OP_NOTMINUPTOI:
1015    
1016    #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
1017        case OP_TYPEMINSTAR: \
1018        case OP_TYPEMINPLUS: \
1019        case OP_TYPEQUERY: \
1020        case OP_TYPEMINQUERY:
1021    
1022    #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
1023        case OP_TYPESTAR: \
1024        case OP_TYPEPLUS:
1025    
1026    #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
1027        case OP_TYPEUPTO: \
1028        case OP_TYPEMINUPTO:
1029    
1030    static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)
1031  {  {
1032  pcre_uchar *cc = common->start;  pcre_uchar *cc = common->start;
1033  pcre_uchar *alternative;  pcre_uchar *alternative;
1034  pcre_uchar *end = NULL;  pcre_uchar *end = NULL;
1035    int private_data_ptr = *private_data_start;
1036  int space, size, bracketlen;  int space, size, bracketlen;
1037    
1038  while (cc < ccend)  while (cc < ccend)
# Line 1020  while (cc < ccend) Line 1040  while (cc < ccend)
1040    space = 0;    space = 0;
1041    size = 0;    size = 0;
1042    bracketlen = 0;    bracketlen = 0;
1043      if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
1044        return;
1045    
1046      if (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND)
1047        if (detect_repeat(common, cc))
1048          {
1049          /* These brackets are converted to repeats, so no global
1050          based single character repeat is allowed. */
1051          if (cc >= end)
1052            end = bracketend(cc);
1053          }
1054    
1055    switch(*cc)    switch(*cc)
1056      {      {
1057        case OP_KET:
1058        if (common->private_data_ptrs[cc + 1 - common->start] != 0)
1059          {
1060          common->private_data_ptrs[cc - common->start] = private_data_ptr;
1061          private_data_ptr += sizeof(sljit_sw);
1062          cc += common->private_data_ptrs[cc + 1 - common->start];
1063          }
1064        cc += 1 + LINK_SIZE;
1065        break;
1066    
1067      case OP_ASSERT:      case OP_ASSERT:
1068      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1069      case OP_ASSERTBACK:      case OP_ASSERTBACK:
# Line 1115  while (cc < ccend) Line 1157  while (cc < ccend)
1157      break;      break;
1158      }      }
1159    
1160      /* Character iterators, which are not inside a repeated bracket,
1161         gets a private slot instead of allocating it on the stack. */
1162    if (space > 0 && cc >= end)    if (space > 0 && cc >= end)
1163      {      {
1164      common->private_data_ptrs[cc - common->start] = private_data_ptr;      common->private_data_ptrs[cc - common->start] = private_data_ptr;
# Line 1145  while (cc < ccend) Line 1189  while (cc < ccend)
1189      cc += bracketlen;      cc += bracketlen;
1190      }      }
1191    }    }
1192    *private_data_start = private_data_ptr;
1193  }  }
1194    
1195  /* Returns with a frame_types (always < 0) if no need for frame. */  /* Returns with a frame_types (always < 0) if no need for frame. */
1196  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)
1197  {  {
 pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);  
1198  int length = 0;  int length = 0;
1199  int possessive = 0;  int possessive = 0;
1200  BOOL stack_restore = FALSE;  BOOL stack_restore = FALSE;
# Line 1159  BOOL setmark_found = recursive; Line 1203  BOOL setmark_found = recursive;
1203  /* The last capture is a local variable even for recursions. */  /* The last capture is a local variable even for recursions. */
1204  BOOL capture_last_found = FALSE;  BOOL capture_last_found = FALSE;
1205    
1206  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))  #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
1207    SLJIT_ASSERT(common->control_head_ptr != 0);
1208    *needs_control_head = TRUE;
1209    #else
1210    *needs_control_head = FALSE;
1211    #endif
1212    
1213    if (ccend == NULL)
1214    {    {
1215    possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;    ccend = bracketend(cc) - (1 + LINK_SIZE);
1216    /* This is correct regardless of common->capture_last_ptr. */    if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
1217    capture_last_found = TRUE;      {
1218        possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
1219        /* This is correct regardless of common->capture_last_ptr. */
1220        capture_last_found = TRUE;
1221        }
1222      cc = next_opcode(common, cc);
1223    }    }
1224    
 cc = next_opcode(common, cc);  
1225  SLJIT_ASSERT(cc != NULL);  SLJIT_ASSERT(cc != NULL);
1226  while (cc < ccend)  while (cc < ccend)
1227    switch(*cc)    switch(*cc)
# Line 1184  while (cc < ccend) Line 1239  while (cc < ccend)
1239    
1240      case OP_MARK:      case OP_MARK:
1241      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
1242        case OP_THEN_ARG:
1243      SLJIT_ASSERT(common->mark_ptr != 0);      SLJIT_ASSERT(common->mark_ptr != 0);
1244      stack_restore = TRUE;      stack_restore = TRUE;
1245      if (!setmark_found)      if (!setmark_found)
# Line 1191  while (cc < ccend) Line 1247  while (cc < ccend)
1247        length += 2;        length += 2;
1248        setmark_found = TRUE;        setmark_found = TRUE;
1249        }        }
1250        if (common->control_head_ptr != 0)
1251          *needs_control_head = TRUE;
1252      cc += 1 + 2 + cc[1];      cc += 1 + 2 + cc[1];
1253      break;      break;
1254    
# Line 1310  if (length > 0) Line 1368  if (length > 0)
1368  return stack_restore ? no_frame : no_stack;  return stack_restore ? no_frame : no_stack;
1369  }  }
1370    
1371  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)
1372  {  {
1373  DEFINE_COMPILER;  DEFINE_COMPILER;
 pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);  
1374  BOOL setsom_found = recursive;  BOOL setsom_found = recursive;
1375  BOOL setmark_found = recursive;  BOOL setmark_found = recursive;
1376  /* The last capture is a local variable even for recursions. */  /* The last capture is a local variable even for recursions. */
# Line 1325  SLJIT_UNUSED_ARG(stacktop); Line 1382  SLJIT_UNUSED_ARG(stacktop);
1382  SLJIT_ASSERT(stackpos >= stacktop + 2);  SLJIT_ASSERT(stackpos >= stacktop + 2);
1383    
1384  stackpos = STACK(stackpos);  stackpos = STACK(stackpos);
1385  if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))  if (ccend == NULL)
1386    cc = next_opcode(common, cc);    {
1387      ccend = bracketend(cc) - (1 + LINK_SIZE);
1388      if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
1389        cc = next_opcode(common, cc);
1390      }
1391    
1392  SLJIT_ASSERT(cc != NULL);  SLJIT_ASSERT(cc != NULL);
1393  while (cc < ccend)  while (cc < ccend)
1394    switch(*cc)    switch(*cc)
# Line 1347  while (cc < ccend) Line 1409  while (cc < ccend)
1409    
1410      case OP_MARK:      case OP_MARK:
1411      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
1412        case OP_THEN_ARG:
1413      SLJIT_ASSERT(common->mark_ptr != 0);      SLJIT_ASSERT(common->mark_ptr != 0);
1414      if (!setmark_found)      if (!setmark_found)
1415        {        {
# Line 1438  while (cc < ccend) Line 1501  while (cc < ccend)
1501    size = 0;    size = 0;
1502    switch(*cc)    switch(*cc)
1503      {      {
1504        case OP_KET:
1505        if (PRIVATE_DATA(cc) != 0)
1506          private_data_length++;
1507        cc += 1 + LINK_SIZE;
1508        break;
1509    
1510      case OP_ASSERT:      case OP_ASSERT:
1511      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1512      case OP_ASSERTBACK:      case OP_ASSERTBACK:
# Line 1606  do Line 1675  do
1675    
1676      switch(*cc)      switch(*cc)
1677        {        {
1678          case OP_KET:
1679          if (PRIVATE_DATA(cc) != 0)
1680            {
1681            count = 1;
1682            srcw[0] = PRIVATE_DATA(cc);
1683            }
1684          cc += 1 + LINK_SIZE;
1685          break;
1686    
1687        case OP_ASSERT:        case OP_ASSERT:
1688        case OP_ASSERT_NOT:        case OP_ASSERT_NOT:
1689        case OP_ASSERTBACK:        case OP_ASSERTBACK:
# Line 1852  if (save) Line 1930  if (save)
1930  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
1931  }  }
1932    
1933    static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)
1934    {
1935    pcre_uchar *end = bracketend(cc);
1936    BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
1937    
1938    /* Assert captures then. */
1939    if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
1940      current_offset = NULL;
1941    /* Conditional block does not. */
1942    if (*cc == OP_COND || *cc == OP_SCOND)
1943      has_alternatives = FALSE;
1944    
1945    cc = next_opcode(common, cc);
1946    if (has_alternatives)
1947      current_offset = common->then_offsets + (cc - common->start);
1948    
1949    while (cc < end)
1950      {
1951      if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
1952        cc = set_then_offsets(common, cc, current_offset);
1953      else
1954        {
1955        if (*cc == OP_ALT && has_alternatives)
1956          current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);
1957        if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)
1958          *current_offset = 1;
1959        cc = next_opcode(common, cc);
1960        }
1961      }
1962    
1963    return end;
1964    }
1965    
1966  #undef CASE_ITERATOR_PRIVATE_DATA_1  #undef CASE_ITERATOR_PRIVATE_DATA_1
1967  #undef CASE_ITERATOR_PRIVATE_DATA_2A  #undef CASE_ITERATOR_PRIVATE_DATA_2A
1968  #undef CASE_ITERATOR_PRIVATE_DATA_2B  #undef CASE_ITERATOR_PRIVATE_DATA_2B
# Line 1915  while (list_item) Line 2026  while (list_item)
2026  common->stubs = NULL;  common->stubs = NULL;
2027  }  }
2028    
2029  static SLJIT_INLINE void decrease_call_count(compiler_common *common)  static SLJIT_INLINE void count_match(compiler_common *common)
2030  {  {
2031  DEFINE_COMPILER;  DEFINE_COMPILER;
2032    
2033  OP2(SLJIT_SUB | SLJIT_SET_E, CALL_COUNT, 0, CALL_COUNT, 0, SLJIT_IMM, 1);  OP2(SLJIT_SUB | SLJIT_SET_E, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);
2034  add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));  add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));
2035  }  }
2036    
# Line 1999  else Line 2110  else
2110  OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);
2111  if (common->mark_ptr != 0)  if (common->mark_ptr != 0)
2112    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, SLJIT_IMM, 0);
2113  SLJIT_ASSERT(common->control_head_ptr != 0);  if (common->control_head_ptr != 0)
2114  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);
2115  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));
2116  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr);  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr);
2117  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, base));  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, base));
2118  }  }
2119    
2120  static sljit_sw SLJIT_CALL do_check_control_chain(sljit_sw *current)  static sljit_sw SLJIT_CALL do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)
2121  {  {
2122  sljit_sw return_value = 0;  while (current != NULL)
   
 SLJIT_ASSERT(current != NULL);  
 do  
2123    {    {
2124    switch (current[-2])    switch (current[-2])
2125      {      {
2126      case type_commit:      case type_then_trap:
     /* Commit overwrites all. */  
     return -1;  
   
     case type_prune:  
2127      break;      break;
2128    
2129      case type_skip:      case type_mark:
2130      /* Overwrites prune, but not other skips. */      if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[-3]) == 0)
2131      if (return_value == 0)        return current[-4];
       return_value = current[-3];  
2132      break;      break;
2133    
2134      default:      default:
# Line 2034  do Line 2137  do
2137      }      }
2138    current = (sljit_sw*)current[-1];    current = (sljit_sw*)current[-1];
2139    }    }
2140  while (current != NULL);  return -1;
 return return_value;  
2141  }  }
2142    
2143  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
# Line 2275  return (bit < 256) ? ((0 << 8) | bit) : Line 2377  return (bit < 256) ? ((0 << 8) | bit) :
2377    
2378  static void check_partial(compiler_common *common, BOOL force)  static void check_partial(compiler_common *common, BOOL force)
2379  {  {
2380  /* Checks whether a partial matching is occured. Does not modify registers. */  /* Checks whether a partial matching is occurred. Does not modify registers. */
2381  DEFINE_COMPILER;  DEFINE_COMPILER;
2382  struct sljit_jump *jump = NULL;  struct sljit_jump *jump = NULL;
2383    
# Line 2362  else Line 2464  else
2464  JUMPHERE(jump);  JUMPHERE(jump);
2465  }  }
2466    
2467  static void read_char(compiler_common *common)  static void peek_char(compiler_common *common)
2468  {  {
2469  /* Reads the character into TMP1, updates STR_PTR.  /* Reads the character into TMP1, keeps STR_PTR.
2470  Does not check STR_END. TMP2 Destroyed. */  Does not check STR_END. TMP2 Destroyed. */
2471  DEFINE_COMPILER;  DEFINE_COMPILER;
2472  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
# Line 2372  struct sljit_jump *jump; Line 2474  struct sljit_jump *jump;
2474  #endif  #endif
2475    
2476  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2477  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2478  if (common->utf)  if (common->utf)
2479    {    {
 #if defined COMPILE_PCRE8  
2480    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
2481  #elif defined COMPILE_PCRE16    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);  
 #endif /* COMPILE_PCRE[8|16] */  
2482    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
2483      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2484    JUMPHERE(jump);    JUMPHERE(jump);
2485    }    }
2486  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
2487    
2488    #if defined SUPPORT_UTF && defined COMPILE_PCRE16
2489    if (common->utf)
2490      {
2491      OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
2492      jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
2493      /* TMP2 contains the high surrogate. */
2494      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2495      OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
2496      OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
2497      OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
2498      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2499      JUMPHERE(jump);
2500      }
2501    #endif
2502    }
2503    
2504    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2505    
2506    static BOOL is_char7_bitset(const pcre_uint8* bitset, BOOL nclass)
2507    {
2508    /* Tells whether the character codes below 128 are enough
2509    to determine a match. */
2510    const pcre_uint8 value = nclass ? 0xff : 0;
2511    const pcre_uint8* end = bitset + 32;
2512    
2513    bitset += 16;
2514    do
2515      {
2516      if (*bitset++ != value)
2517        return FALSE;
2518      }
2519    while (bitset < end);
2520    return TRUE;
2521    }
2522    
2523    static void read_char7_type(compiler_common *common, BOOL full_read)
2524    {
2525    /* Reads the precise character type of a character into TMP1, if the character
2526    is less than 128. Otherwise it returns with zero. Does not check STR_END. The
2527    full_read argument tells whether characters above max are accepted or not. */
2528    DEFINE_COMPILER;
2529    struct sljit_jump *jump;
2530    
2531    SLJIT_ASSERT(common->utf);
2532    
2533    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
2534  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));
2535    
2536    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2537    
2538    if (full_read)
2539      {
2540      jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
2541      OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
2542      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2543      JUMPHERE(jump);
2544      }
2545  }  }
2546    
2547  static void peek_char(compiler_common *common)  #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
2548    
2549    static void read_char_max(compiler_common *common, pcre_uint32 max, BOOL full_read)
2550  {  {
2551  /* Reads the character into TMP1, keeps STR_PTR.  /* Reads the precise value of a character into TMP1, if the character is
2552  Does not check STR_END. TMP2 Destroyed. */  less than or equal to max. Otherwise it returns with a value greater than max.
2553    Does not check STR_END. The full_read argument tells whether characters above
2554    max are accepted or not. */
2555  DEFINE_COMPILER;  DEFINE_COMPILER;
2556  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2557  struct sljit_jump *jump;  struct sljit_jump *jump;
2558  #endif  #endif
2559    
2560    SLJIT_UNUSED_ARG(full_read);
2561    SLJIT_UNUSED_ARG(max);
2562    
2563  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2564  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2565    
2566    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2567  if (common->utf)  if (common->utf)
2568    {    {
2569  #if defined COMPILE_PCRE8    if (max < 128 && !full_read)
2570        return;
2571    
2572    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
2573  #elif defined COMPILE_PCRE16    if (max >= 0x800)
2574    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);      add_jump(compiler, (max < 0x10000) ? &common->utfreadchar16 : &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
2575  #endif /* COMPILE_PCRE[8|16] */    else if (max < 128)
2576    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));      {
2577    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);      OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
2578        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2579        }
2580      else
2581        {
2582        OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2583        if (!full_read)
2584          OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2585        else
2586          OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
2587        OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2588        OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2589        OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2590        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2591        if (full_read)
2592          OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
2593        }
2594    JUMPHERE(jump);    JUMPHERE(jump);
2595    }    }
2596  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */  #endif
2597    
2598    #if defined SUPPORT_UTF && defined COMPILE_PCRE16
2599    if (common->utf)
2600      {
2601      if (max >= 0x10000)
2602        {
2603        OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
2604        jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
2605        /* TMP2 contains the high surrogate. */
2606        OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2607        OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
2608        OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
2609        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2610        OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
2611        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2612        JUMPHERE(jump);
2613        return;
2614        }
2615    
2616      if (max < 0xd800 && !full_read)
2617        return;
2618    
2619      /* Skip low surrogate if necessary. */
2620      OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
2621      jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
2622      if (full_read)
2623        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2624      if (max >= 0xd800)
2625        OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000);
2626      JUMPHERE(jump);
2627      }
2628    #endif
2629    }
2630    
2631    static SLJIT_INLINE void read_char(compiler_common *common)
2632    {
2633    read_char_max(common, READ_CHAR_ANY, TRUE);
2634  }  }
2635    
2636  static void read_char8_type(compiler_common *common)  static void read_char8_type(compiler_common *common, BOOL full_read)
2637  {  {
2638  /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */  /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END.
2639    The full_read argument tells whether characters above max are accepted or not. */
2640  DEFINE_COMPILER;  DEFINE_COMPILER;
2641  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
2642  struct sljit_jump *jump;  struct sljit_jump *jump;
2643  #endif  #endif
2644    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2645    struct sljit_jump *jump2;
2646    #endif
2647    
2648  #ifdef SUPPORT_UTF  SLJIT_UNUSED_ARG(full_read);
2649    
2650    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
2651    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2652    
2653    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2654  if (common->utf)  if (common->utf)
2655    {    {
   OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);  
   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  
 #if defined COMPILE_PCRE8  
2656    /* This can be an extra read in some situations, but hopefully    /* This can be an extra read in some situations, but hopefully
2657    it is needed in most cases. */    it is needed in most cases. */
2658    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2659    jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);    jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
2660    add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));    if (!full_read)
2661    JUMPHERE(jump);      {
2662  #elif defined COMPILE_PCRE16      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2663    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2664    jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);      OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2665    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);      OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
2666    JUMPHERE(jump);      OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2667    /* Skip low surrogate if necessary. */      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
2668    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);      OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
2669    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);      jump2 = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
2670    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);      OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2671    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);      JUMPHERE(jump2);
2672    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);      }
2673  #elif defined COMPILE_PCRE32    else
2674    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);      add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);  
   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);  
2675    JUMPHERE(jump);    JUMPHERE(jump);
 #endif /* COMPILE_PCRE[8|16|32] */  
2676    return;    return;
2677    }    }
2678  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
2679  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);  
2680  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  #if !defined COMPILE_PCRE8
 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  
2681  /* The ctypes array contains only 256 values. */  /* The ctypes array contains only 256 values. */
2682  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
2683  jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);  jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
2684  #endif  #endif
2685  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2686  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if !defined COMPILE_PCRE8
2687  JUMPHERE(jump);  JUMPHERE(jump);
2688  #endif  #endif
2689    
2690    #if defined SUPPORT_UTF && defined COMPILE_PCRE16
2691    if (common->utf && full_read)
2692      {
2693      /* Skip low surrogate if necessary. */
2694      OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800);
2695      jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
2696      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2697      JUMPHERE(jump);
2698      }
2699    #endif /* SUPPORT_UTF && COMPILE_PCRE16 */
2700  }  }
2701    
2702  static void skip_char_back(compiler_common *common)  static void skip_char_back(compiler_common *common)
# Line 2500  if (common->utf) Line 2734  if (common->utf)
2734  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2735  }  }
2736    
2737  static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpiftrue)  static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpifmatch)
2738  {  {
2739  /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */  /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */
2740  DEFINE_COMPILER;  DEFINE_COMPILER;
2741    struct sljit_jump *jump;
2742    
2743  if (nltype == NLTYPE_ANY)  if (nltype == NLTYPE_ANY)
2744    {    {
2745    add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
2746    add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));    add_jump(compiler, backtracks, JUMP(jumpifmatch ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
2747    }    }
2748  else if (nltype == NLTYPE_ANYCRLF)  else if (nltype == NLTYPE_ANYCRLF)
2749    {    {
2750    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_CR);    if (jumpifmatch)
2751    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);      {
2752    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR));
2753    OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
2754    add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));      }
2755      else
2756        {
2757        jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
2758        add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
2759        JUMPHERE(jump);
2760        }
2761    }    }
2762  else  else
2763    {    {
2764    SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);    SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);
2765    add_jump(compiler, backtracks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));    add_jump(compiler, backtracks, CMP(jumpifmatch ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
2766    }    }
2767  }  }
2768    
# Line 2531  else Line 2772  else
2772  static void do_utfreadchar(compiler_common *common)  static void do_utfreadchar(compiler_common *common)
2773  {  {
2774  /* Fast decoding a UTF-8 character. TMP1 contains the first byte  /* Fast decoding a UTF-8 character. TMP1 contains the first byte
2775  of the character (>= 0xc0). Return char value in TMP1, length - 1 in TMP2. */  of the character (>= 0xc0). Return char value in TMP1, length in TMP2. */
2776  DEFINE_COMPILER;  DEFINE_COMPILER;
2777  struct sljit_jump *jump;  struct sljit_jump *jump;
2778    
2779  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
2780    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2781    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2782    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2783    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2784    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2785    
2786  /* Searching for the first zero. */  /* Searching for the first zero. */
2787  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
2788  jump = JUMP(SLJIT_C_NOT_ZERO);  jump = JUMP(SLJIT_C_NOT_ZERO);
2789  /* Two byte sequence. */  /* Two byte sequence. */
 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  
2790  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));
2791  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1f);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
2792    sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2793    
2794    JUMPHERE(jump);
2795    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
2796    OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
2797  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2798  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2799  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));  
 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  
 JUMPHERE(jump);  
2800    
2801  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10);  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10000);
2802  jump = JUMP(SLJIT_C_NOT_ZERO);  jump = JUMP(SLJIT_C_NOT_ZERO);
2803  /* Three byte sequence. */  /* Three byte sequence. */
 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  
 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0f);  
 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12);  
 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  
 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);  
 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  
 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));  
2804  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
2805  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));
 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));  
2806  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 JUMPHERE(jump);  
2807    
2808  /* Four byte sequence. */  /* Four byte sequence. */
2809  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  JUMPHERE(jump);
 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x07);  
 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 18);  
 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  
 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);  
 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  
2810  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
2811  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
2812  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  
 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(3));  
2813  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
2814  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2815  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2816  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(4));
2817  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2818  }  }
2819    
2820  static void do_utfreadtype8(compiler_common *common)  static void do_utfreadchar16(compiler_common *common)
2821  {  {
2822  /* Fast decoding a UTF-8 character type. TMP2 contains the first byte  /* Fast decoding a UTF-8 character. TMP1 contains the first byte
2823  of the character (>= 0xc0). Return value in TMP1. */  of the character (>= 0xc0). Return value in TMP1. */
2824  DEFINE_COMPILER;  DEFINE_COMPILER;
2825  struct sljit_jump *jump;  struct sljit_jump *jump;
 struct sljit_jump *compare;  
2826    
2827  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
2828    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2829    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2830    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2831    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2832    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2833    
2834  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);  /* Searching for the first zero. */
2835    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
2836  jump = JUMP(SLJIT_C_NOT_ZERO);  jump = JUMP(SLJIT_C_NOT_ZERO);
2837  /* Two byte sequence. */  /* Two byte sequence. */
 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));  
2838  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));
 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);  
 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);  
 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);  
 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);  
 compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);  
 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);  
2839  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2840    
 JUMPHERE(compare);  
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);  
 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  
2841  JUMPHERE(jump);  JUMPHERE(jump);
2842    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x400);
2843  /* We only have types for characters less than 256. */  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_NOT_ZERO);
2844  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);  /* This code runs only in 8 bit mode. No need to shift the value. */
2845  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2846  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
2847    OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
2848    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2849    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2850    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2851    /* Three byte sequence. */
2852    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
2853  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2854  }  }
2855    
2856  #elif defined COMPILE_PCRE16  static void do_utfreadtype8(compiler_common *common)
   
 static void do_utfreadchar(compiler_common *common)  
2857  {  {
2858  /* Fast decoding a UTF-16 character. TMP1 contains the first 16 bit char  /* Fast decoding a UTF-8 character type. TMP2 contains the first byte
2859  of the character (>= 0xd800). Return char value in TMP1, length - 1 in TMP2. */  of the character (>= 0xc0). Return value in TMP1. */
2860  DEFINE_COMPILER;  DEFINE_COMPILER;
2861  struct sljit_jump *jump;  struct sljit_jump *jump;
2862    struct sljit_jump *compare;
2863    
2864    sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
2865    
2866    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
2867    jump = JUMP(SLJIT_C_NOT_ZERO);
2868    /* Two byte sequence. */
2869    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2870    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2871    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);
2872    /* The upper 5 bits are known at this point. */
2873    compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 0x3);
2874    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
2875    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2876    OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
2877    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2878    sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2879    
2880  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);  JUMPHERE(compare);
2881  jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xdc00);  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
 /* Do nothing, only return. */  
2882  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2883    
2884    /* We only have types for characters less than 256. */
2885  JUMPHERE(jump);  JUMPHERE(jump);
2886  /* Combine two 16 bit characters. */  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
2887  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
2888  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);  
 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 10);  
 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3ff);  
 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));  
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);  
2889  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2890  }  }
2891    
2892  #endif /* COMPILE_PCRE[8|16] */  #endif /* COMPILE_PCRE8 */
2893    
2894  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
2895    
# Line 2723  if (firstline) Line 2964  if (firstline)
2964      mainloop = LABEL();      mainloop = LABEL();
2965      /* Continual stores does not cause data dependency. */      /* Continual stores does not cause data dependency. */
2966      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
2967      read_char(common);      read_char_max(common, common->nlmax, TRUE);
2968      check_newlinechar(common, common->nltype, &newline, TRUE);      check_newlinechar(common, common->nltype, &newline, TRUE);
2969      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
2970      JUMPHERE(end);      JUMPHERE(end);
# Line 2799  if (newlinecheck) Line 3040  if (newlinecheck)
3040  return mainloop;  return mainloop;
3041  }  }
3042    
3043  #define MAX_N_CHARS 3  static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uint32 *chars, int max_chars)
   
 static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)  
3044  {  {
3045  DEFINE_COMPILER;  /* Recursive function, which scans prefix literals. */
3046  struct sljit_label *start;  int len, repeat, len_save, consumed = 0;
3047  struct sljit_jump *quit;  pcre_uint32 caseless, chr, mask;
3048  pcre_uint32 chars[MAX_N_CHARS * 2];  pcre_uchar *alternative, *cc_save;
3049  pcre_uchar *cc = common->start + 1 + LINK_SIZE;  BOOL last, any;
 int location = 0;  
 pcre_int32 len, c, bit, caseless;  
 int must_stop;  
   
 /* We do not support alternatives now. */  
 if (*(common->start + GET(common->start, 1)) == OP_ALT)  
   return FALSE;  
3050    
3051    repeat = 1;
3052  while (TRUE)  while (TRUE)
3053    {    {
3054      last = TRUE;
3055      any = FALSE;
3056    caseless = 0;    caseless = 0;
3057    must_stop = 1;    switch (*cc)
   switch(*cc)  
3058      {      {
     case OP_CHAR:  
     must_stop = 0;  
     cc++;  
     break;  
   
3059      case OP_CHARI:      case OP_CHARI:
3060      caseless = 1;      caseless = 1;
3061      must_stop = 0;      case OP_CHAR:
3062        last = FALSE;
3063      cc++;      cc++;
3064      break;      break;
3065    
# Line 2854  while (TRUE) Line 3084  while (TRUE)
3084      cc++;      cc++;
3085      break;      break;
3086    
3087        case OP_EXACTI:
3088        caseless = 1;
3089      case OP_EXACT:      case OP_EXACT:
3090        repeat = GET2(cc, 1);
3091        last = FALSE;
3092      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
3093      break;      break;
3094    
# Line 2865  while (TRUE) Line 3099  while (TRUE)
3099      cc++;      cc++;
3100      break;      break;
3101    
3102      case OP_EXACTI:      case OP_KET:
3103      caseless = 1;      cc += 1 + LINK_SIZE;
3104      cc += 1 + IMM2_SIZE;      continue;
3105    
3106        case OP_ALT:
3107        cc += GET(cc, 1);
3108        continue;
3109    
3110        case OP_ONCE:
3111        case OP_ONCE_NC:
3112        case OP_BRA:
3113        case OP_BRAPOS:
3114        case OP_CBRA:
3115        case OP_CBRAPOS:
3116        alternative = cc + GET(cc, 1);
3117        while (*alternative == OP_ALT)
3118          {
3119          max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, max_chars);
3120          if (max_chars == 0)
3121            return consumed;
3122          alternative += GET(alternative, 1);
3123          }
3124    
3125        if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
3126          cc += IMM2_SIZE;
3127        cc += 1 + LINK_SIZE;
3128        continue;
3129    
3130        case OP_CLASS:
3131        case OP_NCLASS:
3132        any = TRUE;
3133        cc += 1 + 32 / sizeof(pcre_uchar);
3134      break;      break;
3135    
3136      default:  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3137      must_stop = 2;      case OP_XCLASS:
3138        any = TRUE;
3139        cc += GET(cc, 1);
3140        break;
3141    #endif
3142    
3143        case OP_NOT_DIGIT:
3144        case OP_DIGIT:
3145        case OP_NOT_WHITESPACE:
3146        case OP_WHITESPACE:
3147        case OP_NOT_WORDCHAR:
3148        case OP_WORDCHAR:
3149        case OP_ANY:
3150        case OP_ALLANY:
3151        any = TRUE;
3152        cc++;
3153      break;      break;
3154    
3155    #ifdef SUPPORT_UCP
3156        case OP_NOTPROP:
3157        case OP_PROP:
3158        any = TRUE;
3159        cc += 1 + 2;
3160        break;
3161    #endif
3162    
3163        case OP_TYPEEXACT:
3164        repeat = GET2(cc, 1);
3165        cc += 1 + IMM2_SIZE;
3166        continue;
3167    
3168        default:
3169        return consumed;
3170      }      }
3171    
3172    if (must_stop == 2)    if (any)
3173        break;      {
3174    #ifdef SUPPORT_UTF
3175        if (common->utf) return consumed;
3176    #endif
3177    #if defined COMPILE_PCRE8
3178        mask = 0xff;
3179    #elif defined COMPILE_PCRE16
3180        mask = 0xffff;
3181    #elif defined COMPILE_PCRE32
3182        mask = 0xffffffff;
3183    #else
3184        SLJIT_ASSERT_STOP();
3185    #endif
3186    
3187        do
3188          {
3189          chars[0] = mask;
3190          chars[1] = mask;
3191    
3192          if (--max_chars == 0)
3193            return consumed;
3194          consumed++;
3195          chars += 2;
3196          }
3197        while (--repeat > 0);
3198    
3199        repeat = 1;
3200        continue;
3201        }
3202    
3203    len = 1;    len = 1;
3204  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3205    if (common->utf && HAS_EXTRALEN(cc[0])) len += GET_EXTRALEN(cc[0]);    if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3206  #endif  #endif
3207    
3208    if (caseless && char_has_othercase(common, cc))    if (caseless != 0 && char_has_othercase(common, cc))
3209      {      {
3210      caseless = char_get_othercase_bit(common, cc);      caseless = char_get_othercase_bit(common, cc);
3211      if (caseless == 0)      if (caseless == 0)
3212        return FALSE;        return consumed;
3213  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
3214      caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));      caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));
3215  #else  #else
# Line 2900  while (TRUE) Line 3222  while (TRUE)
3222    else    else
3223      caseless = 0;      caseless = 0;
3224    
3225    while (len > 0 && location < MAX_N_CHARS * 2)    len_save = len;
3226      {    cc_save = cc;
3227      c = *cc;    while (TRUE)
3228      bit = 0;      {
3229      if (len == (caseless & 0xff))      do
3230        {        {
3231        bit = caseless >> 8;        chr = *cc;
3232        c |= bit;  #ifdef COMPILE_PCRE32
3233          if (SLJIT_UNLIKELY(chr == NOTACHAR))
3234            return consumed;
3235    #endif
3236          mask = 0;
3237          if ((pcre_uint32)len == (caseless & 0xff))
3238            {
3239            mask = caseless >> 8;
3240            chr |= mask;
3241            }
3242    
3243          if (chars[0] == NOTACHAR)
3244            {
3245            chars[0] = chr;
3246            chars[1] = mask;
3247            }
3248          else
3249            {
3250            mask |= chars[0] ^ chr;
3251            chr |= mask;
3252            chars[0] = chr;
3253            chars[1] |= mask;
3254            }
3255    
3256          len--;
3257          if (--max_chars == 0)
3258            return consumed;
3259          consumed++;
3260          chars += 2;
3261          cc++;
3262        }        }
3263        while (len > 0);
3264    
3265        if (--repeat == 0)
3266          break;
3267    
3268      chars[location] = c;      len = len_save;
3269      chars[location + 1] = bit;      cc = cc_save;
3270        }
3271    
3272      len--;    repeat = 1;
3273      location += 2;    if (last)
3274      cc++;      return consumed;
3275      }
3276    }
3277    
3278    #define MAX_N_CHARS 16
3279    
3280    static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
3281    {
3282    DEFINE_COMPILER;
3283    struct sljit_label *start;
3284    struct sljit_jump *quit;
3285    pcre_uint32 chars[MAX_N_CHARS * 2];
3286    pcre_uint8 ones[MAX_N_CHARS];
3287    pcre_uint32 mask;
3288    int i, max;
3289    int offsets[3];
3290    
3291    for (i = 0; i < MAX_N_CHARS; i++)
3292      {
3293      chars[i << 1] = NOTACHAR;
3294      chars[(i << 1) + 1] = 0;
3295      }
3296    
3297    max = scan_prefix(common, common->start, chars, MAX_N_CHARS);
3298    
3299    if (max <= 1)
3300      return FALSE;
3301    
3302    for (i = 0; i < max; i++)
3303      {
3304      mask = chars[(i << 1) + 1];
3305      ones[i] = ones_in_half_byte[mask & 0xf];
3306      mask >>= 4;
3307      while (mask != 0)
3308        {
3309        ones[i] += ones_in_half_byte[mask & 0xf];
3310        mask >>= 4;
3311      }      }
3312      }
3313    
3314    if (location >= MAX_N_CHARS * 2 || must_stop != 0)  offsets[0] = -1;
3315    /* Scan forward. */
3316    for (i = 0; i < max; i++)
3317      if (ones[i] <= 2) {
3318        offsets[0] = i;
3319      break;      break;
3320    }    }
3321    
3322  /* At least two characters are required. */  if (offsets[0] == -1)
3323  if (location < 2 * 2)    return FALSE;
3324      return FALSE;  
3325    /* Scan backward. */
3326    offsets[1] = -1;
3327    for (i = max - 1; i > offsets[0]; i--)
3328      if (ones[i] <= 2) {
3329        offsets[1] = i;
3330        break;
3331      }
3332    
3333    offsets[2] = -1;
3334    if (offsets[1] >= 0)
3335      {
3336      /* Scan from middle. */
3337      for (i = (offsets[0] + offsets[1]) / 2 + 1; i < offsets[1]; i++)
3338        if (ones[i] <= 2)
3339          {
3340          offsets[2] = i;
3341          break;
3342          }
3343    
3344      if (offsets[2] == -1)
3345        {
3346        for (i = (offsets[0] + offsets[1]) / 2; i > offsets[0]; i--)
3347          if (ones[i] <= 2)
3348            {
3349            offsets[2] = i;
3350            break;
3351            }
3352        }
3353      }
3354    
3355    SLJIT_ASSERT(offsets[1] == -1 || (offsets[0] < offsets[1]));
3356    SLJIT_ASSERT(offsets[2] == -1 || (offsets[0] < offsets[2] && offsets[1] > offsets[2]));
3357    
3358    chars[0] = chars[offsets[0] << 1];
3359    chars[1] = chars[(offsets[0] << 1) + 1];
3360    if (offsets[2] >= 0)
3361      {
3362      chars[2] = chars[offsets[2] << 1];
3363      chars[3] = chars[(offsets[2] << 1) + 1];
3364      }
3365    if (offsets[1] >= 0)
3366      {
3367      chars[4] = chars[offsets[1] << 1];
3368      chars[5] = chars[(offsets[1] << 1) + 1];
3369      }
3370    
3371    max -= 1;
3372  if (firstline)  if (firstline)
3373    {    {
3374    SLJIT_ASSERT(common->first_line_end != 0);    SLJIT_ASSERT(common->first_line_end != 0);
3375    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
3376    OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));    OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, IN_UCHARS(max));
3377    }    }
3378  else  else
3379    OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));    OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
3380    
3381  start = LABEL();  start = LABEL();
3382  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3383    
3384  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[0]));
3385  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  if (offsets[1] >= 0)
3386      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[1]));
3387  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));
3388    
3389  if (chars[1] != 0)  if (chars[1] != 0)
3390    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
3391  CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);  CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
3392  if (location > 2 * 2)  if (offsets[2] >= 0)
3393    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[2] - 1));
3394  if (chars[3] != 0)  
3395    OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[3]);  if (offsets[1] >= 0)
 CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[2], start);  
 if (location > 2 * 2)  
3396    {    {
3397    if (chars[5] != 0)    if (chars[5] != 0)
3398      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[5]);      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[5]);
3399    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[4], start);    CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[4], start);
3400      }
3401    
3402    if (offsets[2] >= 0)
3403      {
3404      if (chars[3] != 0)
3405        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[3]);
3406      CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[2], start);
3407    }    }
3408  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
3409    
# Line 2962  JUMPHERE(quit); Line 3412  JUMPHERE(quit);
3412  if (firstline)  if (firstline)
3413    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
3414  else  else
3415    OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));    OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
3416  return TRUE;  return TRUE;
3417  }  }
3418    
# Line 3082  firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_ Line 3532  firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_
3532  skip_char_back(common);  skip_char_back(common);
3533    
3534  loop = LABEL();  loop = LABEL();
3535  read_char(common);  read_char_max(common, common->nlmax, TRUE);
3536  lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);  lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3537  if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)  if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
3538    foundcr = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);    foundcr = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
# Line 3111  if (firstline) Line 3561  if (firstline)
3561    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
3562  }  }
3563    
3564  static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks);  static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks);
3565    
3566  static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline)  static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, pcre_uint8 *start_bits, BOOL firstline)
3567  {  {
3568  DEFINE_COMPILER;  DEFINE_COMPILER;
3569  struct sljit_label *start;  struct sljit_label *start;
3570  struct sljit_jump *quit;  struct sljit_jump *quit;
3571  struct sljit_jump *found = NULL;  struct sljit_jump *found = NULL;
3572  jump_list *matches = NULL;  jump_list *matches = NULL;
 pcre_uint8 inverted_start_bits[32];  
 int i;  
3573  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
3574  struct sljit_jump *jump;  struct sljit_jump *jump;
3575  #endif  #endif
3576    
 for (i = 0; i < 32; ++i)  
   inverted_start_bits[i] = ~(((pcre_uint8*)start_bits)[i]);  
   
3577  if (firstline)  if (firstline)
3578    {    {
3579    SLJIT_ASSERT(common->first_line_end != 0);    SLJIT_ASSERT(common->first_line_end != 0);
# Line 3144  if (common->utf) Line 3589  if (common->utf)
3589    OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);    OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
3590  #endif  #endif
3591    
3592  if (!check_class_ranges(common, inverted_start_bits, (inverted_start_bits[31] & 0x80) != 0, &matches))  if (!check_class_ranges(common, start_bits, (start_bits[31] & 0x80) != 0, TRUE, &matches))
3593    {    {
3594  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
3595    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 255);    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 255);
# Line 3153  if (!check_class_ranges(common, inverted Line 3598  if (!check_class_ranges(common, inverted
3598  #endif  #endif
3599    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
3600    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
3601    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), start_bits);    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)start_bits);
3602    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
3603    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
3604    found = JUMP(SLJIT_C_NOT_ZERO);    found = JUMP(SLJIT_C_NOT_ZERO);
# Line 3402  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSE Line 3847  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSE
3847  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
3848  }  }
3849    
3850  /*  static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks)
   range format:  
   
   ranges[0] = length of the range (max MAX_RANGE_SIZE, -1 means invalid range).  
   ranges[1] = first bit (0 or 1)  
   ranges[2-length] = position of the bit change (when the current bit is not equal to the previous)  
 */  
   
 static BOOL check_ranges(compiler_common *common, int *ranges, jump_list **backtracks, BOOL readch)  
3851  {  {
3852  DEFINE_COMPILER;  DEFINE_COMPILER;
3853  struct sljit_jump *jump;  int ranges[MAX_RANGE_SIZE];
3854    pcre_uint8 bit, cbit, all;
3855    int i, byte, length = 0;
3856    
3857    bit = bits[0] & 0x1;
3858    /* All bits will be zero or one (since bit is zero or one). */
3859    all = -bit;
3860    
3861    for (i = 0; i < 256; )
3862      {
3863      byte = i >> 3;
3864      if ((i & 0x7) == 0 && bits[byte] == all)
3865        i += 8;
3866      else
3867        {
3868        cbit = (bits[byte] >> (i & 0x7)) & 0x1;
3869        if (cbit != bit)
3870          {
3871          if (length >= MAX_RANGE_SIZE)
3872            return FALSE;
3873          ranges[length] = i;
3874          length++;
3875          bit = cbit;
3876          all = -cbit;
3877          }
3878        i++;
3879        }
3880      }
3881    
3882    if (((bit == 0) && nclass) || ((bit == 1) && !nclass))
3883      {
3884      if (length >= MAX_RANGE_SIZE)
3885        return FALSE;
3886      ranges[length] = 256;
3887      length++;
3888      }
3889    
3890  if (ranges[0] < 0)  if (length < 0 || length > 4)
3891    return FALSE;    return FALSE;
3892    
3893  switch(ranges[0])  bit = bits[0] & 0x1;
3894    if (invert) bit ^= 0x1;
3895    
3896    /* No character is accepted. */
3897    if (length == 0 && bit == 0)
3898      add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
3899    
3900    switch(length)
3901    {    {
3902      case 0:
3903      /* When bit != 0, all characters are accepted. */
3904      return TRUE;
3905    
3906    case 1:    case 1:
3907    if (readch)    add_jump(compiler, backtracks, CMP(bit == 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
     read_char(common);  
   add_jump(compiler, backtracks, CMP(ranges[1] == 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));  
3908    return TRUE;    return TRUE;
3909    
3910    case 2:    case 2:
3911    if (readch)    if (ranges[0] + 1 != ranges[1])
3912      read_char(common);      {
3913    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
3914    add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));      add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
3915        }
3916      else
3917        add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
3918    return TRUE;    return TRUE;
3919    
3920    case 4:    case 3:
3921    if (ranges[2] + 1 == ranges[3] && ranges[4] + 1 == ranges[5])    if (bit != 0)
3922      {      {
3923      if (readch)      add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
3924        read_char(common);      if (ranges[0] + 1 != ranges[1])
     if (ranges[1] != 0)  
3925        {        {
3926        add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
3927        add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));        add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
3928        }        }
3929      else      else
3930        {        add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
       jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]);  
       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));  
       JUMPHERE(jump);  
       }  
     return TRUE;  
     }  
   if ((ranges[3] - ranges[2]) == (ranges[5] - ranges[4]) && is_powerof2(ranges[4] - ranges[2]))  
     {  
     if (readch)  
       read_char(common);  
     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4] - ranges[2]);  
     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4]);  
     add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[5] - ranges[4]));  
3931      return TRUE;      return TRUE;
3932      }      }
   return FALSE;  
   
   default:  
   return FALSE;  
   }  
 }  
   
 static void get_ctype_ranges(compiler_common *common, int flag, int *ranges)  
 {  
 int i, bit, length;  
 const pcre_uint8 *ctypes = (const pcre_uint8*)common->ctypes;  
   
 bit = ctypes[0] & flag;  
 ranges[0] = -1;  
 ranges[1] = bit != 0 ? 1 : 0;  
 length = 0;  
3933    
3934  for (i = 1; i < 256; i++)    add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[0]));
3935    if ((ctypes[i] & flag) != bit)    if (ranges[1] + 1 != ranges[2])
3936      {      {
3937      if (length >= MAX_RANGE_SIZE)      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1]);
3938        return;      add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
     ranges[2 + length] = i;  
     length++;  
     bit ^= flag;  
3939      }      }
3940      else
3941        add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1]));
3942      return TRUE;
3943    
3944  if (bit != 0)    case 4:
3945    {    if ((ranges[1] - ranges[0]) == (ranges[3] - ranges[2])
3946    if (length >= MAX_RANGE_SIZE)        && (ranges[0] | (ranges[2] - ranges[0])) == ranges[2]
3947      return;        && is_powerof2(ranges[2] - ranges[0]))
3948    ranges[2 + length] = 256;      {
3949    length++;      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[0]);
3950    }      if (ranges[2] + 1 != ranges[3])
3951  ranges[0] = length;        {
3952  }        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);
3953          add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
3954  static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks)        }
3955  {      else
3956  int ranges[2 + MAX_RANGE_SIZE];        add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
3957  pcre_uint8 bit, cbit, all;      return TRUE;
3958  int i, byte, length = 0;      }
   
 bit = bits[0] & 0x1;  
 ranges[1] = bit;  
 /* Can be 0 or 255. */  
 all = -bit;  
3959    
3960  for (i = 0; i < 256; )    if (bit != 0)
   {  
   byte = i >> 3;  
   if ((i & 0x7) == 0 && bits[byte] == all)  
     i += 8;  
   else  
3961      {      {
3962      cbit = (bits[byte] >> (i & 0x7)) & 0x1;      i = 0;
3963      if (cbit != bit)      if (ranges[0] + 1 != ranges[1])
3964        {        {
3965        if (length >= MAX_RANGE_SIZE)        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
3966          return FALSE;        add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
3967        ranges[2 + length] = i;        i = ranges[0];
       length++;  
       bit = cbit;  
       all = -cbit;  
3968        }        }
3969      i++;      else
3970          add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
3971    
3972        if (ranges[2] + 1 != ranges[3])
3973          {
3974          OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - i);
3975          add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
3976          }
3977        else
3978          add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2] - i));
3979        return TRUE;
3980      }      }
   }  
3981    
3982  if (((bit == 0) && nclass) || ((bit == 1) && !nclass))    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
3983    {    add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[0]));
3984    if (length >= MAX_RANGE_SIZE)    if (ranges[1] + 1 != ranges[2])
3985      return FALSE;      {
3986    ranges[2 + length] = 256;      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]);
3987    length++;      add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
3988    }      }
3989  ranges[0] = length;    else
3990        add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
3991      return TRUE;
3992    
3993  return check_ranges(common, ranges, backtracks, FALSE);    default:
3994      SLJIT_ASSERT_STOP();
3995      return FALSE;
3996      }
3997  }  }
3998    
3999  static void check_anynewline(compiler_common *common)  static void check_anynewline(compiler_common *common)
# Line 3916  return cc; Line 4371  return cc;
4371    if ((value) != charoffset) \    if ((value) != charoffset) \
4372      { \      { \
4373      if ((value) > charoffset) \      if ((value) > charoffset) \
4374        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (value) - charoffset); \        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)((value) - charoffset)); \
4375      else \      else \
4376        OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, charoffset - (value)); \        OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(charoffset - (value))); \
4377      } \      } \
4378    charoffset = (value);    charoffset = (value);
4379    
# Line 3926  static void compile_xclass_matchingpath( Line 4381  static void compile_xclass_matchingpath(
4381  {  {
4382  DEFINE_COMPILER;  DEFINE_COMPILER;
4383  jump_list *found = NULL;  jump_list *found = NULL;
4384  jump_list **list = (*cc & XCL_NOT) == 0 ? &found : backtracks;  jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks;
4385  pcre_int32 c, charoffset;  sljit_uw c, charoffset, max = 0;
 const pcre_uint32 *other_cases;  
4386  struct sljit_jump *jump = NULL;  struct sljit_jump *jump = NULL;
4387  pcre_uchar *ccbegin;  pcre_uchar *ccbegin;
4388  int compares, invertcmp, numberofcmps;  int compares, invertcmp, numberofcmps;
4389    #if defined SUPPORT_UTF && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)
4390    BOOL utf = common->utf;
4391    #endif
4392    
4393  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
4394  BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;  BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
4395  BOOL charsaved = FALSE;  BOOL charsaved = FALSE;
4396  int typereg = TMP1, scriptreg = TMP1;  int typereg = TMP1, scriptreg = TMP1;
4397    const pcre_uint32 *other_cases;
4398  pcre_int32 typeoffset;  pcre_int32 typeoffset;
4399  #endif  #endif
4400    
 /* Although SUPPORT_UTF must be defined, we are  
    not necessary in utf mode even in 8 bit mode. */  
 detect_partial_match(common, backtracks);  
 read_char(common);  
   
 if ((*cc++ & XCL_MAP) != 0)  
   {  
   OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);  
 #ifndef COMPILE_PCRE8  
   jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);  
 #elif defined SUPPORT_UTF  
   if (common->utf)  
     jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);  
 #endif  
   
   if (!check_class_ranges(common, (const pcre_uint8 *)cc, TRUE, list))  
     {  
     OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);  
     OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);  
     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);  
     OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);  
     OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);  
     add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));  
     }  
   
 #ifndef COMPILE_PCRE8  
   JUMPHERE(jump);  
 #elif defined SUPPORT_UTF  
   if (common->utf)  
     JUMPHERE(jump);  
 #endif  
   OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);  
 #ifdef SUPPORT_UCP  
   charsaved = TRUE;  
 #endif  
   cc += 32 / sizeof(pcre_uchar);  
   }  
   
4401  /* Scanning the necessary info. */  /* Scanning the necessary info. */
4402    cc++;
4403  ccbegin = cc;  ccbegin = cc;
4404  compares = 0;  compares = 0;
4405    if (cc[-1] & XCL_MAP) cc += 32 / sizeof(pcre_uchar);
4406    
4407  while (*cc != XCL_END)  while (*cc != XCL_END)
4408    {    {
4409    compares++;    compares++;
4410    if (*cc == XCL_SINGLE)    if (*cc == XCL_SINGLE)
4411      {      {
4412      cc += 2;      cc ++;
4413  #ifdef SUPPORT_UTF      GETCHARINCTEST(c, cc);
4414      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);      if (c > max) max = c;
 #endif  
4415  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
4416      needschar = TRUE;      needschar = TRUE;
4417  #endif  #endif
# Line 3999  while (*cc != XCL_END) Line 4422  while (*cc != XCL_END)
4422  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
4423      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
4424  #endif  #endif
4425      cc++;      GETCHARINCTEST(c, cc);
4426  #ifdef SUPPORT_UTF      if (c > max) max = c;
     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);  
 #endif  
4427  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
4428      needschar = TRUE;      needschar = TRUE;
4429  #endif  #endif
# Line 4012  while (*cc != XCL_END) Line 4433  while (*cc != XCL_END)
4433      {      {
4434      SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);      SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
4435      cc++;      cc++;
4436        if (*cc == PT_CLIST)
4437          {
4438          other_cases = PRIV(ucd_caseless_sets) + cc[1];
4439          while (*other_cases != NOTACHAR)
4440            {
4441            if (*other_cases > max) max = *other_cases;
4442            other_cases++;
4443            }
4444          }
4445        else
4446          max = READ_CHAR_ANY;
4447    
4448      switch(*cc)      switch(*cc)
4449        {        {
4450        case PT_ANY:        case PT_ANY:
# Line 4031  while (*cc != XCL_END) Line 4464  while (*cc != XCL_END)
4464        case PT_SPACE:        case PT_SPACE:
4465        case PT_PXSPACE:        case PT_PXSPACE:
4466        case PT_WORD:        case PT_WORD:
4467          case PT_PXGRAPH:
4468          case PT_PXPRINT:
4469          case PT_PXPUNCT:
4470        needstype = TRUE;        needstype = TRUE;
4471        needschar = TRUE;        needschar = TRUE;
4472        break;        break;
# Line 4049  while (*cc != XCL_END) Line 4485  while (*cc != XCL_END)
4485  #endif  #endif
4486    }    }
4487    
4488    /* We are not necessary in utf mode even in 8 bit mode. */
4489    cc = ccbegin;
4490    detect_partial_match(common, backtracks);
4491    read_char_max(common, max, (cc[0] & XCL_NOT) != 0);
4492    
4493    if ((cc[-1] & XCL_HASPROP) == 0)
4494      {
4495      if ((cc[-1] & XCL_MAP) != 0)
4496        {
4497        jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
4498        if (!check_class_ranges(common, (const pcre_uint8 *)cc, (((const pcre_uint8 *)cc)[31] & 0x80) != 0, TRUE, &found))
4499          {
4500          OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
4501          OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
4502          OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
4503          OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
4504          OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
4505          add_jump(compiler, &found, JUMP(SLJIT_C_NOT_ZERO));
4506          }
4507    
4508        add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
4509        JUMPHERE(jump);
4510    
4511        cc += 32 / sizeof(pcre_uchar);
4512        }
4513      else
4514        add_jump(compiler, (cc[-1] & XCL_NOT) == 0 ? backtracks : &found, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, 0xff));
4515      }
4516    else if ((cc[-1] & XCL_MAP) != 0)
4517      {
4518      OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
4519    #ifdef SUPPORT_UCP
4520      charsaved = TRUE;
4521    #endif
4522      if (!check_class_ranges(common, (const pcre_uint8 *)cc, FALSE, TRUE, list))
4523        {
4524    #ifdef COMPILE_PCRE8
4525        SLJIT_ASSERT(common->utf);
4526    #endif
4527        jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
4528    
4529        OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
4530        OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
4531        OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
4532        OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
4533        OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
4534        add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));
4535    
4536        JUMPHERE(jump);
4537        }
4538    
4539      OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
4540      cc += 32 / sizeof(pcre_uchar);
4541      }
4542    
4543  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
4544  /* Simple register allocation. TMP1 is preferred if possible. */  /* Simple register allocation. TMP1 is preferred if possible. */
4545  if (needstype || needsscript)  if (needstype || needsscript)
# Line 4090  if (needstype || needsscript) Line 4581  if (needstype || needsscript)
4581  #endif  #endif
4582    
4583  /* Generating code. */  /* Generating code. */
 cc = ccbegin;  
4584  charoffset = 0;  charoffset = 0;
4585  numberofcmps = 0;  numberofcmps = 0;
4586  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 4106  while (*cc != XCL_END) Line 4596  while (*cc != XCL_END)
4596    if (*cc == XCL_SINGLE)    if (*cc == XCL_SINGLE)
4597      {      {
4598      cc ++;      cc ++;
4599  #ifdef SUPPORT_UTF      GETCHARINCTEST(c, cc);
     if (common->utf)  
       {  
       GETCHARINC(c, cc);  
       }  
     else  
 #endif  
       c = *cc++;  
4600    
4601      if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))      if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
4602        {        {
4603        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
4604        OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_EQUAL);        OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_EQUAL);
4605        numberofcmps++;        numberofcmps++;
4606        }        }
4607      else if (numberofcmps > 0)      else if (numberofcmps > 0)
4608        {        {
4609        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
4610        OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);        OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4611        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4612        numberofcmps = 0;        numberofcmps = 0;
4613        }        }
4614      else      else
4615        {        {
4616        jump = CMP(SLJIT_C_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, c - charoffset);        jump = CMP(SLJIT_C_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
4617        numberofcmps = 0;        numberofcmps = 0;
4618        }        }
4619      }      }
4620    else if (*cc == XCL_RANGE)    else if (*cc == XCL_RANGE)
4621      {      {
4622      cc ++;      cc ++;
4623  #ifdef SUPPORT_UTF      GETCHARINCTEST(c, cc);
     if (common->utf)  
       {  
       GETCHARINC(c, cc);  
       }  
     else  
 #endif  
       c = *cc++;  
4624      SET_CHAR_OFFSET(c);      SET_CHAR_OFFSET(c);
4625  #ifdef SUPPORT_UTF      GETCHARINCTEST(c, cc);
4626      if (common->utf)  
       {  
       GETCHARINC(c, cc);  
       }  
     else  
 #endif  
       c = *cc++;  
4627      if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))      if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
4628        {        {
4629        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
4630        OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_LESS_EQUAL);        OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_LESS_EQUAL);
4631        numberofcmps++;        numberofcmps++;
4632        }        }
4633      else if (numberofcmps > 0)      else if (numberofcmps > 0)
4634        {        {
4635        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
4636        OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);        OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
4637        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4638        numberofcmps = 0;        numberofcmps = 0;
4639        }        }
4640      else      else
4641        {        {
4642        jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, c - charoffset);        jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
4643        numberofcmps = 0;        numberofcmps = 0;
4644        }        }
4645      }      }
# Line 4218  while (*cc != XCL_END) Line 4688  while (*cc != XCL_END)
4688    
4689        case PT_SPACE:        case PT_SPACE:
4690        case PT_PXSPACE:        case PT_PXSPACE:
       if (*cc == PT_SPACE)  
         {  
         OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);  
         jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 11 - charoffset);  
         }  
4691        SET_CHAR_OFFSET(9);        SET_CHAR_OFFSET(9);
4692        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 13 - 9);        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd - 0x9);
4693        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
4694        if (*cc == PT_SPACE)  
4695          JUMPHERE(jump);        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x9);
4696          OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4697    
4698          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x9);
4699          OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4700    
4701        SET_TYPE_OFFSET(ucp_Zl);        SET_TYPE_OFFSET(ucp_Zl);
4702        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);
# Line 4236  while (*cc != XCL_END) Line 4705  while (*cc != XCL_END)
4705        break;        break;
4706    
4707        case PT_WORD:        case PT_WORD:
4708        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, (sljit_sw)(CHAR_UNDERSCORE - charoffset));
4709        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
4710        /* Fall through. */        /* Fall through. */
4711    
# Line 4284  while (*cc != XCL_END) Line 4753  while (*cc != XCL_END)
4753          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]);          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]);
4754          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
4755    
4756          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, other_cases[0] - charoffset);          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(other_cases[0] - charoffset));
4757          OP_FLAGS(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);          OP_FLAGS(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4758    
4759          other_cases += 3;          other_cases += 3;
4760          }          }
4761        else        else
4762          {          {
4763          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, *other_cases++ - charoffset);          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset));
4764          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
4765          }          }
4766    
4767        while (*other_cases != NOTACHAR)        while (*other_cases != NOTACHAR)
4768          {          {
4769          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, *other_cases++ - charoffset);          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset));
4770          OP_FLAGS(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);          OP_FLAGS(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4771          }          }
4772        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4773        break;        break;
4774    
4775        case PT_UCNC:        case PT_UCNC:
4776        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_DOLLAR_SIGN - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_DOLLAR_SIGN - charoffset));
4777        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
4778        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_COMMERCIAL_AT - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_COMMERCIAL_AT - charoffset));
4779        OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);        OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4780        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_GRAVE_ACCENT - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_GRAVE_ACCENT - charoffset));
4781        OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);        OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4782    
4783        SET_CHAR_OFFSET(0xa0);        SET_CHAR_OFFSET(0xa0);
4784        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd7ff - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(0xd7ff - charoffset));
4785        OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);        OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
4786        SET_CHAR_OFFSET(0);        SET_CHAR_OFFSET(0);
4787        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);        OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);
4788        OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_GREATER_EQUAL);        OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_GREATER_EQUAL);
4789        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4790        break;        break;
4791    
4792          case PT_PXGRAPH:
4793          /* C and Z groups are the farthest two groups. */
4794          SET_TYPE_OFFSET(ucp_Ll);
4795          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);
4796          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER);
4797    
4798          jump = CMP(SLJIT_C_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);
4799    
4800          /* In case of ucp_Cf, we overwrite the result. */
4801          SET_CHAR_OFFSET(0x2066);
4802          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);
4803          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
4804    
4805          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);
4806          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4807    
4808          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x2066);
4809          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4810    
4811          JUMPHERE(jump);
4812          jump = CMP(SLJIT_C_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);
4813          break;
4814    
4815          case PT_PXPRINT:
4816          /* C and Z groups are the farthest two groups. */
4817          SET_TYPE_OFFSET(ucp_Ll);
4818          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);
4819          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER);
4820    
4821          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Ll);
4822          OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_C_NOT_EQUAL);
4823    
4824          jump = CMP(SLJIT_C_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);
4825    
4826          /* In case of ucp_Cf, we overwrite the result. */
4827          SET_CHAR_OFFSET(0x2066);
4828          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);
4829          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
4830    
4831          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);
4832          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4833    
4834          JUMPHERE(jump);
4835          jump = CMP(SLJIT_C_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);
4836          break;
4837    
4838          case PT_PXPUNCT:
4839          SET_TYPE_OFFSET(ucp_Sc);
4840          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Sc);
4841          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);
4842    
4843          SET_CHAR_OFFSET(0);
4844          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xff);
4845          OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
4846    
4847          SET_TYPE_OFFSET(ucp_Pc);
4848          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ps - ucp_Pc);
4849          OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
4850          jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4851          break;
4852        }        }
4853      cc += 2;      cc += 2;
4854      }      }
# Line 4350  struct sljit_label *label; Line 4880  struct sljit_label *label;
4880  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
4881  pcre_uchar propdata[5];  pcre_uchar propdata[5];
4882  #endif  #endif
4883  #endif  #endif /* SUPPORT_UTF */
4884    
4885  switch(type)  switch(type)
4886    {    {
# Line 4375  switch(type) Line 4905  switch(type)
4905    case OP_NOT_DIGIT:    case OP_NOT_DIGIT:
4906    case OP_DIGIT:    case OP_DIGIT:
4907    /* Digits are usually 0-9, so it is worth to optimize them. */    /* Digits are usually 0-9, so it is worth to optimize them. */
   if (common->digits[0] == -2)  
     get_ctype_ranges(common, ctype_digit, common->digits);  
4908    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
4909    /* Flip the starting bit in the negative case. */  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
4910    if (type == OP_NOT_DIGIT)    if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_digit, FALSE))
4911      common->digits[1] ^= 1;      read_char7_type(common, type == OP_NOT_DIGIT);
4912    if (!check_ranges(common, common->digits, backtracks, TRUE))    else
4913      {  #endif
4914      read_char8_type(common);      read_char8_type(common, type == OP_NOT_DIGIT);
4915      OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);      /* Flip the starting bit in the negative case. */
4916      add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
4917      }    add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
   if (type == OP_NOT_DIGIT)  
     common->digits[1] ^= 1;  
4918    return cc;    return cc;
4919    
4920    case OP_NOT_WHITESPACE:    case OP_NOT_WHITESPACE:
4921    case OP_WHITESPACE:    case OP_WHITESPACE:
4922    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
4923    read_char8_type(common);  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
4924      if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_space, FALSE))
4925        read_char7_type(common, type == OP_NOT_WHITESPACE);
4926      else
4927    #endif
4928        read_char8_type(common, type == OP_NOT_WHITESPACE);
4929    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);
4930    add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));    add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
4931    return cc;    return cc;
# Line 4402  switch(type) Line 4933  switch(type)
4933    case OP_NOT_WORDCHAR:    case OP_NOT_WORDCHAR:
4934    case OP_WORDCHAR:    case OP_WORDCHAR:
4935    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
4936    read_char8_type(common);  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
4937      if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_word, FALSE))
4938        read_char7_type(common, type == OP_NOT_WORDCHAR);
4939      else
4940    #endif
4941        read_char8_type(common, type == OP_NOT_WORDCHAR);
4942    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);
4943    add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));    add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
4944    return cc;    return cc;
4945    
4946    case OP_ANY:    case OP_ANY:
4947    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
4948    read_char(common);    read_char_max(common, common->nlmax, TRUE);
4949    if (common->nltype == NLTYPE_FIXED && common->newline > 255)    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
4950      {      {
4951      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);
# Line 4465  switch(type) Line 5001  switch(type)
5001  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
5002    case OP_NOTPROP:    case OP_NOTPROP:
5003    case OP_PROP:    case OP_PROP:
5004    propdata[0] = 0;    propdata[0] = XCL_HASPROP;
5005    propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;    propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;
5006    propdata[2] = cc[0];    propdata[2] = cc[0];
5007    propdata[3] = cc[1];    propdata[3] = cc[1];
# Line 4477  switch(type) Line 5013  switch(type)
5013    
5014    case OP_ANYNL:    case OP_ANYNL:
5015    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
5016    read_char(common);    read_char_max(common, common->bsr_nlmax, FALSE);
5017    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);
5018    /* We don't need to handle soft partial matching case. */    /* We don't need to handle soft partial matching case. */
5019    end_list = NULL;    end_list = NULL;
# Line 4499  switch(type) Line 5035  switch(type)
5035    case OP_NOT_HSPACE:    case OP_NOT_HSPACE:
5036    case OP_HSPACE:    case OP_HSPACE:
5037    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
5038    read_char(common);    read_char_max(common, 0x3000, type == OP_NOT_HSPACE);
5039    add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));
5040    add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));    add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
5041    return cc;    return cc;
# Line 4507  switch(type) Line 5043  switch(type)
5043    case OP_NOT_VSPACE:    case OP_NOT_VSPACE:
5044    case OP_VSPACE:    case OP_VSPACE:
5045    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
5046    read_char(common);    read_char_max(common, 0x2029, type == OP_NOT_VSPACE);
5047    add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));
5048    add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));    add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
5049    return cc;    return cc;
# Line 4606  switch(type) Line 5142  switch(type)
5142      else      else
5143        {        {
5144        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, STR_PTR, 0);
5145        read_char(common);        read_char_max(common, common->nlmax, TRUE);
5146        add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));        add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
5147        add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));        add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
5148        add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));        add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
# Line 4654  switch(type) Line 5190  switch(type)
5190    else    else
5191      {      {
5192      skip_char_back(common);      skip_char_back(common);
5193      read_char(common);      read_char_max(common, common->nlmax, TRUE);
5194      check_newlinechar(common, common->nltype, backtracks, FALSE);      check_newlinechar(common, common->nltype, backtracks, FALSE);
5195      }      }
5196    JUMPHERE(jump[0]);    JUMPHERE(jump[0]);
# Line 4729  switch(type) Line 5265  switch(type)
5265  #endif  #endif
5266      return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);      return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);
5267      }      }
5268    
5269    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
   read_char(common);  
5270  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
5271    if (common->utf)    if (common->utf)
5272      {      {
# Line 4739  switch(type) Line 5275  switch(type)
5275    else    else
5276  #endif  #endif
5277      c = *cc;      c = *cc;
5278    
5279    if (type == OP_CHAR || !char_has_othercase(common, cc))    if (type == OP_CHAR || !char_has_othercase(common, cc))
5280      {      {
5281        read_char_max(common, c, FALSE);
5282      add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));      add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
5283      return cc + length;      return cc + length;
5284      }      }
5285    oc = char_othercase(common, c);    oc = char_othercase(common, c);
5286      read_char_max(common, c > oc ? c : oc, FALSE);
5287    bit = c ^ oc;    bit = c ^ oc;
5288    if (is_powerof2(bit))    if (is_powerof2(bit))
5289      {      {
# Line 4752  switch(type) Line 5291  switch(type)
5291      add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));      add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
5292      return cc + length;      return cc + length;
5293      }      }
5294    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);    jump[0] = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c);
5295    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);    add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, oc));
5296    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);    JUMPHERE(jump[0]);
   OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);  
   add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));  
5297    return cc + length;    return cc + length;
5298    
5299    case OP_NOT:    case OP_NOT:
# Line 4791  switch(type) Line 5328  switch(type)
5328  #endif /* COMPILE_PCRE8 */  #endif /* COMPILE_PCRE8 */
5329        {        {
5330        GETCHARLEN(c, cc, length);        GETCHARLEN(c, cc, length);
       read_char(common);  
5331        }        }
5332      }      }
5333    else    else
5334  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
     {  
     read_char(common);  
5335      c = *cc;      c = *cc;
     }  
5336    
5337    if (type == OP_NOT || !char_has_othercase(common, cc))    if (type == OP_NOT || !char_has_othercase(common, cc))
5338        {
5339        read_char_max(common, c, TRUE);
5340      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
5341        }
5342    else    else
5343      {      {
5344      oc = char_othercase(common, c);      oc = char_othercase(common, c);
5345        read_char_max(common, c > oc ? c : oc, TRUE);
5346      bit = c ^ oc;      bit = c ^ oc;
5347      if (is_powerof2(bit))      if (is_powerof2(bit))
5348        {        {
# Line 4823  switch(type) Line 5360  switch(type)
5360    case OP_CLASS:    case OP_CLASS:
5361    case OP_NCLASS:    case OP_NCLASS:
5362    detect_partial_match(common, backtracks);    detect_partial_match(common, backtracks);
5363    read_char(common);  
5364    if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, backtracks))  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
5365      bit = (common->utf && is_char7_bitset((const pcre_uint8 *)cc, type == OP_NCLASS)) ? 127 : 255;
5366      read_char_max(common, bit, type == OP_NCLASS);
5367    #else
5368      read_char_max(common, 255, type == OP_NCLASS);
5369    #endif
5370    
5371      if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, FALSE, backtracks))
5372      return cc + 32 / sizeof(pcre_uchar);      return cc + 32 / sizeof(pcre_uchar);
5373    
5374  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
5375    jump[0] = NULL;    jump[0] = NULL;
 #ifdef COMPILE_PCRE8  
   /* This check only affects 8 bit mode. In other modes, we  
   always need to compare the value with 255. */  
5376    if (common->utf)    if (common->utf)
 #endif /* COMPILE_PCRE8 */  
5377      {      {
5378      jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);      jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, bit);
5379      if (type == OP_CLASS)      if (type == OP_CLASS)
5380        {        {
5381        add_jump(compiler, backtracks, jump[0]);        add_jump(compiler, backtracks, jump[0]);
5382        jump[0] = NULL;        jump[0] = NULL;
5383        }        }
5384      }      }
5385  #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */  #elif !defined COMPILE_PCRE8
5386      jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
5387      if (type == OP_CLASS)
5388        {
5389        add_jump(compiler, backtracks, jump[0]);
5390        jump[0] = NULL;
5391        }
5392    #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
5393    
5394    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
5395    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
5396    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
5397    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
5398    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
5399    add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));    add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
5400    
5401  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
5402    if (jump[0] != NULL)    if (jump[0] != NULL)
5403      JUMPHERE(jump[0]);      JUMPHERE(jump[0]);
5404  #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */  #endif
5405    
5406    return cc + 32 / sizeof(pcre_uchar);    return cc + 32 / sizeof(pcre_uchar);
5407    
5408  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
# Line 4957  if (context.length > 0) Line 5507  if (context.length > 0)
5507  return compile_char1_matchingpath(common, *cc, cc + 1, backtracks);  return compile_char1_matchingpath(common, *cc, cc + 1, backtracks);
5508  }  }
5509    
 static struct sljit_jump *compile_ref_checks(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)  
 {  
 DEFINE_COMPILER;  
 int offset = GET2(cc, 1) << 1;  
   
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));  
 if (!common->jscript_compat)  
   {  
   if (backtracks == NULL)  
     {  
     /* OVECTOR(1) contains the "string begin - 1" constant. */  
     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));  
     OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);  
     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));  
     OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);  
     return JUMP(SLJIT_C_NOT_ZERO);  
     }  
   add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));  
   }  
 return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));  
 }  
   
5510  /* Forward definitions. */  /* Forward definitions. */
5511  static void compile_matchingpath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);  static void compile_matchingpath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);
5512  static void compile_backtrackingpath(compiler_common *, struct backtrack_common *);  static void compile_backtrackingpath(compiler_common *, struct backtrack_common *);
# Line 5011  static void compile_backtrackingpath(com Line 5539  static void compile_backtrackingpath(com
5539    
5540  #define BACKTRACK_AS(type) ((type *)backtrack)  #define BACKTRACK_AS(type) ((type *)backtrack)
5541    
5542  static pcre_uchar *compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)  static void compile_dnref_search(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
5543    {
5544    /* The OVECTOR offset goes to TMP2. */
5545    DEFINE_COMPILER;
5546    int count = GET2(cc, 1 + IMM2_SIZE);
5547    pcre_uchar *slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
5548    unsigned int offset;
5549    jump_list *found = NULL;
5550    
5551    SLJIT_ASSERT(*cc == OP_DNREF || *cc == OP_DNREFI);
5552    
5553    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
5554    
5555    count--;
5556    while (count-- > 0)
5557      {
5558      offset = GET2(slot, 0) << 1;
5559      GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));
5560      add_jump(compiler, &found, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0));
5561      slot += common->name_entry_size;
5562      }
5563    
5564    offset = GET2(slot, 0) << 1;
5565    GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));
5566    if (backtracks != NULL && !common->jscript_compat)
5567      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0));
5568    
5569    set_jumps(found, LABEL());
5570    }
5571    
5572    static void compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
5573  {  {
5574  DEFINE_COMPILER;  DEFINE_COMPILER;
5575  int offset = GET2(cc, 1) << 1;  BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
5576    int offset = 0;
5577  struct sljit_jump *jump = NULL;  struct sljit_jump *jump = NULL;
5578  struct sljit_jump *partial;  struct sljit_jump *partial;
5579  struct sljit_jump *nopartial;  struct sljit_jump *nopartial;
5580    
5581  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));  if (ref)
5582  /* OVECTOR(1) contains the "string begin - 1" constant. */    {
5583  if (withchecks && !common->jscript_compat)    offset = GET2(cc, 1) << 1;
5584    add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
5585      /* OVECTOR(1) contains the "string begin - 1" constant. */
5586      if (withchecks && !common->jscript_compat)
5587        add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
5588      }
5589    else
5590      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
5591    
5592  #if defined SUPPORT_UTF && defined SUPPORT_UCP  #if defined SUPPORT_UTF && defined SUPPORT_UCP
5593  if (common->utf && *cc == OP_REFI)  if (common->utf && *cc == OP_REFI)
5594    {    {
5595    SLJIT_ASSERT(TMP1 == SLJIT_SCRATCH_REG1 && STACK_TOP == SLJIT_SCRATCH_REG2 && TMP2 == SLJIT_SCRATCH_REG3);    SLJIT_ASSERT(TMP1 == SLJIT_SCRATCH_REG1 && STACK_TOP == SLJIT_SCRATCH_REG2 && TMP2 == SLJIT_SCRATCH_REG3);
5596    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));    if (ref)
5597        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
5598      else
5599        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
5600    
5601    if (withchecks)    if (withchecks)
5602      jump = CMP(SLJIT_C_EQUAL, TMP1, 0, TMP2, 0);      jump = CMP(SLJIT_C_EQUAL, TMP1, 0, TMP2, 0);
5603    
# Line 5053  if (common->utf && *cc == OP_REFI) Line 5622  if (common->utf && *cc == OP_REFI)
5622  else  else
5623  #endif /* SUPPORT_UTF && SUPPORT_UCP */  #endif /* SUPPORT_UTF && SUPPORT_UCP */
5624    {    {
5625    OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);    if (ref)
5626        OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
5627      else
5628        OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
5629    
5630    if (withchecks)    if (withchecks)
5631      jump = JUMP(SLJIT_C_ZERO);      jump = JUMP(SLJIT_C_ZERO);
5632    
# Line 5090  if (jump != NULL) Line 5663  if (jump != NULL)
5663    else    else
5664      JUMPHERE(jump);      JUMPHERE(jump);
5665    }    }
 return cc + 1 + IMM2_SIZE;  
5666  }  }
5667    
5668  static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)  static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
5669  {  {
5670  DEFINE_COMPILER;  DEFINE_COMPILER;
5671    BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
5672  backtrack_common *backtrack;  backtrack_common *backtrack;
5673  pcre_uchar type;  pcre_uchar type;
5674    int offset = 0;
5675  struct sljit_label *label;  struct sljit_label *label;
5676  struct sljit_jump *zerolength;  struct sljit_jump *zerolength;
5677  struct sljit_jump *jump = NULL;  struct sljit_jump *jump = NULL;
# Line 5107  BOOL minimize; Line 5681  BOOL minimize;
5681    
5682  PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);  PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
5683    
5684    if (ref)
5685      offset = GET2(cc, 1) << 1;
5686    else
5687      cc += IMM2_SIZE;
5688  type = cc[1 + IMM2_SIZE];  type = cc[1 + IMM2_SIZE];
5689    
5690    SLJIT_COMPILE_ASSERT((OP_CRSTAR & 0x1) == 0, crstar_opcode_must_be_even);
5691  minimize = (type & 0x1) != 0;  minimize = (type & 0x1) != 0;
5692  switch(type)  switch(type)
5693    {    {
# Line 5145  if (!minimize) Line 5725  if (!minimize)
5725    if (min == 0)    if (min == 0)
5726      {      {
5727      allocate_stack(common, 2);      allocate_stack(common, 2);
5728        if (ref)
5729          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
5730      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5731      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
5732      /* Temporary release of STR_PTR. */      /* Temporary release of STR_PTR. */
5733      OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));      OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
5734      zerolength = compile_ref_checks(common, ccbegin, NULL);      /* Handles both invalid and empty cases. Since the minimum repeat,
5735        is zero the invalid case is basically the same as an empty case. */
5736        if (ref)
5737          zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
5738        else
5739          {
5740          compile_dnref_search(common, ccbegin, NULL);
5741          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
5742          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, TMP2, 0);
5743          zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
5744          }
5745      /* Restore if not zero length. */      /* Restore if not zero length. */
5746      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));
5747      }      }
5748    else    else
5749      {      {
5750      allocate_stack(common, 1);      allocate_stack(common, 1);
5751        if (ref)
5752          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
5753      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5754      zerolength = compile_ref_checks(common, ccbegin, &backtrack->topbacktracks);      if (ref)
5755          {
5756          add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
5757          zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
5758          }
5759        else
5760          {
5761          compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);
5762          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
5763          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, TMP2, 0);
5764          zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
5765          }
5766      }      }
5767    
5768    if (min > 1 || max > 1)    if (min > 1 || max > 1)
5769      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);
5770    
5771    label = LABEL();    label = LABEL();
5772      if (!ref)
5773        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
5774    compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);    compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);
5775    
5776    if (min > 1 || max > 1)    if (min > 1 || max > 1)
# Line 5194  if (!minimize) Line 5801  if (!minimize)
5801    JUMPHERE(zerolength);    JUMPHERE(zerolength);
5802    BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();    BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
5803    
5804    decrease_call_count(common);    count_match(common);
5805    return cc;    return cc;
5806    }    }
5807    
5808  allocate_stack(common, 2);  allocate_stack(common, ref ? 2 : 3);
5809    if (ref)
5810      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
5811  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5812  if (type != OP_CRMINSTAR)  if (type != OP_CRMINSTAR)
5813    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
5814    
5815  if (min == 0)  if (min == 0)
5816    {    {
5817    zerolength = compile_ref_checks(common, ccbegin, NULL);    /* Handles both invalid and empty cases. Since the minimum repeat,
5818      is zero the invalid case is basically the same as an empty case. */
5819      if (ref)
5820        zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
5821      else
5822        {
5823        compile_dnref_search(common, ccbegin, NULL);
5824        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
5825        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);
5826        zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
5827        }
5828      /* Length is non-zero, we can match real repeats. */
5829    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5830    jump = JUMP(SLJIT_JUMP);    jump = JUMP(SLJIT_JUMP);
5831    }    }
5832  else  else
5833    zerolength = compile_ref_checks(common, ccbegin, &backtrack->topbacktracks);    {
5834      if (ref)
5835        {
5836        add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
5837        zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
5838        }
5839      else
5840        {
5841        compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);
5842        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
5843        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);
5844        zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
5845        }
5846      }
5847    
5848  BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();  BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
5849  if (max > 0)  if (max > 0)
5850    add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));    add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
5851    
5852    if (!ref)
5853      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
5854  compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);  compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);
5855  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5856    
# Line 5233  if (jump != NULL) Line 5868  if (jump != NULL)
5868    JUMPHERE(jump);    JUMPHERE(jump);
5869  JUMPHERE(zerolength);  JUMPHERE(zerolength);
5870    
5871  decrease_call_count(common);  count_match(common);
5872  return cc;  return cc;
5873  }  }
5874    
# Line 5243  DEFINE_COMPILER; Line 5878  DEFINE_COMPILER;
5878  backtrack_common *backtrack;  backtrack_common *backtrack;
5879  recurse_entry *entry = common->entries;  recurse_entry *entry = common->entries;
5880  recurse_entry *prev = NULL;  recurse_entry *prev = NULL;
5881  int start = GET(cc, 1);  sljit_sw start = GET(cc, 1);
5882  pcre_uchar *start_cc;  pcre_uchar *start_cc;
5883    BOOL needs_control_head;
5884    
5885  PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);  PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
5886    
5887  /* Inlining simple patterns. */  /* Inlining simple patterns. */
5888  if (get_framesize(common, common->start + start, TRUE) == no_stack)  if (get_framesize(common, common->start + start, NULL, TRUE, &needs_control_head) == no_stack)
5889    {    {
5890    start_cc = common->start + start;    start_cc = common->start + start;
5891    compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);    compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);
# Line 5409  static pcre_uchar *compile_assert_matchi Line 6045  static pcre_uchar *compile_assert_matchi
6045  DEFINE_COMPILER;  DEFINE_COMPILER;
6046  int framesize;  int framesize;
6047  int extrasize;  int extrasize;
6048  BOOL needs_control_head = common->control_head_ptr != 0;  BOOL needs_control_head;
6049  int private_data_ptr;  int private_data_ptr;
6050  backtrack_common altbacktrack;  backtrack_common altbacktrack;
6051  pcre_uchar *ccbegin;  pcre_uchar *ccbegin;
# Line 5419  jump_list *tmp = NULL; Line 6055  jump_list *tmp = NULL;
6055  jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;  jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
6056  jump_list **found;  jump_list **found;
6057  /* Saving previous accept variables. */  /* Saving previous accept variables. */
6058    BOOL save_local_exit = common->local_exit;
6059    BOOL save_positive_assert = common->positive_assert;
6060    then_trap_backtrack *save_then_trap = common->then_trap;
6061  struct sljit_label *save_quit_label = common->quit_label;  struct sljit_label *save_quit_label = common->quit_label;
6062  struct sljit_label *save_accept_label = common->accept_label;  struct sljit_label *save_accept_label = common->accept_label;
6063  jump_list *save_quit = common->quit;  jump_list *save_quit = common->quit;
6064    jump_list *save_positive_assert_quit = common->positive_assert_quit;
6065  jump_list *save_accept = common->accept;  jump_list *save_accept = common->accept;
 BOOL save_local_exit = common->local_exit;  
6066  struct sljit_jump *jump;  struct sljit_jump *jump;
6067  struct sljit_jump *brajump = NULL;  struct sljit_jump *brajump = NULL;
6068    
6069    /* Assert captures then. */
6070    common->then_trap = NULL;
6071    
6072  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
6073    {    {
6074    SLJIT_ASSERT(!conditional);    SLJIT_ASSERT(!conditional);
# Line 5435  if (*cc == OP_BRAZERO || *cc == OP_BRAMI Line 6077  if (*cc == OP_BRAZERO || *cc == OP_BRAMI
6077    }    }
6078  private_data_ptr = PRIVATE_DATA(cc);  private_data_ptr = PRIVATE_DATA(cc);
6079  SLJIT_ASSERT(private_data_ptr != 0);  SLJIT_ASSERT(private_data_ptr != 0);
6080  framesize = get_framesize(common, cc, FALSE);  framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
6081  backtrack->framesize = framesize;  backtrack->framesize = framesize;
6082  backtrack->private_data_ptr = private_data_ptr;  backtrack->private_data_ptr = private_data_ptr;
6083  opcode = *cc;  opcode = *cc;
# Line 5485  else Line 6127  else
6127      }      }
6128    else    else
6129      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
6130    init_frame(common, ccbegin, framesize + extrasize - 1, extrasize, FALSE);    init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);
6131    }    }
6132    
6133  memset(&altbacktrack, 0, sizeof(backtrack_common));  memset(&altbacktrack, 0, sizeof(backtrack_common));
6134  common->local_exit = TRUE;  if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
6135  common->quit_label = NULL;    {
6136  common->quit = NULL;    /* Negative assert is stronger than positive assert. */
6137      common->local_exit = TRUE;
6138      common->quit_label = NULL;
6139      common->quit = NULL;
6140      common->positive_assert = FALSE;
6141      }
6142    else
6143      common->positive_assert = TRUE;
6144    common->positive_assert_quit = NULL;
6145    
6146  while (1)  while (1)
6147    {    {
6148    common->accept_label = NULL;    common->accept_label = NULL;
# Line 5506  while (1) Line 6157  while (1)
6157    compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);    compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
6158    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
6159      {      {
6160      common->local_exit = save_local_exit;      if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
6161      common->quit_label = save_quit_label;        {
6162          common->local_exit = save_local_exit;
6163          common->quit_label = save_quit_label;
6164          common->quit = save_quit;
6165          }
6166        common->positive_assert = save_positive_assert;
6167        common->then_trap = save_then_trap;
6168      common->accept_label = save_accept_label;      common->accept_label = save_accept_label;
6169      common->quit = save_quit;      common->positive_assert_quit = save_positive_assert_quit;
6170      common->accept = save_accept;      common->accept = save_accept;
6171      return NULL;      return NULL;
6172      }      }
# Line 5574  while (1) Line 6231  while (1)
6231    compile_backtrackingpath(common, altbacktrack.top);    compile_backtrackingpath(common, altbacktrack.top);
6232    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
6233      {      {
6234      common->local_exit = save_local_exit;      if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
6235      common->quit_label = save_quit_label;        {
6236          common->local_exit = save_local_exit;
6237          common->quit_label = save_quit_label;
6238          common->quit = save_quit;
6239          }
6240        common->positive_assert = save_positive_assert;
6241        common->then_trap = save_then_trap;
6242      common->accept_label = save_accept_label;      common->accept_label = save_accept_label;
6243      common->quit = save_quit;      common->positive_assert_quit = save_positive_assert_quit;
6244      common->accept = save_accept;      common->accept = save_accept;
6245      return NULL;      return NULL;
6246      }      }
# Line 5590  while (1) Line 6253  while (1)
6253    cc += GET(cc, 1);    cc += GET(cc, 1);
6254    }    }
6255    
6256    if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
6257      {
6258      SLJIT_ASSERT(common->positive_assert_quit == NULL);
6259      /* Makes the check less complicated below. */
6260      common->positive_assert_quit = common->quit;
6261      }
6262    
6263  /* None of them matched. */  /* None of them matched. */
6264  if (common->quit != NULL)  if (common->positive_assert_quit != NULL)
6265    {    {
6266    jump = JUMP(SLJIT_JUMP);    jump = JUMP(SLJIT_JUMP);
6267    set_jumps(common->quit, LABEL());    set_jumps(common->positive_assert_quit, LABEL());
6268    SLJIT_ASSERT(framesize != no_stack);    SLJIT_ASSERT(framesize != no_stack);
6269    if (framesize < 0)    if (framesize < 0)
6270      OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, extrasize * sizeof(sljit_sw));      OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, extrasize * sizeof(sljit_sw));
# Line 5754  else Line 6424  else
6424      }      }
6425    }    }
6426    
6427  common->local_exit = save_local_exit;  if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
6428  common->quit_label = save_quit_label;    {
6429      common->local_exit = save_local_exit;
6430      common->quit_label = save_quit_label;
6431      common->quit = save_quit;
6432      }
6433    common->positive_assert = save_positive_assert;
6434    common->then_trap = save_then_trap;
6435  common->accept_label = save_accept_label;  common->accept_label = save_accept_label;
6436  common->quit = save_quit;  common->positive_assert_quit = save_positive_assert_quit;
6437  common->accept = save_accept;  common->accept = save_accept;
6438  return cc + 1 + LINK_SIZE;  return cc + 1 + LINK_SIZE;
6439  }  }
6440    
6441  static sljit_sw SLJIT_CALL do_searchovector(sljit_uw refno, sljit_sw* locals, pcre_uchar *name_table)  static SLJIT_INLINE void match_once_common(compiler_common *common, pcre_uchar ket, int framesize, int private_data_ptr, BOOL has_alternatives, BOOL needs_control_head)
6442  {  {
6443  int condition = FALSE;  DEFINE_COMPILER;
6444  pcre_uchar *slotA = name_table;  int stacksize;
 pcre_uchar *slotB;  
 sljit_sw name_count = locals[LOCALS0 / sizeof(sljit_sw)];  
 sljit_sw name_entry_size = locals[LOCALS1 / sizeof(sljit_sw)];  
 sljit_sw no_capture;  
 int i;  
   
 locals += refno & 0xff;  
 refno >>= 8;  
 no_capture = locals[1];  
6445    
6446  for (i = 0; i < name_count; i++)  if (framesize < 0)
6447    {    {
6448    if (GET2(slotA, 0) == refno) break;    if (framesize == no_frame)
6449    slotA += name_entry_size;      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6450    }    else
6451        {
6452        stacksize = needs_control_head ? 1 : 0;
6453        if (ket != OP_KET || has_alternatives)
6454          stacksize++;
6455        free_stack(common, stacksize);
6456        }
6457    
6458  if (i < name_count)    if (needs_control_head)
6459    {      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (ket != OP_KET || has_alternatives) ? sizeof(sljit_sw) : 0);
   /* Found a name for the number - there can be only one; duplicate names  
   for different numbers are allowed, but not vice versa. First scan down  
   for duplicates. */  
6460    
6461    slotB = slotA;    /* TMP2 which is set here used by OP_KETRMAX below. */
6462    while (slotB > name_table)    if (ket == OP_KETRMAX)
6463        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
6464      else if (ket == OP_KETRMIN)
6465      {      {
6466      slotB -= name_entry_size;      /* Move the STR_PTR to the private_data_ptr. */
6467      if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), 0);
       {  
       condition = locals[GET2(slotB, 0) << 1] != no_capture;  
       if (condition) break;  
       }  
     else break;  
6468      }      }
6469      }
6470    else
6471      {
6472      stacksize = (ket != OP_KET || has_alternatives) ? 2 : 1;
6473      OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + stacksize) * sizeof(sljit_sw));
6474      if (needs_control_head)
6475        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 0);
6476    
6477    /* Scan up for duplicates */    if (ket == OP_KETRMAX)
   if (!condition)  
6478      {      {
6479      slotB = slotA;      /* TMP2 which is set here used by OP_KETRMAX below. */
6480      for (i++; i < name_count; i++)      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
       {  
       slotB += name_entry_size;  
       if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)  
         {  
         condition = locals[GET2(slotB, 0) << 1] != no_capture;  
         if (condition) break;  
         }  
       else break;  
       }  
6481      }      }
6482    }    }
6483  return condition;  if (needs_control_head)
6484      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP1, 0);
6485  }  }
6486    
6487  static sljit_sw SLJIT_CALL do_searchgroups(sljit_uw recno, sljit_uw* locals, pcre_uchar *name_table)  static SLJIT_INLINE int match_capture_common(compiler_common *common, int stacksize, int offset, int private_data_ptr)
6488  {  {
6489  int condition = FALSE;  DEFINE_COMPILER;
 pcre_uchar *slotA = name_table;  
 pcre_uchar *slotB;  
 sljit_uw name_count = locals[LOCALS0 / sizeof(sljit_sw)];  
 sljit_uw name_entry_size = locals[LOCALS1 / sizeof(sljit_sw)];  
 sljit_uw group_num = locals[POSSESSIVE0 / sizeof(sljit_sw)];  
 sljit_uw i;  
6490    
6491  for (i = 0; i < name_count; i++)  if (common->capture_last_ptr != 0)
6492    {    {
6493    if (GET2(slotA, 0) == recno) break;    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
6494    slotA += name_entry_size;    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
6495      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
6496      stacksize++;
6497    }    }
6498    if (common->optimized_cbracket[offset >> 1] == 0)
 if (i < name_count)  
6499    {    {
6500    /* Found a name for the number - there can be only one; duplicate    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
6501    names for different numbers are allowed, but not vice versa. First    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
6502    scan down for duplicates. */    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
6503      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6504    slotB = slotA;    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
6505    while (slotB > name_table)    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
6506      {    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
6507      slotB -= name_entry_size;    stacksize += 2;
     if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)  
       {  
       condition = GET2(slotB, 0) == group_num;  
       if (condition) break;  
       }  
     else break;  
     }  
   
   /* Scan up for duplicates */  
   if (!condition)  
     {  
     slotB = slotA;  
     for (i++; i < name_count; i++)  
       {  
       slotB += name_entry_size;  
       if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)  
         {  
         condition = GET2(slotB, 0) == group_num;  
         if (condition) break;  
         }  
       else break;  
       }  
     }  
6508    }    }
6509  return condition;  return stacksize;
6510  }  }
6511    
6512  /*  /*
# Line 5933  backtrack_common *backtrack; Line 6570  backtrack_common *backtrack;
6570  pcre_uchar opcode;  pcre_uchar opcode;
6571  int private_data_ptr = 0;  int private_data_ptr = 0;
6572  int offset = 0;  int offset = 0;
6573  int stacksize;  int i, stacksize;
6574    int repeat_ptr = 0, repeat_length = 0;
6575    int repeat_type = 0, repeat_count = 0;
6576  pcre_uchar *ccbegin;  pcre_uchar *ccbegin;
6577  pcre_uchar *matchingpath;  pcre_uchar *matchingpath;
6578    pcre_uchar *slot;
6579  pcre_uchar bra = OP_BRA;  pcre_uchar bra = OP_BRA;
6580  pcre_uchar ket;  pcre_uchar ket;
6581  assert_backtrack *assert;  assert_backtrack *assert;
6582  BOOL has_alternatives;  BOOL has_alternatives;
6583    BOOL needs_control_head = FALSE;
6584  struct sljit_jump *jump;  struct sljit_jump *jump;
6585  struct sljit_jump *skip;  struct sljit_jump *skip;
6586  struct sljit_label *rmaxlabel = NULL;  struct sljit_label *rmax_label = NULL;
6587  struct sljit_jump *braminzerojump = NULL;  struct sljit_jump *braminzero = NULL;
6588    
6589  PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);  PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
6590    
# Line 5956  if (*cc == OP_BRAZERO || *cc == OP_BRAMI Line 6597  if (*cc == OP_BRAZERO || *cc == OP_BRAMI
6597    
6598  opcode = *cc;  opcode = *cc;
6599  ccbegin = cc;  ccbegin = cc;
6600  matchingpath = ccbegin + 1 + LINK_SIZE;  matchingpath = bracketend(cc) - 1 - LINK_SIZE;
6601    ket = *matchingpath;
6602    if (ket == OP_KET && PRIVATE_DATA(matchingpath) != 0)
6603      {
6604      repeat_ptr = PRIVATE_DATA(matchingpath);
6605      repeat_length = PRIVATE_DATA(matchingpath + 1);
6606      repeat_type = PRIVATE_DATA(matchingpath + 2);
6607      repeat_count = PRIVATE_DATA(matchingpath + 3);
6608      SLJIT_ASSERT(repeat_length != 0 && repeat_type != 0 && repeat_count != 0);
6609      if (repeat_type == OP_UPTO)
6610        ket = OP_KETRMAX;
6611      if (repeat_type == OP_MINUPTO)
6612        ket = OP_KETRMIN;
6613      }
6614    
6615  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)
6616    {    {
6617    /* Drop this bracket_backtrack. */    /* Drop this bracket_backtrack. */
6618    parent->top = backtrack->prev;    parent->top = backtrack->prev;
6619    return bracketend(cc);    return matchingpath + 1 + LINK_SIZE + repeat_length;
6620    }    }
6621    
6622  ket = *(bracketend(cc) - 1 - LINK_SIZE);  matchingpath = ccbegin + 1 + LINK_SIZE;
6623  SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);  SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);
6624  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)));
6625  cc += GET(cc, 1);  cc += GET(cc, 1);
6626    
6627  has_alternatives = *cc == OP_ALT;  has_alternatives = *cc == OP_ALT;
6628  if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))  if (SLJIT_UNLIKELY(opcode == OP_COND || opcode == OP_SCOND))
6629    {    has_alternatives = (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF) ? FALSE : TRUE;
   has_alternatives = (*matchingpath == OP_RREF) ? FALSE : TRUE;  
   if (*matchingpath == OP_NRREF)  
     {  
     stacksize = GET2(matchingpath, 1);  
     if (common->currententry == NULL || stacksize == RREF_ANY)  
       has_alternatives = FALSE;  
     else if (common->currententry->start == 0)  
       has_alternatives = stacksize != 0;  
     else  
       has_alternatives = stacksize != (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);  
     }  
   }  
6630    
6631  if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))  if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
6632    opcode = OP_SCOND;    opcode = OP_SCOND;
# Line 6015  else if (opcode == OP_ONCE || opcode == Line 6657  else if (opcode == OP_ONCE || opcode ==
6657    SLJIT_ASSERT(private_data_ptr != 0);    SLJIT_ASSERT(private_data_ptr != 0);
6658    BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;    BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
6659    if (opcode == OP_ONCE)    if (opcode == OP_ONCE)
6660      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);
6661    }    }
6662    
6663  /* Instructions before the first alternative. */  /* Instructions before the first alternative. */
6664  stacksize = 0;  stacksize = 0;
6665  if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))  if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
6666    stacksize++;    stacksize++;
6667  if (bra == OP_BRAZERO)  if (bra == OP_BRAZERO)
6668    stacksize++;    stacksize++;
# Line 6029  if (stacksize > 0) Line 6671  if (stacksize > 0)
6671    allocate_stack(common, stacksize);    allocate_stack(common, stacksize);
6672    
6673  stacksize = 0;  stacksize = 0;
6674  if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))  if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
6675    {    {
6676    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
6677    stacksize++;    stacksize++;
# Line 6045  if (bra == OP_BRAMINZERO) Line 6687  if (bra == OP_BRAMINZERO)
6687    if (ket != OP_KETRMIN)    if (ket != OP_KETRMIN)
6688      {      {
6689      free_stack(common, 1);      free_stack(common, 1);
6690      braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);      braminzero = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
6691      }      }
6692    else    else
6693      {      {
# Line 6060  if (bra == OP_BRAMINZERO) Line 6702  if (bra == OP_BRAMINZERO)
6702        if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)        if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
6703          {          {
6704          /* 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. */
6705          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);
6706          }          }
6707        else        else
6708          {          {
6709          /* Except when the whole stack frame must be saved. */          /* Except when the whole stack frame must be saved. */
6710          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);
6711          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));
6712          }          }
6713        JUMPHERE(skip);        JUMPHERE(skip);
6714        }        }
# Line 6079  if (bra == OP_BRAMINZERO) Line 6721  if (bra == OP_BRAMINZERO)
6721      }      }
6722    }    }
6723    
6724    if (repeat_type != 0)
6725      {
6726      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, repeat_count);
6727      if (repeat_type == OP_EXACT)
6728        rmax_label = LABEL();
6729      }
6730    
6731  if (ket == OP_KETRMIN)  if (ket == OP_KETRMIN)
6732    BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();    BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
6733    
6734  if (ket == OP_KETRMAX)  if (ket == OP_KETRMAX)
6735    {    {
6736    rmaxlabel = LABEL();    rmax_label = LABEL();
6737    if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA)    if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA && repeat_type == 0)
6738      BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmaxlabel;      BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmax_label;
6739    }    }
6740    
6741  /* Handling capturing brackets and alternatives. */  /* Handling capturing brackets and alternatives. */
6742  if (opcode == OP_ONCE)  if (opcode == OP_ONCE)
6743    {    {
6744      stacksize = 0;
6745      if (needs_control_head)
6746        {
6747        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);
6748        stacksize++;
6749        }
6750    
6751    if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)    if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
6752      {      {
6753      /* Neither capturing brackets nor recursions are found in the block. */      /* Neither capturing brackets nor recursions are found in the block. */
6754      if (ket == OP_KETRMIN)      if (ket == OP_KETRMIN)
6755        {        {
6756        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);        stacksize += 2;
6757        allocate_stack(common, 2);        if (!needs_control_head)
6758        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));  
6759        }        }
6760      else if (ket == OP_KETRMAX || has_alternatives)      else
6761        {        {
6762        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);        if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
6763        allocate_stack(common, 1);          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
6764        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);        if (ket == OP_KETRMAX || has_alternatives)
6765            stacksize++;
6766        }        }
6767      else  
6768        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);      if (stacksize > 0)
6769          allocate_stack(common, stacksize);
6770    
6771        stacksize = 0;
6772        if (needs_control_head)
6773          {
6774          stacksize++;
6775          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
6776          }
6777    
6778        if (ket == OP_KETRMIN)
6779          {
6780          if (needs_control_head)
6781            OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6782          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
6783          if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
6784            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));
6785          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
6786          }
6787        else if (ket == OP_KETRMAX || has_alternatives)
6788          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
6789      }      }
6790    else    else
6791      {      {
6792      if (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives)      if (ket != OP_KET || has_alternatives)
6793          stacksize++;
6794    
6795        stacksize += BACKTRACK_AS(bracket_backtrack)->u.framesize + 1;
6796        allocate_stack(common, stacksize);
6797    
6798        if (needs_control_head)
6799          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
6800    
6801        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6802        OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));
6803    
6804        stacksize = needs_control_head ? 1 : 0;
6805        if (ket != OP_KET || has_alternatives)
6806        {        {
6807        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, (BACKTRACK_AS(bracket_backtrack)->u.framesize + 2) * sizeof(sljit_sw));  
       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);  
6808        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);
6809        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);        stacksize++;
6810        init_frame(common, ccbegin, BACKTRACK_AS(bracket_backtrack)->u.framesize + 1, 2, FALSE);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
6811        }        }
6812      else      else
6813        {        {
       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, (BACKTRACK_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw));  
6814        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);
6815        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);  
6816        }        }
6817        init_frame(common, ccbegin, NULL, BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize, stacksize + 1, FALSE);
6818      }      }
6819    }    }
6820  else if (opcode == OP_CBRA || opcode == OP_SCBRA)  else if (opcode == OP_CBRA || opcode == OP_SCBRA)
# Line 6181  if (opcode == OP_COND || opcode == OP_SC Line 6863  if (opcode == OP_COND || opcode == OP_SC
6863        CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));        CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
6864      matchingpath += 1 + IMM2_SIZE;      matchingpath += 1 + IMM2_SIZE;
6865      }      }
6866    else if (*matchingpath == OP_NCREF)    else if (*matchingpath == OP_DNCREF)
6867      {      {
6868      SLJIT_ASSERT(has_alternatives);      SLJIT_ASSERT(has_alternatives);
     stacksize = GET2(matchingpath, 1);  
     jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(stacksize << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));  
   
     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);  
     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);  
     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);  
     OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, (stacksize << 8) | (common->ovector_start / sizeof(sljit_sw)));  
     GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, 0);  
     OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, common->name_table);  
     sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchovector));  
     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);  
     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, 0));  
6869    
6870      JUMPHERE(jump);      i = GET2(matchingpath, 1 + IMM2_SIZE);
6871      matchingpath += 1 + IMM2_SIZE;      slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
6872        OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
6873        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
6874        OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
6875        slot += common->name_entry_size;
6876        i--;
6877        while (i-- > 0)
6878          {
6879          OP2(SLJIT_SUB, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
6880          OP2(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, STR_PTR, 0);
6881          slot += common->name_entry_size;
6882          }
6883        OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
6884        add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), JUMP(SLJIT_C_ZERO));
6885        matchingpath += 1 + 2 * IMM2_SIZE;
6886      }      }
6887    else if (*matchingpath == OP_RREF || *matchingpath == OP_NRREF)    else if (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF)
6888      {      {
6889      /* Never has other case. */      /* Never has other case. */
6890      BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;      BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;
6891        SLJIT_ASSERT(!has_alternatives);
6892    
6893      stacksize = GET2(matchingpath, 1);      if (*matchingpath == OP_RREF)
     if (common->currententry == NULL)  
       stacksize = 0;  
     else if (stacksize == RREF_ANY)  
       stacksize = 1;  
     else if (common->currententry->start == 0)  
       stacksize = stacksize == 0;  
     else  
       stacksize = stacksize == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);  
   
     if (*matchingpath == OP_RREF || stacksize || common->currententry == NULL)  
6894        {        {
6895        SLJIT_ASSERT(!has_alternatives);        stacksize = GET2(matchingpath, 1);
6896          if (common->currententry == NULL)
6897            stacksize = 0;
6898          else if (stacksize == RREF_ANY)
6899            stacksize = 1;
6900          else if (common->currententry->start == 0)
6901            stacksize = stacksize == 0;
6902          else
6903            stacksize = stacksize == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
6904    
6905        if (stacksize != 0)        if (stacksize != 0)
6906          matchingpath += 1 + IMM2_SIZE;          matchingpath += 1 + IMM2_SIZE;
6907          }
6908        else
6909          {
6910          if (common->currententry == NULL || common->currententry->start == 0)
6911            stacksize = 0;
6912        else        else
6913          {          {
6914            stacksize = GET2(matchingpath, 1 + IMM2_SIZE);
6915            slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
6916            i = (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
6917            while (stacksize > 0)
6918              {
6919              if ((int)GET2(slot, 0) == i)
6920                break;
6921              slot += common->name_entry_size;
6922              stacksize--;
6923              }
6924            }
6925    
6926          if (stacksize != 0)
6927            matchingpath += 1 + 2 * IMM2_SIZE;
6928          }
6929    
6930          /* The stacksize == 0 is a common "else" case. */
6931          if (stacksize == 0)
6932            {
6933          if (*cc == OP_ALT)          if (*cc == OP_ALT)
6934            {            {
6935            matchingpath = cc + 1 + LINK_SIZE;            matchingpath = cc + 1 + LINK_SIZE;
# Line 6230  if (opcode == OP_COND || opcode == OP_SC Line 6938  if (opcode == OP_COND || opcode == OP_SC
6938          else          else
6939            matchingpath = cc;            matchingpath = cc;
6940          }          }
       }  
     else  
       {  
       SLJIT_ASSERT(has_alternatives);  
   
       stacksize = GET2(matchingpath, 1);  
       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);  
       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);  
       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);  
       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, GET2(common->start, common->currententry->start + 1 + LINK_SIZE));  
       OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, stacksize);  
       GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, 0);  
       OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, common->name_table);  
       sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchgroups));  
       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);  
       add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG1, 0, SLJIT_IMM, 0));  
       matchingpath += 1 + IMM2_SIZE;  
       }  
6941      }      }
6942    else    else
6943      {      {
# Line 6268  if (SLJIT_UNLIKELY(sljit_get_compiler_er Line 6958  if (SLJIT_UNLIKELY(sljit_get_compiler_er
6958    return NULL;    return NULL;
6959    
6960  if (opcode == OP_ONCE)  if (opcode == OP_ONCE)
6961    {    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));  
       }  
     }  
   }  
6962    
6963  stacksize = 0;  stacksize = 0;
6964    if (repeat_type == OP_MINUPTO)
6965      {
6966      /* We need to preserve the counter. TMP2 will be used below. */
6967      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);
6968      stacksize++;
6969      }
6970  if (ket != OP_KET || bra != OP_BRA)  if (ket != OP_KET || bra != OP_BRA)
6971    stacksize++;    stacksize++;
6972  if (offset != 0)  if (offset != 0)
# Line 6310  if (stacksize > 0) Line 6983  if (stacksize > 0)
6983    allocate_stack(common, stacksize);    allocate_stack(common, stacksize);
6984    
6985  stacksize = 0;  stacksize = 0;
6986    if (repeat_type == OP_MINUPTO)
6987      {
6988      /* TMP2 was set above. */
6989      OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
6990      stacksize++;
6991      }
6992    
6993  if (ket != OP_KET || bra != OP_BRA)  if (ket != OP_KET || bra != OP_BRA)
6994    {    {
6995    if (ket != OP_KET)    if (ket != OP_KET)
# Line 6320  if (ket != OP_KET || bra != OP_BRA) Line 7000  if (ket != OP_KET || bra != OP_BRA)
7000    }    }
7001    
7002  if (offset != 0)  if (offset != 0)
7003    {    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;  
     }  
   }  
7004    
7005  if (has_alternatives)  if (has_alternatives)
7006    {    {
# Line 6358  if (offset != 0 && common->optimized_cbr Line 7019  if (offset != 0 && co