/[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 1275 by zherczeg, Sun Mar 10 05:32:10 2013 UTC revision 1541 by zherczeg, Wed Apr 1 13:43:02 2015 UTC
# Line 52  POSSIBILITY OF SUCH DAMAGE. Line 52  POSSIBILITY OF SUCH DAMAGE.
52  we just include it. This way we don't need to touch the build  we just include it. This way we don't need to touch the build
53  system files. */  system files. */
54    
55  #define SLJIT_MALLOC(size) (PUBL(malloc))(size)  #define SLJIT_MALLOC(size, allocator_data) (PUBL(malloc))(size)
56  #define SLJIT_FREE(ptr) (PUBL(free))(ptr)  #define SLJIT_FREE(ptr, allocator_data) (PUBL(free))(ptr)
57  #define SLJIT_CONFIG_AUTO 1  #define SLJIT_CONFIG_AUTO 1
58  #define SLJIT_CONFIG_STATIC 1  #define SLJIT_CONFIG_STATIC 1
59  #define SLJIT_VERBOSE 0  #define SLJIT_VERBOSE 0
# 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 179  typedef struct jit_arguments { Line 179  typedef struct jit_arguments {
179    
180  typedef struct executable_functions {  typedef struct executable_functions {
181    void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];    void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];
182      void *read_only_data_heads[JIT_NUMBER_OF_COMPILE_MODES];
183      sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
184    PUBL(jit_callback) callback;    PUBL(jit_callback) callback;
185    void *userdata;    void *userdata;
186    pcre_uint32 top_bracket;    pcre_uint32 top_bracket;
187    sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];    pcre_uint32 limit_match;
188  } executable_functions;  } executable_functions;
189    
190  typedef struct jump_list {  typedef struct jump_list {
# Line 196  typedef struct stub_list { Line 198  typedef struct stub_list {
198    struct stub_list *next;    struct stub_list *next;
199  } stub_list;  } stub_list;
200    
201    typedef struct label_addr_list {
202      struct sljit_label *label;
203      sljit_uw *update_addr;
204      struct label_addr_list *next;
205    } label_addr_list;
206    
207  enum frame_types {  enum frame_types {
208    no_frame = -1,    no_frame = -1,
209    no_stack = -2    no_stack = -2
210  };  };
211    
212  enum control_types {  enum control_types {
213    type_commit = 0,    type_mark = 0,
214    type_prune = 1,    type_then_trap = 1
   type_skip = 2  
215  };  };
216    
217  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
218    
219  /* The following structure is the key data type for the recursive  /* The following structure is the key data type for the recursive
220  code generator. It is allocated by compile_matchingpath, and contains  code generator. It is allocated by compile_matchingpath, and contains
221  the aguments for compile_backtrackingpath. Must be the first member  the arguments for compile_backtrackingpath. Must be the first member
222  of its descendants. */  of its descendants. */
223  typedef struct backtrack_common {  typedef struct backtrack_common {
224    /* Concatenation stack. */    /* Concatenation stack. */
# Line 227  typedef struct backtrack_common { Line 234  typedef struct backtrack_common {
234  typedef struct assert_backtrack {  typedef struct assert_backtrack {
235    backtrack_common common;    backtrack_common common;
236    jump_list *condfailed;    jump_list *condfailed;
237    /* Less than 0 (-1) if a frame is not needed. */    /* Less than 0 if a frame is not needed. */
238    int framesize;    int framesize;
239    /* Points to our private memory word on the stack. */    /* Points to our private memory word on the stack. */
240    int private_data_ptr;    int private_data_ptr;
# Line 248  typedef struct bracket_backtrack { Line 255  typedef struct bracket_backtrack {
255      /* Both for OP_COND, OP_SCOND. */      /* Both for OP_COND, OP_SCOND. */
256      jump_list *condfailed;      jump_list *condfailed;
257      assert_backtrack *assert;      assert_backtrack *assert;
258      /* For OP_ONCE. -1 if not needed. */      /* For OP_ONCE. Less than 0 if not needed. */
259      int framesize;      int framesize;
260    } u;    } u;
261    /* Points to our private memory word on the stack. */    /* Points to our private memory word on the stack. */
# Line 283  typedef struct recurse_entry { Line 290  typedef struct recurse_entry {
290    /* Collects the calls until the function is not created. */    /* Collects the calls until the function is not created. */
291    jump_list *calls;    jump_list *calls;
292    /* Points to the starting opcode. */    /* Points to the starting opcode. */
293    int start;    sljit_sw start;
294  } recurse_entry;  } recurse_entry;
295    
296  typedef struct recurse_backtrack {  typedef struct recurse_backtrack {
# Line 291  typedef struct recurse_backtrack { Line 298  typedef struct recurse_backtrack {
298    BOOL inlined_pattern;    BOOL inlined_pattern;
299  } recurse_backtrack;  } recurse_backtrack;
300    
301  #define MAX_RANGE_SIZE 6  #define OP_THEN_TRAP OP_TABLE_LENGTH
302    
303    typedef struct then_trap_backtrack {
304      backtrack_common common;
305      /* If then_trap is not NULL, this structure contains the real
306      then_trap for the backtracking path. */
307      struct then_trap_backtrack *then_trap;
308      /* Points to the starting opcode. */
309      sljit_sw start;
310      /* Exit point for the then opcodes of this alternative. */
311      jump_list *quit;
312      /* Frame size of the current alternative. */
313      int framesize;
314    } then_trap_backtrack;
315    
316    #define MAX_RANGE_SIZE 4
317    
318  typedef struct compiler_common {  typedef struct compiler_common {
319    /* The sljit ceneric compiler. */    /* The sljit ceneric compiler. */
# Line 299  typedef struct compiler_common { Line 321  typedef struct compiler_common {
321    /* First byte code. */    /* First byte code. */
322    pcre_uchar *start;    pcre_uchar *start;
323    /* Maps private data offset to each opcode. */    /* Maps private data offset to each opcode. */
324    int *private_data_ptrs;    sljit_si *private_data_ptrs;
325      /* Chain list of read-only data ptrs. */
326      void *read_only_data_head;
327    /* Tells whether the capturing bracket is optimized. */    /* Tells whether the capturing bracket is optimized. */
328    pcre_uint8 *optimized_cbracket;    pcre_uint8 *optimized_cbracket;
329      /* Tells whether the starting offset is a target of then. */
330      pcre_uint8 *then_offsets;
331      /* Current position where a THEN must jump. */
332      then_trap_backtrack *then_trap;
333    /* Starting offset of private data for capturing brackets. */    /* Starting offset of private data for capturing brackets. */
334    int cbra_ptr;    int cbra_ptr;
335    /* 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 358  typedef struct compiler_common {
358    sljit_sw lcc;    sljit_sw lcc;
359    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */    /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
360    int mode;    int mode;
361    /* \K is in the pattern. */    /* TRUE, when minlength is greater than 0. */
362      BOOL might_be_empty;
363      /* \K is found in the pattern. */
364    BOOL has_set_som;    BOOL has_set_som;
365      /* (*SKIP:arg) is found in the pattern. */
366      BOOL has_skip_arg;
367      /* (*THEN) is found in the pattern. */
368      BOOL has_then;
369    /* Needs to know the start position anytime. */    /* Needs to know the start position anytime. */
370    BOOL needs_start_ptr;    BOOL needs_start_ptr;
371    /* Currently in recurse or assert. */    /* Currently in recurse or negative assert. */
372    BOOL local_exit;    BOOL local_exit;
373      /* Currently in a positive assert. */
374      BOOL positive_assert;
375    /* Newline control. */    /* Newline control. */
376    int nltype;    int nltype;
377      pcre_uint32 nlmax;
378      pcre_uint32 nlmin;
379    int newline;    int newline;
380    int bsr_nltype;    int bsr_nltype;
381      pcre_uint32 bsr_nlmax;
382      pcre_uint32 bsr_nlmin;
383    /* Dollar endonly. */    /* Dollar endonly. */
384    int endonly;    int endonly;
385    /* Tables. */    /* Tables. */
386    sljit_sw ctypes;    sljit_sw ctypes;
   int digits[2 + MAX_RANGE_SIZE];  
387    /* Named capturing brackets. */    /* Named capturing brackets. */
388    sljit_uw name_table;    pcre_uchar *name_table;
389    sljit_sw name_count;    sljit_sw name_count;
390    sljit_sw name_entry_size;    sljit_sw name_entry_size;
391    
# Line 355  typedef struct compiler_common { Line 394  typedef struct compiler_common {
394    struct sljit_label *quit_label;    struct sljit_label *quit_label;
395    struct sljit_label *forced_quit_label;    struct sljit_label *forced_quit_label;
396    struct sljit_label *accept_label;    struct sljit_label *accept_label;
397      struct sljit_label *ff_newline_shortcut;
398    stub_list *stubs;    stub_list *stubs;
399      label_addr_list *label_addrs;
400    recurse_entry *entries;    recurse_entry *entries;
401    recurse_entry *currententry;    recurse_entry *currententry;
402    jump_list *partialmatch;    jump_list *partialmatch;
403    jump_list *quit;    jump_list *quit;
404      jump_list *positive_assert_quit;
405    jump_list *forced_quit;    jump_list *forced_quit;
406    jump_list *accept;    jump_list *accept;
407    jump_list *calllimit;    jump_list *calllimit;
# Line 378  typedef struct compiler_common { Line 420  typedef struct compiler_common {
420  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
421    BOOL use_ucp;    BOOL use_ucp;
422  #endif  #endif
 #ifndef COMPILE_PCRE32  
   jump_list *utfreadchar;  
 #endif  
423  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
424      jump_list *utfreadchar;
425      jump_list *utfreadchar16;
426    jump_list *utfreadtype8;    jump_list *utfreadtype8;
427  #endif  #endif
428  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
# Line 430  typedef struct compare_context { Line 471  typedef struct compare_context {
471  /* Used for accessing the elements of the stack. */  /* Used for accessing the elements of the stack. */
472  #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_sw))  #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_sw))
473    
474  #define TMP1          SLJIT_SCRATCH_REG1  #define TMP1          SLJIT_R0
475  #define TMP2          SLJIT_SCRATCH_REG3  #define TMP2          SLJIT_R2
476  #define TMP3          SLJIT_TEMPORARY_EREG2  #define TMP3          SLJIT_R3
477  #define STR_PTR       SLJIT_SAVED_REG1  #define STR_PTR       SLJIT_S0
478  #define STR_END       SLJIT_SAVED_REG2  #define STR_END       SLJIT_S1
479  #define STACK_TOP     SLJIT_SCRATCH_REG2  #define STACK_TOP     SLJIT_R1
480  #define STACK_LIMIT   SLJIT_SAVED_REG3  #define STACK_LIMIT   SLJIT_S2
481  #define ARGUMENTS     SLJIT_SAVED_EREG1  #define COUNT_MATCH   SLJIT_S3
482  #define CALL_COUNT    SLJIT_SAVED_EREG2  #define ARGUMENTS     SLJIT_S4
483  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1  #define RETURN_ADDR   SLJIT_R4
484    
485  /* Local space layout. */  /* Local space layout. */
486  /* These two locals can be used by the current opcode. */  /* These two locals can be used by the current opcode. */
# Line 449  typedef struct compare_context { Line 490  typedef struct compare_context {
490  #define POSSESSIVE0      (2 * sizeof(sljit_sw))  #define POSSESSIVE0      (2 * sizeof(sljit_sw))
491  #define POSSESSIVE1      (3 * sizeof(sljit_sw))  #define POSSESSIVE1      (3 * sizeof(sljit_sw))
492  /* Max limit of recursions. */  /* Max limit of recursions. */
493  #define CALL_LIMIT       (4 * sizeof(sljit_sw))  #define LIMIT_MATCH      (4 * sizeof(sljit_sw))
494  /* The output vector is stored on the stack, and contains pointers  /* The output vector is stored on the stack, and contains pointers
495  to characters. The vector data is divided into two groups: the first  to characters. The vector data is divided into two groups: the first
496  group contains the start / end character pointers, and the second is  group contains the start / end character pointers, and the second is
497  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. */
498  #define OVECTOR_START    (common->ovector_start)  #define OVECTOR_START    (common->ovector_start)
499  #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_sw))  #define OVECTOR(i)       (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw))
500  #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * sizeof(sljit_sw))  #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))
501  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])  #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
502    
503  #if defined COMPILE_PCRE8  #if defined COMPILE_PCRE8
# Line 498  the start pointers when the end of the c Line 539  the start pointers when the end of the c
539  #define GET_LOCAL_BASE(dst, dstw, offset) \  #define GET_LOCAL_BASE(dst, dstw, offset) \
540    sljit_get_local_base(compiler, (dst), (dstw), (offset))    sljit_get_local_base(compiler, (dst), (dstw), (offset))
541    
542  static pcre_uchar* bracketend(pcre_uchar* cc)  #define READ_CHAR_MAX 0x7fffffff
543    
544    static pcre_uchar *bracketend(pcre_uchar *cc)
545  {  {
546  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));
547  do cc += GET(cc, 1); while (*cc == OP_ALT);  do cc += GET(cc, 1); while (*cc == OP_ALT);
# Line 507  cc += 1 + LINK_SIZE; Line 550  cc += 1 + LINK_SIZE;
550  return cc;  return cc;
551  }  }
552    
553    static int no_alternatives(pcre_uchar *cc)
554    {
555    int count = 0;
556    SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
557    do
558      {
559      cc += GET(cc, 1);
560      count++;
561      }
562    while (*cc == OP_ALT);
563    SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
564    return count;
565    }
566    
567    static int ones_in_half_byte[16] = {
568      /* 0 */ 0, 1, 1, 2, /* 4 */ 1, 2, 2, 3,
569      /* 8 */ 1, 2, 2, 3, /* 12 */ 2, 3, 3, 4
570    };
571    
572  /* Functions whose might need modification for all new supported opcodes:  /* Functions whose might need modification for all new supported opcodes:
573   next_opcode   next_opcode
574   get_private_data_length   check_opcode_types
575   set_private_data_ptrs   set_private_data_ptrs
576   get_framesize   get_framesize
577   init_frame   init_frame
578   get_private_data_length_for_copy   get_private_data_copy_length
579   copy_private_data   copy_private_data
580   compile_matchingpath   compile_matchingpath
581   compile_backtrackingpath   compile_backtrackingpath
# Line 559  switch(*cc) Line 621  switch(*cc)
621    case OP_CRMINQUERY:    case OP_CRMINQUERY:
622    case OP_CRRANGE:    case OP_CRRANGE:
623    case OP_CRMINRANGE:    case OP_CRMINRANGE:
624      case OP_CRPOSSTAR:
625      case OP_CRPOSPLUS:
626      case OP_CRPOSQUERY:
627      case OP_CRPOSRANGE:
628    case OP_CLASS:    case OP_CLASS:
629    case OP_NCLASS:    case OP_NCLASS:
630    case OP_REF:    case OP_REF:
631    case OP_REFI:    case OP_REFI:
632      case OP_DNREF:
633      case OP_DNREFI:
634    case OP_RECURSE:    case OP_RECURSE:
635    case OP_CALLOUT:    case OP_CALLOUT:
636    case OP_ALT:    case OP_ALT:
# Line 588  switch(*cc) Line 656  switch(*cc)
656    case OP_SCBRAPOS:    case OP_SCBRAPOS:
657    case OP_SCOND:    case OP_SCOND:
658    case OP_CREF:    case OP_CREF:
659    case OP_NCREF:    case OP_DNCREF:
660    case OP_RREF:    case OP_RREF:
661    case OP_NRREF:    case OP_DNRREF:
662    case OP_DEF:    case OP_DEF:
663    case OP_BRAZERO:    case OP_BRAZERO:
664    case OP_BRAMINZERO:    case OP_BRAMINZERO:
665    case OP_BRAPOSZERO:    case OP_BRAPOSZERO:
666    case OP_PRUNE:    case OP_PRUNE:
667    case OP_SKIP:    case OP_SKIP:
668      case OP_THEN:
669    case OP_COMMIT:    case OP_COMMIT:
670    case OP_FAIL:    case OP_FAIL:
671    case OP_ACCEPT:    case OP_ACCEPT:
# Line 696  switch(*cc) Line 765  switch(*cc)
765    
766    case OP_MARK:    case OP_MARK:
767    case OP_PRUNE_ARG:    case OP_PRUNE_ARG:
768      case OP_SKIP_ARG:
769      case OP_THEN_ARG:
770    return cc + 1 + 2 + cc[1];    return cc + 1 + 2 + cc[1];
771    
772    default:    default:
773      /* All opcodes are supported now! */
774      SLJIT_ASSERT_STOP();
775    return NULL;    return NULL;
776    }    }
777  }  }
778    
779  #define CASE_ITERATOR_PRIVATE_DATA_1 \  static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
     case OP_MINSTAR: \  
     case OP_MINPLUS: \  
     case OP_QUERY: \  
     case OP_MINQUERY: \  
     case OP_MINSTARI: \  
     case OP_MINPLUSI: \  
     case OP_QUERYI: \  
     case OP_MINQUERYI: \  
     case OP_NOTMINSTAR: \  
     case OP_NOTMINPLUS: \  
     case OP_NOTQUERY: \  
     case OP_NOTMINQUERY: \  
     case OP_NOTMINSTARI: \  
     case OP_NOTMINPLUSI: \  
     case OP_NOTQUERYI: \  
     case OP_NOTMINQUERYI:  
   
 #define CASE_ITERATOR_PRIVATE_DATA_2A \  
     case OP_STAR: \  
     case OP_PLUS: \  
     case OP_STARI: \  
     case OP_PLUSI: \  
     case OP_NOTSTAR: \  
     case OP_NOTPLUS: \  
     case OP_NOTSTARI: \  
     case OP_NOTPLUSI:  
   
 #define CASE_ITERATOR_PRIVATE_DATA_2B \  
     case OP_UPTO: \  
     case OP_MINUPTO: \  
     case OP_UPTOI: \  
     case OP_MINUPTOI: \  
     case OP_NOTUPTO: \  
     case OP_NOTMINUPTO: \  
     case OP_NOTUPTOI: \  
     case OP_NOTMINUPTOI:  
   
 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \  
     case OP_TYPEMINSTAR: \  
     case OP_TYPEMINPLUS: \  
     case OP_TYPEQUERY: \  
     case OP_TYPEMINQUERY:  
   
 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \  
     case OP_TYPESTAR: \  
     case OP_TYPEPLUS:  
   
 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \  
     case OP_TYPEUPTO: \  
     case OP_TYPEMINUPTO:  
   
 static int get_class_iterator_size(pcre_uchar *cc)  
 {  
 switch(*cc)  
   {  
   case OP_CRSTAR:  
   case OP_CRPLUS:  
   return 2;  
   
   case OP_CRMINSTAR:  
   case OP_CRMINPLUS:  
   case OP_CRQUERY:  
   case OP_CRMINQUERY:  
   return 1;  
   
   case OP_CRRANGE:  
   case OP_CRMINRANGE:  
   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))  
     return 0;  
   return 2;  
   
   default:  
   return 0;  
   }  
 }  
   
 static int get_private_data_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)  
