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

Diff of /code/trunk/pcre_jit_compile.c

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

revision 1245 by zherczeg, Sat Feb 9 11:30:51 2013 UTC revision 1269 by zherczeg, Mon Mar 4 10:47:12 2013 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2012 University of Cambridge             Copyright (c) 1997-2013 University of Cambridge
10    
11    The machine code generator part (this module) was written by Zoltan Herczeg    The machine code generator part (this module) was written by Zoltan Herczeg
12                        Copyright (c) 2010-2012                        Copyright (c) 2010-2013
13    
14  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
15  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 65  system files. */ Line 65  system files. */
65  #error Unsupported architecture  #error Unsupported architecture
66  #endif  #endif
67    
68    /* Defines for debugging purposes. */
69    
70    /* 1 - Use unoptimized capturing brackets.
71       2 - Enable capture_last_ptr (includes option 1). */
72    /* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */
73    
74  /* Allocate memory for the regex stack on the real machine stack.  /* Allocate memory for the regex stack on the real machine stack.
75  Fast, but limited size. */  Fast, but limited size. */
76  #define MACHINE_STACK_SIZE 32768  #define MACHINE_STACK_SIZE 32768
# Line 159  typedef struct jit_arguments { Line 165  typedef struct jit_arguments {
165    pcre_uchar *mark_ptr;    pcre_uchar *mark_ptr;
166    void *callout_data;    void *callout_data;
167    /* Everything else after. */    /* Everything else after. */
168      int real_offset_count;
169    int offset_count;    int offset_count;
170    int call_limit;    int call_limit;
171    pcre_uint8 notbol;    pcre_uint8 notbol;
# Line 180  typedef struct jump_list { Line 187  typedef struct jump_list {
187    struct jump_list *next;    struct jump_list *next;
188  } jump_list;  } jump_list;
189    
 enum stub_types { stack_alloc };  
   
190  typedef struct stub_list {  typedef struct stub_list {
   enum stub_types type;  
   int data;  
191    struct sljit_jump *start;    struct sljit_jump *start;
192    struct sljit_label *quit;    struct sljit_label *quit;
193    struct stub_list *next;    struct stub_list *next;
194  } stub_list;  } stub_list;
195    
196    enum frame_types { no_frame = -1, no_stack = -2 };
197    
198  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
199    
200  /* The following structure is the key data type for the recursive  /* The following structure is the key data type for the recursive
# Line 271  typedef struct recurse_entry { Line 276  typedef struct recurse_entry {
276    
277  typedef struct recurse_backtrack {  typedef struct recurse_backtrack {
278    backtrack_common common;    backtrack_common common;
279      BOOL inlined_pattern;
280  } recurse_backtrack;  } recurse_backtrack;
281    
282  #define MAX_RANGE_SIZE 6  #define MAX_RANGE_SIZE 6
# Line 395  typedef struct compare_context { Line 401  typedef struct compare_context {
401  #endif  #endif
402  } compare_context;  } compare_context;
403    
 enum {  
   frame_end = 0,  
   frame_setstrbegin = -1,  
   frame_setmark = -2  
 };  
   
404  /* Undefine sljit macros. */  /* Undefine sljit macros. */
405  #undef CMP  #undef CMP
406    
# Line 464  the start pointers when the end of the c Line 464  the start pointers when the end of the c
464    sljit_set_label(sljit_emit_jump(compiler, (type)), (label))    sljit_set_label(sljit_emit_jump(compiler, (type)), (label))
465  #define JUMPHERE(jump) \  #define JUMPHERE(jump) \
466    sljit_set_label((jump), sljit_emit_label(compiler))    sljit_set_label((jump), sljit_emit_label(compiler))
467    #define SET_LABEL(jump, label) \
468      sljit_set_label((jump), (label))
469  #define CMP(type, src1, src1w, src2, src2w) \  #define CMP(type, src1, src1w, src2, src2w) \
470    sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))    sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))
471  #define CMPTO(type, src1, src1w, src2, src2w, label) \  #define CMPTO(type, src1, src1w, src2, src2w, label) \
# Line 512  switch(*cc) Line 514  switch(*cc)
514    case OP_WORDCHAR:    case OP_WORDCHAR:
515    case OP_ANY:    case OP_ANY:
516    case OP_ALLANY:    case OP_ALLANY:
517      case OP_NOTPROP:
518      case OP_PROP:
519    case OP_ANYNL:    case OP_ANYNL:
520    case OP_NOT_HSPACE:    case OP_NOT_HSPACE:
521    case OP_HSPACE:    case OP_HSPACE:
# Line 524  switch(*cc) Line 528  switch(*cc)
528    case OP_CIRCM:    case OP_CIRCM:
529    case OP_DOLL:    case OP_DOLL:
530    case OP_DOLLM:    case OP_DOLLM:
   case OP_TYPESTAR:  
   case OP_TYPEMINSTAR:  
   case OP_TYPEPLUS:  
   case OP_TYPEMINPLUS:  
   case OP_TYPEQUERY:  
   case OP_TYPEMINQUERY:  
   case OP_TYPEPOSSTAR:  
   case OP_TYPEPOSPLUS:  
   case OP_TYPEPOSQUERY:  
531    case OP_CRSTAR:    case OP_CRSTAR:
532    case OP_CRMINSTAR:    case OP_CRMINSTAR:
533    case OP_CRPLUS:    case OP_CRPLUS:
534    case OP_CRMINPLUS:    case OP_CRMINPLUS:
535    case OP_CRQUERY:    case OP_CRQUERY:
536    case OP_CRMINQUERY:    case OP_CRMINQUERY:
537      case OP_CRRANGE:
538      case OP_CRMINRANGE:
539      case OP_CLASS:
540      case OP_NCLASS:
541      case OP_REF:
542      case OP_REFI:
543      case OP_RECURSE:
544      case OP_CALLOUT:
545      case OP_ALT:
546      case OP_KET:
547      case OP_KETRMAX:
548      case OP_KETRMIN:
549      case OP_KETRPOS:
550      case OP_REVERSE:
551      case OP_ASSERT:
552      case OP_ASSERT_NOT:
553      case OP_ASSERTBACK:
554      case OP_ASSERTBACK_NOT:
555      case OP_ONCE:
556      case OP_ONCE_NC:
557      case OP_BRA:
558      case OP_BRAPOS:
559      case OP_CBRA:
560      case OP_CBRAPOS:
561      case OP_COND:
562      case OP_SBRA:
563      case OP_SBRAPOS:
564      case OP_SCBRA:
565      case OP_SCBRAPOS:
566      case OP_SCOND:
567      case OP_CREF:
568      case OP_NCREF:
569      case OP_RREF:
570      case OP_NRREF:
571    case OP_DEF:    case OP_DEF:
572    case OP_BRAZERO:    case OP_BRAZERO:
573    case OP_BRAMINZERO:    case OP_BRAMINZERO:
# Line 547  switch(*cc) Line 576  switch(*cc)
576    case OP_FAIL:    case OP_FAIL:
577    case OP_ACCEPT:    case OP_ACCEPT:
578    case OP_ASSERT_ACCEPT:    case OP_ASSERT_ACCEPT:
579      case OP_CLOSE:
580    case OP_SKIPZERO:    case OP_SKIPZERO:
581    return cc + 1;    return cc + PRIV(OP_lengths)[*cc];
   
   case OP_ANYBYTE:  
 #ifdef SUPPORT_UTF  
   if (common->utf) return NULL;  
 #endif  
   return cc + 1;  
