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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 941 by zherczeg,
Tue Feb 28 11:33:34 2012 UTC
+revision 999 by zherczeg,
Mon Aug  6 07:36:49 2012 UTC
 Line 82 
 The code generator follows the recursive
  expressions. The basic blocks of regular expressions are condition checkers
  whose execute different commands depending on the result of the condition check.
  The relationship between the operators can be horizontal (concatenation) and
- vertical (sub-expression) (See struct fallback_common for more details).
+ vertical (sub-expression) (See struct backtrack_common for more details).
    'ab' - 'a' and 'b' regexps are concatenated
    'a+' - 'a' is the sub-expression of the '+' operator
  The condition checkers are boolean (true/false) checkers. Machine code is generated
  for the checker itself and for the actions depending on the result of the checker.
- The 'true' case is called as the hot path (expected path), and the other is called as
+ The 'true' case is called as the matching path (expected path), and the other is called as
- the 'fallback' path. Branch instructions are expesive for all CPUs, so we avoid taken
+ the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken
- branches on the hot path.
+ branches on the matching path.
   Greedy star operator (*) :
-    Hot path: match happens.
+    Matching path: match happens.
-    Fallback path: match failed.
+    Backtrack path: match failed.
   Non-greedy star operator (*?) :
-    Hot path: no need to perform a match.
+    Matching path: no need to perform a match.
-    Fallback path: match is required.
+    Backtrack path: match is required.
  The following example shows how the code generated for a capturing bracket
  with two alternatives. Let A, B, C, D are arbirary regular expressions, and
 Line 108 
 we have the following regular expression
  The generated code will be the following:
-  A hot path
+  A matching path
-  '(' hot path (pushing arguments to the stack)
+  '(' matching path (pushing arguments to the stack)
-  B hot path
+  B matching path
-  ')' hot path (pushing arguments to the stack)
+  ')' matching path (pushing arguments to the stack)
-  D hot path
+  D matching path
   return with successful match
-  D fallback path
+  D backtrack path
-  ')' fallback path (If we arrived from "C" jump to the fallback of "C")
+  ')' backtrack path (If we arrived from "C" jump to the backtrack of "C")
-  B fallback path
+  B backtrack path
   C expected path
-  jump to D hot path
+  jump to D matching path
-  C fallback path
+  C backtrack path
-  A fallback path
+  A backtrack path
-  Notice, that the order of fallback code paths are the opposite of the fast
+  Notice, that the order of backtrack code paths are the opposite of the fast
   code paths. In this way the topmost value on the stack is always belong
-  to the current fallback code path. The fallback code path must check
+  to the current backtrack code path. The backtrack path must check
   whether there is a next alternative. If so, it needs to jump back to
-  the hot path eventually. Otherwise it needs to clear out its own stack
+  the matching path eventually. Otherwise it needs to clear out its own stack
-  frame and continue the execution on the fallback code paths.
+  frame and continue the execution on the backtrack code paths.
  */
  /*
  Saved stack frames:
  Atomic blocks and asserts require reloading the values of local variables
- when the fallback mechanism performed. Because of OP_RECURSE, the locals
+ when the backtrack mechanism performed. Because of OP_RECURSE, the locals
  are not necessarly known in compile time, thus we need a dynamic restore
  mechanism.
 Line 181 
 typedef struct stub_list {
    enum stub_types type;
    int data;
    struct sljit_jump *start;
-   struct sljit_label *leave;
+   struct sljit_label *quit;
    struct stub_list *next;
  } stub_list;
  typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
  /* The following structure is the key data type for the recursive
- code generator. It is allocated by compile_hotpath, and contains
+ code generator. It is allocated by compile_matchingpath, and contains
- the aguments for compile_fallbackpath. Must be the first member
+ the aguments for compile_backtrackingpath. Must be the first member
  of its descendants. */