780  {  {
781  int private_data_length = 0;  int count;
782  pcre_uchar *alternative;  pcre_uchar *slot;
 pcre_uchar *name;  
 pcre_uchar *end = NULL;  
 int space, size, i;  
 pcre_uint32 bracketlen;  
783    
784  /* 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. */
785  while (cc < ccend)  while (cc < ccend)
786    {    {
   space = 0;  
   size = 0;  
   bracketlen = 0;  
787    switch(*cc)    switch(*cc)
788      {      {
789      case OP_SET_SOM:      case OP_SET_SOM:
790      common->has_set_som = TRUE;      common->has_set_som = TRUE;
791        common->might_be_empty = TRUE;
792      cc += 1;      cc += 1;
793      break;      break;
794    
# Line 808  while (cc < ccend) Line 798  while (cc < ccend)
798      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
799      break;      break;
800    
     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;  
   
801      case OP_CBRAPOS:      case OP_CBRAPOS:
802      case OP_SCBRAPOS:      case OP_SCBRAPOS:
     private_data_length += sizeof(sljit_sw);  
803      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;      common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
804      bracketlen = 1 + LINK_SIZE + IMM2_SIZE;      cc += 1 + LINK_SIZE + IMM2_SIZE;
805      break;      break;
806    
807      case OP_COND:      case OP_COND:
# Line 833  while (cc < ccend) Line 809  while (cc < ccend)
809      /* Only AUTO_CALLOUT can insert this opcode. We do      /* Only AUTO_CALLOUT can insert this opcode. We do
810         not intend to support this case. */         not intend to support this case. */
811      if (cc[1 + LINK_SIZE] == OP_CALLOUT)      if (cc[1 + LINK_SIZE] == OP_CALLOUT)
812        return -1;        return FALSE;
813        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;  
814      break;      break;
815    
816      case OP_CREF:      case OP_CREF:
817      i = GET2(cc, 1);      common->optimized_cbracket[GET2(cc, 1)] = 0;
     common->optimized_cbracket[i] = 0;  
818      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
819      break;      break;
820    
821      case OP_NCREF:      case OP_DNREF:
822      bracketlen = GET2(cc, 1);      case OP_DNREFI:
823      name = (pcre_uchar *)common->name_table;      case OP_DNCREF:
824      alternative = name;      count = GET2(cc, 1 + IMM2_SIZE);
825      for (i = 0; i < common->name_count; i++)      slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
826        {      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++)  
827        {        {
828        if (STRCMP_UC_UC(alternative + IMM2_SIZE, name + IMM2_SIZE) == 0)        common->optimized_cbracket[GET2(slot, 0)] = 0;
829          common->optimized_cbracket[GET2(alternative, 0)] = 0;        slot += common->name_entry_size;
       alternative += common->name_entry_size;  
830        }        }
831      bracketlen = 0;      cc += 1 + 2 * IMM2_SIZE;
     cc += 1 + IMM2_SIZE;  
     break;  
   
     case OP_BRA:  
     bracketlen = 1 + LINK_SIZE;  
     break;  
   
     case OP_CBRA:  
     case OP_SCBRA:  
     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;  
     break;  
   
     CASE_ITERATOR_PRIVATE_DATA_1  
     space = 1;  
     size = -2;  
     break;  
   
     CASE_ITERATOR_PRIVATE_DATA_2A  
     space = 2;  
     size = -2;  
     break;  
   
     CASE_ITERATOR_PRIVATE_DATA_2B  
     space = 2;  
     size = -(2 + IMM2_SIZE);  
     break;  
   
     CASE_ITERATOR_TYPE_PRIVATE_DATA_1  
     space = 1;  
     size = 1;  
     break;  
   
     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A  
     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)  
       space = 2;  
     size = 1;  
     break;  
   
     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B  
     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)  
       space = 2;  
     size = 1 + IMM2_SIZE;  
     break;  
   
     case OP_CLASS:  
     case OP_NCLASS:  
     size += 1 + 32 / sizeof(pcre_uchar);  
     space = get_class_iterator_size(cc + size);  
832      break;      break;
833    
 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8  
     case OP_XCLASS:  
     size = GET(cc, 1);  
     space = get_class_iterator_size(cc + size);  
     break;  
 #endif  
   
834      case OP_RECURSE:      case OP_RECURSE:
835      /* Set its value only once. */      /* Set its value only once. */
836      if (common->recursive_head_ptr == 0)      if (common->recursive_head_ptr == 0)
# Line 947  while (cc < ccend) Line 850  while (cc < ccend)
850      cc += 2 + 2 * LINK_SIZE;      cc += 2 + 2 * LINK_SIZE;
851      break;      break;
852    
853        case OP_THEN_ARG:
854        common->has_then = TRUE;
855        common->control_head_ptr = 1;
856        /* Fall through. */
857    
858      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
859      common->needs_start_ptr = TRUE;      common->needs_start_ptr = TRUE;
     common->control_head_ptr = 1;  
860      /* Fall through. */      /* Fall through. */
861    
862      case OP_MARK:      case OP_MARK:
# Line 961  while (cc < ccend) Line 868  while (cc < ccend)
868      cc += 1 + 2 + cc[1];      cc += 1 + 2 + cc[1];
869      break;      break;
870    
871        case OP_THEN:
872        common->has_then = TRUE;
873        common->control_head_ptr = 1;
874        /* Fall through. */
875    
876      case OP_PRUNE:      case OP_PRUNE:
877      case OP_SKIP:      case OP_SKIP:
878      common->needs_start_ptr = TRUE;      common->needs_start_ptr = TRUE;
879      /* Fall through. */      cc += 1;
880        break;
881    
882      case OP_COMMIT:      case OP_SKIP_ARG:
883      common->control_head_ptr = 1;      common->control_head_ptr = 1;
884      cc += 1;      common->has_skip_arg = TRUE;
885        cc += 1 + 2 + cc[1];
886      break;      break;
887    
888      default:      default:
889      cc = next_opcode(common, cc);      cc = next_opcode(common, cc);
890      if (cc == NULL)      if (cc == NULL)
891        return -1;        return FALSE;
892      break;      break;
893      }      }
894      }
895    return TRUE;
896    }
897    
898    if (space > 0 && cc >= end)  static int get_class_iterator_size(pcre_uchar *cc)
899      private_data_length += sizeof(sljit_sw) * space;  {
900    switch(*cc)
901      {
902      case OP_CRSTAR:
903      case OP_CRPLUS:
904      return 2;
905    
906    if (size != 0)    case OP_CRMINSTAR:
907      {    case OP_CRMINPLUS:
908      if (size < 0)    case OP_CRQUERY:
909        {    case OP_CRMINQUERY:
910        cc += -size;    return 1;
 #ifdef SUPPORT_UTF  
       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);  
 #endif  
       }  
     else  
       cc += size;  
     }  
911    
912    if (bracketlen != 0)    case OP_CRRANGE:
913      {    case OP_CRMINRANGE:
914      if (cc >= end)    if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
915        {      return 0;
916        end = bracketend(cc);    return 2;
917        if (end[-1 - LINK_SIZE] == OP_KET)  
918          end = NULL;    default:
919        }    return 0;
     cc += bracketlen;  
     }  
920    }    }
 return private_data_length;  
921  }  }
922    
923  static void set_private_data_ptrs(compiler_common *common, int private_data_ptr, pcre_uchar *ccend)  static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
924  {  {
925  pcre_uchar *cc = common->start;  pcre_uchar *end = bracketend(begin);
926  pcre_uchar *alternative;  pcre_uchar *next;
927  pcre_uchar *end = NULL;  pcre_uchar *next_end;
928  int space, size, bracketlen;  pcre_uchar *max_end;
929    pcre_uchar type;
930    sljit_sw length = end - begin;
931    int min, max, i;
932    
933    /* Detect fixed iterations first. */
934    if (end[-(1 + LINK_SIZE)] != OP_KET)
935      return FALSE;
936    
937    /* Already detected repeat. */
938    if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)
939      return TRUE;
940    
941    next = end;
942    min = 1;
943    while (1)
944      {
945      if (*next != *begin)
946        break;
947      next_end = bracketend(next);
948      if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)
949        break;
950      next = next_end;
951      min++;
952      }
953    
954    if (min == 2)
955      return FALSE;
956    
957    max = 0;
958    max_end = next;
959    if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)
960      {
961      type = *next;
962      while (1)
963        {
964        if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
965          break;
966        next_end = bracketend(next + 2 + LINK_SIZE);
967        if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)
968          break;
969        next = next_end;
970        max++;
971        }
972    
973      if (next[0] == type && next[1] == *begin && max >= 1)
974        {
975        next_end = bracketend(next + 1);
976        if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)
977          {
978          for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
979            if (*next_end != OP_KET)
980              break;
981    
982          if (i == max)
983            {
984            common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
985            common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
986            /* +2 the original and the last. */
987            common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;
988            if (min == 1)
989              return TRUE;
990            min--;
991            max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);
992            }
993          }
994        }
995      }
996    
997    if (min >= 3)
998      {
999      common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;
1000      common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;
1001      common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;
1002      return TRUE;
1003      }
1004    
1005    return FALSE;
1006    }
1007    
1008    #define CASE_ITERATOR_PRIVATE_DATA_1 \
1009        case OP_MINSTAR: \
1010        case OP_MINPLUS: \
1011        case OP_QUERY: \
1012        case OP_MINQUERY: \
1013        case OP_MINSTARI: \
1014        case OP_MINPLUSI: \
1015        case OP_QUERYI: \
1016        case OP_MINQUERYI: \
1017        case OP_NOTMINSTAR: \
1018        case OP_NOTMINPLUS: \
1019        case OP_NOTQUERY: \
1020        case OP_NOTMINQUERY: \
1021        case OP_NOTMINSTARI: \
1022        case OP_NOTMINPLUSI: \
1023        case OP_NOTQUERYI: \
1024        case OP_NOTMINQUERYI:
1025    
1026    #define CASE_ITERATOR_PRIVATE_DATA_2A \
1027        case OP_STAR: \
1028        case OP_PLUS: \
1029        case OP_STARI: \
1030        case OP_PLUSI: \
1031        case OP_NOTSTAR: \
1032        case OP_NOTPLUS: \
1033        case OP_NOTSTARI: \
1034        case OP_NOTPLUSI:
1035    
1036    #define CASE_ITERATOR_PRIVATE_DATA_2B \
1037        case OP_UPTO: \
1038        case OP_MINUPTO: \
1039        case OP_UPTOI: \
1040        case OP_MINUPTOI: \
1041        case OP_NOTUPTO: \
1042        case OP_NOTMINUPTO: \
1043        case OP_NOTUPTOI: \
1044        case OP_NOTMINUPTOI:
1045    
1046    #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
1047        case OP_TYPEMINSTAR: \
1048        case OP_TYPEMINPLUS: \
1049        case OP_TYPEQUERY: \
1050        case OP_TYPEMINQUERY:
1051    
1052    #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
1053        case OP_TYPESTAR: \
1054        case OP_TYPEPLUS:
1055    
1056    #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
1057        case OP_TYPEUPTO: \
1058        case OP_TYPEMINUPTO:
1059    
1060    static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)
1061    {
1062    pcre_uchar *cc = common->start;
1063    pcre_uchar *alternative;
1064    pcre_uchar *end = NULL;
1065    int private_data_ptr = *private_data_start;
1066    int space, size, bracketlen;
1067    
1068  while (cc < ccend)  while (cc < ccend)
1069    {    {
1070    space = 0;    space = 0;
1071    size = 0;    size = 0;
1072    bracketlen = 0;    bracketlen = 0;
1073      if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
1074        return;
1075    
1076      if (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND)
1077        if (detect_repeat(common, cc))
1078          {
1079          /* These brackets are converted to repeats, so no global
1080          based single character repeat is allowed. */
1081          if (cc >= end)
1082            end = bracketend(cc);
1083          }
1084    
1085    switch(*cc)    switch(*cc)
1086      {      {
1087        case OP_KET:
1088        if (common->private_data_ptrs[cc + 1 - common->start] != 0)
1089          {
1090          common->private_data_ptrs[cc - common->start] = private_data_ptr;
1091          private_data_ptr += sizeof(sljit_sw);
1092          cc += common->private_data_ptrs[cc + 1 - common->start];
1093          }
1094        cc += 1 + LINK_SIZE;
1095        break;
1096    
1097      case OP_ASSERT:      case OP_ASSERT:
1098      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1099      case OP_ASSERTBACK:      case OP_ASSERTBACK:
# Line 1115  while (cc < ccend) Line 1187  while (cc < ccend)
1187      break;      break;
1188      }      }
1189    
1190      /* Character iterators, which are not inside a repeated bracket,
1191         gets a private slot instead of allocating it on the stack. */
1192    if (space > 0 && cc >= end)    if (space > 0 && cc >= end)
1193      {      {
1194      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 1219  while (cc < ccend)
1219      cc += bracketlen;      cc += bracketlen;
1220      }      }
1221    }    }
1222    *private_data_start = private_data_ptr;
1223  }  }
1224    
1225  /* Returns with a frame_types (always < 0) if no need for frame. */  /* Returns with a frame_types (always < 0) if no need for frame. */
1226  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)
1227  {  {
 pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);  
1228  int length = 0;  int length = 0;
1229  int possessive = 0;  int possessive = 0;
1230  BOOL stack_restore = FALSE;  BOOL stack_restore = FALSE;
# Line 1159  BOOL setmark_found = recursive; Line 1233  BOOL setmark_found = recursive;
1233  /* The last capture is a local variable even for recursions. */  /* The last capture is a local variable even for recursions. */
1234  BOOL capture_last_found = FALSE;  BOOL capture_last_found = FALSE;
1235    
1236  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))  #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
1237    SLJIT_ASSERT(common->control_head_ptr != 0);
1238    *needs_control_head = TRUE;
1239    #else
1240    *needs_control_head = FALSE;
1241    #endif
1242    
1243    if (ccend == NULL)
1244    {    {
1245    possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;    ccend = bracketend(cc) - (1 + LINK_SIZE);
1246    /* This is correct regardless of common->capture_last_ptr. */    if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
1247    capture_last_found = TRUE;      {
1248        possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
1249        /* This is correct regardless of common->capture_last_ptr. */
1250        capture_last_found = TRUE;
1251        }
1252      cc = next_opcode(common, cc);
1253    }    }
1254    
 cc = next_opcode(common, cc);  