582    
583    case OP_CHAR:    case OP_CHAR:
584    case OP_CHARI:    case OP_CHARI:
# Line 566  switch(*cc) Line 590  switch(*cc)
590    case OP_MINPLUS:    case OP_MINPLUS:
591    case OP_QUERY:    case OP_QUERY:
592    case OP_MINQUERY:    case OP_MINQUERY:
593      case OP_UPTO:
594      case OP_MINUPTO:
595      case OP_EXACT:
596    case OP_POSSTAR:    case OP_POSSTAR:
597    case OP_POSPLUS:    case OP_POSPLUS:
598    case OP_POSQUERY:    case OP_POSQUERY:
599      case OP_POSUPTO:
600    case OP_STARI:    case OP_STARI:
601    case OP_MINSTARI:    case OP_MINSTARI:
602    case OP_PLUSI:    case OP_PLUSI:
603    case OP_MINPLUSI:    case OP_MINPLUSI:
604    case OP_QUERYI:    case OP_QUERYI:
605    case OP_MINQUERYI:    case OP_MINQUERYI:
606      case OP_UPTOI:
607      case OP_MINUPTOI:
608      case OP_EXACTI:
609    case OP_POSSTARI:    case OP_POSSTARI:
610    case OP_POSPLUSI:    case OP_POSPLUSI:
611    case OP_POSQUERYI:    case OP_POSQUERYI:
612      case OP_POSUPTOI:
613    case OP_NOTSTAR:    case OP_NOTSTAR:
614    case OP_NOTMINSTAR:    case OP_NOTMINSTAR:
615    case OP_NOTPLUS:    case OP_NOTPLUS:
616    case OP_NOTMINPLUS:    case OP_NOTMINPLUS:
617    case OP_NOTQUERY:    case OP_NOTQUERY:
618    case OP_NOTMINQUERY:    case OP_NOTMINQUERY:
619      case OP_NOTUPTO:
620      case OP_NOTMINUPTO:
621      case OP_NOTEXACT:
622    case OP_NOTPOSSTAR:    case OP_NOTPOSSTAR:
623    case OP_NOTPOSPLUS:    case OP_NOTPOSPLUS:
624    case OP_NOTPOSQUERY:    case OP_NOTPOSQUERY:
625      case OP_NOTPOSUPTO:
626    case OP_NOTSTARI:    case OP_NOTSTARI:
627    case OP_NOTMINSTARI:    case OP_NOTMINSTARI:
628    case OP_NOTPLUSI:    case OP_NOTPLUSI:
629    case OP_NOTMINPLUSI:    case OP_NOTMINPLUSI:
630    case OP_NOTQUERYI:    case OP_NOTQUERYI:
631    case OP_NOTMINQUERYI:    case OP_NOTMINQUERYI:
   case OP_NOTPOSSTARI:  
   case OP_NOTPOSPLUSI:  
   case OP_NOTPOSQUERYI:  
   cc += 2;  
 #ifdef SUPPORT_UTF  
   if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);  
 #endif  
   return cc;  
   
   case OP_UPTO:  
   case OP_MINUPTO:  
   case OP_EXACT:  
   case OP_POSUPTO:  
   case OP_UPTOI:  
   case OP_MINUPTOI:  
   case OP_EXACTI:  
   case OP_POSUPTOI:  
   case OP_NOTUPTO:  
   case OP_NOTMINUPTO:  
   case OP_NOTEXACT:  
   case OP_NOTPOSUPTO:  
632    case OP_NOTUPTOI:    case OP_NOTUPTOI:
633    case OP_NOTMINUPTOI:    case OP_NOTMINUPTOI:
634    case OP_NOTEXACTI:    case OP_NOTEXACTI:
635      case OP_NOTPOSSTARI:
636      case OP_NOTPOSPLUSI:
637      case OP_NOTPOSQUERYI:
638    case OP_NOTPOSUPTOI:    case OP_NOTPOSUPTOI:
639    cc += 2 + IMM2_SIZE;    cc += PRIV(OP_lengths)[*cc];
640  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
641    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
642  #endif  #endif
643    return cc;    return cc;
644    
645    case OP_NOTPROP:    /* Special cases. */
646    case OP_PROP:    case OP_TYPESTAR:
647    return cc + 1 + 2;    case OP_TYPEMINSTAR:
648      case OP_TYPEPLUS:
649      case OP_TYPEMINPLUS:
650      case OP_TYPEQUERY:
651      case OP_TYPEMINQUERY:
652    case OP_TYPEUPTO:    case OP_TYPEUPTO:
653    case OP_TYPEMINUPTO:    case OP_TYPEMINUPTO:
654    case OP_TYPEEXACT:    case OP_TYPEEXACT:
655      case OP_TYPEPOSSTAR:
656      case OP_TYPEPOSPLUS:
657      case OP_TYPEPOSQUERY:
658    case OP_TYPEPOSUPTO:    case OP_TYPEPOSUPTO:
659    case OP_REF:    return cc + PRIV(OP_lengths)[*cc] - 1;
   case OP_REFI:  
   case OP_CREF:  
   case OP_NCREF:  
   case OP_RREF:  
   case OP_NRREF:  
   case OP_CLOSE:  
   cc += 1 + IMM2_SIZE;  
   return cc;  