- typedef struct fallback_common {
+ typedef struct backtrack_common {
    /* Concatenation stack. */
-   struct fallback_common *prev;
+   struct backtrack_common *prev;
-   jump_list *nextfallbacks;
+   jump_list *nextbacktracks;
    /* Internal stack (for component operators). */
-   struct fallback_common *top;
+   struct backtrack_common *top;
-   jump_list *topfallbacks;
+   jump_list *topbacktracks;
    /* Opcode pointer. */
    pcre_uchar *cc;
- } fallback_common;
+ } backtrack_common;
- typedef struct assert_fallback {
+ typedef struct assert_backtrack {
-   fallback_common common;
+   backtrack_common common;
    jump_list *condfailed;
    /* Less than 0 (-1) if a frame is not needed. */
    int framesize;
    /* Points to our private memory word on the stack. */
    int localptr;
    /* For iterators. */
-   struct sljit_label *hotpath;
+   struct sljit_label *matchingpath;
- } assert_fallback;
+ } assert_backtrack;
- typedef struct bracket_fallback {
+ typedef struct bracket_backtrack {
-   fallback_common common;
+   backtrack_common common;
    /* Where to coninue if an alternative is successfully matched. */
-   struct sljit_label *althotpath;
+   struct sljit_label *alternative_matchingpath;
    /* For rmin and rmax iterators. */
-   struct sljit_label *recursivehotpath;
+   struct sljit_label *recursive_matchingpath;
    /* For greedy ? operator. */
-   struct sljit_label *zerohotpath;
+   struct sljit_label *zero_matchingpath;
    /* Contains the branches of a failed condition. */
    union {
      /* Both for OP_COND, OP_SCOND. */
      jump_list *condfailed;
-     assert_fallback *assert;
+     assert_backtrack *assert;
      /* For OP_ONCE. -1 if not needed. */
      int framesize;
    } u;
    /* Points to our private memory word on the stack. */
    int localptr;
- } bracket_fallback;
+ } bracket_backtrack;
- typedef struct bracketpos_fallback {
+ typedef struct bracketpos_backtrack {
-   fallback_common common;
+   backtrack_common common;
    /* Points to our private memory word on the stack. */
    int localptr;
    /* Reverting stack is needed. */
    int framesize;
    /* Allocated stack size. */
    int stacksize;
- } bracketpos_fallback;
+ } bracketpos_backtrack;
- typedef struct braminzero_fallback {
+ typedef struct braminzero_backtrack {
-   fallback_common common;
+   backtrack_common common;
-   struct sljit_label *hotpath;
+   struct sljit_label *matchingpath;
- } braminzero_fallback;
+ } braminzero_backtrack;
- typedef struct iterator_fallback {
+ typedef struct iterator_backtrack {
-   fallback_common common;
+   backtrack_common common;
    /* Next iteration. */
-   struct sljit_label *hotpath;
+   struct sljit_label *matchingpath;
- } iterator_fallback;
+ } iterator_backtrack;
  typedef struct recurse_entry {
    struct recurse_entry *next;
 Line 264 
 typedef struct recurse_entry {
    int start;
  } recurse_entry;
- typedef struct recurse_fallback {
+ typedef struct recurse_backtrack {
-   fallback_common common;
+   backtrack_common common;
- } recurse_fallback;
+ } recurse_backtrack;
+ #define MAX_RANGE_SIZE 6
  typedef struct compiler_common {
    struct sljit_compiler *compiler;
    pcre_uchar *start;
-   /* Local stack area size and variable pointers. */
+   /* Opcode local area direct map. */
-   int localsize;
    int *localptrs;
    int cbraptr;
    /* OVector starting point. Must be divisible by 2. */
-Line 291 
 typedef struct compiler_common {
+Line 292 
 typedef struct compiler_common {
    /* Points to the marked string. */
    int mark_ptr;
-   /* Other  */
+   /* Flipped and lower case tables. */
    const pcre_uint8 *fcc;
    sljit_w lcc;
+   /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
    int mode;
+   /* Newline control. */
    int nltype;
    int newline;
    int bsr_nltype;
+   /* Dollar endonly. */
    int endonly;
    BOOL has_set_som;
+   /* Tables. */
    sljit_w ctypes;
+   int digits[2 + MAX_RANGE_SIZE];
+   /* Named capturing brackets. */
    sljit_uw name_table;
    sljit_w name_count;
    sljit_w name_entry_size;
    /* Labels and jump lists. */
    struct sljit_label *partialmatchlabel;
-   struct sljit_label *leavelabel;
+   struct sljit_label *quitlabel;
    struct sljit_label *acceptlabel;
    stub_list *stubs;
    recurse_entry *entries;
    recurse_entry *currententry;
    jump_list *partialmatch;
-   jump_list *leave;
+   jump_list *quit;
    jump_list *accept;
    jump_list *calllimit;
    jump_list *stackalloc;
-Line 448 
 the start pointers when the end of the c
+Line 455 
 the start pointers when the end of the c
    sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))
  #define COND_VALUE(op, dst, dstw, type) \
    sljit_emit_cond_value(compiler, (op), (dst), (dstw), (type))
+ #define GET_LOCAL_BASE(dst, dstw, offset) \
+   sljit_get_local_base(compiler, (dst), (dstw), (offset))
  static pcre_uchar* bracketend(pcre_uchar* cc)
  {
-Line 466 
 return cc;
+Line 475 
 return cc;
   init_frame
   get_localsize
   copy_locals
-  compile_hotpath
+  compile_matchingpath
-  compile_fallbackpath
+  compile_backtrackingpath
  */
  static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
-Line 666 
 switch(*cc)
+Line 675 
 switch(*cc)
    }
  }
+ #define CASE_ITERATOR_LOCAL1 \
+     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_LOCAL2A \
+     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_LOCAL2B \
+     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_LOCAL1 \
+     case OP_TYPEMINSTAR: \
+     case OP_TYPEMINPLUS: \
+     case OP_TYPEQUERY: \
+     case OP_TYPEMINQUERY:
+ #define CASE_ITERATOR_TYPE_LOCAL2A \
+     case OP_TYPESTAR: \
+     case OP_TYPEPLUS:
+ #define CASE_ITERATOR_TYPE_LOCAL2B \
+     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_localspace(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
  {
  int localspace = 0;
  pcre_uchar *alternative;
+ pcre_uchar *end = NULL;
+ int space, size, bracketlen;
  /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
  while (cc < ccend)
    {
+   space = 0;
+   size = 0;
+   bracketlen = 0;
    switch(*cc)
      {
      case OP_SET_SOM:
-Line 691 
 while (cc < ccend)
+Line 783 
 while (cc < ccend)
      case OP_SBRAPOS:
      case OP_SCOND:
      localspace += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE;
+     bracketlen = 1 + LINK_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
      localspace += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE + IMM2_SIZE;
+     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-Line 705 
 while (cc < ccend)
+Line 797 
 while (cc < ccend)
      alternative = cc + GET(cc, 1);
      if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
        localspace += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE;
+     bracketlen = 1 + LINK_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_LOCAL1
+     space = 1;
+     size = -2;
+     break;
+     CASE_ITERATOR_LOCAL2A
+     space = 2;
+     size = -2;
+     break;
+     CASE_ITERATOR_LOCAL2B
+     space = 2;
+     size = -(2 + IMM2_SIZE);
+     break;
+     CASE_ITERATOR_TYPE_LOCAL1
+     space = 1;
+     size = 1;
+     break;
+     CASE_ITERATOR_TYPE_LOCAL2A
+     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
+       space = 2;
+     size = 1;
      break;
+     CASE_ITERATOR_TYPE_LOCAL2B
+     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
+       space = 2;
+     size = 1 + IMM2_SIZE;
+     break;
+     case OP_CLASS:
+     case OP_NCLASS:
+     size += 1 + 32 / sizeof(pcre_uchar);
+     space = get_class_iterator_size(cc + size);
+     break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_XCLASS:
+     size = GET(cc, 1);
+     space = get_class_iterator_size(cc + size);
+     break;
+ #endif
      case OP_RECURSE:
      /* Set its value only once. */
      if (common->recursive_head == 0)
-Line 733 
 while (cc < ccend)
+Line 879 
 while (cc < ccend)
        return -1;
      break;
      }
+   if (space > 0 && cc >= end)
+     localspace += sizeof(sljit_w) * space;
+   if (size != 0)
+     {
+     if (size < 0)
+       {
+       cc += -size;
+ #ifdef SUPPORT_UTF
+       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+       }
+     else
+       cc += size;
+     }
+   if (bracketlen > 0)
+     {
+     if (cc >= end)
+       {
+       end = bracketend(cc);
+       if (end[-1 - LINK_SIZE] == OP_KET)
+         end = NULL;
+       }
+     cc += bracketlen;
+     }
    }
  return localspace;
  }
-Line 741 
 static void set_localptrs(compiler_commo
+Line 914 
 static void set_localptrs(compiler_commo
  {
  pcre_uchar *cc = common->start;
  pcre_uchar *alternative;
+ pcre_uchar *end = NULL;
+ int space, size, bracketlen;
  while (cc < ccend)
    {
+   space = 0;
+   size = 0;
+   bracketlen = 0;
    switch(*cc)
      {
      case OP_ASSERT:
-Line 757 
 while (cc < ccend)
+Line 936 
 while (cc < ccend)
      case OP_SCOND:
      common->localptrs[cc - common->start] = localptr;
      localptr += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE;
+     bracketlen = 1 + LINK_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
      common->localptrs[cc - common->start] = localptr;
      localptr += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE + IMM2_SIZE;
+     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-Line 775 
 while (cc < ccend)
+Line 954 
 while (cc < ccend)
        common->localptrs[cc - common->start] = localptr;
        localptr += sizeof(sljit_w);
        }
-     cc += 1 + LINK_SIZE;
+     bracketlen = 1 + LINK_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_LOCAL1
+     space = 1;
+     size = -2;
+     break;
+     CASE_ITERATOR_LOCAL2A
+     space = 2;
+     size = -2;
+     break;
+     CASE_ITERATOR_LOCAL2B
+     space = 2;
+     size = -(2 + IMM2_SIZE);
+     break;
+     CASE_ITERATOR_TYPE_LOCAL1
+     space = 1;
+     size = 1;
+     break;
+     CASE_ITERATOR_TYPE_LOCAL2A
+     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
+       space = 2;
+     size = 1;
+     break;
+     CASE_ITERATOR_TYPE_LOCAL2B
+     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
+       space = 2;
+     size = 1 + IMM2_SIZE;
+     break;
+     case OP_CLASS:
+     case OP_NCLASS:
+     size += 1 + 32 / sizeof(pcre_uchar);
+     space = get_class_iterator_size(cc + size);
+     break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_XCLASS:
+     size = GET(cc, 1);
+     space = get_class_iterator_size(cc + size);
+     break;
+ #endif
      default:
      cc = next_opcode(common, cc);
      SLJIT_ASSERT(cc != NULL);
      break;
      }
+   if (space > 0 && cc >= end)
+     {
+     common->localptrs[cc - common->start] = localptr;
+     localptr += sizeof(sljit_w) * space;
+     }
+   if (size != 0)
+     {
+     if (size < 0)
+       {
+       cc += -size;
+ #ifdef SUPPORT_UTF
+       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+       }
+     else
+       cc += size;
+     }
+   if (bracketlen > 0)
+     {
+     if (cc >= end)
+       {
+       end = bracketend(cc);
+       if (end[-1 - LINK_SIZE] == OP_KET)
+         end = NULL;
+       }
+     cc += bracketlen;
+     }
    }
  }
-Line 962 
 SLJIT_ASSERT(stackpos == STACK(stacktop)
+Line 1225 
 SLJIT_ASSERT(stackpos == STACK(stacktop)
  static SLJIT_INLINE int get_localsize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
  {
  int localsize = 2;
+ int size;
  pcre_uchar *alternative;
  /* Calculate the sum of the local variables. */
  while (cc < ccend)
    {
+   size = 0;
    switch(*cc)
      {
      case OP_ASSERT:
-Line 1002 
 while (cc < ccend)
+Line 1267 
 while (cc < ccend)
      cc += 1 + LINK_SIZE;
      break;
+     CASE_ITERATOR_LOCAL1
+     if (PRIV_DATA(cc))
+       localsize++;
+     cc += 2;
+ #ifdef SUPPORT_UTF
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+     break;
+     CASE_ITERATOR_LOCAL2A
+     if (PRIV_DATA(cc))
+       localsize += 2;
+     cc += 2;
+ #ifdef SUPPORT_UTF
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+     break;
+     CASE_ITERATOR_LOCAL2B
+     if (PRIV_DATA(cc))
+       localsize += 2;
+     cc += 2 + IMM2_SIZE;
+ #ifdef SUPPORT_UTF
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+     break;
+     CASE_ITERATOR_TYPE_LOCAL1
+     if (PRIV_DATA(cc))
+       localsize++;
+     cc += 1;
+     break;
+     CASE_ITERATOR_TYPE_LOCAL2A
+     if (PRIV_DATA(cc))
+       localsize += 2;
+     cc += 1;
+     break;
+     CASE_ITERATOR_TYPE_LOCAL2B
+     if (PRIV_DATA(cc))
+       localsize += 2;
+     cc += 1 + IMM2_SIZE;
+     break;
+     case OP_CLASS:
+     case OP_NCLASS:
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_XCLASS:
+     size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);
+ #else
+     size = 1 + 32 / (int)sizeof(pcre_uchar);
+ #endif
+     if (PRIV_DATA(cc))
+       localsize += get_class_iterator_size(cc + size);
+     cc += size;
+     break;
      default:
      cc = next_opcode(common, cc);
      SLJIT_ASSERT(cc != NULL);
-Line 1017 
 static void copy_locals(compiler_common
+Line 1340 
 static void copy_locals(compiler_common
  {
  DEFINE_COMPILER;
  int srcw[2];
- int count;
+ int count, size;
  BOOL tmp1next = TRUE;
  BOOL tmp1empty = TRUE;
  BOOL tmp2empty = TRUE;
-Line 1097 
 while (status != end)
+Line 1420 
 while (status != end)
        case OP_CBRAPOS:
        case OP_SCBRAPOS:
        count = 2;
-       srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
+       srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
-       srcw[0] = PRIV_DATA(cc);
+       srcw[1] = PRIV_DATA(cc);
        SLJIT_ASSERT(srcw[0] != 0);
        cc += 1 + LINK_SIZE + IMM2_SIZE;
        break;
-Line 1115 
 while (status != end)
+Line 1438 
 while (status != end)
        cc += 1 + LINK_SIZE;
        break;
+       CASE_ITERATOR_LOCAL1
+       if (PRIV_DATA(cc))
+         {
+         count = 1;
+         srcw[0] = PRIV_DATA(cc);
+         }
+       cc += 2;
+ #ifdef SUPPORT_UTF
+       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+       break;
+       CASE_ITERATOR_LOCAL2A
+       if (PRIV_DATA(cc))
+         {
+         count = 2;
+         srcw[0] = PRIV_DATA(cc);
+         srcw[1] = PRIV_DATA(cc) + sizeof(sljit_w);
+         }
+       cc += 2;
+ #ifdef SUPPORT_UTF
+       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+       break;
+       CASE_ITERATOR_LOCAL2B
+       if (PRIV_DATA(cc))
+         {
+         count = 2;
+         srcw[0] = PRIV_DATA(cc);
+         srcw[1] = PRIV_DATA(cc) + sizeof(sljit_w);
+         }
+       cc += 2 + IMM2_SIZE;
+ #ifdef SUPPORT_UTF
+       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+       break;
+       CASE_ITERATOR_TYPE_LOCAL1
+       if (PRIV_DATA(cc))
+         {
+         count = 1;
+         srcw[0] = PRIV_DATA(cc);
+         }
+       cc += 1;
+       break;
+       CASE_ITERATOR_TYPE_LOCAL2A
+       if (PRIV_DATA(cc))
+         {
+         count = 2;
+         srcw[0] = PRIV_DATA(cc);
+         srcw[1] = srcw[0] + sizeof(sljit_w);
+         }
+       cc += 1;
+       break;
+       CASE_ITERATOR_TYPE_LOCAL2B
+       if (PRIV_DATA(cc))
+         {
+         count = 2;
+         srcw[0] = PRIV_DATA(cc);
+         srcw[1] = srcw[0] + sizeof(sljit_w);
+         }
+       cc += 1 + IMM2_SIZE;
+       break;
+       case OP_CLASS:
+       case OP_NCLASS:
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+       case OP_XCLASS:
+       size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);
+ #else
+       size = 1 + 32 / (int)sizeof(pcre_uchar);
+ #endif
+       if (PRIV_DATA(cc))
+         switch(get_class_iterator_size(cc + size))
+           {
+           case 1:
+           count = 1;
+           srcw[0] = PRIV_DATA(cc);
+           break;
+           case 2:
+           count = 2;
+           srcw[0] = PRIV_DATA(cc);
+           srcw[1] = srcw[0] + sizeof(sljit_w);
+           break;
+           default:
+           SLJIT_ASSERT_STOP();
+           break;
+           }
+       cc += size;
+       break;
        default:
        cc = next_opcode(common, cc);
        SLJIT_ASSERT(cc != NULL);
-Line 1217 
 if (save)
+Line 1636 
 if (save)
  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
  }
+ #undef CASE_ITERATOR_LOCAL1
+ #undef CASE_ITERATOR_LOCAL2A
+ #undef CASE_ITERATOR_LOCAL2B
+ #undef CASE_ITERATOR_TYPE_LOCAL1
+ #undef CASE_ITERATOR_TYPE_LOCAL2A
+ #undef CASE_ITERATOR_TYPE_LOCAL2B
  static SLJIT_INLINE BOOL ispowerof2(unsigned int value)
  {
  return (value & (value - 1)) == 0;
-Line 1227 
 static SLJIT_INLINE void set_jumps(jump_
+Line 1653 
 static SLJIT_INLINE void set_jumps(jump_
  while (list)
    {
    /* sljit_set_label is clever enough to do nothing
-   if either the jump or the label is NULL */
+   if either the jump or the label is NULL. */
    sljit_set_label(list->jump, label);
    list = list->next;
    }
-Line 1254 
 if (list_item)
+Line 1680 
 if (list_item)
    list_item->type = type;
    list_item->data = data;
    list_item->start = start;
-   list_item->leave = LABEL();
+   list_item->quit = LABEL();
    list_item->next = common->stubs;
    common->stubs = list_item;
    }
-Line 1274 
 while (list_item)
+Line 1700 
 while (list_item)
      add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
      break;
      }
-   JUMPTO(SLJIT_JUMP, list_item->leave);
+   JUMPTO(SLJIT_JUMP, list_item->quit);
    list_item = list_item->next;
    }
  common->stubs = NULL;
-Line 1325 
 if (length < 8)
+Line 1751 
 if (length < 8)
    }
  else
    {
-   OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START - sizeof(sljit_w));
+   GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, OVECTOR_START - sizeof(sljit_w));
    OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, length);
    loop = LABEL();
    OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(sljit_w), SLJIT_TEMPORARY_REG1, 0);
-Line 1352 
 if (common->mark_ptr != 0)
+Line 1778 
 if (common->mark_ptr != 0)
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_TEMPORARY_REG3, 0);
  OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
  OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, begin));
- OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START);
+ GET_LOCAL_BASE(SLJIT_SAVED_REG1, 0, OVECTOR_START);
  /* Unlikely, but possible */
  earlyexit = CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 0);
  loop = LABEL();
-Line 1370 
 JUMPHERE(earlyexit);
+Line 1796 
 JUMPHERE(earlyexit);
  /* Calculate the return value, which is the maximum ovector value. */
  if (topbracket > 1)
    {
-   OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START + topbracket * 2 * sizeof(sljit_w));
+   GET_LOCAL_BASE(SLJIT_TEMPORARY_REG1, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_w));
    OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, topbracket + 1);
    /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */
-Line 1384 
 else
+Line 1810 
 else
    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
  }
- static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *leave)
+ static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)
  {
  DEFINE_COMPILER;
-Line 1394 
 SLJIT_ASSERT(common->start_used_ptr != 0
+Line 1820 
 SLJIT_ASSERT(common->start_used_ptr != 0
  OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
  OP1(SLJIT_MOV_SI, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, offsetcount));
- CMPTO(SLJIT_C_LESS, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 2, leave);
+ CMPTO(SLJIT_C_LESS, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 2, quit);
  /* Store match begin and end. */
  OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, begin));
-Line 1412 
 OP2(SLJIT_ASHR, SLJIT_TEMPORARY_REG3, 0,
+Line 1838 
 OP2(SLJIT_ASHR, SLJIT_TEMPORARY_REG3, 0,
  #endif
  OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), 0, SLJIT_TEMPORARY_REG3, 0);
- JUMPTO(SLJIT_JUMP, leave);
+ JUMPTO(SLJIT_JUMP, quit);
  }
  static SLJIT_INLINE void check_start_used_ptr(compiler_common *common)
-Line 1621 
 JUMPHERE(jump);
+Line 2047 
 JUMPHERE(jump);
  return return_value;
  }
