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

Diff of /code/trunk/pcre_jit_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 958 by zherczeg,
Wed Apr 11 10:19:10 2012 UTC
+revision 1084 by chpe,
Tue Oct 16 15:55:28 2012 UTC
 Line 46 
 POSSIBILITY OF SUCH DAMAGE.
  #include "pcre_internal.h"
- #ifdef SUPPORT_JIT
+ #if defined SUPPORT_JIT
  /* All-in-one: Since we use the JIT compiler only from here,
  we just include it. This way we don't need to touch the build
 Line 65 
 system files. */
  #error Unsupported architecture
  #endif
- /* Allocate memory on the stack. Fast, but limited size. */
+ /* Allocate memory for the regex stack on the real machine stack.
- #define LOCAL_SPACE_SIZE 32768
+ Fast, but limited size. */
+ #define MACHINE_STACK_SIZE 32768
+ /* Growth rate for stack allocated by the OS. Should be the multiply
+ of page size. */
  #define STACK_GROWTH_RATE 8192
  /* Enable to check that the allocation could destroy temporaries. */
-Line 82 
 The code generator follows the recursive
+Line 85 
 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
+Line 111 
 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
+ Atomic blocks and asserts require reloading the values of private data
- when the fallback mechanism performed. Because of OP_RECURSE, the locals
+ when the backtrack mechanism performed. Because of OP_RECURSE, the data
  are not necessarly known in compile time, thus we need a dynamic restore
  mechanism.
  The stack frames are stored in a chain list, and have the following format:
  ([ capturing bracket offset ][ start value ][ end value ])+ ... [ 0 ] [ previous head ]