660    
661    case OP_CRRANGE:    case OP_ANYBYTE:
662    case OP_CRMINRANGE:  #ifdef SUPPORT_UTF
663    return cc + 1 + 2 * IMM2_SIZE;    if (common->utf) return NULL;
664    #endif
665    case OP_CLASS:    return cc + 1;
   case OP_NCLASS:  
   return cc + 1 + 32 / sizeof(pcre_uchar);  
666    
667  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
668    case OP_XCLASS:    case OP_XCLASS:
669    return cc + GET(cc, 1);    return cc + GET(cc, 1);
670  #endif  #endif
671    
   case OP_RECURSE:  
   case OP_ASSERT:  
   case OP_ASSERT_NOT:  
   case OP_ASSERTBACK:  
   case OP_ASSERTBACK_NOT:  
   case OP_REVERSE:  
   case OP_ONCE:  
   case OP_ONCE_NC:  
   case OP_BRA:  
   case OP_BRAPOS:  
   case OP_COND:  
   case OP_SBRA:  
   case OP_SBRAPOS:  
   case OP_SCOND:  
   case OP_ALT:  
   case OP_KET:  
   case OP_KETRMAX:  
   case OP_KETRMIN:  
   case OP_KETRPOS:  
   return cc + 1 + LINK_SIZE;  
   
   case OP_CBRA:  
   case OP_CBRAPOS:  
   case OP_SCBRA:  
   case OP_SCBRAPOS:  
   return cc + 1 + LINK_SIZE + IMM2_SIZE;  
   
672    case OP_MARK:    case OP_MARK:
673    return cc + 1 + 2 + cc[1];    return cc + 1 + 2 + cc[1];
674    
   case OP_CALLOUT:  
   return cc + 2 + 2 * LINK_SIZE;  
   