- static void fallback_at_str_end(compiler_common *common, jump_list **fallbacks)
+ static void detect_partial_match(compiler_common *common, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  struct sljit_jump *jump;
  if (common->mode == JIT_COMPILE)
    {
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
    return;
    }
  /* Partial matching mode. */
  jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
- add_jump(compiler, fallbacks, 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));
  if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
    {
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);
-   add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+   add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
    }
  else
    {
-Line 1788 
 if (common->utf)
+Line 2214 
 if (common->utf)
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  }
- static void check_newlinechar(compiler_common *common, int nltype, jump_list **fallbacks, BOOL jumpiftrue)
+ static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpiftrue)
  {
  /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */
  DEFINE_COMPILER;
-Line 1796 
 DEFINE_COMPILER;
+Line 2222 
 DEFINE_COMPILER;
  if (nltype == NLTYPE_ANY)
    {
    add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    }
  else if (nltype == NLTYPE_ANYCRLF)
    {
-Line 1804 
 else if (nltype == NLTYPE_ANYCRLF)
+Line 2230 
 else if (nltype == NLTYPE_ANYCRLF)
    COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
    COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
-   add_jump(compiler, fallbacks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    }
  else
    {
    SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);
-   add_jump(compiler, fallbacks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
+   add_jump(compiler, backtracks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
    }
  }
-Line 1823 
 of the character (>= 0xc0). Return char
+Line 2249 
 of the character (>= 0xc0). Return char
  DEFINE_COMPILER;
  struct sljit_jump *jump;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  /* Searching for the first zero. */
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
  jump = JUMP(SLJIT_C_NOT_ZERO);
-Line 1882 
 DEFINE_COMPILER;
+Line 2308 
 DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_jump *compare;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
  jump = JUMP(SLJIT_C_NOT_ZERO);
-Line 1919 
 of the character (>= 0xd800). Return cha
+Line 2345 
 of the character (>= 0xd800). Return cha
  DEFINE_COMPILER;
  struct sljit_jump *jump;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ 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);
-Line 1956 
 DEFINE_COMPILER;
+Line 2382 
 DEFINE_COMPILER;
  SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8);
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_w)PRIV(ucd_stage1));
  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);
-Line 1993 
 if (firstline)
+Line 2419 
 if (firstline)
    {
    /* Search for the end of the first line. */
    SLJIT_ASSERT(common->first_line_end != 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STR_PTR, 0);
+   OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_END, 0);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
-Line 2005 
 if (firstline)
+Line 2430 
 if (firstline)
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
      CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
      CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
+     JUMPHERE(end);
      OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      }
    else
-Line 2016 
 if (firstline)
+Line 2442 
 if (firstline)
      read_char(common);
      check_newlinechar(common, common->nltype, &newline, TRUE);
      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
+     JUMPHERE(end);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);
      set_jumps(newline, LABEL());
      }
-   JUMPHERE(end);
+   OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
-   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
    }
  start = JUMP(SLJIT_JUMP);
-Line 2043 
 if (newlinecheck)
+Line 2469 
 if (newlinecheck)
  mainloop = LABEL();
  /* Increasing the STR_PTR here requires one less jump in the most common case. */
  #ifdef SUPPORT_UTF
  if (common->utf) readuchar = TRUE;
+ #endif
+ if (newlinecheck) readuchar = TRUE;
+ if (readuchar)
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ if (newlinecheck)
+   CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ if (common->utf)
+   {
+   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   JUMPHERE(singlechar);
+   }
+ #endif
+ #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ if (common->utf)
+   {
+   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+   JUMPHERE(singlechar);
+   }
+ #endif
+ JUMPHERE(start);
+ if (newlinecheck)
+   {
+   JUMPHERE(end);
+   JUMPHERE(nl);
+   }
+ return mainloop;
+ }
+ static SLJIT_INLINE BOOL fast_forward_first_two_chars(compiler_common *common, BOOL firstline)
+ {
+ DEFINE_COMPILER;
+ struct sljit_label *start;
+ struct sljit_jump *quit;
+ struct sljit_jump *found;
+ pcre_int32 chars[4];
+ pcre_uchar *cc = common->start + 1 + IMM2_SIZE;
+ int location = 0;
+ pcre_int32 len, c, bit, caseless;
+ BOOL must_end;
+ #ifdef COMPILE_PCRE8
+ union {
+     sljit_uh ascombined;
+     sljit_ub asuchars[2];
+ } pair;
+ #else
+ union {
+     sljit_ui ascombined;
+     sljit_uh asuchars[2];
+ } pair;
+ #endif
+ if (*(common->start + GET(common->start, 1)) == OP_ALT)
+   return FALSE;
+ while (TRUE)
+   {
+   caseless = 0;
+   must_end = TRUE;
+   switch(*cc)
+     {
+     case OP_CHAR:
+     must_end = FALSE;
+     cc++;
+     break;
+     case OP_CHARI:
+     caseless = 1;
+     must_end = FALSE;
+     cc++;
+     break;
+     case OP_SOD:
+     case OP_SOM:
+     case OP_SET_SOM:
+     case OP_NOT_WORD_BOUNDARY:
+     case OP_WORD_BOUNDARY:
+     case OP_EODN:
+     case OP_EOD:
+     case OP_CIRC:
+     case OP_CIRCM:
+     case OP_DOLL:
+     case OP_DOLLM:
+     /* Zero width assertions. */
+     cc++;
+     continue;
+     case OP_PLUS:
+     case OP_MINPLUS:
+     case OP_POSPLUS:
+     cc++;
+     break;
+     case OP_EXACT:
+     cc += 1 + IMM2_SIZE;
+     break;
+     case OP_PLUSI:
+     case OP_MINPLUSI:
+     case OP_POSPLUSI:
+     caseless = 1;
+     cc++;
+     break;
+     case OP_EXACTI:
+     caseless = 1;
+     cc += 1 + IMM2_SIZE;
+     break;
+     default:
+     return FALSE;
+     }
+   len = 1;
+ #ifdef SUPPORT_UTF
+   if (common->utf && HAS_EXTRALEN(cc[0])) len += GET_EXTRALEN(cc[0]);
+ #endif
+   if (caseless && char_has_othercase(common, cc))
+     {
+     caseless = char_get_othercase_bit(common, cc);
+     if (caseless == 0)
+       return FALSE;
+ #ifdef COMPILE_PCRE8
+     caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));
+ #else
+     if ((caseless & 0x100) != 0)
+       caseless = ((caseless & 0xff) << 16) | (len - (caseless >> 9));
+     else
+       caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 9));
+ #endif
+     }
+   else
+     caseless = 0;
+   while (len > 0 && location < 2 * 2)
+     {
+     c = *cc;
+     bit = 0;
+     if (len == (caseless & 0xff))
+       {
+       bit = caseless >> 8;
+       c |= bit;
+       }
+     chars[location] = c;
+     chars[location + 1] = bit;
+     len--;
+     location += 2;
+     cc++;
+     }
+   if (location == 2 * 2)
+     break;
+   else if (must_end)
+     return FALSE;
+   }
+ if (firstline)
+   {
+   SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
+   OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, 1);
+   }
+ else
+   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, 1);
+ start = LABEL();
+ quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
+ #ifdef COMPILE_PCRE8
+ OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ #else /* COMPILE_PCRE8 */
+ OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
  #endif
- if (newlinecheck) readuchar = TRUE;
- if (readuchar)
+ #else /* SLJIT_UNALIGNED */
-   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- if (newlinecheck)
+ #if defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN
-   CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ #else /* SLJIT_BIG_ENDIAN */
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+ #endif /* SLJIT_BIG_ENDIAN */
- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ #ifdef COMPILE_PCRE8
- #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 8);
- if (common->utf)
+ #else /* COMPILE_PCRE8 */
-   {
+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 16);
-   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
-   JUMPHERE(singlechar);
-   }
  #endif
- #if defined SUPPORT_UTF && defined COMPILE_PCRE16
+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
- if (common->utf)
-   {
-   singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
-   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
-   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
-   JUMPHERE(singlechar);
-   }
  #endif
- JUMPHERE(start);
- if (newlinecheck)
+ if (chars[1] != 0 || chars[3] != 0)
    {
-   JUMPHERE(end);
+   pair.asuchars[0] = chars[1];
-   JUMPHERE(nl);
+   pair.asuchars[1] = chars[3];
+   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, pair.ascombined);
    }
- return mainloop;
+ pair.asuchars[0] = chars[0];
+ pair.asuchars[1] = chars[2];
+ found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, pair.ascombined);
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ JUMPTO(SLJIT_JUMP, start);
+ JUMPHERE(found);
+ JUMPHERE(quit);
+ if (firstline)
+   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+ else
+   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, 1);
+ return TRUE;
  }
  static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)
  {
  DEFINE_COMPILER;
  struct sljit_label *start;
- struct sljit_jump *leave;
+ struct sljit_jump *quit;
  struct sljit_jump *found;
  pcre_uchar oc, bit;
  if (firstline)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
+   SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
  start = LABEL();
- leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
  oc = first_char;
-Line 2136 
 else
+Line 2754 
 else
    }
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #if defined SUPPORT_UTF && defined COMPILE_PCRE8
- if (common->utf)
-   {
-   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)PRIV(utf8_table4) - 0xc0);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
-   }
- #endif
- #if defined SUPPORT_UTF && defined COMPILE_PCRE16
- if (common->utf)
-   {
-   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
-   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
-   COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
-   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
-   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
-   }
- #endif
  JUMPTO(SLJIT_JUMP, start);
  JUMPHERE(found);
- JUMPHERE(leave);
+ JUMPHERE(quit);
  if (firstline)
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
  static SLJIT_INLINE void fast_forward_newline(compiler_common *common, BOOL firstline)
-Line 2169 
 DEFINE_COMPILER;
+Line 2768 
 DEFINE_COMPILER;
  struct sljit_label *loop;
  struct sljit_jump *lastchar;
  struct sljit_jump *firstchar;
- struct sljit_jump *leave;
+ struct sljit_jump *quit;
  struct sljit_jump *foundcr = NULL;
  struct sljit_jump *notfoundnl;
  jump_list *newline = NULL;
  if (firstline)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
+   SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
-Line 2198 
 if (common->nltype == NLTYPE_FIXED && co
+Line 2798 
 if (common->nltype == NLTYPE_FIXED && co
    loop = LABEL();
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-   leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+   quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);
    CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);
-   JUMPHERE(leave);
+   JUMPHERE(quit);
    JUMPHERE(firstchar);
    JUMPHERE(lastchar);
-Line 2228 
 set_jumps(newline, loop);
+Line 2828 
 set_jumps(newline, loop);
  if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
    {
-   leave = JUMP(SLJIT_JUMP);
+   quit = JUMP(SLJIT_JUMP);
    JUMPHERE(foundcr);
    notfoundnl = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
-Line 2239 
 if (common->nltype == NLTYPE_ANY || comm
+Line 2839 
 if (common->nltype == NLTYPE_ANY || comm
  #endif
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    JUMPHERE(notfoundnl);
-   JUMPHERE(leave);
+   JUMPHERE(quit);
    }
  JUMPHERE(lastchar);
  JUMPHERE(firstchar);
  if (firstline)
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
  }
  static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline)
  {
  DEFINE_COMPILER;
  struct sljit_label *start;
- struct sljit_jump *leave;
+ struct sljit_jump *quit;
  struct sljit_jump *found;
  #ifndef COMPILE_PCRE8
  struct sljit_jump *jump;
-Line 2260 
 struct sljit_jump *jump;
+Line 2860 
 struct sljit_jump *jump;
  if (firstline)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
+   SLJIT_ASSERT(common->first_line_end != 0);
+   OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);
    OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
    }
  start = LABEL();
- leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
  #ifdef SUPPORT_UTF
  if (common->utf)
-Line 2309 
 if (common->utf)
+Line 2910 
 if (common->utf)
  #endif
  JUMPTO(SLJIT_JUMP, start);
  JUMPHERE(found);
- JUMPHERE(leave);
+ JUMPHERE(quit);
  if (firstline)
-   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+   OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0);
  }
  static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uchar req_char, BOOL caseless, BOOL has_firstchar)
-Line 2384 
 DEFINE_COMPILER;
+Line 2985 
 DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_label *mainloop;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP1(SLJIT_MOV, TMP1, 0, STACK_TOP, 0);
+ GET_LOCAL_BASE(TMP3, 0, 0);
  /* Drop frames until we reach STACK_TOP. */
  mainloop = LABEL();
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
  jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
- OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_LOCALS_REG, 0);
+ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
  OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_w), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_w));
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_w));
-Line 2437 
 struct sljit_jump *jump;
+Line 3039 
 struct sljit_jump *jump;
  SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);
- sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
  /* Get type of the previous char, and put it to LOCALS1. */
  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
-Line 2535 
 OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSE
+Line 3137 
 OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSE
  sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
  }