- Thus we can restore the locals to a particular point in the stack.
+ Thus we can restore the private data to a particular point in the stack.
  */
  typedef struct jit_arguments {
-Line 181 
 typedef struct stub_list {
+Line 184 
 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;
+   int private_data_ptr;
    /* 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;
+   int private_data_ptr;
- } 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;
+   int private_data_ptr;
    /* 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 {
+Line 267 
 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;
-   /* Opcode local area direct map. */
+   /* Maps private data offset to each opcode. */
-   int *localptrs;
+   int *private_data_ptrs;
+   /* Tells whether the capturing bracket is optimized. */
+   pcre_uint8 *optimized_cbracket;
+   /* Starting offset of private data for capturing brackets. */
    int cbraptr;
    /* OVector starting point. Must be divisible by 2. */
    int ovector_start;
-Line 290 
 typedef struct compiler_common {
+Line 298 
 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 329 
 typedef struct compiler_common {
+Line 343 
 typedef struct compiler_common {
  #ifdef SUPPORT_UCP
    BOOL use_ucp;
  #endif
+ #ifndef COMPILE_PCRE32
    jump_list *utfreadchar;
+ #endif
  #ifdef COMPILE_PCRE8
    jump_list *utfreadtype8;
  #endif
-Line 349 
 typedef struct compare_context {
+Line 365 
 typedef struct compare_context {
    union {
      sljit_i asint;
      sljit_uh asushort;
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
      sljit_ub asbyte;
      sljit_ub asuchars[4];
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
      sljit_uh asuchars[2];
- #endif
+ #elif defined COMPILE_PCRE32
+     sljit_ui asuchars[1];
  #endif
    } c;
    union {
      sljit_i asint;
      sljit_uh asushort;
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
      sljit_ub asbyte;
      sljit_ub asuchars[4];
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
      sljit_uh asuchars[2];
- #endif
+ #elif defined COMPILE_PCRE32
+     sljit_ui asuchars[1];
  #endif
    } oc;
  #endif
-Line 396 
 enum {
+Line 412 
 enum {
  #define CALL_COUNT    SLJIT_SAVED_EREG2
  #define RETURN_ADDR   SLJIT_TEMPORARY_EREG1
- /* Locals layout. */
+ /* Local space layout. */
  /* These two locals can be used by the current opcode. */
  #define LOCALS0          (0 * sizeof(sljit_w))
  #define LOCALS1          (1 * sizeof(sljit_w))
-Line 412 
 the start pointers when the end of the c
+Line 428 
 the start pointers when the end of the c
  #define OVECTOR_START    (common->ovector_start)
  #define OVECTOR(i)       (OVECTOR_START + (i) * sizeof(sljit_w))
  #define OVECTOR_PRIV(i)  (common->cbraptr + (i) * sizeof(sljit_w))
- #define PRIV_DATA(cc)    (common->localptrs[(cc) - common->start])
+ #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  #define MOV_UCHAR  SLJIT_MOV_UB
  #define MOVU_UCHAR SLJIT_MOVU_UB
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
  #define MOV_UCHAR  SLJIT_MOV_UH
  #define MOVU_UCHAR SLJIT_MOVU_UH
+ #elif defined COMPILE_PCRE32
+ #define MOV_UCHAR  SLJIT_MOV_UI
+ #define MOVU_UCHAR SLJIT_MOVU_UI
  #else
  #error Unsupported compiling mode
  #endif
- #endif
  /* Shortcuts. */
  #define DEFINE_COMPILER \
-Line 461 
 return cc;
+Line 478 
 return cc;
  /* Functions whose might need modification for all new supported opcodes:
   next_opcode
-  get_localspace
+  get_private_data_length
-  set_localptrs
+  set_private_data_ptrs
   get_framesize
   init_frame
-  get_localsize
+  get_private_data_length_for_copy
-  copy_locals
+  copy_private_data
-  compile_hotpath
+  compile_matchingpath
-  compile_fallbackpath
+  compile_backtrackingpath
  */
  static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
-Line 574 
 switch(*cc)
+Line 591 
 switch(*cc)
    case OP_NOTPOSPLUSI:
    case OP_NOTPOSQUERYI:
    cc += 2;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
    return cc;
-Line 596 
 switch(*cc)
+Line 613 
 switch(*cc)
    case OP_NOTEXACTI:
    case OP_NOTPOSUPTOI:
    cc += 2 + IMM2_SIZE;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
    return cc;
-Line 667 
 switch(*cc)
+Line 684 
 switch(*cc)
    }
  }
- static int get_localspace(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
+ #define CASE_ITERATOR_PRIVATE_DATA_1 \
+     case OP_MINSTAR: \
+     case OP_MINPLUS: \
+     case OP_QUERY: \
+     case OP_MINQUERY: \
+     case OP_MINSTARI: \
+     case OP_MINPLUSI: \
+     case OP_QUERYI: \
+     case OP_MINQUERYI: \
+     case OP_NOTMINSTAR: \
+     case OP_NOTMINPLUS: \
+     case OP_NOTQUERY: \
+     case OP_NOTMINQUERY: \
+     case OP_NOTMINSTARI: \
+     case OP_NOTMINPLUSI: \
+     case OP_NOTQUERYI: \
+     case OP_NOTMINQUERYI:
+ #define CASE_ITERATOR_PRIVATE_DATA_2A \
+     case OP_STAR: \
+     case OP_PLUS: \
+     case OP_STARI: \
+     case OP_PLUSI: \
+     case OP_NOTSTAR: \
+     case OP_NOTPLUS: \
+     case OP_NOTSTARI: \
+     case OP_NOTPLUSI:
+ #define CASE_ITERATOR_PRIVATE_DATA_2B \
+     case OP_UPTO: \
+     case OP_MINUPTO: \
+     case OP_UPTOI: \
+     case OP_MINUPTOI: \
+     case OP_NOTUPTO: \
+     case OP_NOTMINUPTO: \
+     case OP_NOTUPTOI: \
+     case OP_NOTMINUPTOI:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
+     case OP_TYPEMINSTAR: \
+     case OP_TYPEMINPLUS: \
+     case OP_TYPEQUERY: \
+     case OP_TYPEMINQUERY:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
+     case OP_TYPESTAR: \
+     case OP_TYPEPLUS:
+ #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
+     case OP_TYPEUPTO: \
+     case OP_TYPEMINUPTO:
+ static int get_class_iterator_size(pcre_uchar *cc)
  {
- int localspace = 0;
+ switch(*cc)
+   {
+   case OP_CRSTAR:
+   case OP_CRPLUS:
+   return 2;
+   case OP_CRMINSTAR:
+   case OP_CRMINPLUS:
+   case OP_CRQUERY:
+   case OP_CRMINQUERY:
+   return 1;
+   case OP_CRRANGE:
+   case OP_CRMINRANGE:
+   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
+     return 0;
+   return 2;
+   default:
+   return 0;
+   }
+ }
+ static int get_private_data_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
+ {
+ int private_data_length = 0;
  pcre_uchar *alternative;
+ pcre_uchar *name;
+ pcre_uchar *end = NULL;
+ int space, size, bracketlen, i;
  /* 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 681 
 while (cc < ccend)
+Line 782 
 while (cc < ccend)
      cc += 1;
      break;
+     case OP_REF:
+     case OP_REFI:
+     common->optimized_cbracket[GET2(cc, 1)] = 0;
+     cc += 1 + IMM2_SIZE;
+     break;
      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
-Line 690 
 while (cc < ccend)
+Line 797 
 while (cc < ccend)
      case OP_BRAPOS:
      case OP_SBRA:
      case OP_SBRAPOS:
-     case OP_SCOND:
+     private_data_length += sizeof(sljit_w);
-     localspace += sizeof(sljit_w);
+     bracketlen = 1 + LINK_SIZE;
-     cc += 1 + LINK_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     localspace += sizeof(sljit_w);
+     private_data_length += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE + IMM2_SIZE;
+     common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
+     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-     /* Might be a hidden SCOND. */
+     case OP_SCOND:
-     alternative = cc + GET(cc, 1);
+     bracketlen = cc[1 + LINK_SIZE];
-     if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
+     if (bracketlen == OP_CREF)
-       localspace += sizeof(sljit_w);
+       {
-     cc += 1 + LINK_SIZE;
+       bracketlen = GET2(cc, 1 + LINK_SIZE + 1);
+       common->optimized_cbracket[bracketlen] = 0;
+       }
+     else if (bracketlen == OP_NCREF)
+       {
+       bracketlen = GET2(cc, 1 + LINK_SIZE + 1);
+       name = (pcre_uchar *)common->name_table;
+       alternative = name;
+       for (i = 0; i < common->name_count; i++)
+         {
+         if (GET2(name, 0) == bracketlen) break;
+         name += common->name_entry_size;
+         }
+       SLJIT_ASSERT(i != common->name_count);
+       for (i = 0; i < common->name_count; i++)
+         {
+         if (STRCMP_UC_UC(alternative + IMM2_SIZE, name + IMM2_SIZE) == 0)
+           common->optimized_cbracket[GET2(alternative, 0)] = 0;
+         alternative += common->name_entry_size;
+         }
+       }
+     if (*cc == OP_COND)
+       {
+       /* Might be a hidden SCOND. */
+       alternative = cc + GET(cc, 1);
+       if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
+         private_data_length += sizeof(sljit_w);
+       }
+     else
+       private_data_length += sizeof(sljit_w);
+     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_PRIVATE_DATA_1
+     space = 1;
+     size = -2;
+     break;
+     CASE_ITERATOR_PRIVATE_DATA_2A
+     space = 2;
+     size = -2;
+     break;
+     CASE_ITERATOR_PRIVATE_DATA_2B
+     space = 2;
+     size = -(2 + IMM2_SIZE);
      break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+     space = 1;
+     size = 1;
+     break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
+       space = 2;
+     size = 1;
+     break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
+       space = 2;
+     size = 1 + IMM2_SIZE;
+     break;
+     case OP_CLASS:
+     case OP_NCLASS:
+     size += 1 + 32 / sizeof(pcre_uchar);
+     space = get_class_iterator_size(cc + size);
+     break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_XCLASS:
+     size = GET(cc, 1);
+     space = get_class_iterator_size(cc + size);
+     break;
+ #endif
      case OP_RECURSE:
      /* Set its value only once. */
      if (common->recursive_head == 0)
-Line 734 
 while (cc < ccend)
+Line 927 
 while (cc < ccend)
        return -1;
      break;
      }
+   if (space > 0 && cc >= end)
+     private_data_length += sizeof(sljit_w) * space;
+   if (size != 0)
+     {
+     if (size < 0)
+       {
+       cc += -size;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+       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;
+ return private_data_length;
  }
- static void set_localptrs(compiler_common *common, int localptr, pcre_uchar *ccend)
+ static void set_private_data_ptrs(compiler_common *common, int private_data_ptr, pcre_uchar *ccend)
  {
  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 756 
 while (cc < ccend)
+Line 982 
 while (cc < ccend)
      case OP_SBRA:
      case OP_SBRAPOS:
      case OP_SCOND:
-     common->localptrs[cc - common->start] = localptr;
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     localptr += sizeof(sljit_w);
+     private_data_ptr += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE;
+     bracketlen = 1 + LINK_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     common->localptrs[cc - common->start] = localptr;
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
-     localptr += sizeof(sljit_w);
+     private_data_ptr += sizeof(sljit_w);
-     cc += 1 + LINK_SIZE + IMM2_SIZE;
+     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_COND:
-Line 773 
 while (cc < ccend)
+Line 999 
 while (cc < ccend)
      alternative = cc + GET(cc, 1);
      if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
        {
-       common->localptrs[cc - common->start] = localptr;
+       common->private_data_ptrs[cc - common->start] = private_data_ptr;
-       localptr += sizeof(sljit_w);
+       private_data_ptr += 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_PRIVATE_DATA_1
+     space = 1;
+     size = -2;
      break;
+     CASE_ITERATOR_PRIVATE_DATA_2A
+     space = 2;
+     size = -2;
+     break;
+     CASE_ITERATOR_PRIVATE_DATA_2B
+     space = 2;
+     size = -(2 + IMM2_SIZE);
+     break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+     space = 1;
+     size = 1;
+     break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
+       space = 2;
+     size = 1;
+     break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
+       space = 2;
+     size = 1 + IMM2_SIZE;
+     break;
+     case OP_CLASS:
+     case OP_NCLASS:
+     size += 1 + 32 / sizeof(pcre_uchar);
+     space = get_class_iterator_size(cc + size);
+     break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_XCLASS:
+     size = GET(cc, 1);
+     space = get_class_iterator_size(cc + size);
+     break;
+ #endif
      default:
      cc = next_opcode(common, cc);
      SLJIT_ASSERT(cc != NULL);
      break;
      }
+   if (space > 0 && cc >= end)
+     {
+     common->private_data_ptrs[cc - common->start] = private_data_ptr;
+     private_data_ptr += sizeof(sljit_w) * space;
+     }
+   if (size != 0)
+     {
+     if (size < 0)
+       {
+       cc += -size;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+       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 960 
 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), st
+Line 1270 
 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), st
  SLJIT_ASSERT(stackpos == STACK(stacktop));
  }
- static SLJIT_INLINE int get_localsize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
+ static SLJIT_INLINE int get_private_data_length_for_copy(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
  {
- int localsize = 2;
+ int private_data_length = 2;
+ int size;
  pcre_uchar *alternative;
- /* Calculate the sum of the local variables. */
+ /* Calculate the sum of the private machine words. */
  while (cc < ccend)
    {
+   size = 0;
    switch(*cc)
      {
      case OP_ASSERT:
-Line 979 
 while (cc < ccend)
+Line 1291 
 while (cc < ccend)
      case OP_SBRA:
      case OP_SBRAPOS:
      case OP_SCOND:
-     localsize++;
+     private_data_length++;
      cc += 1 + LINK_SIZE;
      break;
      case OP_CBRA:
      case OP_SCBRA:
-     localsize++;
+     if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+       private_data_length++;
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
-     localsize += 2;
+     private_data_length += 2;
      cc += 1 + LINK_SIZE + IMM2_SIZE;
      break;
-Line 999 
 while (cc < ccend)
+Line 1312 
 while (cc < ccend)
      /* Might be a hidden SCOND. */
      alternative = cc + GET(cc, 1);
      if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
-       localsize++;
+       private_data_length++;
      cc += 1 + LINK_SIZE;
      break;
+     CASE_ITERATOR_PRIVATE_DATA_1
+     if (PRIVATE_DATA(cc))
+       private_data_length++;
+     cc += 2;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+     break;
+     CASE_ITERATOR_PRIVATE_DATA_2A
+     if (PRIVATE_DATA(cc))
+       private_data_length += 2;
+     cc += 2;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+     break;
+     CASE_ITERATOR_PRIVATE_DATA_2B
+     if (PRIVATE_DATA(cc))
+       private_data_length += 2;
+     cc += 2 + IMM2_SIZE;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+     break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+     if (PRIVATE_DATA(cc))
+       private_data_length++;
+     cc += 1;
+     break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+     if (PRIVATE_DATA(cc))
+       private_data_length += 2;
+     cc += 1;
+     break;
+     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+     if (PRIVATE_DATA(cc))
+       private_data_length += 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 (PRIVATE_DATA(cc))
+       private_data_length += get_class_iterator_size(cc + size);
+     cc += size;
+     break;
      default:
      cc = next_opcode(common, cc);
      SLJIT_ASSERT(cc != NULL);
-Line 1010 
 while (cc < ccend)
+Line 1381 
 while (cc < ccend)
      }
    }
  SLJIT_ASSERT(cc == ccend);
- return localsize;
+ return private_data_length;
  }
- static void copy_locals(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
+ static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
    BOOL save, int stackptr, int stacktop)
  {
  DEFINE_COMPILER;
  int srcw[2];
- int count;
+ int count, size;
  BOOL tmp1next = TRUE;
  BOOL tmp1empty = TRUE;
  BOOL tmp2empty = TRUE;
-Line 1083 
 while (status != end)
+Line 1454 
 while (status != end)
        case OP_SBRAPOS:
        case OP_SCOND:
        count = 1;
-       srcw[0] = PRIV_DATA(cc);
+       srcw[0] = PRIVATE_DATA(cc);
        SLJIT_ASSERT(srcw[0] != 0);
        cc += 1 + LINK_SIZE;
        break;
        case OP_CBRA:
        case OP_SCBRA:
-       count = 1;
+       if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
-       srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
+         {
+         count = 1;
+         srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
+         }
        cc += 1 + LINK_SIZE + IMM2_SIZE;
        break;
        case OP_CBRAPOS:
        case OP_SCBRAPOS:
        count = 2;
+       srcw[0] = PRIVATE_DATA(cc);
        srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
-       srcw[0] = PRIV_DATA(cc);
+       SLJIT_ASSERT(srcw[0] != 0 && srcw[1] != 0);
-       SLJIT_ASSERT(srcw[0] != 0);
        cc += 1 + LINK_SIZE + IMM2_SIZE;
        break;
-Line 1110 
 while (status != end)
+Line 1484 
 while (status != end)
        if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
          {
          count = 1;
-         srcw[0] = PRIV_DATA(cc);
+         srcw[0] = PRIVATE_DATA(cc);
          SLJIT_ASSERT(srcw[0] != 0);
          }
        cc += 1 + LINK_SIZE;
        break;
+       CASE_ITERATOR_PRIVATE_DATA_1
+       if (PRIVATE_DATA(cc))
+         {
+         count = 1;
+         srcw[0] = PRIVATE_DATA(cc);
+         }
+       cc += 2;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+       break;
+       CASE_ITERATOR_PRIVATE_DATA_2A
+       if (PRIVATE_DATA(cc))
+         {
+         count = 2;
+         srcw[0] = PRIVATE_DATA(cc);
+         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_w);
+         }
+       cc += 2;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+       break;
+       CASE_ITERATOR_PRIVATE_DATA_2B
+       if (PRIVATE_DATA(cc))
+         {
+         count = 2;
+         srcw[0] = PRIVATE_DATA(cc);
+         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_w);
+         }
+       cc += 2 + IMM2_SIZE;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+ #endif
+       break;
+       CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+       if (PRIVATE_DATA(cc))
+         {
+         count = 1;
+         srcw[0] = PRIVATE_DATA(cc);
+         }
+       cc += 1;
+       break;
+       CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+       if (PRIVATE_DATA(cc))
+         {
+         count = 2;
+         srcw[0] = PRIVATE_DATA(cc);
+         srcw[1] = srcw[0] + sizeof(sljit_w);
+         }
+       cc += 1;
+       break;
+       CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+       if (PRIVATE_DATA(cc))
+         {
+         count = 2;
+         srcw[0] = PRIVATE_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 (PRIVATE_DATA(cc))
+         switch(get_class_iterator_size(cc + size))
+           {
+           case 1:
+           count = 1;
+           srcw[0] = PRIVATE_DATA(cc);
+           break;
+           case 2:
+           count = 2;
+           srcw[0] = PRIVATE_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 1218 
 if (save)
+Line 1688 
 if (save)
  SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
  }
- static SLJIT_INLINE BOOL ispowerof2(unsigned int value)
+ #undef CASE_ITERATOR_PRIVATE_DATA_1
+ #undef CASE_ITERATOR_PRIVATE_DATA_2A
+ #undef CASE_ITERATOR_PRIVATE_DATA_2B
+ #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+ #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+ #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+ static SLJIT_INLINE BOOL is_powerof2(unsigned int value)
  {
  return (value & (value - 1)) == 0;
  }
-Line 1228 
 static SLJIT_INLINE void set_jumps(jump_
+Line 1705 
 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 1255 
 if (list_item)
+Line 1732 
 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 1275 
 while (list_item)
+Line 1752 
 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 1360 
 loop = LABEL();
+Line 1837 
 loop = LABEL();
  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_TEMPORARY_REG1, 0);
  OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_w));
  /* Copy the integer value to the output buffer */
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
  OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG3), sizeof(int), SLJIT_SAVED_REG2, 0);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
-Line 1385 
 else
+Line 1862 
 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 1395 
 SLJIT_ASSERT(common->start_used_ptr != 0
+Line 1872 
 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));
  OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));
  OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
  OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
  OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(int), SLJIT_SAVED_REG2, 0);
  OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_SAVED_REG1, 0);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- OP2(SLJIT_ASHR, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 1);
+ OP2(SLJIT_ASHR, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);
  #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 1524 
 if (c <= 127 && bit == 0x20)
+Line 2001 
 if (c <= 127 && bit == 0x20)
    return (0 << 8) | 0x20;
  /* Since c != oc, they must have at least 1 bit difference. */
- if (!ispowerof2(bit))
+ if (!is_powerof2(bit))
    return 0;
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  #ifdef SUPPORT_UTF
  if (common->utf && c > 127)
-Line 1543 
 if (common->utf && c > 127)
+Line 2020 
 if (common->utf && c > 127)
  #endif /* SUPPORT_UTF */
  return (0 << 8) | bit;
- #else /* COMPILE_PCRE8 */
+ #elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- #ifdef COMPILE_PCRE16
  #ifdef SUPPORT_UTF
  if (common->utf && c > 65535)
    {
-Line 1556 
 if (common->utf && c > 65535)
+Line 2032 
 if (common->utf && c > 65535)
    }
  #endif /* SUPPORT_UTF */
  return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));