675    default:    default:
676    return NULL;    return NULL;
677    }    }
# Line 1122  while (cc < ccend) Line 1106  while (cc < ccend)
1106    }    }
1107  }  }
1108    
1109  /* Returns with -1 if no need for frame. */  /* Returns with a frame_types (always < 0) if no need for frame. */
1110  static int get_framesize(compiler_common *common, pcre_uchar *cc, BOOL recursive)  static int get_framesize(compiler_common *common, pcre_uchar *cc, BOOL recursive)
1111  {  {
1112  pcre_uchar *ccend = bracketend(cc);  pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);
1113  int length = 0;  int length = 0;
1114  BOOL possessive = FALSE;  int possessive = 0;
1115    BOOL stack_restore = FALSE;
1116  BOOL setsom_found = recursive;  BOOL setsom_found = recursive;
1117  BOOL setmark_found = recursive;  BOOL setmark_found = recursive;
1118    /* The last capture is a local variable even for recursions. */
1119    BOOL capture_last_found = FALSE;
1120    
1121  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
1122    {    {
1123    length = 3;    possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
1124    possessive = TRUE;    /* This is correct regardless of common->capture_last_ptr. */
1125      capture_last_found = TRUE;
1126    }    }
1127    
1128  cc = next_opcode(common, cc);  cc = next_opcode(common, cc);
# Line 1144  while (cc < ccend) Line 1132  while (cc < ccend)
1132      {      {
1133      case OP_SET_SOM:      case OP_SET_SOM:
1134      SLJIT_ASSERT(common->has_set_som);      SLJIT_ASSERT(common->has_set_som);
1135        stack_restore = TRUE;
1136      if (!setsom_found)      if (!setsom_found)
1137        {        {
1138        length += 2;        length += 2;
# Line 1154  while (cc < ccend) Line 1143  while (cc < ccend)
1143    
1144      case OP_MARK:      case OP_MARK:
1145      SLJIT_ASSERT(common->mark_ptr != 0);      SLJIT_ASSERT(common->mark_ptr != 0);
1146        stack_restore = TRUE;
1147      if (!setmark_found)      if (!setmark_found)
1148        {        {
1149        length += 2;        length += 2;
# Line 1163  while (cc < ccend) Line 1153  while (cc < ccend)
1153      break;      break;
1154    
1155      case OP_RECURSE:      case OP_RECURSE:
1156        stack_restore = TRUE;
1157      if (common->has_set_som && !setsom_found)      if (common->has_set_som && !setsom_found)
1158        {        {
1159        length += 2;        length += 2;
# Line 1173  while (cc < ccend) Line 1164  while (cc < ccend)
1164        length += 2;        length += 2;
1165        setmark_found = TRUE;        setmark_found = TRUE;
1166        }        }
1167        if (common->capture_last_ptr != 0 && !capture_last_found)
1168          {
1169          length += 2;
1170          capture_last_found = TRUE;
1171          }
1172      cc += 1 + LINK_SIZE;      cc += 1 + LINK_SIZE;
1173      break;      break;
1174    
# Line 1180  while (cc < ccend) Line 1176  while (cc < ccend)
1176      case OP_CBRAPOS:      case OP_CBRAPOS:
1177      case OP_SCBRA:      case OP_SCBRA:
1178      case OP_SCBRAPOS:      case OP_SCBRAPOS:
1179        stack_restore = TRUE;
1180        if (common->capture_last_ptr != 0 && !capture_last_found)
1181          {
1182          length += 2;
1183          capture_last_found = TRUE;
1184          }
1185      length += 3;      length += 3;
1186      cc += 1 + LINK_SIZE + IMM2_SIZE;      cc += 1 + LINK_SIZE + IMM2_SIZE;
1187      break;      break;
1188    
1189      default:      default:
1190        stack_restore = TRUE;
1191        /* Fall through. */
1192    
1193        case OP_NOT_WORD_BOUNDARY:
1194        case OP_WORD_BOUNDARY:
1195        case OP_NOT_DIGIT:
1196        case OP_DIGIT:
1197        case OP_NOT_WHITESPACE:
1198        case OP_WHITESPACE:
1199        case OP_NOT_WORDCHAR:
1200        case OP_WORDCHAR:
1201        case OP_ANY:
1202        case OP_ALLANY:
1203        case OP_ANYBYTE:
1204        case OP_NOTPROP:
1205        case OP_PROP:
1206        case OP_ANYNL:
1207        case OP_NOT_HSPACE:
1208        case OP_HSPACE:
1209        case OP_NOT_VSPACE:
1210        case OP_VSPACE:
1211        case OP_EXTUNI:
1212        case OP_EODN:
1213        case OP_EOD:
1214        case OP_CIRC:
1215        case OP_CIRCM:
1216        case OP_DOLL:
1217        case OP_DOLLM:
1218        case OP_CHAR:
1219        case OP_CHARI:
1220        case OP_NOT:
1221        case OP_NOTI:
1222    
1223        case OP_EXACT:
1224        case OP_POSSTAR:
1225        case OP_POSPLUS:
1226        case OP_POSQUERY:
1227        case OP_POSUPTO:
1228    
1229        case OP_EXACTI:
1230        case OP_POSSTARI:
1231        case OP_POSPLUSI:
1232        case OP_POSQUERYI:
1233        case OP_POSUPTOI:
1234    
1235        case OP_NOTEXACT:
1236        case OP_NOTPOSSTAR:
1237        case OP_NOTPOSPLUS:
1238        case OP_NOTPOSQUERY:
1239        case OP_NOTPOSUPTO:
1240    
1241        case OP_NOTEXACTI:
1242        case OP_NOTPOSSTARI:
1243        case OP_NOTPOSPLUSI:
1244        case OP_NOTPOSQUERYI:
1245        case OP_NOTPOSUPTOI:
1246    
1247        case OP_TYPEEXACT:
1248        case OP_TYPEPOSSTAR:
1249        case OP_TYPEPOSPLUS:
1250        case OP_TYPEPOSQUERY:
1251        case OP_TYPEPOSUPTO:
1252    
1253        case OP_CLASS:
1254        case OP_NCLASS:
1255        case OP_XCLASS:
1256    
1257      cc = next_opcode(common, cc);      cc = next_opcode(common, cc);
1258      SLJIT_ASSERT(cc != NULL);      SLJIT_ASSERT(cc != NULL);
1259      break;      break;
1260      }      }
1261    
1262  /* Possessive quantifiers can use a special case. */  /* Possessive quantifiers can use a special case. */
1263  if (SLJIT_UNLIKELY(possessive) && length == 3)  if (SLJIT_UNLIKELY(possessive == length))
1264    return -1;    return stack_restore ? no_frame : no_stack;
1265    
1266  if (length > 0)  if (length > 0)
1267    return length + 1;    return length + 1;
1268  return -1;  return stack_restore ? no_frame : no_stack;
1269  }  }
1270    
1271  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, int stackpos, int stacktop, BOOL recursive)
1272  {  {
1273  DEFINE_COMPILER;  DEFINE_COMPILER;
1274  pcre_uchar *ccend = bracketend(cc);  pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);
1275  BOOL setsom_found = recursive;  BOOL setsom_found = recursive;
1276  BOOL setmark_found = recursive;  BOOL setmark_found = recursive;
1277    /* The last capture is a local variable even for recursions. */
1278    BOOL capture_last_found = FALSE;
1279  int offset;  int offset;
1280    
1281  /* >= 1 + shortest item size (2) */  /* >= 1 + shortest item size (2) */
# Line 1223  while (cc < ccend) Line 1294  while (cc < ccend)
1294      if (!setsom_found)      if (!setsom_found)
1295        {        {
1296        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
1297        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setstrbegin);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
1298        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1299        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1300        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
# Line 1237  while (cc < ccend) Line 1308  while (cc < ccend)
1308      if (!setmark_found)      if (!setmark_found)
1309        {        {
1310        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
1311        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
1312        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1313        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1314        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
# Line 1250  while (cc < ccend) Line 1321  while (cc < ccend)
1321      if (common->has_set_som && !setsom_found)      if (common->has_set_som && !setsom_found)
1322        {        {
1323        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
1324        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setstrbegin);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
1325        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1326        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1327        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
# Line 1259  while (cc < ccend) Line 1330  while (cc < ccend)
1330      if (common->mark_ptr != 0 && !setmark_found)      if (common->mark_ptr != 0 && !setmark_found)
1331        {        {
1332        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
1333        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setmark);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
1334        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1335        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1336        stackpos += (int)sizeof(sljit_sw);        stackpos += (int)sizeof(sljit_sw);
1337        setmark_found = TRUE;        setmark_found = TRUE;
1338        }        }
1339        if (common->capture_last_ptr != 0 && !capture_last_found)
1340          {
1341          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
1342          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
1343          stackpos += (int)sizeof(sljit_sw);
1344          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1345          stackpos += (int)sizeof(sljit_sw);
1346          capture_last_found = TRUE;
1347          }
1348      cc += 1 + LINK_SIZE;      cc += 1 + LINK_SIZE;
1349      break;      break;
1350    
# Line 1272  while (cc < ccend) Line 1352  while (cc < ccend)
1352      case OP_CBRAPOS:      case OP_CBRAPOS:
1353      case OP_SCBRA:      case OP_SCBRA:
1354      case OP_SCBRAPOS:      case OP_SCBRAPOS:
1355        if (common->capture_last_ptr != 0 && !capture_last_found)
1356          {
1357          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
1358          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
1359          stackpos += (int)sizeof(sljit_sw);
1360          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
1361          stackpos += (int)sizeof(sljit_sw);
1362          capture_last_found = TRUE;
1363          }
1364      offset = (GET2(cc, 1 + LINK_SIZE)) << 1;      offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
1365      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));
1366      stackpos += (int)sizeof(sljit_sw);      stackpos += (int)sizeof(sljit_sw);
# Line 1291  while (cc < ccend) Line 1380  while (cc < ccend)
1380      break;      break;
1381      }      }
1382    
1383  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_end);  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0);
1384  SLJIT_ASSERT(stackpos == STACK(stacktop));  SLJIT_ASSERT(stackpos == STACK(stacktop));
1385  }  }
1386    
# Line 1731  while (list) Line 1820  while (list)
1820    {    {
1821    /* sljit_set_label is clever enough to do nothing    /* sljit_set_label is clever enough to do nothing
1822    if either the jump or the label is NULL. */    if either the jump or the label is NULL. */
1823    sljit_set_label(list->jump, label);    SET_LABEL(list->jump, label);
1824    list = list->next;    list = list->next;
1825    }    }
1826  }  }
# Line 1747  if (list_item) Line 1836  if (list_item)
1836    }    }
1837  }  }
1838    
1839  static void add_stub(compiler_common *common, enum stub_types type, int data, struct sljit_jump *start)  static void add_stub(compiler_common *common, struct sljit_jump *start)
1840  {  {
1841  DEFINE_COMPILER;  DEFINE_COMPILER;
1842  stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));  stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
1843    
1844  if (list_item)  if (list_item)
1845    {    {
   list_item->type = type;  
   list_item->data = data;  
1846    list_item->start = start;    list_item->start = start;
1847    list_item->quit = LABEL();    list_item->quit = LABEL();
1848    list_item->next = common->stubs;    list_item->next = common->stubs;
# Line 1771  stub_list* list_item = common->stubs; Line 1858  stub_list* list_item = common->stubs;
1858  while (list_item)  while (list_item)
1859    {    {
1860    JUMPHERE(list_item->start);    JUMPHERE(list_item->start);
1861    switch(list_item->type)    add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
     {  
     case stack_alloc:  
     add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));  
     break;  
     }  
1862    JUMPTO(SLJIT_JUMP, list_item->quit);    JUMPTO(SLJIT_JUMP, list_item->quit);
1863    list_item = list_item->next;    list_item = list_item->next;
1864    }    }
# Line 1804  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0); Line 1886  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
1886  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0);
1887  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);
1888  #endif  #endif
1889  add_stub(common, stack_alloc, 0, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));  add_stub(common, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));
1890  }  }
1891    
1892  static SLJIT_INLINE void free_stack(compiler_common *common, int size)  static SLJIT_INLINE void free_stack(compiler_common *common, int size)
# Line 1890  else Line 1972  else
1972  static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)  static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)
1973  {  {
1974  DEFINE_COMPILER;  DEFINE_COMPILER;
1975    struct sljit_jump *jump;
1976    
1977  SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);  SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);
1978  SLJIT_ASSERT(common->start_used_ptr != 0 && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));  SLJIT_ASSERT(common->start_used_ptr != 0 && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
1979    
1980  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);
1981  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
1982  OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offset_count));  OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
1983  CMPTO(SLJIT_C_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 2, quit);  CMPTO(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 2, quit);
1984    
1985  /* Store match begin and end. */  /* Store match begin and end. */
1986  OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, begin));  OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, begin));
1987  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));
1988    
1989    jump = CMP(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 3);
1990    OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr + sizeof(sljit_sw), SLJIT_SAVED_REG1, 0);
1991    #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
1992    OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);
1993    #endif
1994    OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 2 * sizeof(int), SLJIT_SCRATCH_REG3, 0);
1995    JUMPHERE(jump);
1996    
1997  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);  OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
1998  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);
1999  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
# Line 2078  else if (common->mode == JIT_PARTIAL_SOF Line 2170  else if (common->mode == JIT_PARTIAL_SOF
2170    jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);    jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);
2171    
2172  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2173    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
2174  else  else
2175    {    {
2176    if (common->partialmatchlabel != NULL)    if (common->partialmatchlabel != NULL)
# Line 2091  if (jump != NULL) Line 2183  if (jump != NULL)
2183    JUMPHERE(jump);    JUMPHERE(jump);
2184  }  }
2185    
2186  static struct sljit_jump *check_str_end(compiler_common *common)  static void check_str_end(compiler_common *common, jump_list **end_reached)
2187  {  {
2188  /* Does not affect registers. Usually used in a tight spot. */  /* Does not affect registers. Usually used in a tight spot. */
2189  DEFINE_COMPILER;  DEFINE_COMPILER;
2190  struct sljit_jump *jump;  struct sljit_jump *jump;
 struct sljit_jump *nohit;  
 struct sljit_jump *return_value;  
2191    
2192  if (common->mode == JIT_COMPILE)  if (common->mode == JIT_COMPILE)
2193    return CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);    {
2194      add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
2195      return;
2196      }
2197    
2198  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
2199  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2200    {    {
2201    nohit = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
2202    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
2203    JUMPHERE(nohit);    add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));
   return_value = JUMP(SLJIT_JUMP);  
2204    }    }
2205  else  else
2206    {    {
2207    return_value = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
2208    if (common->partialmatchlabel != NULL)    if (common->partialmatchlabel != NULL)
2209      JUMPTO(SLJIT_JUMP, common->partialmatchlabel);      JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
2210    else    else
2211      add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));      add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
2212    }    }
2213  JUMPHERE(jump);  JUMPHERE(jump);
 return return_value;  