+ /*
+   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)
+ {
+ DEFINE_COMPILER;
+ struct sljit_jump *jump;
+ 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]) && ispowerof2(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];
+ pcre_uint8 bit, cbit, all;
+ int i, byte, length = 0;
+ bit = bits[0] & 0x1;
+ ranges[1] = bit;
+ /* Can be 0 or 255. */
+ all = -bit;
+ for (i = 0; i < 256; )
+   {
+   byte = i >> 3;
+   if ((i & 0x7) == 0 && bits[byte] == all)
+     i += 8;
+   else
+     {
+     cbit = (bits[byte] >> (i & 0x7)) & 0x1;
+     if (cbit != bit)
+       {
+       if (length >= MAX_RANGE_SIZE)
+         return FALSE;
+       ranges[2 + length] = i;
+       length++;
+       bit = cbit;
+       all = -cbit;
+       }
+     i++;
+     }
+   }
+ if (((bit == 0) && nclass) || ((bit == 1) && !nclass))
+   {
+   if (length >= MAX_RANGE_SIZE)
+     return FALSE;
+   ranges[2 + length] = 256;
+   length++;
+   }
+ ranges[0] = length;
+ return check_ranges(common, ranges, backtracks, FALSE);
+ }
  static void check_anynewline(compiler_common *common)
  {
  /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
  DEFINE_COMPILER;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
-Line 2567 
 static void check_hspace(compiler_common
+Line 3308 
 static void check_hspace(compiler_common
  /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
  DEFINE_COMPILER;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);
  COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
-Line 2606 
 static void check_vspace(compiler_common
+Line 3347 
 static void check_vspace(compiler_common
  /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
  DEFINE_COMPILER;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
-Line 2638 
 DEFINE_COMPILER;
+Line 3379 
 DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_label *label;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
  OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);
  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR2, 0);
-Line 2667 
 DEFINE_COMPILER;
+Line 3408 
 DEFINE_COMPILER;
  struct sljit_jump *jump;
  struct sljit_label *label;
- sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
+ sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
  OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);
-Line 2731 
 return src2;
+Line 3472 
 return src2;
  #endif /* SUPPORT_UTF && SUPPORT_UCP */
  static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,
-     compare_context* context, jump_list **fallbacks)
+     compare_context* context, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  unsigned int othercasebit = 0;
-Line 2832 
 do
+Line 3573 
 do
        case 4 / sizeof(pcre_uchar):
        if (context->oc.asint != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
        break;
        case 2 / sizeof(pcre_uchar):
        if (context->oc.asushort != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));
        break;
  #ifdef COMPILE_PCRE8
        case 1:
        if (context->oc.asbyte != 0)
          OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
        break;
  #endif
-Line 2871 
 do
+Line 3612 
 do
    if (othercasebit != 0 && othercasechar == cc)
      {
      OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
      }
    else
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
  #endif
-Line 2910 
 return cc;
+Line 3651 
 return cc;
      } \
    charoffset = (value);
- static void compile_xclass_hotpath(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks)
+ static void compile_xclass_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  jump_list *found = NULL;
- jump_list **list = (*cc & XCL_NOT) == 0 ? &found : fallbacks;
+ jump_list **list = (*cc & XCL_NOT) == 0 ? &found : backtracks;
  unsigned int c;
  int compares;
  struct sljit_jump *jump = NULL;
-Line 2928 
 unsigned int typeoffset;
+Line 3669 
 unsigned int typeoffset;
  int invertcmp, numberofcmps;
  unsigned int charoffset;
- /* Although SUPPORT_UTF must be defined, we are not necessary in utf mode. */
+ /* Although SUPPORT_UTF must be defined, we are
- fallback_at_str_end(common, fallbacks);
+    not necessary in utf mode even in 8 bit mode. */
+ detect_partial_match(common, backtracks);
  read_char(common);
  if ((*cc++ & XCL_MAP) != 0)
-Line 2942 
 if ((*cc++ & XCL_MAP) != 0)
+Line 3684 
 if ((*cc++ & XCL_MAP) != 0)
      jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
  #endif
-   OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
+   if (!check_class_ranges(common, (const pcre_uint8 *)cc, TRUE, list))
-   OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
+     {
-   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
+     OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
-   OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
+     OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
-   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
-   add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));
+     OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
+     OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+     add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));
+     }
  #ifndef COMPILE_PCRE8
    JUMPHERE(jump);
-Line 3080 
 typeoffset = 0;
+Line 3825 
 typeoffset = 0;
  while (*cc != XCL_END)
    {
    compares--;
-   invertcmp = (compares == 0 && list != fallbacks);
+   invertcmp = (compares == 0 && list != backtracks);
    jump = NULL;
    if (*cc == XCL_SINGLE)
-Line 3162 
 while (*cc != XCL_END)
+Line 3907 
 while (*cc != XCL_END)
      switch(*cc)
        {
        case PT_ANY:
-       if (list != fallbacks)
+       if (list != backtracks)
          {
          if ((cc[-1] == XCL_NOTPROP && compares > 0) || (cc[-1] == XCL_PROP && compares == 0))
            continue;
-Line 3235 
 while (*cc != XCL_END)
+Line 3980 
 while (*cc != XCL_END)
  #endif
    if (jump != NULL)
-     add_jump(compiler, compares > 0 ? list : fallbacks, jump);
+     add_jump(compiler, compares > 0 ? list : backtracks, jump);
    }
  if (found != NULL)
-Line 3247 
 if (found != NULL)
+Line 3992 
 if (found != NULL)
  #endif
- static pcre_uchar *compile_char1_hotpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **fallbacks)
+ static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  int length;
-Line 3266 
 switch(type)
+Line 4011 
 switch(type)
    case OP_SOD:
    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
    return cc;
    case OP_SOM:
    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
    return cc;
    case OP_NOT_WORD_BOUNDARY:
    case OP_WORD_BOUNDARY:
    add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    return cc;
    case OP_NOT_DIGIT:
    case OP_DIGIT:
-   fallback_at_str_end(common, fallbacks);
+   /* Digits are usually 0-9, so it is worth to optimize them. */
-   read_char8_type(common);
+   if (common->digits[0] == -2)
-   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
+     get_ctype_ranges(common, ctype_digit, common->digits);
-   add_jump(compiler, fallbacks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
+   detect_partial_match(common, backtracks);
+   /* Flip the starting bit in the negative case. */
+   if (type == OP_NOT_DIGIT)
+     common->digits[1] ^= 1;
+   if (!check_ranges(common, common->digits, backtracks, TRUE))
+     {
+     read_char8_type(common);
+     OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
+     add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
+     }
+   if (type == OP_NOT_DIGIT)
+     common->digits[1] ^= 1;
    return cc;
    case OP_NOT_WHITESPACE:
    case OP_WHITESPACE:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char8_type(common);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);
-   add_jump(compiler, fallbacks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
    return cc;
    case OP_NOT_WORDCHAR:
    case OP_WORDCHAR:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char8_type(common);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);
-   add_jump(compiler, fallbacks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
    return cc;
    case OP_ANY:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
-Line 3317 
 switch(type)
+Line 4073 
 switch(type)
        jump[1] = check_str_end(common);
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
-     add_jump(compiler, fallbacks, 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));
      if (jump[1] != NULL)
        JUMPHERE(jump[1]);
      JUMPHERE(jump[0]);
      }
    else
-     check_newlinechar(common, common->nltype, fallbacks, TRUE);
+     check_newlinechar(common, common->nltype, backtracks, TRUE);
    return cc;
    case OP_ALLANY:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
  #ifdef SUPPORT_UTF
    if (common->utf)
      {
-Line 3355 
 switch(type)
+Line 4111 
 switch(type)
    return cc;
    case OP_ANYBYTE:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    return cc;
-Line 3368 
 switch(type)
+Line 4124 
 switch(type)
    propdata[2] = cc[0];
    propdata[3] = cc[1];
    propdata[4] = XCL_END;
-   compile_xclass_hotpath(common, propdata, fallbacks);
+   compile_xclass_matchingpath(common, propdata, backtracks);
    return cc + 2;
  #endif
  #endif
    case OP_ANYNL:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
    /* We don't need to handle soft partial matching case. */
-Line 3387 
 switch(type)
+Line 4143 
 switch(type)
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
    jump[3] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[0]);
-   check_newlinechar(common, common->bsr_nltype, fallbacks, FALSE);
+   check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);
    JUMPHERE(jump[1]);
    JUMPHERE(jump[2]);
    JUMPHERE(jump[3]);
-Line 3395 
 switch(type)
+Line 4151 
 switch(type)
    case OP_NOT_HSPACE:
    case OP_HSPACE:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    return cc;
    case OP_NOT_VSPACE:
    case OP_VSPACE:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
    return cc;
  #ifdef SUPPORT_UCP
    case OP_EXTUNI:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Mc);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc));
    label = LABEL();
    jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
-Line 3445 
 switch(type)
+Line 4201 
 switch(type)
      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
      if (common->mode == JIT_COMPILE)
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
      else
        {
        jump[1] = CMP(SLJIT_C_EQUAL, TMP2, 0, STR_END, 0);
-Line 3453 
 switch(type)
+Line 4209 
 switch(type)
        COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS);
        OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
        COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_NOT_EQUAL);
-       add_jump(compiler, fallbacks, JUMP(SLJIT_C_NOT_EQUAL));
+       add_jump(compiler, backtracks, JUMP(SLJIT_C_NOT_EQUAL));
        check_partial(common, TRUE);
-       add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+       add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
        JUMPHERE(jump[1]);
        }
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
    else if (common->nltype == NLTYPE_FIXED)
      {
      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
      }
    else
      {
-Line 3476 
 switch(type)
+Line 4232 
 switch(type)
      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
      OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
      jump[2] = JUMP(SLJIT_C_GREATER);
-     add_jump(compiler, fallbacks, JUMP(SLJIT_C_LESS));
+     add_jump(compiler, backtracks, JUMP(SLJIT_C_LESS));
      /* Equal. */
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
      jump[3] = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
-     add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
      JUMPHERE(jump[1]);
      if (common->nltype == NLTYPE_ANYCRLF)
        {
        OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
        }
      else
        {
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, STR_PTR, 0);
        read_char(common);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
        add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
-       add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
+       add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
        }
      JUMPHERE(jump[2]);
-Line 3506 
 switch(type)
+Line 4262 
 switch(type)
    return cc;
    case OP_EOD:
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
    check_partial(common, FALSE);
    return cc;
    case OP_CIRC:
    OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0));
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
    return cc;
    case OP_CIRCM:
-Line 3523 
 switch(type)
+Line 4279 
 switch(type)
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
    jump[1] = CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0);
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
    jump[0] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[1]);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
    if (common->nltype == NLTYPE_FIXED && common->newline > 255)
      {
      OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, TMP1, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP2, 0, TMP1, 0));
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
    else
      {
      skip_char_back(common);
      read_char(common);
-     check_newlinechar(common, common->nltype, fallbacks, FALSE);
+     check_newlinechar(common, common->nltype, backtracks, FALSE);
      }
    JUMPHERE(jump[0]);
    return cc;
-Line 3549 
 switch(type)
+Line 4305 
 switch(type)
    case OP_DOLL:
    OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
    if (!common->endonly)
-     compile_char1_hotpath(common, OP_EODN, cc, fallbacks);
+     compile_char1_matchingpath(common, OP_EODN, cc, backtracks);
    else
      {
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
      check_partial(common, FALSE);
      }
    return cc;
-Line 3564 
 switch(type)
+Line 4320 
 switch(type)
    jump[1] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
    OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
    OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
    check_partial(common, FALSE);
    jump[0] = JUMP(SLJIT_JUMP);
    JUMPHERE(jump[1]);
-Line 3574 
 switch(type)
+Line 4330 
 switch(type)
      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
      if (common->mode == JIT_COMPILE)
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));
      else
        {
        jump[1] = CMP(SLJIT_C_LESS_EQUAL, TMP2, 0, STR_END, 0);
        /* STR_PTR = STR_END - IN_UCHARS(1) */
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
        check_partial(common, TRUE);
-       add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+       add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
        JUMPHERE(jump[1]);
        }
      OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
      }
    else
      {
      peek_char(common);
-     check_newlinechar(common, common->nltype, fallbacks, FALSE);
+     check_newlinechar(common, common->nltype, backtracks, FALSE);
      }
    JUMPHERE(jump[0]);
    return cc;
-Line 3606 
 switch(type)
+Line 4362 
 switch(type)
    if (common->mode == JIT_COMPILE && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))
      {
      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
      context.length = IN_UCHARS(length);
      context.sourcereg = -1;
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
      context.ucharptr = 0;
  #endif
-     return byte_sequence_compare(common, type == OP_CHARI, cc, &context, fallbacks);
+     return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);
      }
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
  #ifdef SUPPORT_UTF
    if (common->utf)
-Line 3627 
 switch(type)