- #endif /* COMPILE_PCRE16 */
- #endif /* COMPILE_PCRE8 */
+ #endif /* COMPILE_PCRE[8|16|32] */
  }
  static void check_partial(compiler_common *common, BOOL force)
-Line 1622 
 JUMPHERE(jump);
+Line 2097 
 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 1656 
 static void read_char(compiler_common *c
+Line 2131 
 static void read_char(compiler_common *c
  /* Reads the character into TMP1, updates STR_PTR.
  Does not check STR_END. TMP2 Destroyed. */
  DEFINE_COMPILER;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  if (common->utf)
    {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
- #endif /* COMPILE_PCRE8 */
    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
    JUMPHERE(jump);
    }
- #endif
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
  }
-Line 1683 
 static void peek_char(compiler_common *c
+Line 2156 
 static void peek_char(compiler_common *c
  /* Reads the character into TMP1, keeps STR_PTR.
  Does not check STR_END. TMP2 Destroyed. */
  DEFINE_COMPILER;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
  if (common->utf)
    {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
    jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
- #endif /* COMPILE_PCRE8 */
    add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
    JUMPHERE(jump);
    }
- #endif
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  }
  static void read_char8_type(compiler_common *common)
  {
  /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
  DEFINE_COMPILER;
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  struct sljit_jump *jump;
  #endif
-Line 1718 
 if (common->utf)
+Line 2189 
 if (common->utf)
    {
    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    /* This can be an extra read in some situations, but hopefully
    it is needed in most cases. */
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
    jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
    add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
    JUMPHERE(jump);
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
    jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
-Line 1737 
 if (common->utf)
+Line 2207 
 if (common->utf)
    COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
- #endif
+ #elif defined COMPILE_PCRE32
- #endif /* COMPILE_PCRE8 */
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+   jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
+   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+   JUMPHERE(jump);
+ #endif /* COMPILE_PCRE[8|16|32] */
    return;
    }
- #endif
+ #endif /* SUPPORT_UTF */
  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  /* The ctypes array contains only 256 values. */
  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
  jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
  #endif
  OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  JUMPHERE(jump);
  #endif
  }
-Line 1759 
 static void skip_char_back(compiler_comm
+Line 2233 
 static void skip_char_back(compiler_comm
  {
  /* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */
  DEFINE_COMPILER;
- #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #if defined COMPILE_PCRE8
  struct sljit_label *label;
  if (common->utf)
-Line 1771 
 if (common->utf)
+Line 2246 
 if (common->utf)
    CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
    return;
    }
- #endif
+ #elif defined COMPILE_PCRE16
- #if defined SUPPORT_UTF && defined COMPILE_PCRE16
  if (common->utf)
    {
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
-Line 1785 
 if (common->utf)
+Line 2259 
 if (common->utf)
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    return;
    }
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  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 1797 
 DEFINE_COMPILER;
+Line 2272 
 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 1805 
 else if (nltype == NLTYPE_ANYCRLF)
+Line 2280 
 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));
    }
  }
  #ifdef SUPPORT_UTF
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  static void do_utfreadchar(compiler_common *common)
  {
  /* Fast decoding a UTF-8 character. TMP1 contains the first byte
-Line 1910 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+Line 2385 
 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
- #else /* COMPILE_PCRE8 */
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
  static void do_utfreadchar(compiler_common *common)
  {
  /* Fast decoding a UTF-16 character. TMP1 contains the first 16 bit char
-Line 1937 
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UC
+Line 2411 
 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UC
  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
- #endif /* COMPILE_PCRE16 */
- #endif /* COMPILE_PCRE8 */
+ #endif /* COMPILE_PCRE[8|16] */
  #endif /* SUPPORT_UTF */
-Line 1994 
 if (firstline)
+Line 2467 
 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 2006 
 if (firstline)
+Line 2478 
 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 2017 
 if (firstline)
+Line 2490 
 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 2035 
 if (newlinecheck)
+Line 2508 
 if (newlinecheck)
    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);
    COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
-   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    nl = JUMP(SLJIT_JUMP);
-Line 2057 
 if (newlinecheck)
+Line 2530 
 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 defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #if defined COMPILE_PCRE8
  if (common->utf)
    {
    singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
-Line 2065 
 if (common->utf)
+Line 2539 
 if (common->utf)
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    JUMPHERE(singlechar);
    }
- #endif
+ #elif defined COMPILE_PCRE16
- #if defined SUPPORT_UTF && defined COMPILE_PCRE16
  if (common->utf)
    {
    singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
-Line 2077 
 if (common->utf)
+Line 2550 
 if (common->utf)
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    JUMPHERE(singlechar);
    }
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
+ #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
  JUMPHERE(start);
  if (newlinecheck)
-Line 2089 
 if (newlinecheck)
+Line 2563 
 if (newlinecheck)
  return mainloop;
  }