2214  }  }
2215    
2216  static void detect_partial_match(compiler_common *common, jump_list **backtracks)  static void detect_partial_match(compiler_common *common, jump_list **backtracks)
# Line 2138  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR Line 2229  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR
2229  add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));  add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));
2230  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
2231    {    {
2232    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
2233    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
2234    }    }
2235  else  else
# Line 3060  GET_LOCAL_BASE(TMP3, 0, 0); Line 3151  GET_LOCAL_BASE(TMP3, 0, 0);
3151  /* Drop frames until we reach STACK_TOP. */  /* Drop frames until we reach STACK_TOP. */
3152  mainloop = LABEL();  mainloop = LABEL();
3153  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
3154  jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);  OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);
3155    jump = JUMP(SLJIT_C_SIG_LESS_EQUAL);
3156    
3157  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
3158  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));
3159  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));
# Line 3068  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I Line 3161  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_I
3161  JUMPTO(SLJIT_JUMP, mainloop);  JUMPTO(SLJIT_JUMP, mainloop);
3162    
3163  JUMPHERE(jump);  JUMPHERE(jump);
3164  jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);  jump = JUMP(SLJIT_C_SIG_LESS);
3165  /* End of dropping frames. */  /* End of dropping frames. */
3166  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
3167    
3168  JUMPHERE(jump);  JUMPHERE(jump);
3169  jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setstrbegin);  OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);
3170  /* Set string begin. */  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
3171  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));  
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);  
 JUMPTO(SLJIT_JUMP, mainloop);  
   
 JUMPHERE(jump);  
 if (common->mark_ptr != 0)  
   {  
   jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setmark);  
   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));  
   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));  
   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);  
   JUMPTO(SLJIT_JUMP, mainloop);  
   
   JUMPHERE(jump);  
   }  
   
 /* Unknown command. */  