+Line 4383 
 switch(type)
      c = *cc;
    if (type == OP_CHAR || !char_has_othercase(common, cc))
      {
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
      return cc + length;
      }
    oc = char_othercase(common, c);
-Line 3635 
 switch(type)
+Line 4391 
 switch(type)
    if (ispowerof2(bit))
      {
      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
      return cc + length;
      }
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);
    COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
-   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char_othercase(common, c));
+   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);
    COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
-   add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
    return cc + length;
    case OP_NOT:
    case OP_NOTI:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    length = 1;
  #ifdef SUPPORT_UTF
    if (common->utf)
-Line 3658 
 switch(type)
+Line 4414 
 switch(type)
        {
        OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
        if (type == OP_NOT || !char_has_othercase(common, cc))
-         add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
+         add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
        else
          {
          /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */
          OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20);
-         add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));
+         add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));
          }
        /* Skip the variable-length character. */
        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
-Line 3688 
 switch(type)
+Line 4444 
 switch(type)
      }
    if (type == OP_NOT || !char_has_othercase(common, cc))
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
    else
      {
      oc = char_othercase(common, c);
-Line 3696 
 switch(type)
+Line 4452 
 switch(type)
      if (ispowerof2(bit))
        {
        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
        }
      else
        {
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
-       add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));
+       add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));
        }
      }
    return cc + length;
    case OP_CLASS:
    case OP_NCLASS:
-   fallback_at_str_end(common, fallbacks);
+   detect_partial_match(common, backtracks);
    read_char(common);
+   if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, backtracks))
+     return cc + 32 / sizeof(pcre_uchar);
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    jump[0] = NULL;
  #ifdef COMPILE_PCRE8
-Line 3721 
 switch(type)
+Line 4480 
 switch(type)
      jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
      if (type == OP_CLASS)
        {
-       add_jump(compiler, fallbacks, jump[0]);
+       add_jump(compiler, backtracks, jump[0]);
        jump[0] = NULL;
        }
      }
-Line 3731 
 switch(type)
+Line 4490 
 switch(type)
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
    OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
-   add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
+   add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    if (jump[0] != NULL)
      JUMPHERE(jump[0]);
-Line 3740 
 switch(type)
+Line 4499 
 switch(type)
  #if defined SUPPORT_UTF || defined COMPILE_PCRE16
    case OP_XCLASS:
-   compile_xclass_hotpath(common, cc + LINK_SIZE, fallbacks);
+   compile_xclass_matchingpath(common, cc + LINK_SIZE, backtracks);
    return cc + GET(cc, 0) - 1;
  #endif
    case OP_REVERSE:
    length = GET(cc, 0);
-   SLJIT_ASSERT(length > 0);
+   if (length == 0)
+     return cc + LINK_SIZE;
    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  #ifdef SUPPORT_UTF
    if (common->utf)
-Line 3754 
 switch(type)
+Line 4514 
 switch(type)
      OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);
      label = LABEL();
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP3, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP3, 0));
      skip_char_back(common);
      OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
      JUMPTO(SLJIT_C_NOT_ZERO, label);
-Line 3764 
 switch(type)
+Line 4524 
 switch(type)
      {
      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
      }
    check_start_used_ptr(common);
    return cc + LINK_SIZE;
-Line 3773 
 SLJIT_ASSERT_STOP();
+Line 4533 
 SLJIT_ASSERT_STOP();
  return cc;
  }
- static SLJIT_INLINE pcre_uchar *compile_charn_hotpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **fallbacks)
+ static SLJIT_INLINE pcre_uchar *compile_charn_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **backtracks)
  {
  /* This function consumes at least one input character. */
  /* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */
-Line 3825 
 if (context.length > 0)
+Line 4585 
 if (context.length > 0)
    {
    /* We have a fixed-length byte sequence. */
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, context.length);
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
    context.sourcereg = -1;
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    context.ucharptr = 0;
  #endif
-   do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, fallbacks); while (context.length > 0);
+   do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, backtracks); while (context.length > 0);
    return cc;
    }
  /* A non-fixed length character will be checked if length == 0. */
- return compile_char1_hotpath(common, *cc, cc + 1, fallbacks);
+ return compile_char1_matchingpath(common, *cc, cc + 1, backtracks);
  }
- static struct sljit_jump *compile_ref_checks(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks)
+ static struct sljit_jump *compile_ref_checks(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1) << 1;
-Line 3847 
 int offset = GET2(cc, 1) << 1;
+Line 4607 
 int offset = GET2(cc, 1) << 1;
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
  if (!common->jscript_compat)
    {
-   if (fallbacks == NULL)
+   if (backtracks == NULL)
      {
      /* OVECTOR(1) contains the "string begin - 1" constant. */
      OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
-Line 3856 
 if (!common->jscript_compat)
+Line 4616 
 if (!common->jscript_compat)
      COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
      return JUMP(SLJIT_C_NOT_ZERO);
      }
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
    }
  return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
  }
  /* Forward definitions. */
- static void compile_hotpath(compiler_common *, pcre_uchar *, pcre_uchar *, fallback_common *);
+ static void compile_matchingpath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);
- static void compile_fallbackpath(compiler_common *, struct fallback_common *);
+ static void compile_backtrackingpath(compiler_common *, struct backtrack_common *);
- #define PUSH_FALLBACK(size, ccstart, error) \
+ #define PUSH_BACKTRACK(size, ccstart, error) \
    do \
      { \
-     fallback = sljit_alloc_memory(compiler, (size)); \
+     backtrack = sljit_alloc_memory(compiler, (size)); \
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
        return error; \
-     memset(fallback, 0, size); \
+     memset(backtrack, 0, size); \
-     fallback->prev = parent->top; \
+     backtrack->prev = parent->top; \
-     fallback->cc = (ccstart); \
+     backtrack->cc = (ccstart); \
-     parent->top = fallback; \
+     parent->top = backtrack; \
      } \
    while (0)
- #define PUSH_FALLBACK_NOVALUE(size, ccstart) \
+ #define PUSH_BACKTRACK_NOVALUE(size, ccstart) \
    do \
      { \
-     fallback = sljit_alloc_memory(compiler, (size)); \
+     backtrack = sljit_alloc_memory(compiler, (size)); \
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
        return; \
-     memset(fallback, 0, size); \
+     memset(backtrack, 0, size); \
-     fallback->prev = parent->top; \
+     backtrack->prev = parent->top; \
-     fallback->cc = (ccstart); \
+     backtrack->cc = (ccstart); \
-     parent->top = fallback; \
+     parent->top = backtrack; \
      } \
    while (0)
- #define FALLBACK_AS(type) ((type *)fallback)
+ #define BACKTRACK_AS(type) ((type *)backtrack)
- static pcre_uchar *compile_ref_hotpath(compiler_common *common, pcre_uchar *cc, jump_list **fallbacks, BOOL withchecks, BOOL emptyfail)
+ static pcre_uchar *compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1) << 1;
-Line 3904 
 struct sljit_jump *nopartial;
+Line 4664 
 struct sljit_jump *nopartial;
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
  /* OVECTOR(1) contains the "string begin - 1" constant. */
  if (withchecks && !common->jscript_compat)
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
  #if defined SUPPORT_UTF && defined SUPPORT_UCP
  if (common->utf && *cc == OP_REFI)
-Line 3921 
 if (common->utf && *cc == OP_REFI)
+Line 4681 
 if (common->utf && *cc == OP_REFI)
    sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));
    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
    if (common->mode == JIT_COMPILE)
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));
    else
      {
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
      nopartial = CMP(SLJIT_C_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
      check_partial(common, FALSE);
-     add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
      JUMPHERE(nopartial);
      }
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);
-Line 3942 
 else
+Line 4702 
 else
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
    partial = CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0);
    if (common->mode == JIT_COMPILE)
-     add_jump(compiler, fallbacks, partial);
+     add_jump(compiler, backtracks, partial);
    add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+   add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
    if (common->mode != JIT_COMPILE)
      {
-Line 3957 
 else
+Line 4717 
 else
      partial = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0);
      OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);
      add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
-     add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+     add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
      JUMPHERE(partial);
      check_partial(common, FALSE);
-     add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
+     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
      JUMPHERE(nopartial);
      }
    }
-Line 3968 
 else
+Line 4728 
 else
  if (jump != NULL)
    {
    if (emptyfail)
-     add_jump(compiler, fallbacks, jump);
+     add_jump(compiler, backtracks, jump);
    else
      JUMPHERE(jump);
    }
  return cc + 1 + IMM2_SIZE;
  }
- static SLJIT_INLINE pcre_uchar *compile_ref_iterator_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  pcre_uchar type;
  struct sljit_label *label;
  struct sljit_jump *zerolength;
-Line 3987 
 pcre_uchar *ccbegin = cc;
+Line 4747 
 pcre_uchar *ccbegin = cc;
  int min = 0, max = 0;
  BOOL minimize;
- PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
  type = cc[1 + IMM2_SIZE];
  minimize = (type & 0x1) != 0;
-Line 4039 
 if (!minimize)
+Line 4799 
 if (!minimize)
      {
      allocate_stack(common, 1);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-     zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);
+     zerolength = compile_ref_checks(common, ccbegin, &backtrack->topbacktracks);
      }
    if (min > 1 || max > 1)
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);
    label = LABEL();
-   compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, FALSE, FALSE);
+   compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);
    if (min > 1 || max > 1)
      {
-Line 4074 
 if (!minimize)
+Line 4834 
 if (!minimize)
      }
    JUMPHERE(zerolength);
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
    decrease_call_count(common);
    return cc;
-Line 4092 
 if (min == 0)
+Line 4852 
 if (min == 0)
    jump = JUMP(SLJIT_JUMP);
    }
  else
-   zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);
+   zerolength = compile_ref_checks(common, ccbegin, &backtrack->topbacktracks);
- FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+ BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
  if (max > 0)
-   add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
+   add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
- compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, TRUE, TRUE);
+ compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);
  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
  if (min > 1)
-Line 4106 
 if (min > 1)
+Line 4866 
 if (min > 1)
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
-   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, FALLBACK_AS(iterator_fallback)->hotpath);
+   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, BACKTRACK_AS(iterator_backtrack)->matchingpath);
    }
  else if (max > 0)
    OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
-Line 4119 
 decrease_call_count(common);
+Line 4879 
 decrease_call_count(common);
  return cc;
  }
- static SLJIT_INLINE pcre_uchar *compile_recurse_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_recurse_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  recurse_entry *entry = common->entries;
  recurse_entry *prev = NULL;
  int start = GET(cc, 1);
- PUSH_FALLBACK(sizeof(recurse_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
  while (entry != NULL)
    {
    if (entry->start == start)
-Line 4172 
 if (entry->entry == NULL)
+Line 4932 
 if (entry->entry == NULL)
  else
    JUMPTO(SLJIT_FAST_CALL, entry->entry);
  /* Leave if the match is failed. */
- add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0));
+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0));
  return cc + 1 + LINK_SIZE;
  }
- static pcre_uchar *compile_assert_hotpath(compiler_common *common, pcre_uchar *cc, assert_fallback *fallback, BOOL conditional)
+ static pcre_uchar *compile_assert_matchingpath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)
  {
  DEFINE_COMPILER;
  int framesize;
  int localptr;
- fallback_common altfallback;
+ backtrack_common altbacktrack;
  pcre_uchar *ccbegin;
  pcre_uchar opcode;
  pcre_uchar bra = OP_BRA;
  jump_list *tmp = NULL;
- jump_list **target = (conditional) ? &fallback->condfailed : &fallback->common.topfallbacks;
+ jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
  jump_list **found;
  /* Saving previous accept variables. */
- struct sljit_label *save_leavelabel = common->leavelabel;
+ struct sljit_label *save_quitlabel = common->quitlabel;
  struct sljit_label *save_acceptlabel = common->acceptlabel;
- jump_list *save_leave = common->leave;
+ jump_list *save_quit = common->quit;
  jump_list *save_accept = common->accept;
  struct sljit_jump *jump;
  struct sljit_jump *brajump = NULL;
-Line 4205 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 4965 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
  localptr = PRIV_DATA(cc);
  SLJIT_ASSERT(localptr != 0);
  framesize = get_framesize(common, cc, FALSE);
- fallback->framesize = framesize;
+ backtrack->framesize = framesize;
- fallback->localptr = localptr;
+ backtrack->localptr = localptr;
  opcode = *cc;
  SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);
  found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;
-Line 4215 
 cc += GET(cc, 1);
+Line 4975 
 cc += GET(cc, 1);
  if (bra == OP_BRAMINZERO)
    {
-   /* This is a braminzero fallback path. */
+   /* This is a braminzero backtrack path. */
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    free_stack(common, 1);
    brajump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
-Line 4238 
 else
+Line 4998 
 else
    init_frame(common, ccbegin, framesize + 1, 2, FALSE);
    }