+ #define MAX_N_CHARS 3
+ static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
+ {
+ DEFINE_COMPILER;
+ struct sljit_label *start;
+ struct sljit_jump *quit;
+ pcre_uint32 chars[MAX_N_CHARS * 2];
+ pcre_uchar *cc = common->start + 1 + IMM2_SIZE;
+ int location = 0;
+ pcre_int32 len, c, bit, caseless;
+ int must_stop;
+ /* We do not support alternatives now. */
+ if (*(common->start + GET(common->start, 1)) == OP_ALT)
+   return FALSE;
+ while (TRUE)
+   {
+   caseless = 0;
+   must_stop = 1;
+   switch(*cc)
+     {
+     case OP_CHAR:
+     must_stop = 0;
+     cc++;
+     break;
+     case OP_CHARI:
+     caseless = 1;
+     must_stop = 0;
+     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:
+     must_stop = 2;
+     break;
+     }
+   if (must_stop == 2)
+       break;
+   len = 1;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+   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 < MAX_N_CHARS * 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 >= MAX_N_CHARS * 2 || must_stop != 0)
+     break;
+   }
+ /* At least two characters are required. */
+ if (location < 2 * 2)
+     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, (location >> 1) - 1);
+   }
+ else
+   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, (location >> 1) - 1);
+ start = LABEL();
+ quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ if (chars[1] != 0)
+   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
+ CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
+ if (location > 2 * 2)
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+ if (chars[3] != 0)
+   OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[3]);
+ CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[2], start);
+ if (location > 2 * 2)
+   {
+   if (chars[5] != 0)
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[5]);
+   CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[4], start);
+   }
+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+ JUMPHERE(quit);
+ if (firstline)
+   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+ else
+   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, (location >> 1) - 1);
+ return TRUE;
+ }
+ #undef MAX_N_CHARS
  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 2121 
 if (first_char == oc)