3172  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
3173  JUMPTO(SLJIT_JUMP, mainloop);  JUMPTO(SLJIT_JUMP, mainloop);
3174  }  }
# Line 3101  static void check_wordboundary(compiler_ Line 3177  static void check_wordboundary(compiler_
3177  {  {
3178  DEFINE_COMPILER;  DEFINE_COMPILER;
3179  struct sljit_jump *skipread;  struct sljit_jump *skipread;
3180    jump_list *skipread_list = NULL;
3181  #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF  #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF
3182  struct sljit_jump *jump;  struct sljit_jump *jump;
3183  #endif  #endif
# Line 3158  else Line 3235  else
3235  JUMPHERE(skipread);  JUMPHERE(skipread);
3236    
3237  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
3238  skipread = check_str_end(common);  check_str_end(common, &skipread_list);
3239  peek_char(common);  peek_char(common);
3240    
3241  /* Testing char type. This is a code duplication. */  /* Testing char type. This is a code duplication. */
# Line 3199  else Line 3276  else
3276      JUMPHERE(jump);      JUMPHERE(jump);
3277  #endif /* COMPILE_PCRE8 */  #endif /* COMPILE_PCRE8 */
3278    }    }
3279  JUMPHERE(skipread);  set_jumps(skipread_list, LABEL());
3280    
3281  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);  OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
3282  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
# Line 3839  while (*cc != XCL_END) Line 3916  while (*cc != XCL_END)
3916        break;        break;
3917    
3918        case PT_CLIST:        case PT_CLIST:
3919          case PT_UCNC:
3920        needschar = TRUE;        needschar = TRUE;
3921        break;        break;
3922    
# Line 4040  while (*cc != XCL_END) Line 4118  while (*cc != XCL_END)
4118        case PT_WORD:        case PT_WORD:
4119        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE - charoffset);        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE - charoffset);
4120        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
4121        /* ... fall through */        /* Fall through. */
4122    
4123        case PT_ALNUM:        case PT_ALNUM:
4124        SET_TYPE_OFFSET(ucp_Ll);        SET_TYPE_OFFSET(ucp_Ll);
# Line 4104  while (*cc != XCL_END) Line 4182  while (*cc != XCL_END)
4182          }          }
4183        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4184        break;        break;
4185    
4186          case PT_UCNC:
4187          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_DOLLAR_SIGN - charoffset);
4188          OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);
4189          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_COMMERCIAL_AT - charoffset);
4190          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4191          OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_GRAVE_ACCENT - charoffset);
4192          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);
4193    
4194          SET_CHAR_OFFSET(0xa0);
4195          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd7ff - charoffset);
4196          OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);
4197          SET_CHAR_OFFSET(0);
4198          OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);
4199          OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_GREATER_EQUAL);
4200          jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
4201          break;
4202        }        }
4203      cc += 2;      cc += 2;
4204      }      }
# Line 4129  int length; Line 4224  int length;
4224  unsigned int c, oc, bit;  unsigned int c, oc, bit;
4225  compare_context context;  compare_context context;
4226  struct sljit_jump *jump[4];  struct sljit_jump *jump[4];
4227    jump_list *end_list;
4228  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
4229  struct sljit_label *label;  struct sljit_label *label;
4230  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 4197  switch(type) Line 4293  switch(type)
4293    if (common->nltype == NLTYPE_FIXED && common->newline > 255)    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
4294      {      {
4295      jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);      jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
4296        end_list = NULL;
4297      if (common->mode != JIT_PARTIAL_HARD_COMPILE)      if (common->mode != JIT_PARTIAL_HARD_COMPILE)
4298        jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);        add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
4299      else      else
4300        jump[1] = check_str_end(common);        check_str_end(common, &end_list);
4301    
4302      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
4303      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));      add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
4304      if (jump[1] != NULL)      set_jumps(end_list, LABEL());
       JUMPHERE(jump[1]);  
4305      JUMPHERE(jump[0]);      JUMPHERE(jump[0]);
4306      }      }
4307    else    else
# Line 4264  switch(type) Line 4360  switch(type)
4360    read_char(common);    read_char(common);
4361    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
4362    /* We don't need to handle soft partial matching case. */    /* We don't need to handle soft partial matching case. */
4363      end_list = NULL;
4364    if (common->mode != JIT_PARTIAL_HARD_COMPILE)    if (common->mode != JIT_PARTIAL_HARD_COMPILE)
4365      jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);      add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
4366    else    else
4367      jump[1] = check_str_end(common);      check_str_end(common, &end_list);
4368    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
4369    jump[2] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);    jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
4370    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));
4371    jump[3] = JUMP(SLJIT_JUMP);    jump[2] = JUMP(SLJIT_JUMP);
4372    JUMPHERE(jump[0]);    JUMPHERE(jump[0]);
4373    check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);    check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);
4374      set_jumps(end_list, LABEL());
4375    JUMPHERE(jump[1]);    JUMPHERE(jump[1]);
4376    JUMPHERE(jump[2]);    JUMPHERE(jump[2]);
   JUMPHERE(jump[3]);  