1255  SLJIT_ASSERT(cc != NULL);  SLJIT_ASSERT(cc != NULL);
1256  while (cc < ccend)  while (cc < ccend)
1257    switch(*cc)    switch(*cc)
# Line 1184  while (cc < ccend) Line 1269  while (cc < ccend)
1269    
1270      case OP_MARK:      case OP_MARK:
1271      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
1272        case OP_THEN_ARG:
1273      SLJIT_ASSERT(common->mark_ptr != 0);      SLJIT_ASSERT(common->mark_ptr != 0);
1274      stack_restore = TRUE;      stack_restore = TRUE;
1275      if (!setmark_found)      if (!setmark_found)
# Line 1191  while (cc < ccend) Line 1277  while (cc < ccend)
1277        length += 2;        length += 2;
1278        setmark_found = TRUE;        setmark_found = TRUE;
1279        }        }
1280        if (common->control_head_ptr != 0)
1281          *needs_control_head = TRUE;
1282      cc += 1 + 2 + cc[1];      cc += 1 + 2 + cc[1];
1283      break;      break;
1284    
# Line 1310  if (length > 0) Line 1398  if (length > 0)
1398  return stack_restore ? no_frame : no_stack;  return stack_restore ? no_frame : no_stack;
1399  }  }
1400    
1401  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)
1402  {  {
1403  DEFINE_COMPILER;  DEFINE_COMPILER;
 pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);  
1404  BOOL setsom_found = recursive;  BOOL setsom_found = recursive;
1405  BOOL setmark_found = recursive;  BOOL setmark_found = recursive;
1406  /* 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 1412  SLJIT_UNUSED_ARG(stacktop);
1412  SLJIT_ASSERT(stackpos >= stacktop + 2);  SLJIT_ASSERT(stackpos >= stacktop + 2);
1413    
1414  stackpos = STACK(stackpos);  stackpos = STACK(stackpos);
1415  if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))  if (ccend == NULL)
1416    cc = next_opcode(common, cc);    {
1417      ccend = bracketend(cc) - (1 + LINK_SIZE);
1418      if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
1419        cc = next_opcode(common, cc);
1420      }
1421    
1422  SLJIT_ASSERT(cc != NULL);  SLJIT_ASSERT(cc != NULL);
1423  while (cc < ccend)  while (cc < ccend)
1424    switch(*cc)    switch(*cc)
# Line 1335  while (cc < ccend) Line 1427  while (cc < ccend)
1427      SLJIT_ASSERT(common->has_set_som);      SLJIT_ASSERT(common->has_set_som);
1428      if (!setsom_found)      if (!setsom_found)
1429        {        {
1430        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
1431        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
1432        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1433        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
# Line 1347  while (cc < ccend) Line 1439  while (cc < ccend)
1439    
1440      case OP_MARK:      case OP_MARK:
1441      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
1442        case OP_THEN_ARG:
1443      SLJIT_ASSERT(common->mark_ptr != 0);      SLJIT_ASSERT(common->mark_ptr != 0);
1444      if (!setmark_found)      if (!setmark_found)
1445        {        {
1446        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
1447        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
1448        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1449        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
# Line 1363  while (cc < ccend) Line 1456  while (cc < ccend)
1456      case OP_RECURSE:      case OP_RECURSE:
1457      if (common->has_set_som && !setsom_found)      if (common->has_set_som && !setsom_found)
1458        {        {
1459        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
1460        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
1461        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1462        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
# Line 1372  while (cc < ccend) Line 1465  while (cc < ccend)
1465        }        }
1466      if (common->mark_ptr != 0 && !setmark_found)      if (common->mark_ptr != 0 && !setmark_found)
1467        {        {
1468        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
1469        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
1470        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1471        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
# Line 1381  while (cc < ccend) Line 1474  while (cc < ccend)
1474        }        }
1475      if (common->capture_last_ptr != 0 && !capture_last_found)      if (common->capture_last_ptr != 0 && !capture_last_found)
1476        {        {
1477        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
1478        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
1479        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1480        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
# Line 1397  while (cc < ccend) Line 1490  while (cc < ccend)
1490      case OP_SCBRAPOS:      case OP_SCBRAPOS:
1491      if (common->capture_last_ptr != 0 && !capture_last_found)      if (common->capture_last_ptr != 0 && !capture_last_found)
1492        {        {
1493        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
1494        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
1495        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1496        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
# Line 1407  while (cc < ccend) Line 1500  while (cc < ccend)
1500      offset = (GET2(cc, 1 + LINK_SIZE)) << 1;      offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
1501      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));
1502      stackpos += (int)sizeof(sljit_sw);      stackpos += (int)sizeof(sljit_sw);
1503      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
1504      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
1505      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1506      stackpos += (int)sizeof(sljit_sw);      stackpos += (int)sizeof(sljit_sw);
1507      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);
# Line 1427  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), st Line 1520  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), st
1520  SLJIT_ASSERT(stackpos == STACK(stacktop));  SLJIT_ASSERT(stackpos == STACK(stacktop));
1521  }  }
1522    
1523  static SLJIT_INLINE int get_private_data_length_for_copy(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)  static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)
1524  {  {
1525  int private_data_length = common->control_head_ptr ? 3 : 2;  int private_data_length = needs_control_head ? 3 : 2;
1526  int size;  int size;
1527  pcre_uchar *alternative;  pcre_uchar *alternative;
1528  /* Calculate the sum of the private machine words. */  /* Calculate the sum of the private machine words. */
# Line 1438  while (cc < ccend) Line 1531  while (cc < ccend)
1531    size = 0;    size = 0;
1532    switch(*cc)    switch(*cc)
1533      {      {
1534        case OP_KET:
1535        if (PRIVATE_DATA(cc) != 0)
1536          private_data_length++;
1537        cc += 1 + LINK_SIZE;
1538        break;
1539    
1540      case OP_ASSERT:      case OP_ASSERT:
1541      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1542      case OP_ASSERTBACK:      case OP_ASSERTBACK:
# Line 1542  return private_data_length; Line 1641  return private_data_length;
1641  }  }
1642    
1643  static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,  static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
1644    BOOL save, int stackptr, int stacktop)    BOOL save, int stackptr, int stacktop, BOOL needs_control_head)
1645  {  {
1646  DEFINE_COMPILER;  DEFINE_COMPILER;
1647  int srcw[2];  int srcw[2];
# Line 1563  stacktop = STACK(stacktop - 1); Line 1662  stacktop = STACK(stacktop - 1);
1662    
1663  if (!save)  if (!save)
1664    {    {
1665    stackptr += (common->control_head_ptr ? 2 : 1) * sizeof(sljit_sw);    stackptr += (needs_control_head ? 2 : 1) * sizeof(sljit_sw);
1666    if (stackptr < stacktop)    if (stackptr < stacktop)
1667      {      {
1668      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
# Line 1588  do Line 1687  do
1687      SLJIT_ASSERT(save && common->recursive_head_ptr != 0);      SLJIT_ASSERT(save && common->recursive_head_ptr != 0);
1688      count = 1;      count = 1;
1689      srcw[0] = common->recursive_head_ptr;      srcw[0] = common->recursive_head_ptr;
1690      if (common->control_head_ptr != 0)      if (needs_control_head)
1691        {        {
1692          SLJIT_ASSERT(common->control_head_ptr != 0);
1693        count = 2;        count = 2;
1694        srcw[1] = common->control_head_ptr;        srcw[1] = common->control_head_ptr;
1695        }        }
# Line 1605  do Line 1705  do
1705    
1706      switch(*cc)      switch(*cc)
1707        {        {
1708          case OP_KET:
1709          if (PRIVATE_DATA(cc) != 0)
1710            {
1711            count = 1;
1712            srcw[0] = PRIVATE_DATA(cc);
1713            }
1714          cc += 1 + LINK_SIZE;
1715          break;
1716    
1717        case OP_ASSERT:        case OP_ASSERT:
1718        case OP_ASSERT_NOT:        case OP_ASSERT_NOT:
1719        case OP_ASSERTBACK:        case OP_ASSERTBACK:
# Line 1772  do Line 1881  do
1881            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
1882            stackptr += sizeof(sljit_sw);            stackptr += sizeof(sljit_sw);
1883            }            }
1884          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);
1885          tmp1empty = FALSE;          tmp1empty = FALSE;
1886          tmp1next = FALSE;          tmp1next = FALSE;
1887          }          }
# Line 1783  do Line 1892  do
1892            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);            OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
1893            stackptr += sizeof(sljit_sw);            stackptr += sizeof(sljit_sw);
1894            }            }
1895          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);
1896          tmp2empty = FALSE;          tmp2empty = FALSE;
1897          tmp1next = TRUE;          tmp1next = TRUE;
1898          }          }
# Line 1793  do Line 1902  do
1902        if (tmp1next)        if (tmp1next)
1903          {          {
1904          SLJIT_ASSERT(!tmp1empty);          SLJIT_ASSERT(!tmp1empty);
1905          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP1, 0);          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP1, 0);
1906          tmp1empty = stackptr >= stacktop;          tmp1empty = stackptr >= stacktop;
1907          if (!tmp1empty)          if (!tmp1empty)
1908            {            {
# Line 1805  do Line 1914  do
1914        else        else
1915          {          {
1916          SLJIT_ASSERT(!tmp2empty);          SLJIT_ASSERT(!tmp2empty);
1917          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP2, 0);          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP2, 0);
1918          tmp2empty = stackptr >= stacktop;          tmp2empty = stackptr >= stacktop;
1919          if (!tmp2empty)          if (!tmp2empty)
1920            {            {
# Line 1851  if (save) Line 1960  if (save)
1960  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
1961  }  }
1962    
1963    static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)
1964    {
1965    pcre_uchar *end = bracketend(cc);
1966    BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
1967    
1968    /* Assert captures then. */
1969    if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
1970      current_offset = NULL;
1971    /* Conditional block does not. */
1972    if (*cc == OP_COND || *cc == OP_SCOND)
1973      has_alternatives = FALSE;
1974    
1975    cc = next_opcode(common, cc);
1976    if (has_alternatives)
1977      current_offset = common->then_offsets + (cc - common->start);
1978    
1979    while (cc < end)
1980      {
1981      if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
1982        cc = set_then_offsets(common, cc, current_offset);
1983      else
1984        {
1985        if (*cc == OP_ALT && has_alternatives)
1986          current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);
1987        if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)
1988          *current_offset = 1;
1989        cc = next_opcode(common, cc);
1990        }
1991      }
1992    
1993    return end;
1994    }
1995    
1996  #undef CASE_ITERATOR_PRIVATE_DATA_1  #undef CASE_ITERATOR_PRIVATE_DATA_1
1997  #undef CASE_ITERATOR_PRIVATE_DATA_2A  #undef CASE_ITERATOR_PRIVATE_DATA_2A
1998  #undef CASE_ITERATOR_PRIVATE_DATA_2B  #undef CASE_ITERATOR_PRIVATE_DATA_2B
# Line 1874  while (list) Line 2016  while (list)
2016    }    }
2017  }  }
2018    
2019  static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump* jump)  static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump *jump)
2020  {  {
2021  jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));  jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));
2022  if (list_item)  if (list_item)
# Line 1888  if (list_item) Line 2030  if (list_item)
2030  static void add_stub(compiler_common *common, struct sljit_jump *start)  static void add_stub(compiler_common *common, struct sljit_jump *start)
2031  {  {
2032  DEFINE_COMPILER;  DEFINE_COMPILER;
2033  stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));  stub_list *list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
2034    
2035  if (list_item)  if (list_item)
2036    {    {
# Line 1902  if (list_item) Line 2044  if (list_item)
2044  static void flush_stubs(compiler_common *common)  static void flush_stubs(compiler_common *common)
2045  {  {
2046  DEFINE_COMPILER;  DEFINE_COMPILER;
2047  stub_list* list_item = common->stubs;  stub_list *list_item = common->stubs;
2048    
2049  while (list_item)  while (list_item)
2050    {    {
# Line 1914  while (list_item) Line 2056  while (list_item)
2056  common->stubs = NULL;  common->stubs = NULL;
2057  }  }
2058    
2059  static SLJIT_INLINE void decrease_call_count(compiler_common *common)  static void add_label_addr(compiler_common *common, sljit_uw *update_addr)
2060    {
2061    DEFINE_COMPILER;
2062    label_addr_list *label_addr;
2063    
2064    label_addr = sljit_alloc_memory(compiler, sizeof(label_addr_list));
2065    if (label_addr == NULL)
2066      return;
2067    label_addr->label = LABEL();
2068    label_addr->update_addr = update_addr;
2069    label_addr->next = common->label_addrs;
2070    common->label_addrs = label_addr;
2071    }
2072    
2073    static SLJIT_INLINE void count_match(compiler_common *common)
2074  {  {
2075  DEFINE_COMPILER;  DEFINE_COMPILER;
2076    
2077  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);
2078  add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));  add_jump(compiler, &common->calllimit, JUMP(SLJIT_ZERO));
2079  }  }
2080    
2081  static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)  static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)
# Line 1932  OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, Line 2088  OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP,
2088  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);
2089  OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);  OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
2090  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
2091  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, TMP1, 0);
2092  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);
2093  #endif  #endif
2094  add_stub(common, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));  add_stub(common, CMP(SLJIT_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));
2095  }  }
2096    
2097  static SLJIT_INLINE void free_stack(compiler_common *common, int size)  static SLJIT_INLINE void free_stack(compiler_common *common, int size)
# Line 1944  DEFINE_COMPILER; Line 2100  DEFINE_COMPILER;
2100  OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));  OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
2101  }  }
2102    
2103    static sljit_uw * allocate_read_only_data(compiler_common *common, sljit_uw size)
2104    {
2105    DEFINE_COMPILER;
2106    sljit_uw *result;
2107    
2108    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
2109      return NULL;
2110    
2111    result = (sljit_uw *)SLJIT_MALLOC(size + sizeof(sljit_uw), compiler->allocator_data);
2112    if (SLJIT_UNLIKELY(result == NULL))
2113      {
2114      sljit_set_compiler_memory_error(compiler);
2115      return NULL;
2116      }
2117    
2118    *(void**)result = common->read_only_data_head;
2119    common->read_only_data_head = (void *)result;
2120    return result + 1;
2121    }
2122    
2123    static void free_read_only_data(void *current, void *allocator_data)
2124    {
2125    void *next;
2126    
2127    SLJIT_UNUSED_ARG(allocator_data);
2128    
2129    while (current != NULL)
2130      {
2131      next = *(void**)current;
2132      SLJIT_FREE(current, allocator_data);
2133      current = next;
2134      }
2135    }
2136    
2137  static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)  static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)
2138  {  {
2139  DEFINE_COMPILER;  DEFINE_COMPILER;
# Line 1953  int i; Line 2143  int i;
2143  /* At this point we can freely use all temporary registers. */  /* At this point we can freely use all temporary registers. */
2144  SLJIT_ASSERT(length > 1);  SLJIT_ASSERT(length > 1);
2145  /* TMP1 returns with begin - 1. */  /* TMP1 returns with begin - 1. */
2146  OP2(SLJIT_SUB, SLJIT_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
2147  if (length < 8)  if (length < 8)
2148    {    {
2149    for (i = 1; i < length; i++)    for (i = 1; i < length; i++)
2150      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_SCRATCH_REG1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), SLJIT_R0, 0);
2151    }    }
2152  else  else
2153    {    {
2154    GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, OVECTOR_START);    GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START);
2155    OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, length - 1);    OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1);
2156    loop = LABEL();    loop = LABEL();
2157    OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(sljit_sw), SLJIT_SCRATCH_REG1, 0);    OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R0, 0);
2158    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 1);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);
2159    JUMPTO(SLJIT_C_NOT_ZERO, loop);    JUMPTO(SLJIT_NOT_ZERO, loop);
2160    }    }
2161  }  }
2162    
# Line 1979  int i; Line 2169  int i;
2169  SLJIT_ASSERT(length > 1);  SLJIT_ASSERT(length > 1);
2170  /* OVECTOR(1) contains the "string begin - 1" constant. */  /* OVECTOR(1) contains the "string begin - 1" constant. */
2171  if (length > 2)  if (length > 2)
2172    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
2173  if (length < 8)  if (length < 8)
2174    {    {
2175    for (i = 2; i < length; i++)    for (i = 2; i < length; i++)
2176      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), TMP1, 0);
2177    }    }
2178  else  else
2179    {    {
# Line 1992  else Line 2182  else
2182    loop = LABEL();    loop = LABEL();
2183    OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);    OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
2184    OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);    OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);
2185    JUMPTO(SLJIT_C_NOT_ZERO, loop);    JUMPTO(SLJIT_NOT_ZERO, loop);
2186    }    }
2187    
2188  OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);
2189  if (common->mark_ptr != 0)  if (common->mark_ptr != 0)
2190    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0);
2191  SLJIT_ASSERT(common->control_head_ptr != 0);  if (common->control_head_ptr != 0)
2192  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
2193  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));
2194  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr);  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_ptr);
2195  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));
2196  }  }
2197    
2198  static sljit_sw do_check_control_chain(sljit_sw *current)  static sljit_sw SLJIT_CALL do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)
2199  {  {
2200  sljit_sw return_value = 0;  while (current != NULL)
   
 SLJIT_ASSERT(current != NULL);  
 do  
2201    {    {
2202    switch (current[-2])    switch (current[-2])
2203      {      {
2204      case type_commit:      case type_then_trap:
     /* Commit overwrites all. */  
     return -1;  
   
     case type_prune:  
2205      break;      break;
2206    
2207      case type_skip:      case type_mark:
2208      /* Overwrites prune, but not other skips. */      if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[-3]) == 0)
2209      if (return_value == 0)        return current[-4];
       return_value = current[-3];  
2210      break;      break;
2211    
2212      default:      default:
# Line 2033  do Line 2215  do
2215      }      }
2216    current = (sljit_sw*)current[-1];    current = (sljit_sw*)current[-1];
2217    }    }
2218  while (current != NULL);  return -1;
 return return_value;  