+Line 2765 
 if (first_char == oc)
  else
    {
    bit = first_char ^ oc;
-   if (ispowerof2(bit))
+   if (is_powerof2(bit))
      {
      OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);
      found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, first_char | bit);
-Line 2137 
 else
+Line 2781 
 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 2170 
 DEFINE_COMPILER;
+Line 2795 
 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 2192 
 if (common->nltype == NLTYPE_FIXED && co
+Line 2818 
 if (common->nltype == NLTYPE_FIXED && co
    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));
    OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);
    COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_GREATER_EQUAL);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
-   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
  #endif
    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
    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 2229 
 set_jumps(newline, loop);
+Line 2855 
 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);
    OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
    COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
- #ifdef COMPILE_PCRE16
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
-   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
  #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 2261 
 struct sljit_jump *jump;
+Line 2887 
 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 2289 
 if (common->utf)
+Line 2916 
 if (common->utf)
    OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
  #endif
  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #if defined SUPPORT_UTF && defined COMPILE_PCRE8
+ #ifdef SUPPORT_UTF
+ #if 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
+ #elif defined COMPILE_PCRE16
- #if defined SUPPORT_UTF && defined COMPILE_PCRE16
  if (common->utf)
    {
    CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
-Line 2307 
 if (common->utf)
+Line 2934 
 if (common->utf)
    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
    }
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
+ #endif /* SUPPORT_UTF */
  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 2325 
 struct sljit_jump *alreadyfound;
+Line 2953 
 struct sljit_jump *alreadyfound;
  struct sljit_jump *found;
  struct sljit_jump *foundoc = NULL;
  struct sljit_jump *notfound;
- pcre_uchar oc, bit;
+ pcre_uint32 oc, bit;
  SLJIT_ASSERT(common->req_char_ptr != 0);
  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr);
-Line 2356 
 if (req_char == oc)