4377    return cc;    return cc;
4378    
4379    case OP_NOT_HSPACE:    case OP_NOT_HSPACE:
# Line 5027  backtrack_common *backtrack; Line 5124  backtrack_common *backtrack;
5124  recurse_entry *entry = common->entries;  recurse_entry *entry = common->entries;
5125  recurse_entry *prev = NULL;  recurse_entry *prev = NULL;
5126  int start = GET(cc, 1);  int start = GET(cc, 1);
5127    pcre_uchar *start_cc;
5128    
5129  PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);  PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
5130    
5131    /* Inlining simple patterns. */
5132    if (get_framesize(common, common->start + start, TRUE) == no_stack)
5133      {
5134      start_cc = common->start + start;
5135      compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);
5136      BACKTRACK_AS(recurse_backtrack)->inlined_pattern = TRUE;
5137      return cc + 1 + LINK_SIZE;
5138      }
5139    
5140  while (entry != NULL)  while (entry != NULL)
5141    {    {
5142    if (entry->start == start)    if (entry->start == start)
# Line 5394  if (opcode == OP_ASSERT || opcode == OP_ Line 5502  if (opcode == OP_ASSERT || opcode == OP_
5502    if (bra == OP_BRAZERO)    if (bra == OP_BRAZERO)
5503      {      {
5504      backtrack->matchingpath = LABEL();      backtrack->matchingpath = LABEL();
5505      sljit_set_label(jump, backtrack->matchingpath);      SET_LABEL(jump, backtrack->matchingpath);
5506      }      }
5507    else if (bra == OP_BRAMINZERO)    else if (bra == OP_BRAMINZERO)
5508      {      {
# Line 6163  framesize = get_framesize(common, cc, FA Line 6271  framesize = get_framesize(common, cc, FA
6271  BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;  BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;
6272  if (framesize < 0)  if (framesize < 0)
6273    {    {
6274    stacksize = (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS) ? 2 : 1;    if (offset != 0)
6275        {
6276        stacksize = 2;
6277        if (common->capture_last_ptr != 0)
6278          stacksize++;
6279        }
6280      else
6281        stacksize = 1;
6282    
6283    if (!zero)    if (!zero)
6284      stacksize++;      stacksize++;
6285    
6286    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
6287    allocate_stack(common, stacksize);    allocate_stack(common, stacksize);
6288    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);    if (framesize == no_frame)
6289        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
6290    
6291    if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)    if (offset != 0)
6292      {      {
6293      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
6294      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
6295      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
6296        if (common->capture_last_ptr != 0)
6297          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);
6298      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
6299        if (common->capture_last_ptr != 0)
6300          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
6301      }      }
6302    else    else
6303      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
# Line 6191  else Line 6313  else
6313    if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)    if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)
6314      stacksize++;      stacksize++;
6315    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;    BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
   allocate_stack(common, stacksize);  
6316    
6317      allocate_stack(common, stacksize);
6318    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6319    OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));    OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));
6320    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
6321    
6322    stack = 0;    stack = 0;
6323    if (!zero)    if (!zero)
6324      {      {
# Line 6211  else Line 6334  else
6334    init_frame(common, cc, stacksize - 1, stacksize - framesize, FALSE);    init_frame(common, cc, stacksize - 1, stacksize - framesize, FALSE);
6335    }    }
6336    
6337  if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)  if (offset != 0)
6338    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
6339    
6340  loop = LABEL();  loop = LABEL();
# Line 6227  while (*cc != OP_KETRPOS) Line 6350  while (*cc != OP_KETRPOS)
6350    
6351    if (framesize < 0)    if (framesize < 0)
6352      {      {
6353      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);      if (framesize == no_frame)
6354          OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
6355    
6356      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)      if (offset != 0)
6357        {        {
6358        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
6359        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
6360        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
6361          if (common->capture_last_ptr != 0)
6362            OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
6363        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
6364        }        }
6365      else      else
# Line 6251  while (*cc != OP_KETRPOS) Line 6377  while (*cc != OP_KETRPOS)
6377      }      }
6378    else    else
6379      {      {
6380      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)      if (offset != 0)
6381        {        {
6382        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));        OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));
6383        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
6384        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
6385        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
6386          if (common->capture_last_ptr != 0)
6387            OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
6388        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
6389        }        }
6390      else      else
# Line 6289  while (*cc != OP_KETRPOS) Line 6417  while (*cc != OP_KETRPOS)
6417    
6418    if (framesize < 0)    if (framesize < 0)
6419      {      {
6420      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)      if (offset != 0)
6421        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
6422      else      else
6423        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
6424      }      }
6425    else    else
6426      {      {
6427      if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)      if (offset != 0)
6428        {        {
6429        /* Last alternative. */        /* Last alternative. */
6430        if (*cc == OP_KETRPOS)        if (*cc == OP_KETRPOS)
# Line 6443  PUSH_BACKTRACK(sizeof(iterator_backtrack Line 6571  PUSH_BACKTRACK(sizeof(iterator_backtrack
6571    
6572  cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);  cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);
6573    
6574  switch (type)  switch(type)
6575    {    {
6576    case OP_NOT_DIGIT:    case OP_NOT_DIGIT:
6577    case OP_DIGIT:    case OP_DIGIT:
# Line 7145  static void compile_recurse_backtracking Line 7273  static void compile_recurse_backtracking
7273  {  {
7274  DEFINE_COMPILER;  DEFINE_COMPILER;
7275    
7276    if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
7277      compile_backtrackingpath(common, current->top);
7278  set_jumps(current->topbacktracks, LABEL());  set_jumps(current->topbacktracks, LABEL());
7279    if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
7280      return;
7281    
7282  if (common->has_set_som && common->mark_ptr != 0)  if (common->has_set_som && common->mark_ptr != 0)
7283    {    {
# Line 7315  if (offset != 0) Line 7447  if (offset != 0)
7447    {    {
7448    if (common->capture_last_ptr != 0)    if (common->capture_last_ptr != 0)
7449      {      {
7450        SLJIT_ASSERT(common->optimized_cbracket[offset >> 1] == 0);
7451      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
7452      free_stack(common, 1);      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
7453      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);
7454        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
7455        free_stack(common, 3);
7456        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP2, 0);
7457        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
7458      }      }
7459    if (common->optimized_cbracket[offset >> 1] == 0)    else if (common->optimized_cbracket[offset >> 1] == 0)
7460      {      {
7461      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
7462      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
# Line 7671  if (CURRENT_AS(bracketpos_backtrack)->fr Line 7808  if (CURRENT_AS(bracketpos_backtrack)->fr
7808      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
7809      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
7810      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
7811        if (common->capture_last_ptr != 0)
7812          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
7813      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
7814        if (common->capture_last_ptr != 0)
7815          OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);
7816      }      }
7817    set_jumps(current->topbacktracks, LABEL());    set_jumps(current->topbacktracks, LABEL());
7818    free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);    free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
# Line 8077  common->ovector_start = CALL_LIMIT + siz Line 8218  common->ovector_start = CALL_LIMIT + siz
8218  common->optimized_cbracket = (pcre_uint8 *)SLJIT_MALLOC(re->top_bracket + 1);  common->optimized_cbracket = (pcre_uint8 *)SLJIT_MALLOC(re->top_bracket + 1);
8219  if (!common->optimized_cbracket)  if (!common->optimized_cbracket)
8220    return;    return;
8221    #if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 1
8222    memset(common->optimized_cbracket, 0, re->top_bracket + 1);
8223    #else
8224  memset(common->optimized_cbracket, 1, re->top_bracket + 1);  memset(common->optimized_cbracket, 1, re->top_bracket + 1);
8225    #endif
8226    
8227  SLJIT_ASSERT(*rootbacktrack.cc == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);  SLJIT_ASSERT(*rootbacktrack.cc == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);
8228    #if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 2
8229    common->capture_last_ptr = common->ovector_start;
8230    common->ovector_start += sizeof(sljit_sw);
8231    #endif
8232  private_data_size = get_private_data_length(common, rootbacktrack.cc, ccend);  private_data_size = get_private_data_length(common, rootbacktrack.cc, ccend);
8233  if (private_data_size < 0)  if (private_data_size < 0)
8234    {    {
# Line 8096  if (mode == JIT_COMPILE && (re->flags & Line 8245  if (mode == JIT_COMPILE && (re->flags &
8245  if (mode != JIT_COMPILE)  if (mode != JIT_COMPILE)
8246    {    {
8247    common->start_used_ptr = common->ovector_start;    common->start_used_ptr = common->ovector_start;
8248    common->ovector_start += sizeof(sljit_sw);    common->ovector_start += 2 * sizeof(sljit_sw);
8249    if (mode == JIT_PARTIAL_SOFT_COMPILE)    if (mode == JIT_PARTIAL_SOFT_COMPILE)
8250      {      {
8251      common->hit_start = common->ovector_start;      common->hit_start = common->ovector_start;
# Line 8162  OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM Line 8311  OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM
8311  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CALL_LIMIT, TMP1, 0);  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CALL_LIMIT, TMP1, 0);
8312    
8313  if (mode == JIT_PARTIAL_SOFT_COMPILE)  if (mode == JIT_PARTIAL_SOFT_COMPILE)
8314    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
8315    
8316  /* Main part of the matching */  /* Main part of the matching */
8317  if ((re->options & PCRE_ANCHORED) == 0)  if ((re->options & PCRE_ANCHORED) == 0)
# Line 8201  if (common->capture_last_ptr != 0) Line 8350  if (common->capture_last_ptr != 0)
8350  /* Copy the beginning of the string. */  /* Copy the beginning of the string. */
8351  if (mode == JIT_PARTIAL_SOFT_COMPILE)  if (mode == JIT_PARTIAL_SOFT_COMPILE)
8352    {    {
8353    jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);    jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
8354    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
8355      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr + sizeof(sljit_sw), STR_PTR, 0);
8356    JUMPHERE(jump);    JUMPHERE(jump);
8357    }    }
8358  else if (mode == JIT_PARTIAL_HARD_COMPILE)  else if (mode == JIT_PARTIAL_HARD_COMPILE)
8359      {
8360    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);
8361      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr + sizeof(sljit_sw), STR_PTR, 0);
8362      }
8363    
8364  compile_matchingpath(common, rootbacktrack.cc, ccend, &rootbacktrack);  compile_matchingpath(common, rootbacktrack.cc, ccend, &rootbacktrack);
8365  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
# Line 8232  if (common->quit != NULL) Line 8385  if (common->quit != NULL)
8385  if (common->forced_quit != NULL)  if (common->forced_quit != NULL)
8386    set_jumps(common->forced_quit, common->forced_quit_label);    set_jumps(common->forced_quit, common->forced_quit_label);
8387  if (minlength_check_failed != NULL)  if (minlength_check_failed != NULL)
8388    sljit_set_label(minlength_check_failed, common->forced_quit_label);    SET_LABEL(minlength_check_failed, common->forced_quit_label);
8389  sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);  sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
8390    
8391  if (mode != JIT_COMPILE)  if (mode != JIT_COMPILE)
# Line 8257  SLJIT_ASSERT(rootbacktrack.prev == NULL) Line 8410  SLJIT_ASSERT(rootbacktrack.prev == NULL)
8410  if (mode == JIT_PARTIAL_SOFT_COMPILE)  if (mode == JIT_PARTIAL_SOFT_COMPILE)
8411    {    {
8412    /* Update hit_start only in the first time. */    /* Update hit_start only in the first time. */
8413    jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);    jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);
8414    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr);    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr);
8415    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);
8416    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, TMP1, 0);    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, TMP1, 0);
# Line 8265  if (mode == JIT_PARTIAL_SOFT_COMPILE) Line 8418  if (mode == JIT_PARTIAL_SOFT_COMPILE)
8418    }    }
8419    
8420  /* Check we have remaining characters. */  /* Check we have remaining characters. */
8421    if ((re->options & PCRE_ANCHORED) == 0 && (re->options & PCRE_FIRSTLINE) != 0)
8422      {
8423      SLJIT_ASSERT(common->first_line_end != 0);
8424      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
8425      }
8426  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
8427    
8428  if ((re->options & PCRE_ANCHORED) == 0)  if ((re->options & PCRE_ANCHORED) == 0)
8429    {    {
8430    if ((re->options & PCRE_FIRSTLINE) == 0)    if ((re->options & PCRE_FIRSTLINE) == 0)
8431      {      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
     if (mode == JIT_COMPILE && study != NULL && study->minlength > 1 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)  
       {  
       OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(study->minlength + 1));  
       CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, STR_END, 0, mainloop);  
       }  
     else  
       CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);  
     }  