- memset(&altfallback, 0, sizeof(fallback_common));
+ memset(&altbacktrack, 0, sizeof(backtrack_common));
- common->leavelabel = NULL;
+ common->quitlabel = NULL;
- common->leave = NULL;
+ common->quit = NULL;
  while (1)
    {
    common->acceptlabel = NULL;
    common->accept = NULL;
-   altfallback.top = NULL;
+   altbacktrack.top = NULL;
-   altfallback.topfallbacks = NULL;
+   altbacktrack.topbacktracks = NULL;
    if (*ccbegin == OP_ALT)
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
-   altfallback.cc = ccbegin;
+   altbacktrack.cc = ccbegin;
-   compile_hotpath(common, ccbegin + 1 + LINK_SIZE, cc, &altfallback);
+   compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
-     common->leavelabel = save_leavelabel;
+     common->quitlabel = save_quitlabel;
      common->acceptlabel = save_acceptlabel;
-     common->leave = save_leave;
+     common->quit = save_quit;
      common->accept = save_accept;
      return NULL;
      }
-Line 4307 
 while (1)
+Line 5067 
 while (1)
      }
    add_jump(compiler, found, JUMP(SLJIT_JUMP));
-   compile_fallbackpath(common, altfallback.top);
+   compile_backtrackingpath(common, altbacktrack.top);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      {
-     common->leavelabel = save_leavelabel;
+     common->quitlabel = save_quitlabel;
      common->acceptlabel = save_acceptlabel;
-     common->leave = save_leave;
+     common->quit = save_quit;
      common->accept = save_accept;
      return NULL;
      }
-   set_jumps(altfallback.topfallbacks, LABEL());
+   set_jumps(altbacktrack.topbacktracks, LABEL());
    if (*cc != OP_ALT)
      break;
-Line 4325 
 while (1)
+Line 5085 
 while (1)
    cc += GET(cc, 1);
    }
  /* None of them matched. */
- if (common->leave != NULL)
+ if (common->quit != NULL)
-   set_jumps(common->leave, LABEL());
+   set_jumps(common->quit, LABEL());
  if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
    {
-Line 4393 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 5153 
 if (opcode == OP_ASSERT || opcode == OP_
    if (bra == OP_BRAZERO)
      {
-     fallback->hotpath = LABEL();
+     backtrack->matchingpath = LABEL();
-     sljit_set_label(jump, fallback->hotpath);
+     sljit_set_label(jump, backtrack->matchingpath);
      }
    else if (bra == OP_BRAMINZERO)
      {
-     JUMPTO(SLJIT_JUMP, fallback->hotpath);
+     JUMPTO(SLJIT_JUMP, backtrack->matchingpath);
      JUMPHERE(brajump);
      if (framesize >= 0)
        {
-Line 4406 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 5166 
 if (opcode == OP_ASSERT || opcode == OP_
        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
        }
-     set_jumps(fallback->common.topfallbacks, LABEL());
+     set_jumps(backtrack->common.topbacktracks, LABEL());
      }
    }
  else
-Line 4436 
 else
+Line 5196 
 else
      }
    if (bra == OP_BRAZERO)
-     fallback->hotpath = LABEL();
+     backtrack->matchingpath = LABEL();
    else if (bra == OP_BRAMINZERO)
      {
-     JUMPTO(SLJIT_JUMP, fallback->hotpath);
+     JUMPTO(SLJIT_JUMP, backtrack->matchingpath);
      JUMPHERE(brajump);
      }
    if (bra != OP_BRA)
      {
-     SLJIT_ASSERT(found == &fallback->common.topfallbacks);
+     SLJIT_ASSERT(found == &backtrack->common.topbacktracks);
-     set_jumps(fallback->common.topfallbacks, LABEL());
+     set_jumps(backtrack->common.topbacktracks, LABEL());
-     fallback->common.topfallbacks = NULL;
+     backtrack->common.topbacktracks = NULL;
      }
    }
- common->leavelabel = save_leavelabel;
+ common->quitlabel = save_quitlabel;
  common->acceptlabel = save_acceptlabel;
- common->leave = save_leave;
+ common->quit = save_quit;
  common->accept = save_accept;
  return cc + 1 + LINK_SIZE;
  }
-Line 4622 
 return condition;
+Line 5382 
 return condition;
                                            Or nothing, if trace is unnecessary
  */
- static pcre_uchar *compile_bracket_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static pcre_uchar *compile_bracket_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  pcre_uchar opcode;
  int localptr = 0;
  int offset = 0;
  int stacksize;
  pcre_uchar *ccbegin;
- pcre_uchar *hotpath;
+ pcre_uchar *matchingpath;
  pcre_uchar bra = OP_BRA;
  pcre_uchar ket;
- assert_fallback *assert;
+ assert_backtrack *assert;
  BOOL has_alternatives;
  struct sljit_jump *jump;
  struct sljit_jump *skip;
  struct sljit_label *rmaxlabel = NULL;
  struct sljit_jump *braminzerojump = NULL;
- PUSH_FALLBACK(sizeof(bracket_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
  if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
    {
-Line 4652 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 5412 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
  opcode = *cc;
  ccbegin = cc;
- hotpath = ccbegin + 1 + LINK_SIZE;
+ matchingpath = ccbegin + 1 + LINK_SIZE;
  if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
    {
-   /* Drop this bracket_fallback. */
+   /* Drop this bracket_backtrack. */
-   parent->top = fallback->prev;
+   parent->top = backtrack->prev;
    return bracketend(cc);
    }
-Line 4669 
 cc += GET(cc, 1);
+Line 5429 
 cc += GET(cc, 1);
  has_alternatives = *cc == OP_ALT;
  if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
    {
-   has_alternatives = (*hotpath == OP_RREF) ? FALSE : TRUE;
+   has_alternatives = (*matchingpath == OP_RREF) ? FALSE : TRUE;
-   if (*hotpath == OP_NRREF)
+   if (*matchingpath == OP_NRREF)
      {
-     stacksize = GET2(hotpath, 1);
+     stacksize = GET2(matchingpath, 1);
      if (common->currententry == NULL || stacksize == RREF_ANY)
        has_alternatives = FALSE;
      else if (common->currententry->start == 0)
-Line 4693 
 if (opcode == OP_CBRA || opcode == OP_SC
+Line 5453 
 if (opcode == OP_CBRA || opcode == OP_SC
    offset = GET2(ccbegin, 1 + LINK_SIZE);
    localptr = OVECTOR_PRIV(offset);
    offset <<= 1;
-   FALLBACK_AS(bracket_fallback)->localptr = localptr;
+   BACKTRACK_AS(bracket_backtrack)->localptr = localptr;
-   hotpath += IMM2_SIZE;
+   matchingpath += IMM2_SIZE;
    }
  else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)
    {
    /* Other brackets simply allocate the next entry. */
    localptr = PRIV_DATA(ccbegin);
    SLJIT_ASSERT(localptr != 0);
-   FALLBACK_AS(bracket_fallback)->localptr = localptr;
+   BACKTRACK_AS(bracket_backtrack)->localptr = localptr;
    if (opcode == OP_ONCE)
-     FALLBACK_AS(bracket_fallback)->u.framesize = get_framesize(common, ccbegin, FALSE);
+     BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, FALSE);
    }
  /* Instructions before the first alternative. */
-Line 4728 
 if (bra == OP_BRAZERO)
+Line 5488 
 if (bra == OP_BRAZERO)
  if (bra == OP_BRAMINZERO)
    {
-   /* This is a fallback path! (Since the hot-path of OP_BRAMINZERO matches to the empty string) */
+   /* This is a backtrack path! (Since the try-path of OP_BRAMINZERO matches to the empty string) */
    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
    if (ket != OP_KETRMIN)
      {
-Line 4745 
 if (bra == OP_BRAMINZERO)
+Line 5505 
 if (bra == OP_BRAMINZERO)
        skip = JUMP(SLJIT_JUMP);
        JUMPHERE(jump);
        /* Checking zero-length iteration. */
-       if (opcode != OP_ONCE || FALLBACK_AS(bracket_fallback)->u.framesize < 0)
+       if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
          {
          /* When we come from outside, localptr contains the previous STR_PTR. */
          braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-Line 4754 
 if (bra == OP_BRAMINZERO)
+Line 5514 
 if (bra == OP_BRAMINZERO)
          {
          /* Except when the whole stack frame must be saved. */
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-         braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (FALLBACK_AS(bracket_fallback)->u.framesize + 1) * sizeof(sljit_w));
+         braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (BACKTRACK_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_w));
          }
        JUMPHERE(skip);
        }
-Line 4768 
 if (bra == OP_BRAMINZERO)
+Line 5528 
 if (bra == OP_BRAMINZERO)
    }
  if (ket == OP_KETRMIN)
-   FALLBACK_AS(bracket_fallback)->recursivehotpath = LABEL();
+   BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
  if (ket == OP_KETRMAX)
    {
    rmaxlabel = LABEL();
    if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA)
-     FALLBACK_AS(bracket_fallback)->althotpath = rmaxlabel;
+     BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmaxlabel;
    }
  /* Handling capturing brackets and alternatives. */
  if (opcode == OP_ONCE)
    {
-   if (FALLBACK_AS(bracket_fallback)->u.framesize < 0)
+   if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
      {
      /* Neither capturing brackets nor recursions are not found in the block. */
      if (ket == OP_KETRMIN)
-Line 4804 
 if (opcode == OP_ONCE)
+Line 5564 
 if (opcode == OP_ONCE)
      {
      if (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives)
        {
-       allocate_stack(common, FALLBACK_AS(bracket_fallback)->u.framesize + 2);
+       allocate_stack(common, BACKTRACK_AS(bracket_backtrack)->u.framesize + 2);
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(FALLBACK_AS(bracket_fallback)->u.framesize + 1));
+       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(BACKTRACK_AS(bracket_backtrack)->u.framesize + 1));
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
-       init_frame(common, ccbegin, FALLBACK_AS(bracket_fallback)->u.framesize + 1, 2, FALSE);
+       init_frame(common, ccbegin, BACKTRACK_AS(bracket_backtrack)->u.framesize + 1, 2, FALSE);
        }
      else
        {
-       allocate_stack(common, FALLBACK_AS(bracket_fallback)->u.framesize + 1);
+       allocate_stack(common, BACKTRACK_AS(bracket_backtrack)->u.framesize + 1);
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(FALLBACK_AS(bracket_fallback)->u.framesize));
+       OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(BACKTRACK_AS(bracket_backtrack)->u.framesize));
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
-       init_frame(common, ccbegin, FALLBACK_AS(bracket_fallback)->u.framesize, 1, FALSE);
+       init_frame(common, ccbegin, BACKTRACK_AS(bracket_backtrack)->u.framesize, 1, FALSE);
        }
      }
    }
-Line 4853 
 else if (has_alternatives)
+Line 5613 
 else if (has_alternatives)
  /* Generating code for the first alternative. */
  if (opcode == OP_COND || opcode == OP_SCOND)
    {
-   if (*hotpath == OP_CREF)
+   if (*matchingpath == OP_CREF)
      {
      SLJIT_ASSERT(has_alternatives);
-     add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed),
+     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed),
-       CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(hotpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
+       CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
-     hotpath += 1 + IMM2_SIZE;
+     matchingpath += 1 + IMM2_SIZE;
      }
-   else if (*hotpath == OP_NCREF)
+   else if (*matchingpath == OP_NCREF)
      {
      SLJIT_ASSERT(has_alternatives);
-     stacksize = GET2(hotpath, 1);
+     stacksize = GET2(matchingpath, 1);
      jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(stacksize << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
      OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, (stacksize << 8) | (common->ovector_start / sizeof(sljit_w)));
-     OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);
+     GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, 0);
      OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
      sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchovector));
      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
-     add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
      JUMPHERE(jump);
-     hotpath += 1 + IMM2_SIZE;
+     matchingpath += 1 + IMM2_SIZE;
      }