+Line 2984 
 if (req_char == oc)
  else
    {
    bit = req_char ^ oc;
-   if (ispowerof2(bit))
+   if (is_powerof2(bit))
      {
      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
      found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
-Line 2531 
 else
+Line 3159 
 else
      JUMPHERE(jump);
  #endif /* COMPILE_PCRE8 */
    }
  JUMPHERE(skipread);
+ OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
+ 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]) && is_powerof2(ranges[4] - ranges[2]))
+     {
+     if (readch)
+       read_char(common);
+     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4] - ranges[2]);
+     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4]);
+     add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[5] - ranges[4]));
+     return TRUE;
+     }
+   return FALSE;
+   default:
+   return FALSE;
+   }
+ }
+ static void get_ctype_ranges(compiler_common *common, int flag, int *ranges)
+ {
+ int i, bit, length;
+ const pcre_uint8 *ctypes = (const pcre_uint8*)common->ctypes;
+ bit = ctypes[0] & flag;
+ ranges[0] = -1;
+ ranges[1] = bit != 0 ? 1 : 0;
+ length = 0;
+ for (i = 1; i < 256; i++)
+   if ((ctypes[i] & flag) != bit)
+     {
+     if (length >= MAX_RANGE_SIZE)
+       return;
+     ranges[2 + length] = i;
+     length++;
+     bit ^= flag;
+     }
+ if (bit != 0)
+   {
+   if (length >= MAX_RANGE_SIZE)
+     return;
+   ranges[2 + length] = 256;
+   length++;
+   }
+ ranges[0] = length;
+ }
+ static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks)
+ {
+ int ranges[2 + MAX_RANGE_SIZE];
+ 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++;
+     }
+   }
- OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
+ if (((bit == 0) && nclass) || ((bit == 1) && !nclass))
- sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
+   {
+   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)
-Line 2548 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
+Line 3315 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
  COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  #ifdef COMPILE_PCRE8
  if (common->utf)
    {
-Line 2559 
 if (common->utf)
+Line 3326 
 if (common->utf)
  #ifdef COMPILE_PCRE8
    }
  #endif
- #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
  COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
  }
-Line 2576 
 COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_E
+Line 3343 
 COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_E
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
  COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  #ifdef COMPILE_PCRE8
  if (common->utf)
    {
-Line 2597 
 if (common->utf)
+Line 3364 
 if (common->utf)
  #ifdef COMPILE_PCRE8
    }
  #endif
- #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
  COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
-Line 2614 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
+Line 3381 
 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_I
  OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
  COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
  OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
  #ifdef COMPILE_PCRE8
  if (common->utf)
    {
-Line 2625 
 if (common->utf)
+Line 3392 
 if (common->utf)
  #ifdef COMPILE_PCRE8
    }
  #endif
- #endif /* SUPPORT_UTF || COMPILE_PCRE16 */
+ #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
  COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
  sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
-Line 2715 
 sljit_emit_fast_return(compiler, RETURN_
+Line 3482 
 sljit_emit_fast_return(compiler, RETURN_
  static const pcre_uchar *SLJIT_CALL do_utf_caselesscmp(pcre_uchar *src1, jit_arguments *args, pcre_uchar *end1)
  {
  /* This function would be ineffective to do in JIT level. */
- int c1, c2;
+ pcre_uint32 c1, c2;
  const pcre_uchar *src2 = args->uchar_ptr;
  const pcre_uchar *end2 = args->end;
+ const ucd_record *ur;
+ const pcre_uint32 *pp;
  while (src1 < end1)
    {
-Line 2725 
 while (src1 < end1)
+Line 3494 
 while (src1 < end1)
      return (pcre_uchar*)1;
    GETCHARINC(c1, src1);
    GETCHARINC(c2, src2);
-   if (c1 != c2 && c1 != UCD_OTHERCASE(c2)) return NULL;
+   ur = GET_UCD(c2);
+   if (c1 != c2 && c1 != c2 + ur->other_case)
+     {
+     pp = PRIV(ucd_caseless_sets) + ur->caseset;
+     for (;;)
+       {
+       if (c1 < *pp) return NULL;
+       if (c1 == *pp++) break;
+       }
+     }
    }
  return src2;
  }
-Line 2733 
 return src2;
+Line 3511 
 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 2747 
 if (caseless && char_has_othercase(commo
+Line 3525 
 if (caseless && char_has_othercase(commo
    othercasebit = char_get_othercase_bit(common, cc);
    SLJIT_ASSERT(othercasebit);
    /* Extracting bit difference info. */
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    othercasechar = cc + (othercasebit >> 8);
    othercasebit &= 0xff;
- #else
+ #elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
- #ifdef COMPILE_PCRE16
    othercasechar = cc + (othercasebit >> 9);
    if ((othercasebit & 0x100) != 0)
      othercasebit = (othercasebit & 0xff) << 8;
    else
      othercasebit &= 0xff;
- #endif
+ #endif /* COMPILE_PCRE[8|16|32] */
- #endif
    }
  if (context->sourcereg == -1)
    {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    if (context->length >= 4)
      OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
-Line 2772 
 if (context->sourcereg == -1)
+Line 3548 
 if (context->sourcereg == -1)
    else
  #endif
      OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
  #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    if (context->length >= 4)
      OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
    else
  #endif
-     OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #endif
+ #elif defined COMPILE_PCRE32
- #endif /* COMPILE_PCRE8 */
+   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #endif /* COMPILE_PCRE[8|16|32] */
    context->sourcereg = TMP2;
    }
  #ifdef SUPPORT_UTF
  utflength = 1;
+ #ifndef COMPILE_PCRE32
  if (common->utf && HAS_EXTRALEN(*cc))
    utflength += GET_EXTRALEN(*cc);
+ #endif
  do
    {
-Line 2810 
 do
+Line 3588 
 do
      }
    context->ucharptr++;
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1))
- #else
+ #elif defined COMPILE_PCRE16
    if (context->ucharptr >= 2 || context->length == 0)
+ #elif defined COMPILE_PCRE32
+   if (1 /* context->ucharptr >= 1 || context->length == 0 */)
  #endif
      {
+ #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
      if (context->length >= 4)
        OP1(SLJIT_MOV_SI, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
      else if (context->length >= 2)
        OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
      else if (context->length >= 1)
        OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #else
+ #elif defined COMPILE_PCRE16
      else if (context->length >= 2)
        OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #endif
+ #endif /* COMPILE_PCRE[8|16] */
+ #elif defined COMPILE_PCRE32
+     OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+ #endif /* COMPILE_PCRE[8|16|32] */
      context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
      switch(context->ucharptr)
-Line 2834 
 do
+Line 3618 
 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;
+ #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
        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
+ #endif /* COMPILE_PCRE[8|16] */
        default:
        SLJIT_ASSERT_STOP();
        break;
-Line 2861 
 do
+Line 3648 
 do
  #else
    /* Unaligned read is unsupported. */
- #ifdef COMPILE_PCRE8
-   if (context->length > 0)
-     OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #else
    if (context->length > 0)
-     OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+     OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
- #endif
    context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
    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 2912 
 return cc;
+Line 3695 
 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;
+ pcre_int32 c, charoffset;
- int compares;
+ const pcre_uint32 *other_cases;
  struct sljit_jump *jump = NULL;
  pcre_uchar *ccbegin;
+ int compares, invertcmp, numberofcmps;
  #ifdef SUPPORT_UCP
  BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
  BOOL charsaved = FALSE;
  int typereg = TMP1, scriptreg = TMP1;
- unsigned int typeoffset;
+ pcre_int32 typeoffset;
  #endif
- 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 2944 
 if ((*cc++ & XCL_MAP) != 0)
+Line 3727 
 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 2973 
 while (*cc != XCL_END)
+Line 3759 
 while (*cc != XCL_END)
    if (*cc == XCL_SINGLE)
      {
      cc += 2;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
  #ifdef SUPPORT_UCP
-Line 2983 
 while (*cc != XCL_END)
+Line 3769 
 while (*cc != XCL_END)
    else if (*cc == XCL_RANGE)
      {
      cc += 2;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      cc++;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
  #ifdef SUPPORT_UCP
-Line 3022 
 while (*cc != XCL_END)
+Line 3808 
 while (*cc != XCL_END)
        needschar = TRUE;
        break;
+       case PT_CLIST:
+       needschar = TRUE;
+       break;
        default:
        SLJIT_ASSERT_STOP();
        break;
-Line 3082 
 typeoffset = 0;
+Line 3872 
 typeoffset = 0;
  while (*cc != XCL_END)
    {
    compares--;
-   invertcmp = (compares == 0 && list != fallbacks);
+   invertcmp = (compares == 0 && list != backtracks);
    jump = NULL;
    if (*cc == XCL_SINGLE)
-Line 3164 
 while (*cc != XCL_END)
+Line 3954 
 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 3231 
 while (*cc != XCL_END)
+Line 4021 
 while (*cc != XCL_END)
        COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);
        jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
        break;
+       case PT_CLIST:
+       other_cases = PRIV(ucd_caseless_sets) + cc[1];
+       /* At least three characters are required.
+          Otherwise this case would be handled by the normal code path. */
+       SLJIT_ASSERT(other_cases[0] != NOTACHAR && other_cases[1] != NOTACHAR && other_cases[2] != NOTACHAR);
+       SLJIT_ASSERT(other_cases[0] < other_cases[1] && other_cases[1] < other_cases[2]);
+       /* Optimizing character pairs, if their difference is power of 2. */
+       if (is_powerof2(other_cases[1] ^ other_cases[0]))
+         {
+         if (charoffset == 0)
+           OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+         else
+           {
+           OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_w)charoffset);
+           OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+           }
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[1]);
+         COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+         other_cases += 2;
+         }
+       else if (is_powerof2(other_cases[2] ^ other_cases[1]))
+         {
+         if (charoffset == 0)
+           OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[2] ^ other_cases[1]);
+         else
+           {
+           OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_w)charoffset);
+           OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+           }
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]);
+         COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, other_cases[0] - charoffset);
+         COND_VALUE(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, SLJIT_C_EQUAL);
+         other_cases += 3;
+         }
+       else
+         {
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, *other_cases++ - charoffset);
+         COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
+         }
+       while (*other_cases != NOTACHAR)
+         {
+         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, *other_cases++ - charoffset);
+         COND_VALUE(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, SLJIT_C_EQUAL);
+         }
+       jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
+       break;
        }
      cc += 2;
      }
  #endif
    if (jump != NULL)