8432    else    else
8433      {      CMPTO(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0, mainloop);
     SLJIT_ASSERT(common->first_line_end != 0);  
     if (mode == JIT_COMPILE && study != NULL && study->minlength > 1 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)  
       {  
       OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(study->minlength + 1));  
       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, STR_END, 0);  
       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER);  
       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);  
       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_GREATER_EQUAL);  
       JUMPTO(SLJIT_C_ZERO, mainloop);  
       }  
     else  
       CMPTO(SLJIT_C_LESS, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, mainloop);  
     }  
8434    }    }
8435    
8436  /* No more remaining characters. */  /* No more remaining characters. */
# Line 8301  if (reqbyte_notfound != NULL) Line 8438  if (reqbyte_notfound != NULL)
8438    JUMPHERE(reqbyte_notfound);    JUMPHERE(reqbyte_notfound);
8439    
8440  if (mode == JIT_PARTIAL_SOFT_COMPILE)  if (mode == JIT_PARTIAL_SOFT_COMPILE)
8441    CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0, common->partialmatchlabel);    CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1, common->partialmatchlabel);
8442    
8443  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
8444  JUMPTO(SLJIT_JUMP, common->quit_label);  JUMPTO(SLJIT_JUMP, common->quit_label);
# Line 8517  arguments.notempty = (options & PCRE_NOT Line 8654  arguments.notempty = (options & PCRE_NOT
8654  arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;  arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
8655  arguments.offsets = offsets;  arguments.offsets = offsets;
8656  arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;  arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;
8657    arguments.real_offset_count = offset_count;
8658    
8659  /* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of  /* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of
8660  the output vector for storing captured strings, with the remainder used as  the output vector for storing captured strings, with the remainder used as
# Line 8607  arguments.notempty = (options & PCRE_NOT Line 8745  arguments.notempty = (options & PCRE_NOT
8745  arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;  arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
8746  arguments.offsets = offsets;  arguments.offsets = offsets;
8747  arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;  arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;
8748    arguments.real_offset_count = offset_count;
8749    
8750  /* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of  /* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of
8751  the output vector for storing captured strings, with the remainder used as  the output vector for storing captured strings, with the remainder used as

Legend:
Removed from v.1245  
changed lines
  Added in v.1269

  ViewVC Help
Powered by ViewVC 1.1.5