2219  }  }
2220    
2221  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)  static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
# Line 2044  struct sljit_label *loop; Line 2225  struct sljit_label *loop;
2225  struct sljit_jump *early_quit;  struct sljit_jump *early_quit;
2226    
2227  /* At this point we can freely use all registers. */  /* At this point we can freely use all registers. */
2228  OP1(SLJIT_MOV, SLJIT_SAVED_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));  OP1(SLJIT_MOV, SLJIT_S2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
2229  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1), STR_PTR, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(1), STR_PTR, 0);
2230    
2231  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0);
2232  if (common->mark_ptr != 0)  if (common->mark_ptr != 0)
2233    OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);    OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
2234  OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, offset_count));  OP1(SLJIT_MOV_SI, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offset_count));
2235  if (common->mark_ptr != 0)  if (common->mark_ptr != 0)
2236    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_SCRATCH_REG3, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_R2, 0);
2237  OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));  OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
2238  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, begin));  OP1(SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, begin));
2239  GET_LOCAL_BASE(SLJIT_SAVED_REG1, 0, OVECTOR_START);  GET_LOCAL_BASE(SLJIT_S0, 0, OVECTOR_START);
2240  /* Unlikely, but possible */  /* Unlikely, but possible */
2241  early_quit = CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 0);  early_quit = CMP(SLJIT_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0);
2242  loop = LABEL();  loop = LABEL();
2243  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_SCRATCH_REG1, 0);  OP2(SLJIT_SUB, SLJIT_S1, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
2244  OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_sw));  OP2(SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_sw));
2245  /* Copy the integer value to the output buffer */  /* Copy the integer value to the output buffer */
2246  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
2247  OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);  OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);
2248  #endif  #endif
2249  OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG3), sizeof(int), SLJIT_SAVED_REG2, 0);  OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_R2), sizeof(int), SLJIT_S1, 0);
2250  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 1);  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
2251  JUMPTO(SLJIT_C_NOT_ZERO, loop);  JUMPTO(SLJIT_NOT_ZERO, loop);
2252  JUMPHERE(early_quit);  JUMPHERE(early_quit);
2253    
2254  /* Calculate the return value, which is the maximum ovector value. */  /* Calculate the return value, which is the maximum ovector value. */
2255  if (topbracket > 1)  if (topbracket > 1)
2256    {    {
2257    GET_LOCAL_BASE(SLJIT_SCRATCH_REG1, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));    GET_LOCAL_BASE(SLJIT_R0, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));
2258    OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, topbracket + 1);    OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, topbracket + 1);
2259    
2260    /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */    /* OVECTOR(0) is never equal to SLJIT_S2. */
2261    loop = LABEL();    loop = LABEL();
2262    OP1(SLJIT_MOVU, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), -(2 * (sljit_sw)sizeof(sljit_sw)));    OP1(SLJIT_MOVU, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), -(2 * (sljit_sw)sizeof(sljit_sw)));
2263    OP2(SLJIT_SUB, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 1);    OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
2264    CMPTO(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG3, 0, SLJIT_SAVED_REG3, 0, loop);    CMPTO(SLJIT_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop);
2265    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_SCRATCH_REG2, 0);    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_R1, 0);
2266    }    }
2267  else  else
2268    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
# Line 2092  static SLJIT_INLINE void return_with_par Line 2273  static SLJIT_INLINE void return_with_par
2273  DEFINE_COMPILER;  DEFINE_COMPILER;
2274  struct sljit_jump *jump;  struct sljit_jump *jump;
2275    
2276  SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);  SLJIT_COMPILE_ASSERT(STR_END == SLJIT_S1, str_end_must_be_saved_reg2);
2277  SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0  SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0
2278    && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));    && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
2279    
2280  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, SLJIT_R1, 0, ARGUMENTS, 0);
2281  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
2282  OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, real_offset_count));  OP1(SLJIT_MOV_SI, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
2283  CMPTO(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 2, quit);  CMPTO(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 2, quit);
2284    
2285  /* Store match begin and end. */  /* Store match begin and end. */
2286  OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, begin));  OP1(SLJIT_MOV, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, begin));
2287  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));  OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, offsets));
2288    
2289  jump = CMP(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 3);  jump = CMP(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 3);
2290  OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + sizeof(sljit_sw)), SLJIT_SAVED_REG1, 0);  OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + (int)sizeof(sljit_sw)), SLJIT_S0, 0);
2291  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
2292  OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);  OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
2293  #endif  #endif
2294  OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 2 * sizeof(int), SLJIT_SCRATCH_REG3, 0);  OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(int), SLJIT_R2, 0);
2295  JUMPHERE(jump);  JUMPHERE(jump);
2296    
2297  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);  OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
2298  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);  OP2(SLJIT_SUB, SLJIT_S1, 0, STR_END, 0, SLJIT_S0, 0);
2299  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
2300  OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);  OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);
2301  #endif  #endif
2302  OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(int), SLJIT_SAVED_REG2, 0);  OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), sizeof(int), SLJIT_S1, 0);
2303    
2304  OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_SAVED_REG1, 0);  OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_S0, 0);
2305  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
2306  OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);  OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
2307  #endif  #endif
2308  OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 0, SLJIT_SCRATCH_REG3, 0);  OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);
2309    
2310  JUMPTO(SLJIT_JUMP, quit);  JUMPTO(SLJIT_JUMP, quit);
2311  }  }
# Line 2138  struct sljit_jump *jump; Line 2319  struct sljit_jump *jump;
2319  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2320    {    {
2321    /* The value of -1 must be kept for start_used_ptr! */    /* The value of -1 must be kept for start_used_ptr! */
2322    OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, 1);    OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, 1);
2323    /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting    /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting
2324    is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */    is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */
2325    jump = CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, STR_PTR, 0);    jump = CMP(SLJIT_LESS_EQUAL, TMP1, 0, STR_PTR, 0);
2326    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
2327    JUMPHERE(jump);    JUMPHERE(jump);
2328    }    }
2329  else if (common->mode == JIT_PARTIAL_HARD_COMPILE)  else if (common->mode == JIT_PARTIAL_HARD_COMPILE)
2330    {    {
2331    jump = CMP(SLJIT_C_LESS_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    jump = CMP(SLJIT_LESS_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
2332    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
2333    JUMPHERE(jump);    JUMPHERE(jump);
2334    }    }
2335  }  }
2336    
2337  static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar* cc)  static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar *cc)
2338  {  {
2339  /* Detects if the character has an othercase. */  /* Detects if the character has an othercase. */
2340  unsigned int c;  unsigned int c;
# Line 2196  if (common->utf && c > 127) Line 2377  if (common->utf && c > 127)
2377  return TABLE_GET(c, common->fcc, c);  return TABLE_GET(c, common->fcc, c);
2378  }  }
2379    
2380  static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar* cc)  static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar *cc)
2381  {  {
2382  /* Detects if the character and its othercase has only 1 bit difference. */  /* Detects if the character and its othercase has only 1 bit difference. */
2383  unsigned int c, oc, bit;  unsigned int c, oc, bit;
# Line 2274  return (bit < 256) ? ((0 << 8) | bit) : Line 2455  return (bit < 256) ? ((0 << 8) | bit) :
2455    
2456  static void check_partial(compiler_common *common, BOOL force)  static void check_partial(compiler_common *common, BOOL force)
2457  {  {
2458  /* Checks whether a partial matching is occured. Does not modify registers. */  /* Checks whether a partial matching is occurred. Does not modify registers. */
2459  DEFINE_COMPILER;  DEFINE_COMPILER;
2460  struct sljit_jump *jump = NULL;  struct sljit_jump *jump = NULL;
2461    
# Line 2284  if (common->mode == JIT_COMPILE) Line 2465  if (common->mode == JIT_COMPILE)
2465    return;    return;
2466    
2467  if (!force)  if (!force)
2468    jump = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    jump = CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
2469  else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2470    jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);    jump = CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1);
2471    
2472  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2473    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
2474  else  else
2475    {    {
2476    if (common->partialmatchlabel != NULL)    if (common->partialmatchlabel != NULL)
# Line 2310  struct sljit_jump *jump; Line 2491  struct sljit_jump *jump;
2491    
2492  if (common->mode == JIT_COMPILE)  if (common->mode == JIT_COMPILE)
2493    {    {
2494    add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));    add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
2495    return;    return;
2496    }    }
2497    
2498  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);  jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
2499  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2500    {    {
2501    add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));    add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
2502    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
2503    add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));    add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));
2504    }    }
2505  else  else
2506    {    {
2507    add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));    add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
2508    if (common->partialmatchlabel != NULL)    if (common->partialmatchlabel != NULL)
2509      JUMPTO(SLJIT_JUMP, common->partialmatchlabel);      JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
2510    else    else
# Line 2339  struct sljit_jump *jump; Line 2520  struct sljit_jump *jump;
2520    
2521  if (common->mode == JIT_COMPILE)  if (common->mode == JIT_COMPILE)
2522    {    {
2523    add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));    add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
2524    return;    return;
2525    }    }
2526    
2527  /* Partial matching mode. */  /* Partial matching mode. */
2528  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);  jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
2529  add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));  add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
2530  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2531    {    {
2532    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
2533    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
2534    }    }
2535  else  else
# Line 2361  else Line 2542  else
2542  JUMPHERE(jump);  JUMPHERE(jump);
2543  }  }
2544    
2545  static void read_char(compiler_common *common)  static void peek_char(compiler_common *common, pcre_uint32 max)
2546  {  {
2547  /* Reads the character into TMP1, updates STR_PTR.  /* Reads the character into TMP1, keeps STR_PTR.
2548  Does not check STR_END. TMP2 Destroyed. */  Does not check STR_END. TMP2 Destroyed. */
2549  DEFINE_COMPILER;  DEFINE_COMPILER;
2550  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2551  struct sljit_jump *jump;  struct sljit_jump *jump;
2552  #endif  #endif
2553    
2554    SLJIT_UNUSED_ARG(max);
2555    
2556  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2557  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2558  if (common->utf)  if (common->utf)
2559    {    {
2560  #if defined COMPILE_PCRE8    if (max < 128) return;
2561    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);  
2562  #elif defined COMPILE_PCRE16    jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
2563    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
 #endif /* COMPILE_PCRE[8|16] */  
2564    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
2565      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2566    JUMPHERE(jump);    JUMPHERE(jump);
2567    }    }
2568  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
2569  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  
2570    #if defined SUPPORT_UTF && defined COMPILE_PCRE16
2571    if (common->utf)
2572      {
2573      if (max < 0xd800) return;
2574    
2575      OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
2576      jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
2577      /* TMP2 contains the high surrogate. */
2578      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2579      OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
2580      OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
2581      OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
2582      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2583      JUMPHERE(jump);
2584      }
2585    #endif
2586  }  }
2587    
2588  static void peek_char(compiler_common *common)  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2589    
2590    static BOOL is_char7_bitset(const pcre_uint8 *bitset, BOOL nclass)
2591  {  {
2592  /* Reads the character into TMP1, keeps STR_PTR.  /* Tells whether the character codes below 128 are enough
2593  Does not check STR_END. TMP2 Destroyed. */  to determine a match. */
2594  DEFINE_COMPILER;  const pcre_uint8 value = nclass ? 0xff : 0;
2595  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  const pcre_uint8 *end = bitset + 32;
 struct sljit_jump *jump;  
 #endif  
2596    
2597  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);  bitset += 16;
2598  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  do
 if (common->utf)  
2599    {    {
2600  #if defined COMPILE_PCRE8    if (*bitset++ != value)
2601    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);      return FALSE;
 #elif defined COMPILE_PCRE16  
   jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);  
 #endif /* COMPILE_PCRE[8|16] */  
   add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));  
   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);  
   JUMPHERE(jump);  