-     add_jump(compiler, compares > 0 ? list : fallbacks, jump);
+     add_jump(compiler, compares > 0 ? list : backtracks, jump);
    }
  if (found != NULL)
-Line 3249 
 if (found != NULL)
+Line 4092 
 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 3268 
 switch(type)
+Line 4111 
 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 3319 
 switch(type)
+Line 4173 
 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)
      {
      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
+ #if defined COMPILE_PCRE8
      jump[0] = 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);
- #else /* COMPILE_PCRE8 */
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
      jump[0] = 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);
- #endif /* COMPILE_PCRE16 */
+ #endif
- #endif /* COMPILE_PCRE8 */
      JUMPHERE(jump[0]);
+ #endif /* COMPILE_PCRE[8|16] */
      return cc;
      }
  #endif
-Line 3357 
 switch(type)
+Line 4211 
 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 3370 
 switch(type)
+Line 4224 
 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 3389 
 switch(type)
+Line 4243 
 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 3397 
 switch(type)
+Line 4251 
 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);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
-   add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc));
+   /* Optimize register allocation: use a real register. */
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
+   OP1(SLJIT_MOV_UB, STACK_TOP, 0, SLJIT_MEM2(TMP1, TMP2), 3);
    label = LABEL();
    jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
    OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
    read_char(common);
    add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
-   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Mc);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
-   CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc, label);
+   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM2(TMP1, TMP2), 3);
+   OP2(SLJIT_SHL, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 2);
+   OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(STACK_TOP), (sljit_w)PRIV(ucp_gbtable));
+   OP1(SLJIT_MOV, STACK_TOP, 0, TMP2, 0);
+   OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
+   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+   JUMPTO(SLJIT_C_NOT_ZERO, label);
    OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
    JUMPHERE(jump[0]);
+   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
    if (common->mode == JIT_PARTIAL_HARD_COMPILE)
      {
      jump[0] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
-Line 3447 
 switch(type)
+Line 4312 
 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 3455 
 switch(type)
+Line 4320 
 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 3478 
 switch(type)
+Line 4343 
 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 3508 
 switch(type)
+Line 4373 
 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 3525 
 switch(type)
+Line 4390 
 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 3551 
 switch(type)
+Line 4416 
 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 3566 
 switch(type)
+Line 4431 
 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 3576 
 switch(type)
+Line 4441 
 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 3602 
 switch(type)
+Line 4467 
 switch(type)
    case OP_CHAR:
    case OP_CHARI:
    length = 1;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
    if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);
  #endif
    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 3629 
 switch(type)
+Line 4494 
 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);
    bit = c ^ oc;