-   else if (*hotpath == OP_RREF || *hotpath == OP_NRREF)
+   else if (*matchingpath == OP_RREF || *matchingpath == OP_NRREF)
      {
      /* Never has other case. */
-     FALLBACK_AS(bracket_fallback)->u.condfailed = NULL;
+     BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;
-     stacksize = GET2(hotpath, 1);
+     stacksize = GET2(matchingpath, 1);
      if (common->currententry == NULL)
        stacksize = 0;
      else if (stacksize == RREF_ANY)
-Line 4894 
 if (opcode == OP_COND || opcode == OP_SC
+Line 5654 
 if (opcode == OP_COND || opcode == OP_SC
      else
        stacksize = stacksize == GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
-     if (*hotpath == OP_RREF || stacksize || common->currententry == NULL)
+     if (*matchingpath == OP_RREF || stacksize || common->currententry == NULL)
        {
        SLJIT_ASSERT(!has_alternatives);
        if (stacksize != 0)
-         hotpath += 1 + IMM2_SIZE;
+         matchingpath += 1 + IMM2_SIZE;
        else
          {
          if (*cc == OP_ALT)
            {
-           hotpath = cc + 1 + LINK_SIZE;
+           matchingpath = cc + 1 + LINK_SIZE;
            cc += GET(cc, 1);
            }
          else
-           hotpath = cc;
+           matchingpath = cc;
          }
        }
      else
        {
        SLJIT_ASSERT(has_alternatives);
-       stacksize = GET2(hotpath, 1);
+       stacksize = GET2(matchingpath, 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, GET2(common->start, common->currententry->start + 1 + LINK_SIZE));
        OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);
-       OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);
+       GET_LOCAL_BASE(SLJIT_TEMPORARY_REG2, 0, 0);
        OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
        sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchgroups));
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
-       add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
+       add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
-       hotpath += 1 + IMM2_SIZE;
+       matchingpath += 1 + IMM2_SIZE;
        }
      }
    else
      {
-     SLJIT_ASSERT(has_alternatives && *hotpath >= OP_ASSERT && *hotpath <= OP_ASSERTBACK_NOT);
+     SLJIT_ASSERT(has_alternatives && *matchingpath >= OP_ASSERT && *matchingpath <= OP_ASSERTBACK_NOT);
-     /* Similar code as PUSH_FALLBACK macro. */
+     /* Similar code as PUSH_BACKTRACK macro. */
-     assert = sljit_alloc_memory(compiler, sizeof(assert_fallback));
+     assert = sljit_alloc_memory(compiler, sizeof(assert_backtrack));
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
        return NULL;
-     memset(assert, 0, sizeof(assert_fallback));
+     memset(assert, 0, sizeof(assert_backtrack));
-     assert->common.cc = hotpath;
+     assert->common.cc = matchingpath;
-     FALLBACK_AS(bracket_fallback)->u.assert = assert;
+     BACKTRACK_AS(bracket_backtrack)->u.assert = assert;
-     hotpath = compile_assert_hotpath(common, hotpath, assert, TRUE);
+     matchingpath = compile_assert_matchingpath(common, matchingpath, assert, TRUE);
      }
    }
- compile_hotpath(common, hotpath, cc, fallback);
+ compile_matchingpath(common, matchingpath, cc, backtrack);
  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
    return NULL;
  if (opcode == OP_ONCE)
    {
-   if (FALLBACK_AS(bracket_fallback)->u.framesize < 0)
+   if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
      {
      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
      /* TMP2 which is set here used by OP_KETRMAX below. */
-Line 4963 
 if (opcode == OP_ONCE)
+Line 5723 
 if (opcode == OP_ONCE)
    else
      {
      stacksize = (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives) ? 2 : 1;
-     OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (FALLBACK_AS(bracket_fallback)->u.framesize + stacksize) * sizeof(sljit_w));
+     OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize) * sizeof(sljit_w));
      if (ket == OP_KETRMAX)
        {
        /* TMP2 which is set here used by OP_KETRMAX below. */
-Line 4998 
 if (has_alternatives)
+Line 5758 
 if (has_alternatives)
    if (opcode != OP_ONCE)
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
    if (ket != OP_KETRMAX)
-     FALLBACK_AS(bracket_fallback)->althotpath = LABEL();
+     BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
    }
- /* Must be after the hotpath label. */
+ /* Must be after the matchingpath label. */
  if (offset != 0)
    {
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-Line 5014 
 if (ket == OP_KETRMAX)
+Line 5774 
 if (ket == OP_KETRMAX)
    if (opcode == OP_ONCE || opcode >= OP_SBRA)
      {
      if (has_alternatives)
-       FALLBACK_AS(bracket_fallback)->althotpath = LABEL();
+       BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
      /* Checking zero-length iteration. */
      if (opcode != OP_ONCE)
+       {
        CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0, rmaxlabel);
+       /* Drop STR_PTR for greedy plus quantifier. */
+       if (bra != OP_BRAZERO)
+         free_stack(common, 1);
+       }
      else
        /* TMP2 must contain the starting STR_PTR. */
        CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmaxlabel);
      }
    else
      JUMPTO(SLJIT_JUMP, rmaxlabel);
-   FALLBACK_AS(bracket_fallback)->recursivehotpath = LABEL();
+   BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
    }
  if (bra == OP_BRAZERO)
-   FALLBACK_AS(bracket_fallback)->zerohotpath = LABEL();
+   BACKTRACK_AS(bracket_backtrack)->zero_matchingpath = LABEL();
  if (bra == OP_BRAMINZERO)
    {
-   /* This is a fallback path! (From the viewpoint of OP_BRAMINZERO) */
+   /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */
-   JUMPTO(SLJIT_JUMP, ((braminzero_fallback *)parent)->hotpath);
+   JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->matchingpath);
    if (braminzerojump != NULL)
      {
      JUMPHERE(braminzerojump);
      /* We need to release the end pointer to perform the
-     fallback for the zero-length iteration. When
+     backtrack for the zero-length iteration. When
      framesize is < 0, OP_ONCE will do the release itself. */
-     if (opcode == OP_ONCE && FALLBACK_AS(bracket_fallback)->u.framesize >= 0)
+     if (opcode == OP_ONCE && BACKTRACK_AS(bracket_backtrack)->u.framesize >= 0)
        {
        OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
-Line 5048 
 if (bra == OP_BRAMINZERO)
+Line 5813 
 if (bra == OP_BRAMINZERO)
      else if (ket == OP_KETRMIN && opcode != OP_ONCE)
        free_stack(common, 1);
      }
-   /* Continue to the normal fallback. */
+   /* Continue to the normal backtrack. */
    }
  if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)
-Line 5061 
 cc += 1 + LINK_SIZE;
+Line 5826 
 cc += 1 + LINK_SIZE;
  return cc;
  }
- static pcre_uchar *compile_bracketpos_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  pcre_uchar opcode;
  int localptr;
  int cbraprivptr = 0;
-Line 5077 
 int stack;
+Line 5842 
 int stack;
  struct sljit_label *loop = NULL;
  struct jump_list *emptymatch = NULL;
- PUSH_FALLBACK(sizeof(bracketpos_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(bracketpos_backtrack), cc, NULL);
  if (*cc == OP_BRAPOSZERO)
    {
    zero = TRUE;
-Line 5087 
 if (*cc == OP_BRAPOSZERO)
+Line 5852 
 if (*cc == OP_BRAPOSZERO)
  opcode = *cc;
  localptr = PRIV_DATA(cc);
  SLJIT_ASSERT(localptr != 0);
- FALLBACK_AS(bracketpos_fallback)->localptr = localptr;
+ BACKTRACK_AS(bracketpos_backtrack)->localptr = localptr;
  switch(opcode)
    {
    case OP_BRAPOS:
-Line 5109 
 switch(opcode)
+Line 5874 
 switch(opcode)
    }
  framesize = get_framesize(common, cc, FALSE);
- FALLBACK_AS(bracketpos_fallback)->framesize = framesize;
+ BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;
  if (framesize < 0)
    {
    stacksize = (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS) ? 2 : 1;
    if (!zero)
      stacksize++;
-   FALLBACK_AS(bracketpos_fallback)->stacksize = stacksize;
+   BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
    allocate_stack(common, stacksize);
    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);
-Line 5139 
 else
+Line 5904 
 else
      stacksize++;
    if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)
      stacksize++;
-   FALLBACK_AS(bracketpos_fallback)->stacksize = stacksize;
+   BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
    allocate_stack(common, stacksize);
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
-Line 5166 
 if (opcode == OP_CBRAPOS || opcode == OP
+Line 5931 
 if (opcode == OP_CBRAPOS || opcode == OP
  loop = LABEL();
  while (*cc != OP_KETRPOS)
    {
-   fallback->top = NULL;
+   backtrack->top = NULL;
-   fallback->topfallbacks = NULL;
+   backtrack->topbacktracks = NULL;
    cc += GET(cc, 1);
-   compile_hotpath(common, ccbegin, cc, fallback);
+   compile_matchingpath(common, ccbegin, cc, backtrack);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      return NULL;
-Line 5231 
 while (*cc != OP_KETRPOS)
+Line 5996 
 while (*cc != OP_KETRPOS)
    JUMPTO(SLJIT_JUMP, loop);
    flush_stubs(common);
-   compile_fallbackpath(common, fallback->top);
+   compile_backtrackingpath(common, backtrack->top);
    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
      return NULL;
-   set_jumps(fallback->topfallbacks, LABEL());
+   set_jumps(backtrack->topbacktracks, LABEL());
    if (framesize < 0)
      {
-Line 5264 
 while (*cc != OP_KETRPOS)
+Line 6029 
 while (*cc != OP_KETRPOS)
    ccbegin = cc + 1 + LINK_SIZE;
    }
- fallback->topfallbacks = NULL;
+ backtrack->topbacktracks = NULL;
  if (!zero)
    {
    if (framesize < 0)
-     add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));
+     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));
    else /* TMP2 is set to [localptr] above. */
-     add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_w), SLJIT_IMM, 0));
+     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_w), SLJIT_IMM, 0));
    }
  /* None of them matched. */
-Line 5371 
 if (end != NULL)
+Line 6136 
 if (end != NULL)
  return cc;
  }
- static pcre_uchar *compile_iterator_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static pcre_uchar *compile_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  pcre_uchar opcode;
  pcre_uchar type;
  int arg1 = -1, arg2 = -1;
-Line 5382 
 pcre_uchar* end;
+Line 6147 
 pcre_uchar* end;
  jump_list *nomatch = NULL;
  struct sljit_jump *jump = NULL;
  struct sljit_label *label;
+ int localptr = PRIV_DATA(cc);
+ int base = (localptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_LOCALS_REG);
+ int offset0 = (localptr == 0) ? STACK(0) : localptr;
+ int offset1 = (localptr == 0) ? STACK(1) : localptr + (int)sizeof(sljit_w);
+ int tmp_base, tmp_offset;
- PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
  cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);
+ switch (type)
+   {
+   case OP_NOT_DIGIT:
+   case OP_DIGIT:
+   case OP_NOT_WHITESPACE:
+   case OP_WHITESPACE:
+   case OP_NOT_WORDCHAR:
+   case OP_WORDCHAR:
+   case OP_ANY:
+   case OP_ALLANY:
+   case OP_ANYBYTE:
+   case OP_ANYNL:
+   case OP_NOT_HSPACE:
+   case OP_HSPACE:
+   case OP_NOT_VSPACE:
+   case OP_VSPACE:
+   case OP_CHAR:
+   case OP_CHARI:
+   case OP_NOT:
+   case OP_NOTI:
+   case OP_CLASS:
+   case OP_NCLASS:
+   tmp_base = TMP3;
+   tmp_offset = 0;
+   break;
+   default:
+   SLJIT_ASSERT_STOP();
+   /* Fall through. */
+   case OP_EXTUNI:
+   case OP_XCLASS:
+   case OP_NOTPROP:
+   case OP_PROP:
+   tmp_base = SLJIT_MEM1(SLJIT_LOCALS_REG);
+   tmp_offset = POSSESSIVE0;
+   break;
+   }
  switch(opcode)
    {
    case OP_STAR:
-Line 5395 
 switch(opcode)
+Line 6204 
 switch(opcode)
    case OP_CRRANGE:
    if (type == OP_ANYNL || type == OP_EXTUNI)
      {
+     SLJIT_ASSERT(localptr == 0);
      if (opcode == OP_STAR || opcode == OP_UPTO)
        {
        allocate_stack(common, 2);
-Line 5406 
 switch(opcode)
+Line 6216 
 switch(opcode)
        allocate_stack(common, 1);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
        }
      if (opcode == OP_UPTO || opcode == OP_CRRANGE)
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);
      label = LABEL();
-     compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
+     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
      if (opcode == OP_UPTO || opcode == OP_CRRANGE)
        {
        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
-Line 5422 
 switch(opcode)
+Line 6233 
 switch(opcode)
        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
        }
+     /* We cannot use TMP3 because of this allocate_stack. */
      allocate_stack(common, 1);
      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
      JUMPTO(SLJIT_JUMP, label);
-Line 5430 
 switch(opcode)
+Line 6242 
 switch(opcode)
      }
    else
      {
-     allocate_stack(common, 2);
+     if (opcode == OP_PLUS)
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+       compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
+     if (localptr == 0)
+       allocate_stack(common, 2);
+     OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+     if (opcode <= OP_PLUS)
+       OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
+     else
+       OP1(SLJIT_MOV, base, offset1, SLJIT_IMM, 1);
      label = LABEL();
-     compile_char1_hotpath(common, type, cc, &nomatch);
+     compile_char1_matchingpath(common, type, cc, &nomatch);
-     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+     OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
-     if (opcode <= OP_PLUS || (opcode == OP_CRRANGE && arg1 == 0))
+     if (opcode <= OP_PLUS)
+       JUMPTO(SLJIT_JUMP, label);
+     else if (opcode == OP_CRRANGE && arg1 == 0)
        {
-       OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
+       OP2(SLJIT_ADD, base, offset1, base, offset1, SLJIT_IMM, 1);
        JUMPTO(SLJIT_JUMP, label);
        }
      else
        {
-       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+       OP1(SLJIT_MOV, TMP1, 0, base, offset1);
        OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
-       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+       OP1(SLJIT_MOV, base, offset1, TMP1, 0);
        CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);
        }
      set_jumps(nomatch, LABEL());