2602    }    }
2603  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */  while (bitset < end);
2604    return TRUE;
2605  }  }
2606    
2607  static void read_char8_type(compiler_common *common)  static void read_char7_type(compiler_common *common, BOOL full_read)
2608  {  {
2609  /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */  /* Reads the precise character type of a character into TMP1, if the character
2610    is less than 128. Otherwise it returns with zero. Does not check STR_END. The
2611    full_read argument tells whether characters above max are accepted or not. */
2612  DEFINE_COMPILER;  DEFINE_COMPILER;
 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32  
2613  struct sljit_jump *jump;  struct sljit_jump *jump;
 #endif  
2614    
2615  #ifdef SUPPORT_UTF  SLJIT_ASSERT(common->utf);
2616  if (common->utf)  
2617    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
2618    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2619    
2620    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2621    
2622    if (full_read)
2623    {    {
2624    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);    jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
2625    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
 #if defined COMPILE_PCRE8  
   /* This can be an extra read in some situations, but hopefully  
   it is needed in most cases. */  
   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);  
   jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);  
   add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));  
   JUMPHERE(jump);  
 #elif defined COMPILE_PCRE16  
   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);  
   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);  
   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);  
   JUMPHERE(jump);  
   /* Skip low surrogate if necessary. */  
   OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);  
   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);  
   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);  
   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);  
2626    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
 #elif defined COMPILE_PCRE32  
   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);  
   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);  
   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);  
2627    JUMPHERE(jump);    JUMPHERE(jump);
 #endif /* COMPILE_PCRE[8|16|32] */  
   return;  
2628    }    }
 #endif /* SUPPORT_UTF */  
 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);  
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  
 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  
 /* The ctypes array contains only 256 values. */  
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);  
 jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);  
 #endif  
 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);  
 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  
 JUMPHERE(jump);  
 #endif  
2629  }  }
2630    
2631  static void skip_char_back(compiler_common *common)  #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
2632    
2633    static void read_char_range(compiler_common *common, pcre_uint32 min, pcre_uint32 max, BOOL update_str_ptr)
2634    {
2635    /* Reads the precise value of a character into TMP1, if the character is
2636    between min and max (c >= min && c <= max). Otherwise it returns with a value
2637    outside the range. Does not check STR_END. */
2638    DEFINE_COMPILER;
2639    #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2640    struct sljit_jump *jump;
2641    #endif
2642    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2643    struct sljit_jump *jump2;
2644    #endif
2645    
2646    SLJIT_UNUSED_ARG(update_str_ptr);
2647    SLJIT_UNUSED_ARG(min);
2648    SLJIT_UNUSED_ARG(max);
2649    SLJIT_ASSERT(min <= max);
2650    
2651    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2652    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2653    
2654    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2655    if (common->utf)
2656      {
2657      if (max < 128 && !update_str_ptr) return;
2658    
2659      jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
2660      if (min >= 0x10000)
2661        {
2662        OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xf0);
2663        if (update_str_ptr)
2664          OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
2665        OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2666        jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x7);
2667        OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
2668        OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2669        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2670        OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
2671        OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2672        OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2673        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2674        OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
2675        if (!update_str_ptr)
2676          OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
2677        OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2678        OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2679        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2680        JUMPHERE(jump2);
2681        if (update_str_ptr)
2682          OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
2683        }
2684      else if (min >= 0x800 && max <= 0xffff)
2685        {
2686        OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xe0);
2687        if (update_str_ptr)
2688          OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
2689        OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2690        jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xf);
2691        OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
2692        OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2693        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2694        OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
2695        if (!update_str_ptr)
2696          OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
2697        OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2698        OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2699        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2700        JUMPHERE(jump2);
2701        if (update_str_ptr)
2702          OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
2703        }
2704      else if (max >= 0x800)
2705        add_jump(compiler, (max < 0x10000) ? &common->utfreadchar16 : &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
2706      else if (max < 128)
2707        {
2708        OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
2709        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2710        }
2711      else
2712        {
2713        OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2714        if (!update_str_ptr)
2715          OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2716        else
2717          OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
2718        OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2719        OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2720        OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2721        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2722        if (update_str_ptr)
2723          OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
2724        }
2725      JUMPHERE(jump);
2726      }
2727    #endif
2728    
2729    #if defined SUPPORT_UTF && defined COMPILE_PCRE16
2730    if (common->utf)
2731      {
2732      if (max >= 0x10000)
2733        {
2734        OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
2735        jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
2736        /* TMP2 contains the high surrogate. */
2737        OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2738        OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
2739        OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
2740        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2741        OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
2742        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2743        JUMPHERE(jump);
2744        return;
2745        }
2746    
2747      if (max < 0xd800 && !update_str_ptr) return;
2748    
2749      /* Skip low surrogate if necessary. */
2750      OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
2751      jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
2752      if (update_str_ptr)
2753        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2754      if (max >= 0xd800)
2755        OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000);
2756      JUMPHERE(jump);
2757      }
2758    #endif
2759    }
2760    
2761    static SLJIT_INLINE void read_char(compiler_common *common)
2762    {
2763    read_char_range(common, 0, READ_CHAR_MAX, TRUE);
2764    }
2765    
2766    static void read_char8_type(compiler_common *common, BOOL update_str_ptr)
2767    {
2768    /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
2769    DEFINE_COMPILER;
2770    #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
2771    struct sljit_jump *jump;
2772    #endif
2773    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2774    struct sljit_jump *jump2;
2775    #endif
2776    
2777    SLJIT_UNUSED_ARG(update_str_ptr);
2778    
2779    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
2780    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2781    
2782    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
2783    if (common->utf)
2784      {
2785      /* This can be an extra read in some situations, but hopefully
2786      it is needed in most cases. */
2787      OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2788      jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
2789      if (!update_str_ptr)
2790        {
2791        OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2792        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2793        OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2794        OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
2795        OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2796        OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
2797        OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
2798        jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);
2799        OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2800        JUMPHERE(jump2);
2801        }
2802      else
2803        add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
2804      JUMPHERE(jump);
2805      return;
2806      }
2807    #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
2808    
2809    #if !defined COMPILE_PCRE8
2810    /* The ctypes array contains only 256 values. */
2811    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
2812    jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);
2813    #endif
2814    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
2815    #if !defined COMPILE_PCRE8
2816    JUMPHERE(jump);
2817    #endif
2818    
2819    #if defined SUPPORT_UTF && defined COMPILE_PCRE16
2820    if (common->utf && update_str_ptr)
2821      {
2822      /* Skip low surrogate if necessary. */
2823      OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800);
2824      jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
2825      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2826      JUMPHERE(jump);
2827      }
2828    #endif /* SUPPORT_UTF && COMPILE_PCRE16 */
2829    }
2830    
2831    static void skip_char_back(compiler_common *common)
2832  {  {
2833  /* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */  /* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */
2834  DEFINE_COMPILER;  DEFINE_COMPILER;
# Line 2478  if (common->utf) Line 2842  if (common->utf)
2842    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
2843    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));
2844    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
2845    CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);    CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
2846    return;    return;
2847    }    }
2848  #elif defined COMPILE_PCRE16  #elif defined COMPILE_PCRE16
# Line 2489  if (common->utf) Line 2853  if (common->utf)
2853    /* Skip low surrogate if necessary. */    /* Skip low surrogate if necessary. */
2854    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
2855    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);
2856    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
2857    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
2858    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
2859    return;    return;
# Line 2499  if (common->utf) Line 2863  if (common->utf)
2863  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));
2864  }  }
2865    
2866  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)
2867  {  {
2868  /* 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. */
2869  DEFINE_COMPILER;  DEFINE_COMPILER;
2870    struct sljit_jump *jump;
2871    
2872  if (nltype == NLTYPE_ANY)  if (nltype == NLTYPE_ANY)
2873    {    {
2874    add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
2875    add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));    add_jump(compiler, backtracks, JUMP(jumpifmatch ? SLJIT_NOT_ZERO : SLJIT_ZERO));
2876    }    }
2877  else if (nltype == NLTYPE_ANYCRLF)  else if (nltype == NLTYPE_ANYCRLF)
2878    {    {
2879    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_CR);    if (jumpifmatch)
2880    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);      {
2881    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);      add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR));
2882    OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);      add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
2883    add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));      }
2884      else
2885        {
2886        jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
2887        add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
2888        JUMPHERE(jump);
2889        }
2890    }    }
2891  else  else
2892    {    {
2893    SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);    SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);
2894    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_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
2895    }    }
2896  }  }
2897    
# Line 2530  else Line 2901  else
2901  static void do_utfreadchar(compiler_common *common)  static void do_utfreadchar(compiler_common *common)
2902  {  {
2903  /* Fast decoding a UTF-8 character. TMP1 contains the first byte  /* Fast decoding a UTF-8 character. TMP1 contains the first byte
2904  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. */
2905  DEFINE_COMPILER;  DEFINE_COMPILER;
2906  struct sljit_jump *jump;  struct sljit_jump *jump;
2907    
2908  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
2909  /* Searching for the first zero. */  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2910  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
 jump = JUMP(SLJIT_C_NOT_ZERO);  
 /* Two byte sequence. */  
 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  
 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1f);  
2911  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2912  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2913  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2914  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));  
2915    /* Searching for the first zero. */
2916    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
2917    jump = JUMP(SLJIT_NOT_ZERO);
2918    /* Two byte sequence. */
2919    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2920    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
2921  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 JUMPHERE(jump);  
2922    
2923  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10);  JUMPHERE(jump);
 jump = JUMP(SLJIT_C_NOT_ZERO);  
 /* Three byte sequence. */  
2924  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
2925  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0f);  OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
2926  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12);  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2927  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);  
2928  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2929  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));  
2930    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10000);
2931    jump = JUMP(SLJIT_NOT_ZERO);
2932    /* Three byte sequence. */
2933  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));
2934  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));  
2935  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 JUMPHERE(jump);  
2936    
2937  /* Four byte sequence. */  /* Four byte sequence. */
2938  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  JUMPHERE(jump);
2939  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x07);  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
2940  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 18);  OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
2941    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2942    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
2943  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);  
2944  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2945  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(4));
2946    sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2947    }
2948    
2949    static void do_utfreadchar16(compiler_common *common)
2950    {
2951    /* Fast decoding a UTF-8 character. TMP1 contains the first byte
2952    of the character (>= 0xc0). Return value in TMP1. */
2953    DEFINE_COMPILER;
2954    struct sljit_jump *jump;
2955    
2956    sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
2957    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2958    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
2959    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2960  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);  
2961  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2962  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(3));  
2963  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));  /* Searching for the first zero. */
2964    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
2965    jump = JUMP(SLJIT_NOT_ZERO);
2966    /* Two byte sequence. */
2967    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
2968    sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2969    
2970    JUMPHERE(jump);
2971    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x400);
2972    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_NOT_ZERO);
2973    /* This code runs only in 8 bit mode. No need to shift the value. */
2974    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2975    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
2976    OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
2977    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
2978  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
2979  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
2980  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));  /* Three byte sequence. */
2981    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
2982  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2983  }  }
2984    
# Line 2596  struct sljit_jump *compare; Line 2993  struct sljit_jump *compare;
2993  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
2994    
2995  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
2996  jump = JUMP(SLJIT_C_NOT_ZERO);  jump = JUMP(SLJIT_NOT_ZERO);
2997  /* Two byte sequence. */  /* Two byte sequence. */
2998  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
2999  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));
3000  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);
3001    /* The upper 5 bits are known at this point. */
3002    compare = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x3);
3003  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
3004  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
3005  OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);  OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
 compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);  
3006  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
3007  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
3008    
3009  JUMPHERE(compare);  JUMPHERE(compare);
3010  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
3011  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
 JUMPHERE(jump);  
3012    
3013  /* We only have types for characters less than 256. */  /* We only have types for characters less than 256. */
 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);  
 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);  
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);  
 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  
 }  
   
 #elif defined COMPILE_PCRE16  
   
 static void do_utfreadchar(compiler_common *common)  
 {  
 /* Fast decoding a UTF-16 character. TMP1 contains the first 16 bit char  
 of the character (>= 0xd800). Return char value in TMP1, length - 1 in TMP2. */  
 DEFINE_COMPILER;  
 struct sljit_jump *jump;  
   
 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);  
 jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xdc00);  
 /* Do nothing, only return. */  
 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  
   