-   if (ispowerof2(bit))
+   if (is_powerof2(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 3660 
 switch(type)
+Line 4525 
 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 3690 
 switch(type)
+Line 4555 
 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);
      bit = c ^ oc;
-     if (ispowerof2(bit))
+     if (is_powerof2(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 3723 
 switch(type)
+Line 4591 
 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 3733 
 switch(type)
+Line 4601 
 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]);
  #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
    return cc + 32 / sizeof(pcre_uchar);
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
    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
-Line 3757 
 switch(type)
+Line 4625 
 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 3767 
 switch(type)
+Line 4635 
 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 3776 
 SLJIT_ASSERT_STOP();
+Line 4644 
 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 3794 
 do
+Line 4662 
 do
    if (*cc == OP_CHAR)
      {
      size = 1;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (common->utf && HAS_EXTRALEN(cc[1]))
        size += GET_EXTRALEN(cc[1]);
  #endif
-Line 3807 
 do
+Line 4675 
 do
        {
        if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
          size = 0;
+ #ifndef COMPILE_PCRE32
        else if (HAS_EXTRALEN(cc[1]))
          size += GET_EXTRALEN(cc[1]);
+ #endif
        }
      else
  #endif
-Line 3828 
 if (context.length > 0)
+Line 4698 
 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 3850 
 int offset = GET2(cc, 1) << 1;
+Line 4720 
 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 3859 
 if (!common->jscript_compat)
+Line 4729 
 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 3907 
 struct sljit_jump *nopartial;
+Line 4777 
 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 3924 
 if (common->utf && *cc == OP_REFI)
+Line 4794 
 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 3945 
 else
+Line 4815 
 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 3960 
 else
+Line 4830 
 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 3971 
 else
+Line 4841 
 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 3990 
 pcre_uchar *ccbegin = cc;
+Line 4860 
 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 4042 
 if (!minimize)
+Line 4912 
 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 4077 
 if (!minimize)
+Line 4947 
 if (!minimize)
      }
    JUMPHERE(zerolength);
-   FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
+   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
    decrease_call_count(common);
    return cc;
-Line 4095 
 if (min == 0)
+Line 4965 
 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 4109 
 if (min > 1)
+Line 4979 
 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 4122 
 decrease_call_count(common);
+Line 4992 
 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 4175 
 if (entry->entry == NULL)
+Line 5045 
 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;
+ int private_data_ptr;
- 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 5075 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
    bra = *cc;
    cc++;
    }
- localptr = PRIV_DATA(cc);
+ private_data_ptr = PRIVATE_DATA(cc);
- SLJIT_ASSERT(localptr != 0);
+ SLJIT_ASSERT(private_data_ptr != 0);
  framesize = get_framesize(common, cc, FALSE);
- fallback->framesize = framesize;
+ backtrack->framesize = framesize;
- fallback->localptr = localptr;
+ backtrack->private_data_ptr = private_data_ptr;
  opcode = *cc;
  SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);
  found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;
-Line 4218 
 cc += GET(cc, 1);
+Line 5088 
 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 4226 
 if (bra == OP_BRAMINZERO)
+Line 5096 
 if (bra == OP_BRAMINZERO)
  if (framesize < 0)
    {
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);
    allocate_stack(common, 1);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
    }
  else
    {
    allocate_stack(common, framesize + 2);
-   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
    OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(framesize + 1));
-   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
+   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
    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 4270 
 while (1)
+Line 5140 
 while (1)
    /* Reset stack. */
    if (framesize < 0)
-     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
    else {
      if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)
        {
-       /* We don't need to keep the STR_PTR, only the previous localptr. */
+       /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
-       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
        }
      else
        {
-       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
        add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
        }
    }
-Line 4297 
 while (1)
+Line 5167 
 while (1)
          {
          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
          OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_w));
-         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
+         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
          }
        OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
-Line 4305 
 while (1)
+Line 5175 
 while (1)
      else if (framesize >= 0)
        {
        /* For OP_BRA and OP_BRAMINZERO. */
-       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
        }
      }
    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 4328 
 while (1)
+Line 5198 
 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 4356 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 5226 
 if (opcode == OP_ASSERT || opcode == OP_
        }
      else
        free_stack(common, framesize + 2);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
      }
    jump = JUMP(SLJIT_JUMP);
    if (bra != OP_BRAZERO)
-Line 4381 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 5251 
 if (opcode == OP_ASSERT || opcode == OP_
      {
      if (bra == OP_BRA)
        {
-       /* We don't need to keep the STR_PTR, only the previous localptr. */
+       /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
-       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
        }
      else
        {
-       /* We don't need to keep the STR_PTR, only the previous localptr. */
+       /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
-       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_w));
+       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_w));
        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
        }
-Line 4396 
 if (opcode == OP_ASSERT || opcode == OP_
+Line 5266 
 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)
        {
-       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
+       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);
        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));
+       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
        }
-     set_jumps(fallback->common.topfallbacks, LABEL());
+     set_jumps(backtrack->common.topbacktracks, LABEL());
      }
    }
  else
-Line 4435 
 else
+Line 5305 
 else
        }
      else
        free_stack(common, framesize + 2);
-     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
+     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);
      }
    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 4625 
 return condition;
+Line 5495 
 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 private_data_ptr = 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 4655 
 if (*cc == OP_BRAZERO || *cc == OP_BRAMI
+Line 5525 
 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 4672 
 cc += GET(cc, 1);
+Line 5542 
 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 4694 
 if (opcode == OP_CBRA || opcode == OP_SC
+Line 5564 
 if (opcode == OP_CBRA || opcode == OP_SC
    {
    /* Capturing brackets has a pre-allocated space. */
    offset = GET2(ccbegin, 1 + LINK_SIZE);
-   localptr = OVECTOR_PRIV(offset);
+   if (common->optimized_cbracket[offset] == 0)
-   offset <<= 1;
+     {
-   FALLBACK_AS(bracket_fallback)->localptr = localptr;
+     private_data_ptr = OVECTOR_PRIV(offset);
-   hotpath += IMM2_SIZE;
+     offset <<= 1;
+     }
+   else
+     {
+     offset <<= 1;
+     private_data_ptr = OVECTOR(offset);
+     }
+   BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
+   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);
+   private_data_ptr = PRIVATE_DATA(ccbegin);
-   SLJIT_ASSERT(localptr != 0);
+   SLJIT_ASSERT(private_data_ptr != 0);
-   FALLBACK_AS(bracket_fallback)->localptr = localptr;
+   BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
    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 4731 
 if (bra == OP_BRAZERO)