-     if (opcode == OP_PLUS || opcode == OP_CRRANGE)
+     if (opcode == OP_CRRANGE)
-       add_jump(compiler, &fallback->topfallbacks,
+       add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_LESS, base, offset1, SLJIT_IMM, arg2 + 1));
-         CMP(SLJIT_C_LESS, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, opcode == OP_PLUS ? 2 : arg2 + 1));
+     OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
-     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      }
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
    break;
    case OP_MINSTAR:
    case OP_MINPLUS:
-   allocate_stack(common, 1);
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
    if (opcode == OP_MINPLUS)
-     add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
+     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   if (localptr == 0)
+     allocate_stack(common, 1);
+   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
    break;
    case OP_MINUPTO:
    case OP_CRMINRANGE:
-   allocate_stack(common, 2);
+   if (localptr == 0)
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+     allocate_stack(common, 2);
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
+   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+   OP1(SLJIT_MOV, base, offset1, SLJIT_IMM, 1);
    if (opcode == OP_CRMINRANGE)
-     add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
+     add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
    break;
    case OP_QUERY:
    case OP_MINQUERY:
-   allocate_stack(common, 1);
+   if (localptr == 0)
-   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+     allocate_stack(common, 1);
+   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
    if (opcode == OP_QUERY)
-     compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
+     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
    break;
    case OP_EXACT:
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 1);
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, arg1);
    label = LABEL();
-   compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
+   compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+   OP2(SLJIT_SUB | SLJIT_SET_E, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
-   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   JUMPTO(SLJIT_C_NOT_ZERO, label);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
-   CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);
    break;
    case OP_POSSTAR:
    case OP_POSPLUS:
    case OP_POSUPTO:
-   if (opcode != OP_POSSTAR)
+   if (opcode == OP_POSPLUS)
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 1);
+     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
+   if (opcode == OP_POSUPTO)
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, arg1);
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
    label = LABEL();
-   compile_char1_hotpath(common, type, cc, &nomatch);
+   compile_char1_matchingpath(common, type, cc, &nomatch);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
    if (opcode != OP_POSUPTO)
-     {
-     if (opcode == OP_POSPLUS)
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 2);
      JUMPTO(SLJIT_JUMP, label);
-     }
    else
      {
-     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
+     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, 1);
-     OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+     JUMPTO(SLJIT_C_NOT_ZERO, label);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
-     CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);
      }
    set_jumps(nomatch, LABEL());
-   if (opcode == OP_POSPLUS)
+   OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
-     add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_LESS, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 2));
-   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
    break;
    case OP_POSQUERY:
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
-   compile_char1_hotpath(common, type, cc, &nomatch);
+   compile_char1_matchingpath(common, type, cc, &nomatch);
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
+   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
    set_jumps(nomatch, LABEL());
-   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
+   OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
    break;
    default:
-Line 5540 
 decrease_call_count(common);
+Line 6354 
 decrease_call_count(common);
  return end;
  }
- static SLJIT_INLINE pcre_uchar *compile_fail_accept_hotpath(compiler_common *common, pcre_uchar *cc, fallback_common *parent)
+ static SLJIT_INLINE pcre_uchar *compile_fail_accept_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
- PUSH_FALLBACK(sizeof(bracket_fallback), cc, NULL);
+ PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
  if (*cc == OP_FAIL)
    {
-   add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
+   add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
    return cc + 1;
    }
-Line 5569 
 else
+Line 6383 
 else
    CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), common->acceptlabel);
  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
- add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
  OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
  if (common->acceptlabel == NULL)
    add_jump(compiler, &common->accept, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0));
-Line 5580 
 if (common->acceptlabel == NULL)
+Line 6394 
 if (common->acceptlabel == NULL)
    add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0));
  else
    CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->acceptlabel);
- add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
+ add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
  return cc + 1;
  }
- static SLJIT_INLINE pcre_uchar *compile_close_hotpath(compiler_common *common, pcre_uchar *cc)
+ static SLJIT_INLINE pcre_uchar *compile_close_matchingpath(compiler_common *common, pcre_uchar *cc)
  {
  DEFINE_COMPILER;
  int offset = GET2(cc, 1);
-Line 5600 
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_R
+Line 6414 
 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_R
  return cc + 1 + IMM2_SIZE;
  }
- static void compile_hotpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, fallback_common *parent)
+ static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
  {
  DEFINE_COMPILER;
- fallback_common *fallback;
+ backtrack_common *backtrack;
  while (cc < ccend)
    {
-Line 5639 
 while (cc < ccend)
+Line 6453 
 while (cc < ccend)
      case OP_NOT:
      case OP_NOTI:
      case OP_REVERSE:
-     cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+     cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      break;
      case OP_SET_SOM:
-     PUSH_FALLBACK_NOVALUE(sizeof(fallback_common), cc);
+     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
      allocate_stack(common, 1);
      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);
-Line 5654 
 while (cc < ccend)
+Line 6468 
 while (cc < ccend)
      case OP_CHAR:
      case OP_CHARI:
      if (common->mode == JIT_COMPILE)
-       cc = compile_charn_hotpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+       cc = compile_charn_matchingpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      else
-       cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+       cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      break;
      case OP_STAR:
-Line 5724 
 while (cc < ccend)
+Line 6538 
 while (cc < ccend)
      case OP_TYPEPOSPLUS:
      case OP_TYPEPOSQUERY:
      case OP_TYPEPOSUPTO:
-     cc = compile_iterator_hotpath(common, cc, parent);
+     cc = compile_iterator_matchingpath(common, cc, parent);
      break;
      case OP_CLASS:
      case OP_NCLASS:
      if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRMINRANGE)
-       cc = compile_iterator_hotpath(common, cc, parent);
+       cc = compile_iterator_matchingpath(common, cc, parent);
      else
-       cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+       cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      break;
  #if defined SUPPORT_UTF || defined COMPILE_PCRE16
      case OP_XCLASS:
      if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRMINRANGE)
-       cc = compile_iterator_hotpath(common, cc, parent);
+       cc = compile_iterator_matchingpath(common, cc, parent);
      else
-       cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
+       cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
      break;
  #endif
      case OP_REF:
      case OP_REFI:
      if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRMINRANGE)
-       cc = compile_ref_iterator_hotpath(common, cc, parent);
+       cc = compile_ref_iterator_matchingpath(common, cc, parent);
      else
-       cc = compile_ref_hotpath(common, cc, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks, TRUE, FALSE);
+       cc = compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
      break;
      case OP_RECURSE:
-     cc = compile_recurse_hotpath(common, cc, parent);
+     cc = compile_recurse_matchingpath(common, cc, parent);
      break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
-     PUSH_FALLBACK_NOVALUE(sizeof(assert_fallback), cc);
+     PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
-     cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);
+     cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
      break;
      case OP_BRAMINZERO:
-     PUSH_FALLBACK_NOVALUE(sizeof(braminzero_fallback), cc);
+     PUSH_BACKTRACK_NOVALUE(sizeof(braminzero_backtrack), cc);
      cc = bracketend(cc + 1);
      if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)
        {
-Line 5778 
 while (cc < ccend)
+Line 6592 
 while (cc < ccend)
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), STR_PTR, 0);
        }
-     FALLBACK_AS(braminzero_fallback)->hotpath = LABEL();
+     BACKTRACK_AS(braminzero_backtrack)->matchingpath = LABEL();
      if (cc[1] > OP_ASSERTBACK_NOT)
        decrease_call_count(common);
      break;
-Line 5791 
 while (cc < ccend)
+Line 6605 
 while (cc < ccend)
      case OP_SBRA:
      case OP_SCBRA:
      case OP_SCOND:
-     cc = compile_bracket_hotpath(common, cc, parent);
+     cc = compile_bracket_matchingpath(common, cc, parent);
      break;
      case OP_BRAZERO:
      if (cc[1] > OP_ASSERTBACK_NOT)
-       cc = compile_bracket_hotpath(common, cc, parent);
+       cc = compile_bracket_matchingpath(common, cc, parent);
      else
        {
-       PUSH_FALLBACK_NOVALUE(sizeof(assert_fallback), cc);
+       PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
-       cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);
+       cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
        }
      break;
-Line 5809 
 while (cc < ccend)
+Line 6623 
 while (cc < ccend)
      case OP_SBRAPOS:
      case OP_SCBRAPOS:
      case OP_BRAPOSZERO:
-     cc = compile_bracketpos_hotpath(common, cc, parent);
+     cc = compile_bracketpos_matchingpath(common, cc, parent);
      break;
      case OP_MARK:
-     PUSH_FALLBACK_NOVALUE(sizeof(fallback_common), cc);
+     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
      SLJIT_ASSERT(common->mark_ptr != 0);
      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);
      allocate_stack(common, 1);
-Line 5826 
 while (cc < ccend)
+Line 6640 
 while (cc < ccend)
      break;
      case OP_COMMIT:
-     PUSH_FALLBACK_NOVALUE(sizeof(fallback_common), cc);
+     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
      cc += 1;
      break;
      case OP_FAIL:
      case OP_ACCEPT:
      case OP_ASSERT_ACCEPT:
-     cc = compile_fail_accept_hotpath(common, cc, parent);
+     cc = compile_fail_accept_matchingpath(common, cc, parent);
      break;
      case OP_CLOSE:
-     cc = compile_close_hotpath(common, cc);
+     cc = compile_close_matchingpath(common, cc);
      break;
      case OP_SKIPZERO:
-Line 5854 
 while (cc < ccend)
+Line 6668 
 while (cc < ccend)
  SLJIT_ASSERT(cc == ccend);
  }
- #undef PUSH_FALLBACK
+ #undef PUSH_BACKTRACK
- #undef PUSH_FALLBACK_NOVALUE
+ #undef PUSH_BACKTRACK_NOVALUE
- #undef FALLBACK_AS
+ #undef BACKTRACK_AS
- #define COMPILE_FALLBACKPATH(current) \
+ #define COMPILE_BACKTRACKINGPATH(current) \
    do \
      { \
-     compile_fallbackpath(common, (current)); \
+     compile_backtrackingpath(common, (current)); \
      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
        return; \
      } \
-Line 5869 
 SLJIT_ASSERT(cc == ccend);
+Line 6683 
 SLJIT_ASSERT(cc == ccend);
  #define CURRENT_AS(type) ((type *)current)
- static void compile_iterator_fallbackpath(compiler_common *common, struct fallback_common *current)
+ static void compile_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)
  {
  DEFINE_COMPILER;
  pcre_uchar *cc = current->cc;
-Line 5878 
 pcre_uchar type;
+Line 6692 
 pcre_uchar type;
  int arg1 = -1, arg2 = -1;
  struct sljit_label *label = NULL;
  struct sljit_jump *jump = NULL;
+ jump_list *jumplist = NULL;
+ int localptr = PRIV_DATA(cc);
+ int base = (localptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_LOCALS_REG);
+ int offset0 = (localptr == 0) ? STACK(0) : localptr;
+ int offset1 = (localptr == 0) ? STACK(1) : localptr + (int)sizeof(sljit_w);
  cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, NULL);
-Line 5889 
 switch(opcode)
+Line 6708 
 switch(opcode)
    case OP_CRRANGE:
    if (type == OP_ANYNL || type == OP_EXTUNI)
      {
-     set_jumps(current->topfallbacks, LABEL());
+     SLJIT_ASSERT(localptr == 0);
+     set_jumps(current->topbacktracks, LABEL());
      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
      free_stack(common, 1);
-     CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
+     CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);
      }
    else
      {
      if (opcode == OP_STAR || opcode == OP_UPTO)