3014  JUMPHERE(jump);  JUMPHERE(jump);
3015  /* Combine two 16 bit characters. */  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
3016  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
3017  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);  
3018  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
3019  }  }
3020    
3021  #endif /* COMPILE_PCRE[8|16] */  #endif /* COMPILE_PCRE8 */
3022    
3023  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
3024    
# Line 2708  if (firstline) Line 3079  if (firstline)
3079      {      {
3080      mainloop = LABEL();      mainloop = LABEL();
3081      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));
3082      end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);      end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3083      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
3084      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
3085      CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);      CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
3086      CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);      CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
3087      JUMPHERE(end);      JUMPHERE(end);
3088      OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));      OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
3089      }      }
3090    else    else
3091      {      {
3092      end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);      end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3093      mainloop = LABEL();      mainloop = LABEL();
3094      /* Continual stores does not cause data dependency. */      /* Continual stores does not cause data dependency. */
3095      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->first_line_end, STR_PTR, 0);
3096      read_char(common);      read_char_range(common, common->nlmin, common->nlmax, TRUE);
3097      check_newlinechar(common, common->nltype, &newline, TRUE);      check_newlinechar(common, common->nltype, &newline, TRUE);
3098      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);      CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, mainloop);
3099      JUMPHERE(end);      JUMPHERE(end);
3100      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->first_line_end, STR_PTR, 0);
3101      set_jumps(newline, LABEL());      set_jumps(newline, LABEL());
3102      }      }
3103    
# Line 2739  if (newlinecheck) Line 3110  if (newlinecheck)
3110    {    {
3111    newlinelabel = LABEL();    newlinelabel = LABEL();
3112    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));
3113    end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);    end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3114    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
3115    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);
3116    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
3117  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
3118    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
3119  #endif  #endif
# Line 2762  if (readuchar) Line 3133  if (readuchar)
3133    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
3134    
3135  if (newlinecheck)  if (newlinecheck)
3136    CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);    CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
3137    
3138  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));
3139  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
3140  #if defined COMPILE_PCRE8  #if defined COMPILE_PCRE8
3141  if (common->utf)  if (common->utf)
3142    {    {
3143    singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);    singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
3144    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
3145    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
3146    JUMPHERE(singlechar);    JUMPHERE(singlechar);
# Line 2777  if (common->utf) Line 3148  if (common->utf)
3148  #elif defined COMPILE_PCRE16  #elif defined COMPILE_PCRE16
3149  if (common->utf)  if (common->utf)
3150    {    {
3151    singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);    singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
3152    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
3153    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
3154    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
3155    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
3156    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
3157    JUMPHERE(singlechar);    JUMPHERE(singlechar);
# Line 2789  if (common->utf) Line 3160  if (common->utf)
3160  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */  #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
3161  JUMPHERE(start);  JUMPHERE(start);
3162    
3163  if (newlinecheck)  if (newlinecheck)
3164    {    {
3165    JUMPHERE(end);    JUMPHERE(end);
3166    JUMPHERE(nl);    JUMPHERE(nl);
3167    }    }
3168    
3169    return mainloop;
3170    }
3171    
3172    #define MAX_N_CHARS 16
3173    #define MAX_N_BYTES 8
3174    
3175    static SLJIT_INLINE void add_prefix_byte(pcre_uint8 byte, pcre_uint8 *bytes)
3176    {
3177    pcre_uint8 len = bytes[0];
3178    int i;
3179    
3180    if (len == 255)
3181      return;
3182    
3183    if (len == 0)
3184      {
3185      bytes[0] = 1;
3186      bytes[1] = byte;
3187      return;
3188      }
3189    
3190    for (i = len; i > 0; i--)
3191      if (bytes[i] == byte)
3192        return;
3193    
3194    if (len >= MAX_N_BYTES - 1)
3195      {
3196      bytes[0] = 255;
3197      return;
3198      }
3199    
3200    len++;
3201    bytes[len] = byte;
3202    bytes[0] = len;
3203    }
3204    
3205    static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uint32 *chars, pcre_uint8 *bytes, int max_chars)
3206    {
3207    /* Recursive function, which scans prefix literals. */
3208    BOOL last, any, caseless;
3209    int len, repeat, len_save, consumed = 0;
3210    pcre_uint32 chr, mask;
3211    pcre_uchar *alternative, *cc_save, *oc;
3212    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
3213    pcre_uchar othercase[8];
3214    #elif defined SUPPORT_UTF && defined COMPILE_PCRE16
3215    pcre_uchar othercase[2];
3216    #else
3217    pcre_uchar othercase[1];
3218    #endif
3219    
3220    repeat = 1;
3221    while (TRUE)
3222      {
3223      last = TRUE;
3224      any = FALSE;
3225      caseless = FALSE;
3226      switch (*cc)
3227        {
3228        case OP_CHARI:
3229        caseless = TRUE;
3230        case OP_CHAR:
3231        last = FALSE;
3232        cc++;
3233        break;
3234    
3235        case OP_SOD:
3236        case OP_SOM:
3237        case OP_SET_SOM:
3238        case OP_NOT_WORD_BOUNDARY:
3239        case OP_WORD_BOUNDARY:
3240        case OP_EODN:
3241        case OP_EOD:
3242        case OP_CIRC:
3243        case OP_CIRCM:
3244        case OP_DOLL:
3245        case OP_DOLLM:
3246        /* Zero width assertions. */
3247        cc++;
3248        continue;
3249    
3250        case OP_ASSERT:
3251        case OP_ASSERT_NOT:
3252        case OP_ASSERTBACK:
3253        case OP_ASSERTBACK_NOT:
3254        cc = bracketend(cc);
3255        continue;
3256    
3257        case OP_PLUSI:
3258        case OP_MINPLUSI:
3259        case OP_POSPLUSI:
3260        caseless = TRUE;
3261        case OP_PLUS:
3262        case OP_MINPLUS:
3263        case OP_POSPLUS:
3264        cc++;
3265        break;
3266    
3267        case OP_EXACTI:
3268        caseless = TRUE;
3269        case OP_EXACT:
3270        repeat = GET2(cc, 1);
3271        last = FALSE;
3272        cc += 1 + IMM2_SIZE;
3273        break;
3274    
3275        case OP_QUERYI:
3276        case OP_MINQUERYI:
3277        case OP_POSQUERYI:
3278        caseless = TRUE;
3279        case OP_QUERY:
3280        case OP_MINQUERY:
3281        case OP_POSQUERY:
3282        len = 1;
3283        cc++;
3284    #ifdef SUPPORT_UTF
3285        if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3286    #endif
3287        max_chars = scan_prefix(common, cc + len, chars, bytes, max_chars);
3288        if (max_chars == 0)
3289          return consumed;
3290        last = FALSE;
3291        break;
3292    
3293        case OP_KET:
3294        cc += 1 + LINK_SIZE;
3295        continue;
3296    
3297        case OP_ALT:
3298        cc += GET(cc, 1);
3299        continue;
3300    
3301        case OP_ONCE:
3302        case OP_ONCE_NC:
3303        case OP_BRA:
3304        case OP_BRAPOS:
3305        case OP_CBRA:
3306        case OP_CBRAPOS:
3307        alternative = cc + GET(cc, 1);
3308        while (*alternative == OP_ALT)
3309          {
3310          max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, bytes, max_chars);
3311          if (max_chars == 0)
3312            return consumed;
3313          alternative += GET(alternative, 1);
3314          }
3315    
3316        if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
3317          cc += IMM2_SIZE;
3318        cc += 1 + LINK_SIZE;
3319        continue;
3320    
3321        case OP_CLASS:
3322    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
3323        if (common->utf && !is_char7_bitset((const pcre_uint8 *)(cc + 1), FALSE)) return consumed;
3324    #endif
3325        any = TRUE;
3326        cc += 1 + 32 / sizeof(pcre_uchar);
3327        break;
3328    
3329        case OP_NCLASS:
3330    #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
3331        if (common->utf) return consumed;
3332    #endif
3333        any = TRUE;
3334        cc += 1 + 32 / sizeof(pcre_uchar);
3335        break;
3336    
3337    #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3338        case OP_XCLASS:
3339    #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
3340        if (common->utf) return consumed;
3341    #endif
3342        any = TRUE;
3343        cc += GET(cc, 1);
3344        break;
3345    #endif
3346    
3347        case OP_DIGIT:
3348    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
3349        if (common->utf && !is_char7_bitset((const pcre_uint8 *)common->ctypes - cbit_length + cbit_digit, FALSE))
3350          return consumed;
3351    #endif
3352        any = TRUE;
3353        cc++;
3354        break;
3355    
3356        case OP_WHITESPACE:
3357    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
3358        if (common->utf && !is_char7_bitset((const pcre_uint8 *)common->ctypes - cbit_length + cbit_space, FALSE))
3359          return consumed;
3360    #endif
3361        any = TRUE;
3362        cc++;
3363        break;
3364    
3365        case OP_WORDCHAR:
3366    #if defined SUPPORT_UTF && defined COMPILE_PCRE8
3367        if (common->utf && !is_char7_bitset((const pcre_uint8 *)common->ctypes - cbit_length + cbit_word, FALSE))
3368          return consumed;
3369    #endif
3370        any = TRUE;
3371        cc++;
3372        break;
3373    
3374        case OP_NOT:
3375        case OP_NOTI:
3376        cc++;
3377        /* Fall through. */
3378        case OP_NOT_DIGIT:
3379        case OP_NOT_WHITESPACE:
3380        case OP_NOT_WORDCHAR:
3381        case OP_ANY:
3382        case OP_ALLANY:
3383    #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
3384        if (common->utf) return consumed;
3385    #endif
3386        any = TRUE;
3387        cc++;
3388        break;
3389    
3390    #ifdef SUPPORT_UCP
3391        case OP_NOTPROP:
3392        case OP_PROP:
3393    #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
3394        if (common->utf) return consumed;
3395    #endif
3396        any = TRUE;
3397        cc += 1 + 2;
3398        break;
3399    #endif
3400    
3401        case OP_TYPEEXACT:
3402        repeat = GET2(cc, 1);
3403        cc += 1 + IMM2_SIZE;
3404        continue;
3405    
3406        case OP_NOTEXACT:
3407        case OP_NOTEXACTI:
3408    #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
3409        if (common->utf) return consumed;
3410    #endif
3411        any = TRUE;
3412        repeat = GET2(cc, 1);
3413        cc += 1 + IMM2_SIZE + 1;
3414        break;
3415    
3416        default:
3417        return consumed;
3418        }
3419    
3420      if (any)
3421        {
3422    #if defined COMPILE_PCRE8
3423        mask = 0xff;
3424    #elif defined COMPILE_PCRE16
3425        mask = 0xffff;
3426    #elif defined COMPILE_PCRE32
3427        mask = 0xffffffff;
3428    #else
3429        SLJIT_ASSERT_STOP();
3430    #endif
3431    
3432        do
3433          {
3434          chars[0] = mask;
3435          chars[1] = mask;
3436          bytes[0] = 255;
3437    
3438          consumed++;
3439          if (--max_chars == 0)
3440            return consumed;
3441          chars += 2;
3442          bytes += MAX_N_BYTES;
3443          }
3444        while (--repeat > 0);
3445    
3446        repeat = 1;
3447        continue;
3448        }
3449    
3450      len = 1;
3451    #ifdef SUPPORT_UTF
3452      if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3453    #endif
3454    
3455      if (caseless && char_has_othercase(common, cc))
3456        {
3457    #ifdef SUPPORT_UTF
3458        if (common->utf)
3459          {
3460          GETCHAR(chr, cc);
3461          if ((int)PRIV(ord2utf)(char_othercase(common, chr), othercase) != len)
3462            return consumed;
3463          }
3464        else
3465    #endif
3466          {
3467          chr = *cc;
3468          othercase[0] = TABLE_GET(chr, common->fcc, chr);
3469          }
3470        }
3471      else
3472        caseless = FALSE;
3473    
3474      len_save = len;
3475      cc_save = cc;
3476      while (TRUE)
3477        {
3478        oc = othercase;
3479        do
3480          {
3481          chr = *cc;
3482    #ifdef COMPILE_PCRE32
3483          if (SLJIT_UNLIKELY(chr == NOTACHAR))
3484            return consumed;
3485    #endif
3486          add_prefix_byte((pcre_uint8)chr, bytes);
3487    
3488          mask = 0;
3489          if (caseless)
3490            {
3491            add_prefix_byte((pcre_uint8)*oc, bytes);
3492            mask = *cc ^ *oc;
3493            chr |= mask;
3494            }
3495    
3496    #ifdef COMPILE_PCRE32
3497          if (chars[0] == NOTACHAR && chars[1] == 0)
3498    #else
3499          if (chars[0] == NOTACHAR)
3500    #endif
3501            {
3502            chars[0] = chr;
3503            chars[1] = mask;
3504            }
3505          else
3506            {
3507            mask |= chars[0] ^ chr;
3508            chr |= mask;
3509            chars[0] = chr;
3510            chars[1] |= mask;
3511            }
3512    
3513          len--;
3514          consumed++;
3515          if (--max_chars == 0)
3516            return consumed;
3517          chars += 2;
3518          bytes += MAX_N_BYTES;
3519          cc++;
3520          oc++;
3521          }
3522        while (len > 0);
3523    
3524  return mainloop;      if (--repeat == 0)
3525  }        break;
3526    
3527        len = len_save;
3528        cc = cc_save;
3529        }
3530    
3531  #define MAX_N_CHARS 3    repeat = 1;
3532      if (last)
3533        return consumed;
3534      }
3535    }
3536    
3537  static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)  static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
3538  {  {
# Line 2806  DEFINE_COMPILER; Line 3540  DEFINE_COMPILER;
3540  struct sljit_label *start;  struct sljit_label *start;
3541  struct sljit_jump *quit;  struct sljit_jump *quit;
3542  pcre_uint32 chars[MAX_N_CHARS * 2];  pcre_uint32 chars[MAX_N_CHARS * 2];
3543  pcre_uchar *cc = common->start + 1 + LINK_SIZE;  pcre_uint8 bytes[MAX_N_CHARS * MAX_N_BYTES];
3544  int location = 0;  pcre_uint8 ones[MAX_N_CHARS];
3545  pcre_int32 len, c, bit, caseless;  int offsets[3];
3546  int must_stop;  pcre_uint32 mask;
3547    pcre_uint8 *byte_set, *byte_set_end;
3548    int i, max, from;
3549    int range_right = -1, range_len = 3 - 1;
3550    sljit_ub *update_table = NULL;
3551    BOOL in_range;
3552    
3553    for (i = 0; i < MAX_N_CHARS; i++)
3554      {
3555      chars[i << 1] = NOTACHAR;
3556      chars[(i << 1) + 1] = 0;
3557      bytes[i * MAX_N_BYTES] = 0;
3558      }
3559    
3560  /* We do not support alternatives now. */  max = scan_prefix(common, common->start, chars, bytes, MAX_N_CHARS);
3561  if (*(common->start + GET(common->start, 1)) == OP_ALT)  
3562    if (max <= 1)
3563    return FALSE;    return FALSE;
3564    
3565  while (TRUE)  for (i = 0; i < max; i++)
3566    {    {
3567    caseless = 0;    mask = chars[(i << 1) + 1];
3568    must_stop = 1;    ones[i] = ones_in_half_byte[mask & 0xf];
3569    switch(*cc)    mask >>= 4;
3570      while (mask != 0)
3571      {      {
3572      case OP_CHAR:      ones[i] += ones_in_half_byte[mask & 0xf];
3573      must_stop = 0;      mask >>= 4;
3574      cc++;      }
3575      break;    }
   
     case OP_CHARI:  
     caseless = 1;  
     must_stop = 0;  
     cc++;  
     break;  
3576    
3577      case OP_SOD:  in_range = FALSE;
3578      case OP_SOM:  from = 0;   /* Prevent compiler "uninitialized" warning */
3579      case OP_SET_SOM:  for (i = 0; i <= max; i++)
3580      case OP_NOT_WORD_BOUNDARY:    {
3581      case OP_WORD_BOUNDARY:    if (in_range && (i - from) > range_len && (bytes[(i - 1) * MAX_N_BYTES] <= 4))
3582      case OP_EODN:      {
3583      case OP_EOD:      range_len = i - from;
3584      case OP_CIRC:      range_right = i - 1;
3585      case OP_CIRCM:      }
     case OP_DOLL:  
     case OP_DOLLM:  
     /* Zero width assertions. */  
     cc++;  
     continue;  
3586    
3587      case OP_PLUS:    if (i < max && bytes[i * MAX_N_BYTES] < 255)
3588      case OP_MINPLUS:      {
3589      case OP_POSPLUS:      if (!in_range)
3590      cc++;        {
3591      break;        in_range = TRUE;
3592          from = i;
3593          }
3594        }
3595      else if (in_range)
3596        in_range = FALSE;
3597      }
3598    
3599      case OP_EXACT:  if (range_right >= 0)
3600      cc += 1 + IMM2_SIZE;    {
3601      break;    update_table = (sljit_ub *)allocate_read_only_data(common, 256);
3602      if (update_table == NULL)
3603        return TRUE;
3604      memset(update_table, IN_UCHARS(range_len), 256);
3605    
3606      case OP_PLUSI:    for (i = 0; i < range_len; i++)
3607      case OP_MINPLUSI:      {
3608      case OP_POSPLUSI:      byte_set = bytes + ((range_right - i) * MAX_N_BYTES);
3609      caseless = 1;      SLJIT_ASSERT(byte_set[0] > 0 && byte_set[0] < 255);
3610      cc++;      byte_set_end = byte_set + byte_set[0];
3611      break;      byte_set++;
3612        while (byte_set <= byte_set_end)
3613          {
3614          if (update_table[*byte_set] > IN_UCHARS(i))
3615            update_table[*byte_set] = IN_UCHARS(i);
3616          byte_set++;
3617          }
3618        }
3619      }
3620    
3621      case OP_EXACTI:  offsets[0] = -1;
3622      caseless = 1;  /* Scan forward. */
3623      cc += 1 + IMM2_SIZE;  for (i = 0; i < max; i++)
3624      if (ones[i] <= 2) {
3625        offsets[0] = i;
3626      break;      break;
3627      }
3628    
3629      default:  if (offsets[0] < 0 && range_right < 0)
3630      must_stop = 2;    return FALSE;
     break;  
     }  
3631    
3632    if (must_stop == 2)  if (offsets[0] >= 0)
3633      {
3634      /* Scan backward. */
3635      offsets[1] = -1;
3636      for (i = max - 1; i > offsets[0]; i--)
3637        if (ones[i] <= 2 && i != range_right)
3638          {
3639          offsets[1] = i;
3640        break;        break;
3641          }
3642    
3643    len = 1;    /* This case is handled better by fast_forward_first_char. */
3644  #ifdef SUPPORT_UTF    if (offsets[1] == -1 && offsets[0] == 0 && range_right < 0)
3645    if (common->utf && HAS_EXTRALEN(cc[0])) len += GET_EXTRALEN(cc[0]);      return FALSE;
 #endif  
3646    
3647    if (caseless && char_has_othercase(common, cc))    offsets[2] = -1;
3648      {    /* We only search for a middle character if there is no range check. */
3649      caseless = char_get_othercase_bit(common, cc);    if (offsets[1] >= 0 && range_right == -1)
3650      if (caseless == 0)      {
3651        return FALSE;      /* Scan from middle. */
3652  #ifdef COMPILE_PCRE8      for (i = (offsets[0] + offsets[1]) / 2 + 1; i < offsets[1]; i++)
3653      caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));        if (ones[i] <= 2)
3654  #else          {
3655      if ((caseless & 0x100) != 0)          offsets[2] = i;
3656        caseless = ((caseless & 0xff) << 16) | (len - (caseless >> 9));          break;
3657      else          }
       caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 9));  
 #endif  
     }  
   else  
     caseless = 0;  
3658    
3659    while (len > 0 && location < MAX_N_CHARS * 2)      if (offsets[2] == -1)
     {  
     c = *cc;  
     bit = 0;  
     if (len == (caseless & 0xff))  
3660        {        {
3661        bit = caseless >> 8;        for (i = (offsets[0] + offsets[1]) / 2; i > offsets[0]; i--)
3662        c |= bit;          if (ones[i] <= 2)
3663              {
3664              offsets[2] = i;
3665              break;
3666              }
3667        }        }
3668        }
3669    
3670      chars[location] = c;    SLJIT_ASSERT(offsets[1] == -1 || (offsets[0] < offsets[1]));
3671      chars[location + 1] = bit;    SLJIT_ASSERT(offsets[2] == -1 || (offsets[0] < offsets[2] && offsets[1] > offsets[2]));
3672    
3673      len--;    chars[0] = chars[offsets[0] << 1];
3674      location += 2;    chars[1] = chars[(offsets[0] << 1) + 1];
3675      cc++;    if (offsets[2] >= 0)
3676        {
3677        chars[2] = chars[offsets[2] << 1];
3678        chars[3] = chars[(offsets[2] << 1) + 1];
3679        }
3680      if (offsets[1] >= 0)
3681        {
3682        chars[4] = chars[offsets[1] << 1];
3683        chars[5] = chars[(offsets[1] << 1) + 1];
3684      }      }
   
   if (location >= MAX_N_CHARS * 2 || must_stop != 0)  
     break;  
3685    }    }
3686    
3687  /* At least two characters are required. */  max -= 1;
 if (location < 2 * 2)  
     return FALSE;  
   
3688  if (firstline)  if (firstline)
3689    {    {
3690    SLJIT_ASSERT(common->first_line_end != 0);    SLJIT_ASSERT(common->first_line_end != 0);
3691      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
3692    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
3693    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, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
3694      quit = CMP(SLJIT_LESS_EQUAL, STR_END, 0, TMP1, 0);
3695      OP1(SLJIT_MOV, STR_END, 0, TMP1, 0);
3696      JUMPHERE(quit);
3697    }    }
3698  else  else
3699    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));
3700    
3701    #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3702    if (range_right >= 0)
3703      OP1(SLJIT_MOV, RETURN_ADDR, 0, SLJIT_IMM, (sljit_sw)update_table);
3704    #endif
3705    
3706  start = LABEL();  start = LABEL();
3707  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);  quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3708    
3709  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));  SLJIT_ASSERT(range_right >= 0 || offsets[0] >= 0);
3710  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  
3711  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  if (range_right >= 0)
3712  if (chars[1] != 0)    {
3713    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);  #if defined COMPILE_PCRE8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
3714  CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right));
3715  if (location > 2 * 2)  #else
3716    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right + 1) - 1);
3717  if (chars[3] != 0)  #endif
3718    OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[3]);  
3719  CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[2], start);  #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3720  if (location > 2 * 2)    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(RETURN_ADDR, TMP1), 0);
3721    {  #else
3722    if (chars[5] != 0)    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)update_table);
3723      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[5]);  #endif
3724    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[4], start);    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
3725      CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start);
3726      }
3727    
3728    if (offsets[0] >= 0)
3729      {
3730      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[0]));
3731      if (offsets[1] >= 0)
3732        OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[1]));
3733      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
3734    
3735      if (chars[1] != 0)
3736        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
3737      CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
3738      if (offsets[2] >= 0)
3739        OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[2] - 1));
3740    
3741      if (offsets[1] >= 0)
3742        {
3743        if (chars[5] != 0)
3744          OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[5]);
3745        CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[4], start);
3746        }
3747    
3748      if (offsets[2] >= 0)
3749        {
3750        if (chars[3] != 0)
3751          OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[3]);
3752        CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[2], start);
3753        }
3754      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
3755    }    }
 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  
3756    
3757  JUMPHERE(quit);  JUMPHERE(quit);
3758    
3759  if (firstline)  if (firstline)
3760      {
3761      if (range_right >= 0)
3762        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
3763    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
3764      if (range_right >= 0)
3765        {
3766        quit = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
3767        OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
3768        JUMPHERE(quit);
3769        }
3770      }
3771  else  else
3772    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));
3773  return TRUE;  return TRUE;
3774  }  }
3775    
3776  #undef MAX_N_CHARS  #undef MAX_N_CHARS
3777    #undef MAX_N_BYTES
3778    
3779  static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)  static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)
3780  {  {
# Line 2979  if (firstline) Line 3788  if (firstline)
3788    {    {
3789    SLJIT_ASSERT(common->first_line_end != 0);    SLJIT_ASSERT(common->first_line_end != 0);
3790    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
3791    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
3792    }    }
3793    
3794  start = LABEL();  start = LABEL();
3795  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);  quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3796  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
3797    
3798  oc = first_char;  oc = first_char;
# Line 2996  if (caseless) Line 3805  if (caseless)
3805  #endif  #endif
3806    }    }
3807  if (first_char == oc)  if (first_char == oc)
3808    found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, first_char);    found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, first_char);
3809  else  else
3810    {    {
3811    bit = first_char ^ oc;    bit = first_char ^ oc;
3812    if (is_powerof2(bit))    if (is_powerof2(bit))
3813      {      {
3814      OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);      OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);
3815      found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, first_char | bit);      found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, first_char | bit);
3816      }      }
3817    else    else
3818      {      {
3819      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, first_char);      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, first_char);
3820      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
3821      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);
3822      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_EQUAL);
3823      found = JUMP(SLJIT_C_NOT_ZERO);      found = JUMP(SLJIT_NOT_ZERO);
3824      }      }
3825    }    }
3826    
# Line 3039  if (firstline) Line 3848  if (firstline)
3848    {    {
3849    SLJIT_ASSERT(common->first_line_end != 0);    SLJIT_ASSERT(common->first_line_end != 0);
3850    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);    OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
3851    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
3852    }    }
3853    
3854  if (common->nltype == NLTYPE_FIXED && common->newline > 255)  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
3855    {    {
3856    lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);    lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3857    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
3858    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
3859    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
3860    firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);    firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
3861    
3862    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));
3863    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);
3864    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER_EQUAL);    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_GREATER_EQUAL);
3865  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
3866    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
3867  #endif  #endif
# Line 3060  if (common->nltype == NLTYPE_FIXED && co Line 3869  if (common->nltype == NLTYPE_FIXED && co
3869    
3870    loop = LABEL();    loop = LABEL();
3871    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));
3872    quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);    quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3873    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
3874    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
3875    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);    CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);
3876    CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);    CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);
3877    
3878    JUMPHERE(quit);    JUMPHERE(quit);
3879    JUMPHERE(firstchar);    JUMPHERE(firstchar);
3880    JUMPHERE(lastchar);    JUMPHERE(lastchar);
3881    
3882    if (firstline)    if (firstline)
3883      OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);      OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
3884    return;    return;
3885    }    }
3886    
3887  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
3888  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
3889  firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);  firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
3890  skip_char_back(common);  skip_char_back(common);
3891    
3892  loop = LABEL();  loop = LABEL();
3893  read_char(common);  common->ff_newline_shortcut = loop;
3894  lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);  
3895    read_char_range(common, common->nlmin, common->nlmax, TRUE);
3896    lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3897  if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)  if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
3898    foundcr = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);    foundcr = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
3899  check_newlinechar(common, common->nltype, &newline, FALSE);  check_newlinechar(common, common->nltype, &newline, FALSE);
3900  set_jumps(newline, loop);  set_jumps(newline, loop);
3901    
# Line 3092  if (common->nltype == NLTYPE_ANY || comm Line 3903  if (common->nltype == NLTYPE_ANY || comm
3903    {    {
3904    quit = JUMP(SLJIT_JUMP);    quit = JUMP(SLJIT_JUMP);
3905    JUMPHERE(foundcr);    JUMPHERE(foundcr);
3906    notfoundnl = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);    notfoundnl = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3907    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
3908    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
3909    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
3910  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
3911    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
3912  #endif  #endif
# Line 3110  if (firstline) Line 3921  if (firstline)
3921    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
3922  }  }
3923    
3924  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);
3925    
3926  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)
3927  {  {
3928  DEFINE_COMPILER;  DEFINE_COMPILER;
3929  struct sljit_label *start;  struct sljit_label *start;
3930  struct sljit_jump *quit;  struct sljit_jump *quit;
3931  struct sljit_jump *found = NULL;  struct sljit_jump *found = NULL;
3932  jump_list *matches = NULL;  jump_list *matches = NULL;
 pcre_uint8 inverted_start_bits[32];  
 int i;  
3933  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
3934  struct sljit_jump *jump;  struct sljit_jump *jump;
3935  #endif  #endif
3936    
 for (i = 0; i < 32; ++i)  
   inverted_start_bits[i] = ~(((pcre_uint8*)start_bits)[i]);  
   
3937  if (firstline)  if (firstline)
3938    {    {
3939    SLJIT_ASSERT(common->first_line_end != 0);    SLJIT_ASSERT(common->first_line_end != 0);
3940    OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);    OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);
3941    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
3942    }    }
3943    
3944  start = LABEL();  start = LABEL();
3945  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);  quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3946  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
3947  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3948  if (common->utf)  if (common->utf)
3949    OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);    OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
3950  #endif  #endif
3951    
3952  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))
3953    {    {
3954  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
3955    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 255);    jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 255);
3956    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);
3957    JUMPHERE(jump);    JUMPHERE(jump);
3958  #endif  #endif
3959    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
3960    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
3961    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), start_bits);    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)start_bits);
3962    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
3963    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);
3964    found = JUMP(SLJIT_C_NOT_ZERO);    found = JUMP(SLJIT_NOT_ZERO);
3965    }    }
3966    
3967  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 3167  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, S Line 3973  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, S
3973  #if defined COMPILE_PCRE8  #if defined COMPILE_PCRE8
3974  if (common->utf)  if (common->utf)
3975    {    {
3976    CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);    CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
3977    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
3978    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
3979    }    }
3980  #elif defined COMPILE_PCRE16  #elif defined COMPILE_PCRE16
3981  if (common->utf)  if (common->utf)
3982    {    {
3983    CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);    CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
3984    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
3985    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
3986    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
3987    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
3988    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
3989    }    }
# Line 3206  struct sljit_jump *notfound; Line 4012  struct sljit_jump *notfound;
4012  pcre_uint32 oc, bit;  pcre_uint32 oc, bit;
4013    
4014  SLJIT_ASSERT(common->req_char_ptr != 0);  SLJIT_ASSERT(common->req_char_ptr != 0);
4015  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr);
4016  OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);  OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);
4017  toolong = CMP(SLJIT_C_LESS, TMP1, 0, STR_END, 0);  toolong = CMP(SLJIT_LESS, TMP1, 0, STR_END, 0);
4018  alreadyfound = CMP(SLJIT_C_LESS, STR_PTR, 0, TMP2, 0);  alreadyfound = CMP(SLJIT_LESS, STR_PTR, 0, TMP2, 0);
4019    
4020  if (has_firstchar)  if (has_firstchar)
4021    OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));    OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
# Line 3217  else Line 4023  else
4023    OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);    OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);
4024    
4025  loop = LABEL();  loop = LABEL();
4026  notfound = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, STR_END, 0);  notfound = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, STR_END, 0);
4027    
4028  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);
4029  oc = req_char;  oc = req_char;
# Line 3230  if (caseless) Line 4036  if (caseless)
4036  #endif  #endif
4037    }    }
4038  if (req_char == oc)  if (req_char == oc)
4039    found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);    found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
4040  else  else
4041    {    {
4042    bit = req_char ^ oc;    bit = req_char ^ oc;
4043    if (is_powerof2(bit))    if (is_powerof2(bit))
4044      {      {
4045      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
4046      found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);      found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
4047      }      }
4048    else    else
4049      {      {
4050      found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);      found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
4051      foundoc = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, oc);      foundoc = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, oc);
4052      }      }
4053    }    }
4054  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
# Line 3251  JUMPTO(SLJIT_JUMP, loop); Line 4057  JUMPTO(SLJIT_JUMP, loop);
4057  JUMPHERE(found);  JUMPHERE(found);
4058  if (foundoc)  if (foundoc)
4059    JUMPHERE(foundoc);    JUMPHERE(foundoc);
4060  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr, TMP1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, TMP1, 0);
4061  JUMPHERE(alreadyfound);  JUMPHERE(alreadyfound);
4062  JUMPHERE(toolong);  JUMPHERE(toolong);
4063  return notfound;  return notfound;
# Line 3271  GET_LOCAL_BASE(TMP3, 0, 0); Line 4077  GET_LOCAL_BASE(TMP3, 0, 0);
4077  mainloop = LABEL();  mainloop = LABEL();
4078  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
4079  OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);  OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);
4080  jump = JUMP(SLJIT_C_SIG_LESS_EQUAL);  jump = JUMP(SLJIT_SIG_LESS_EQUAL);
4081    
4082  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
4083  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
# Line 3280  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I Line 4086  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
4086  JUMPTO(SLJIT_JUMP, mainloop);  JUMPTO(SLJIT_JUMP, mainloop);
4087    
4088  JUMPHERE(jump);  JUMPHERE(jump);
4089  jump = JUMP(SLJIT_C_SIG_LESS);  jump = JUMP(SLJIT_SIG_LESS);
4090  /* End of dropping frames. */  /* End of dropping frames. */
4091  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
4092    
# Line 3303  struct sljit_jump *jump; Line 4109  struct sljit_jump *jump;
4109    
4110  SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);  SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);
4111    
4112  sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);  sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
4113  /* Get type of the previous char, and put it to LOCALS1. */  /* Get type of the previous char, and put it to LOCALS1. */
4114  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
4115  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
4116  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, SLJIT_IMM, 0);
4117  skipread = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);  skipread = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
4118  skip_char_back(common);  skip_char_back(common);
4119  check_start_used_ptr(common);  check_start_used_ptr(common);
4120  read_char(common);  read_char(common);
# Line 3318  read_char(common); Line 4124  read_char(common);
4124  if (common->use_ucp)  if (common->use_ucp)
4125    {    {
4126    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
4127    jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);    jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
4128    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
4129    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
4130    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
4131    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
4132    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
4133    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
4134    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
4135    JUMPHERE(jump);    JUMPHERE(jump);
4136    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP2, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP2, 0);
4137    }    }
4138  else  else
4139  #endif  #endif
4140    {    {
4141  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
4142    jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);    jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
4143  #elif defined SUPPORT_UTF  #elif defined SUPPORT_UTF
4144    /* Here LOCALS1 has already been zeroed. */    /* Here LOCALS1 has already been zeroed. */
4145    jump = NULL;    jump = NULL;
4146    if (common->utf)    if (common->utf)
4147      jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);      jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
4148  #endif /* COMPILE_PCRE8 */  #endif /* COMPILE_PCRE8 */
4149    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);
4150    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);
4151    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
4152    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);
4153  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
4154    JUMPHERE(jump);    JUMPHERE(jump);
4155  #elif defined SUPPORT_UTF  #elif defined SUPPORT_UTF
# Line 3355  JUMPHERE(skipread); Line 4161  JUMPHERE(skipread);
4161    
4162  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
4163  check_str_end(common, &skipread_list);  check_str_end(common, &skipread_list);
4164  peek_char(common);  peek_char(common, READ_CHAR_MAX);
4165    
4166  /* Testing char type. This is a code duplication. */  /* Testing char type. This is a code duplication. */
4167  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
4168  if (common->use_ucp)  if (common->use_ucp)
4169    {    {
4170    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
4171    jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);    jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
4172    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
4173    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
4174    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
4175    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
4176    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
4177    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
4178    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
4179    JUMPHERE(jump);    JUMPHERE(jump);
4180    }    }
4181  else  else
# Line 3378  else Line 4184  else
4184  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
4185    /* TMP2 may be destroyed by peek_char. */    /* TMP2 may be destroyed by peek_char. */
4186    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
4187    jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);    jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
4188  #elif defined SUPPORT_UTF  #elif defined SUPPORT_UTF
4189    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
4190    jump = NULL;    jump = NULL;
4191    if (common->utf)    if (common->utf)
4192      jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);      jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
4193  #endif  #endif
4194    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);
4195    OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);    OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);
# Line 3397  else Line 4203  else
4203    }    }
4204  set_jumps(skipread_list, LABEL());  set_jumps(skipread_list, LABEL());
4205    
4206  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
4207  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
4208  }  }
4209    
4210  /*  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)  
4211  {  {
4212  DEFINE_COMPILER;  DEFINE_COMPILER;
4213  struct sljit_jump *jump;  int ranges[MAX_RANGE_SIZE];
   
 if (ranges[0] < 0)  
   return FALSE;  
   
 switch(ranges[0])  
   {  
   case 1:  
   if (readch)  
     read_char(common);  
   add_jump(compiler, backtracks, CMP(ranges[1] == 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));  
   return TRUE;  
   
   case 2:  
   if (readch)  
     read_char(common);  
   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);  
   add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));  
   return TRUE;  
   
   case 4:  
   if (ranges[2] + 1 == ranges[3] && ranges[4] + 1 == ranges[5])  
     {  
     if (readch)  
       read_char(common);  
     if (ranges[1] != 0)  
       {  
       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));  
       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));  
       }  
     else  
       {  
       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]));  
     return TRUE;  
     }  
   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;  
   
 for (i = 1; i < 256; i++)  
   if ((ctypes[i] & flag) != bit)  
     {  
     if (length >= MAX_RANGE_SIZE)  
       return;  
     ranges[2 + length] = i;  
     length++;  
     bit ^= flag;  
     }  
   
 if (bit != 0)  
   {  
   if (length >= MAX_RANGE_SIZE)  
     return;  
   ranges[2 + length] = 256;  
   length++;  
   }  
 ranges[0] = length;  
 }  
   
 static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks)  
 {  
 int ranges[2 + MAX_RANGE_SIZE];  
4214  pcre_uint8 bit, cbit, all;  pcre_uint8 bit, cbit, all;
4215  int i, byte, length = 0;  int i, byte, length = 0;
4216    
4217  bit = bits[0] & 0x1;  bit = bits[0] & 0x1;
4218  ranges[1] = bit;  /* All bits will be zero or one (since bit is zero or one). */
 /* Can be 0 or 255. */  
4219  all = -bit;  all = -bit;
4220    
4221  for (i = 0; i < 256; )  for (i = 0; i < 256; )
# Line 3519  for (i = 0; i < 256; ) Line 4230  for (i = 0; i < 256; )
4230        {        {
4231        if (length >= MAX_RANGE_SIZE)        if (length >= MAX_RANGE_SIZE)
4232          return FALSE;          return FALSE;
4233        ranges[2 + length] = i;        ranges[length] = i;
4234        length++;        length++;
4235        bit = cbit;        bit = cbit;
4236        all = -cbit;        all = -cbit;
# Line 3532  if (((bit == 0) && nclass) || ((bit == 1 Line 4243  if (((bit == 0) && nclass) || ((bit == 1
4243    {    {
4244    if (length >= MAX_RANGE_SIZE)    if (length >= MAX_RANGE_SIZE)
4245      return FALSE;      return FALSE;
4246    ranges[2 + length] = 256;    ranges[length] = 256;
4247    length++;    length++;
4248    }    }
 ranges[0] = length;  
4249    
4250  return check_ranges(common, ranges, backtracks, FALSE);  if (length < 0 || length > 4)
4251      return FALSE;
4252    
4253    bit = bits[0] & 0x1;
4254    if (invert) bit ^= 0x1;
4255    
4256    /* No character is accepted. */
4257    if (length == 0 && bit == 0)
4258      add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
4259    
4260    switch(length)
4261      {
4262      case 0:
4263      /* When bit != 0, all characters are accepted. */
4264      return TRUE;
4265    
4266      case 1:
4267      add_jump(compiler, backtracks, CMP(bit == 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
4268      return TRUE;
4269    
4270      case 2:
4271      if (ranges[0] + 1 != ranges[1])
4272        {
4273        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
4274        add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
4275        }
4276      else
4277        add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
4278      return TRUE;
4279    
4280      case 3:
4281      if (bit != 0)
4282        {
4283        add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
4284        if (ranges[0] + 1 != ranges[1])
4285          {
4286          OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
4287          add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
4288          }
4289        else
4290          add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
4291        return TRUE;
4292        }
4293    
4294      add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[0]));
4295      if (ranges[1] + 1 != ranges[2])
4296        {
4297        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1]);
4298        add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
4299        }
4300      else
4301        add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1]));
4302      return TRUE;
4303    
4304      case 4:
4305      if ((ranges[1] - ranges[0]) == (ranges[3] - ranges[2])
4306          && (ranges[0] | (ranges[2] - ranges[0])) == ranges[2]
4307          && is_powerof2(ranges[2] - ranges[0]))
4308        {
4309        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[0]);
4310        if (ranges[2] + 1 != ranges[3])
4311          {
4312          OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);
4313          add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
4314          }
4315        else
4316          add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
4317        return TRUE;
4318        }
4319    
4320      if (bit != 0)
4321        {
4322        i = 0;
4323        if (ranges[0] + 1 != ranges[1])
4324          {
4325          OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
4326          add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
4327          i = ranges[0];
4328          }
4329        else
4330          add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
4331    
4332        if (ranges[2] + 1 != ranges[3])
4333          {
4334          OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - i);
4335          add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
4336          }
4337        else
4338          add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2] - i));
4339        return TRUE;
4340        }
4341    
4342      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
4343      add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[0]));
4344      if (ranges[1] + 1 != ranges[2])
4345        {
4346        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]);
4347        add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
4348        }
4349      else
4350        add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
4351      return TRUE;
4352    
4353      default:
4354      SLJIT_ASSERT_STOP();
4355      return FALSE;
4356      }
4357  }  }
4358    
4359  static void check_anynewline(compiler_common *common)  static void check_anynewline(compiler_common *common)
# Line 3549  sljit_emit_fast_enter(compiler, RETURN_A Line 4365  sljit_emit_fast_enter(compiler, RETURN_A
4365    
4366  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
4367  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
4368  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
4369  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
4370  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4371  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
4372  if (common->utf)  if (common->utf)
4373    {    {
4374  #endif  #endif
4375    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
4376    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
4377    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
4378  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
4379    }    }
4380  #endif  #endif
4381  #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */  #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
4382  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_EQUAL);
4383  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
4384  }  }
4385    
# Line 3575  DEFINE_COMPILER; Line 4391  DEFINE_COMPILER;
4391  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
4392    
4393  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);
4394  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
4395  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
4396  OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);  OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
4397  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);
4398  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4399  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
4400  if (common->utf)  if (common->utf)
4401    {    {
4402  #endif  #endif
4403    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
4404    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);
4405    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
4406    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);
4407    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
4408    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);
4409    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);
4410    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
4411    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);
4412    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
4413    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);
4414    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);    OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
4415    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);
4416  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
4417    }    }
4418  #endif  #endif
4419  #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */  #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
4420  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_EQUAL);
4421    
4422  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
4423  }  }
# Line 3615  sljit_emit_fast_enter(compiler, RETURN_A Line 4431  sljit_emit_fast_enter(compiler, RETURN_A
4431    
4432  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
4433  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
4434  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
4435  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
4436  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4437  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
4438  if (common->utf)  if (common->utf)
4439    {    {
4440  #endif  #endif
4441    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_EQUAL);
4442    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
4443    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
4444  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
4445    }    }
4446  #endif  #endif
4447  #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */  #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
4448  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_EQUAL);
4449    
4450  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
4451  }  }
# Line 3646  struct sljit_label *label; Line 4462  struct sljit_label *label;
4462  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);  sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
4463  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
4464  OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);  OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);
4465  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR2, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, CHAR2, 0);
4466  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
4467  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));
4468    
4469  label = LABEL();  label = LABEL();
4470  OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));  OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));
4471  OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
4472  jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);  jump = CMP(SLJIT_NOT_EQUAL, CHAR1, 0, CHAR2, 0);
4473  OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
4474  JUMPTO(SLJIT_C_NOT_ZERO, label);  JUMPTO(SLJIT_NOT_ZERO, label);
4475    
4476  JUMPHERE(jump);  JUMPHERE(jump);
4477  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));
4478  OP1(SLJIT_MOV, CHAR1, 0, TMP3, 0);  OP1(SLJIT_MOV, CHAR1, 0, TMP3, 0);
4479  OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);  OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
4480  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
4481  }  }
4482    
# Line 3676  sljit_emit_fast_enter(compiler, RETURN_A Line 4492  sljit_emit_fast_enter(compiler, RETURN_A
4492  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
4493    
4494  OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);  OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);
4495  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, CHAR1, 0);
4496  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, CHAR2, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, CHAR2, 0);
4497  OP1(SLJIT_MOV, LCC_TABLE, 0, SLJIT_IMM, common->lcc);  OP1(SLJIT_MOV, LCC_TABLE, 0, SLJIT_IMM, common->lcc);
4498  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
4499  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));
# Line 3686  label = LABEL(); Line 4502  label = LABEL();
4502  OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));  OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));
4503  OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));  OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
4504  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
4505  jump = CMP(SLJIT_C_GREATER, CHAR1, 0, SLJIT_IMM, 255);  jump = CMP(SLJIT_GREATER, CHAR1, 0, SLJIT_IMM, 255);
4506  #endif  #endif
4507  OP1(SLJIT_MOV_UB, CHAR1, 0, SLJIT_MEM2(LCC_TABLE, CHAR1), 0);  OP1(SLJIT_MOV_UB, CHAR1, 0, SLJIT_MEM2(LCC_TABLE, CHAR1), 0);
4508  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
4509  JUMPHERE(jump);  JUMPHERE(jump);
4510  jump = CMP(SLJIT_C_GREATER, CHAR2, 0, SLJIT_IMM, 255);  jump = CMP(SLJIT_GREATER, CHAR2, 0, SLJIT_IMM, 255);
4511  #endif  #endif
4512  OP1(SLJIT_MOV_UB, CHAR2, 0, SLJIT_MEM2(LCC_TABLE, CHAR2), 0);  OP1(SLJIT_MOV_UB, CHAR2, 0, SLJIT_MEM2(LCC_TABLE, CHAR2), 0);
4513  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
4514  JUMPHERE(jump);  JUMPHERE(jump);
4515  #endif  #endif
4516  jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);  jump = CMP(SLJIT_NOT_EQUAL, CHAR1, 0, CHAR2, 0);
4517  OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));  OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
4518  JUMPTO(SLJIT_C_NOT_ZERO, label);  JUMPTO(SLJIT_NOT_ZERO, label);
4519    
4520  JUMPHERE(jump);  JUMPHERE(jump);
4521  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));
4522  OP1(SLJIT_MOV, LCC_TABLE, 0, TMP3, 0);  OP1(SLJIT_MOV, LCC_TABLE, 0, TMP3, 0);
4523  OP1(SLJIT_MOV, CHAR1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);  OP1(SLJIT_MOV, CHAR1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
4524  OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);  OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
4525  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
4526  }  }
4527    
# Line 3747  return src2; Line 4563  return src2;
4563  #endif /* SUPPORT_UTF && SUPPORT_UCP */  #endif /* SUPPORT_UTF && SUPPORT_UCP */
4564    
4565  static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,  static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,
4566      compare_context* context, jump_list **backtracks)      compare_context *context, jump_list **backtracks)
4567  {  {
4568  DEFINE_COMPILER;  DEFINE_COMPILER;
4569  unsigned int othercasebit = 0;  unsigned int othercasebit = 0;
# Line 3847  do Line 4663  do
4663        case 4 / sizeof(pcre_uchar):        case 4 / sizeof(pcre_uchar):
4664        if (context->oc.asint != 0)        if (context->oc.asint != 0)
4665          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);
4666        add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));        add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
4667        break;        break;
4668    
4669        case 2 / sizeof(pcre_uchar):        case 2 / sizeof(pcre_uchar):
4670        if (context->oc.asushort != 0)        if (context->oc.asushort != 0)
4671          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);
4672        add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));        add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));
4673        break;        break;
4674    
4675  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
4676        case 1:        case 1:
4677        if (context->oc.asbyte != 0)        if (context->oc.asbyte != 0)
4678          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);
4679        add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));        add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
4680        break;        break;
4681  #endif  #endif
4682    
# Line 3882  do Line 4698  do
4698    if (othercasebit != 0 && othercasechar == cc)    if (othercasebit != 0 && othercasechar == cc)
4699      {      {
4700      OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);      OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);
4701      add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
4702      }      }
4703    else    else
4704      add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
4705    
4706  #endif  #endif
4707    
# Line 3904  return cc; Line 4720  return cc;
4720  #define SET_TYPE_OFFSET(value) \  #define SET_TYPE_OFFSET(value) \
4721    if ((value) != typeoffset) \    if ((value) != typeoffset) \
4722      { \      { \
4723      if ((value) > typeoffset) \      if ((value) < typeoffset) \
       OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \  
     else \  
4724        OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \        OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \
4725        else \
4726          OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \
4727      } \      } \
4728    typeoffset = (value);    typeoffset = (value);
4729    
4730  #define SET_CHAR_OFFSET(value) \  #define SET_CHAR_OFFSET(value) \
4731    if ((value) != charoffset) \    if ((value) != charoffset) \
4732      { \      { \
4733      if ((value) > charoffset) \      if ((value) < charoffset) \
4734        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (value) - charoffset); \        OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(charoffset - (value))); \
4735      else \      else \
4736        OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, charoffset - (value)); \        OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)((value) - charoffset)); \
4737      } \      } \
4738    charoffset = (value);    charoffset = (value);
4739    
# Line 3925  static void compile_xclass_matchingpath( Line 4741  static void compile_xclass_matchingpath(
4741  {  {
4742  DEFINE_COMPILER;  DEFINE_COMPILER;
4743  jump_list *found = NULL;  jump_list *found = NULL;
4744  jump_list **list = (*cc & XCL_NOT) == 0 ? &found : backtracks;  jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks;
4745  pcre_int32 c, charoffset;  sljit_uw c, charoffset, max = 256, min = READ_CHAR_MAX;
 const pcre_uint32 *other_cases;  
4746  struct sljit_jump *jump = NULL;  struct sljit_jump *jump = NULL;
4747  pcre_uchar *ccbegin;  pcre_uchar *ccbegin;
4748  int compares, invertcmp, numberofcmps;  int compares, invertcmp, numberofcmps;
4749    #if defined SUPPORT_UTF && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)
4750    BOOL utf = common->utf;
4751    #endif
4752    
4753  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
4754  BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;  BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
4755  BOOL charsaved = FALSE;  BOOL charsaved = FALSE;
4756  int typereg = TMP1, scriptreg = TMP1;  int typereg = TMP1, scriptreg = TMP1;
4757  pcre_int32 typeoffset;  const pcre_uint32 *other_cases;
4758    sljit_uw typeoffset;
4759  #endif  #endif
4760