Home | History | Annotate | Download | only in dist
      1 /*************************************************
      2 *      Perl-Compatible Regular Expressions       *
      3 *************************************************/
      4 
      5 /* PCRE is a library of functions to support regular expressions whose syntax
      6 and semantics are as close as possible to those of the Perl 5 language.
      7 
      8                        Written by Philip Hazel
      9            Copyright (c) 1997-2013 University of Cambridge
     10 
     11   The machine code generator part (this module) was written by Zoltan Herczeg
     12                       Copyright (c) 2010-2013
     13 
     14 -----------------------------------------------------------------------------
     15 Redistribution and use in source and binary forms, with or without
     16 modification, are permitted provided that the following conditions are met:
     17 
     18     * Redistributions of source code must retain the above copyright notice,
     19       this list of conditions and the following disclaimer.
     20 
     21     * Redistributions in binary form must reproduce the above copyright
     22       notice, this list of conditions and the following disclaimer in the
     23       documentation and/or other materials provided with the distribution.
     24 
     25     * Neither the name of the University of Cambridge nor the names of its
     26       contributors may be used to endorse or promote products derived from
     27       this software without specific prior written permission.
     28 
     29 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     30 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     31 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     32 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
     33 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     34 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     35 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     36 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     37 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     38 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     39 POSSIBILITY OF SUCH DAMAGE.
     40 -----------------------------------------------------------------------------
     41 */
     42 
     43 #ifdef HAVE_CONFIG_H
     44 #include "config.h"
     45 #endif
     46 
     47 #include "pcre_internal.h"
     48 
     49 #if defined SUPPORT_JIT
     50 
     51 /* All-in-one: Since we use the JIT compiler only from here,
     52 we just include it. This way we don't need to touch the build
     53 system files. */
     54 
     55 #define SLJIT_MALLOC(size, allocator_data) (PUBL(malloc))(size)
     56 #define SLJIT_FREE(ptr, allocator_data) (PUBL(free))(ptr)
     57 #define SLJIT_CONFIG_AUTO 1
     58 #define SLJIT_CONFIG_STATIC 1
     59 #define SLJIT_VERBOSE 0
     60 #define SLJIT_DEBUG 0
     61 
     62 #include "sljit/sljitLir.c"
     63 
     64 #if defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED
     65 #error Unsupported architecture
     66 #endif
     67 
     68 /* Defines for debugging purposes. */
     69 
     70 /* 1 - Use unoptimized capturing brackets.
     71    2 - Enable capture_last_ptr (includes option 1). */
     72 /* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */
     73 
     74 /* 1 - Always have a control head. */
     75 /* #define DEBUG_FORCE_CONTROL_HEAD 1 */
     76 
     77 /* Allocate memory for the regex stack on the real machine stack.
     78 Fast, but limited size. */
     79 #define MACHINE_STACK_SIZE 32768
     80 
     81 /* Growth rate for stack allocated by the OS. Should be the multiply
     82 of page size. */
     83 #define STACK_GROWTH_RATE 8192
     84 
     85 /* Enable to check that the allocation could destroy temporaries. */
     86 #if defined SLJIT_DEBUG && SLJIT_DEBUG
     87 #define DESTROY_REGISTERS 1
     88 #endif
     89 
     90 /*
     91 Short summary about the backtracking mechanism empolyed by the jit code generator:
     92 
     93 The code generator follows the recursive nature of the PERL compatible regular
     94 expressions. The basic blocks of regular expressions are condition checkers
     95 whose execute different commands depending on the result of the condition check.
     96 The relationship between the operators can be horizontal (concatenation) and
     97 vertical (sub-expression) (See struct backtrack_common for more details).
     98 
     99   'ab' - 'a' and 'b' regexps are concatenated
    100   'a+' - 'a' is the sub-expression of the '+' operator
    101 
    102 The condition checkers are boolean (true/false) checkers. Machine code is generated
    103 for the checker itself and for the actions depending on the result of the checker.
    104 The 'true' case is called as the matching path (expected path), and the other is called as
    105 the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken
    106 branches on the matching path.
    107 
    108  Greedy star operator (*) :
    109    Matching path: match happens.
    110    Backtrack path: match failed.
    111  Non-greedy star operator (*?) :
    112    Matching path: no need to perform a match.
    113    Backtrack path: match is required.
    114 
    115 The following example shows how the code generated for a capturing bracket
    116 with two alternatives. Let A, B, C, D are arbirary regular expressions, and
    117 we have the following regular expression:
    118 
    119    A(B|C)D
    120 
    121 The generated code will be the following:
    122 
    123  A matching path
    124  '(' matching path (pushing arguments to the stack)
    125  B matching path
    126  ')' matching path (pushing arguments to the stack)
    127  D matching path
    128  return with successful match
    129 
    130  D backtrack path
    131  ')' backtrack path (If we arrived from "C" jump to the backtrack of "C")
    132  B backtrack path
    133  C expected path
    134  jump to D matching path
    135  C backtrack path
    136  A backtrack path
    137 
    138  Notice, that the order of backtrack code paths are the opposite of the fast
    139  code paths. In this way the topmost value on the stack is always belong
    140  to the current backtrack code path. The backtrack path must check
    141  whether there is a next alternative. If so, it needs to jump back to
    142  the matching path eventually. Otherwise it needs to clear out its own stack
    143  frame and continue the execution on the backtrack code paths.
    144 */
    145 
    146 /*
    147 Saved stack frames:
    148 
    149 Atomic blocks and asserts require reloading the values of private data
    150 when the backtrack mechanism performed. Because of OP_RECURSE, the data
    151 are not necessarly known in compile time, thus we need a dynamic restore
    152 mechanism.
    153 
    154 The stack frames are stored in a chain list, and have the following format:
    155 ([ capturing bracket offset ][ start value ][ end value ])+ ... [ 0 ] [ previous head ]
    156 
    157 Thus we can restore the private data to a particular point in the stack.
    158 */
    159 
    160 typedef struct jit_arguments {
    161   /* Pointers first. */
    162   struct sljit_stack *stack;
    163   const pcre_uchar *str;
    164   const pcre_uchar *begin;
    165   const pcre_uchar *end;
    166   int *offsets;
    167   pcre_uchar *uchar_ptr;
    168   pcre_uchar *mark_ptr;
    169   void *callout_data;
    170   /* Everything else after. */
    171   pcre_uint32 limit_match;
    172   int real_offset_count;
    173   int offset_count;
    174   pcre_uint8 notbol;
    175   pcre_uint8 noteol;
    176   pcre_uint8 notempty;
    177   pcre_uint8 notempty_atstart;
    178 } jit_arguments;
    179 
    180 typedef struct executable_functions {
    181   void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];
    182   void *read_only_data_heads[JIT_NUMBER_OF_COMPILE_MODES];
    183   sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
    184   PUBL(jit_callback) callback;
    185   void *userdata;
    186   pcre_uint32 top_bracket;
    187   pcre_uint32 limit_match;
    188 } executable_functions;
    189 
    190 typedef struct jump_list {
    191   struct sljit_jump *jump;
    192   struct jump_list *next;
    193 } jump_list;
    194 
    195 typedef struct stub_list {
    196   struct sljit_jump *start;
    197   struct sljit_label *quit;
    198   struct stub_list *next;
    199 } stub_list;
    200 
    201 typedef struct label_addr_list {
    202   struct sljit_label *label;
    203   sljit_uw *update_addr;
    204   struct label_addr_list *next;
    205 } label_addr_list;
    206 
    207 enum frame_types {
    208   no_frame = -1,
    209   no_stack = -2
    210 };
    211 
    212 enum control_types {
    213   type_mark = 0,
    214   type_then_trap = 1
    215 };
    216 
    217 typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
    218 
    219 /* The following structure is the key data type for the recursive
    220 code generator. It is allocated by compile_matchingpath, and contains
    221 the arguments for compile_backtrackingpath. Must be the first member
    222 of its descendants. */
    223 typedef struct backtrack_common {
    224   /* Concatenation stack. */
    225   struct backtrack_common *prev;
    226   jump_list *nextbacktracks;
    227   /* Internal stack (for component operators). */
    228   struct backtrack_common *top;
    229   jump_list *topbacktracks;
    230   /* Opcode pointer. */
    231   pcre_uchar *cc;
    232 } backtrack_common;
    233 
    234 typedef struct assert_backtrack {
    235   backtrack_common common;
    236   jump_list *condfailed;
    237   /* Less than 0 if a frame is not needed. */
    238   int framesize;
    239   /* Points to our private memory word on the stack. */
    240   int private_data_ptr;
    241   /* For iterators. */
    242   struct sljit_label *matchingpath;
    243 } assert_backtrack;
    244 
    245 typedef struct bracket_backtrack {
    246   backtrack_common common;
    247   /* Where to coninue if an alternative is successfully matched. */
    248   struct sljit_label *alternative_matchingpath;
    249   /* For rmin and rmax iterators. */
    250   struct sljit_label *recursive_matchingpath;
    251   /* For greedy ? operator. */
    252   struct sljit_label *zero_matchingpath;
    253   /* Contains the branches of a failed condition. */
    254   union {
    255     /* Both for OP_COND, OP_SCOND. */
    256     jump_list *condfailed;
    257     assert_backtrack *assert;
    258     /* For OP_ONCE. Less than 0 if not needed. */
    259     int framesize;
    260   } u;
    261   /* Points to our private memory word on the stack. */
    262   int private_data_ptr;
    263 } bracket_backtrack;
    264 
    265 typedef struct bracketpos_backtrack {
    266   backtrack_common common;
    267   /* Points to our private memory word on the stack. */
    268   int private_data_ptr;
    269   /* Reverting stack is needed. */
    270   int framesize;
    271   /* Allocated stack size. */
    272   int stacksize;
    273 } bracketpos_backtrack;
    274 
    275 typedef struct braminzero_backtrack {
    276   backtrack_common common;
    277   struct sljit_label *matchingpath;
    278 } braminzero_backtrack;
    279 
    280 typedef struct iterator_backtrack {
    281   backtrack_common common;
    282   /* Next iteration. */
    283   struct sljit_label *matchingpath;
    284 } iterator_backtrack;
    285 
    286 typedef struct recurse_entry {
    287   struct recurse_entry *next;
    288   /* Contains the function entry. */
    289   struct sljit_label *entry;
    290   /* Collects the calls until the function is not created. */
    291   jump_list *calls;
    292   /* Points to the starting opcode. */
    293   sljit_sw start;
    294 } recurse_entry;
    295 
    296 typedef struct recurse_backtrack {
    297   backtrack_common common;
    298   BOOL inlined_pattern;
    299 } recurse_backtrack;
    300 
    301 #define OP_THEN_TRAP OP_TABLE_LENGTH
    302 
    303 typedef struct then_trap_backtrack {
    304   backtrack_common common;
    305   /* If then_trap is not NULL, this structure contains the real
    306   then_trap for the backtracking path. */
    307   struct then_trap_backtrack *then_trap;
    308   /* Points to the starting opcode. */
    309   sljit_sw start;
    310   /* Exit point for the then opcodes of this alternative. */
    311   jump_list *quit;
    312   /* Frame size of the current alternative. */
    313   int framesize;
    314 } then_trap_backtrack;
    315 
    316 #define MAX_RANGE_SIZE 4
    317 
    318 typedef struct compiler_common {
    319   /* The sljit ceneric compiler. */
    320   struct sljit_compiler *compiler;
    321   /* First byte code. */
    322   pcre_uchar *start;
    323   /* Maps private data offset to each opcode. */
    324   sljit_si *private_data_ptrs;
    325   /* Chain list of read-only data ptrs. */
    326   void *read_only_data_head;
    327   /* Tells whether the capturing bracket is optimized. */
    328   pcre_uint8 *optimized_cbracket;
    329   /* Tells whether the starting offset is a target of then. */
    330   pcre_uint8 *then_offsets;
    331   /* Current position where a THEN must jump. */
    332   then_trap_backtrack *then_trap;
    333   /* Starting offset of private data for capturing brackets. */
    334   int cbra_ptr;
    335   /* Output vector starting point. Must be divisible by 2. */
    336   int ovector_start;
    337   /* Last known position of the requested byte. */
    338   int req_char_ptr;
    339   /* Head of the last recursion. */
    340   int recursive_head_ptr;
    341   /* First inspected character for partial matching. */
    342   int start_used_ptr;
    343   /* Starting pointer for partial soft matches. */
    344   int hit_start;
    345   /* End pointer of the first line. */
    346   int first_line_end;
    347   /* Points to the marked string. */
    348   int mark_ptr;
    349   /* Recursive control verb management chain. */
    350   int control_head_ptr;
    351   /* Points to the last matched capture block index. */
    352   int capture_last_ptr;
    353   /* Points to the starting position of the current match. */
    354   int start_ptr;
    355 
    356   /* Flipped and lower case tables. */
    357   const pcre_uint8 *fcc;
    358   sljit_sw lcc;
    359   /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
    360   int mode;
    361   /* TRUE, when minlength is greater than 0. */
    362   BOOL might_be_empty;
    363   /* \K is found in the pattern. */
    364   BOOL has_set_som;
    365   /* (*SKIP:arg) is found in the pattern. */
    366   BOOL has_skip_arg;
    367   /* (*THEN) is found in the pattern. */
    368   BOOL has_then;
    369   /* Needs to know the start position anytime. */
    370   BOOL needs_start_ptr;
    371   /* Currently in recurse or negative assert. */
    372   BOOL local_exit;
    373   /* Currently in a positive assert. */
    374   BOOL positive_assert;
    375   /* Newline control. */
    376   int nltype;
    377   pcre_uint32 nlmax;
    378   pcre_uint32 nlmin;
    379   int newline;
    380   int bsr_nltype;
    381   pcre_uint32 bsr_nlmax;
    382   pcre_uint32 bsr_nlmin;
    383   /* Dollar endonly. */
    384   int endonly;
    385   /* Tables. */
    386   sljit_sw ctypes;
    387   /* Named capturing brackets. */
    388   pcre_uchar *name_table;
    389   sljit_sw name_count;
    390   sljit_sw name_entry_size;
    391 
    392   /* Labels and jump lists. */
    393   struct sljit_label *partialmatchlabel;
    394   struct sljit_label *quit_label;
    395   struct sljit_label *forced_quit_label;
    396   struct sljit_label *accept_label;
    397   struct sljit_label *ff_newline_shortcut;
    398   stub_list *stubs;
    399   label_addr_list *label_addrs;
    400   recurse_entry *entries;
    401   recurse_entry *currententry;
    402   jump_list *partialmatch;
    403   jump_list *quit;
    404   jump_list *positive_assert_quit;
    405   jump_list *forced_quit;
    406   jump_list *accept;
    407   jump_list *calllimit;
    408   jump_list *stackalloc;
    409   jump_list *revertframes;
    410   jump_list *wordboundary;
    411   jump_list *anynewline;
    412   jump_list *hspace;
    413   jump_list *vspace;
    414   jump_list *casefulcmp;
    415   jump_list *caselesscmp;
    416   jump_list *reset_match;
    417   BOOL jscript_compat;
    418 #ifdef SUPPORT_UTF
    419   BOOL utf;
    420 #ifdef SUPPORT_UCP
    421   BOOL use_ucp;
    422 #endif
    423 #ifdef COMPILE_PCRE8
    424   jump_list *utfreadchar;
    425   jump_list *utfreadchar16;
    426   jump_list *utfreadtype8;
    427 #endif
    428 #endif /* SUPPORT_UTF */
    429 #ifdef SUPPORT_UCP
    430   jump_list *getucd;
    431 #endif
    432 } compiler_common;
    433 
    434 /* For byte_sequence_compare. */
    435 
    436 typedef struct compare_context {
    437   int length;
    438   int sourcereg;
    439 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
    440   int ucharptr;
    441   union {
    442     sljit_si asint;
    443     sljit_uh asushort;
    444 #if defined COMPILE_PCRE8
    445     sljit_ub asbyte;
    446     sljit_ub asuchars[4];
    447 #elif defined COMPILE_PCRE16
    448     sljit_uh asuchars[2];
    449 #elif defined COMPILE_PCRE32
    450     sljit_ui asuchars[1];
    451 #endif
    452   } c;
    453   union {
    454     sljit_si asint;
    455     sljit_uh asushort;
    456 #if defined COMPILE_PCRE8
    457     sljit_ub asbyte;
    458     sljit_ub asuchars[4];
    459 #elif defined COMPILE_PCRE16
    460     sljit_uh asuchars[2];
    461 #elif defined COMPILE_PCRE32
    462     sljit_ui asuchars[1];
    463 #endif
    464   } oc;
    465 #endif
    466 } compare_context;
    467 
    468 /* Undefine sljit macros. */
    469 #undef CMP
    470 
    471 /* Used for accessing the elements of the stack. */
    472 #define STACK(i)      ((-(i) - 1) * (int)sizeof(sljit_sw))
    473 
    474 #define TMP1          SLJIT_R0
    475 #define TMP2          SLJIT_R2
    476 #define TMP3          SLJIT_R3
    477 #define STR_PTR       SLJIT_S0
    478 #define STR_END       SLJIT_S1
    479 #define STACK_TOP     SLJIT_R1
    480 #define STACK_LIMIT   SLJIT_S2
    481 #define COUNT_MATCH   SLJIT_S3
    482 #define ARGUMENTS     SLJIT_S4
    483 #define RETURN_ADDR   SLJIT_R4
    484 
    485 /* Local space layout. */
    486 /* These two locals can be used by the current opcode. */
    487 #define LOCALS0          (0 * sizeof(sljit_sw))
    488 #define LOCALS1          (1 * sizeof(sljit_sw))
    489 /* Two local variables for possessive quantifiers (char1 cannot use them). */
    490 #define POSSESSIVE0      (2 * sizeof(sljit_sw))
    491 #define POSSESSIVE1      (3 * sizeof(sljit_sw))
    492 /* Max limit of recursions. */
    493 #define LIMIT_MATCH      (4 * sizeof(sljit_sw))
    494 /* The output vector is stored on the stack, and contains pointers
    495 to characters. The vector data is divided into two groups: the first
    496 group contains the start / end character pointers, and the second is
    497 the start pointers when the end of the capturing group has not yet reached. */
    498 #define OVECTOR_START    (common->ovector_start)
    499 #define OVECTOR(i)       (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw))
    500 #define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))
    501 #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
    502 
    503 #if defined COMPILE_PCRE8
    504 #define MOV_UCHAR  SLJIT_MOV_UB
    505 #define MOVU_UCHAR SLJIT_MOVU_UB
    506 #elif defined COMPILE_PCRE16
    507 #define MOV_UCHAR  SLJIT_MOV_UH
    508 #define MOVU_UCHAR SLJIT_MOVU_UH
    509 #elif defined COMPILE_PCRE32
    510 #define MOV_UCHAR  SLJIT_MOV_UI
    511 #define MOVU_UCHAR SLJIT_MOVU_UI
    512 #else
    513 #error Unsupported compiling mode
    514 #endif
    515 
    516 /* Shortcuts. */
    517 #define DEFINE_COMPILER \
    518   struct sljit_compiler *compiler = common->compiler
    519 #define OP1(op, dst, dstw, src, srcw) \
    520   sljit_emit_op1(compiler, (op), (dst), (dstw), (src), (srcw))
    521 #define OP2(op, dst, dstw, src1, src1w, src2, src2w) \
    522   sljit_emit_op2(compiler, (op), (dst), (dstw), (src1), (src1w), (src2), (src2w))
    523 #define LABEL() \
    524   sljit_emit_label(compiler)
    525 #define JUMP(type) \
    526   sljit_emit_jump(compiler, (type))
    527 #define JUMPTO(type, label) \
    528   sljit_set_label(sljit_emit_jump(compiler, (type)), (label))
    529 #define JUMPHERE(jump) \
    530   sljit_set_label((jump), sljit_emit_label(compiler))
    531 #define SET_LABEL(jump, label) \
    532   sljit_set_label((jump), (label))
    533 #define CMP(type, src1, src1w, src2, src2w) \
    534   sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))
    535 #define CMPTO(type, src1, src1w, src2, src2w, label) \
    536   sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))
    537 #define OP_FLAGS(op, dst, dstw, src, srcw, type) \
    538   sljit_emit_op_flags(compiler, (op), (dst), (dstw), (src), (srcw), (type))
    539 #define GET_LOCAL_BASE(dst, dstw, offset) \
    540   sljit_get_local_base(compiler, (dst), (dstw), (offset))
    541 
    542 #define READ_CHAR_MAX 0x7fffffff
    543 
    544 static pcre_uchar *bracketend(pcre_uchar *cc)
    545 {
    546 SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
    547 do cc += GET(cc, 1); while (*cc == OP_ALT);
    548 SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
    549 cc += 1 + LINK_SIZE;
    550 return cc;
    551 }
    552 
    553 static int no_alternatives(pcre_uchar *cc)
    554 {
    555 int count = 0;
    556 SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
    557 do
    558   {
    559   cc += GET(cc, 1);
    560   count++;
    561   }
    562 while (*cc == OP_ALT);
    563 SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
    564 return count;
    565 }
    566 
    567 static int ones_in_half_byte[16] = {
    568   /* 0 */ 0, 1, 1, 2, /* 4 */ 1, 2, 2, 3,
    569   /* 8 */ 1, 2, 2, 3, /* 12 */ 2, 3, 3, 4
    570 };
    571 
    572 /* Functions whose might need modification for all new supported opcodes:
    573  next_opcode
    574  check_opcode_types
    575  set_private_data_ptrs
    576  get_framesize
    577  init_frame
    578  get_private_data_copy_length
    579  copy_private_data
    580  compile_matchingpath
    581  compile_backtrackingpath
    582 */
    583 
    584 static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
    585 {
    586 SLJIT_UNUSED_ARG(common);
    587 switch(*cc)
    588   {
    589   case OP_SOD:
    590   case OP_SOM:
    591   case OP_SET_SOM:
    592   case OP_NOT_WORD_BOUNDARY:
    593   case OP_WORD_BOUNDARY:
    594   case OP_NOT_DIGIT:
    595   case OP_DIGIT:
    596   case OP_NOT_WHITESPACE:
    597   case OP_WHITESPACE:
    598   case OP_NOT_WORDCHAR:
    599   case OP_WORDCHAR:
    600   case OP_ANY:
    601   case OP_ALLANY:
    602   case OP_NOTPROP:
    603   case OP_PROP:
    604   case OP_ANYNL:
    605   case OP_NOT_HSPACE:
    606   case OP_HSPACE:
    607   case OP_NOT_VSPACE:
    608   case OP_VSPACE:
    609   case OP_EXTUNI:
    610   case OP_EODN:
    611   case OP_EOD:
    612   case OP_CIRC:
    613   case OP_CIRCM:
    614   case OP_DOLL:
    615   case OP_DOLLM:
    616   case OP_CRSTAR:
    617   case OP_CRMINSTAR:
    618   case OP_CRPLUS:
    619   case OP_CRMINPLUS:
    620   case OP_CRQUERY:
    621   case OP_CRMINQUERY:
    622   case OP_CRRANGE:
    623   case OP_CRMINRANGE:
    624   case OP_CRPOSSTAR:
    625   case OP_CRPOSPLUS:
    626   case OP_CRPOSQUERY:
    627   case OP_CRPOSRANGE:
    628   case OP_CLASS:
    629   case OP_NCLASS:
    630   case OP_REF:
    631   case OP_REFI:
    632   case OP_DNREF:
    633   case OP_DNREFI:
    634   case OP_RECURSE:
    635   case OP_CALLOUT:
    636   case OP_ALT:
    637   case OP_KET:
    638   case OP_KETRMAX:
    639   case OP_KETRMIN:
    640   case OP_KETRPOS:
    641   case OP_REVERSE:
    642   case OP_ASSERT:
    643   case OP_ASSERT_NOT:
    644   case OP_ASSERTBACK:
    645   case OP_ASSERTBACK_NOT:
    646   case OP_ONCE:
    647   case OP_ONCE_NC:
    648   case OP_BRA:
    649   case OP_BRAPOS:
    650   case OP_CBRA:
    651   case OP_CBRAPOS:
    652   case OP_COND:
    653   case OP_SBRA:
    654   case OP_SBRAPOS:
    655   case OP_SCBRA:
    656   case OP_SCBRAPOS:
    657   case OP_SCOND:
    658   case OP_CREF:
    659   case OP_DNCREF:
    660   case OP_RREF:
    661   case OP_DNRREF:
    662   case OP_DEF:
    663   case OP_BRAZERO:
    664   case OP_BRAMINZERO:
    665   case OP_BRAPOSZERO:
    666   case OP_PRUNE:
    667   case OP_SKIP:
    668   case OP_THEN:
    669   case OP_COMMIT:
    670   case OP_FAIL:
    671   case OP_ACCEPT:
    672   case OP_ASSERT_ACCEPT:
    673   case OP_CLOSE:
    674   case OP_SKIPZERO:
    675   return cc + PRIV(OP_lengths)[*cc];
    676 
    677   case OP_CHAR:
    678   case OP_CHARI:
    679   case OP_NOT:
    680   case OP_NOTI:
    681   case OP_STAR:
    682   case OP_MINSTAR:
    683   case OP_PLUS:
    684   case OP_MINPLUS:
    685   case OP_QUERY:
    686   case OP_MINQUERY:
    687   case OP_UPTO:
    688   case OP_MINUPTO:
    689   case OP_EXACT:
    690   case OP_POSSTAR:
    691   case OP_POSPLUS:
    692   case OP_POSQUERY:
    693   case OP_POSUPTO:
    694   case OP_STARI:
    695   case OP_MINSTARI:
    696   case OP_PLUSI:
    697   case OP_MINPLUSI:
    698   case OP_QUERYI:
    699   case OP_MINQUERYI:
    700   case OP_UPTOI:
    701   case OP_MINUPTOI:
    702   case OP_EXACTI:
    703   case OP_POSSTARI:
    704   case OP_POSPLUSI:
    705   case OP_POSQUERYI:
    706   case OP_POSUPTOI:
    707   case OP_NOTSTAR:
    708   case OP_NOTMINSTAR:
    709   case OP_NOTPLUS:
    710   case OP_NOTMINPLUS:
    711   case OP_NOTQUERY:
    712   case OP_NOTMINQUERY:
    713   case OP_NOTUPTO:
    714   case OP_NOTMINUPTO:
    715   case OP_NOTEXACT:
    716   case OP_NOTPOSSTAR:
    717   case OP_NOTPOSPLUS:
    718   case OP_NOTPOSQUERY:
    719   case OP_NOTPOSUPTO:
    720   case OP_NOTSTARI:
    721   case OP_NOTMINSTARI:
    722   case OP_NOTPLUSI:
    723   case OP_NOTMINPLUSI:
    724   case OP_NOTQUERYI:
    725   case OP_NOTMINQUERYI:
    726   case OP_NOTUPTOI:
    727   case OP_NOTMINUPTOI:
    728   case OP_NOTEXACTI:
    729   case OP_NOTPOSSTARI:
    730   case OP_NOTPOSPLUSI:
    731   case OP_NOTPOSQUERYI:
    732   case OP_NOTPOSUPTOI:
    733   cc += PRIV(OP_lengths)[*cc];
    734 #ifdef SUPPORT_UTF
    735   if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
    736 #endif
    737   return cc;
    738 
    739   /* Special cases. */
    740   case OP_TYPESTAR:
    741   case OP_TYPEMINSTAR:
    742   case OP_TYPEPLUS:
    743   case OP_TYPEMINPLUS:
    744   case OP_TYPEQUERY:
    745   case OP_TYPEMINQUERY:
    746   case OP_TYPEUPTO:
    747   case OP_TYPEMINUPTO:
    748   case OP_TYPEEXACT:
    749   case OP_TYPEPOSSTAR:
    750   case OP_TYPEPOSPLUS:
    751   case OP_TYPEPOSQUERY:
    752   case OP_TYPEPOSUPTO:
    753   return cc + PRIV(OP_lengths)[*cc] - 1;
    754 
    755   case OP_ANYBYTE:
    756 #ifdef SUPPORT_UTF
    757   if (common->utf) return NULL;
    758 #endif
    759   return cc + 1;
    760 
    761 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
    762   case OP_XCLASS:
    763   return cc + GET(cc, 1);
    764 #endif
    765 
    766   case OP_MARK:
    767   case OP_PRUNE_ARG:
    768   case OP_SKIP_ARG:
    769   case OP_THEN_ARG:
    770   return cc + 1 + 2 + cc[1];
    771 
    772   default:
    773   /* All opcodes are supported now! */
    774   SLJIT_ASSERT_STOP();
    775   return NULL;
    776   }
    777 }
    778 
    779 static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
    780 {
    781 int count;
    782 pcre_uchar *slot;
    783 
    784 /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
    785 while (cc < ccend)
    786   {
    787   switch(*cc)
    788     {
    789     case OP_SET_SOM:
    790     common->has_set_som = TRUE;
    791     common->might_be_empty = TRUE;
    792     cc += 1;
    793     break;
    794 
    795     case OP_REF:
    796     case OP_REFI:
    797     common->optimized_cbracket[GET2(cc, 1)] = 0;
    798     cc += 1 + IMM2_SIZE;
    799     break;
    800 
    801     case OP_CBRAPOS:
    802     case OP_SCBRAPOS:
    803     common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
    804     cc += 1 + LINK_SIZE + IMM2_SIZE;
    805     break;
    806 
    807     case OP_COND:
    808     case OP_SCOND:
    809     /* Only AUTO_CALLOUT can insert this opcode. We do
    810        not intend to support this case. */
    811     if (cc[1 + LINK_SIZE] == OP_CALLOUT)
    812       return FALSE;
    813     cc += 1 + LINK_SIZE;
    814     break;
    815 
    816     case OP_CREF:
    817     common->optimized_cbracket[GET2(cc, 1)] = 0;
    818     cc += 1 + IMM2_SIZE;
    819     break;
    820 
    821     case OP_DNREF:
    822     case OP_DNREFI:
    823     case OP_DNCREF:
    824     count = GET2(cc, 1 + IMM2_SIZE);
    825     slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
    826     while (count-- > 0)
    827       {
    828       common->optimized_cbracket[GET2(slot, 0)] = 0;
    829       slot += common->name_entry_size;
    830       }
    831     cc += 1 + 2 * IMM2_SIZE;
    832     break;
    833 
    834     case OP_RECURSE:
    835     /* Set its value only once. */
    836     if (common->recursive_head_ptr == 0)
    837       {
    838       common->recursive_head_ptr = common->ovector_start;
    839       common->ovector_start += sizeof(sljit_sw);
    840       }
    841     cc += 1 + LINK_SIZE;
    842     break;
    843 
    844     case OP_CALLOUT:
    845     if (common->capture_last_ptr == 0)
    846       {
    847       common->capture_last_ptr = common->ovector_start;
    848       common->ovector_start += sizeof(sljit_sw);
    849       }
    850     cc += 2 + 2 * LINK_SIZE;
    851     break;
    852 
    853     case OP_THEN_ARG:
    854     common->has_then = TRUE;
    855     common->control_head_ptr = 1;
    856     /* Fall through. */
    857 
    858     case OP_PRUNE_ARG:
    859     common->needs_start_ptr = TRUE;
    860     /* Fall through. */
    861 
    862     case OP_MARK:
    863     if (common->mark_ptr == 0)
    864       {
    865       common->mark_ptr = common->ovector_start;
    866       common->ovector_start += sizeof(sljit_sw);
    867       }
    868     cc += 1 + 2 + cc[1];
    869     break;
    870 
    871     case OP_THEN:
    872     common->has_then = TRUE;
    873     common->control_head_ptr = 1;
    874     /* Fall through. */
    875 
    876     case OP_PRUNE:
    877     case OP_SKIP:
    878     common->needs_start_ptr = TRUE;
    879     cc += 1;
    880     break;
    881 
    882     case OP_SKIP_ARG:
    883     common->control_head_ptr = 1;
    884     common->has_skip_arg = TRUE;
    885     cc += 1 + 2 + cc[1];
    886     break;
    887 
    888     default:
    889     cc = next_opcode(common, cc);
    890     if (cc == NULL)
    891       return FALSE;
    892     break;
    893     }
    894   }
    895 return TRUE;
    896 }
    897 
    898 static int get_class_iterator_size(pcre_uchar *cc)
    899 {
    900 switch(*cc)
    901   {
    902   case OP_CRSTAR:
    903   case OP_CRPLUS:
    904   return 2;
    905 
    906   case OP_CRMINSTAR:
    907   case OP_CRMINPLUS:
    908   case OP_CRQUERY:
    909   case OP_CRMINQUERY:
    910   return 1;
    911 
    912   case OP_CRRANGE:
    913   case OP_CRMINRANGE:
    914   if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
    915     return 0;
    916   return 2;
    917 
    918   default:
    919   return 0;
    920   }
    921 }
    922 
    923 static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
    924 {
    925 pcre_uchar *end = bracketend(begin);
    926 pcre_uchar *next;
    927 pcre_uchar *next_end;
    928 pcre_uchar *max_end;
    929 pcre_uchar type;
    930 sljit_sw length = end - begin;
    931 int min, max, i;
    932 
    933 /* Detect fixed iterations first. */
    934 if (end[-(1 + LINK_SIZE)] != OP_KET)
    935   return FALSE;
    936 
    937 /* Already detected repeat. */
    938 if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)
    939   return TRUE;
    940 
    941 next = end;
    942 min = 1;
    943 while (1)
    944   {
    945   if (*next != *begin)
    946     break;
    947   next_end = bracketend(next);
    948   if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)
    949     break;
    950   next = next_end;
    951   min++;
    952   }
    953 
    954 if (min == 2)
    955   return FALSE;
    956 
    957 max = 0;
    958 max_end = next;
    959 if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)
    960   {
    961   type = *next;
    962   while (1)
    963     {
    964     if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
    965       break;
    966     next_end = bracketend(next + 2 + LINK_SIZE);
    967     if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)
    968       break;
    969     next = next_end;
    970     max++;
    971     }
    972 
    973   if (next[0] == type && next[1] == *begin && max >= 1)
    974     {
    975     next_end = bracketend(next + 1);
    976     if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)
    977       {
    978       for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
    979         if (*next_end != OP_KET)
    980           break;
    981 
    982       if (i == max)
    983         {
    984         common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
    985         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
    986         /* +2 the original and the last. */
    987         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;
    988         if (min == 1)
    989           return TRUE;
    990         min--;
    991         max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);
    992         }
    993       }
    994     }
    995   }
    996 
    997 if (min >= 3)
    998   {
    999   common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;
   1000   common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;
   1001   common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;
   1002   return TRUE;
   1003   }
   1004 
   1005 return FALSE;
   1006 }
   1007 
   1008 #define CASE_ITERATOR_PRIVATE_DATA_1 \
   1009     case OP_MINSTAR: \
   1010     case OP_MINPLUS: \
   1011     case OP_QUERY: \
   1012     case OP_MINQUERY: \
   1013     case OP_MINSTARI: \
   1014     case OP_MINPLUSI: \
   1015     case OP_QUERYI: \
   1016     case OP_MINQUERYI: \
   1017     case OP_NOTMINSTAR: \
   1018     case OP_NOTMINPLUS: \
   1019     case OP_NOTQUERY: \
   1020     case OP_NOTMINQUERY: \
   1021     case OP_NOTMINSTARI: \
   1022     case OP_NOTMINPLUSI: \
   1023     case OP_NOTQUERYI: \
   1024     case OP_NOTMINQUERYI:
   1025 
   1026 #define CASE_ITERATOR_PRIVATE_DATA_2A \
   1027     case OP_STAR: \
   1028     case OP_PLUS: \
   1029     case OP_STARI: \
   1030     case OP_PLUSI: \
   1031     case OP_NOTSTAR: \
   1032     case OP_NOTPLUS: \
   1033     case OP_NOTSTARI: \
   1034     case OP_NOTPLUSI:
   1035 
   1036 #define CASE_ITERATOR_PRIVATE_DATA_2B \
   1037     case OP_UPTO: \
   1038     case OP_MINUPTO: \
   1039     case OP_UPTOI: \
   1040     case OP_MINUPTOI: \
   1041     case OP_NOTUPTO: \
   1042     case OP_NOTMINUPTO: \
   1043     case OP_NOTUPTOI: \
   1044     case OP_NOTMINUPTOI:
   1045 
   1046 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
   1047     case OP_TYPEMINSTAR: \
   1048     case OP_TYPEMINPLUS: \
   1049     case OP_TYPEQUERY: \
   1050     case OP_TYPEMINQUERY:
   1051 
   1052 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
   1053     case OP_TYPESTAR: \
   1054     case OP_TYPEPLUS:
   1055 
   1056 #define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
   1057     case OP_TYPEUPTO: \
   1058     case OP_TYPEMINUPTO:
   1059 
   1060 static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)
   1061 {
   1062 pcre_uchar *cc = common->start;
   1063 pcre_uchar *alternative;
   1064 pcre_uchar *end = NULL;
   1065 int private_data_ptr = *private_data_start;
   1066 int space, size, bracketlen;
   1067 BOOL repeat_check = TRUE;
   1068 
   1069 while (cc < ccend)
   1070   {
   1071   space = 0;
   1072   size = 0;
   1073   bracketlen = 0;
   1074   if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
   1075     break;
   1076 
   1077   if (repeat_check && (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND))
   1078     {
   1079     if (detect_repeat(common, cc))
   1080       {
   1081       /* These brackets are converted to repeats, so no global
   1082       based single character repeat is allowed. */
   1083       if (cc >= end)
   1084         end = bracketend(cc);
   1085       }
   1086     }
   1087   repeat_check = TRUE;
   1088 
   1089   switch(*cc)
   1090     {
   1091     case OP_KET:
   1092     if (common->private_data_ptrs[cc + 1 - common->start] != 0)
   1093       {
   1094       common->private_data_ptrs[cc - common->start] = private_data_ptr;
   1095       private_data_ptr += sizeof(sljit_sw);
   1096       cc += common->private_data_ptrs[cc + 1 - common->start];
   1097       }
   1098     cc += 1 + LINK_SIZE;
   1099     break;
   1100 
   1101     case OP_ASSERT:
   1102     case OP_ASSERT_NOT:
   1103     case OP_ASSERTBACK:
   1104     case OP_ASSERTBACK_NOT:
   1105     case OP_ONCE:
   1106     case OP_ONCE_NC:
   1107     case OP_BRAPOS:
   1108     case OP_SBRA:
   1109     case OP_SBRAPOS:
   1110     case OP_SCOND:
   1111     common->private_data_ptrs[cc - common->start] = private_data_ptr;
   1112     private_data_ptr += sizeof(sljit_sw);
   1113     bracketlen = 1 + LINK_SIZE;
   1114     break;
   1115 
   1116     case OP_CBRAPOS:
   1117     case OP_SCBRAPOS:
   1118     common->private_data_ptrs[cc - common->start] = private_data_ptr;
   1119     private_data_ptr += sizeof(sljit_sw);
   1120     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
   1121     break;
   1122 
   1123     case OP_COND:
   1124     /* Might be a hidden SCOND. */
   1125     alternative = cc + GET(cc, 1);
   1126     if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
   1127       {
   1128       common->private_data_ptrs[cc - common->start] = private_data_ptr;
   1129       private_data_ptr += sizeof(sljit_sw);
   1130       }
   1131     bracketlen = 1 + LINK_SIZE;
   1132     break;
   1133 
   1134     case OP_BRA:
   1135     bracketlen = 1 + LINK_SIZE;
   1136     break;
   1137 
   1138     case OP_CBRA:
   1139     case OP_SCBRA:
   1140     bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
   1141     break;
   1142 
   1143     case OP_BRAZERO:
   1144     case OP_BRAMINZERO:
   1145     case OP_BRAPOSZERO:
   1146     repeat_check = FALSE;
   1147     size = 1;
   1148     break;
   1149 
   1150     CASE_ITERATOR_PRIVATE_DATA_1
   1151     space = 1;
   1152     size = -2;
   1153     break;
   1154 
   1155     CASE_ITERATOR_PRIVATE_DATA_2A
   1156     space = 2;
   1157     size = -2;
   1158     break;
   1159 
   1160     CASE_ITERATOR_PRIVATE_DATA_2B
   1161     space = 2;
   1162     size = -(2 + IMM2_SIZE);
   1163     break;
   1164 
   1165     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
   1166     space = 1;
   1167     size = 1;
   1168     break;
   1169 
   1170     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
   1171     if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
   1172       space = 2;
   1173     size = 1;
   1174     break;
   1175 
   1176     case OP_TYPEUPTO:
   1177     if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
   1178       space = 2;
   1179     size = 1 + IMM2_SIZE;
   1180     break;
   1181 
   1182     case OP_TYPEMINUPTO:
   1183     space = 2;
   1184     size = 1 + IMM2_SIZE;
   1185     break;
   1186 
   1187     case OP_CLASS:
   1188     case OP_NCLASS:
   1189     size += 1 + 32 / sizeof(pcre_uchar);
   1190     space = get_class_iterator_size(cc + size);
   1191     break;
   1192 
   1193 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   1194     case OP_XCLASS:
   1195     size = GET(cc, 1);
   1196     space = get_class_iterator_size(cc + size);
   1197     break;
   1198 #endif
   1199 
   1200     default:
   1201     cc = next_opcode(common, cc);
   1202     SLJIT_ASSERT(cc != NULL);
   1203     break;
   1204     }
   1205 
   1206   /* Character iterators, which are not inside a repeated bracket,
   1207      gets a private slot instead of allocating it on the stack. */
   1208   if (space > 0 && cc >= end)
   1209     {
   1210     common->private_data_ptrs[cc - common->start] = private_data_ptr;
   1211     private_data_ptr += sizeof(sljit_sw) * space;
   1212     }
   1213 
   1214   if (size != 0)
   1215     {
   1216     if (size < 0)
   1217       {
   1218       cc += -size;
   1219 #ifdef SUPPORT_UTF
   1220       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
   1221 #endif
   1222       }
   1223     else
   1224       cc += size;
   1225     }
   1226 
   1227   if (bracketlen > 0)
   1228     {
   1229     if (cc >= end)
   1230       {
   1231       end = bracketend(cc);
   1232       if (end[-1 - LINK_SIZE] == OP_KET)
   1233         end = NULL;
   1234       }
   1235     cc += bracketlen;
   1236     }
   1237   }
   1238 *private_data_start = private_data_ptr;
   1239 }
   1240 
   1241 /* Returns with a frame_types (always < 0) if no need for frame. */
   1242 static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL *needs_control_head)
   1243 {
   1244 int length = 0;
   1245 int possessive = 0;
   1246 BOOL stack_restore = FALSE;
   1247 BOOL setsom_found = recursive;
   1248 BOOL setmark_found = recursive;
   1249 /* The last capture is a local variable even for recursions. */
   1250 BOOL capture_last_found = FALSE;
   1251 
   1252 #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
   1253 SLJIT_ASSERT(common->control_head_ptr != 0);
   1254 *needs_control_head = TRUE;
   1255 #else
   1256 *needs_control_head = FALSE;
   1257 #endif
   1258 
   1259 if (ccend == NULL)
   1260   {
   1261   ccend = bracketend(cc) - (1 + LINK_SIZE);
   1262   if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
   1263     {
   1264     possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
   1265     /* This is correct regardless of common->capture_last_ptr. */
   1266     capture_last_found = TRUE;
   1267     }
   1268   cc = next_opcode(common, cc);
   1269   }
   1270 
   1271 SLJIT_ASSERT(cc != NULL);
   1272 while (cc < ccend)
   1273   switch(*cc)
   1274     {
   1275     case OP_SET_SOM:
   1276     SLJIT_ASSERT(common->has_set_som);
   1277     stack_restore = TRUE;
   1278     if (!setsom_found)
   1279       {
   1280       length += 2;
   1281       setsom_found = TRUE;
   1282       }
   1283     cc += 1;
   1284     break;
   1285 
   1286     case OP_MARK:
   1287     case OP_PRUNE_ARG:
   1288     case OP_THEN_ARG:
   1289     SLJIT_ASSERT(common->mark_ptr != 0);
   1290     stack_restore = TRUE;
   1291     if (!setmark_found)
   1292       {
   1293       length += 2;
   1294       setmark_found = TRUE;
   1295       }
   1296     if (common->control_head_ptr != 0)
   1297       *needs_control_head = TRUE;
   1298     cc += 1 + 2 + cc[1];
   1299     break;
   1300 
   1301     case OP_RECURSE:
   1302     stack_restore = TRUE;
   1303     if (common->has_set_som && !setsom_found)
   1304       {
   1305       length += 2;
   1306       setsom_found = TRUE;
   1307       }
   1308     if (common->mark_ptr != 0 && !setmark_found)
   1309       {
   1310       length += 2;
   1311       setmark_found = TRUE;
   1312       }
   1313     if (common->capture_last_ptr != 0 && !capture_last_found)
   1314       {
   1315       length += 2;
   1316       capture_last_found = TRUE;
   1317       }
   1318     cc += 1 + LINK_SIZE;
   1319     break;
   1320 
   1321     case OP_CBRA:
   1322     case OP_CBRAPOS:
   1323     case OP_SCBRA:
   1324     case OP_SCBRAPOS:
   1325     stack_restore = TRUE;
   1326     if (common->capture_last_ptr != 0 && !capture_last_found)
   1327       {
   1328       length += 2;
   1329       capture_last_found = TRUE;
   1330       }
   1331     length += 3;
   1332     cc += 1 + LINK_SIZE + IMM2_SIZE;
   1333     break;
   1334 
   1335     case OP_THEN:
   1336     stack_restore = TRUE;
   1337     if (common->control_head_ptr != 0)
   1338       *needs_control_head = TRUE;
   1339     cc ++;
   1340     break;
   1341 
   1342     default:
   1343     stack_restore = TRUE;
   1344     /* Fall through. */
   1345 
   1346     case OP_NOT_WORD_BOUNDARY:
   1347     case OP_WORD_BOUNDARY:
   1348     case OP_NOT_DIGIT:
   1349     case OP_DIGIT:
   1350     case OP_NOT_WHITESPACE:
   1351     case OP_WHITESPACE:
   1352     case OP_NOT_WORDCHAR:
   1353     case OP_WORDCHAR:
   1354     case OP_ANY:
   1355     case OP_ALLANY:
   1356     case OP_ANYBYTE:
   1357     case OP_NOTPROP:
   1358     case OP_PROP:
   1359     case OP_ANYNL:
   1360     case OP_NOT_HSPACE:
   1361     case OP_HSPACE:
   1362     case OP_NOT_VSPACE:
   1363     case OP_VSPACE:
   1364     case OP_EXTUNI:
   1365     case OP_EODN:
   1366     case OP_EOD:
   1367     case OP_CIRC:
   1368     case OP_CIRCM:
   1369     case OP_DOLL:
   1370     case OP_DOLLM:
   1371     case OP_CHAR:
   1372     case OP_CHARI:
   1373     case OP_NOT:
   1374     case OP_NOTI:
   1375 
   1376     case OP_EXACT:
   1377     case OP_POSSTAR:
   1378     case OP_POSPLUS:
   1379     case OP_POSQUERY:
   1380     case OP_POSUPTO:
   1381 
   1382     case OP_EXACTI:
   1383     case OP_POSSTARI:
   1384     case OP_POSPLUSI:
   1385     case OP_POSQUERYI:
   1386     case OP_POSUPTOI:
   1387 
   1388     case OP_NOTEXACT:
   1389     case OP_NOTPOSSTAR:
   1390     case OP_NOTPOSPLUS:
   1391     case OP_NOTPOSQUERY:
   1392     case OP_NOTPOSUPTO:
   1393 
   1394     case OP_NOTEXACTI:
   1395     case OP_NOTPOSSTARI:
   1396     case OP_NOTPOSPLUSI:
   1397     case OP_NOTPOSQUERYI:
   1398     case OP_NOTPOSUPTOI:
   1399 
   1400     case OP_TYPEEXACT:
   1401     case OP_TYPEPOSSTAR:
   1402     case OP_TYPEPOSPLUS:
   1403     case OP_TYPEPOSQUERY:
   1404     case OP_TYPEPOSUPTO:
   1405 
   1406     case OP_CLASS:
   1407     case OP_NCLASS:
   1408     case OP_XCLASS:
   1409 
   1410     cc = next_opcode(common, cc);
   1411     SLJIT_ASSERT(cc != NULL);
   1412     break;
   1413     }
   1414 
   1415 /* Possessive quantifiers can use a special case. */
   1416 if (SLJIT_UNLIKELY(possessive == length))
   1417   return stack_restore ? no_frame : no_stack;
   1418 
   1419 if (length > 0)
   1420   return length + 1;
   1421 return stack_restore ? no_frame : no_stack;
   1422 }
   1423 
   1424 static void init_frame(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, int stackpos, int stacktop, BOOL recursive)
   1425 {
   1426 DEFINE_COMPILER;
   1427 BOOL setsom_found = recursive;
   1428 BOOL setmark_found = recursive;
   1429 /* The last capture is a local variable even for recursions. */
   1430 BOOL capture_last_found = FALSE;
   1431 int offset;
   1432 
   1433 /* >= 1 + shortest item size (2) */
   1434 SLJIT_UNUSED_ARG(stacktop);
   1435 SLJIT_ASSERT(stackpos >= stacktop + 2);
   1436 
   1437 stackpos = STACK(stackpos);
   1438 if (ccend == NULL)
   1439   {
   1440   ccend = bracketend(cc) - (1 + LINK_SIZE);
   1441   if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
   1442     cc = next_opcode(common, cc);
   1443   }
   1444 
   1445 SLJIT_ASSERT(cc != NULL);
   1446 while (cc < ccend)
   1447   switch(*cc)
   1448     {
   1449     case OP_SET_SOM:
   1450     SLJIT_ASSERT(common->has_set_som);
   1451     if (!setsom_found)
   1452       {
   1453       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
   1454       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
   1455       stackpos += (int)sizeof(sljit_sw);
   1456       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
   1457       stackpos += (int)sizeof(sljit_sw);
   1458       setsom_found = TRUE;
   1459       }
   1460     cc += 1;
   1461     break;
   1462 
   1463     case OP_MARK:
   1464     case OP_PRUNE_ARG:
   1465     case OP_THEN_ARG:
   1466     SLJIT_ASSERT(common->mark_ptr != 0);
   1467     if (!setmark_found)
   1468       {
   1469       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
   1470       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
   1471       stackpos += (int)sizeof(sljit_sw);
   1472       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
   1473       stackpos += (int)sizeof(sljit_sw);
   1474       setmark_found = TRUE;
   1475       }
   1476     cc += 1 + 2 + cc[1];
   1477     break;
   1478 
   1479     case OP_RECURSE:
   1480     if (common->has_set_som && !setsom_found)
   1481       {
   1482       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
   1483       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
   1484       stackpos += (int)sizeof(sljit_sw);
   1485       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
   1486       stackpos += (int)sizeof(sljit_sw);
   1487       setsom_found = TRUE;
   1488       }
   1489     if (common->mark_ptr != 0 && !setmark_found)
   1490       {
   1491       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
   1492       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
   1493       stackpos += (int)sizeof(sljit_sw);
   1494       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
   1495       stackpos += (int)sizeof(sljit_sw);
   1496       setmark_found = TRUE;
   1497       }
   1498     if (common->capture_last_ptr != 0 && !capture_last_found)
   1499       {
   1500       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
   1501       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
   1502       stackpos += (int)sizeof(sljit_sw);
   1503       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
   1504       stackpos += (int)sizeof(sljit_sw);
   1505       capture_last_found = TRUE;
   1506       }
   1507     cc += 1 + LINK_SIZE;
   1508     break;
   1509 
   1510     case OP_CBRA:
   1511     case OP_CBRAPOS:
   1512     case OP_SCBRA:
   1513     case OP_SCBRAPOS:
   1514     if (common->capture_last_ptr != 0 && !capture_last_found)
   1515       {
   1516       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
   1517       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
   1518       stackpos += (int)sizeof(sljit_sw);
   1519       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
   1520       stackpos += (int)sizeof(sljit_sw);
   1521       capture_last_found = TRUE;
   1522       }
   1523     offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
   1524     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));
   1525     stackpos += (int)sizeof(sljit_sw);
   1526     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
   1527     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
   1528     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
   1529     stackpos += (int)sizeof(sljit_sw);
   1530     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);
   1531     stackpos += (int)sizeof(sljit_sw);
   1532 
   1533     cc += 1 + LINK_SIZE + IMM2_SIZE;
   1534     break;
   1535 
   1536     default:
   1537     cc = next_opcode(common, cc);
   1538     SLJIT_ASSERT(cc != NULL);
   1539     break;
   1540     }
   1541 
   1542 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0);
   1543 SLJIT_ASSERT(stackpos == STACK(stacktop));
   1544 }
   1545 
   1546 static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)
   1547 {
   1548 int private_data_length = needs_control_head ? 3 : 2;
   1549 int size;
   1550 pcre_uchar *alternative;
   1551 /* Calculate the sum of the private machine words. */
   1552 while (cc < ccend)
   1553   {
   1554   size = 0;
   1555   switch(*cc)
   1556     {
   1557     case OP_KET:
   1558     if (PRIVATE_DATA(cc) != 0)
   1559       {
   1560       private_data_length++;
   1561       SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
   1562       cc += PRIVATE_DATA(cc + 1);
   1563       }
   1564     cc += 1 + LINK_SIZE;
   1565     break;
   1566 
   1567     case OP_ASSERT:
   1568     case OP_ASSERT_NOT:
   1569     case OP_ASSERTBACK:
   1570     case OP_ASSERTBACK_NOT:
   1571     case OP_ONCE:
   1572     case OP_ONCE_NC:
   1573     case OP_BRAPOS:
   1574     case OP_SBRA:
   1575     case OP_SBRAPOS:
   1576     case OP_SCOND:
   1577     private_data_length++;
   1578     SLJIT_ASSERT(PRIVATE_DATA(cc) != 0);
   1579     cc += 1 + LINK_SIZE;
   1580     break;
   1581 
   1582     case OP_CBRA:
   1583     case OP_SCBRA:
   1584     if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
   1585       private_data_length++;
   1586     cc += 1 + LINK_SIZE + IMM2_SIZE;
   1587     break;
   1588 
   1589     case OP_CBRAPOS:
   1590     case OP_SCBRAPOS:
   1591     private_data_length += 2;
   1592     cc += 1 + LINK_SIZE + IMM2_SIZE;
   1593     break;
   1594 
   1595     case OP_COND:
   1596     /* Might be a hidden SCOND. */
   1597     alternative = cc + GET(cc, 1);
   1598     if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
   1599       private_data_length++;
   1600     cc += 1 + LINK_SIZE;
   1601     break;
   1602 
   1603     CASE_ITERATOR_PRIVATE_DATA_1
   1604     if (PRIVATE_DATA(cc))
   1605       private_data_length++;
   1606     cc += 2;
   1607 #ifdef SUPPORT_UTF
   1608     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
   1609 #endif
   1610     break;
   1611 
   1612     CASE_ITERATOR_PRIVATE_DATA_2A
   1613     if (PRIVATE_DATA(cc))
   1614       private_data_length += 2;
   1615     cc += 2;
   1616 #ifdef SUPPORT_UTF
   1617     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
   1618 #endif
   1619     break;
   1620 
   1621     CASE_ITERATOR_PRIVATE_DATA_2B
   1622     if (PRIVATE_DATA(cc))
   1623       private_data_length += 2;
   1624     cc += 2 + IMM2_SIZE;
   1625 #ifdef SUPPORT_UTF
   1626     if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
   1627 #endif
   1628     break;
   1629 
   1630     CASE_ITERATOR_TYPE_PRIVATE_DATA_1
   1631     if (PRIVATE_DATA(cc))
   1632       private_data_length++;
   1633     cc += 1;
   1634     break;
   1635 
   1636     CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
   1637     if (PRIVATE_DATA(cc))
   1638       private_data_length += 2;
   1639     cc += 1;
   1640     break;
   1641 
   1642     CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
   1643     if (PRIVATE_DATA(cc))
   1644       private_data_length += 2;
   1645     cc += 1 + IMM2_SIZE;
   1646     break;
   1647 
   1648     case OP_CLASS:
   1649     case OP_NCLASS:
   1650 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   1651     case OP_XCLASS:
   1652     size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);
   1653 #else
   1654     size = 1 + 32 / (int)sizeof(pcre_uchar);
   1655 #endif
   1656     if (PRIVATE_DATA(cc))
   1657       private_data_length += get_class_iterator_size(cc + size);
   1658     cc += size;
   1659     break;
   1660 
   1661     default:
   1662     cc = next_opcode(common, cc);
   1663     SLJIT_ASSERT(cc != NULL);
   1664     break;
   1665     }
   1666   }
   1667 SLJIT_ASSERT(cc == ccend);
   1668 return private_data_length;
   1669 }
   1670 
   1671 static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
   1672   BOOL save, int stackptr, int stacktop, BOOL needs_control_head)
   1673 {
   1674 DEFINE_COMPILER;
   1675 int srcw[2];
   1676 int count, size;
   1677 BOOL tmp1next = TRUE;
   1678 BOOL tmp1empty = TRUE;
   1679 BOOL tmp2empty = TRUE;
   1680 pcre_uchar *alternative;
   1681 enum {
   1682   start,
   1683   loop,
   1684   end
   1685 } status;
   1686 
   1687 status = save ? start : loop;
   1688 stackptr = STACK(stackptr - 2);
   1689 stacktop = STACK(stacktop - 1);
   1690 
   1691 if (!save)
   1692   {
   1693   stackptr += (needs_control_head ? 2 : 1) * sizeof(sljit_sw);
   1694   if (stackptr < stacktop)
   1695     {
   1696     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
   1697     stackptr += sizeof(sljit_sw);
   1698     tmp1empty = FALSE;
   1699     }
   1700   if (stackptr < stacktop)
   1701     {
   1702     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);
   1703     stackptr += sizeof(sljit_sw);
   1704     tmp2empty = FALSE;
   1705     }
   1706   /* The tmp1next must be TRUE in either way. */
   1707   }
   1708 
   1709 do
   1710   {
   1711   count = 0;
   1712   switch(status)
   1713     {
   1714     case start:
   1715     SLJIT_ASSERT(save && common->recursive_head_ptr != 0);
   1716     count = 1;
   1717     srcw[0] = common->recursive_head_ptr;
   1718     if (needs_control_head)
   1719       {
   1720       SLJIT_ASSERT(common->control_head_ptr != 0);
   1721       count = 2;
   1722       srcw[1] = common->control_head_ptr;
   1723       }
   1724     status = loop;
   1725     break;
   1726 
   1727     case loop:
   1728     if (cc >= ccend)
   1729       {
   1730       status = end;
   1731       break;
   1732       }
   1733 
   1734     switch(*cc)
   1735       {
   1736       case OP_KET:
   1737       if (PRIVATE_DATA(cc) != 0)
   1738         {
   1739         count = 1;
   1740         srcw[0] = PRIVATE_DATA(cc);
   1741         SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
   1742         cc += PRIVATE_DATA(cc + 1);
   1743         }
   1744       cc += 1 + LINK_SIZE;
   1745       break;
   1746 
   1747       case OP_ASSERT:
   1748       case OP_ASSERT_NOT:
   1749       case OP_ASSERTBACK:
   1750       case OP_ASSERTBACK_NOT:
   1751       case OP_ONCE:
   1752       case OP_ONCE_NC:
   1753       case OP_BRAPOS:
   1754       case OP_SBRA:
   1755       case OP_SBRAPOS:
   1756       case OP_SCOND:
   1757       count = 1;
   1758       srcw[0] = PRIVATE_DATA(cc);
   1759       SLJIT_ASSERT(srcw[0] != 0);
   1760       cc += 1 + LINK_SIZE;
   1761       break;
   1762 
   1763       case OP_CBRA:
   1764       case OP_SCBRA:
   1765       if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
   1766         {
   1767         count = 1;
   1768         srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
   1769         }
   1770       cc += 1 + LINK_SIZE + IMM2_SIZE;
   1771       break;
   1772 
   1773       case OP_CBRAPOS:
   1774       case OP_SCBRAPOS:
   1775       count = 2;
   1776       srcw[0] = PRIVATE_DATA(cc);
   1777       srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
   1778       SLJIT_ASSERT(srcw[0] != 0 && srcw[1] != 0);
   1779       cc += 1 + LINK_SIZE + IMM2_SIZE;
   1780       break;
   1781 
   1782       case OP_COND:
   1783       /* Might be a hidden SCOND. */
   1784       alternative = cc + GET(cc, 1);
   1785       if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
   1786         {
   1787         count = 1;
   1788         srcw[0] = PRIVATE_DATA(cc);
   1789         SLJIT_ASSERT(srcw[0] != 0);
   1790         }
   1791       cc += 1 + LINK_SIZE;
   1792       break;
   1793 
   1794       CASE_ITERATOR_PRIVATE_DATA_1
   1795       if (PRIVATE_DATA(cc))
   1796         {
   1797         count = 1;
   1798         srcw[0] = PRIVATE_DATA(cc);
   1799         }
   1800       cc += 2;
   1801 #ifdef SUPPORT_UTF
   1802       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
   1803 #endif
   1804       break;
   1805 
   1806       CASE_ITERATOR_PRIVATE_DATA_2A
   1807       if (PRIVATE_DATA(cc))
   1808         {
   1809         count = 2;
   1810         srcw[0] = PRIVATE_DATA(cc);
   1811         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
   1812         }
   1813       cc += 2;
   1814 #ifdef SUPPORT_UTF
   1815       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
   1816 #endif
   1817       break;
   1818 
   1819       CASE_ITERATOR_PRIVATE_DATA_2B
   1820       if (PRIVATE_DATA(cc))
   1821         {
   1822         count = 2;
   1823         srcw[0] = PRIVATE_DATA(cc);
   1824         srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
   1825         }
   1826       cc += 2 + IMM2_SIZE;
   1827 #ifdef SUPPORT_UTF
   1828       if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
   1829 #endif
   1830       break;
   1831 
   1832       CASE_ITERATOR_TYPE_PRIVATE_DATA_1
   1833       if (PRIVATE_DATA(cc))
   1834         {
   1835         count = 1;
   1836         srcw[0] = PRIVATE_DATA(cc);
   1837         }
   1838       cc += 1;
   1839       break;
   1840 
   1841       CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
   1842       if (PRIVATE_DATA(cc))
   1843         {
   1844         count = 2;
   1845         srcw[0] = PRIVATE_DATA(cc);
   1846         srcw[1] = srcw[0] + sizeof(sljit_sw);
   1847         }
   1848       cc += 1;
   1849       break;
   1850 
   1851       CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
   1852       if (PRIVATE_DATA(cc))
   1853         {
   1854         count = 2;
   1855         srcw[0] = PRIVATE_DATA(cc);
   1856         srcw[1] = srcw[0] + sizeof(sljit_sw);
   1857         }
   1858       cc += 1 + IMM2_SIZE;
   1859       break;
   1860 
   1861       case OP_CLASS:
   1862       case OP_NCLASS:
   1863 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   1864       case OP_XCLASS:
   1865       size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);
   1866 #else
   1867       size = 1 + 32 / (int)sizeof(pcre_uchar);
   1868 #endif
   1869       if (PRIVATE_DATA(cc))
   1870         switch(get_class_iterator_size(cc + size))
   1871           {
   1872           case 1:
   1873           count = 1;
   1874           srcw[0] = PRIVATE_DATA(cc);
   1875           break;
   1876 
   1877           case 2:
   1878           count = 2;
   1879           srcw[0] = PRIVATE_DATA(cc);
   1880           srcw[1] = srcw[0] + sizeof(sljit_sw);
   1881           break;
   1882 
   1883           default:
   1884           SLJIT_ASSERT_STOP();
   1885           break;
   1886           }
   1887       cc += size;
   1888       break;
   1889 
   1890       default:
   1891       cc = next_opcode(common, cc);
   1892       SLJIT_ASSERT(cc != NULL);
   1893       break;
   1894       }
   1895     break;
   1896 
   1897     case end:
   1898     SLJIT_ASSERT_STOP();
   1899     break;
   1900     }
   1901 
   1902   while (count > 0)
   1903     {
   1904     count--;
   1905     if (save)
   1906       {
   1907       if (tmp1next)
   1908         {
   1909         if (!tmp1empty)
   1910           {
   1911           OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
   1912           stackptr += sizeof(sljit_sw);
   1913           }
   1914         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);
   1915         tmp1empty = FALSE;
   1916         tmp1next = FALSE;
   1917         }
   1918       else
   1919         {
   1920         if (!tmp2empty)
   1921           {
   1922           OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
   1923           stackptr += sizeof(sljit_sw);
   1924           }
   1925         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);
   1926         tmp2empty = FALSE;
   1927         tmp1next = TRUE;
   1928         }
   1929       }
   1930     else
   1931       {
   1932       if (tmp1next)
   1933         {
   1934         SLJIT_ASSERT(!tmp1empty);
   1935         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP1, 0);
   1936         tmp1empty = stackptr >= stacktop;
   1937         if (!tmp1empty)
   1938           {
   1939           OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
   1940           stackptr += sizeof(sljit_sw);
   1941           }
   1942         tmp1next = FALSE;
   1943         }
   1944       else
   1945         {
   1946         SLJIT_ASSERT(!tmp2empty);
   1947         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP2, 0);
   1948         tmp2empty = stackptr >= stacktop;
   1949         if (!tmp2empty)
   1950           {
   1951           OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);
   1952           stackptr += sizeof(sljit_sw);
   1953           }
   1954         tmp1next = TRUE;
   1955         }
   1956       }
   1957     }
   1958   }
   1959 while (status != end);
   1960 
   1961 if (save)
   1962   {
   1963   if (tmp1next)
   1964     {
   1965     if (!tmp1empty)
   1966       {
   1967       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
   1968       stackptr += sizeof(sljit_sw);
   1969       }
   1970     if (!tmp2empty)
   1971       {
   1972       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
   1973       stackptr += sizeof(sljit_sw);
   1974       }
   1975     }
   1976   else
   1977     {
   1978     if (!tmp2empty)
   1979       {
   1980       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
   1981       stackptr += sizeof(sljit_sw);
   1982       }
   1983     if (!tmp1empty)
   1984       {
   1985       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
   1986       stackptr += sizeof(sljit_sw);
   1987       }
   1988     }
   1989   }
   1990 SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
   1991 }
   1992 
   1993 static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)
   1994 {
   1995 pcre_uchar *end = bracketend(cc);
   1996 BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
   1997 
   1998 /* Assert captures then. */
   1999 if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
   2000   current_offset = NULL;
   2001 /* Conditional block does not. */
   2002 if (*cc == OP_COND || *cc == OP_SCOND)
   2003   has_alternatives = FALSE;
   2004 
   2005 cc = next_opcode(common, cc);
   2006 if (has_alternatives)
   2007   current_offset = common->then_offsets + (cc - common->start);
   2008 
   2009 while (cc < end)
   2010   {
   2011   if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
   2012     cc = set_then_offsets(common, cc, current_offset);
   2013   else
   2014     {
   2015     if (*cc == OP_ALT && has_alternatives)
   2016       current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);
   2017     if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)
   2018       *current_offset = 1;
   2019     cc = next_opcode(common, cc);
   2020     }
   2021   }
   2022 
   2023 return end;
   2024 }
   2025 
   2026 #undef CASE_ITERATOR_PRIVATE_DATA_1
   2027 #undef CASE_ITERATOR_PRIVATE_DATA_2A
   2028 #undef CASE_ITERATOR_PRIVATE_DATA_2B
   2029 #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_1
   2030 #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
   2031 #undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
   2032 
   2033 static SLJIT_INLINE BOOL is_powerof2(unsigned int value)
   2034 {
   2035 return (value & (value - 1)) == 0;
   2036 }
   2037 
   2038 static SLJIT_INLINE void set_jumps(jump_list *list, struct sljit_label *label)
   2039 {
   2040 while (list)
   2041   {
   2042   /* sljit_set_label is clever enough to do nothing
   2043   if either the jump or the label is NULL. */
   2044   SET_LABEL(list->jump, label);
   2045   list = list->next;
   2046   }
   2047 }
   2048 
   2049 static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump *jump)
   2050 {
   2051 jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));
   2052 if (list_item)
   2053   {
   2054   list_item->next = *list;
   2055   list_item->jump = jump;
   2056   *list = list_item;
   2057   }
   2058 }
   2059 
   2060 static void add_stub(compiler_common *common, struct sljit_jump *start)
   2061 {
   2062 DEFINE_COMPILER;
   2063 stub_list *list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
   2064 
   2065 if (list_item)
   2066   {
   2067   list_item->start = start;
   2068   list_item->quit = LABEL();
   2069   list_item->next = common->stubs;
   2070   common->stubs = list_item;
   2071   }
   2072 }
   2073 
   2074 static void flush_stubs(compiler_common *common)
   2075 {
   2076 DEFINE_COMPILER;
   2077 stub_list *list_item = common->stubs;
   2078 
   2079 while (list_item)
   2080   {
   2081   JUMPHERE(list_item->start);
   2082   add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
   2083   JUMPTO(SLJIT_JUMP, list_item->quit);
   2084   list_item = list_item->next;
   2085   }
   2086 common->stubs = NULL;
   2087 }
   2088 
   2089 static void add_label_addr(compiler_common *common, sljit_uw *update_addr)
   2090 {
   2091 DEFINE_COMPILER;
   2092 label_addr_list *label_addr;
   2093 
   2094 label_addr = sljit_alloc_memory(compiler, sizeof(label_addr_list));
   2095 if (label_addr == NULL)
   2096   return;
   2097 label_addr->label = LABEL();
   2098 label_addr->update_addr = update_addr;
   2099 label_addr->next = common->label_addrs;
   2100 common->label_addrs = label_addr;
   2101 }
   2102 
   2103 static SLJIT_INLINE void count_match(compiler_common *common)
   2104 {
   2105 DEFINE_COMPILER;
   2106 
   2107 OP2(SLJIT_SUB | SLJIT_SET_E, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);
   2108 add_jump(compiler, &common->calllimit, JUMP(SLJIT_ZERO));
   2109 }
   2110 
   2111 static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)
   2112 {
   2113 /* May destroy all locals and registers except TMP2. */
   2114 DEFINE_COMPILER;
   2115 
   2116 OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
   2117 #ifdef DESTROY_REGISTERS
   2118 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);
   2119 OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
   2120 OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
   2121 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, TMP1, 0);
   2122 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);
   2123 #endif
   2124 add_stub(common, CMP(SLJIT_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));
   2125 }
   2126 
   2127 static SLJIT_INLINE void free_stack(compiler_common *common, int size)
   2128 {
   2129 DEFINE_COMPILER;
   2130 OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
   2131 }
   2132 
   2133 static sljit_uw * allocate_read_only_data(compiler_common *common, sljit_uw size)
   2134 {
   2135 DEFINE_COMPILER;
   2136 sljit_uw *result;
   2137 
   2138 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   2139   return NULL;
   2140 
   2141 result = (sljit_uw *)SLJIT_MALLOC(size + sizeof(sljit_uw), compiler->allocator_data);
   2142 if (SLJIT_UNLIKELY(result == NULL))
   2143   {
   2144   sljit_set_compiler_memory_error(compiler);
   2145   return NULL;
   2146   }
   2147 
   2148 *(void**)result = common->read_only_data_head;
   2149 common->read_only_data_head = (void *)result;
   2150 return result + 1;
   2151 }
   2152 
   2153 static void free_read_only_data(void *current, void *allocator_data)
   2154 {
   2155 void *next;
   2156 
   2157 SLJIT_UNUSED_ARG(allocator_data);
   2158 
   2159 while (current != NULL)
   2160   {
   2161   next = *(void**)current;
   2162   SLJIT_FREE(current, allocator_data);
   2163   current = next;
   2164   }
   2165 }
   2166 
   2167 static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)
   2168 {
   2169 DEFINE_COMPILER;
   2170 struct sljit_label *loop;
   2171 int i;
   2172 
   2173 /* At this point we can freely use all temporary registers. */
   2174 SLJIT_ASSERT(length > 1);
   2175 /* TMP1 returns with begin - 1. */
   2176 OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
   2177 if (length < 8)
   2178   {
   2179   for (i = 1; i < length; i++)
   2180     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), SLJIT_R0, 0);
   2181   }
   2182 else
   2183   {
   2184   GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START);
   2185   OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1);
   2186   loop = LABEL();
   2187   OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw), SLJIT_R0, 0);
   2188   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);
   2189   JUMPTO(SLJIT_NOT_ZERO, loop);
   2190   }
   2191 }
   2192 
   2193 static SLJIT_INLINE void do_reset_match(compiler_common *common, int length)
   2194 {
   2195 DEFINE_COMPILER;
   2196 struct sljit_label *loop;
   2197 int i;
   2198 
   2199 SLJIT_ASSERT(length > 1);
   2200 /* OVECTOR(1) contains the "string begin - 1" constant. */
   2201 if (length > 2)
   2202   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
   2203 if (length < 8)
   2204   {
   2205   for (i = 2; i < length; i++)
   2206     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), TMP1, 0);
   2207   }
   2208 else
   2209   {
   2210   GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw));
   2211   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);
   2212   loop = LABEL();
   2213   OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
   2214   OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);
   2215   JUMPTO(SLJIT_NOT_ZERO, loop);
   2216   }
   2217 
   2218 OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);
   2219 if (common->mark_ptr != 0)
   2220   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0);
   2221 if (common->control_head_ptr != 0)
   2222   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
   2223 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));
   2224 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_ptr);
   2225 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, base));
   2226 }
   2227 
   2228 static sljit_sw SLJIT_CALL do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)
   2229 {
   2230 while (current != NULL)
   2231   {
   2232   switch (current[-2])
   2233     {
   2234     case type_then_trap:
   2235     break;
   2236 
   2237     case type_mark:
   2238     if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[-3]) == 0)
   2239       return current[-4];
   2240     break;
   2241 
   2242     default:
   2243     SLJIT_ASSERT_STOP();
   2244     break;
   2245     }
   2246   SLJIT_ASSERT(current > (sljit_sw*)current[-1]);
   2247   current = (sljit_sw*)current[-1];
   2248   }
   2249 return -1;
   2250 }
   2251 
   2252 static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
   2253 {
   2254 DEFINE_COMPILER;
   2255 struct sljit_label *loop;
   2256 struct sljit_jump *early_quit;
   2257 
   2258 /* At this point we can freely use all registers. */
   2259 OP1(SLJIT_MOV, SLJIT_S2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
   2260 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(1), STR_PTR, 0);
   2261 
   2262 OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0);
   2263 if (common->mark_ptr != 0)
   2264   OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
   2265 OP1(SLJIT_MOV_SI, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offset_count));
   2266 if (common->mark_ptr != 0)
   2267   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_R2, 0);
   2268 OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
   2269 OP1(SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, begin));
   2270 GET_LOCAL_BASE(SLJIT_S0, 0, OVECTOR_START);
   2271 /* Unlikely, but possible */
   2272 early_quit = CMP(SLJIT_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0);
   2273 loop = LABEL();
   2274 OP2(SLJIT_SUB, SLJIT_S1, 0, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_R0, 0);
   2275 OP2(SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_sw));
   2276 /* Copy the integer value to the output buffer */
   2277 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   2278 OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);
   2279 #endif
   2280 OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_R2), sizeof(int), SLJIT_S1, 0);
   2281 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
   2282 JUMPTO(SLJIT_NOT_ZERO, loop);
   2283 JUMPHERE(early_quit);
   2284 
   2285 /* Calculate the return value, which is the maximum ovector value. */
   2286 if (topbracket > 1)
   2287   {
   2288   GET_LOCAL_BASE(SLJIT_R0, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));
   2289   OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, topbracket + 1);
   2290 
   2291   /* OVECTOR(0) is never equal to SLJIT_S2. */
   2292   loop = LABEL();
   2293   OP1(SLJIT_MOVU, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), -(2 * (sljit_sw)sizeof(sljit_sw)));
   2294   OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
   2295   CMPTO(SLJIT_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop);
   2296   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_R1, 0);
   2297   }
   2298 else
   2299   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
   2300 }
   2301 
   2302 static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)
   2303 {
   2304 DEFINE_COMPILER;
   2305 struct sljit_jump *jump;
   2306 
   2307 SLJIT_COMPILE_ASSERT(STR_END == SLJIT_S1, str_end_must_be_saved_reg2);
   2308 SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0
   2309   && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
   2310 
   2311 OP1(SLJIT_MOV, SLJIT_R1, 0, ARGUMENTS, 0);
   2312 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
   2313 OP1(SLJIT_MOV_SI, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
   2314 CMPTO(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 2, quit);
   2315 
   2316 /* Store match begin and end. */
   2317 OP1(SLJIT_MOV, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, begin));
   2318 OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, offsets));
   2319 
   2320 jump = CMP(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 3);
   2321 OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + (int)sizeof(sljit_sw)), SLJIT_S0, 0);
   2322 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   2323 OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
   2324 #endif
   2325 OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(int), SLJIT_R2, 0);
   2326 JUMPHERE(jump);
   2327 
   2328 OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
   2329 OP2(SLJIT_SUB, SLJIT_S1, 0, STR_END, 0, SLJIT_S0, 0);
   2330 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   2331 OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);
   2332 #endif
   2333 OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), sizeof(int), SLJIT_S1, 0);
   2334 
   2335 OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_S0, 0);
   2336 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   2337 OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
   2338 #endif
   2339 OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);
   2340 
   2341 JUMPTO(SLJIT_JUMP, quit);
   2342 }
   2343 
   2344 static SLJIT_INLINE void check_start_used_ptr(compiler_common *common)
   2345 {
   2346 /* May destroy TMP1. */
   2347 DEFINE_COMPILER;
   2348 struct sljit_jump *jump;
   2349 
   2350 if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
   2351   {
   2352   /* The value of -1 must be kept for start_used_ptr! */
   2353   OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, 1);
   2354   /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting
   2355   is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */
   2356   jump = CMP(SLJIT_LESS_EQUAL, TMP1, 0, STR_PTR, 0);
   2357   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
   2358   JUMPHERE(jump);
   2359   }
   2360 else if (common->mode == JIT_PARTIAL_HARD_COMPILE)
   2361   {
   2362   jump = CMP(SLJIT_LESS_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
   2363   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
   2364   JUMPHERE(jump);
   2365   }
   2366 }
   2367 
   2368 static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar *cc)
   2369 {
   2370 /* Detects if the character has an othercase. */
   2371 unsigned int c;
   2372 
   2373 #ifdef SUPPORT_UTF
   2374 if (common->utf)
   2375   {
   2376   GETCHAR(c, cc);
   2377   if (c > 127)
   2378     {
   2379 #ifdef SUPPORT_UCP
   2380     return c != UCD_OTHERCASE(c);
   2381 #else
   2382     return FALSE;
   2383 #endif
   2384     }
   2385 #ifndef COMPILE_PCRE8
   2386   return common->fcc[c] != c;
   2387 #endif
   2388   }
   2389 else
   2390 #endif
   2391   c = *cc;
   2392 return MAX_255(c) ? common->fcc[c] != c : FALSE;
   2393 }
   2394 
   2395 static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigned int c)
   2396 {
   2397 /* Returns with the othercase. */
   2398 #ifdef SUPPORT_UTF
   2399 if (common->utf && c > 127)
   2400   {
   2401 #ifdef SUPPORT_UCP
   2402   return UCD_OTHERCASE(c);
   2403 #else
   2404   return c;
   2405 #endif
   2406   }
   2407 #endif
   2408 return TABLE_GET(c, common->fcc, c);
   2409 }
   2410 
   2411 static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar *cc)
   2412 {
   2413 /* Detects if the character and its othercase has only 1 bit difference. */
   2414 unsigned int c, oc, bit;
   2415 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   2416 int n;
   2417 #endif
   2418 
   2419 #ifdef SUPPORT_UTF
   2420 if (common->utf)
   2421   {
   2422   GETCHAR(c, cc);
   2423   if (c <= 127)
   2424     oc = common->fcc[c];
   2425   else
   2426     {
   2427 #ifdef SUPPORT_UCP
   2428     oc = UCD_OTHERCASE(c);
   2429 #else
   2430     oc = c;
   2431 #endif
   2432     }
   2433   }
   2434 else
   2435   {
   2436   c = *cc;
   2437   oc = TABLE_GET(c, common->fcc, c);
   2438   }
   2439 #else
   2440 c = *cc;
   2441 oc = TABLE_GET(c, common->fcc, c);
   2442 #endif
   2443 
   2444 SLJIT_ASSERT(c != oc);
   2445 
   2446 bit = c ^ oc;
   2447 /* Optimized for English alphabet. */
   2448 if (c <= 127 && bit == 0x20)
   2449   return (0 << 8) | 0x20;
   2450 
   2451 /* Since c != oc, they must have at least 1 bit difference. */
   2452 if (!is_powerof2(bit))
   2453   return 0;
   2454 
   2455 #if defined COMPILE_PCRE8
   2456 
   2457 #ifdef SUPPORT_UTF
   2458 if (common->utf && c > 127)
   2459   {
   2460   n = GET_EXTRALEN(*cc);
   2461   while ((bit & 0x3f) == 0)
   2462     {
   2463     n--;
   2464     bit >>= 6;
   2465     }
   2466   return (n << 8) | bit;
   2467   }
   2468 #endif /* SUPPORT_UTF */
   2469 return (0 << 8) | bit;
   2470 
   2471 #elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   2472 
   2473 #ifdef SUPPORT_UTF
   2474 if (common->utf && c > 65535)
   2475   {
   2476   if (bit >= (1 << 10))
   2477     bit >>= 10;
   2478   else
   2479     return (bit < 256) ? ((2 << 8) | bit) : ((3 << 8) | (bit >> 8));
   2480   }
   2481 #endif /* SUPPORT_UTF */
   2482 return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));
   2483 
   2484 #endif /* COMPILE_PCRE[8|16|32] */
   2485 }
   2486 
   2487 static void check_partial(compiler_common *common, BOOL force)
   2488 {
   2489 /* Checks whether a partial matching is occurred. Does not modify registers. */
   2490 DEFINE_COMPILER;
   2491 struct sljit_jump *jump = NULL;
   2492 
   2493 SLJIT_ASSERT(!force || common->mode != JIT_COMPILE);
   2494 
   2495 if (common->mode == JIT_COMPILE)
   2496   return;
   2497 
   2498 if (!force)
   2499   jump = CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
   2500 else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
   2501   jump = CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1);
   2502 
   2503 if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
   2504   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
   2505 else
   2506   {
   2507   if (common->partialmatchlabel != NULL)
   2508     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
   2509   else
   2510     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
   2511   }
   2512 
   2513 if (jump != NULL)
   2514   JUMPHERE(jump);
   2515 }
   2516 
   2517 static void check_str_end(compiler_common *common, jump_list **end_reached)
   2518 {
   2519 /* Does not affect registers. Usually used in a tight spot. */
   2520 DEFINE_COMPILER;
   2521 struct sljit_jump *jump;
   2522 
   2523 if (common->mode == JIT_COMPILE)
   2524   {
   2525   add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
   2526   return;
   2527   }
   2528 
   2529 jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
   2530 if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
   2531   {
   2532   add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
   2533   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
   2534   add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));
   2535   }
   2536 else
   2537   {
   2538   add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
   2539   if (common->partialmatchlabel != NULL)
   2540     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
   2541   else
   2542     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
   2543   }
   2544 JUMPHERE(jump);
   2545 }
   2546 
   2547 static void detect_partial_match(compiler_common *common, jump_list **backtracks)
   2548 {
   2549 DEFINE_COMPILER;
   2550 struct sljit_jump *jump;
   2551 
   2552 if (common->mode == JIT_COMPILE)
   2553   {
   2554   add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
   2555   return;
   2556   }
   2557 
   2558 /* Partial matching mode. */
   2559 jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
   2560 add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
   2561 if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
   2562   {
   2563   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
   2564   add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   2565   }
   2566 else
   2567   {
   2568   if (common->partialmatchlabel != NULL)
   2569     JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
   2570   else
   2571     add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
   2572   }
   2573 JUMPHERE(jump);
   2574 }
   2575 
   2576 static void peek_char(compiler_common *common, pcre_uint32 max)
   2577 {
   2578 /* Reads the character into TMP1, keeps STR_PTR.
   2579 Does not check STR_END. TMP2 Destroyed. */
   2580 DEFINE_COMPILER;
   2581 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   2582 struct sljit_jump *jump;
   2583 #endif
   2584 
   2585 SLJIT_UNUSED_ARG(max);
   2586 
   2587 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   2588 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   2589 if (common->utf)
   2590   {
   2591   if (max < 128) return;
   2592 
   2593   jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
   2594   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2595   add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
   2596   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   2597   JUMPHERE(jump);
   2598   }
   2599 #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
   2600 
   2601 #if defined SUPPORT_UTF && defined COMPILE_PCRE16
   2602 if (common->utf)
   2603   {
   2604   if (max < 0xd800) return;
   2605 
   2606   OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
   2607   jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
   2608   /* TMP2 contains the high surrogate. */
   2609   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2610   OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
   2611   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
   2612   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
   2613   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2614   JUMPHERE(jump);
   2615   }
   2616 #endif
   2617 }
   2618 
   2619 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   2620 
   2621 static BOOL is_char7_bitset(const pcre_uint8 *bitset, BOOL nclass)
   2622 {
   2623 /* Tells whether the character codes below 128 are enough
   2624 to determine a match. */
   2625 const pcre_uint8 value = nclass ? 0xff : 0;
   2626 const pcre_uint8 *end = bitset + 32;
   2627 
   2628 bitset += 16;
   2629 do
   2630   {
   2631   if (*bitset++ != value)
   2632     return FALSE;
   2633   }
   2634 while (bitset < end);
   2635 return TRUE;
   2636 }
   2637 
   2638 static void read_char7_type(compiler_common *common, BOOL full_read)
   2639 {
   2640 /* Reads the precise character type of a character into TMP1, if the character
   2641 is less than 128. Otherwise it returns with zero. Does not check STR_END. The
   2642 full_read argument tells whether characters above max are accepted or not. */
   2643 DEFINE_COMPILER;
   2644 struct sljit_jump *jump;
   2645 
   2646 SLJIT_ASSERT(common->utf);
   2647 
   2648 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
   2649 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2650 
   2651 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
   2652 
   2653 if (full_read)
   2654   {
   2655   jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
   2656   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   2657   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   2658   JUMPHERE(jump);
   2659   }
   2660 }
   2661 
   2662 #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
   2663 
   2664 static void read_char_range(compiler_common *common, pcre_uint32 min, pcre_uint32 max, BOOL update_str_ptr)
   2665 {
   2666 /* Reads the precise value of a character into TMP1, if the character is
   2667 between min and max (c >= min && c <= max). Otherwise it returns with a value
   2668 outside the range. Does not check STR_END. */
   2669 DEFINE_COMPILER;
   2670 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   2671 struct sljit_jump *jump;
   2672 #endif
   2673 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   2674 struct sljit_jump *jump2;
   2675 #endif
   2676 
   2677 SLJIT_UNUSED_ARG(update_str_ptr);
   2678 SLJIT_UNUSED_ARG(min);
   2679 SLJIT_UNUSED_ARG(max);
   2680 SLJIT_ASSERT(min <= max);
   2681 
   2682 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2683 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2684 
   2685 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   2686 if (common->utf)
   2687   {
   2688   if (max < 128 && !update_str_ptr) return;
   2689 
   2690   jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
   2691   if (min >= 0x10000)
   2692     {
   2693     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xf0);
   2694     if (update_str_ptr)
   2695       OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   2696     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2697     jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x7);
   2698     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
   2699     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
   2700     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2701     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   2702     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   2703     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2704     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2705     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
   2706     if (!update_str_ptr)
   2707       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
   2708     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   2709     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2710     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2711     JUMPHERE(jump2);
   2712     if (update_str_ptr)
   2713       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
   2714     }
   2715   else if (min >= 0x800 && max <= 0xffff)
   2716     {
   2717     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xe0);
   2718     if (update_str_ptr)
   2719       OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   2720     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2721     jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xf);
   2722     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
   2723     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
   2724     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2725     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   2726     if (!update_str_ptr)
   2727       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
   2728     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   2729     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2730     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2731     JUMPHERE(jump2);
   2732     if (update_str_ptr)
   2733       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
   2734     }
   2735   else if (max >= 0x800)
   2736     add_jump(compiler, (max < 0x10000) ? &common->utfreadchar16 : &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
   2737   else if (max < 128)
   2738     {
   2739     OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   2740     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   2741     }
   2742   else
   2743     {
   2744     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2745     if (!update_str_ptr)
   2746       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2747     else
   2748       OP1(SLJIT_MOV_UB, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   2749     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
   2750     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   2751     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2752     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2753     if (update_str_ptr)
   2754       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
   2755     }
   2756   JUMPHERE(jump);
   2757   }
   2758 #endif
   2759 
   2760 #if defined SUPPORT_UTF && defined COMPILE_PCRE16
   2761 if (common->utf)
   2762   {
   2763   if (max >= 0x10000)
   2764     {
   2765     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
   2766     jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
   2767     /* TMP2 contains the high surrogate. */
   2768     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2769     OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
   2770     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
   2771     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2772     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
   2773     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2774     JUMPHERE(jump);
   2775     return;
   2776     }
   2777 
   2778   if (max < 0xd800 && !update_str_ptr) return;
   2779 
   2780   /* Skip low surrogate if necessary. */
   2781   OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
   2782   jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
   2783   if (update_str_ptr)
   2784     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2785   if (max >= 0xd800)
   2786     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000);
   2787   JUMPHERE(jump);
   2788   }
   2789 #endif
   2790 }
   2791 
   2792 static SLJIT_INLINE void read_char(compiler_common *common)
   2793 {
   2794 read_char_range(common, 0, READ_CHAR_MAX, TRUE);
   2795 }
   2796 
   2797 static void read_char8_type(compiler_common *common, BOOL update_str_ptr)
   2798 {
   2799 /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
   2800 DEFINE_COMPILER;
   2801 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   2802 struct sljit_jump *jump;
   2803 #endif
   2804 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   2805 struct sljit_jump *jump2;
   2806 #endif
   2807 
   2808 SLJIT_UNUSED_ARG(update_str_ptr);
   2809 
   2810 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
   2811 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2812 
   2813 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   2814 if (common->utf)
   2815   {
   2816   /* This can be an extra read in some situations, but hopefully
   2817   it is needed in most cases. */
   2818   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
   2819   jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
   2820   if (!update_str_ptr)
   2821     {
   2822     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2823     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2824     OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2825     OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
   2826     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
   2827     OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
   2828     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
   2829     jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);
   2830     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
   2831     JUMPHERE(jump2);
   2832     }
   2833   else
   2834     add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
   2835   JUMPHERE(jump);
   2836   return;
   2837   }
   2838 #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
   2839 
   2840 #if !defined COMPILE_PCRE8
   2841 /* The ctypes array contains only 256 values. */
   2842 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
   2843 jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);
   2844 #endif
   2845 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
   2846 #if !defined COMPILE_PCRE8
   2847 JUMPHERE(jump);
   2848 #endif
   2849 
   2850 #if defined SUPPORT_UTF && defined COMPILE_PCRE16
   2851 if (common->utf && update_str_ptr)
   2852   {
   2853   /* Skip low surrogate if necessary. */
   2854   OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800);
   2855   jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
   2856   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2857   JUMPHERE(jump);
   2858   }
   2859 #endif /* SUPPORT_UTF && COMPILE_PCRE16 */
   2860 }
   2861 
   2862 static void skip_char_back(compiler_common *common)
   2863 {
   2864 /* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */
   2865 DEFINE_COMPILER;
   2866 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   2867 #if defined COMPILE_PCRE8
   2868 struct sljit_label *label;
   2869 
   2870 if (common->utf)
   2871   {
   2872   label = LABEL();
   2873   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
   2874   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2875   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
   2876   CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
   2877   return;
   2878   }
   2879 #elif defined COMPILE_PCRE16
   2880 if (common->utf)
   2881   {
   2882   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
   2883   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2884   /* Skip low surrogate if necessary. */
   2885   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
   2886   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);
   2887   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   2888   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   2889   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   2890   return;
   2891   }
   2892 #endif /* COMPILE_PCRE[8|16] */
   2893 #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
   2894 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2895 }
   2896 
   2897 static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpifmatch)
   2898 {
   2899 /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */
   2900 DEFINE_COMPILER;
   2901 struct sljit_jump *jump;
   2902 
   2903 if (nltype == NLTYPE_ANY)
   2904   {
   2905   add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
   2906   add_jump(compiler, backtracks, JUMP(jumpifmatch ? SLJIT_NOT_ZERO : SLJIT_ZERO));
   2907   }
   2908 else if (nltype == NLTYPE_ANYCRLF)
   2909   {
   2910   if (jumpifmatch)
   2911     {
   2912     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR));
   2913     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
   2914     }
   2915   else
   2916     {
   2917     jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
   2918     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
   2919     JUMPHERE(jump);
   2920     }
   2921   }
   2922 else
   2923   {
   2924   SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);
   2925   add_jump(compiler, backtracks, CMP(jumpifmatch ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
   2926   }
   2927 }
   2928 
   2929 #ifdef SUPPORT_UTF
   2930 
   2931 #if defined COMPILE_PCRE8
   2932 static void do_utfreadchar(compiler_common *common)
   2933 {
   2934 /* Fast decoding a UTF-8 character. TMP1 contains the first byte
   2935 of the character (>= 0xc0). Return char value in TMP1, length in TMP2. */
   2936 DEFINE_COMPILER;
   2937 struct sljit_jump *jump;
   2938 
   2939 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   2940 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2941 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
   2942 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   2943 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2944 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2945 
   2946 /* Searching for the first zero. */
   2947 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
   2948 jump = JUMP(SLJIT_NOT_ZERO);
   2949 /* Two byte sequence. */
   2950 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2951 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
   2952 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   2953 
   2954 JUMPHERE(jump);
   2955 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   2956 OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
   2957 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   2958 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2959 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2960 
   2961 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10000);
   2962 jump = JUMP(SLJIT_NOT_ZERO);
   2963 /* Three byte sequence. */
   2964 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
   2965 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));
   2966 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   2967 
   2968 /* Four byte sequence. */
   2969 JUMPHERE(jump);
   2970 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
   2971 OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
   2972 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   2973 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
   2974 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2975 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2976 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(4));
   2977 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   2978 }
   2979 
   2980 static void do_utfreadchar16(compiler_common *common)
   2981 {
   2982 /* Fast decoding a UTF-8 character. TMP1 contains the first byte
   2983 of the character (>= 0xc0). Return value in TMP1. */
   2984 DEFINE_COMPILER;
   2985 struct sljit_jump *jump;
   2986 
   2987 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   2988 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   2989 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
   2990 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   2991 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   2992 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   2993 
   2994 /* Searching for the first zero. */
   2995 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
   2996 jump = JUMP(SLJIT_NOT_ZERO);
   2997 /* Two byte sequence. */
   2998 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   2999 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   3000 
   3001 JUMPHERE(jump);
   3002 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x400);
   3003 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_NOT_ZERO);
   3004 /* This code runs only in 8 bit mode. No need to shift the value. */
   3005 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   3006 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   3007 OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
   3008 OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
   3009 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
   3010 OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
   3011 /* Three byte sequence. */
   3012 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
   3013 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   3014 }
   3015 
   3016 static void do_utfreadtype8(compiler_common *common)
   3017 {
   3018 /* Fast decoding a UTF-8 character type. TMP2 contains the first byte
   3019 of the character (>= 0xc0). Return value in TMP1. */
   3020 DEFINE_COMPILER;
   3021 struct sljit_jump *jump;
   3022 struct sljit_jump *compare;
   3023 
   3024 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   3025 
   3026 OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
   3027 jump = JUMP(SLJIT_NOT_ZERO);
   3028 /* Two byte sequence. */
   3029 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   3030 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3031 OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);
   3032 /* The upper 5 bits are known at this point. */
   3033 compare = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x3);
   3034 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
   3035 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
   3036 OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
   3037 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
   3038 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   3039 
   3040 JUMPHERE(compare);
   3041 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
   3042 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   3043 
   3044 /* We only have types for characters less than 256. */
   3045 JUMPHERE(jump);
   3046 OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   3047 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
   3048 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   3049 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   3050 }
   3051 
   3052 #endif /* COMPILE_PCRE8 */
   3053 
   3054 #endif /* SUPPORT_UTF */
   3055 
   3056 #ifdef SUPPORT_UCP
   3057 
   3058 /* UCD_BLOCK_SIZE must be 128 (see the assert below). */
   3059 #define UCD_BLOCK_MASK 127
   3060 #define UCD_BLOCK_SHIFT 7
   3061 
   3062 static void do_getucd(compiler_common *common)
   3063 {
   3064 /* Search the UCD record for the character comes in TMP1.
   3065 Returns chartype in TMP1 and UCD offset in TMP2. */
   3066 DEFINE_COMPILER;
   3067 
   3068 SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8);
   3069 
   3070 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   3071 OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
   3072 OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1));
   3073 OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);
   3074 OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
   3075 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
   3076 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2));
   3077 OP1(SLJIT_MOV_UH, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
   3078 OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
   3079 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
   3080 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   3081 }
   3082 #endif
   3083 
   3084 static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf, BOOL firstline)
   3085 {
   3086 DEFINE_COMPILER;
   3087 struct sljit_label *mainloop;
   3088 struct sljit_label *newlinelabel = NULL;
   3089 struct sljit_jump *start;
   3090 struct sljit_jump *end = NULL;
   3091 struct sljit_jump *nl = NULL;
   3092 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   3093 struct sljit_jump *singlechar;
   3094 #endif
   3095 jump_list *newline = NULL;
   3096 BOOL newlinecheck = FALSE;
   3097 BOOL readuchar = FALSE;
   3098 
   3099 if (!(hascrorlf || firstline) && (common->nltype == NLTYPE_ANY ||
   3100     common->nltype == NLTYPE_ANYCRLF || common->newline > 255))
   3101   newlinecheck = TRUE;
   3102 
   3103 if (firstline)
   3104   {
   3105   /* Search for the end of the first line. */
   3106   SLJIT_ASSERT(common->first_line_end != 0);
   3107   OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
   3108 
   3109   if (common->nltype == NLTYPE_FIXED && common->newline > 255)
   3110     {
   3111     mainloop = LABEL();
   3112     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3113     end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3114     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
   3115     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   3116     CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
   3117     CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
   3118     JUMPHERE(end);
   3119     OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3120     }
   3121   else
   3122     {
   3123     end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3124     mainloop = LABEL();
   3125     /* Continual stores does not cause data dependency. */
   3126     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->first_line_end, STR_PTR, 0);
   3127     read_char_range(common, common->nlmin, common->nlmax, TRUE);
   3128     check_newlinechar(common, common->nltype, &newline, TRUE);
   3129     CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, mainloop);
   3130     JUMPHERE(end);
   3131     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->first_line_end, STR_PTR, 0);
   3132     set_jumps(newline, LABEL());
   3133     }
   3134 
   3135   OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
   3136   }
   3137 
   3138 start = JUMP(SLJIT_JUMP);
   3139 
   3140 if (newlinecheck)
   3141   {
   3142   newlinelabel = LABEL();
   3143   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3144   end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3145   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   3146   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);
   3147   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   3148 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   3149   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
   3150 #endif
   3151   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   3152   nl = JUMP(SLJIT_JUMP);
   3153   }
   3154 
   3155 mainloop = LABEL();
   3156 
   3157 /* Increasing the STR_PTR here requires one less jump in the most common case. */
   3158 #ifdef SUPPORT_UTF
   3159 if (common->utf) readuchar = TRUE;
   3160 #endif
   3161 if (newlinecheck) readuchar = TRUE;
   3162 
   3163 if (readuchar)
   3164   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   3165 
   3166 if (newlinecheck)
   3167   CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
   3168 
   3169 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3170 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   3171 #if defined COMPILE_PCRE8
   3172 if (common->utf)
   3173   {
   3174   singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
   3175   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   3176   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   3177   JUMPHERE(singlechar);
   3178   }
   3179 #elif defined COMPILE_PCRE16
   3180 if (common->utf)
   3181   {
   3182   singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
   3183   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
   3184   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
   3185   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   3186   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   3187   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   3188   JUMPHERE(singlechar);
   3189   }
   3190 #endif /* COMPILE_PCRE[8|16] */
   3191 #endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
   3192 JUMPHERE(start);
   3193 
   3194 if (newlinecheck)
   3195   {
   3196   JUMPHERE(end);
   3197   JUMPHERE(nl);
   3198   }
   3199 
   3200 return mainloop;
   3201 }
   3202 
   3203 #define MAX_N_CHARS 16
   3204 #define MAX_N_BYTES 8
   3205 
   3206 static SLJIT_INLINE void add_prefix_byte(pcre_uint8 byte, pcre_uint8 *bytes)
   3207 {
   3208 pcre_uint8 len = bytes[0];
   3209 int i;
   3210 
   3211 if (len == 255)
   3212   return;
   3213 
   3214 if (len == 0)
   3215   {
   3216   bytes[0] = 1;
   3217   bytes[1] = byte;
   3218   return;
   3219   }
   3220 
   3221 for (i = len; i > 0; i--)
   3222   if (bytes[i] == byte)
   3223     return;
   3224 
   3225 if (len >= MAX_N_BYTES - 1)
   3226   {
   3227   bytes[0] = 255;
   3228   return;
   3229   }
   3230 
   3231 len++;
   3232 bytes[len] = byte;
   3233 bytes[0] = len;
   3234 }
   3235 
   3236 static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uint32 *chars, pcre_uint8 *bytes, int max_chars, pcre_uint32 *rec_count)
   3237 {
   3238 /* Recursive function, which scans prefix literals. */
   3239 BOOL last, any, caseless;
   3240 int len, repeat, len_save, consumed = 0;
   3241 pcre_uint32 chr, mask;
   3242 pcre_uchar *alternative, *cc_save, *oc;
   3243 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   3244 pcre_uchar othercase[8];
   3245 #elif defined SUPPORT_UTF && defined COMPILE_PCRE16
   3246 pcre_uchar othercase[2];
   3247 #else
   3248 pcre_uchar othercase[1];
   3249 #endif
   3250 
   3251 repeat = 1;
   3252 while (TRUE)
   3253   {
   3254   if (*rec_count == 0)
   3255     return 0;
   3256   (*rec_count)--;
   3257 
   3258   last = TRUE;
   3259   any = FALSE;
   3260   caseless = FALSE;
   3261 
   3262   switch (*cc)
   3263     {
   3264     case OP_CHARI:
   3265     caseless = TRUE;
   3266     case OP_CHAR:
   3267     last = FALSE;
   3268     cc++;
   3269     break;
   3270 
   3271     case OP_SOD:
   3272     case OP_SOM:
   3273     case OP_SET_SOM:
   3274     case OP_NOT_WORD_BOUNDARY:
   3275     case OP_WORD_BOUNDARY:
   3276     case OP_EODN:
   3277     case OP_EOD:
   3278     case OP_CIRC:
   3279     case OP_CIRCM:
   3280     case OP_DOLL:
   3281     case OP_DOLLM:
   3282     /* Zero width assertions. */
   3283     cc++;
   3284     continue;
   3285 
   3286     case OP_ASSERT:
   3287     case OP_ASSERT_NOT:
   3288     case OP_ASSERTBACK:
   3289     case OP_ASSERTBACK_NOT:
   3290     cc = bracketend(cc);
   3291     continue;
   3292 
   3293     case OP_PLUSI:
   3294     case OP_MINPLUSI:
   3295     case OP_POSPLUSI:
   3296     caseless = TRUE;
   3297     case OP_PLUS:
   3298     case OP_MINPLUS:
   3299     case OP_POSPLUS:
   3300     cc++;
   3301     break;
   3302 
   3303     case OP_EXACTI:
   3304     caseless = TRUE;
   3305     case OP_EXACT:
   3306     repeat = GET2(cc, 1);
   3307     last = FALSE;
   3308     cc += 1 + IMM2_SIZE;
   3309     break;
   3310 
   3311     case OP_QUERYI:
   3312     case OP_MINQUERYI:
   3313     case OP_POSQUERYI:
   3314     caseless = TRUE;
   3315     case OP_QUERY:
   3316     case OP_MINQUERY:
   3317     case OP_POSQUERY:
   3318     len = 1;
   3319     cc++;
   3320 #ifdef SUPPORT_UTF
   3321     if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
   3322 #endif
   3323     max_chars = scan_prefix(common, cc + len, chars, bytes, max_chars, rec_count);
   3324     if (max_chars == 0)
   3325       return consumed;
   3326     last = FALSE;
   3327     break;
   3328 
   3329     case OP_KET:
   3330     cc += 1 + LINK_SIZE;
   3331     continue;
   3332 
   3333     case OP_ALT:
   3334     cc += GET(cc, 1);
   3335     continue;
   3336 
   3337     case OP_ONCE:
   3338     case OP_ONCE_NC:
   3339     case OP_BRA:
   3340     case OP_BRAPOS:
   3341     case OP_CBRA:
   3342     case OP_CBRAPOS:
   3343     alternative = cc + GET(cc, 1);
   3344     while (*alternative == OP_ALT)
   3345       {
   3346       max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, bytes, max_chars, rec_count);
   3347       if (max_chars == 0)
   3348         return consumed;
   3349       alternative += GET(alternative, 1);
   3350       }
   3351 
   3352     if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
   3353       cc += IMM2_SIZE;
   3354     cc += 1 + LINK_SIZE;
   3355     continue;
   3356 
   3357     case OP_CLASS:
   3358 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   3359     if (common->utf && !is_char7_bitset((const pcre_uint8 *)(cc + 1), FALSE)) return consumed;
   3360 #endif
   3361     any = TRUE;
   3362     cc += 1 + 32 / sizeof(pcre_uchar);
   3363     break;
   3364 
   3365     case OP_NCLASS:
   3366 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   3367     if (common->utf) return consumed;
   3368 #endif
   3369     any = TRUE;
   3370     cc += 1 + 32 / sizeof(pcre_uchar);
   3371     break;
   3372 
   3373 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   3374     case OP_XCLASS:
   3375 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   3376     if (common->utf) return consumed;
   3377 #endif
   3378     any = TRUE;
   3379     cc += GET(cc, 1);
   3380     break;
   3381 #endif
   3382 
   3383     case OP_DIGIT:
   3384 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   3385     if (common->utf && !is_char7_bitset((const pcre_uint8 *)common->ctypes - cbit_length + cbit_digit, FALSE))
   3386       return consumed;
   3387 #endif
   3388     any = TRUE;
   3389     cc++;
   3390     break;
   3391 
   3392     case OP_WHITESPACE:
   3393 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   3394     if (common->utf && !is_char7_bitset((const pcre_uint8 *)common->ctypes - cbit_length + cbit_space, FALSE))
   3395       return consumed;
   3396 #endif
   3397     any = TRUE;
   3398     cc++;
   3399     break;
   3400 
   3401     case OP_WORDCHAR:
   3402 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   3403     if (common->utf && !is_char7_bitset((const pcre_uint8 *)common->ctypes - cbit_length + cbit_word, FALSE))
   3404       return consumed;
   3405 #endif
   3406     any = TRUE;
   3407     cc++;
   3408     break;
   3409 
   3410     case OP_NOT:
   3411     case OP_NOTI:
   3412     cc++;
   3413     /* Fall through. */
   3414     case OP_NOT_DIGIT:
   3415     case OP_NOT_WHITESPACE:
   3416     case OP_NOT_WORDCHAR:
   3417     case OP_ANY:
   3418     case OP_ALLANY:
   3419 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   3420     if (common->utf) return consumed;
   3421 #endif
   3422     any = TRUE;
   3423     cc++;
   3424     break;
   3425 
   3426 #ifdef SUPPORT_UCP
   3427     case OP_NOTPROP:
   3428     case OP_PROP:
   3429 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   3430     if (common->utf) return consumed;
   3431 #endif
   3432     any = TRUE;
   3433     cc += 1 + 2;
   3434     break;
   3435 #endif
   3436 
   3437     case OP_TYPEEXACT:
   3438     repeat = GET2(cc, 1);
   3439     cc += 1 + IMM2_SIZE;
   3440     continue;
   3441 
   3442     case OP_NOTEXACT:
   3443     case OP_NOTEXACTI:
   3444 #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
   3445     if (common->utf) return consumed;
   3446 #endif
   3447     any = TRUE;
   3448     repeat = GET2(cc, 1);
   3449     cc += 1 + IMM2_SIZE + 1;
   3450     break;
   3451 
   3452     default:
   3453     return consumed;
   3454     }
   3455 
   3456   if (any)
   3457     {
   3458 #if defined COMPILE_PCRE8
   3459     mask = 0xff;
   3460 #elif defined COMPILE_PCRE16
   3461     mask = 0xffff;
   3462 #elif defined COMPILE_PCRE32
   3463     mask = 0xffffffff;
   3464 #else
   3465     SLJIT_ASSERT_STOP();
   3466 #endif
   3467 
   3468     do
   3469       {
   3470       chars[0] = mask;
   3471       chars[1] = mask;
   3472       bytes[0] = 255;
   3473 
   3474       consumed++;
   3475       if (--max_chars == 0)
   3476         return consumed;
   3477       chars += 2;
   3478       bytes += MAX_N_BYTES;
   3479       }
   3480     while (--repeat > 0);
   3481 
   3482     repeat = 1;
   3483     continue;
   3484     }
   3485 
   3486   len = 1;
   3487 #ifdef SUPPORT_UTF
   3488   if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
   3489 #endif
   3490 
   3491   if (caseless && char_has_othercase(common, cc))
   3492     {
   3493 #ifdef SUPPORT_UTF
   3494     if (common->utf)
   3495       {
   3496       GETCHAR(chr, cc);
   3497       if ((int)PRIV(ord2utf)(char_othercase(common, chr), othercase) != len)
   3498         return consumed;
   3499       }
   3500     else
   3501 #endif
   3502       {
   3503       chr = *cc;
   3504       othercase[0] = TABLE_GET(chr, common->fcc, chr);
   3505       }
   3506     }
   3507   else
   3508     caseless = FALSE;
   3509 
   3510   len_save = len;
   3511   cc_save = cc;
   3512   while (TRUE)
   3513     {
   3514     oc = othercase;
   3515     do
   3516       {
   3517       chr = *cc;
   3518 #ifdef COMPILE_PCRE32
   3519       if (SLJIT_UNLIKELY(chr == NOTACHAR))
   3520         return consumed;
   3521 #endif
   3522       add_prefix_byte((pcre_uint8)chr, bytes);
   3523 
   3524       mask = 0;
   3525       if (caseless)
   3526         {
   3527         add_prefix_byte((pcre_uint8)*oc, bytes);
   3528         mask = *cc ^ *oc;
   3529         chr |= mask;
   3530         }
   3531 
   3532 #ifdef COMPILE_PCRE32
   3533       if (chars[0] == NOTACHAR && chars[1] == 0)
   3534 #else
   3535       if (chars[0] == NOTACHAR)
   3536 #endif
   3537         {
   3538         chars[0] = chr;
   3539         chars[1] = mask;
   3540         }
   3541       else
   3542         {
   3543         mask |= chars[0] ^ chr;
   3544         chr |= mask;
   3545         chars[0] = chr;
   3546         chars[1] |= mask;
   3547         }
   3548 
   3549       len--;
   3550       consumed++;
   3551       if (--max_chars == 0)
   3552         return consumed;
   3553       chars += 2;
   3554       bytes += MAX_N_BYTES;
   3555       cc++;
   3556       oc++;
   3557       }
   3558     while (len > 0);
   3559 
   3560     if (--repeat == 0)
   3561       break;
   3562 
   3563     len = len_save;
   3564     cc = cc_save;
   3565     }
   3566 
   3567   repeat = 1;
   3568   if (last)
   3569     return consumed;
   3570   }
   3571 }
   3572 
   3573 static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
   3574 {
   3575 DEFINE_COMPILER;
   3576 struct sljit_label *start;
   3577 struct sljit_jump *quit;
   3578 pcre_uint32 chars[MAX_N_CHARS * 2];
   3579 pcre_uint8 bytes[MAX_N_CHARS * MAX_N_BYTES];
   3580 pcre_uint8 ones[MAX_N_CHARS];
   3581 int offsets[3];
   3582 pcre_uint32 mask;
   3583 pcre_uint8 *byte_set, *byte_set_end;
   3584 int i, max, from;
   3585 int range_right = -1, range_len = 3 - 1;
   3586 sljit_ub *update_table = NULL;
   3587 BOOL in_range;
   3588 pcre_uint32 rec_count;
   3589 
   3590 for (i = 0; i < MAX_N_CHARS; i++)
   3591   {
   3592   chars[i << 1] = NOTACHAR;
   3593   chars[(i << 1) + 1] = 0;
   3594   bytes[i * MAX_N_BYTES] = 0;
   3595   }
   3596 
   3597 rec_count = 10000;
   3598 max = scan_prefix(common, common->start, chars, bytes, MAX_N_CHARS, &rec_count);
   3599 
   3600 if (max <= 1)
   3601   return FALSE;
   3602 
   3603 for (i = 0; i < max; i++)
   3604   {
   3605   mask = chars[(i << 1) + 1];
   3606   ones[i] = ones_in_half_byte[mask & 0xf];
   3607   mask >>= 4;
   3608   while (mask != 0)
   3609     {
   3610     ones[i] += ones_in_half_byte[mask & 0xf];
   3611     mask >>= 4;
   3612     }
   3613   }
   3614 
   3615 in_range = FALSE;
   3616 from = 0;   /* Prevent compiler "uninitialized" warning */
   3617 for (i = 0; i <= max; i++)
   3618   {
   3619   if (in_range && (i - from) > range_len && (bytes[(i - 1) * MAX_N_BYTES] <= 4))
   3620     {
   3621     range_len = i - from;
   3622     range_right = i - 1;
   3623     }
   3624 
   3625   if (i < max && bytes[i * MAX_N_BYTES] < 255)
   3626     {
   3627     if (!in_range)
   3628       {
   3629       in_range = TRUE;
   3630       from = i;
   3631       }
   3632     }
   3633   else if (in_range)
   3634     in_range = FALSE;
   3635   }
   3636 
   3637 if (range_right >= 0)
   3638   {
   3639   update_table = (sljit_ub *)allocate_read_only_data(common, 256);
   3640   if (update_table == NULL)
   3641     return TRUE;
   3642   memset(update_table, IN_UCHARS(range_len), 256);
   3643 
   3644   for (i = 0; i < range_len; i++)
   3645     {
   3646     byte_set = bytes + ((range_right - i) * MAX_N_BYTES);
   3647     SLJIT_ASSERT(byte_set[0] > 0 && byte_set[0] < 255);
   3648     byte_set_end = byte_set + byte_set[0];
   3649     byte_set++;
   3650     while (byte_set <= byte_set_end)
   3651       {
   3652       if (update_table[*byte_set] > IN_UCHARS(i))
   3653         update_table[*byte_set] = IN_UCHARS(i);
   3654       byte_set++;
   3655       }
   3656     }
   3657   }
   3658 
   3659 offsets[0] = -1;
   3660 /* Scan forward. */
   3661 for (i = 0; i < max; i++)
   3662   if (ones[i] <= 2) {
   3663     offsets[0] = i;
   3664     break;
   3665   }
   3666 
   3667 if (offsets[0] < 0 && range_right < 0)
   3668   return FALSE;
   3669 
   3670 if (offsets[0] >= 0)
   3671   {
   3672   /* Scan backward. */
   3673   offsets[1] = -1;
   3674   for (i = max - 1; i > offsets[0]; i--)
   3675     if (ones[i] <= 2 && i != range_right)
   3676       {
   3677       offsets[1] = i;
   3678       break;
   3679       }
   3680 
   3681   /* This case is handled better by fast_forward_first_char. */
   3682   if (offsets[1] == -1 && offsets[0] == 0 && range_right < 0)
   3683     return FALSE;
   3684 
   3685   offsets[2] = -1;
   3686   /* We only search for a middle character if there is no range check. */
   3687   if (offsets[1] >= 0 && range_right == -1)
   3688     {
   3689     /* Scan from middle. */
   3690     for (i = (offsets[0] + offsets[1]) / 2 + 1; i < offsets[1]; i++)
   3691       if (ones[i] <= 2)
   3692         {
   3693         offsets[2] = i;
   3694         break;
   3695         }
   3696 
   3697     if (offsets[2] == -1)
   3698       {
   3699       for (i = (offsets[0] + offsets[1]) / 2; i > offsets[0]; i--)
   3700         if (ones[i] <= 2)
   3701           {
   3702           offsets[2] = i;
   3703           break;
   3704           }
   3705       }
   3706     }
   3707 
   3708   SLJIT_ASSERT(offsets[1] == -1 || (offsets[0] < offsets[1]));
   3709   SLJIT_ASSERT(offsets[2] == -1 || (offsets[0] < offsets[2] && offsets[1] > offsets[2]));
   3710 
   3711   chars[0] = chars[offsets[0] << 1];
   3712   chars[1] = chars[(offsets[0] << 1) + 1];
   3713   if (offsets[2] >= 0)
   3714     {
   3715     chars[2] = chars[offsets[2] << 1];
   3716     chars[3] = chars[(offsets[2] << 1) + 1];
   3717     }
   3718   if (offsets[1] >= 0)
   3719     {
   3720     chars[4] = chars[offsets[1] << 1];
   3721     chars[5] = chars[(offsets[1] << 1) + 1];
   3722     }
   3723   }
   3724 
   3725 max -= 1;
   3726 if (firstline)
   3727   {
   3728   SLJIT_ASSERT(common->first_line_end != 0);
   3729   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
   3730   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
   3731   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
   3732   quit = CMP(SLJIT_LESS_EQUAL, STR_END, 0, TMP1, 0);
   3733   OP1(SLJIT_MOV, STR_END, 0, TMP1, 0);
   3734   JUMPHERE(quit);
   3735   }
   3736 else
   3737   OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
   3738 
   3739 #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
   3740 if (range_right >= 0)
   3741   OP1(SLJIT_MOV, RETURN_ADDR, 0, SLJIT_IMM, (sljit_sw)update_table);
   3742 #endif
   3743 
   3744 start = LABEL();
   3745 quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3746 
   3747 SLJIT_ASSERT(range_right >= 0 || offsets[0] >= 0);
   3748 
   3749 if (range_right >= 0)
   3750   {
   3751 #if defined COMPILE_PCRE8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
   3752   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right));
   3753 #else
   3754   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right + 1) - 1);
   3755 #endif
   3756 
   3757 #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
   3758   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(RETURN_ADDR, TMP1), 0);
   3759 #else
   3760   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)update_table);
   3761 #endif
   3762   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   3763   CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start);
   3764   }
   3765 
   3766 if (offsets[0] >= 0)
   3767   {
   3768   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[0]));
   3769   if (offsets[1] >= 0)
   3770     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[1]));
   3771   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3772 
   3773   if (chars[1] != 0)
   3774     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
   3775   CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
   3776   if (offsets[2] >= 0)
   3777     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[2] - 1));
   3778 
   3779   if (offsets[1] >= 0)
   3780     {
   3781     if (chars[5] != 0)
   3782       OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[5]);
   3783     CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[4], start);
   3784     }
   3785 
   3786   if (offsets[2] >= 0)
   3787     {
   3788     if (chars[3] != 0)
   3789       OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[3]);
   3790     CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[2], start);
   3791     }
   3792   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3793   }
   3794 
   3795 JUMPHERE(quit);
   3796 
   3797 if (firstline)
   3798   {
   3799   if (range_right >= 0)
   3800     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
   3801   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
   3802   if (range_right >= 0)
   3803     {
   3804     quit = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
   3805     OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
   3806     JUMPHERE(quit);
   3807     }
   3808   }
   3809 else
   3810   OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
   3811 return TRUE;
   3812 }
   3813 
   3814 #undef MAX_N_CHARS
   3815 #undef MAX_N_BYTES
   3816 
   3817 static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)
   3818 {
   3819 DEFINE_COMPILER;
   3820 struct sljit_label *start;
   3821 struct sljit_jump *quit;
   3822 struct sljit_jump *found;
   3823 pcre_uchar oc, bit;
   3824 
   3825 if (firstline)
   3826   {
   3827   SLJIT_ASSERT(common->first_line_end != 0);
   3828   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
   3829   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
   3830   }
   3831 
   3832 start = LABEL();
   3833 quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3834 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   3835 
   3836 oc = first_char;
   3837 if (caseless)
   3838   {
   3839   oc = TABLE_GET(first_char, common->fcc, first_char);
   3840 #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
   3841   if (first_char > 127 && common->utf)
   3842     oc = UCD_OTHERCASE(first_char);
   3843 #endif
   3844   }
   3845 if (first_char == oc)
   3846   found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, first_char);
   3847 else
   3848   {
   3849   bit = first_char ^ oc;
   3850   if (is_powerof2(bit))
   3851     {
   3852     OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);
   3853     found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, first_char | bit);
   3854     }
   3855   else
   3856     {
   3857     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, first_char);
   3858     OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   3859     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);
   3860     OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   3861     found = JUMP(SLJIT_NOT_ZERO);
   3862     }
   3863   }
   3864 
   3865 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3866 JUMPTO(SLJIT_JUMP, start);
   3867 JUMPHERE(found);
   3868 JUMPHERE(quit);
   3869 
   3870 if (firstline)
   3871   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
   3872 }
   3873 
   3874 static SLJIT_INLINE void fast_forward_newline(compiler_common *common, BOOL firstline)
   3875 {
   3876 DEFINE_COMPILER;
   3877 struct sljit_label *loop;
   3878 struct sljit_jump *lastchar;
   3879 struct sljit_jump *firstchar;
   3880 struct sljit_jump *quit;
   3881 struct sljit_jump *foundcr = NULL;
   3882 struct sljit_jump *notfoundnl;
   3883 jump_list *newline = NULL;
   3884 
   3885 if (firstline)
   3886   {
   3887   SLJIT_ASSERT(common->first_line_end != 0);
   3888   OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
   3889   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
   3890   }
   3891 
   3892 if (common->nltype == NLTYPE_FIXED && common->newline > 255)
   3893   {
   3894   lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3895   OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   3896   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
   3897   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
   3898   firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
   3899 
   3900   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));
   3901   OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);
   3902   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_GREATER_EQUAL);
   3903 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   3904   OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
   3905 #endif
   3906   OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   3907 
   3908   loop = LABEL();
   3909   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   3910   quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3911   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
   3912   OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
   3913   CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);
   3914   CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);
   3915 
   3916   JUMPHERE(quit);
   3917   JUMPHERE(firstchar);
   3918   JUMPHERE(lastchar);
   3919 
   3920   if (firstline)
   3921     OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
   3922   return;
   3923   }
   3924 
   3925 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   3926 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
   3927 firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
   3928 skip_char_back(common);
   3929 
   3930 loop = LABEL();
   3931 common->ff_newline_shortcut = loop;
   3932 
   3933 read_char_range(common, common->nlmin, common->nlmax, TRUE);
   3934 lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3935 if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
   3936   foundcr = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
   3937 check_newlinechar(common, common->nltype, &newline, FALSE);
   3938 set_jumps(newline, loop);
   3939 
   3940 if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
   3941   {
   3942   quit = JUMP(SLJIT_JUMP);
   3943   JUMPHERE(foundcr);
   3944   notfoundnl = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3945   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   3946   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
   3947   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   3948 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   3949   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
   3950 #endif
   3951   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   3952   JUMPHERE(notfoundnl);
   3953   JUMPHERE(quit);
   3954   }
   3955 JUMPHERE(lastchar);
   3956 JUMPHERE(firstchar);
   3957 
   3958 if (firstline)
   3959   OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
   3960 }
   3961 
   3962 static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks);
   3963 
   3964 static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, pcre_uint8 *start_bits, BOOL firstline)
   3965 {
   3966 DEFINE_COMPILER;
   3967 struct sljit_label *start;
   3968 struct sljit_jump *quit;
   3969 struct sljit_jump *found = NULL;
   3970 jump_list *matches = NULL;
   3971 #ifndef COMPILE_PCRE8
   3972 struct sljit_jump *jump;
   3973 #endif
   3974 
   3975 if (firstline)
   3976   {
   3977   SLJIT_ASSERT(common->first_line_end != 0);
   3978   OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);
   3979   OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
   3980   }
   3981 
   3982 start = LABEL();
   3983 quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   3984 OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   3985 #ifdef SUPPORT_UTF
   3986 if (common->utf)
   3987   OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
   3988 #endif
   3989 
   3990 if (!check_class_ranges(common, start_bits, (start_bits[31] & 0x80) != 0, TRUE, &matches))
   3991   {
   3992 #ifndef COMPILE_PCRE8
   3993   jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 255);
   3994   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);
   3995   JUMPHERE(jump);
   3996 #endif
   3997   OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
   3998   OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
   3999   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)start_bits);
   4000   OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
   4001   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
   4002   found = JUMP(SLJIT_NOT_ZERO);
   4003   }
   4004 
   4005 #ifdef SUPPORT_UTF
   4006 if (common->utf)
   4007   OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
   4008 #endif
   4009 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   4010 #ifdef SUPPORT_UTF
   4011 #if defined COMPILE_PCRE8
   4012 if (common->utf)
   4013   {
   4014   CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
   4015   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   4016   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   4017   }
   4018 #elif defined COMPILE_PCRE16
   4019 if (common->utf)
   4020   {
   4021   CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
   4022   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
   4023   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
   4024   OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   4025   OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   4026   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   4027   }
   4028 #endif /* COMPILE_PCRE[8|16] */
   4029 #endif /* SUPPORT_UTF */
   4030 JUMPTO(SLJIT_JUMP, start);
   4031 if (found != NULL)
   4032   JUMPHERE(found);
   4033 if (matches != NULL)
   4034   set_jumps(matches, LABEL());
   4035 JUMPHERE(quit);
   4036 
   4037 if (firstline)
   4038   OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0);
   4039 }
   4040 
   4041 static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uchar req_char, BOOL caseless, BOOL has_firstchar)
   4042 {
   4043 DEFINE_COMPILER;
   4044 struct sljit_label *loop;
   4045 struct sljit_jump *toolong;
   4046 struct sljit_jump *alreadyfound;
   4047 struct sljit_jump *found;
   4048 struct sljit_jump *foundoc = NULL;
   4049 struct sljit_jump *notfound;
   4050 pcre_uint32 oc, bit;
   4051 
   4052 SLJIT_ASSERT(common->req_char_ptr != 0);
   4053 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr);
   4054 OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);
   4055 toolong = CMP(SLJIT_LESS, TMP1, 0, STR_END, 0);
   4056 alreadyfound = CMP(SLJIT_LESS, STR_PTR, 0, TMP2, 0);
   4057 
   4058 if (has_firstchar)
   4059   OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   4060 else
   4061   OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);
   4062 
   4063 loop = LABEL();
   4064 notfound = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, STR_END, 0);
   4065 
   4066 OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);
   4067 oc = req_char;
   4068 if (caseless)
   4069   {
   4070   oc = TABLE_GET(req_char, common->fcc, req_char);
   4071 #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
   4072   if (req_char > 127 && common->utf)
   4073     oc = UCD_OTHERCASE(req_char);
   4074 #endif
   4075   }
   4076 if (req_char == oc)
   4077   found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
   4078 else
   4079   {
   4080   bit = req_char ^ oc;
   4081   if (is_powerof2(bit))
   4082     {
   4083     OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
   4084     found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
   4085     }
   4086   else
   4087     {
   4088     found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
   4089     foundoc = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, oc);
   4090     }
   4091   }
   4092 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
   4093 JUMPTO(SLJIT_JUMP, loop);
   4094 
   4095 JUMPHERE(found);
   4096 if (foundoc)
   4097   JUMPHERE(foundoc);
   4098 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, TMP1, 0);
   4099 JUMPHERE(alreadyfound);
   4100 JUMPHERE(toolong);
   4101 return notfound;
   4102 }
   4103 
   4104 static void do_revertframes(compiler_common *common)
   4105 {
   4106 DEFINE_COMPILER;
   4107 struct sljit_jump *jump;
   4108 struct sljit_label *mainloop;
   4109 
   4110 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   4111 OP1(SLJIT_MOV, TMP1, 0, STACK_TOP, 0);
   4112 GET_LOCAL_BASE(TMP3, 0, 0);
   4113 
   4114 /* Drop frames until we reach STACK_TOP. */
   4115 mainloop = LABEL();
   4116 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
   4117 OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);
   4118 jump = JUMP(SLJIT_SIG_LESS_EQUAL);
   4119 
   4120 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
   4121 OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
   4122 OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));
   4123 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_sw));
   4124 JUMPTO(SLJIT_JUMP, mainloop);
   4125 
   4126 JUMPHERE(jump);
   4127 jump = JUMP(SLJIT_SIG_LESS);
   4128 /* End of dropping frames. */
   4129 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   4130 
   4131 JUMPHERE(jump);
   4132 OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);
   4133 OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);
   4134 OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));
   4135 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
   4136 JUMPTO(SLJIT_JUMP, mainloop);
   4137 }
   4138 
   4139 static void check_wordboundary(compiler_common *common)
   4140 {
   4141 DEFINE_COMPILER;
   4142 struct sljit_jump *skipread;
   4143 jump_list *skipread_list = NULL;
   4144 #if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF
   4145 struct sljit_jump *jump;
   4146 #endif
   4147 
   4148 SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);
   4149 
   4150 sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   4151 /* Get type of the previous char, and put it to LOCALS1. */
   4152 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   4153 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
   4154 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, SLJIT_IMM, 0);
   4155 skipread = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
   4156 skip_char_back(common);
   4157 check_start_used_ptr(common);
   4158 read_char(common);
   4159 
   4160 /* Testing char type. */
   4161 #ifdef SUPPORT_UCP
   4162 if (common->use_ucp)
   4163   {
   4164   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
   4165   jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
   4166   add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
   4167   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
   4168   OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
   4169   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
   4170   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
   4171   OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
   4172   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   4173   JUMPHERE(jump);
   4174   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP2, 0);
   4175   }
   4176 else
   4177 #endif
   4178   {
   4179 #ifndef COMPILE_PCRE8
   4180   jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
   4181 #elif defined SUPPORT_UTF
   4182   /* Here LOCALS1 has already been zeroed. */
   4183   jump = NULL;
   4184   if (common->utf)
   4185     jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
   4186 #endif /* COMPILE_PCRE8 */
   4187   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);
   4188   OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);
   4189   OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   4190   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);
   4191 #ifndef COMPILE_PCRE8
   4192   JUMPHERE(jump);
   4193 #elif defined SUPPORT_UTF
   4194   if (jump != NULL)
   4195     JUMPHERE(jump);
   4196 #endif /* COMPILE_PCRE8 */
   4197   }
   4198 JUMPHERE(skipread);
   4199 
   4200 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
   4201 check_str_end(common, &skipread_list);
   4202 peek_char(common, READ_CHAR_MAX);
   4203 
   4204 /* Testing char type. This is a code duplication. */
   4205 #ifdef SUPPORT_UCP
   4206 if (common->use_ucp)
   4207   {
   4208   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
   4209   jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
   4210   add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
   4211   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
   4212   OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
   4213   OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
   4214   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
   4215   OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
   4216   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   4217   JUMPHERE(jump);
   4218   }
   4219 else
   4220 #endif
   4221   {
   4222 #ifndef COMPILE_PCRE8
   4223   /* TMP2 may be destroyed by peek_char. */
   4224   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
   4225   jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
   4226 #elif defined SUPPORT_UTF
   4227   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
   4228   jump = NULL;
   4229   if (common->utf)
   4230     jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
   4231 #endif
   4232   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);
   4233   OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);
   4234   OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
   4235 #ifndef COMPILE_PCRE8
   4236   JUMPHERE(jump);
   4237 #elif defined SUPPORT_UTF
   4238   if (jump != NULL)
   4239     JUMPHERE(jump);
   4240 #endif /* COMPILE_PCRE8 */
   4241   }
   4242 set_jumps(skipread_list, LABEL());
   4243 
   4244 OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
   4245 sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   4246 }
   4247 
   4248 static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks)
   4249 {
   4250 DEFINE_COMPILER;
   4251 int ranges[MAX_RANGE_SIZE];
   4252 pcre_uint8 bit, cbit, all;
   4253 int i, byte, length = 0;
   4254 
   4255 bit = bits[0] & 0x1;
   4256 /* All bits will be zero or one (since bit is zero or one). */
   4257 all = -bit;
   4258 
   4259 for (i = 0; i < 256; )
   4260   {
   4261   byte = i >> 3;
   4262   if ((i & 0x7) == 0 && bits[byte] == all)
   4263     i += 8;
   4264   else
   4265     {
   4266     cbit = (bits[byte] >> (i & 0x7)) & 0x1;
   4267     if (cbit != bit)
   4268       {
   4269       if (length >= MAX_RANGE_SIZE)
   4270         return FALSE;
   4271       ranges[length] = i;
   4272       length++;
   4273       bit = cbit;
   4274       all = -cbit;
   4275       }
   4276     i++;
   4277     }
   4278   }
   4279 
   4280 if (((bit == 0) && nclass) || ((bit == 1) && !nclass))
   4281   {
   4282   if (length >= MAX_RANGE_SIZE)
   4283     return FALSE;
   4284   ranges[length] = 256;
   4285   length++;
   4286   }
   4287 
   4288 if (length < 0 || length > 4)
   4289   return FALSE;
   4290 
   4291 bit = bits[0] & 0x1;
   4292 if (invert) bit ^= 0x1;
   4293 
   4294 /* No character is accepted. */
   4295 if (length == 0 && bit == 0)
   4296   add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   4297 
   4298 switch(length)
   4299   {
   4300   case 0:
   4301   /* When bit != 0, all characters are accepted. */
   4302   return TRUE;
   4303 
   4304   case 1:
   4305   add_jump(compiler, backtracks, CMP(bit == 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
   4306   return TRUE;
   4307 
   4308   case 2:
   4309   if (ranges[0] + 1 != ranges[1])
   4310     {
   4311     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
   4312     add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
   4313     }
   4314   else
   4315     add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
   4316   return TRUE;
   4317 
   4318   case 3:
   4319   if (bit != 0)
   4320     {
   4321     add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
   4322     if (ranges[0] + 1 != ranges[1])
   4323       {
   4324       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
   4325       add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
   4326       }
   4327     else
   4328       add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
   4329     return TRUE;
   4330     }
   4331 
   4332   add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[0]));
   4333   if (ranges[1] + 1 != ranges[2])
   4334     {
   4335     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1]);
   4336     add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
   4337     }
   4338   else
   4339     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1]));
   4340   return TRUE;
   4341 
   4342   case 4:
   4343   if ((ranges[1] - ranges[0]) == (ranges[3] - ranges[2])
   4344       && (ranges[0] | (ranges[2] - ranges[0])) == ranges[2]
   4345       && (ranges[1] & (ranges[2] - ranges[0])) == 0
   4346       && is_powerof2(ranges[2] - ranges[0]))
   4347     {
   4348     SLJIT_ASSERT((ranges[0] & (ranges[2] - ranges[0])) == 0 && (ranges[2] & ranges[3] & (ranges[2] - ranges[0])) != 0);
   4349     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[0]);
   4350     if (ranges[2] + 1 != ranges[3])
   4351       {
   4352       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);
   4353       add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
   4354       }
   4355     else
   4356       add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
   4357     return TRUE;
   4358     }
   4359 
   4360   if (bit != 0)
   4361     {
   4362     i = 0;
   4363     if (ranges[0] + 1 != ranges[1])
   4364       {
   4365       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
   4366       add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
   4367       i = ranges[0];
   4368       }
   4369     else
   4370       add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
   4371 
   4372     if (ranges[2] + 1 != ranges[3])
   4373       {
   4374       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - i);
   4375       add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
   4376       }
   4377     else
   4378       add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2] - i));
   4379     return TRUE;
   4380     }
   4381 
   4382   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
   4383   add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[0]));
   4384   if (ranges[1] + 1 != ranges[2])
   4385     {
   4386     OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]);
   4387     add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
   4388     }
   4389   else
   4390     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
   4391   return TRUE;
   4392 
   4393   default:
   4394   SLJIT_ASSERT_STOP();
   4395   return FALSE;
   4396   }
   4397 }
   4398 
   4399 static void check_anynewline(compiler_common *common)
   4400 {
   4401 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
   4402 DEFINE_COMPILER;
   4403 
   4404 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   4405 
   4406 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
   4407 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
   4408 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
   4409 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
   4410 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   4411 #ifdef COMPILE_PCRE8
   4412 if (common->utf)
   4413   {
   4414 #endif
   4415   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4416   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
   4417   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
   4418 #ifdef COMPILE_PCRE8
   4419   }
   4420 #endif
   4421 #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
   4422 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4423 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   4424 }
   4425 
   4426 static void check_hspace(compiler_common *common)
   4427 {
   4428 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
   4429 DEFINE_COMPILER;
   4430 
   4431 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   4432 
   4433 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);
   4434 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   4435 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
   4436 OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4437 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);
   4438 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   4439 #ifdef COMPILE_PCRE8
   4440 if (common->utf)
   4441   {
   4442 #endif
   4443   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4444   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);
   4445   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4446   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);
   4447   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4448   OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);
   4449   OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);
   4450   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   4451   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);
   4452   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4453   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);
   4454   OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4455   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);
   4456 #ifdef COMPILE_PCRE8
   4457   }
   4458 #endif
   4459 #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
   4460 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4461 
   4462 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   4463 }
   4464 
   4465 static void check_vspace(compiler_common *common)
   4466 {
   4467 /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
   4468 DEFINE_COMPILER;
   4469 
   4470 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   4471 
   4472 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
   4473 OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
   4474 OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
   4475 OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
   4476 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   4477 #ifdef COMPILE_PCRE8
   4478 if (common->utf)
   4479   {
   4480 #endif
   4481   OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4482   OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
   4483   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
   4484 #ifdef COMPILE_PCRE8
   4485   }
   4486 #endif
   4487 #endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
   4488 OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   4489 
   4490 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   4491 }
   4492 
   4493 #define CHAR1 STR_END
   4494 #define CHAR2 STACK_TOP
   4495 
   4496 static void do_casefulcmp(compiler_common *common)
   4497 {
   4498 DEFINE_COMPILER;
   4499 struct sljit_jump *jump;
   4500 struct sljit_label *label;
   4501 
   4502 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   4503 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   4504 OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);
   4505 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, CHAR2, 0);
   4506 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
   4507 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   4508 
   4509 label = LABEL();
   4510 OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));
   4511 OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   4512 jump = CMP(SLJIT_NOT_EQUAL, CHAR1, 0, CHAR2, 0);
   4513 OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
   4514 JUMPTO(SLJIT_NOT_ZERO, label);
   4515 
   4516 JUMPHERE(jump);
   4517 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   4518 OP1(SLJIT_MOV, CHAR1, 0, TMP3, 0);
   4519 OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   4520 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   4521 }
   4522 
   4523 #define LCC_TABLE STACK_LIMIT
   4524 
   4525 static void do_caselesscmp(compiler_common *common)
   4526 {
   4527 DEFINE_COMPILER;
   4528 struct sljit_jump *jump;
   4529 struct sljit_label *label;
   4530 
   4531 sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
   4532 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   4533 
   4534 OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);
   4535 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, CHAR1, 0);
   4536 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, CHAR2, 0);
   4537 OP1(SLJIT_MOV, LCC_TABLE, 0, SLJIT_IMM, common->lcc);
   4538 OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
   4539 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   4540 
   4541 label = LABEL();
   4542 OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));
   4543 OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   4544 #ifndef COMPILE_PCRE8
   4545 jump = CMP(SLJIT_GREATER, CHAR1, 0, SLJIT_IMM, 255);
   4546 #endif
   4547 OP1(SLJIT_MOV_UB, CHAR1, 0, SLJIT_MEM2(LCC_TABLE, CHAR1), 0);
   4548 #ifndef COMPILE_PCRE8
   4549 JUMPHERE(jump);
   4550 jump = CMP(SLJIT_GREATER, CHAR2, 0, SLJIT_IMM, 255);
   4551 #endif
   4552 OP1(SLJIT_MOV_UB, CHAR2, 0, SLJIT_MEM2(LCC_TABLE, CHAR2), 0);
   4553 #ifndef COMPILE_PCRE8
   4554 JUMPHERE(jump);
   4555 #endif
   4556 jump = CMP(SLJIT_NOT_EQUAL, CHAR1, 0, CHAR2, 0);
   4557 OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
   4558 JUMPTO(SLJIT_NOT_ZERO, label);
   4559 
   4560 JUMPHERE(jump);
   4561 OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   4562 OP1(SLJIT_MOV, LCC_TABLE, 0, TMP3, 0);
   4563 OP1(SLJIT_MOV, CHAR1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   4564 OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
   4565 sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
   4566 }
   4567 
   4568 #undef LCC_TABLE
   4569 #undef CHAR1
   4570 #undef CHAR2
   4571 
   4572 #if defined SUPPORT_UTF && defined SUPPORT_UCP
   4573 
   4574 static const pcre_uchar * SLJIT_CALL do_utf_caselesscmp(pcre_uchar *src1, jit_arguments *args, pcre_uchar *end1)
   4575 {
   4576 /* This function would be ineffective to do in JIT level. */
   4577 pcre_uint32 c1, c2;
   4578 const pcre_uchar *src2 = args->uchar_ptr;
   4579 const pcre_uchar *end2 = args->end;
   4580 const ucd_record *ur;
   4581 const pcre_uint32 *pp;
   4582 
   4583 while (src1 < end1)
   4584   {
   4585   if (src2 >= end2)
   4586     return (pcre_uchar*)1;
   4587   GETCHARINC(c1, src1);
   4588   GETCHARINC(c2, src2);
   4589   ur = GET_UCD(c2);
   4590   if (c1 != c2 && c1 != c2 + ur->other_case)
   4591     {
   4592     pp = PRIV(ucd_caseless_sets) + ur->caseset;
   4593     for (;;)
   4594       {
   4595       if (c1 < *pp) return NULL;
   4596       if (c1 == *pp++) break;
   4597       }
   4598     }
   4599   }
   4600 return src2;
   4601 }
   4602 
   4603 #endif /* SUPPORT_UTF && SUPPORT_UCP */
   4604 
   4605 static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,
   4606     compare_context *context, jump_list **backtracks)
   4607 {
   4608 DEFINE_COMPILER;
   4609 unsigned int othercasebit = 0;
   4610 pcre_uchar *othercasechar = NULL;
   4611 #ifdef SUPPORT_UTF
   4612 int utflength;
   4613 #endif
   4614 
   4615 if (caseless && char_has_othercase(common, cc))
   4616   {
   4617   othercasebit = char_get_othercase_bit(common, cc);
   4618   SLJIT_ASSERT(othercasebit);
   4619   /* Extracting bit difference info. */
   4620 #if defined COMPILE_PCRE8
   4621   othercasechar = cc + (othercasebit >> 8);
   4622   othercasebit &= 0xff;
   4623 #elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   4624   /* Note that this code only handles characters in the BMP. If there
   4625   ever are characters outside the BMP whose othercase differs in only one
   4626   bit from itself (there currently are none), this code will need to be
   4627   revised for COMPILE_PCRE32. */
   4628   othercasechar = cc + (othercasebit >> 9);
   4629   if ((othercasebit & 0x100) != 0)
   4630     othercasebit = (othercasebit & 0xff) << 8;
   4631   else
   4632     othercasebit &= 0xff;
   4633 #endif /* COMPILE_PCRE[8|16|32] */
   4634   }
   4635 
   4636 if (context->sourcereg == -1)
   4637   {
   4638 #if defined COMPILE_PCRE8
   4639 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
   4640   if (context->length >= 4)
   4641     OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4642   else if (context->length >= 2)
   4643     OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4644   else
   4645 #endif
   4646     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4647 #elif defined COMPILE_PCRE16
   4648 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
   4649   if (context->length >= 4)
   4650     OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4651   else
   4652 #endif
   4653     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4654 #elif defined COMPILE_PCRE32
   4655   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4656 #endif /* COMPILE_PCRE[8|16|32] */
   4657   context->sourcereg = TMP2;
   4658   }
   4659 
   4660 #ifdef SUPPORT_UTF
   4661 utflength = 1;
   4662 if (common->utf && HAS_EXTRALEN(*cc))
   4663   utflength += GET_EXTRALEN(*cc);
   4664 
   4665 do
   4666   {
   4667 #endif
   4668 
   4669   context->length -= IN_UCHARS(1);
   4670 #if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED) && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)
   4671 
   4672   /* Unaligned read is supported. */
   4673   if (othercasebit != 0 && othercasechar == cc)
   4674     {
   4675     context->c.asuchars[context->ucharptr] = *cc | othercasebit;
   4676     context->oc.asuchars[context->ucharptr] = othercasebit;
   4677     }
   4678   else
   4679     {
   4680     context->c.asuchars[context->ucharptr] = *cc;
   4681     context->oc.asuchars[context->ucharptr] = 0;
   4682     }
   4683   context->ucharptr++;
   4684 
   4685 #if defined COMPILE_PCRE8
   4686   if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1))
   4687 #else
   4688   if (context->ucharptr >= 2 || context->length == 0)
   4689 #endif
   4690     {
   4691     if (context->length >= 4)
   4692       OP1(SLJIT_MOV_SI, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4693     else if (context->length >= 2)
   4694       OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4695 #if defined COMPILE_PCRE8
   4696     else if (context->length >= 1)
   4697       OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4698 #endif /* COMPILE_PCRE8 */
   4699     context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
   4700 
   4701     switch(context->ucharptr)
   4702       {
   4703       case 4 / sizeof(pcre_uchar):
   4704       if (context->oc.asint != 0)
   4705         OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);
   4706       add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
   4707       break;
   4708 
   4709       case 2 / sizeof(pcre_uchar):
   4710       if (context->oc.asushort != 0)
   4711         OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);
   4712       add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));
   4713       break;
   4714 
   4715 #ifdef COMPILE_PCRE8
   4716       case 1:
   4717       if (context->oc.asbyte != 0)
   4718         OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);
   4719       add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
   4720       break;
   4721 #endif
   4722 
   4723       default:
   4724       SLJIT_ASSERT_STOP();
   4725       break;
   4726       }
   4727     context->ucharptr = 0;
   4728     }
   4729 
   4730 #else
   4731 
   4732   /* Unaligned read is unsupported or in 32 bit mode. */
   4733   if (context->length >= 1)
   4734     OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
   4735 
   4736   context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
   4737 
   4738   if (othercasebit != 0 && othercasechar == cc)
   4739     {
   4740     OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);
   4741     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
   4742     }
   4743   else
   4744     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
   4745 
   4746 #endif
   4747 
   4748   cc++;
   4749 #ifdef SUPPORT_UTF
   4750   utflength--;
   4751   }
   4752 while (utflength > 0);
   4753 #endif
   4754 
   4755 return cc;
   4756 }
   4757 
   4758 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   4759 
   4760 #define SET_TYPE_OFFSET(value) \
   4761   if ((value) != typeoffset) \
   4762     { \
   4763     if ((value) < typeoffset) \
   4764       OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \
   4765     else \
   4766       OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \
   4767     } \
   4768   typeoffset = (value);
   4769 
   4770 #define SET_CHAR_OFFSET(value) \
   4771   if ((value) != charoffset) \
   4772     { \
   4773     if ((value) < charoffset) \
   4774       OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(charoffset - (value))); \
   4775     else \
   4776       OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)((value) - charoffset)); \
   4777     } \
   4778   charoffset = (value);
   4779 
   4780 static void compile_xclass_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
   4781 {
   4782 DEFINE_COMPILER;
   4783 jump_list *found = NULL;
   4784 jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks;
   4785 sljit_uw c, charoffset, max = 256, min = READ_CHAR_MAX;
   4786 struct sljit_jump *jump = NULL;
   4787 pcre_uchar *ccbegin;
   4788 int compares, invertcmp, numberofcmps;
   4789 #if defined SUPPORT_UTF && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)
   4790 BOOL utf = common->utf;
   4791 #endif
   4792 
   4793 #ifdef SUPPORT_UCP
   4794 BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
   4795 BOOL charsaved = FALSE;
   4796 int typereg = TMP1, scriptreg = TMP1;
   4797 const pcre_uint32 *other_cases;
   4798 sljit_uw typeoffset;
   4799 #endif
   4800 
   4801 /* Scanning the necessary info. */
   4802 cc++;
   4803 ccbegin = cc;
   4804 compares = 0;
   4805 if (cc[-1] & XCL_MAP)
   4806   {
   4807   min = 0;
   4808   cc += 32 / sizeof(pcre_uchar);
   4809   }
   4810 
   4811 while (*cc != XCL_END)
   4812   {
   4813   compares++;
   4814   if (*cc == XCL_SINGLE)
   4815     {
   4816     cc ++;
   4817     GETCHARINCTEST(c, cc);
   4818     if (c > max) max = c;
   4819     if (c < min) min = c;
   4820 #ifdef SUPPORT_UCP
   4821     needschar = TRUE;
   4822 #endif
   4823     }
   4824   else if (*cc == XCL_RANGE)
   4825     {
   4826     cc ++;
   4827     GETCHARINCTEST(c, cc);
   4828     if (c < min) min = c;
   4829     GETCHARINCTEST(c, cc);
   4830     if (c > max) max = c;
   4831 #ifdef SUPPORT_UCP
   4832     needschar = TRUE;
   4833 #endif
   4834     }
   4835 #ifdef SUPPORT_UCP
   4836   else
   4837     {
   4838     SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
   4839     cc++;
   4840     if (*cc == PT_CLIST)
   4841       {
   4842       other_cases = PRIV(ucd_caseless_sets) + cc[1];
   4843       while (*other_cases != NOTACHAR)
   4844         {
   4845         if (*other_cases > max) max = *other_cases;
   4846         if (*other_cases < min) min = *other_cases;
   4847         other_cases++;
   4848         }
   4849       }
   4850     else
   4851       {
   4852       max = READ_CHAR_MAX;
   4853       min = 0;
   4854       }
   4855 
   4856     switch(*cc)
   4857       {
   4858       case PT_ANY:
   4859       break;
   4860 
   4861       case PT_LAMP:
   4862       case PT_GC:
   4863       case PT_PC:
   4864       case PT_ALNUM:
   4865       needstype = TRUE;
   4866       break;
   4867 
   4868       case PT_SC:
   4869       needsscript = TRUE;
   4870       break;
   4871 
   4872       case PT_SPACE:
   4873       case PT_PXSPACE:
   4874       case PT_WORD:
   4875       case PT_PXGRAPH:
   4876       case PT_PXPRINT:
   4877       case PT_PXPUNCT:
   4878       needstype = TRUE;
   4879       needschar = TRUE;
   4880       break;
   4881 
   4882       case PT_CLIST:
   4883       case PT_UCNC:
   4884       needschar = TRUE;
   4885       break;
   4886 
   4887       default:
   4888       SLJIT_ASSERT_STOP();
   4889       break;
   4890       }
   4891     cc += 2;
   4892     }
   4893 #endif
   4894   }
   4895 
   4896 /* We are not necessary in utf mode even in 8 bit mode. */
   4897 cc = ccbegin;
   4898 detect_partial_match(common, backtracks);
   4899 read_char_range(common, min, max, (cc[-1] & XCL_NOT) != 0);
   4900 
   4901 if ((cc[-1] & XCL_HASPROP) == 0)
   4902   {
   4903   if ((cc[-1] & XCL_MAP) != 0)
   4904     {
   4905     jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
   4906     if (!check_class_ranges(common, (const pcre_uint8 *)cc, (((const pcre_uint8 *)cc)[31] & 0x80) != 0, TRUE, &found))
   4907       {
   4908       OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
   4909       OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
   4910       OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
   4911       OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
   4912       OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
   4913       add_jump(compiler, &found, JUMP(SLJIT_NOT_ZERO));
   4914       }
   4915 
   4916     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   4917     JUMPHERE(jump);
   4918 
   4919     cc += 32 / sizeof(pcre_uchar);
   4920     }
   4921   else
   4922     {
   4923     OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, min);
   4924     add_jump(compiler, (cc[-1] & XCL_NOT) == 0 ? backtracks : &found, CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, max - min));
   4925     }
   4926   }
   4927 else if ((cc[-1] & XCL_MAP) != 0)
   4928   {
   4929   OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
   4930 #ifdef SUPPORT_UCP
   4931   charsaved = TRUE;
   4932 #endif
   4933   if (!check_class_ranges(common, (const pcre_uint8 *)cc, FALSE, TRUE, list))
   4934     {
   4935 #ifdef COMPILE_PCRE8
   4936     jump = NULL;
   4937     if (common->utf)
   4938 #endif
   4939       jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
   4940 
   4941     OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
   4942     OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
   4943     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
   4944     OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
   4945     OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
   4946     add_jump(compiler, list, JUMP(SLJIT_NOT_ZERO));
   4947 
   4948 #ifdef COMPILE_PCRE8
   4949     if (common->utf)
   4950 #endif
   4951       JUMPHERE(jump);
   4952     }
   4953 
   4954   OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
   4955   cc += 32 / sizeof(pcre_uchar);
   4956   }
   4957 
   4958 #ifdef SUPPORT_UCP
   4959 /* Simple register allocation. TMP1 is preferred if possible. */
   4960 if (needstype || needsscript)
   4961   {
   4962   if (needschar && !charsaved)
   4963     OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
   4964   add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
   4965   if (needschar)
   4966     {
   4967     if (needstype)
   4968       {
   4969       OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
   4970       typereg = RETURN_ADDR;
   4971       }
   4972 
   4973     if (needsscript)
   4974       scriptreg = TMP3;
   4975     OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
   4976     }
   4977   else if (needstype && needsscript)
   4978     scriptreg = TMP3;
   4979   /* In all other cases only one of them was specified, and that can goes to TMP1. */
   4980 
   4981   if (needsscript)
   4982     {
   4983     if (scriptreg == TMP1)
   4984       {
   4985       OP1(SLJIT_MOV, scriptreg, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
   4986       OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM2(scriptreg, TMP2), 3);
   4987       }
   4988     else
   4989       {
   4990       OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
   4991       OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
   4992       OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM1(TMP2), 0);
   4993       }
   4994     }
   4995   }
   4996 #endif
   4997 
   4998 /* Generating code. */
   4999 charoffset = 0;
   5000 numberofcmps = 0;
   5001 #ifdef SUPPORT_UCP
   5002 typeoffset = 0;
   5003 #endif
   5004 
   5005 while (*cc != XCL_END)
   5006   {
   5007   compares--;
   5008   invertcmp = (compares == 0 && list != backtracks);
   5009   jump = NULL;
   5010 
   5011   if (*cc == XCL_SINGLE)
   5012     {
   5013     cc ++;
   5014     GETCHARINCTEST(c, cc);
   5015 
   5016     if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
   5017       {
   5018       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
   5019       OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_EQUAL);
   5020       numberofcmps++;
   5021       }
   5022     else if (numberofcmps > 0)
   5023       {
   5024       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
   5025       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5026       jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
   5027       numberofcmps = 0;
   5028       }
   5029     else
   5030       {
   5031       jump = CMP(SLJIT_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
   5032       numberofcmps = 0;
   5033       }
   5034     }
   5035   else if (*cc == XCL_RANGE)
   5036     {
   5037     cc ++;
   5038     GETCHARINCTEST(c, cc);
   5039     SET_CHAR_OFFSET(c);
   5040     GETCHARINCTEST(c, cc);
   5041 
   5042     if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
   5043       {
   5044       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
   5045       OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_LESS_EQUAL);
   5046       numberofcmps++;
   5047       }
   5048     else if (numberofcmps > 0)
   5049       {
   5050       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
   5051       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   5052       jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
   5053       numberofcmps = 0;
   5054       }
   5055     else
   5056       {
   5057       jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
   5058       numberofcmps = 0;
   5059       }
   5060     }
   5061 #ifdef SUPPORT_UCP
   5062   else
   5063     {
   5064     if (*cc == XCL_NOTPROP)
   5065       invertcmp ^= 0x1;
   5066     cc++;
   5067     switch(*cc)
   5068       {
   5069       case PT_ANY:
   5070       if (list != backtracks)
   5071         {
   5072         if ((cc[-1] == XCL_NOTPROP && compares > 0) || (cc[-1] == XCL_PROP && compares == 0))
   5073           continue;
   5074         }
   5075       else if (cc[-1] == XCL_NOTPROP)
   5076         continue;
   5077       jump = JUMP(SLJIT_JUMP);
   5078       break;
   5079 
   5080       case PT_LAMP:
   5081       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - typeoffset);
   5082       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   5083       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ll - typeoffset);
   5084       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5085       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lt - typeoffset);
   5086       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5087       jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
   5088       break;
   5089 
   5090       case PT_GC:
   5091       c = PRIV(ucp_typerange)[(int)cc[1] * 2];
   5092       SET_TYPE_OFFSET(c);
   5093       jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c);
   5094       break;
   5095 
   5096       case PT_PC:
   5097       jump = CMP(SLJIT_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset);
   5098       break;
   5099 
   5100       case PT_SC:
   5101       jump = CMP(SLJIT_EQUAL ^ invertcmp, scriptreg, 0, SLJIT_IMM, (int)cc[1]);
   5102       break;
   5103 
   5104       case PT_SPACE:
   5105       case PT_PXSPACE:
   5106       SET_CHAR_OFFSET(9);
   5107       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd - 0x9);
   5108       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
   5109 
   5110       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x9);
   5111       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5112 
   5113       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x9);
   5114       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5115 
   5116       SET_TYPE_OFFSET(ucp_Zl);
   5117       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);
   5118       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   5119       jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
   5120       break;
   5121 
   5122       case PT_WORD:
   5123       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_UNDERSCORE - charoffset));
   5124       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   5125       /* Fall through. */
   5126 
   5127       case PT_ALNUM:
   5128       SET_TYPE_OFFSET(ucp_Ll);
   5129       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
   5130       OP_FLAGS((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, (*cc == PT_ALNUM) ? SLJIT_UNUSED : TMP2, 0, SLJIT_LESS_EQUAL);
   5131       SET_TYPE_OFFSET(ucp_Nd);
   5132       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_No - ucp_Nd);
   5133       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   5134       jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
   5135       break;
   5136 
   5137       case PT_CLIST:
   5138       other_cases = PRIV(ucd_caseless_sets) + cc[1];
   5139 
   5140       /* At least three characters are required.
   5141          Otherwise this case would be handled by the normal code path. */
   5142       SLJIT_ASSERT(other_cases[0] != NOTACHAR && other_cases[1] != NOTACHAR && other_cases[2] != NOTACHAR);
   5143       SLJIT_ASSERT(other_cases[0] < other_cases[1] && other_cases[1] < other_cases[2]);
   5144 
   5145       /* Optimizing character pairs, if their difference is power of 2. */
   5146       if (is_powerof2(other_cases[1] ^ other_cases[0]))
   5147         {
   5148         if (charoffset == 0)
   5149           OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
   5150         else
   5151           {
   5152           OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);
   5153           OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
   5154           }
   5155         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[1]);
   5156         OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   5157         other_cases += 2;
   5158         }
   5159       else if (is_powerof2(other_cases[2] ^ other_cases[1]))
   5160         {
   5161         if (charoffset == 0)
   5162           OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[2] ^ other_cases[1]);
   5163         else
   5164           {
   5165           OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);
   5166           OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
   5167           }
   5168         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]);
   5169         OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   5170 
   5171         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(other_cases[0] - charoffset));
   5172         OP_FLAGS(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5173 
   5174         other_cases += 3;
   5175         }
   5176       else
   5177         {
   5178         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset));
   5179         OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   5180         }
   5181 
   5182       while (*other_cases != NOTACHAR)
   5183         {
   5184         OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset));
   5185         OP_FLAGS(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5186         }
   5187       jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
   5188       break;
   5189 
   5190       case PT_UCNC:
   5191       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_DOLLAR_SIGN - charoffset));
   5192       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   5193       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_COMMERCIAL_AT - charoffset));
   5194       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5195       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_GRAVE_ACCENT - charoffset));
   5196       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5197 
   5198       SET_CHAR_OFFSET(0xa0);
   5199       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(0xd7ff - charoffset));
   5200       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   5201       SET_CHAR_OFFSET(0);
   5202       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);
   5203       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_GREATER_EQUAL);
   5204       jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
   5205       break;
   5206 
   5207       case PT_PXGRAPH:
   5208       /* C and Z groups are the farthest two groups. */
   5209       SET_TYPE_OFFSET(ucp_Ll);
   5210       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);
   5211       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_GREATER);
   5212 
   5213       jump = CMP(SLJIT_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);
   5214 
   5215       /* In case of ucp_Cf, we overwrite the result. */
   5216       SET_CHAR_OFFSET(0x2066);
   5217       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);
   5218       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
   5219 
   5220       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);
   5221       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5222 
   5223       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x2066);
   5224       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5225 
   5226       JUMPHERE(jump);
   5227       jump = CMP(SLJIT_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);
   5228       break;
   5229 
   5230       case PT_PXPRINT:
   5231       /* C and Z groups are the farthest two groups. */
   5232       SET_TYPE_OFFSET(ucp_Ll);
   5233       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);
   5234       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_GREATER);
   5235 
   5236       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Ll);
   5237       OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_NOT_EQUAL);
   5238 
   5239       jump = CMP(SLJIT_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);
   5240 
   5241       /* In case of ucp_Cf, we overwrite the result. */
   5242       SET_CHAR_OFFSET(0x2066);
   5243       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);
   5244       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
   5245 
   5246       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);
   5247       OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_EQUAL);
   5248 
   5249       JUMPHERE(jump);
   5250       jump = CMP(SLJIT_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);
   5251       break;
   5252 
   5253       case PT_PXPUNCT:
   5254       SET_TYPE_OFFSET(ucp_Sc);
   5255       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Sc);
   5256       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS_EQUAL);
   5257 
   5258       SET_CHAR_OFFSET(0);
   5259       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x7f);
   5260       OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   5261 
   5262       SET_TYPE_OFFSET(ucp_Pc);
   5263       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ps - ucp_Pc);
   5264       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_LESS_EQUAL);
   5265       jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
   5266       break;
   5267       }
   5268     cc += 2;
   5269     }
   5270 #endif
   5271 
   5272   if (jump != NULL)
   5273     add_jump(compiler, compares > 0 ? list : backtracks, jump);
   5274   }
   5275 
   5276 if (found != NULL)
   5277   set_jumps(found, LABEL());
   5278 }
   5279 
   5280 #undef SET_TYPE_OFFSET
   5281 #undef SET_CHAR_OFFSET
   5282 
   5283 #endif
   5284 
   5285 static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)
   5286 {
   5287 DEFINE_COMPILER;
   5288 int length;
   5289 unsigned int c, oc, bit;
   5290 compare_context context;
   5291 struct sljit_jump *jump[4];
   5292 jump_list *end_list;
   5293 #ifdef SUPPORT_UTF
   5294 struct sljit_label *label;
   5295 #ifdef SUPPORT_UCP
   5296 pcre_uchar propdata[5];
   5297 #endif
   5298 #endif /* SUPPORT_UTF */
   5299 
   5300 switch(type)
   5301   {
   5302   case OP_SOD:
   5303   OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   5304   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
   5305   add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
   5306   return cc;
   5307 
   5308   case OP_SOM:
   5309   OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   5310   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
   5311   add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
   5312   return cc;
   5313 
   5314   case OP_NOT_WORD_BOUNDARY:
   5315   case OP_WORD_BOUNDARY:
   5316   add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL));
   5317   add_jump(compiler, backtracks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_NOT_ZERO : SLJIT_ZERO));
   5318   return cc;
   5319 
   5320   case OP_NOT_DIGIT:
   5321   case OP_DIGIT:
   5322   /* Digits are usually 0-9, so it is worth to optimize them. */
   5323   detect_partial_match(common, backtracks);
   5324 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   5325   if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_digit, FALSE))
   5326     read_char7_type(common, type == OP_NOT_DIGIT);
   5327   else
   5328 #endif
   5329     read_char8_type(common, type == OP_NOT_DIGIT);
   5330     /* Flip the starting bit in the negative case. */
   5331   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
   5332   add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_ZERO : SLJIT_NOT_ZERO));
   5333   return cc;
   5334 
   5335   case OP_NOT_WHITESPACE:
   5336   case OP_WHITESPACE:
   5337   detect_partial_match(common, backtracks);
   5338 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   5339   if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_space, FALSE))
   5340     read_char7_type(common, type == OP_NOT_WHITESPACE);
   5341   else
   5342 #endif
   5343     read_char8_type(common, type == OP_NOT_WHITESPACE);
   5344   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);
   5345   add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_ZERO : SLJIT_NOT_ZERO));
   5346   return cc;
   5347 
   5348   case OP_NOT_WORDCHAR:
   5349   case OP_WORDCHAR:
   5350   detect_partial_match(common, backtracks);
   5351 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   5352   if (common->utf && is_char7_bitset((const pcre_uint8*)common->ctypes - cbit_length + cbit_word, FALSE))
   5353     read_char7_type(common, type == OP_NOT_WORDCHAR);
   5354   else
   5355 #endif
   5356     read_char8_type(common, type == OP_NOT_WORDCHAR);
   5357   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);
   5358   add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_ZERO : SLJIT_NOT_ZERO));
   5359   return cc;
   5360 
   5361   case OP_ANY:
   5362   detect_partial_match(common, backtracks);
   5363   read_char_range(common, common->nlmin, common->nlmax, TRUE);
   5364   if (common->nltype == NLTYPE_FIXED && common->newline > 255)
   5365     {
   5366     jump[0] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
   5367     end_list = NULL;
   5368     if (common->mode != JIT_PARTIAL_HARD_COMPILE)
   5369       add_jump(compiler, &end_list, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
   5370     else
   5371       check_str_end(common, &end_list);
   5372 
   5373     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   5374     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
   5375     set_jumps(end_list, LABEL());
   5376     JUMPHERE(jump[0]);
   5377     }
   5378   else
   5379     check_newlinechar(common, common->nltype, backtracks, TRUE);
   5380   return cc;
   5381 
   5382   case OP_ALLANY:
   5383   detect_partial_match(common, backtracks);
   5384 #ifdef SUPPORT_UTF
   5385   if (common->utf)
   5386     {
   5387     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   5388     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   5389 #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
   5390 #if defined COMPILE_PCRE8
   5391     jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
   5392     OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   5393     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   5394 #elif defined COMPILE_PCRE16
   5395     jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
   5396     OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
   5397     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
   5398     OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_EQUAL);
   5399     OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   5400     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   5401 #endif
   5402     JUMPHERE(jump[0]);
   5403 #endif /* COMPILE_PCRE[8|16] */
   5404     return cc;
   5405     }
   5406 #endif
   5407   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   5408   return cc;
   5409 
   5410   case OP_ANYBYTE:
   5411   detect_partial_match(common, backtracks);
   5412   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   5413   return cc;
   5414 
   5415 #ifdef SUPPORT_UTF
   5416 #ifdef SUPPORT_UCP
   5417   case OP_NOTPROP:
   5418   case OP_PROP:
   5419   propdata[0] = XCL_HASPROP;
   5420   propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;
   5421   propdata[2] = cc[0];
   5422   propdata[3] = cc[1];
   5423   propdata[4] = XCL_END;
   5424   compile_xclass_matchingpath(common, propdata, backtracks);
   5425   return cc + 2;
   5426 #endif
   5427 #endif
   5428 
   5429   case OP_ANYNL:
   5430   detect_partial_match(common, backtracks);
   5431   read_char_range(common, common->bsr_nlmin, common->bsr_nlmax, FALSE);
   5432   jump[0] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
   5433   /* We don't need to handle soft partial matching case. */
   5434   end_list = NULL;
   5435   if (common->mode != JIT_PARTIAL_HARD_COMPILE)
   5436     add_jump(compiler, &end_list, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
   5437   else
   5438     check_str_end(common, &end_list);
   5439   OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   5440   jump[1] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
   5441   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   5442   jump[2] = JUMP(SLJIT_JUMP);
   5443   JUMPHERE(jump[0]);
   5444   check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);
   5445   set_jumps(end_list, LABEL());
   5446   JUMPHERE(jump[1]);
   5447   JUMPHERE(jump[2]);
   5448   return cc;
   5449 
   5450   case OP_NOT_HSPACE:
   5451   case OP_HSPACE:
   5452   detect_partial_match(common, backtracks);
   5453   read_char_range(common, 0x9, 0x3000, type == OP_NOT_HSPACE);
   5454   add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));
   5455   add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_NOT_ZERO : SLJIT_ZERO));
   5456   return cc;
   5457 
   5458   case OP_NOT_VSPACE:
   5459   case OP_VSPACE:
   5460   detect_partial_match(common, backtracks);
   5461   read_char_range(common, 0xa, 0x2029, type == OP_NOT_VSPACE);
   5462   add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));
   5463   add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_NOT_ZERO : SLJIT_ZERO));
   5464   return cc;
   5465 
   5466 #ifdef SUPPORT_UCP
   5467   case OP_EXTUNI:
   5468   detect_partial_match(common, backtracks);
   5469   read_char(common);
   5470   add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
   5471   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
   5472   /* Optimize register allocation: use a real register. */
   5473   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);
   5474   OP1(SLJIT_MOV_UB, STACK_TOP, 0, SLJIT_MEM2(TMP1, TMP2), 3);
   5475 
   5476   label = LABEL();
   5477   jump[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   5478   OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
   5479   read_char(common);
   5480   add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
   5481   OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
   5482   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM2(TMP1, TMP2), 3);
   5483 
   5484   OP2(SLJIT_SHL, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 2);
   5485   OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(STACK_TOP), (sljit_sw)PRIV(ucp_gbtable));
   5486   OP1(SLJIT_MOV, STACK_TOP, 0, TMP2, 0);
   5487   OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
   5488   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
   5489   JUMPTO(SLJIT_NOT_ZERO, label);
   5490 
   5491   OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
   5492   JUMPHERE(jump[0]);
   5493   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   5494 
   5495   if (common->mode == JIT_PARTIAL_HARD_COMPILE)
   5496     {
   5497     jump[0] = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
   5498     /* Since we successfully read a char above, partial matching must occure. */
   5499     check_partial(common, TRUE);
   5500     JUMPHERE(jump[0]);
   5501     }
   5502   return cc;
   5503 #endif
   5504 
   5505   case OP_EODN:
   5506   /* Requires rather complex checks. */
   5507   jump[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
   5508   if (common->nltype == NLTYPE_FIXED && common->newline > 255)
   5509     {
   5510     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
   5511     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   5512     if (common->mode == JIT_COMPILE)
   5513       add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_END, 0));
   5514     else
   5515       {
   5516       jump[1] = CMP(SLJIT_EQUAL, TMP2, 0, STR_END, 0);
   5517       OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
   5518       OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_LESS);
   5519       OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
   5520       OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_NOT_EQUAL);
   5521       add_jump(compiler, backtracks, JUMP(SLJIT_NOT_EQUAL));
   5522       check_partial(common, TRUE);
   5523       add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   5524       JUMPHERE(jump[1]);
   5525       }
   5526     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   5527     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
   5528     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
   5529     }
   5530   else if (common->nltype == NLTYPE_FIXED)
   5531     {
   5532     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   5533     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   5534     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_END, 0));
   5535     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
   5536     }
   5537   else
   5538     {
   5539     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   5540     jump[1] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
   5541     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
   5542     OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
   5543     jump[2] = JUMP(SLJIT_GREATER);
   5544     add_jump(compiler, backtracks, JUMP(SLJIT_LESS));
   5545     /* Equal. */
   5546     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   5547     jump[3] = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
   5548     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   5549 
   5550     JUMPHERE(jump[1]);
   5551     if (common->nltype == NLTYPE_ANYCRLF)
   5552       {
   5553       OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   5554       add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP2, 0, STR_END, 0));
   5555       add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
   5556       }
   5557     else
   5558       {
   5559       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, STR_PTR, 0);
   5560       read_char_range(common, common->nlmin, common->nlmax, TRUE);
   5561       add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
   5562       add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
   5563       add_jump(compiler, backtracks, JUMP(SLJIT_ZERO));
   5564       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
   5565       }
   5566     JUMPHERE(jump[2]);
   5567     JUMPHERE(jump[3]);
   5568     }
   5569   JUMPHERE(jump[0]);
   5570   check_partial(common, FALSE);
   5571   return cc;
   5572 
   5573   case OP_EOD:
   5574   add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0));
   5575   check_partial(common, FALSE);
   5576   return cc;
   5577 
   5578   case OP_CIRC:
   5579   OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
   5580   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
   5581   add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, TMP1, 0));
   5582   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
   5583   add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
   5584   return cc;
   5585 
   5586   case OP_CIRCM:
   5587   OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
   5588   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
   5589   jump[1] = CMP(SLJIT_GREATER, STR_PTR, 0, TMP1, 0);
   5590   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
   5591   add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
   5592   jump[0] = JUMP(SLJIT_JUMP);
   5593   JUMPHERE(jump[1]);
   5594 
   5595   add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
   5596   if (common->nltype == NLTYPE_FIXED && common->newline > 255)
   5597     {
   5598     OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
   5599     add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP2, 0, TMP1, 0));
   5600     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
   5601     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
   5602     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
   5603     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
   5604     }
   5605   else
   5606     {
   5607     skip_char_back(common);
   5608     read_char_range(common, common->nlmin, common->nlmax, TRUE);
   5609     check_newlinechar(common, common->nltype, backtracks, FALSE);
   5610     }
   5611   JUMPHERE(jump[0]);
   5612   return cc;
   5613 
   5614   case OP_DOLL:
   5615   OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
   5616   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
   5617   add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
   5618 
   5619   if (!common->endonly)
   5620     compile_char1_matchingpath(common, OP_EODN, cc, backtracks);
   5621   else
   5622     {
   5623     add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0));
   5624     check_partial(common, FALSE);
   5625     }
   5626   return cc;
   5627 
   5628   case OP_DOLLM:
   5629   jump[1] = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
   5630   OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
   5631   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
   5632   add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
   5633   check_partial(common, FALSE);
   5634   jump[0] = JUMP(SLJIT_JUMP);
   5635   JUMPHERE(jump[1]);
   5636 
   5637   if (common->nltype == NLTYPE_FIXED && common->newline > 255)
   5638     {
   5639     OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
   5640     OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
   5641     if (common->mode == JIT_COMPILE)
   5642       add_jump(compiler, backtracks, CMP(SLJIT_GREATER, TMP2, 0, STR_END, 0));
   5643     else
   5644       {
   5645       jump[1] = CMP(SLJIT_LESS_EQUAL, TMP2, 0, STR_END, 0);
   5646       /* STR_PTR = STR_END - IN_UCHARS(1) */
   5647       add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
   5648       check_partial(common, TRUE);
   5649       add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   5650       JUMPHERE(jump[1]);
   5651       }
   5652 
   5653     OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
   5654     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
   5655     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
   5656     }
   5657   else
   5658     {
   5659     peek_char(common, common->nlmax);
   5660     check_newlinechar(common, common->nltype, backtracks, FALSE);
   5661     }
   5662   JUMPHERE(jump[0]);
   5663   return cc;
   5664 
   5665   case OP_CHAR:
   5666   case OP_CHARI:
   5667   length = 1;
   5668 #ifdef SUPPORT_UTF
   5669   if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);
   5670 #endif
   5671   if (common->mode == JIT_COMPILE && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))
   5672     {
   5673     OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
   5674     add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0));
   5675 
   5676     context.length = IN_UCHARS(length);
   5677     context.sourcereg = -1;
   5678 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
   5679     context.ucharptr = 0;
   5680 #endif
   5681     return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);
   5682     }
   5683 
   5684   detect_partial_match(common, backtracks);
   5685 #ifdef SUPPORT_UTF
   5686   if (common->utf)
   5687     {
   5688     GETCHAR(c, cc);
   5689     }
   5690   else
   5691 #endif
   5692     c = *cc;
   5693 
   5694   if (type == OP_CHAR || !char_has_othercase(common, cc))
   5695     {
   5696     read_char_range(common, c, c, FALSE);
   5697     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
   5698     return cc + length;
   5699     }
   5700   oc = char_othercase(common, c);
   5701   read_char_range(common, c < oc ? c : oc, c > oc ? c : oc, FALSE);
   5702   bit = c ^ oc;
   5703   if (is_powerof2(bit))
   5704     {
   5705     OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
   5706     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
   5707     return cc + length;
   5708     }
   5709   jump[0] = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c);
   5710   add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, oc));
   5711   JUMPHERE(jump[0]);
   5712   return cc + length;
   5713 
   5714   case OP_NOT:
   5715   case OP_NOTI:
   5716   detect_partial_match(common, backtracks);
   5717   length = 1;
   5718 #ifdef SUPPORT_UTF
   5719   if (common->utf)
   5720     {
   5721 #ifdef COMPILE_PCRE8
   5722     c = *cc;
   5723     if (c < 128)
   5724       {
   5725       OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
   5726       if (type == OP_NOT || !char_has_othercase(common, cc))
   5727         add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));
   5728       else
   5729         {
   5730         /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */
   5731         OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20);
   5732         add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));
   5733         }
   5734       /* Skip the variable-length character. */
   5735       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
   5736       jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
   5737       OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
   5738       OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
   5739       JUMPHERE(jump[0]);
   5740       return cc + 1;
   5741       }
   5742     else
   5743 #endif /* COMPILE_PCRE8 */
   5744       {
   5745       GETCHARLEN(c, cc, length);
   5746       }
   5747     }
   5748   else
   5749 #endif /* SUPPORT_UTF */
   5750     c = *cc;
   5751 
   5752   if (type == OP_NOT || !char_has_othercase(common, cc))
   5753     {
   5754     read_char_range(common, c, c, TRUE);
   5755     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));
   5756     }
   5757   else
   5758     {
   5759     oc = char_othercase(common, c);
   5760     read_char_range(common, c < oc ? c : oc, c > oc ? c : oc, TRUE);
   5761     bit = c ^ oc;
   5762     if (is_powerof2(bit))
   5763       {
   5764       OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
   5765       add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
   5766       }
   5767     else
   5768       {
   5769       add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));
   5770       add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, oc));
   5771       }
   5772     }
   5773   return cc + length;
   5774 
   5775   case OP_CLASS:
   5776   case OP_NCLASS:
   5777   detect_partial_match(common, backtracks);
   5778 
   5779 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   5780   bit = (common->utf && is_char7_bitset((const pcre_uint8 *)cc, type == OP_NCLASS)) ? 127 : 255;
   5781   read_char_range(common, 0, bit, type == OP_NCLASS);
   5782 #else
   5783   read_char_range(common, 0, 255, type == OP_NCLASS);
   5784 #endif
   5785 
   5786   if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, FALSE, backtracks))
   5787     return cc + 32 / sizeof(pcre_uchar);
   5788 
   5789 #if defined SUPPORT_UTF && defined COMPILE_PCRE8
   5790   jump[0] = NULL;
   5791   if (common->utf)
   5792     {
   5793     jump[0] = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, bit);
   5794     if (type == OP_CLASS)
   5795       {
   5796       add_jump(compiler, backtracks, jump[0]);
   5797       jump[0] = NULL;
   5798       }
   5799     }
   5800 #elif !defined COMPILE_PCRE8
   5801   jump[0] = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
   5802   if (type == OP_CLASS)
   5803     {
   5804     add_jump(compiler, backtracks, jump[0]);
   5805     jump[0] = NULL;
   5806     }
   5807 #endif /* SUPPORT_UTF && COMPILE_PCRE8 */
   5808 
   5809   OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
   5810   OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
   5811   OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
   5812   OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
   5813   OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
   5814   add_jump(compiler, backtracks, JUMP(SLJIT_ZERO));
   5815 
   5816 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   5817   if (jump[0] != NULL)
   5818     JUMPHERE(jump[0]);
   5819 #endif
   5820 
   5821   return cc + 32 / sizeof(pcre_uchar);
   5822 
   5823 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   5824   case OP_XCLASS:
   5825   compile_xclass_matchingpath(common, cc + LINK_SIZE, backtracks);
   5826   return cc + GET(cc, 0) - 1;
   5827 #endif
   5828 
   5829   case OP_REVERSE:
   5830   length = GET(cc, 0);
   5831   if (length == 0)
   5832     return cc + LINK_SIZE;
   5833   OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   5834 #ifdef SUPPORT_UTF
   5835   if (common->utf)
   5836     {
   5837     OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
   5838     OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);
   5839     label = LABEL();
   5840     add_jump(compiler, backtracks, CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP3, 0));
   5841     skip_char_back(common);
   5842     OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
   5843     JUMPTO(SLJIT_NOT_ZERO, label);
   5844     }
   5845   else
   5846 #endif
   5847     {
   5848     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
   5849     OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
   5850     add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, TMP1, 0));
   5851     }
   5852   check_start_used_ptr(common);
   5853   return cc + LINK_SIZE;
   5854   }
   5855 SLJIT_ASSERT_STOP();
   5856 return cc;
   5857 }
   5858 
   5859 static SLJIT_INLINE pcre_uchar *compile_charn_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **backtracks)
   5860 {
   5861 /* This function consumes at least one input character. */
   5862 /* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */
   5863 DEFINE_COMPILER;
   5864 pcre_uchar *ccbegin = cc;
   5865 compare_context context;
   5866 int size;
   5867 
   5868 context.length = 0;
   5869 do
   5870   {
   5871   if (cc >= ccend)
   5872     break;
   5873 
   5874   if (*cc == OP_CHAR)
   5875     {
   5876     size = 1;
   5877 #ifdef SUPPORT_UTF
   5878     if (common->utf && HAS_EXTRALEN(cc[1]))
   5879       size += GET_EXTRALEN(cc[1]);
   5880 #endif
   5881     }
   5882   else if (*cc == OP_CHARI)
   5883     {
   5884     size = 1;
   5885 #ifdef SUPPORT_UTF
   5886     if (common->utf)
   5887       {
   5888       if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
   5889         size = 0;
   5890       else if (HAS_EXTRALEN(cc[1]))
   5891         size += GET_EXTRALEN(cc[1]);
   5892       }
   5893     else
   5894 #endif
   5895     if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
   5896       size = 0;
   5897     }
   5898   else
   5899     size = 0;
   5900 
   5901   cc += 1 + size;
   5902   context.length += IN_UCHARS(size);
   5903   }
   5904 while (size > 0 && context.length <= 128);
   5905 
   5906 cc = ccbegin;
   5907 if (context.length > 0)
   5908   {
   5909   /* We have a fixed-length byte sequence. */
   5910   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, context.length);
   5911   add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0));
   5912 
   5913   context.sourcereg = -1;
   5914 #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
   5915   context.ucharptr = 0;
   5916 #endif
   5917   do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, backtracks); while (context.length > 0);
   5918   return cc;
   5919   }
   5920 
   5921 /* A non-fixed length character will be checked if length == 0. */
   5922 return compile_char1_matchingpath(common, *cc, cc + 1, backtracks);
   5923 }
   5924 
   5925 /* Forward definitions. */
   5926 static void compile_matchingpath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);
   5927 static void compile_backtrackingpath(compiler_common *, struct backtrack_common *);
   5928 
   5929 #define PUSH_BACKTRACK(size, ccstart, error) \
   5930   do \
   5931     { \
   5932     backtrack = sljit_alloc_memory(compiler, (size)); \
   5933     if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
   5934       return error; \
   5935     memset(backtrack, 0, size); \
   5936     backtrack->prev = parent->top; \
   5937     backtrack->cc = (ccstart); \
   5938     parent->top = backtrack; \
   5939     } \
   5940   while (0)
   5941 
   5942 #define PUSH_BACKTRACK_NOVALUE(size, ccstart) \
   5943   do \
   5944     { \
   5945     backtrack = sljit_alloc_memory(compiler, (size)); \
   5946     if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
   5947       return; \
   5948     memset(backtrack, 0, size); \
   5949     backtrack->prev = parent->top; \
   5950     backtrack->cc = (ccstart); \
   5951     parent->top = backtrack; \
   5952     } \
   5953   while (0)
   5954 
   5955 #define BACKTRACK_AS(type) ((type *)backtrack)
   5956 
   5957 static void compile_dnref_search(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
   5958 {
   5959 /* The OVECTOR offset goes to TMP2. */
   5960 DEFINE_COMPILER;
   5961 int count = GET2(cc, 1 + IMM2_SIZE);
   5962 pcre_uchar *slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
   5963 unsigned int offset;
   5964 jump_list *found = NULL;
   5965 
   5966 SLJIT_ASSERT(*cc == OP_DNREF || *cc == OP_DNREFI);
   5967 
   5968 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
   5969 
   5970 count--;
   5971 while (count-- > 0)
   5972   {
   5973   offset = GET2(slot, 0) << 1;
   5974   GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));
   5975   add_jump(compiler, &found, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0));
   5976   slot += common->name_entry_size;
   5977   }
   5978 
   5979 offset = GET2(slot, 0) << 1;
   5980 GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));
   5981 if (backtracks != NULL && !common->jscript_compat)
   5982   add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0));
   5983 
   5984 set_jumps(found, LABEL());
   5985 }
   5986 
   5987 static void compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
   5988 {
   5989 DEFINE_COMPILER;
   5990 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
   5991 int offset = 0;
   5992 struct sljit_jump *jump = NULL;
   5993 struct sljit_jump *partial;
   5994 struct sljit_jump *nopartial;
   5995 
   5996 if (ref)
   5997   {
   5998   offset = GET2(cc, 1) << 1;
   5999   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
   6000   /* OVECTOR(1) contains the "string begin - 1" constant. */
   6001   if (withchecks && !common->jscript_compat)
   6002     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));
   6003   }
   6004 else
   6005   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
   6006 
   6007 #if defined SUPPORT_UTF && defined SUPPORT_UCP
   6008 if (common->utf && *cc == OP_REFI)
   6009   {
   6010   SLJIT_ASSERT(TMP1 == SLJIT_R0 && STACK_TOP == SLJIT_R1 && TMP2 == SLJIT_R2);
   6011   if (ref)
   6012     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
   6013   else
   6014     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
   6015 
   6016   if (withchecks)
   6017     jump = CMP(SLJIT_EQUAL, TMP1, 0, TMP2, 0);
   6018 
   6019   /* Needed to save important temporary registers. */
   6020   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);
   6021   OP1(SLJIT_MOV, SLJIT_R1, 0, ARGUMENTS, 0);
   6022   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, uchar_ptr), STR_PTR, 0);
   6023   sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));
   6024   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   6025   if (common->mode == JIT_COMPILE)
   6026     add_jump(compiler, backtracks, CMP(SLJIT_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));
   6027   else
   6028     {
   6029     add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
   6030     nopartial = CMP(SLJIT_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
   6031     check_partial(common, FALSE);
   6032     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   6033     JUMPHERE(nopartial);
   6034     }
   6035   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);
   6036   }
   6037 else
   6038 #endif /* SUPPORT_UTF && SUPPORT_UCP */
   6039   {
   6040   if (ref)
   6041     OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP1, 0);
   6042   else
   6043     OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
   6044 
   6045   if (withchecks)
   6046     jump = JUMP(SLJIT_ZERO);
   6047 
   6048   OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
   6049   partial = CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0);
   6050   if (common->mode == JIT_COMPILE)
   6051     add_jump(compiler, backtracks, partial);
   6052 
   6053   add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
   6054   add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
   6055 
   6056   if (common->mode != JIT_COMPILE)
   6057     {
   6058     nopartial = JUMP(SLJIT_JUMP);
   6059     JUMPHERE(partial);
   6060     /* TMP2 -= STR_END - STR_PTR */
   6061     OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, STR_PTR, 0);
   6062     OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, STR_END, 0);
   6063     partial = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0);
   6064     OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);
   6065     add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
   6066     add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
   6067     JUMPHERE(partial);
   6068     check_partial(common, FALSE);
   6069     add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
   6070     JUMPHERE(nopartial);
   6071     }
   6072   }
   6073 
   6074 if (jump != NULL)
   6075   {
   6076   if (emptyfail)
   6077     add_jump(compiler, backtracks, jump);
   6078   else
   6079     JUMPHERE(jump);
   6080   }
   6081 }
   6082 
   6083 static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
   6084 {
   6085 DEFINE_COMPILER;
   6086 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
   6087 backtrack_common *backtrack;
   6088 pcre_uchar type;
   6089 int offset = 0;
   6090 struct sljit_label *label;
   6091 struct sljit_jump *zerolength;
   6092 struct sljit_jump *jump = NULL;
   6093 pcre_uchar *ccbegin = cc;
   6094 int min = 0, max = 0;
   6095 BOOL minimize;
   6096 
   6097 PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
   6098 
   6099 if (ref)
   6100   offset = GET2(cc, 1) << 1;
   6101 else
   6102   cc += IMM2_SIZE;
   6103 type = cc[1 + IMM2_SIZE];
   6104 
   6105 SLJIT_COMPILE_ASSERT((OP_CRSTAR & 0x1) == 0, crstar_opcode_must_be_even);
   6106 minimize = (type & 0x1) != 0;
   6107 switch(type)
   6108   {
   6109   case OP_CRSTAR:
   6110   case OP_CRMINSTAR:
   6111   min = 0;
   6112   max = 0;
   6113   cc += 1 + IMM2_SIZE + 1;
   6114   break;
   6115   case OP_CRPLUS:
   6116   case OP_CRMINPLUS:
   6117   min = 1;
   6118   max = 0;
   6119   cc += 1 + IMM2_SIZE + 1;
   6120   break;
   6121   case OP_CRQUERY:
   6122   case OP_CRMINQUERY:
   6123   min = 0;
   6124   max = 1;
   6125   cc += 1 + IMM2_SIZE + 1;
   6126   break;
   6127   case OP_CRRANGE:
   6128   case OP_CRMINRANGE:
   6129   min = GET2(cc, 1 + IMM2_SIZE + 1);
   6130   max = GET2(cc, 1 + IMM2_SIZE + 1 + IMM2_SIZE);
   6131   cc += 1 + IMM2_SIZE + 1 + 2 * IMM2_SIZE;
   6132   break;
   6133   default:
   6134   SLJIT_ASSERT_STOP();
   6135   break;
   6136   }
   6137 
   6138 if (!minimize)
   6139   {
   6140   if (min == 0)
   6141     {
   6142     allocate_stack(common, 2);
   6143     if (ref)
   6144       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
   6145     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   6146     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
   6147     /* Temporary release of STR_PTR. */
   6148     OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
   6149     /* Handles both invalid and empty cases. Since the minimum repeat,
   6150     is zero the invalid case is basically the same as an empty case. */
   6151     if (ref)
   6152       zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
   6153     else
   6154       {
   6155       compile_dnref_search(common, ccbegin, NULL);
   6156       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
   6157       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, TMP2, 0);
   6158       zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
   6159       }
   6160     /* Restore if not zero length. */
   6161     OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
   6162     }
   6163   else
   6164     {
   6165     allocate_stack(common, 1);
   6166     if (ref)
   6167       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
   6168     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6169     if (ref)
   6170       {
   6171       add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));
   6172       zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
   6173       }
   6174     else
   6175       {
   6176       compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);
   6177       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
   6178       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, TMP2, 0);
   6179       zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
   6180       }
   6181     }
   6182 
   6183   if (min > 1 || max > 1)
   6184     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, SLJIT_IMM, 0);
   6185 
   6186   label = LABEL();
   6187   if (!ref)
   6188     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1);
   6189   compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);
   6190 
   6191   if (min > 1 || max > 1)
   6192     {
   6193     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0);
   6194     OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   6195     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, TMP1, 0);
   6196     if (min > 1)
   6197       CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, min, label);
   6198     if (max > 1)
   6199       {
   6200       jump = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);
   6201       allocate_stack(common, 1);
   6202       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   6203       JUMPTO(SLJIT_JUMP, label);
   6204       JUMPHERE(jump);
   6205       }
   6206     }
   6207 
   6208   if (max == 0)
   6209     {
   6210     /* Includes min > 1 case as well. */
   6211     allocate_stack(common, 1);
   6212     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   6213     JUMPTO(SLJIT_JUMP, label);
   6214     }
   6215 
   6216   JUMPHERE(zerolength);
   6217   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
   6218 
   6219   count_match(common);
   6220   return cc;
   6221   }
   6222 
   6223 allocate_stack(common, ref ? 2 : 3);
   6224 if (ref)
   6225   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
   6226 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6227 if (type != OP_CRMINSTAR)
   6228   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
   6229 
   6230 if (min == 0)
   6231   {
   6232   /* Handles both invalid and empty cases. Since the minimum repeat,
   6233   is zero the invalid case is basically the same as an empty case. */
   6234   if (ref)
   6235     zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
   6236   else
   6237     {
   6238     compile_dnref_search(common, ccbegin, NULL);
   6239     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
   6240     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);
   6241     zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
   6242     }
   6243   /* Length is non-zero, we can match real repeats. */
   6244   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   6245   jump = JUMP(SLJIT_JUMP);
   6246   }
   6247 else
   6248   {
   6249   if (ref)
   6250     {
   6251     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));
   6252     zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
   6253     }
   6254   else
   6255     {
   6256     compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);
   6257     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
   6258     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);
   6259     zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
   6260     }
   6261   }
   6262 
   6263 BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
   6264 if (max > 0)
   6265   add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
   6266 
   6267 if (!ref)
   6268   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
   6269 compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);
   6270 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   6271 
   6272 if (min > 1)
   6273   {
   6274   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   6275   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   6276   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
   6277   CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, min, BACKTRACK_AS(iterator_backtrack)->matchingpath);
   6278   }
   6279 else if (max > 0)
   6280   OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
   6281 
   6282 if (jump != NULL)
   6283   JUMPHERE(jump);
   6284 JUMPHERE(zerolength);
   6285 
   6286 count_match(common);
   6287 return cc;
   6288 }
   6289 
   6290 static SLJIT_INLINE pcre_uchar *compile_recurse_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
   6291 {
   6292 DEFINE_COMPILER;
   6293 backtrack_common *backtrack;
   6294 recurse_entry *entry = common->entries;
   6295 recurse_entry *prev = NULL;
   6296 sljit_sw start = GET(cc, 1);
   6297 pcre_uchar *start_cc;
   6298 BOOL needs_control_head;
   6299 
   6300 PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
   6301 
   6302 /* Inlining simple patterns. */
   6303 if (get_framesize(common, common->start + start, NULL, TRUE, &needs_control_head) == no_stack)
   6304   {
   6305   start_cc = common->start + start;
   6306   compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);
   6307   BACKTRACK_AS(recurse_backtrack)->inlined_pattern = TRUE;
   6308   return cc + 1 + LINK_SIZE;
   6309   }
   6310 
   6311 while (entry != NULL)
   6312   {
   6313   if (entry->start == start)
   6314     break;
   6315   prev = entry;
   6316   entry = entry->next;
   6317   }
   6318 
   6319 if (entry == NULL)
   6320   {
   6321   entry = sljit_alloc_memory(compiler, sizeof(recurse_entry));
   6322   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   6323     return NULL;
   6324   entry->next = NULL;
   6325   entry->entry = NULL;
   6326   entry->calls = NULL;
   6327   entry->start = start;
   6328 
   6329   if (prev != NULL)
   6330     prev->next = entry;
   6331   else
   6332     common->entries = entry;
   6333   }
   6334 
   6335 if (common->has_set_som && common->mark_ptr != 0)
   6336   {
   6337   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
   6338   allocate_stack(common, 2);
   6339   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
   6340   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
   6341   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
   6342   }
   6343 else if (common->has_set_som || common->mark_ptr != 0)
   6344   {
   6345   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr);
   6346   allocate_stack(common, 1);
   6347   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
   6348   }
   6349 
   6350 if (entry->entry == NULL)
   6351   add_jump(compiler, &entry->calls, JUMP(SLJIT_FAST_CALL));
   6352 else
   6353   JUMPTO(SLJIT_FAST_CALL, entry->entry);
   6354 /* Leave if the match is failed. */
   6355 add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0));
   6356 return cc + 1 + LINK_SIZE;
   6357 }
   6358 
   6359 static int SLJIT_CALL do_callout(struct jit_arguments *arguments, PUBL(callout_block) *callout_block, pcre_uchar **jit_ovector)
   6360 {
   6361 const pcre_uchar *begin = arguments->begin;
   6362 int *offset_vector = arguments->offsets;
   6363 int offset_count = arguments->offset_count;
   6364 int i;
   6365 
   6366 if (PUBL(callout) == NULL)
   6367   return 0;
   6368 
   6369 callout_block->version = 2;
   6370 callout_block->callout_data = arguments->callout_data;
   6371 
   6372 /* Offsets in subject. */
   6373 callout_block->subject_length = arguments->end - arguments->begin;
   6374 callout_block->start_match = (pcre_uchar*)callout_block->subject - arguments->begin;
   6375 callout_block->current_position = (pcre_uchar*)callout_block->offset_vector - arguments->begin;
   6376 #if defined COMPILE_PCRE8
   6377 callout_block->subject = (PCRE_SPTR)begin;
   6378 #elif defined COMPILE_PCRE16
   6379 callout_block->subject = (PCRE_SPTR16)begin;
   6380 #elif defined COMPILE_PCRE32
   6381 callout_block->subject = (PCRE_SPTR32)begin;
   6382 #endif
   6383 
   6384 /* Convert and copy the JIT offset vector to the offset_vector array. */
   6385 callout_block->capture_top = 0;
   6386 callout_block->offset_vector = offset_vector;
   6387 for (i = 2; i < offset_count; i += 2)
   6388   {
   6389   offset_vector[i] = jit_ovector[i] - begin;
   6390   offset_vector[i + 1] = jit_ovector[i + 1] - begin;
   6391   if (jit_ovector[i] >= begin)
   6392     callout_block->capture_top = i;
   6393   }
   6394 
   6395 callout_block->capture_top = (callout_block->capture_top >> 1) + 1;
   6396 if (offset_count > 0)
   6397   offset_vector[0] = -1;
   6398 if (offset_count > 1)
   6399   offset_vector[1] = -1;
   6400 return (*PUBL(callout))(callout_block);
   6401 }
   6402 
   6403 /* Aligning to 8 byte. */
   6404 #define CALLOUT_ARG_SIZE \
   6405     (((int)sizeof(PUBL(callout_block)) + 7) & ~7)
   6406 
   6407 #define CALLOUT_ARG_OFFSET(arg) \
   6408     (-CALLOUT_ARG_SIZE + SLJIT_OFFSETOF(PUBL(callout_block), arg))
   6409 
   6410 static SLJIT_INLINE pcre_uchar *compile_callout_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
   6411 {
   6412 DEFINE_COMPILER;
   6413 backtrack_common *backtrack;
   6414 
   6415 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
   6416 
   6417 allocate_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));
   6418 
   6419 SLJIT_ASSERT(common->capture_last_ptr != 0);
   6420 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
   6421 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   6422 OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);
   6423 OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(capture_last), TMP2, 0);
   6424 
   6425 /* These pointer sized fields temporarly stores internal variables. */
   6426 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
   6427 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(offset_vector), STR_PTR, 0);
   6428 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(subject), TMP2, 0);
   6429 
   6430 if (common->mark_ptr != 0)
   6431   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr));
   6432 OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 2));
   6433 OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(next_item_length), SLJIT_IMM, GET(cc, 2 + LINK_SIZE));
   6434 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(mark), (common->mark_ptr != 0) ? TMP2 : SLJIT_IMM, 0);
   6435 
   6436 /* Needed to save important temporary registers. */
   6437 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);
   6438 OP2(SLJIT_SUB, SLJIT_R1, 0, STACK_TOP, 0, SLJIT_IMM, CALLOUT_ARG_SIZE);
   6439 GET_LOCAL_BASE(SLJIT_R2, 0, OVECTOR_START);
   6440 sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_callout));
   6441 OP1(SLJIT_MOV_SI, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0);
   6442 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   6443 free_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));
   6444 
   6445 /* Check return value. */
   6446 OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
   6447 add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_SIG_GREATER));
   6448 if (common->forced_quit_label == NULL)
   6449   add_jump(compiler, &common->forced_quit, JUMP(SLJIT_SIG_LESS));
   6450 else
   6451   JUMPTO(SLJIT_SIG_LESS, common->forced_quit_label);
   6452 return cc + 2 + 2 * LINK_SIZE;
   6453 }
   6454 
   6455 #undef CALLOUT_ARG_SIZE
   6456 #undef CALLOUT_ARG_OFFSET
   6457 
   6458 static pcre_uchar *compile_assert_matchingpath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)
   6459 {
   6460 DEFINE_COMPILER;
   6461 int framesize;
   6462 int extrasize;
   6463 BOOL needs_control_head;
   6464 int private_data_ptr;
   6465 backtrack_common altbacktrack;
   6466 pcre_uchar *ccbegin;
   6467 pcre_uchar opcode;
   6468 pcre_uchar bra = OP_BRA;
   6469 jump_list *tmp = NULL;
   6470 jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
   6471 jump_list **found;
   6472 /* Saving previous accept variables. */
   6473 BOOL save_local_exit = common->local_exit;
   6474 BOOL save_positive_assert = common->positive_assert;
   6475 then_trap_backtrack *save_then_trap = common->then_trap;
   6476 struct sljit_label *save_quit_label = common->quit_label;
   6477 struct sljit_label *save_accept_label = common->accept_label;
   6478 jump_list *save_quit = common->quit;
   6479 jump_list *save_positive_assert_quit = common->positive_assert_quit;
   6480 jump_list *save_accept = common->accept;
   6481 struct sljit_jump *jump;
   6482 struct sljit_jump *brajump = NULL;
   6483 
   6484 /* Assert captures then. */
   6485 common->then_trap = NULL;
   6486 
   6487 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
   6488   {
   6489   SLJIT_ASSERT(!conditional);
   6490   bra = *cc;
   6491   cc++;
   6492   }
   6493 private_data_ptr = PRIVATE_DATA(cc);
   6494 SLJIT_ASSERT(private_data_ptr != 0);
   6495 framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
   6496 backtrack->framesize = framesize;
   6497 backtrack->private_data_ptr = private_data_ptr;
   6498 opcode = *cc;
   6499 SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);
   6500 found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;
   6501 ccbegin = cc;
   6502 cc += GET(cc, 1);
   6503 
   6504 if (bra == OP_BRAMINZERO)
   6505   {
   6506   /* This is a braminzero backtrack path. */
   6507   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   6508   free_stack(common, 1);
   6509   brajump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
   6510   }
   6511 
   6512 if (framesize < 0)
   6513   {
   6514   extrasize = needs_control_head ? 2 : 1;
   6515   if (framesize == no_frame)
   6516     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);
   6517   allocate_stack(common, extrasize);
   6518   if (needs_control_head)
   6519     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   6520   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   6521   if (needs_control_head)
   6522     {
   6523     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
   6524     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
   6525     }
   6526   }
   6527 else
   6528   {
   6529   extrasize = needs_control_head ? 3 : 2;
   6530   allocate_stack(common, framesize + extrasize);
   6531   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   6532   OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
   6533   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);
   6534   if (needs_control_head)
   6535     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   6536   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   6537   if (needs_control_head)
   6538     {
   6539     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
   6540     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
   6541     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
   6542     }
   6543   else
   6544     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
   6545   init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);
   6546   }
   6547 
   6548 memset(&altbacktrack, 0, sizeof(backtrack_common));
   6549 if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
   6550   {
   6551   /* Negative assert is stronger than positive assert. */
   6552   common->local_exit = TRUE;
   6553   common->quit_label = NULL;
   6554   common->quit = NULL;
   6555   common->positive_assert = FALSE;
   6556   }
   6557 else
   6558   common->positive_assert = TRUE;
   6559 common->positive_assert_quit = NULL;
   6560 
   6561 while (1)
   6562   {
   6563   common->accept_label = NULL;
   6564   common->accept = NULL;
   6565   altbacktrack.top = NULL;
   6566   altbacktrack.topbacktracks = NULL;
   6567 
   6568   if (*ccbegin == OP_ALT)
   6569     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   6570 
   6571   altbacktrack.cc = ccbegin;
   6572   compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
   6573   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   6574     {
   6575     if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
   6576       {
   6577       common->local_exit = save_local_exit;
   6578       common->quit_label = save_quit_label;
   6579       common->quit = save_quit;
   6580       }
   6581     common->positive_assert = save_positive_assert;
   6582     common->then_trap = save_then_trap;
   6583     common->accept_label = save_accept_label;
   6584     common->positive_assert_quit = save_positive_assert_quit;
   6585     common->accept = save_accept;
   6586     return NULL;
   6587     }
   6588   common->accept_label = LABEL();
   6589   if (common->accept != NULL)
   6590     set_jumps(common->accept, common->accept_label);
   6591 
   6592   /* Reset stack. */
   6593   if (framesize < 0)
   6594     {
   6595     if (framesize == no_frame)
   6596       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   6597     else
   6598       free_stack(common, extrasize);
   6599     if (needs_control_head)
   6600       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);
   6601     }
   6602   else
   6603     {
   6604     if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)
   6605       {
   6606       /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
   6607       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
   6608       if (needs_control_head)
   6609         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);
   6610       }
   6611     else
   6612       {
   6613       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   6614       if (needs_control_head)
   6615         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_sw));
   6616       add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   6617       }
   6618     }
   6619 
   6620   if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
   6621     {
   6622     /* We know that STR_PTR was stored on the top of the stack. */
   6623     if (conditional)
   6624       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), needs_control_head ? sizeof(sljit_sw) : 0);
   6625     else if (bra == OP_BRAZERO)
   6626       {
   6627       if (framesize < 0)
   6628         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 1) * sizeof(sljit_sw));
   6629       else
   6630         {
   6631         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));
   6632         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + extrasize - 1) * sizeof(sljit_sw));
   6633         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
   6634         }
   6635       OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
   6636       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6637       }
   6638     else if (framesize >= 0)
   6639       {
   6640       /* For OP_BRA and OP_BRAMINZERO. */
   6641       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));
   6642       }
   6643     }
   6644   add_jump(compiler, found, JUMP(SLJIT_JUMP));
   6645 
   6646   compile_backtrackingpath(common, altbacktrack.top);
   6647   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   6648     {
   6649     if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
   6650       {
   6651       common->local_exit = save_local_exit;
   6652       common->quit_label = save_quit_label;
   6653       common->quit = save_quit;
   6654       }
   6655     common->positive_assert = save_positive_assert;
   6656     common->then_trap = save_then_trap;
   6657     common->accept_label = save_accept_label;
   6658     common->positive_assert_quit = save_positive_assert_quit;
   6659     common->accept = save_accept;
   6660     return NULL;
   6661     }
   6662   set_jumps(altbacktrack.topbacktracks, LABEL());
   6663 
   6664   if (*cc != OP_ALT)
   6665     break;
   6666 
   6667   ccbegin = cc;
   6668   cc += GET(cc, 1);
   6669   }
   6670 
   6671 if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
   6672   {
   6673   SLJIT_ASSERT(common->positive_assert_quit == NULL);
   6674   /* Makes the check less complicated below. */
   6675   common->positive_assert_quit = common->quit;
   6676   }
   6677 
   6678 /* None of them matched. */
   6679 if (common->positive_assert_quit != NULL)
   6680   {
   6681   jump = JUMP(SLJIT_JUMP);
   6682   set_jumps(common->positive_assert_quit, LABEL());
   6683   SLJIT_ASSERT(framesize != no_stack);
   6684   if (framesize < 0)
   6685     OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, extrasize * sizeof(sljit_sw));
   6686   else
   6687     {
   6688     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   6689     add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   6690     OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
   6691     }
   6692   JUMPHERE(jump);
   6693   }
   6694 
   6695 if (needs_control_head)
   6696   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(1));
   6697 
   6698 if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
   6699   {
   6700   /* Assert is failed. */
   6701   if (conditional || bra == OP_BRAZERO)
   6702     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   6703 
   6704   if (framesize < 0)
   6705     {
   6706     /* The topmost item should be 0. */
   6707     if (bra == OP_BRAZERO)
   6708       {
   6709       if (extrasize == 2)
   6710         free_stack(common, 1);
   6711       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6712       }
   6713     else
   6714       free_stack(common, extrasize);
   6715     }
   6716   else
   6717     {
   6718     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));
   6719     /* The topmost item should be 0. */
   6720     if (bra == OP_BRAZERO)
   6721       {
   6722       free_stack(common, framesize + extrasize - 1);
   6723       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6724       }
   6725     else
   6726       free_stack(common, framesize + extrasize);
   6727     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
   6728     }
   6729   jump = JUMP(SLJIT_JUMP);
   6730   if (bra != OP_BRAZERO)
   6731     add_jump(compiler, target, jump);
   6732 
   6733   /* Assert is successful. */
   6734   set_jumps(tmp, LABEL());
   6735   if (framesize < 0)
   6736     {
   6737     /* We know that STR_PTR was stored on the top of the stack. */
   6738     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 1) * sizeof(sljit_sw));
   6739     /* Keep the STR_PTR on the top of the stack. */
   6740     if (bra == OP_BRAZERO)
   6741       {
   6742       OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
   6743       if (extrasize == 2)
   6744         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   6745       }
   6746     else if (bra == OP_BRAMINZERO)
   6747       {
   6748       OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
   6749       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6750       }
   6751     }
   6752   else
   6753     {
   6754     if (bra == OP_BRA)
   6755       {
   6756       /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
   6757       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
   6758       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 2) * sizeof(sljit_sw));
   6759       }
   6760     else
   6761       {
   6762       /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
   6763       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_sw));
   6764       if (extrasize == 2)
   6765         {
   6766         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   6767         if (bra == OP_BRAMINZERO)
   6768           OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6769         }
   6770       else
   6771         {
   6772         OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
   6773         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
   6774         }
   6775       }
   6776     }
   6777 
   6778   if (bra == OP_BRAZERO)
   6779     {
   6780     backtrack->matchingpath = LABEL();
   6781     SET_LABEL(jump, backtrack->matchingpath);
   6782     }
   6783   else if (bra == OP_BRAMINZERO)
   6784     {
   6785     JUMPTO(SLJIT_JUMP, backtrack->matchingpath);
   6786     JUMPHERE(brajump);
   6787     if (framesize >= 0)
   6788       {
   6789       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   6790       add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   6791       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));
   6792       }
   6793     set_jumps(backtrack->common.topbacktracks, LABEL());
   6794     }
   6795   }
   6796 else
   6797   {
   6798   /* AssertNot is successful. */
   6799   if (framesize < 0)
   6800     {
   6801     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   6802     if (bra != OP_BRA)
   6803       {
   6804       if (extrasize == 2)
   6805         free_stack(common, 1);
   6806       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6807       }
   6808     else
   6809       free_stack(common, extrasize);
   6810     }
   6811   else
   6812     {
   6813     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   6814     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));
   6815     /* The topmost item should be 0. */
   6816     if (bra != OP_BRA)
   6817       {
   6818       free_stack(common, framesize + extrasize - 1);
   6819       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   6820       }
   6821     else
   6822       free_stack(common, framesize + extrasize);
   6823     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
   6824     }
   6825 
   6826   if (bra == OP_BRAZERO)
   6827     backtrack->matchingpath = LABEL();
   6828   else if (bra == OP_BRAMINZERO)
   6829     {
   6830     JUMPTO(SLJIT_JUMP, backtrack->matchingpath);
   6831     JUMPHERE(brajump);
   6832     }
   6833 
   6834   if (bra != OP_BRA)
   6835     {
   6836     SLJIT_ASSERT(found == &backtrack->common.topbacktracks);
   6837     set_jumps(backtrack->common.topbacktracks, LABEL());
   6838     backtrack->common.topbacktracks = NULL;
   6839     }
   6840   }
   6841 
   6842 if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
   6843   {
   6844   common->local_exit = save_local_exit;
   6845   common->quit_label = save_quit_label;
   6846   common->quit = save_quit;
   6847   }
   6848 common->positive_assert = save_positive_assert;
   6849 common->then_trap = save_then_trap;
   6850 common->accept_label = save_accept_label;
   6851 common->positive_assert_quit = save_positive_assert_quit;
   6852 common->accept = save_accept;
   6853 return cc + 1 + LINK_SIZE;
   6854 }
   6855 
   6856 static SLJIT_INLINE void match_once_common(compiler_common *common, pcre_uchar ket, int framesize, int private_data_ptr, BOOL has_alternatives, BOOL needs_control_head)
   6857 {
   6858 DEFINE_COMPILER;
   6859 int stacksize;
   6860 
   6861 if (framesize < 0)
   6862   {
   6863   if (framesize == no_frame)
   6864     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   6865   else
   6866     {
   6867     stacksize = needs_control_head ? 1 : 0;
   6868     if (ket != OP_KET || has_alternatives)
   6869       stacksize++;
   6870     free_stack(common, stacksize);
   6871     }
   6872 
   6873   if (needs_control_head)
   6874     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (ket != OP_KET || has_alternatives) ? sizeof(sljit_sw) : 0);
   6875 
   6876   /* TMP2 which is set here used by OP_KETRMAX below. */
   6877   if (ket == OP_KETRMAX)
   6878     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
   6879   else if (ket == OP_KETRMIN)
   6880     {
   6881     /* Move the STR_PTR to the private_data_ptr. */
   6882     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), 0);
   6883     }
   6884   }
   6885 else
   6886   {
   6887   stacksize = (ket != OP_KET || has_alternatives) ? 2 : 1;
   6888   OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + stacksize) * sizeof(sljit_sw));
   6889   if (needs_control_head)
   6890     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 0);
   6891 
   6892   if (ket == OP_KETRMAX)
   6893     {
   6894     /* TMP2 which is set here used by OP_KETRMAX below. */
   6895     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   6896     }
   6897   }
   6898 if (needs_control_head)
   6899   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP1, 0);
   6900 }
   6901 
   6902 static SLJIT_INLINE int match_capture_common(compiler_common *common, int stacksize, int offset, int private_data_ptr)
   6903 {
   6904 DEFINE_COMPILER;
   6905 
   6906 if (common->capture_last_ptr != 0)
   6907   {
   6908   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
   6909   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
   6910   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
   6911   stacksize++;
   6912   }
   6913 if (common->optimized_cbracket[offset >> 1] == 0)
   6914   {
   6915   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
   6916   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
   6917   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
   6918   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   6919   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
   6920   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
   6921   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
   6922   stacksize += 2;
   6923   }
   6924 return stacksize;
   6925 }
   6926 
   6927 /*
   6928   Handling bracketed expressions is probably the most complex part.
   6929 
   6930   Stack layout naming characters:
   6931     S - Push the current STR_PTR
   6932     0 - Push a 0 (NULL)
   6933     A - Push the current STR_PTR. Needed for restoring the STR_PTR
   6934         before the next alternative. Not pushed if there are no alternatives.
   6935     M - Any values pushed by the current alternative. Can be empty, or anything.
   6936     C - Push the previous OVECTOR(i), OVECTOR(i+1) and OVECTOR_PRIV(i) to the stack.
   6937     L - Push the previous local (pointed by localptr) to the stack
   6938    () - opional values stored on the stack
   6939   ()* - optonal, can be stored multiple times
   6940 
   6941   The following list shows the regular expression templates, their PCRE byte codes
   6942   and stack layout supported by pcre-sljit.
   6943 
   6944   (?:)                     OP_BRA     | OP_KET                A M
   6945   ()                       OP_CBRA    | OP_KET                C M
   6946   (?:)+                    OP_BRA     | OP_KETRMAX        0   A M S   ( A M S )*
   6947                            OP_SBRA    | OP_KETRMAX        0   L M S   ( L M S )*
   6948   (?:)+?                   OP_BRA     | OP_KETRMIN        0   A M S   ( A M S )*
   6949                            OP_SBRA    | OP_KETRMIN        0   L M S   ( L M S )*
   6950   ()+                      OP_CBRA    | OP_KETRMAX        0   C M S   ( C M S )*
   6951                            OP_SCBRA   | OP_KETRMAX        0   C M S   ( C M S )*
   6952   ()+?                     OP_CBRA    | OP_KETRMIN        0   C M S   ( C M S )*
   6953                            OP_SCBRA   | OP_KETRMIN        0   C M S   ( C M S )*
   6954   (?:)?    OP_BRAZERO    | OP_BRA     | OP_KET            S ( A M 0 )
   6955   (?:)??   OP_BRAMINZERO | OP_BRA     | OP_KET            S ( A M 0 )
   6956   ()?      OP_BRAZERO    | OP_CBRA    | OP_KET            S ( C M 0 )
   6957   ()??     OP_BRAMINZERO | OP_CBRA    | OP_KET            S ( C M 0 )
   6958   (?:)*    OP_BRAZERO    | OP_BRA     | OP_KETRMAX      S 0 ( A M S )*
   6959            OP_BRAZERO    | OP_SBRA    | OP_KETRMAX      S 0 ( L M S )*
   6960   (?:)*?   OP_BRAMINZERO | OP_BRA     | OP_KETRMIN      S 0 ( A M S )*
   6961            OP_BRAMINZERO | OP_SBRA    | OP_KETRMIN      S 0 ( L M S )*
   6962   ()*      OP_BRAZERO    | OP_CBRA    | OP_KETRMAX      S 0 ( C M S )*
   6963            OP_BRAZERO    | OP_SCBRA   | OP_KETRMAX      S 0 ( C M S )*
   6964   ()*?     OP_BRAMINZERO | OP_CBRA    | OP_KETRMIN      S 0 ( C M S )*
   6965            OP_BRAMINZERO | OP_SCBRA   | OP_KETRMIN      S 0 ( C M S )*
   6966 
   6967 
   6968   Stack layout naming characters:
   6969     A - Push the alternative index (starting from 0) on the stack.
   6970         Not pushed if there is no alternatives.
   6971     M - Any values pushed by the current alternative. Can be empty, or anything.
   6972 
   6973   The next list shows the possible content of a bracket:
   6974   (|)     OP_*BRA    | OP_ALT ...         M A
   6975   (?()|)  OP_*COND   | OP_ALT             M A
   6976   (?>|)   OP_ONCE    | OP_ALT ...         [stack trace] M A
   6977   (?>|)   OP_ONCE_NC | OP_ALT ...         [stack trace] M A
   6978                                           Or nothing, if trace is unnecessary
   6979 */
   6980 
   6981 static pcre_uchar *compile_bracket_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
   6982 {
   6983 DEFINE_COMPILER;
   6984 backtrack_common *backtrack;
   6985 pcre_uchar opcode;
   6986 int private_data_ptr = 0;
   6987 int offset = 0;
   6988 int i, stacksize;
   6989 int repeat_ptr = 0, repeat_length = 0;
   6990 int repeat_type = 0, repeat_count = 0;
   6991 pcre_uchar *ccbegin;
   6992 pcre_uchar *matchingpath;
   6993 pcre_uchar *slot;
   6994 pcre_uchar bra = OP_BRA;
   6995 pcre_uchar ket;
   6996 assert_backtrack *assert;
   6997 BOOL has_alternatives;
   6998 BOOL needs_control_head = FALSE;
   6999 struct sljit_jump *jump;
   7000 struct sljit_jump *skip;
   7001 struct sljit_label *rmax_label = NULL;
   7002 struct sljit_jump *braminzero = NULL;
   7003 
   7004 PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
   7005 
   7006 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
   7007   {
   7008   bra = *cc;
   7009   cc++;
   7010   opcode = *cc;
   7011   }
   7012 
   7013 opcode = *cc;
   7014 ccbegin = cc;
   7015 matchingpath = bracketend(cc) - 1 - LINK_SIZE;
   7016 ket = *matchingpath;
   7017 if (ket == OP_KET && PRIVATE_DATA(matchingpath) != 0)
   7018   {
   7019   repeat_ptr = PRIVATE_DATA(matchingpath);
   7020   repeat_length = PRIVATE_DATA(matchingpath + 1);
   7021   repeat_type = PRIVATE_DATA(matchingpath + 2);
   7022   repeat_count = PRIVATE_DATA(matchingpath + 3);
   7023   SLJIT_ASSERT(repeat_length != 0 && repeat_type != 0 && repeat_count != 0);
   7024   if (repeat_type == OP_UPTO)
   7025     ket = OP_KETRMAX;
   7026   if (repeat_type == OP_MINUPTO)
   7027     ket = OP_KETRMIN;
   7028   }
   7029 
   7030 if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
   7031   {
   7032   /* Drop this bracket_backtrack. */
   7033   parent->top = backtrack->prev;
   7034   return matchingpath + 1 + LINK_SIZE + repeat_length;
   7035   }
   7036 
   7037 matchingpath = ccbegin + 1 + LINK_SIZE;
   7038 SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);
   7039 SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));
   7040 cc += GET(cc, 1);
   7041 
   7042 has_alternatives = *cc == OP_ALT;
   7043 if (SLJIT_UNLIKELY(opcode == OP_COND || opcode == OP_SCOND))
   7044   has_alternatives = (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF || *matchingpath == OP_FAIL) ? FALSE : TRUE;
   7045 
   7046 if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
   7047   opcode = OP_SCOND;
   7048 if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
   7049   opcode = OP_ONCE;
   7050 
   7051 if (opcode == OP_CBRA || opcode == OP_SCBRA)
   7052   {
   7053   /* Capturing brackets has a pre-allocated space. */
   7054   offset = GET2(ccbegin, 1 + LINK_SIZE);
   7055   if (common->optimized_cbracket[offset] == 0)
   7056     {
   7057     private_data_ptr = OVECTOR_PRIV(offset);
   7058     offset <<= 1;
   7059     }
   7060   else
   7061     {
   7062     offset <<= 1;
   7063     private_data_ptr = OVECTOR(offset);
   7064     }
   7065   BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
   7066   matchingpath += IMM2_SIZE;
   7067   }
   7068 else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)
   7069   {
   7070   /* Other brackets simply allocate the next entry. */
   7071   private_data_ptr = PRIVATE_DATA(ccbegin);
   7072   SLJIT_ASSERT(private_data_ptr != 0);
   7073   BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
   7074   if (opcode == OP_ONCE)
   7075     BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, NULL, FALSE, &needs_control_head);
   7076   }
   7077 
   7078 /* Instructions before the first alternative. */
   7079 stacksize = 0;
   7080 if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
   7081   stacksize++;
   7082 if (bra == OP_BRAZERO)
   7083   stacksize++;
   7084 
   7085 if (stacksize > 0)
   7086   allocate_stack(common, stacksize);
   7087 
   7088 stacksize = 0;
   7089 if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
   7090   {
   7091   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
   7092   stacksize++;
   7093   }
   7094 
   7095 if (bra == OP_BRAZERO)
   7096   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
   7097 
   7098 if (bra == OP_BRAMINZERO)
   7099   {
   7100   /* This is a backtrack path! (Since the try-path of OP_BRAMINZERO matches to the empty string) */
   7101   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   7102   if (ket != OP_KETRMIN)
   7103     {
   7104     free_stack(common, 1);
   7105     braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
   7106     }
   7107   else
   7108     {
   7109     if (opcode == OP_ONCE || opcode >= OP_SBRA)
   7110       {
   7111       jump = CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
   7112       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   7113       /* Nothing stored during the first run. */
   7114       skip = JUMP(SLJIT_JUMP);
   7115       JUMPHERE(jump);
   7116       /* Checking zero-length iteration. */
   7117       if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
   7118         {
   7119         /* When we come from outside, private_data_ptr contains the previous STR_PTR. */
   7120         braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7121         }
   7122       else
   7123         {
   7124         /* Except when the whole stack frame must be saved. */
   7125         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7126         braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (BACKTRACK_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw));
   7127         }
   7128       JUMPHERE(skip);
   7129       }
   7130     else
   7131       {
   7132       jump = CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
   7133       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   7134       JUMPHERE(jump);
   7135       }
   7136     }
   7137   }
   7138 
   7139 if (repeat_type != 0)
   7140   {
   7141   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, repeat_count);
   7142   if (repeat_type == OP_EXACT)
   7143     rmax_label = LABEL();
   7144   }
   7145 
   7146 if (ket == OP_KETRMIN)
   7147   BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
   7148 
   7149 if (ket == OP_KETRMAX)
   7150   {
   7151   rmax_label = LABEL();
   7152   if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA && repeat_type == 0)
   7153     BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmax_label;
   7154   }
   7155 
   7156 /* Handling capturing brackets and alternatives. */
   7157 if (opcode == OP_ONCE)
   7158   {
   7159   stacksize = 0;
   7160   if (needs_control_head)
   7161     {
   7162     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   7163     stacksize++;
   7164     }
   7165 
   7166   if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
   7167     {
   7168     /* Neither capturing brackets nor recursions are found in the block. */
   7169     if (ket == OP_KETRMIN)
   7170       {
   7171       stacksize += 2;
   7172       if (!needs_control_head)
   7173         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7174       }
   7175     else
   7176       {
   7177       if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
   7178         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);
   7179       if (ket == OP_KETRMAX || has_alternatives)
   7180         stacksize++;
   7181       }
   7182 
   7183     if (stacksize > 0)
   7184       allocate_stack(common, stacksize);
   7185 
   7186     stacksize = 0;
   7187     if (needs_control_head)
   7188       {
   7189       stacksize++;
   7190       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
   7191       }
   7192 
   7193     if (ket == OP_KETRMIN)
   7194       {
   7195       if (needs_control_head)
   7196         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7197       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
   7198       if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
   7199         OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, needs_control_head ? (2 * sizeof(sljit_sw)) : sizeof(sljit_sw));
   7200       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
   7201       }
   7202     else if (ket == OP_KETRMAX || has_alternatives)
   7203       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
   7204     }
   7205   else
   7206     {
   7207     if (ket != OP_KET || has_alternatives)
   7208       stacksize++;
   7209 
   7210     stacksize += BACKTRACK_AS(bracket_backtrack)->u.framesize + 1;
   7211     allocate_stack(common, stacksize);
   7212 
   7213     if (needs_control_head)
   7214       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
   7215 
   7216     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7217     OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));
   7218 
   7219     stacksize = needs_control_head ? 1 : 0;
   7220     if (ket != OP_KET || has_alternatives)
   7221       {
   7222       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
   7223       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);
   7224       stacksize++;
   7225       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
   7226       }
   7227     else
   7228       {
   7229       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);
   7230       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
   7231       }
   7232     init_frame(common, ccbegin, NULL, BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize, stacksize + 1, FALSE);
   7233     }
   7234   }
   7235 else if (opcode == OP_CBRA || opcode == OP_SCBRA)
   7236   {
   7237   /* Saving the previous values. */
   7238   if (common->optimized_cbracket[offset >> 1] != 0)
   7239     {
   7240     SLJIT_ASSERT(private_data_ptr == OVECTOR(offset));
   7241     allocate_stack(common, 2);
   7242     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7243     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr + sizeof(sljit_sw));
   7244     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);
   7245     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
   7246     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
   7247     }
   7248   else
   7249     {
   7250     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7251     allocate_stack(common, 1);
   7252     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);
   7253     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
   7254     }
   7255   }
   7256 else if (opcode == OP_SBRA || opcode == OP_SCOND)
   7257   {
   7258   /* Saving the previous value. */
   7259   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7260   allocate_stack(common, 1);
   7261   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);
   7262   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
   7263   }
   7264 else if (has_alternatives)
   7265   {
   7266   /* Pushing the starting string pointer. */
   7267   allocate_stack(common, 1);
   7268   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   7269   }
   7270 
   7271 /* Generating code for the first alternative. */
   7272 if (opcode == OP_COND || opcode == OP_SCOND)
   7273   {
   7274   if (*matchingpath == OP_CREF)
   7275     {
   7276     SLJIT_ASSERT(has_alternatives);
   7277     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed),
   7278       CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));
   7279     matchingpath += 1 + IMM2_SIZE;
   7280     }
   7281   else if (*matchingpath == OP_DNCREF)
   7282     {
   7283     SLJIT_ASSERT(has_alternatives);
   7284 
   7285     i = GET2(matchingpath, 1 + IMM2_SIZE);
   7286     slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
   7287     OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
   7288     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
   7289     OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
   7290     slot += common->name_entry_size;
   7291     i--;
   7292     while (i-- > 0)
   7293       {
   7294       OP2(SLJIT_SUB, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
   7295       OP2(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, STR_PTR, 0);
   7296       slot += common->name_entry_size;
   7297       }
   7298     OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
   7299     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), JUMP(SLJIT_ZERO));
   7300     matchingpath += 1 + 2 * IMM2_SIZE;
   7301     }
   7302   else if (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF || *matchingpath == OP_FAIL)
   7303     {
   7304     /* Never has other case. */
   7305     BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;
   7306     SLJIT_ASSERT(!has_alternatives);
   7307 
   7308     if (*matchingpath == OP_FAIL)
   7309       stacksize = 0;
   7310     if (*matchingpath == OP_RREF)
   7311       {
   7312       stacksize = GET2(matchingpath, 1);
   7313       if (common->currententry == NULL)
   7314         stacksize = 0;
   7315       else if (stacksize == RREF_ANY)
   7316         stacksize = 1;
   7317       else if (common->currententry->start == 0)
   7318         stacksize = stacksize == 0;
   7319       else
   7320         stacksize = stacksize == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
   7321 
   7322       if (stacksize != 0)
   7323         matchingpath += 1 + IMM2_SIZE;
   7324       }
   7325     else
   7326       {
   7327       if (common->currententry == NULL || common->currententry->start == 0)
   7328         stacksize = 0;
   7329       else
   7330         {
   7331         stacksize = GET2(matchingpath, 1 + IMM2_SIZE);
   7332         slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
   7333         i = (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
   7334         while (stacksize > 0)
   7335           {
   7336           if ((int)GET2(slot, 0) == i)
   7337             break;
   7338           slot += common->name_entry_size;
   7339           stacksize--;
   7340           }
   7341         }
   7342 
   7343       if (stacksize != 0)
   7344         matchingpath += 1 + 2 * IMM2_SIZE;
   7345       }
   7346 
   7347       /* The stacksize == 0 is a common "else" case. */
   7348       if (stacksize == 0)
   7349         {
   7350         if (*cc == OP_ALT)
   7351           {
   7352           matchingpath = cc + 1 + LINK_SIZE;
   7353           cc += GET(cc, 1);
   7354           }
   7355         else
   7356           matchingpath = cc;
   7357         }
   7358     }
   7359   else
   7360     {
   7361     SLJIT_ASSERT(has_alternatives && *matchingpath >= OP_ASSERT && *matchingpath <= OP_ASSERTBACK_NOT);
   7362     /* Similar code as PUSH_BACKTRACK macro. */
   7363     assert = sljit_alloc_memory(compiler, sizeof(assert_backtrack));
   7364     if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   7365       return NULL;
   7366     memset(assert, 0, sizeof(assert_backtrack));
   7367     assert->common.cc = matchingpath;
   7368     BACKTRACK_AS(bracket_backtrack)->u.assert = assert;
   7369     matchingpath = compile_assert_matchingpath(common, matchingpath, assert, TRUE);
   7370     }
   7371   }
   7372 
   7373 compile_matchingpath(common, matchingpath, cc, backtrack);
   7374 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   7375   return NULL;
   7376 
   7377 if (opcode == OP_ONCE)
   7378   match_once_common(common, ket, BACKTRACK_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
   7379 
   7380 stacksize = 0;
   7381 if (repeat_type == OP_MINUPTO)
   7382   {
   7383   /* We need to preserve the counter. TMP2 will be used below. */
   7384   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);
   7385   stacksize++;
   7386   }
   7387 if (ket != OP_KET || bra != OP_BRA)
   7388   stacksize++;
   7389 if (offset != 0)
   7390   {
   7391   if (common->capture_last_ptr != 0)
   7392     stacksize++;
   7393   if (common->optimized_cbracket[offset >> 1] == 0)
   7394     stacksize += 2;
   7395   }
   7396 if (has_alternatives && opcode != OP_ONCE)
   7397   stacksize++;
   7398 
   7399 if (stacksize > 0)
   7400   allocate_stack(common, stacksize);
   7401 
   7402 stacksize = 0;
   7403 if (repeat_type == OP_MINUPTO)
   7404   {
   7405   /* TMP2 was set above. */
   7406   OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
   7407   stacksize++;
   7408   }
   7409 
   7410 if (ket != OP_KET || bra != OP_BRA)
   7411   {
   7412   if (ket != OP_KET)
   7413     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
   7414   else
   7415     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
   7416   stacksize++;
   7417   }
   7418 
   7419 if (offset != 0)
   7420   stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);
   7421 
   7422 if (has_alternatives)
   7423   {
   7424   if (opcode != OP_ONCE)
   7425     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
   7426   if (ket != OP_KETRMAX)
   7427     BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
   7428   }
   7429 
   7430 /* Must be after the matchingpath label. */
   7431 if (offset != 0 && common->optimized_cbracket[offset >> 1] != 0)
   7432   {
   7433   SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));
   7434   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
   7435   }
   7436 
   7437 if (ket == OP_KETRMAX)
   7438   {
   7439   if (repeat_type != 0)
   7440     {
   7441     if (has_alternatives)
   7442       BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
   7443     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
   7444     JUMPTO(SLJIT_NOT_ZERO, rmax_label);
   7445     /* Drop STR_PTR for greedy plus quantifier. */
   7446     if (opcode != OP_ONCE)
   7447       free_stack(common, 1);
   7448     }
   7449   else if (opcode == OP_ONCE || opcode >= OP_SBRA)
   7450     {
   7451     if (has_alternatives)
   7452       BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
   7453     /* Checking zero-length iteration. */
   7454     if (opcode != OP_ONCE)
   7455       {
   7456       CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0, rmax_label);
   7457       /* Drop STR_PTR for greedy plus quantifier. */
   7458       if (bra != OP_BRAZERO)
   7459         free_stack(common, 1);
   7460       }
   7461     else
   7462       /* TMP2 must contain the starting STR_PTR. */
   7463       CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmax_label);
   7464     }
   7465   else
   7466     JUMPTO(SLJIT_JUMP, rmax_label);
   7467   BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
   7468   }
   7469 
   7470 if (repeat_type == OP_EXACT)
   7471   {
   7472   count_match(common);
   7473   OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
   7474   JUMPTO(SLJIT_NOT_ZERO, rmax_label);
   7475   }
   7476 else if (repeat_type == OP_UPTO)
   7477   {
   7478   /* We need to preserve the counter. */
   7479   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);
   7480   allocate_stack(common, 1);
   7481   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
   7482   }
   7483 
   7484 if (bra == OP_BRAZERO)
   7485   BACKTRACK_AS(bracket_backtrack)->zero_matchingpath = LABEL();
   7486 
   7487 if (bra == OP_BRAMINZERO)
   7488   {
   7489   /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */
   7490   JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->matchingpath);
   7491   if (braminzero != NULL)
   7492     {
   7493     JUMPHERE(braminzero);
   7494     /* We need to release the end pointer to perform the
   7495     backtrack for the zero-length iteration. When
   7496     framesize is < 0, OP_ONCE will do the release itself. */
   7497     if (opcode == OP_ONCE && BACKTRACK_AS(bracket_backtrack)->u.framesize >= 0)
   7498       {
   7499       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7500       add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   7501       }
   7502     else if (ket == OP_KETRMIN && opcode != OP_ONCE)
   7503       free_stack(common, 1);
   7504     }
   7505   /* Continue to the normal backtrack. */
   7506   }
   7507 
   7508 if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)
   7509   count_match(common);
   7510 
   7511 /* Skip the other alternatives. */
   7512 while (*cc == OP_ALT)
   7513   cc += GET(cc, 1);
   7514 cc += 1 + LINK_SIZE;
   7515 
   7516 /* Temporarily encoding the needs_control_head in framesize. */
   7517 if (opcode == OP_ONCE)
   7518   BACKTRACK_AS(bracket_backtrack)->u.framesize = (BACKTRACK_AS(bracket_backtrack)->u.framesize << 1) | (needs_control_head ? 1 : 0);
   7519 return cc + repeat_length;
   7520 }
   7521 
   7522 static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
   7523 {
   7524 DEFINE_COMPILER;
   7525 backtrack_common *backtrack;
   7526 pcre_uchar opcode;
   7527 int private_data_ptr;
   7528 int cbraprivptr = 0;
   7529 BOOL needs_control_head;
   7530 int framesize;
   7531 int stacksize;
   7532 int offset = 0;
   7533 BOOL zero = FALSE;
   7534 pcre_uchar *ccbegin = NULL;
   7535 int stack; /* Also contains the offset of control head. */
   7536 struct sljit_label *loop = NULL;
   7537 struct jump_list *emptymatch = NULL;
   7538 
   7539 PUSH_BACKTRACK(sizeof(bracketpos_backtrack), cc, NULL);
   7540 if (*cc == OP_BRAPOSZERO)
   7541   {
   7542   zero = TRUE;
   7543   cc++;
   7544   }
   7545 
   7546 opcode = *cc;
   7547 private_data_ptr = PRIVATE_DATA(cc);
   7548 SLJIT_ASSERT(private_data_ptr != 0);
   7549 BACKTRACK_AS(bracketpos_backtrack)->private_data_ptr = private_data_ptr;
   7550 switch(opcode)
   7551   {
   7552   case OP_BRAPOS:
   7553   case OP_SBRAPOS:
   7554   ccbegin = cc + 1 + LINK_SIZE;
   7555   break;
   7556 
   7557   case OP_CBRAPOS:
   7558   case OP_SCBRAPOS:
   7559   offset = GET2(cc, 1 + LINK_SIZE);
   7560   /* This case cannot be optimized in the same was as
   7561   normal capturing brackets. */
   7562   SLJIT_ASSERT(common->optimized_cbracket[offset] == 0);
   7563   cbraprivptr = OVECTOR_PRIV(offset);
   7564   offset <<= 1;
   7565   ccbegin = cc + 1 + LINK_SIZE + IMM2_SIZE;
   7566   break;
   7567 
   7568   default:
   7569   SLJIT_ASSERT_STOP();
   7570   break;
   7571   }
   7572 
   7573 framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
   7574 BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;
   7575 if (framesize < 0)
   7576   {
   7577   if (offset != 0)
   7578     {
   7579     stacksize = 2;
   7580     if (common->capture_last_ptr != 0)
   7581       stacksize++;
   7582     }
   7583   else
   7584     stacksize = 1;
   7585 
   7586   if (needs_control_head)
   7587     stacksize++;
   7588   if (!zero)
   7589     stacksize++;
   7590 
   7591   BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
   7592   allocate_stack(common, stacksize);
   7593   if (framesize == no_frame)
   7594     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);
   7595 
   7596   stack = 0;
   7597   if (offset != 0)
   7598     {
   7599     stack = 2;
   7600     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
   7601     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
   7602     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
   7603     if (common->capture_last_ptr != 0)
   7604       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
   7605     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
   7606     if (needs_control_head)
   7607       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   7608     if (common->capture_last_ptr != 0)
   7609       {
   7610       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
   7611       stack = 3;
   7612       }
   7613     }
   7614   else
   7615     {
   7616     if (needs_control_head)
   7617       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   7618     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   7619     stack = 1;
   7620     }
   7621 
   7622   if (needs_control_head)
   7623     stack++;
   7624   if (!zero)
   7625     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), SLJIT_IMM, 1);
   7626   if (needs_control_head)
   7627     {
   7628     stack--;
   7629     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);
   7630     }
   7631   }
   7632 else
   7633   {
   7634   stacksize = framesize + 1;
   7635   if (!zero)
   7636     stacksize++;
   7637   if (needs_control_head)
   7638     stacksize++;
   7639   if (offset == 0)
   7640     stacksize++;
   7641   BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
   7642 
   7643   allocate_stack(common, stacksize);
   7644   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7645   if (needs_control_head)
   7646     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   7647   OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));
   7648 
   7649   stack = 0;
   7650   if (!zero)
   7651     {
   7652     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);
   7653     stack = 1;
   7654     }
   7655   if (needs_control_head)
   7656     {
   7657     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);
   7658     stack++;
   7659     }
   7660   if (offset == 0)
   7661     {
   7662     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);
   7663     stack++;
   7664     }
   7665   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);
   7666   init_frame(common, cc, NULL, stacksize - 1, stacksize - framesize, FALSE);
   7667   stack -= 1 + (offset == 0);
   7668   }
   7669 
   7670 if (offset != 0)
   7671   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);
   7672 
   7673 loop = LABEL();
   7674 while (*cc != OP_KETRPOS)
   7675   {
   7676   backtrack->top = NULL;
   7677   backtrack->topbacktracks = NULL;
   7678   cc += GET(cc, 1);
   7679 
   7680   compile_matchingpath(common, ccbegin, cc, backtrack);
   7681   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   7682     return NULL;
   7683 
   7684   if (framesize < 0)
   7685     {
   7686     if (framesize == no_frame)
   7687       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7688 
   7689     if (offset != 0)
   7690       {
   7691       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);
   7692       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
   7693       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);
   7694       if (common->capture_last_ptr != 0)
   7695         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
   7696       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
   7697       }
   7698     else
   7699       {
   7700       if (opcode == OP_SBRAPOS)
   7701         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   7702       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   7703       }
   7704 
   7705     /* Even if the match is empty, we need to reset the control head. */
   7706     if (needs_control_head)
   7707       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));
   7708 
   7709     if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)
   7710       add_jump(compiler, &emptymatch, CMP(SLJIT_EQUAL, TMP1, 0, STR_PTR, 0));
   7711 
   7712     if (!zero)
   7713       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);
   7714     }
   7715   else
   7716     {
   7717     if (offset != 0)
   7718       {
   7719       OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));
   7720       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);
   7721       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
   7722       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);
   7723       if (common->capture_last_ptr != 0)
   7724         OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
   7725       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
   7726       }
   7727     else
   7728       {
   7729       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7730       OP2(SLJIT_ADD, STACK_TOP, 0, TMP2, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));
   7731       if (opcode == OP_SBRAPOS)
   7732         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_sw));
   7733       OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_sw), STR_PTR, 0);
   7734       }
   7735 
   7736     /* Even if the match is empty, we need to reset the control head. */
   7737     if (needs_control_head)
   7738       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));
   7739 
   7740     if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)
   7741       add_jump(compiler, &emptymatch, CMP(SLJIT_EQUAL, TMP1, 0, STR_PTR, 0));
   7742 
   7743     if (!zero)
   7744       {
   7745       if (framesize < 0)
   7746         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);
   7747       else
   7748         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   7749       }
   7750     }
   7751 
   7752   JUMPTO(SLJIT_JUMP, loop);
   7753   flush_stubs(common);
   7754 
   7755   compile_backtrackingpath(common, backtrack->top);
   7756   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   7757     return NULL;
   7758   set_jumps(backtrack->topbacktracks, LABEL());
   7759 
   7760   if (framesize < 0)
   7761     {
   7762     if (offset != 0)
   7763       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);
   7764     else
   7765       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   7766     }
   7767   else
   7768     {
   7769     if (offset != 0)
   7770       {
   7771       /* Last alternative. */
   7772       if (*cc == OP_KETRPOS)
   7773         OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7774       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);
   7775       }
   7776     else
   7777       {
   7778       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   7779       OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_sw));
   7780       }
   7781     }
   7782 
   7783   if (*cc == OP_KETRPOS)
   7784     break;
   7785   ccbegin = cc + 1 + LINK_SIZE;
   7786   }
   7787 
   7788 /* We don't have to restore the control head in case of a failed match. */
   7789 
   7790 backtrack->topbacktracks = NULL;
   7791 if (!zero)
   7792   {
   7793   if (framesize < 0)
   7794     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));
   7795   else /* TMP2 is set to [private_data_ptr] above. */
   7796     add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_sw), SLJIT_IMM, 0));
   7797   }
   7798 
   7799 /* None of them matched. */
   7800 set_jumps(emptymatch, LABEL());
   7801 count_match(common);
   7802 return cc + 1 + LINK_SIZE;
   7803 }
   7804 
   7805 static SLJIT_INLINE pcre_uchar *get_iterator_parameters(compiler_common *common, pcre_uchar *cc, pcre_uchar *opcode, pcre_uchar *type, int *max, int *min, pcre_uchar **end)
   7806 {
   7807 int class_len;
   7808 
   7809 *opcode = *cc;
   7810 if (*opcode >= OP_STAR && *opcode <= OP_POSUPTO)
   7811   {
   7812   cc++;
   7813   *type = OP_CHAR;
   7814   }
   7815 else if (*opcode >= OP_STARI && *opcode <= OP_POSUPTOI)
   7816   {
   7817   cc++;
   7818   *type = OP_CHARI;
   7819   *opcode -= OP_STARI - OP_STAR;
   7820   }
   7821 else if (*opcode >= OP_NOTSTAR && *opcode <= OP_NOTPOSUPTO)
   7822   {
   7823   cc++;
   7824   *type = OP_NOT;
   7825   *opcode -= OP_NOTSTAR - OP_STAR;
   7826   }
   7827 else if (*opcode >= OP_NOTSTARI && *opcode <= OP_NOTPOSUPTOI)
   7828   {
   7829   cc++;
   7830   *type = OP_NOTI;
   7831   *opcode -= OP_NOTSTARI - OP_STAR;
   7832   }
   7833 else if (*opcode >= OP_TYPESTAR && *opcode <= OP_TYPEPOSUPTO)
   7834   {
   7835   cc++;
   7836   *opcode -= OP_TYPESTAR - OP_STAR;
   7837   *type = 0;
   7838   }
   7839 else
   7840   {
   7841   SLJIT_ASSERT(*opcode == OP_CLASS || *opcode == OP_NCLASS || *opcode == OP_XCLASS);
   7842   *type = *opcode;
   7843   cc++;
   7844   class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
   7845   *opcode = cc[class_len - 1];
   7846   if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)
   7847     {
   7848     *opcode -= OP_CRSTAR - OP_STAR;
   7849     if (end != NULL)
   7850       *end = cc + class_len;
   7851     }
   7852   else if (*opcode >= OP_CRPOSSTAR && *opcode <= OP_CRPOSQUERY)
   7853     {
   7854     *opcode -= OP_CRPOSSTAR - OP_POSSTAR;
   7855     if (end != NULL)
   7856       *end = cc + class_len;
   7857     }
   7858   else
   7859     {
   7860     SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE || *opcode == OP_CRPOSRANGE);
   7861     *max = GET2(cc, (class_len + IMM2_SIZE));
   7862     *min = GET2(cc, class_len);
   7863 
   7864     if (*min == 0)
   7865       {
   7866       SLJIT_ASSERT(*max != 0);
   7867       *opcode = (*opcode == OP_CRRANGE) ? OP_UPTO : (*opcode == OP_CRMINRANGE ? OP_MINUPTO : OP_POSUPTO);
   7868       }
   7869     if (*max == *min)
   7870       *opcode = OP_EXACT;
   7871 
   7872     if (end != NULL)
   7873       *end = cc + class_len + 2 * IMM2_SIZE;
   7874     }
   7875   return cc;
   7876   }
   7877 
   7878 if (*opcode == OP_UPTO || *opcode == OP_MINUPTO || *opcode == OP_EXACT || *opcode == OP_POSUPTO)
   7879   {
   7880   *max = GET2(cc, 0);
   7881   cc += IMM2_SIZE;
   7882   }
   7883 
   7884 if (*type == 0)
   7885   {
   7886   *type = *cc;
   7887   if (end != NULL)
   7888     *end = next_opcode(common, cc);
   7889   cc++;
   7890   return cc;
   7891   }
   7892 
   7893 if (end != NULL)
   7894   {
   7895   *end = cc + 1;
   7896 #ifdef SUPPORT_UTF
   7897   if (common->utf && HAS_EXTRALEN(*cc)) *end += GET_EXTRALEN(*cc);
   7898 #endif
   7899   }
   7900 return cc;
   7901 }
   7902 
   7903 static pcre_uchar *compile_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
   7904 {
   7905 DEFINE_COMPILER;
   7906 backtrack_common *backtrack;
   7907 pcre_uchar opcode;
   7908 pcre_uchar type;
   7909 int max = -1, min = -1;
   7910 pcre_uchar *end;
   7911 jump_list *nomatch = NULL;
   7912 struct sljit_jump *jump = NULL;
   7913 struct sljit_label *label;
   7914 int private_data_ptr = PRIVATE_DATA(cc);
   7915 int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_SP);
   7916 int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;
   7917 int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);
   7918 int tmp_base, tmp_offset;
   7919 
   7920 PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
   7921 
   7922 cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, &end);
   7923 
   7924 switch(type)
   7925   {
   7926   case OP_NOT_DIGIT:
   7927   case OP_DIGIT:
   7928   case OP_NOT_WHITESPACE:
   7929   case OP_WHITESPACE:
   7930   case OP_NOT_WORDCHAR:
   7931   case OP_WORDCHAR:
   7932   case OP_ANY:
   7933   case OP_ALLANY:
   7934   case OP_ANYBYTE:
   7935   case OP_ANYNL:
   7936   case OP_NOT_HSPACE:
   7937   case OP_HSPACE:
   7938   case OP_NOT_VSPACE:
   7939   case OP_VSPACE:
   7940   case OP_CHAR:
   7941   case OP_CHARI:
   7942   case OP_NOT:
   7943   case OP_NOTI:
   7944   case OP_CLASS:
   7945   case OP_NCLASS:
   7946   tmp_base = TMP3;
   7947   tmp_offset = 0;
   7948   break;
   7949 
   7950   default:
   7951   SLJIT_ASSERT_STOP();
   7952   /* Fall through. */
   7953 
   7954   case OP_EXTUNI:
   7955   case OP_XCLASS:
   7956   case OP_NOTPROP:
   7957   case OP_PROP:
   7958   tmp_base = SLJIT_MEM1(SLJIT_SP);
   7959   tmp_offset = POSSESSIVE0;
   7960   break;
   7961   }
   7962 
   7963 switch(opcode)
   7964   {
   7965   case OP_STAR:
   7966   case OP_PLUS:
   7967   case OP_UPTO:
   7968   case OP_CRRANGE:
   7969   if (type == OP_ANYNL || type == OP_EXTUNI)
   7970     {
   7971     SLJIT_ASSERT(private_data_ptr == 0);
   7972     if (opcode == OP_STAR || opcode == OP_UPTO)
   7973       {
   7974       allocate_stack(common, 2);
   7975       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   7976       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
   7977       }
   7978     else
   7979       {
   7980       allocate_stack(common, 1);
   7981       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   7982       }
   7983 
   7984     if (opcode == OP_UPTO || opcode == OP_CRRANGE)
   7985       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, SLJIT_IMM, 0);
   7986 
   7987     label = LABEL();
   7988     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
   7989     if (opcode == OP_UPTO || opcode == OP_CRRANGE)
   7990       {
   7991       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0);
   7992       OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   7993       if (opcode == OP_CRRANGE && min > 0)
   7994         CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, min, label);
   7995       if (opcode == OP_UPTO || (opcode == OP_CRRANGE && max > 0))
   7996         jump = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);
   7997       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, TMP1, 0);
   7998       }
   7999 
   8000     /* We cannot use TMP3 because of this allocate_stack. */
   8001     allocate_stack(common, 1);
   8002     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   8003     JUMPTO(SLJIT_JUMP, label);
   8004     if (jump != NULL)
   8005       JUMPHERE(jump);
   8006     }
   8007   else
   8008     {
   8009     if (opcode == OP_PLUS)
   8010       compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
   8011     if (private_data_ptr == 0)
   8012       allocate_stack(common, 2);
   8013     OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   8014     if (opcode <= OP_PLUS)
   8015       OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
   8016     else
   8017       OP1(SLJIT_MOV, base, offset1, SLJIT_IMM, 1);
   8018     label = LABEL();
   8019     compile_char1_matchingpath(common, type, cc, &nomatch);
   8020     OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   8021     if (opcode <= OP_PLUS)
   8022       JUMPTO(SLJIT_JUMP, label);
   8023     else if (opcode == OP_CRRANGE && max == 0)
   8024       {
   8025       OP2(SLJIT_ADD, base, offset1, base, offset1, SLJIT_IMM, 1);
   8026       JUMPTO(SLJIT_JUMP, label);
   8027       }
   8028     else
   8029       {
   8030       OP1(SLJIT_MOV, TMP1, 0, base, offset1);
   8031       OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   8032       OP1(SLJIT_MOV, base, offset1, TMP1, 0);
   8033       CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, max + 1, label);
   8034       }
   8035     set_jumps(nomatch, LABEL());
   8036     if (opcode == OP_CRRANGE)
   8037       add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_LESS, base, offset1, SLJIT_IMM, min + 1));
   8038     OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
   8039     }
   8040   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
   8041   break;
   8042 
   8043   case OP_MINSTAR:
   8044   case OP_MINPLUS:
   8045   if (opcode == OP_MINPLUS)
   8046     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
   8047   if (private_data_ptr == 0)
   8048     allocate_stack(common, 1);
   8049   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   8050   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
   8051   break;
   8052 
   8053   case OP_MINUPTO:
   8054   case OP_CRMINRANGE:
   8055   if (private_data_ptr == 0)
   8056     allocate_stack(common, 2);
   8057   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   8058   OP1(SLJIT_MOV, base, offset1, SLJIT_IMM, 1);
   8059   if (opcode == OP_CRMINRANGE)
   8060     add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
   8061   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
   8062   break;
   8063 
   8064   case OP_QUERY:
   8065   case OP_MINQUERY:
   8066   if (private_data_ptr == 0)
   8067     allocate_stack(common, 1);
   8068   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   8069   if (opcode == OP_QUERY)
   8070     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
   8071   BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();
   8072   break;
   8073 
   8074   case OP_EXACT:
   8075   OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
   8076   label = LABEL();
   8077   compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
   8078   OP2(SLJIT_SUB | SLJIT_SET_E, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
   8079   JUMPTO(SLJIT_NOT_ZERO, label);
   8080   break;
   8081 
   8082   case OP_POSSTAR:
   8083   case OP_POSPLUS:
   8084   case OP_POSUPTO:
   8085   if (opcode == OP_POSPLUS)
   8086     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
   8087   if (opcode == OP_POSUPTO)
   8088     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, SLJIT_IMM, max);
   8089   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
   8090   label = LABEL();
   8091   compile_char1_matchingpath(common, type, cc, &nomatch);
   8092   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
   8093   if (opcode != OP_POSUPTO)
   8094     JUMPTO(SLJIT_JUMP, label);
   8095   else
   8096     {
   8097     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, SLJIT_IMM, 1);
   8098     JUMPTO(SLJIT_NOT_ZERO, label);
   8099     }
   8100   set_jumps(nomatch, LABEL());
   8101   OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
   8102   break;
   8103 
   8104   case OP_POSQUERY:
   8105   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
   8106   compile_char1_matchingpath(common, type, cc, &nomatch);
   8107   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
   8108   set_jumps(nomatch, LABEL());
   8109   OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
   8110   break;
   8111 
   8112   case OP_CRPOSRANGE:
   8113   /* Combination of OP_EXACT and OP_POSSTAR or OP_POSUPTO */
   8114   OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, min);
   8115   label = LABEL();
   8116   compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
   8117   OP2(SLJIT_SUB | SLJIT_SET_E, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
   8118   JUMPTO(SLJIT_NOT_ZERO, label);
   8119 
   8120   if (max != 0)
   8121     {
   8122     SLJIT_ASSERT(max - min > 0);
   8123     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, SLJIT_IMM, max - min);
   8124     }
   8125   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
   8126   label = LABEL();
   8127   compile_char1_matchingpath(common, type, cc, &nomatch);
   8128   OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
   8129   if (max == 0)
   8130     JUMPTO(SLJIT_JUMP, label);
   8131   else
   8132     {
   8133     OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, SLJIT_IMM, 1);
   8134     JUMPTO(SLJIT_NOT_ZERO, label);
   8135     }
   8136   set_jumps(nomatch, LABEL());
   8137   OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
   8138   break;
   8139 
   8140   default:
   8141   SLJIT_ASSERT_STOP();
   8142   break;
   8143   }
   8144 
   8145 count_match(common);
   8146 return end;
   8147 }
   8148 
   8149 static SLJIT_INLINE pcre_uchar *compile_fail_accept_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
   8150 {
   8151 DEFINE_COMPILER;
   8152 backtrack_common *backtrack;
   8153 
   8154 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
   8155 
   8156 if (*cc == OP_FAIL)
   8157   {
   8158   add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
   8159   return cc + 1;
   8160   }
   8161 
   8162 if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL || !common->might_be_empty)
   8163   {
   8164   /* No need to check notempty conditions. */
   8165   if (common->accept_label == NULL)
   8166     add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));
   8167   else
   8168     JUMPTO(SLJIT_JUMP, common->accept_label);
   8169   return cc + 1;
   8170   }
   8171 
   8172 if (common->accept_label == NULL)
   8173   add_jump(compiler, &common->accept, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0)));
   8174 else
   8175   CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), common->accept_label);
   8176 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   8177 OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
   8178 add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
   8179 OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
   8180 if (common->accept_label == NULL)
   8181   add_jump(compiler, &common->accept, CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
   8182 else
   8183   CMPTO(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0, common->accept_label);
   8184 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
   8185 if (common->accept_label == NULL)
   8186   add_jump(compiler, &common->accept, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0));
   8187 else
   8188   CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->accept_label);
   8189 add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
   8190 return cc + 1;
   8191 }
   8192 
   8193 static SLJIT_INLINE pcre_uchar *compile_close_matchingpath(compiler_common *common, pcre_uchar *cc)
   8194 {
   8195 DEFINE_COMPILER;
   8196 int offset = GET2(cc, 1);
   8197 BOOL optimized_cbracket = common->optimized_cbracket[offset] != 0;
   8198 
   8199 /* Data will be discarded anyway... */
   8200 if (common->currententry != NULL)
   8201   return cc + 1 + IMM2_SIZE;
   8202 
   8203 if (!optimized_cbracket)
   8204   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR_PRIV(offset));
   8205 offset <<= 1;
   8206 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
   8207 if (!optimized_cbracket)
   8208   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
   8209 return cc + 1 + IMM2_SIZE;
   8210 }
   8211 
   8212 static SLJIT_INLINE pcre_uchar *compile_control_verb_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
   8213 {
   8214 DEFINE_COMPILER;
   8215 backtrack_common *backtrack;
   8216 pcre_uchar opcode = *cc;
   8217 pcre_uchar *ccend = cc + 1;
   8218 
   8219 if (opcode == OP_PRUNE_ARG || opcode == OP_SKIP_ARG || opcode == OP_THEN_ARG)
   8220   ccend += 2 + cc[1];
   8221 
   8222 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
   8223 
   8224 if (opcode == OP_SKIP)
   8225   {
   8226   allocate_stack(common, 1);
   8227   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   8228   return ccend;
   8229   }
   8230 
   8231 if (opcode == OP_PRUNE_ARG || opcode == OP_THEN_ARG)
   8232   {
   8233   OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   8234   OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
   8235   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP2, 0);
   8236   OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
   8237   }
   8238 
   8239 return ccend;
   8240 }
   8241 
   8242 static pcre_uchar then_trap_opcode[1] = { OP_THEN_TRAP };
   8243 
   8244 static SLJIT_INLINE void compile_then_trap_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
   8245 {
   8246 DEFINE_COMPILER;
   8247 backtrack_common *backtrack;
   8248 BOOL needs_control_head;
   8249 int size;
   8250 
   8251 PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
   8252 common->then_trap = BACKTRACK_AS(then_trap_backtrack);
   8253 BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
   8254 BACKTRACK_AS(then_trap_backtrack)->start = (sljit_sw)(cc - common->start);
   8255 BACKTRACK_AS(then_trap_backtrack)->framesize = get_framesize(common, cc, ccend, FALSE, &needs_control_head);
   8256 
   8257 size = BACKTRACK_AS(then_trap_backtrack)->framesize;
   8258 size = 3 + (size < 0 ? 0 : size);
   8259 
   8260 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   8261 allocate_stack(common, size);
   8262 if (size > 3)
   8263   OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0, SLJIT_IMM, (size - 3) * sizeof(sljit_sw));
   8264 else
   8265   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0);
   8266 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 1), SLJIT_IMM, BACKTRACK_AS(then_trap_backtrack)->start);
   8267 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 2), SLJIT_IMM, type_then_trap);
   8268 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 3), TMP2, 0);
   8269 
   8270 size = BACKTRACK_AS(then_trap_backtrack)->framesize;
   8271 if (size >= 0)
   8272   init_frame(common, cc, ccend, size - 1, 0, FALSE);
   8273 }
   8274 
   8275 static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
   8276 {
   8277 DEFINE_COMPILER;
   8278 backtrack_common *backtrack;
   8279 BOOL has_then_trap = FALSE;
   8280 then_trap_backtrack *save_then_trap = NULL;
   8281 
   8282 SLJIT_ASSERT(*ccend == OP_END || (*ccend >= OP_ALT && *ccend <= OP_KETRPOS));
   8283 
   8284 if (common->has_then && common->then_offsets[cc - common->start] != 0)
   8285   {
   8286   SLJIT_ASSERT(*ccend != OP_END && common->control_head_ptr != 0);
   8287   has_then_trap = TRUE;
   8288   save_then_trap = common->then_trap;
   8289   /* Tail item on backtrack. */
   8290   compile_then_trap_matchingpath(common, cc, ccend, parent);
   8291   }
   8292 
   8293 while (cc < ccend)
   8294   {
   8295   switch(*cc)
   8296     {
   8297     case OP_SOD:
   8298     case OP_SOM:
   8299     case OP_NOT_WORD_BOUNDARY:
   8300     case OP_WORD_BOUNDARY:
   8301     case OP_NOT_DIGIT:
   8302     case OP_DIGIT:
   8303     case OP_NOT_WHITESPACE:
   8304     case OP_WHITESPACE:
   8305     case OP_NOT_WORDCHAR:
   8306     case OP_WORDCHAR:
   8307     case OP_ANY:
   8308     case OP_ALLANY:
   8309     case OP_ANYBYTE:
   8310     case OP_NOTPROP:
   8311     case OP_PROP:
   8312     case OP_ANYNL:
   8313     case OP_NOT_HSPACE:
   8314     case OP_HSPACE:
   8315     case OP_NOT_VSPACE:
   8316     case OP_VSPACE:
   8317     case OP_EXTUNI:
   8318     case OP_EODN:
   8319     case OP_EOD:
   8320     case OP_CIRC:
   8321     case OP_CIRCM:
   8322     case OP_DOLL:
   8323     case OP_DOLLM:
   8324     case OP_NOT:
   8325     case OP_NOTI:
   8326     case OP_REVERSE:
   8327     cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
   8328     break;
   8329 
   8330     case OP_SET_SOM:
   8331     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
   8332     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
   8333     allocate_stack(common, 1);
   8334     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), STR_PTR, 0);
   8335     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
   8336     cc++;
   8337     break;
   8338 
   8339     case OP_CHAR:
   8340     case OP_CHARI:
   8341     if (common->mode == JIT_COMPILE)
   8342       cc = compile_charn_matchingpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
   8343     else
   8344       cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
   8345     break;
   8346 
   8347     case OP_STAR:
   8348     case OP_MINSTAR:
   8349     case OP_PLUS:
   8350     case OP_MINPLUS:
   8351     case OP_QUERY:
   8352     case OP_MINQUERY:
   8353     case OP_UPTO:
   8354     case OP_MINUPTO:
   8355     case OP_EXACT:
   8356     case OP_POSSTAR:
   8357     case OP_POSPLUS:
   8358     case OP_POSQUERY:
   8359     case OP_POSUPTO:
   8360     case OP_STARI:
   8361     case OP_MINSTARI:
   8362     case OP_PLUSI:
   8363     case OP_MINPLUSI:
   8364     case OP_QUERYI:
   8365     case OP_MINQUERYI:
   8366     case OP_UPTOI:
   8367     case OP_MINUPTOI:
   8368     case OP_EXACTI:
   8369     case OP_POSSTARI:
   8370     case OP_POSPLUSI:
   8371     case OP_POSQUERYI:
   8372     case OP_POSUPTOI:
   8373     case OP_NOTSTAR:
   8374     case OP_NOTMINSTAR:
   8375     case OP_NOTPLUS:
   8376     case OP_NOTMINPLUS:
   8377     case OP_NOTQUERY:
   8378     case OP_NOTMINQUERY:
   8379     case OP_NOTUPTO:
   8380     case OP_NOTMINUPTO:
   8381     case OP_NOTEXACT:
   8382     case OP_NOTPOSSTAR:
   8383     case OP_NOTPOSPLUS:
   8384     case OP_NOTPOSQUERY:
   8385     case OP_NOTPOSUPTO:
   8386     case OP_NOTSTARI:
   8387     case OP_NOTMINSTARI:
   8388     case OP_NOTPLUSI:
   8389     case OP_NOTMINPLUSI:
   8390     case OP_NOTQUERYI:
   8391     case OP_NOTMINQUERYI:
   8392     case OP_NOTUPTOI:
   8393     case OP_NOTMINUPTOI:
   8394     case OP_NOTEXACTI:
   8395     case OP_NOTPOSSTARI:
   8396     case OP_NOTPOSPLUSI:
   8397     case OP_NOTPOSQUERYI:
   8398     case OP_NOTPOSUPTOI:
   8399     case OP_TYPESTAR:
   8400     case OP_TYPEMINSTAR:
   8401     case OP_TYPEPLUS:
   8402     case OP_TYPEMINPLUS:
   8403     case OP_TYPEQUERY:
   8404     case OP_TYPEMINQUERY:
   8405     case OP_TYPEUPTO:
   8406     case OP_TYPEMINUPTO:
   8407     case OP_TYPEEXACT:
   8408     case OP_TYPEPOSSTAR:
   8409     case OP_TYPEPOSPLUS:
   8410     case OP_TYPEPOSQUERY:
   8411     case OP_TYPEPOSUPTO:
   8412     cc = compile_iterator_matchingpath(common, cc, parent);
   8413     break;
   8414 
   8415     case OP_CLASS:
   8416     case OP_NCLASS:
   8417     if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRPOSRANGE)
   8418       cc = compile_iterator_matchingpath(common, cc, parent);
   8419     else
   8420       cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
   8421     break;
   8422 
   8423 #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
   8424     case OP_XCLASS:
   8425     if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRPOSRANGE)
   8426       cc = compile_iterator_matchingpath(common, cc, parent);
   8427     else
   8428       cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
   8429     break;
   8430 #endif
   8431 
   8432     case OP_REF:
   8433     case OP_REFI:
   8434     if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRPOSRANGE)
   8435       cc = compile_ref_iterator_matchingpath(common, cc, parent);
   8436     else
   8437       {
   8438       compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
   8439       cc += 1 + IMM2_SIZE;
   8440       }
   8441     break;
   8442 
   8443     case OP_DNREF:
   8444     case OP_DNREFI:
   8445     if (cc[1 + 2 * IMM2_SIZE] >= OP_CRSTAR && cc[1 + 2 * IMM2_SIZE] <= OP_CRPOSRANGE)
   8446       cc = compile_ref_iterator_matchingpath(common, cc, parent);
   8447     else
   8448       {
   8449       compile_dnref_search(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
   8450       compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
   8451       cc += 1 + 2 * IMM2_SIZE;
   8452       }
   8453     break;
   8454 
   8455     case OP_RECURSE:
   8456     cc = compile_recurse_matchingpath(common, cc, parent);
   8457     break;
   8458 
   8459     case OP_CALLOUT:
   8460     cc = compile_callout_matchingpath(common, cc, parent);
   8461     break;
   8462 
   8463     case OP_ASSERT:
   8464     case OP_ASSERT_NOT:
   8465     case OP_ASSERTBACK:
   8466     case OP_ASSERTBACK_NOT:
   8467     PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
   8468     cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
   8469     break;
   8470 
   8471     case OP_BRAMINZERO:
   8472     PUSH_BACKTRACK_NOVALUE(sizeof(braminzero_backtrack), cc);
   8473     cc = bracketend(cc + 1);
   8474     if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)
   8475       {
   8476       allocate_stack(common, 1);
   8477       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   8478       }
   8479     else
   8480       {
   8481       allocate_stack(common, 2);
   8482       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   8483       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), STR_PTR, 0);
   8484       }
   8485     BACKTRACK_AS(braminzero_backtrack)->matchingpath = LABEL();
   8486     count_match(common);
   8487     break;
   8488 
   8489     case OP_ONCE:
   8490     case OP_ONCE_NC:
   8491     case OP_BRA:
   8492     case OP_CBRA:
   8493     case OP_COND:
   8494     case OP_SBRA:
   8495     case OP_SCBRA:
   8496     case OP_SCOND:
   8497     cc = compile_bracket_matchingpath(common, cc, parent);
   8498     break;
   8499 
   8500     case OP_BRAZERO:
   8501     if (cc[1] > OP_ASSERTBACK_NOT)
   8502       cc = compile_bracket_matchingpath(common, cc, parent);
   8503     else
   8504       {
   8505       PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
   8506       cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
   8507       }
   8508     break;
   8509 
   8510     case OP_BRAPOS:
   8511     case OP_CBRAPOS:
   8512     case OP_SBRAPOS:
   8513     case OP_SCBRAPOS:
   8514     case OP_BRAPOSZERO:
   8515     cc = compile_bracketpos_matchingpath(common, cc, parent);
   8516     break;
   8517 
   8518     case OP_MARK:
   8519     PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
   8520     SLJIT_ASSERT(common->mark_ptr != 0);
   8521     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
   8522     allocate_stack(common, common->has_skip_arg ? 5 : 1);
   8523     OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   8524     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0), TMP2, 0);
   8525     OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
   8526     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP2, 0);
   8527     OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
   8528     if (common->has_skip_arg)
   8529       {
   8530       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   8531       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0);
   8532       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, type_mark);
   8533       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), SLJIT_IMM, (sljit_sw)(cc + 2));
   8534       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(3), STR_PTR, 0);
   8535       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
   8536       }
   8537     cc += 1 + 2 + cc[1];
   8538     break;
   8539 
   8540     case OP_PRUNE:
   8541     case OP_PRUNE_ARG:
   8542     case OP_SKIP:
   8543     case OP_SKIP_ARG:
   8544     case OP_THEN:
   8545     case OP_THEN_ARG:
   8546     case OP_COMMIT:
   8547     cc = compile_control_verb_matchingpath(common, cc, parent);
   8548     break;
   8549 
   8550     case OP_FAIL:
   8551     case OP_ACCEPT:
   8552     case OP_ASSERT_ACCEPT:
   8553     cc = compile_fail_accept_matchingpath(common, cc, parent);
   8554     break;
   8555 
   8556     case OP_CLOSE:
   8557     cc = compile_close_matchingpath(common, cc);
   8558     break;
   8559 
   8560     case OP_SKIPZERO:
   8561     cc = bracketend(cc + 1);
   8562     break;
   8563 
   8564     default:
   8565     SLJIT_ASSERT_STOP();
   8566     return;
   8567     }
   8568   if (cc == NULL)
   8569     return;
   8570   }
   8571 
   8572 if (has_then_trap)
   8573   {
   8574   /* Head item on backtrack. */
   8575   PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
   8576   BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
   8577   BACKTRACK_AS(then_trap_backtrack)->then_trap = common->then_trap;
   8578   common->then_trap = save_then_trap;
   8579   }
   8580 SLJIT_ASSERT(cc == ccend);
   8581 }
   8582 
   8583 #undef PUSH_BACKTRACK
   8584 #undef PUSH_BACKTRACK_NOVALUE
   8585 #undef BACKTRACK_AS
   8586 
   8587 #define COMPILE_BACKTRACKINGPATH(current) \
   8588   do \
   8589     { \
   8590     compile_backtrackingpath(common, (current)); \
   8591     if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
   8592       return; \
   8593     } \
   8594   while (0)
   8595 
   8596 #define CURRENT_AS(type) ((type *)current)
   8597 
   8598 static void compile_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   8599 {
   8600 DEFINE_COMPILER;
   8601 pcre_uchar *cc = current->cc;
   8602 pcre_uchar opcode;
   8603 pcre_uchar type;
   8604 int max = -1, min = -1;
   8605 struct sljit_label *label = NULL;
   8606 struct sljit_jump *jump = NULL;
   8607 jump_list *jumplist = NULL;
   8608 int private_data_ptr = PRIVATE_DATA(cc);
   8609 int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_SP);
   8610 int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;
   8611 int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);
   8612 
   8613 cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, NULL);
   8614 
   8615 switch(opcode)
   8616   {
   8617   case OP_STAR:
   8618   case OP_PLUS:
   8619   case OP_UPTO:
   8620   case OP_CRRANGE:
   8621   if (type == OP_ANYNL || type == OP_EXTUNI)
   8622     {
   8623     SLJIT_ASSERT(private_data_ptr == 0);
   8624     set_jumps(current->topbacktracks, LABEL());
   8625     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8626     free_stack(common, 1);
   8627     CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);
   8628     }
   8629   else
   8630     {
   8631     if (opcode == OP_UPTO)
   8632       min = 0;
   8633     if (opcode <= OP_PLUS)
   8634       {
   8635       OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
   8636       jump = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, base, offset1);
   8637       }
   8638     else
   8639       {
   8640       OP1(SLJIT_MOV, TMP1, 0, base, offset1);
   8641       OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
   8642       jump = CMP(SLJIT_LESS_EQUAL, TMP1, 0, SLJIT_IMM, min + 1);
   8643       OP2(SLJIT_SUB, base, offset1, TMP1, 0, SLJIT_IMM, 1);
   8644       }
   8645     skip_char_back(common);
   8646     OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   8647     JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);
   8648     if (opcode == OP_CRRANGE)
   8649       set_jumps(current->topbacktracks, LABEL());
   8650     JUMPHERE(jump);
   8651     if (private_data_ptr == 0)
   8652       free_stack(common, 2);
   8653     if (opcode == OP_PLUS)
   8654       set_jumps(current->topbacktracks, LABEL());
   8655     }
   8656   break;
   8657 
   8658   case OP_MINSTAR:
   8659   case OP_MINPLUS:
   8660   OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
   8661   compile_char1_matchingpath(common, type, cc, &jumplist);
   8662   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   8663   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);
   8664   set_jumps(jumplist, LABEL());
   8665   if (private_data_ptr == 0)
   8666     free_stack(common, 1);
   8667   if (opcode == OP_MINPLUS)
   8668     set_jumps(current->topbacktracks, LABEL());
   8669   break;
   8670 
   8671   case OP_MINUPTO:
   8672   case OP_CRMINRANGE:
   8673   if (opcode == OP_CRMINRANGE)
   8674     {
   8675     label = LABEL();
   8676     set_jumps(current->topbacktracks, label);
   8677     }
   8678   OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
   8679   compile_char1_matchingpath(common, type, cc, &jumplist);
   8680 
   8681   OP1(SLJIT_MOV, TMP1, 0, base, offset1);
   8682   OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
   8683   OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   8684   OP1(SLJIT_MOV, base, offset1, TMP1, 0);
   8685 
   8686   if (opcode == OP_CRMINRANGE)
   8687     CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, min + 1, label);
   8688 
   8689   if (opcode == OP_CRMINRANGE && max == 0)
   8690     JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);
   8691   else
   8692     CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, max + 2, CURRENT_AS(iterator_backtrack)->matchingpath);
   8693 
   8694   set_jumps(jumplist, LABEL());
   8695   if (private_data_ptr == 0)
   8696     free_stack(common, 2);
   8697   break;
   8698 
   8699   case OP_QUERY:
   8700   OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
   8701   OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);
   8702   CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);
   8703   jump = JUMP(SLJIT_JUMP);
   8704   set_jumps(current->topbacktracks, LABEL());
   8705   OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
   8706   OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);
   8707   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);
   8708   JUMPHERE(jump);
   8709   if (private_data_ptr == 0)
   8710     free_stack(common, 1);
   8711   break;
   8712 
   8713   case OP_MINQUERY:
   8714   OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
   8715   OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);
   8716   jump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
   8717   compile_char1_matchingpath(common, type, cc, &jumplist);
   8718   JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);
   8719   set_jumps(jumplist, LABEL());
   8720   JUMPHERE(jump);
   8721   if (private_data_ptr == 0)
   8722     free_stack(common, 1);
   8723   break;
   8724 
   8725   case OP_EXACT:
   8726   case OP_POSPLUS:
   8727   case OP_CRPOSRANGE:
   8728   set_jumps(current->topbacktracks, LABEL());
   8729   break;
   8730 
   8731   case OP_POSSTAR:
   8732   case OP_POSQUERY:
   8733   case OP_POSUPTO:
   8734   break;
   8735 
   8736   default:
   8737   SLJIT_ASSERT_STOP();
   8738   break;
   8739   }
   8740 }
   8741 
   8742 static SLJIT_INLINE void compile_ref_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   8743 {
   8744 DEFINE_COMPILER;
   8745 pcre_uchar *cc = current->cc;
   8746 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
   8747 pcre_uchar type;
   8748 
   8749 type = cc[ref ? 1 + IMM2_SIZE : 1 + 2 * IMM2_SIZE];
   8750 
   8751 if ((type & 0x1) == 0)
   8752   {
   8753   /* Maximize case. */
   8754   set_jumps(current->topbacktracks, LABEL());
   8755   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8756   free_stack(common, 1);
   8757   CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);
   8758   return;
   8759   }
   8760 
   8761 OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8762 CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);
   8763 set_jumps(current->topbacktracks, LABEL());
   8764 free_stack(common, ref ? 2 : 3);
   8765 }
   8766 
   8767 static SLJIT_INLINE void compile_recurse_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   8768 {
   8769 DEFINE_COMPILER;
   8770 
   8771 if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
   8772   compile_backtrackingpath(common, current->top);
   8773 set_jumps(current->topbacktracks, LABEL());
   8774 if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
   8775   return;
   8776 
   8777 if (common->has_set_som && common->mark_ptr != 0)
   8778   {
   8779   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8780   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   8781   free_stack(common, 2);
   8782   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), TMP2, 0);
   8783   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP1, 0);
   8784   }
   8785 else if (common->has_set_som || common->mark_ptr != 0)
   8786   {
   8787   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8788   free_stack(common, 1);
   8789   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr, TMP2, 0);
   8790   }
   8791 }
   8792 
   8793 static void compile_assert_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   8794 {
   8795 DEFINE_COMPILER;
   8796 pcre_uchar *cc = current->cc;
   8797 pcre_uchar bra = OP_BRA;
   8798 struct sljit_jump *brajump = NULL;
   8799 
   8800 SLJIT_ASSERT(*cc != OP_BRAMINZERO);
   8801 if (*cc == OP_BRAZERO)
   8802   {
   8803   bra = *cc;
   8804   cc++;
   8805   }
   8806 
   8807 if (bra == OP_BRAZERO)
   8808   {
   8809   SLJIT_ASSERT(current->topbacktracks == NULL);
   8810   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8811   }
   8812 
   8813 if (CURRENT_AS(assert_backtrack)->framesize < 0)
   8814   {
   8815   set_jumps(current->topbacktracks, LABEL());
   8816 
   8817   if (bra == OP_BRAZERO)
   8818     {
   8819     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   8820     CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->matchingpath);
   8821     free_stack(common, 1);
   8822     }
   8823   return;
   8824   }
   8825 
   8826 if (bra == OP_BRAZERO)
   8827   {
   8828   if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)
   8829     {
   8830     OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   8831     CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->matchingpath);
   8832     free_stack(common, 1);
   8833     return;
   8834     }
   8835   free_stack(common, 1);
   8836   brajump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
   8837   }
   8838 
   8839 if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)
   8840   {
   8841   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(assert_backtrack)->private_data_ptr);
   8842   add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   8843   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(assert_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(assert_backtrack)->framesize * sizeof(sljit_sw));
   8844 
   8845   set_jumps(current->topbacktracks, LABEL());
   8846   }
   8847 else
   8848   set_jumps(current->topbacktracks, LABEL());
   8849 
   8850 if (bra == OP_BRAZERO)
   8851   {
   8852   /* We know there is enough place on the stack. */
   8853   OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
   8854   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
   8855   JUMPTO(SLJIT_JUMP, CURRENT_AS(assert_backtrack)->matchingpath);
   8856   JUMPHERE(brajump);
   8857   }
   8858 }
   8859 
   8860 static void compile_bracket_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   8861 {
   8862 DEFINE_COMPILER;
   8863 int opcode, stacksize, alt_count, alt_max;
   8864 int offset = 0;
   8865 int private_data_ptr = CURRENT_AS(bracket_backtrack)->private_data_ptr;
   8866 int repeat_ptr = 0, repeat_type = 0, repeat_count = 0;
   8867 pcre_uchar *cc = current->cc;
   8868 pcre_uchar *ccbegin;
   8869 pcre_uchar *ccprev;
   8870 pcre_uchar bra = OP_BRA;
   8871 pcre_uchar ket;
   8872 assert_backtrack *assert;
   8873 sljit_uw *next_update_addr = NULL;
   8874 BOOL has_alternatives;
   8875 BOOL needs_control_head = FALSE;
   8876 struct sljit_jump *brazero = NULL;
   8877 struct sljit_jump *alt1 = NULL;
   8878 struct sljit_jump *alt2 = NULL;
   8879 struct sljit_jump *once = NULL;
   8880 struct sljit_jump *cond = NULL;
   8881 struct sljit_label *rmin_label = NULL;
   8882 struct sljit_label *exact_label = NULL;
   8883 
   8884 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
   8885   {
   8886   bra = *cc;
   8887   cc++;
   8888   }
   8889 
   8890 opcode = *cc;
   8891 ccbegin = bracketend(cc) - 1 - LINK_SIZE;
   8892 ket = *ccbegin;
   8893 if (ket == OP_KET && PRIVATE_DATA(ccbegin) != 0)
   8894   {
   8895   repeat_ptr = PRIVATE_DATA(ccbegin);
   8896   repeat_type = PRIVATE_DATA(ccbegin + 2);
   8897   repeat_count = PRIVATE_DATA(ccbegin + 3);
   8898   SLJIT_ASSERT(repeat_type != 0 && repeat_count != 0);
   8899   if (repeat_type == OP_UPTO)
   8900     ket = OP_KETRMAX;
   8901   if (repeat_type == OP_MINUPTO)
   8902     ket = OP_KETRMIN;
   8903   }
   8904 ccbegin = cc;
   8905 cc += GET(cc, 1);
   8906 has_alternatives = *cc == OP_ALT;
   8907 if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
   8908   has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_backtrack)->u.condfailed != NULL;
   8909 if (opcode == OP_CBRA || opcode == OP_SCBRA)
   8910   offset = (GET2(ccbegin, 1 + LINK_SIZE)) << 1;
   8911 if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
   8912   opcode = OP_SCOND;
   8913 if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
   8914   opcode = OP_ONCE;
   8915 
   8916 alt_max = has_alternatives ? no_alternatives(ccbegin) : 0;
   8917 
   8918 /* Decoding the needs_control_head in framesize. */
   8919 if (opcode == OP_ONCE)
   8920   {
   8921   needs_control_head = (CURRENT_AS(bracket_backtrack)->u.framesize & 0x1) != 0;
   8922   CURRENT_AS(bracket_backtrack)->u.framesize >>= 1;
   8923   }
   8924 
   8925 if (ket != OP_KET && repeat_type != 0)
   8926   {
   8927   /* TMP1 is used in OP_KETRMIN below. */
   8928   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8929   free_stack(common, 1);
   8930   if (repeat_type == OP_UPTO)
   8931     OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0, SLJIT_IMM, 1);
   8932   else
   8933     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0);
   8934   }
   8935 
   8936 if (ket == OP_KETRMAX)
   8937   {
   8938   if (bra == OP_BRAZERO)
   8939     {
   8940     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8941     free_stack(common, 1);
   8942     brazero = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
   8943     }
   8944   }
   8945 else if (ket == OP_KETRMIN)
   8946   {
   8947   if (bra != OP_BRAMINZERO)
   8948     {
   8949     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8950     if (repeat_type != 0)
   8951       {
   8952       /* TMP1 was set a few lines above. */
   8953       CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
   8954       /* Drop STR_PTR for non-greedy plus quantifier. */
   8955       if (opcode != OP_ONCE)
   8956         free_stack(common, 1);
   8957       }
   8958     else if (opcode >= OP_SBRA || opcode == OP_ONCE)
   8959       {
   8960       /* Checking zero-length iteration. */
   8961       if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)
   8962         CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
   8963       else
   8964         {
   8965         OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   8966         CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (CURRENT_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw), CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
   8967         }
   8968       /* Drop STR_PTR for non-greedy plus quantifier. */
   8969       if (opcode != OP_ONCE)
   8970         free_stack(common, 1);
   8971       }
   8972     else
   8973       JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
   8974     }
   8975   rmin_label = LABEL();
   8976   if (repeat_type != 0)
   8977     OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
   8978   }
   8979 else if (bra == OP_BRAZERO)
   8980   {
   8981   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8982   free_stack(common, 1);
   8983   brazero = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
   8984   }
   8985 else if (repeat_type == OP_EXACT)
   8986   {
   8987   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
   8988   exact_label = LABEL();
   8989   }
   8990 
   8991 if (offset != 0)
   8992   {
   8993   if (common->capture_last_ptr != 0)
   8994     {
   8995     SLJIT_ASSERT(common->optimized_cbracket[offset >> 1] == 0);
   8996     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   8997     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   8998     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, TMP1, 0);
   8999     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
   9000     free_stack(common, 3);
   9001     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP2, 0);
   9002     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP1, 0);
   9003     }
   9004   else if (common->optimized_cbracket[offset >> 1] == 0)
   9005     {
   9006     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9007     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   9008     free_stack(common, 2);
   9009     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
   9010     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);
   9011     }
   9012   }
   9013 
   9014 if (SLJIT_UNLIKELY(opcode == OP_ONCE))
   9015   {
   9016   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
   9017     {
   9018     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   9019     add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   9020     }
   9021   once = JUMP(SLJIT_JUMP);
   9022   }
   9023 else if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
   9024   {
   9025   if (has_alternatives)
   9026     {
   9027     /* Always exactly one alternative. */
   9028     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9029     free_stack(common, 1);
   9030 
   9031     alt_max = 2;
   9032     alt1 = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, sizeof(sljit_uw));
   9033     }
   9034   }
   9035 else if (has_alternatives)
   9036   {
   9037   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9038   free_stack(common, 1);
   9039 
   9040   if (alt_max > 4)
   9041     {
   9042     /* Table jump if alt_max is greater than 4. */
   9043     next_update_addr = allocate_read_only_data(common, alt_max * sizeof(sljit_uw));
   9044     if (SLJIT_UNLIKELY(next_update_addr == NULL))
   9045       return;
   9046     sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM1(TMP1), (sljit_sw)next_update_addr);
   9047     add_label_addr(common, next_update_addr++);
   9048     }
   9049   else
   9050     {
   9051     if (alt_max == 4)
   9052       alt2 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_uw));
   9053     alt1 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, sizeof(sljit_uw));
   9054     }
   9055   }
   9056 
   9057 COMPILE_BACKTRACKINGPATH(current->top);
   9058 if (current->topbacktracks)
   9059   set_jumps(current->topbacktracks, LABEL());
   9060 
   9061 if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
   9062   {
   9063   /* Conditional block always has at most one alternative. */
   9064   if (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT)
   9065     {
   9066     SLJIT_ASSERT(has_alternatives);
   9067     assert = CURRENT_AS(bracket_backtrack)->u.assert;
   9068     if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK))
   9069       {
   9070       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr);
   9071       add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   9072       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_sw));
   9073       }
   9074     cond = JUMP(SLJIT_JUMP);
   9075     set_jumps(CURRENT_AS(bracket_backtrack)->u.assert->condfailed, LABEL());
   9076     }
   9077   else if (CURRENT_AS(bracket_backtrack)->u.condfailed != NULL)
   9078     {
   9079     SLJIT_ASSERT(has_alternatives);
   9080     cond = JUMP(SLJIT_JUMP);
   9081     set_jumps(CURRENT_AS(bracket_backtrack)->u.condfailed, LABEL());
   9082     }
   9083   else
   9084     SLJIT_ASSERT(!has_alternatives);
   9085   }
   9086 
   9087 if (has_alternatives)
   9088   {
   9089   alt_count = sizeof(sljit_uw);
   9090   do
   9091     {
   9092     current->top = NULL;
   9093     current->topbacktracks = NULL;
   9094     current->nextbacktracks = NULL;
   9095     /* Conditional blocks always have an additional alternative, even if it is empty. */
   9096     if (*cc == OP_ALT)
   9097       {
   9098       ccprev = cc + 1 + LINK_SIZE;
   9099       cc += GET(cc, 1);
   9100       if (opcode != OP_COND && opcode != OP_SCOND)
   9101         {
   9102         if (opcode != OP_ONCE)
   9103           {
   9104           if (private_data_ptr != 0)
   9105             OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
   9106           else
   9107             OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9108           }
   9109         else
   9110           OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(needs_control_head ? 1 : 0));
   9111         }
   9112       compile_matchingpath(common, ccprev, cc, current);
   9113       if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   9114         return;
   9115       }
   9116 
   9117     /* Instructions after the current alternative is successfully matched. */
   9118     /* There is a similar code in compile_bracket_matchingpath. */
   9119     if (opcode == OP_ONCE)
   9120       match_once_common(common, ket, CURRENT_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
   9121 
   9122     stacksize = 0;
   9123     if (repeat_type == OP_MINUPTO)
   9124       {
   9125       /* We need to preserve the counter. TMP2 will be used below. */
   9126       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);
   9127       stacksize++;
   9128       }
   9129     if (ket != OP_KET || bra != OP_BRA)
   9130       stacksize++;
   9131     if (offset != 0)
   9132       {
   9133       if (common->capture_last_ptr != 0)
   9134         stacksize++;
   9135       if (common->optimized_cbracket[offset >> 1] == 0)
   9136         stacksize += 2;
   9137       }
   9138     if (opcode != OP_ONCE)
   9139       stacksize++;
   9140 
   9141     if (stacksize > 0)
   9142       allocate_stack(common, stacksize);
   9143 
   9144     stacksize = 0;
   9145     if (repeat_type == OP_MINUPTO)
   9146       {
   9147       /* TMP2 was set above. */
   9148       OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
   9149       stacksize++;
   9150       }
   9151 
   9152     if (ket != OP_KET || bra != OP_BRA)
   9153       {
   9154       if (ket != OP_KET)
   9155         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
   9156       else
   9157         OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
   9158       stacksize++;
   9159       }
   9160 
   9161     if (offset != 0)
   9162       stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);
   9163 
   9164     if (opcode != OP_ONCE)
   9165       OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, alt_count);
   9166 
   9167     if (offset != 0 && ket == OP_KETRMAX && common->optimized_cbracket[offset >> 1] != 0)
   9168       {
   9169       /* If ket is not OP_KETRMAX, this code path is executed after the jump to alternative_matchingpath. */
   9170       SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));
   9171       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
   9172       }
   9173 
   9174     JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->alternative_matchingpath);
   9175 
   9176     if (opcode != OP_ONCE)
   9177       {
   9178       if (alt_max > 4)
   9179         add_label_addr(common, next_update_addr++);
   9180       else
   9181         {
   9182         if (alt_count != 2 * sizeof(sljit_uw))
   9183           {
   9184           JUMPHERE(alt1);
   9185           if (alt_max == 3 && alt_count == sizeof(sljit_uw))
   9186             alt2 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_uw));
   9187           }
   9188         else
   9189           {
   9190           JUMPHERE(alt2);
   9191           if (alt_max == 4)
   9192             alt1 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_uw));
   9193           }
   9194         }
   9195       alt_count += sizeof(sljit_uw);
   9196       }
   9197 
   9198     COMPILE_BACKTRACKINGPATH(current->top);
   9199     if (current->topbacktracks)
   9200       set_jumps(current->topbacktracks, LABEL());
   9201     SLJIT_ASSERT(!current->nextbacktracks);
   9202     }
   9203   while (*cc == OP_ALT);
   9204 
   9205   if (cond != NULL)
   9206     {
   9207     SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);
   9208     assert = CURRENT_AS(bracket_backtrack)->u.assert;
   9209     if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)
   9210       {
   9211       OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr);
   9212       add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   9213       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_sw));
   9214       }
   9215     JUMPHERE(cond);
   9216     }
   9217 
   9218   /* Free the STR_PTR. */
   9219   if (private_data_ptr == 0)
   9220     free_stack(common, 1);
   9221   }
   9222 
   9223 if (offset != 0)
   9224   {
   9225   /* Using both tmp register is better for instruction scheduling. */
   9226   if (common->optimized_cbracket[offset >> 1] != 0)
   9227     {
   9228     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9229     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   9230     free_stack(common, 2);
   9231     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
   9232     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);
   9233     }
   9234   else
   9235     {
   9236     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9237     free_stack(common, 1);
   9238     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
   9239     }
   9240   }
   9241 else if (opcode == OP_SBRA || opcode == OP_SCOND)
   9242   {
   9243   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(0));
   9244   free_stack(common, 1);
   9245   }
   9246 else if (opcode == OP_ONCE)
   9247   {
   9248   cc = ccbegin + GET(ccbegin, 1);
   9249   stacksize = needs_control_head ? 1 : 0;
   9250 
   9251   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
   9252     {
   9253     /* Reset head and drop saved frame. */
   9254     stacksize += CURRENT_AS(bracket_backtrack)->u.framesize + ((ket != OP_KET || *cc == OP_ALT) ? 2 : 1);
   9255     }
   9256   else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
   9257     {
   9258     /* The STR_PTR must be released. */
   9259     stacksize++;
   9260     }
   9261   free_stack(common, stacksize);
   9262 
   9263   JUMPHERE(once);
   9264   /* Restore previous private_data_ptr */
   9265   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
   9266     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracket_backtrack)->u.framesize * sizeof(sljit_sw));
   9267   else if (ket == OP_KETRMIN)
   9268     {
   9269     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   9270     /* See the comment below. */
   9271     free_stack(common, 2);
   9272     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
   9273     }
   9274   }
   9275 
   9276 if (repeat_type == OP_EXACT)
   9277   {
   9278   OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
   9279   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0);
   9280   CMPTO(SLJIT_LESS_EQUAL, TMP1, 0, SLJIT_IMM, repeat_count, exact_label);
   9281   }
   9282 else if (ket == OP_KETRMAX)
   9283   {
   9284   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9285   if (bra != OP_BRAZERO)
   9286     free_stack(common, 1);
   9287 
   9288   CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
   9289   if (bra == OP_BRAZERO)
   9290     {
   9291     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   9292     JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zero_matchingpath);
   9293     JUMPHERE(brazero);
   9294     free_stack(common, 1);
   9295     }
   9296   }
   9297 else if (ket == OP_KETRMIN)
   9298   {
   9299   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9300 
   9301   /* OP_ONCE removes everything in case of a backtrack, so we don't
   9302   need to explicitly release the STR_PTR. The extra release would
   9303   affect badly the free_stack(2) above. */
   9304   if (opcode != OP_ONCE)
   9305     free_stack(common, 1);
   9306   CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rmin_label);
   9307   if (opcode == OP_ONCE)
   9308     free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);
   9309   else if (bra == OP_BRAMINZERO)
   9310     free_stack(common, 1);
   9311   }
   9312 else if (bra == OP_BRAZERO)
   9313   {
   9314   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9315   JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zero_matchingpath);
   9316   JUMPHERE(brazero);
   9317   }
   9318 }
   9319 
   9320 static SLJIT_INLINE void compile_bracketpos_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   9321 {
   9322 DEFINE_COMPILER;
   9323 int offset;
   9324 struct sljit_jump *jump;
   9325 
   9326 if (CURRENT_AS(bracketpos_backtrack)->framesize < 0)
   9327   {
   9328   if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)
   9329     {
   9330     offset = (GET2(current->cc, 1 + LINK_SIZE)) << 1;
   9331     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9332     OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
   9333     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
   9334     if (common->capture_last_ptr != 0)
   9335       OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
   9336     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);
   9337     if (common->capture_last_ptr != 0)
   9338       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, TMP1, 0);
   9339     }
   9340   set_jumps(current->topbacktracks, LABEL());
   9341   free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
   9342   return;
   9343   }
   9344 
   9345 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(bracketpos_backtrack)->private_data_ptr);
   9346 add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   9347 
   9348 if (current->topbacktracks)
   9349   {
   9350   jump = JUMP(SLJIT_JUMP);
   9351   set_jumps(current->topbacktracks, LABEL());
   9352   /* Drop the stack frame. */
   9353   free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
   9354   JUMPHERE(jump);
   9355   }
   9356 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(bracketpos_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracketpos_backtrack)->framesize * sizeof(sljit_sw));
   9357 }
   9358 
   9359 static SLJIT_INLINE void compile_braminzero_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   9360 {
   9361 assert_backtrack backtrack;
   9362 
   9363 current->top = NULL;
   9364 current->topbacktracks = NULL;
   9365 current->nextbacktracks = NULL;
   9366 if (current->cc[1] > OP_ASSERTBACK_NOT)
   9367   {
   9368   /* Manual call of compile_bracket_matchingpath and compile_bracket_backtrackingpath. */
   9369   compile_bracket_matchingpath(common, current->cc, current);
   9370   compile_bracket_backtrackingpath(common, current->top);
   9371   }
   9372 else
   9373   {
   9374   memset(&backtrack, 0, sizeof(backtrack));
   9375   backtrack.common.cc = current->cc;
   9376   backtrack.matchingpath = CURRENT_AS(braminzero_backtrack)->matchingpath;
   9377   /* Manual call of compile_assert_matchingpath. */
   9378   compile_assert_matchingpath(common, current->cc, &backtrack, FALSE);
   9379   }
   9380 SLJIT_ASSERT(!current->nextbacktracks && !current->topbacktracks);
   9381 }
   9382 
   9383 static SLJIT_INLINE void compile_control_verb_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   9384 {
   9385 DEFINE_COMPILER;
   9386 pcre_uchar opcode = *current->cc;
   9387 struct sljit_label *loop;
   9388 struct sljit_jump *jump;
   9389 
   9390 if (opcode == OP_THEN || opcode == OP_THEN_ARG)
   9391   {
   9392   if (common->then_trap != NULL)
   9393     {
   9394     SLJIT_ASSERT(common->control_head_ptr != 0);
   9395 
   9396     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   9397     OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, type_then_trap);
   9398     OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, common->then_trap->start);
   9399     jump = JUMP(SLJIT_JUMP);
   9400 
   9401     loop = LABEL();
   9402     OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), -(int)sizeof(sljit_sw));
   9403     JUMPHERE(jump);
   9404     CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), -(int)(2 * sizeof(sljit_sw)), TMP1, 0, loop);
   9405     CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), -(int)(3 * sizeof(sljit_sw)), TMP2, 0, loop);
   9406     add_jump(compiler, &common->then_trap->quit, JUMP(SLJIT_JUMP));
   9407     return;
   9408     }
   9409   else if (common->positive_assert)
   9410     {
   9411     add_jump(compiler, &common->positive_assert_quit, JUMP(SLJIT_JUMP));
   9412     return;
   9413     }
   9414   }
   9415 
   9416 if (common->local_exit)
   9417   {
   9418   if (common->quit_label == NULL)
   9419     add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
   9420   else
   9421     JUMPTO(SLJIT_JUMP, common->quit_label);
   9422   return;
   9423   }
   9424 
   9425 if (opcode == OP_SKIP_ARG)
   9426   {
   9427   SLJIT_ASSERT(common->control_head_ptr != 0);
   9428   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
   9429   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);
   9430   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, (sljit_sw)(current->cc + 2));
   9431   sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_search_mark));
   9432   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   9433 
   9434   OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
   9435   add_jump(compiler, &common->reset_match, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, -1));
   9436   return;
   9437   }
   9438 
   9439 if (opcode == OP_SKIP)
   9440   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9441 else
   9442   OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_IMM, 0);
   9443 add_jump(compiler, &common->reset_match, JUMP(SLJIT_JUMP));
   9444 }
   9445 
   9446 static SLJIT_INLINE void compile_then_trap_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   9447 {
   9448 DEFINE_COMPILER;
   9449 struct sljit_jump *jump;
   9450 int size;
   9451 
   9452 if (CURRENT_AS(then_trap_backtrack)->then_trap)
   9453   {
   9454   common->then_trap = CURRENT_AS(then_trap_backtrack)->then_trap;
   9455   return;
   9456   }
   9457 
   9458 size = CURRENT_AS(then_trap_backtrack)->framesize;
   9459 size = 3 + (size < 0 ? 0 : size);
   9460 
   9461 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(size - 3));
   9462 free_stack(common, size);
   9463 jump = JUMP(SLJIT_JUMP);
   9464 
   9465 set_jumps(CURRENT_AS(then_trap_backtrack)->quit, LABEL());
   9466 /* STACK_TOP is set by THEN. */
   9467 if (CURRENT_AS(then_trap_backtrack)->framesize >= 0)
   9468   add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   9469 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9470 free_stack(common, 3);
   9471 
   9472 JUMPHERE(jump);
   9473 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP1, 0);
   9474 }
   9475 
   9476 static void compile_backtrackingpath(compiler_common *common, struct backtrack_common *current)
   9477 {
   9478 DEFINE_COMPILER;
   9479 then_trap_backtrack *save_then_trap = common->then_trap;
   9480 
   9481 while (current)
   9482   {
   9483   if (current->nextbacktracks != NULL)
   9484     set_jumps(current->nextbacktracks, LABEL());
   9485   switch(*current->cc)
   9486     {
   9487     case OP_SET_SOM:
   9488     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9489     free_stack(common, 1);
   9490     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), TMP1, 0);
   9491     break;
   9492 
   9493     case OP_STAR:
   9494     case OP_MINSTAR:
   9495     case OP_PLUS:
   9496     case OP_MINPLUS:
   9497     case OP_QUERY:
   9498     case OP_MINQUERY:
   9499     case OP_UPTO:
   9500     case OP_MINUPTO:
   9501     case OP_EXACT:
   9502     case OP_POSSTAR:
   9503     case OP_POSPLUS:
   9504     case OP_POSQUERY:
   9505     case OP_POSUPTO:
   9506     case OP_STARI:
   9507     case OP_MINSTARI:
   9508     case OP_PLUSI:
   9509     case OP_MINPLUSI:
   9510     case OP_QUERYI:
   9511     case OP_MINQUERYI:
   9512     case OP_UPTOI:
   9513     case OP_MINUPTOI:
   9514     case OP_EXACTI:
   9515     case OP_POSSTARI:
   9516     case OP_POSPLUSI:
   9517     case OP_POSQUERYI:
   9518     case OP_POSUPTOI:
   9519     case OP_NOTSTAR:
   9520     case OP_NOTMINSTAR:
   9521     case OP_NOTPLUS:
   9522     case OP_NOTMINPLUS:
   9523     case OP_NOTQUERY:
   9524     case OP_NOTMINQUERY:
   9525     case OP_NOTUPTO:
   9526     case OP_NOTMINUPTO:
   9527     case OP_NOTEXACT:
   9528     case OP_NOTPOSSTAR:
   9529     case OP_NOTPOSPLUS:
   9530     case OP_NOTPOSQUERY:
   9531     case OP_NOTPOSUPTO:
   9532     case OP_NOTSTARI:
   9533     case OP_NOTMINSTARI:
   9534     case OP_NOTPLUSI:
   9535     case OP_NOTMINPLUSI:
   9536     case OP_NOTQUERYI:
   9537     case OP_NOTMINQUERYI:
   9538     case OP_NOTUPTOI:
   9539     case OP_NOTMINUPTOI:
   9540     case OP_NOTEXACTI:
   9541     case OP_NOTPOSSTARI:
   9542     case OP_NOTPOSPLUSI:
   9543     case OP_NOTPOSQUERYI:
   9544     case OP_NOTPOSUPTOI:
   9545     case OP_TYPESTAR:
   9546     case OP_TYPEMINSTAR:
   9547     case OP_TYPEPLUS:
   9548     case OP_TYPEMINPLUS:
   9549     case OP_TYPEQUERY:
   9550     case OP_TYPEMINQUERY:
   9551     case OP_TYPEUPTO:
   9552     case OP_TYPEMINUPTO:
   9553     case OP_TYPEEXACT:
   9554     case OP_TYPEPOSSTAR:
   9555     case OP_TYPEPOSPLUS:
   9556     case OP_TYPEPOSQUERY:
   9557     case OP_TYPEPOSUPTO:
   9558     case OP_CLASS:
   9559     case OP_NCLASS:
   9560 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
   9561     case OP_XCLASS:
   9562 #endif
   9563     compile_iterator_backtrackingpath(common, current);
   9564     break;
   9565 
   9566     case OP_REF:
   9567     case OP_REFI:
   9568     case OP_DNREF:
   9569     case OP_DNREFI:
   9570     compile_ref_iterator_backtrackingpath(common, current);
   9571     break;
   9572 
   9573     case OP_RECURSE:
   9574     compile_recurse_backtrackingpath(common, current);
   9575     break;
   9576 
   9577     case OP_ASSERT:
   9578     case OP_ASSERT_NOT:
   9579     case OP_ASSERTBACK:
   9580     case OP_ASSERTBACK_NOT:
   9581     compile_assert_backtrackingpath(common, current);
   9582     break;
   9583 
   9584     case OP_ONCE:
   9585     case OP_ONCE_NC:
   9586     case OP_BRA:
   9587     case OP_CBRA:
   9588     case OP_COND:
   9589     case OP_SBRA:
   9590     case OP_SCBRA:
   9591     case OP_SCOND:
   9592     compile_bracket_backtrackingpath(common, current);
   9593     break;
   9594 
   9595     case OP_BRAZERO:
   9596     if (current->cc[1] > OP_ASSERTBACK_NOT)
   9597       compile_bracket_backtrackingpath(common, current);
   9598     else
   9599       compile_assert_backtrackingpath(common, current);
   9600     break;
   9601 
   9602     case OP_BRAPOS:
   9603     case OP_CBRAPOS:
   9604     case OP_SBRAPOS:
   9605     case OP_SCBRAPOS:
   9606     case OP_BRAPOSZERO:
   9607     compile_bracketpos_backtrackingpath(common, current);
   9608     break;
   9609 
   9610     case OP_BRAMINZERO:
   9611     compile_braminzero_backtrackingpath(common, current);
   9612     break;
   9613 
   9614     case OP_MARK:
   9615     OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0));
   9616     if (common->has_skip_arg)
   9617       OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9618     free_stack(common, common->has_skip_arg ? 5 : 1);
   9619     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP1, 0);
   9620     if (common->has_skip_arg)
   9621       OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP2, 0);
   9622     break;
   9623 
   9624     case OP_THEN:
   9625     case OP_THEN_ARG:
   9626     case OP_PRUNE:
   9627     case OP_PRUNE_ARG:
   9628     case OP_SKIP:
   9629     case OP_SKIP_ARG:
   9630     compile_control_verb_backtrackingpath(common, current);
   9631     break;
   9632 
   9633     case OP_COMMIT:
   9634     if (!common->local_exit)
   9635       OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
   9636     if (common->quit_label == NULL)
   9637       add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
   9638     else
   9639       JUMPTO(SLJIT_JUMP, common->quit_label);
   9640     break;
   9641 
   9642     case OP_CALLOUT:
   9643     case OP_FAIL:
   9644     case OP_ACCEPT:
   9645     case OP_ASSERT_ACCEPT:
   9646     set_jumps(current->topbacktracks, LABEL());
   9647     break;
   9648 
   9649     case OP_THEN_TRAP:
   9650     /* A virtual opcode for then traps. */
   9651     compile_then_trap_backtrackingpath(common, current);
   9652     break;
   9653 
   9654     default:
   9655     SLJIT_ASSERT_STOP();
   9656     break;
   9657     }
   9658   current = current->prev;
   9659   }
   9660 common->then_trap = save_then_trap;
   9661 }
   9662 
   9663 static SLJIT_INLINE void compile_recurse(compiler_common *common)
   9664 {
   9665 DEFINE_COMPILER;
   9666 pcre_uchar *cc = common->start + common->currententry->start;
   9667 pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);
   9668 pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);
   9669 BOOL needs_control_head;
   9670 int framesize = get_framesize(common, cc, NULL, TRUE, &needs_control_head);
   9671 int private_data_size = get_private_data_copy_length(common, ccbegin, ccend, needs_control_head);
   9672 int alternativesize;
   9673 BOOL needs_frame;
   9674 backtrack_common altbacktrack;
   9675 struct sljit_jump *jump;
   9676 
   9677 /* Recurse captures then. */
   9678 common->then_trap = NULL;
   9679 
   9680 SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);
   9681 needs_frame = framesize >= 0;
   9682 if (!needs_frame)
   9683   framesize = 0;
   9684 alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;
   9685 
   9686 SLJIT_ASSERT(common->currententry->entry == NULL && common->recursive_head_ptr != 0);
   9687 common->currententry->entry = LABEL();
   9688 set_jumps(common->currententry->calls, common->currententry->entry);
   9689 
   9690 sljit_emit_fast_enter(compiler, TMP2, 0);
   9691 allocate_stack(common, private_data_size + framesize + alternativesize);
   9692 count_match(common);
   9693 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(private_data_size + framesize + alternativesize - 1), TMP2, 0);
   9694 copy_private_data(common, ccbegin, ccend, TRUE, private_data_size + framesize + alternativesize, framesize + alternativesize, needs_control_head);
   9695 if (needs_control_head)
   9696   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
   9697 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, STACK_TOP, 0);
   9698 if (needs_frame)
   9699   init_frame(common, cc, NULL, framesize + alternativesize - 1, alternativesize, TRUE);
   9700 
   9701 if (alternativesize > 0)
   9702   OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
   9703 
   9704 memset(&altbacktrack, 0, sizeof(backtrack_common));
   9705 common->quit_label = NULL;
   9706 common->accept_label = NULL;
   9707 common->quit = NULL;
   9708 common->accept = NULL;
   9709 altbacktrack.cc = ccbegin;
   9710 cc += GET(cc, 1);
   9711 while (1)
   9712   {
   9713   altbacktrack.top = NULL;
   9714   altbacktrack.topbacktracks = NULL;
   9715 
   9716   if (altbacktrack.cc != ccbegin)
   9717     OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
   9718 
   9719   compile_matchingpath(common, altbacktrack.cc, cc, &altbacktrack);
   9720   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   9721     return;
   9722 
   9723   add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));
   9724 
   9725   compile_backtrackingpath(common, altbacktrack.top);
   9726   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   9727     return;
   9728   set_jumps(altbacktrack.topbacktracks, LABEL());
   9729 
   9730   if (*cc != OP_ALT)
   9731     break;
   9732 
   9733   altbacktrack.cc = cc + 1 + LINK_SIZE;
   9734   cc += GET(cc, 1);
   9735   }
   9736 
   9737 /* None of them matched. */
   9738 OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
   9739 jump = JUMP(SLJIT_JUMP);
   9740 
   9741 if (common->quit != NULL)
   9742   {
   9743   set_jumps(common->quit, LABEL());
   9744   OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr);
   9745   if (needs_frame)
   9746     {
   9747     OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
   9748     add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   9749     OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
   9750     }
   9751   OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
   9752   common->quit = NULL;
   9753   add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
   9754   }
   9755 
   9756 set_jumps(common->accept, LABEL());
   9757 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr);
   9758 if (needs_frame)
   9759   {
   9760   OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
   9761   add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
   9762   OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
   9763   }
   9764 OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);
   9765 
   9766 JUMPHERE(jump);
   9767 if (common->quit != NULL)
   9768   set_jumps(common->quit, LABEL());
   9769 copy_private_data(common, ccbegin, ccend, FALSE, private_data_size + framesize + alternativesize, framesize + alternativesize, needs_control_head);
   9770 free_stack(common, private_data_size + framesize + alternativesize);
   9771 if (needs_control_head)
   9772   {
   9773   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 2 * sizeof(sljit_sw));
   9774   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_sw));
   9775   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, TMP1, 0);
   9776   OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
   9777   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP2, 0);
   9778   }
   9779 else
   9780   {
   9781   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_sw));
   9782   OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
   9783   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, TMP2, 0);
   9784   }
   9785 sljit_emit_fast_return(compiler, SLJIT_MEM1(STACK_TOP), 0);
   9786 }
   9787 
   9788 #undef COMPILE_BACKTRACKINGPATH
   9789 #undef CURRENT_AS
   9790 
   9791 void
   9792 PRIV(jit_compile)(const REAL_PCRE *re, PUBL(extra) *extra, int mode)
   9793 {
   9794 struct sljit_compiler *compiler;
   9795 backtrack_common rootbacktrack;
   9796 compiler_common common_data;
   9797 compiler_common *common = &common_data;
   9798 const pcre_uint8 *tables = re->tables;
   9799 pcre_study_data *study;
   9800 int private_data_size;
   9801 pcre_uchar *ccend;
   9802 executable_functions *functions;
   9803 void *executable_func;
   9804 sljit_uw executable_size;
   9805 sljit_uw total_length;
   9806 label_addr_list *label_addr;
   9807 struct sljit_label *mainloop_label = NULL;
   9808 struct sljit_label *continue_match_label;
   9809 struct sljit_label *empty_match_found_label = NULL;
   9810 struct sljit_label *empty_match_backtrack_label = NULL;
   9811 struct sljit_label *reset_match_label;
   9812 struct sljit_label *quit_label;
   9813 struct sljit_jump *jump;
   9814 struct sljit_jump *minlength_check_failed = NULL;
   9815 struct sljit_jump *reqbyte_notfound = NULL;
   9816 struct sljit_jump *empty_match = NULL;
   9817 
   9818 SLJIT_ASSERT((extra->flags & PCRE_EXTRA_STUDY_DATA) != 0);
   9819 study = extra->study_data;
   9820 
   9821 if (!tables)
   9822   tables = PRIV(default_tables);
   9823 
   9824 memset(&rootbacktrack, 0, sizeof(backtrack_common));
   9825 memset(common, 0, sizeof(compiler_common));
   9826 rootbacktrack.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;
   9827 
   9828 common->start = rootbacktrack.cc;
   9829 common->read_only_data_head = NULL;
   9830 common->fcc = tables + fcc_offset;
   9831 common->lcc = (sljit_sw)(tables + lcc_offset);
   9832 common->mode = mode;
   9833 common->might_be_empty = study->minlength == 0;
   9834 common->nltype = NLTYPE_FIXED;
   9835 switch(re->options & PCRE_NEWLINE_BITS)
   9836   {
   9837   case 0:
   9838   /* Compile-time default */
   9839   switch(NEWLINE)
   9840     {
   9841     case -1: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;
   9842     case -2: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;
   9843     default: common->newline = NEWLINE; break;
   9844     }
   9845   break;
   9846   case PCRE_NEWLINE_CR: common->newline = CHAR_CR; break;
   9847   case PCRE_NEWLINE_LF: common->newline = CHAR_NL; break;
   9848   case PCRE_NEWLINE_CR+
   9849        PCRE_NEWLINE_LF: common->newline = (CHAR_CR << 8) | CHAR_NL; break;
   9850   case PCRE_NEWLINE_ANY: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;
   9851   case PCRE_NEWLINE_ANYCRLF: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;
   9852   default: return;
   9853   }
   9854 common->nlmax = READ_CHAR_MAX;
   9855 common->nlmin = 0;
   9856 if ((re->options & PCRE_BSR_ANYCRLF) != 0)
   9857   common->bsr_nltype = NLTYPE_ANYCRLF;
   9858 else if ((re->options & PCRE_BSR_UNICODE) != 0)
   9859   common->bsr_nltype = NLTYPE_ANY;
   9860 else
   9861   {
   9862 #ifdef BSR_ANYCRLF
   9863   common->bsr_nltype = NLTYPE_ANYCRLF;
   9864 #else
   9865   common->bsr_nltype = NLTYPE_ANY;
   9866 #endif
   9867   }
   9868 common->bsr_nlmax = READ_CHAR_MAX;
   9869 common->bsr_nlmin = 0;
   9870 common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
   9871 common->ctypes = (sljit_sw)(tables + ctypes_offset);
   9872 common->name_table = ((pcre_uchar *)re) + re->name_table_offset;
   9873 common->name_count = re->name_count;
   9874 common->name_entry_size = re->name_entry_size;
   9875 common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
   9876 #ifdef SUPPORT_UTF
   9877 /* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */
   9878 common->utf = (re->options & PCRE_UTF8) != 0;
   9879 #ifdef SUPPORT_UCP
   9880 common->use_ucp = (re->options & PCRE_UCP) != 0;
   9881 #endif
   9882 if (common->utf)
   9883   {
   9884   if (common->nltype == NLTYPE_ANY)
   9885     common->nlmax = 0x2029;
   9886   else if (common->nltype == NLTYPE_ANYCRLF)
   9887     common->nlmax = (CHAR_CR > CHAR_NL) ? CHAR_CR : CHAR_NL;
   9888   else
   9889     {
   9890     /* We only care about the first newline character. */
   9891     common->nlmax = common->newline & 0xff;
   9892     }
   9893 
   9894   if (common->nltype == NLTYPE_FIXED)
   9895     common->nlmin = common->newline & 0xff;
   9896   else
   9897     common->nlmin = (CHAR_CR < CHAR_NL) ? CHAR_CR : CHAR_NL;
   9898 
   9899   if (common->bsr_nltype == NLTYPE_ANY)
   9900     common->bsr_nlmax = 0x2029;
   9901   else
   9902     common->bsr_nlmax = (CHAR_CR > CHAR_NL) ? CHAR_CR : CHAR_NL;
   9903   common->bsr_nlmin = (CHAR_CR < CHAR_NL) ? CHAR_CR : CHAR_NL;
   9904   }
   9905 #endif /* SUPPORT_UTF */
   9906 ccend = bracketend(common->start);
   9907 
   9908 /* Calculate the local space size on the stack. */
   9909 common->ovector_start = LIMIT_MATCH + sizeof(sljit_sw);
   9910 common->optimized_cbracket = (pcre_uint8 *)SLJIT_MALLOC(re->top_bracket + 1, compiler->allocator_data);
   9911 if (!common->optimized_cbracket)
   9912   return;
   9913 #if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 1
   9914 memset(common->optimized_cbracket, 0, re->top_bracket + 1);
   9915 #else
   9916 memset(common->optimized_cbracket, 1, re->top_bracket + 1);
   9917 #endif
   9918 
   9919 SLJIT_ASSERT(*common->start == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);
   9920 #if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 2
   9921 common->capture_last_ptr = common->ovector_start;
   9922 common->ovector_start += sizeof(sljit_sw);
   9923 #endif
   9924 if (!check_opcode_types(common, common->start, ccend))
   9925   {
   9926   SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
   9927   return;
   9928   }
   9929 
   9930 /* Checking flags and updating ovector_start. */
   9931 if (mode == JIT_COMPILE && (re->flags & PCRE_REQCHSET) != 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)
   9932   {
   9933   common->req_char_ptr = common->ovector_start;
   9934   common->ovector_start += sizeof(sljit_sw);
   9935   }
   9936 if (mode != JIT_COMPILE)
   9937   {
   9938   common->start_used_ptr = common->ovector_start;
   9939   common->ovector_start += sizeof(sljit_sw);
   9940   if (mode == JIT_PARTIAL_SOFT_COMPILE)
   9941     {
   9942     common->hit_start = common->ovector_start;
   9943     common->ovector_start += 2 * sizeof(sljit_sw);
   9944     }
   9945   else
   9946     {
   9947     SLJIT_ASSERT(mode == JIT_PARTIAL_HARD_COMPILE);
   9948     common->needs_start_ptr = TRUE;
   9949     }
   9950   }
   9951 if ((re->options & PCRE_FIRSTLINE) != 0)
   9952   {
   9953   common->first_line_end = common->ovector_start;
   9954   common->ovector_start += sizeof(sljit_sw);
   9955   }
   9956 #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
   9957 common->control_head_ptr = 1;
   9958 #endif
   9959 if (common->control_head_ptr != 0)
   9960   {
   9961   common->control_head_ptr = common->ovector_start;
   9962   common->ovector_start += sizeof(sljit_sw);
   9963   }
   9964 if (common->needs_start_ptr && common->has_set_som)
   9965   {
   9966   /* Saving the real start pointer is necessary. */
   9967   common->start_ptr = common->ovector_start;
   9968   common->ovector_start += sizeof(sljit_sw);
   9969   }
   9970 else
   9971   common->needs_start_ptr = FALSE;
   9972 
   9973 /* Aligning ovector to even number of sljit words. */
   9974 if ((common->ovector_start & sizeof(sljit_sw)) != 0)
   9975   common->ovector_start += sizeof(sljit_sw);
   9976 
   9977 if (common->start_ptr == 0)
   9978   common->start_ptr = OVECTOR(0);
   9979 
   9980 /* Capturing brackets cannot be optimized if callouts are allowed. */
   9981 if (common->capture_last_ptr != 0)
   9982   memset(common->optimized_cbracket, 0, re->top_bracket + 1);
   9983 
   9984 SLJIT_ASSERT(!(common->req_char_ptr != 0 && common->start_used_ptr != 0));
   9985 common->cbra_ptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_sw);
   9986 
   9987 total_length = ccend - common->start;
   9988 common->private_data_ptrs = (sljit_si *)SLJIT_MALLOC(total_length * (sizeof(sljit_si) + (common->has_then ? 1 : 0)), compiler->allocator_data);
   9989 if (!common->private_data_ptrs)
   9990   {
   9991   SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
   9992   return;
   9993   }
   9994 memset(common->private_data_ptrs, 0, total_length * sizeof(sljit_si));
   9995 
   9996 private_data_size = common->cbra_ptr + (re->top_bracket + 1) * sizeof(sljit_sw);
   9997 set_private_data_ptrs(common, &private_data_size, ccend);
   9998 if (private_data_size > SLJIT_MAX_LOCAL_SIZE)
   9999   {
   10000   SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
   10001   SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
   10002   return;
   10003   }
   10004 
   10005 if (common->has_then)
   10006   {
   10007   common->then_offsets = (pcre_uint8 *)(common->private_data_ptrs + total_length);
   10008   memset(common->then_offsets, 0, total_length);
   10009   set_then_offsets(common, common->start, NULL);
   10010   }
   10011 
   10012 compiler = sljit_create_compiler(NULL);
   10013 if (!compiler)
   10014   {
   10015   SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
   10016   SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
   10017   return;
   10018   }
   10019 common->compiler = compiler;
   10020 
   10021 /* Main pcre_jit_exec entry. */
   10022 sljit_emit_enter(compiler, 0, 1, 5, 5, 0, 0, private_data_size);
   10023 
   10024 /* Register init. */
   10025 reset_ovector(common, (re->top_bracket + 1) * 2);
   10026 if (common->req_char_ptr != 0)
   10027   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, SLJIT_R0, 0);
   10028 
   10029 OP1(SLJIT_MOV, ARGUMENTS, 0, SLJIT_S0, 0);
   10030 OP1(SLJIT_MOV, TMP1, 0, SLJIT_S0, 0);
   10031 OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
   10032 OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, end));
   10033 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));
   10034 OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, limit_match));
   10035 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, base));
   10036 OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, limit));
   10037 OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
   10038 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LIMIT_MATCH, TMP1, 0);
   10039 
   10040 if (mode == JIT_PARTIAL_SOFT_COMPILE)
   10041   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1);
   10042 if (common->mark_ptr != 0)
   10043   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0);
   10044 if (common->control_head_ptr != 0)
   10045   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
   10046 
   10047 /* Main part of the matching */
   10048 if ((re->options & PCRE_ANCHORED) == 0)
   10049   {
   10050   mainloop_label = mainloop_entry(common, (re->flags & PCRE_HASCRORLF) != 0, (re->options & PCRE_FIRSTLINE) != 0);
   10051   continue_match_label = LABEL();
   10052   /* Forward search if possible. */
   10053   if ((re->options & PCRE_NO_START_OPTIMIZE) == 0)
   10054     {
   10055     if (mode == JIT_COMPILE && fast_forward_first_n_chars(common, (re->options & PCRE_FIRSTLINE) != 0))
   10056       ;
   10057     else if ((re->flags & PCRE_FIRSTSET) != 0)
   10058       fast_forward_first_char(common, (pcre_uchar)re->first_char, (re->flags & PCRE_FCH_CASELESS) != 0, (re->options & PCRE_FIRSTLINE) != 0);
   10059     else if ((re->flags & PCRE_STARTLINE) != 0)
   10060       fast_forward_newline(common, (re->options & PCRE_FIRSTLINE) != 0);
   10061     else if (study != NULL && (study->flags & PCRE_STUDY_MAPPED) != 0)
   10062       fast_forward_start_bits(common, study->start_bits, (re->options & PCRE_FIRSTLINE) != 0);
   10063     }
   10064   }
   10065 else
   10066   continue_match_label = LABEL();
   10067 
   10068 if (mode == JIT_COMPILE && study->minlength > 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)
   10069   {
   10070   OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
   10071   OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(study->minlength));
   10072   minlength_check_failed = CMP(SLJIT_GREATER, TMP2, 0, STR_END, 0);
   10073   }
   10074 if (common->req_char_ptr != 0)
   10075   reqbyte_notfound = search_requested_char(common, (pcre_uchar)re->req_char, (re->flags & PCRE_RCH_CASELESS) != 0, (re->flags & PCRE_FIRSTSET) != 0);
   10076 
   10077 /* Store the current STR_PTR in OVECTOR(0). */
   10078 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), STR_PTR, 0);
   10079 /* Copy the limit of allowed recursions. */
   10080 OP1(SLJIT_MOV, COUNT_MATCH, 0, SLJIT_MEM1(SLJIT_SP), LIMIT_MATCH);
   10081 if (common->capture_last_ptr != 0)
   10082   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, -1);
   10083 
   10084 if (common->needs_start_ptr)
   10085   {
   10086   SLJIT_ASSERT(common->start_ptr != OVECTOR(0));
   10087   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_ptr, STR_PTR, 0);
   10088   }
   10089 else
   10090   SLJIT_ASSERT(common->start_ptr == OVECTOR(0));
   10091 
   10092 /* Copy the beginning of the string. */
   10093 if (mode == JIT_PARTIAL_SOFT_COMPILE)
   10094   {
   10095   jump = CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1);
   10096   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
   10097   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start + sizeof(sljit_sw), STR_PTR, 0);
   10098   JUMPHERE(jump);
   10099   }
   10100 else if (mode == JIT_PARTIAL_HARD_COMPILE)
   10101   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
   10102 
   10103 compile_matchingpath(common, common->start, ccend, &rootbacktrack);
   10104 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   10105   {
   10106   sljit_free_compiler(compiler);
   10107   SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
   10108   SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
   10109   free_read_only_data(common->read_only_data_head, compiler->allocator_data);
   10110   return;
   10111   }
   10112 
   10113 if (common->might_be_empty)
   10114   {
   10115   empty_match = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
   10116   empty_match_found_label = LABEL();
   10117   }
   10118 
   10119 common->accept_label = LABEL();
   10120 if (common->accept != NULL)
   10121   set_jumps(common->accept, common->accept_label);
   10122 
   10123 /* This means we have a match. Update the ovector. */
   10124 copy_ovector(common, re->top_bracket + 1);
   10125 common->quit_label = common->forced_quit_label = LABEL();
   10126 if (common->quit != NULL)
   10127   set_jumps(common->quit, common->quit_label);
   10128 if (common->forced_quit != NULL)
   10129   set_jumps(common->forced_quit, common->forced_quit_label);
   10130 if (minlength_check_failed != NULL)
   10131   SET_LABEL(minlength_check_failed, common->forced_quit_label);
   10132 sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
   10133 
   10134 if (mode != JIT_COMPILE)
   10135   {
   10136   common->partialmatchlabel = LABEL();
   10137   set_jumps(common->partialmatch, common->partialmatchlabel);
   10138   return_with_partial_match(common, common->quit_label);
   10139   }
   10140 
   10141 if (common->might_be_empty)
   10142   empty_match_backtrack_label = LABEL();
   10143 compile_backtrackingpath(common, rootbacktrack.top);
   10144 if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   10145   {
   10146   sljit_free_compiler(compiler);
   10147   SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
   10148   SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
   10149   free_read_only_data(common->read_only_data_head, compiler->allocator_data);
   10150   return;
   10151   }
   10152 
   10153 SLJIT_ASSERT(rootbacktrack.prev == NULL);
   10154 reset_match_label = LABEL();
   10155 
   10156 if (mode == JIT_PARTIAL_SOFT_COMPILE)
   10157   {
   10158   /* Update hit_start only in the first time. */
   10159   jump = CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
   10160   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr);
   10161   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1);
   10162   OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, TMP1, 0);
   10163   JUMPHERE(jump);
   10164   }
   10165 
   10166 /* Check we have remaining characters. */
   10167 if ((re->options & PCRE_ANCHORED) == 0 && (re->options & PCRE_FIRSTLINE) != 0)
   10168   {
   10169   SLJIT_ASSERT(common->first_line_end != 0);
   10170   OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->first_line_end);
   10171   }
   10172 
   10173 OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), common->start_ptr);
   10174 
   10175 if ((re->options & PCRE_ANCHORED) == 0)
   10176   {
   10177   if (common->ff_newline_shortcut != NULL)
   10178     {
   10179     if ((re->options & PCRE_FIRSTLINE) == 0)
   10180       CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, common->ff_newline_shortcut);
   10181     /* There cannot be more newlines here. */
   10182     }
   10183   else
   10184     {
   10185     if ((re->options & PCRE_FIRSTLINE) == 0)
   10186       CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, mainloop_label);
   10187     else
   10188       CMPTO(SLJIT_LESS, STR_PTR, 0, TMP1, 0, mainloop_label);
   10189     }
   10190   }
   10191 
   10192 /* No more remaining characters. */
   10193 if (reqbyte_notfound != NULL)
   10194   JUMPHERE(reqbyte_notfound);
   10195 
   10196 if (mode == JIT_PARTIAL_SOFT_COMPILE)
   10197   CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1, common->partialmatchlabel);
   10198 
   10199 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
   10200 JUMPTO(SLJIT_JUMP, common->quit_label);
   10201 
   10202 flush_stubs(common);
   10203 
   10204 if (common->might_be_empty)
   10205   {
   10206   JUMPHERE(empty_match);
   10207   OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   10208   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
   10209   CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_backtrack_label);
   10210   OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
   10211   CMPTO(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_found_label);
   10212   OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
   10213   CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, empty_match_found_label);
   10214   JUMPTO(SLJIT_JUMP, empty_match_backtrack_label);
   10215   }
   10216 
   10217 common->currententry = common->entries;
   10218 common->local_exit = TRUE;
   10219 quit_label = common->quit_label;
   10220 while (common->currententry != NULL)
   10221   {
   10222   /* Might add new entries. */
   10223   compile_recurse(common);
   10224   if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
   10225     {
   10226     sljit_free_compiler(compiler);
   10227     SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
   10228     SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
   10229     free_read_only_data(common->read_only_data_head, compiler->allocator_data);
   10230     return;
   10231     }
   10232   flush_stubs(common);
   10233   common->currententry = common->currententry->next;
   10234   }
   10235 common->local_exit = FALSE;
   10236 common->quit_label = quit_label;
   10237 
   10238 /* Allocating stack, returns with PCRE_ERROR_JIT_STACKLIMIT if fails. */
   10239 /* This is a (really) rare case. */
   10240 set_jumps(common->stackalloc, LABEL());
   10241 /* RETURN_ADDR is not a saved register. */
   10242 sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   10243 OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP2, 0);
   10244 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   10245 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));
   10246 OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, top), STACK_TOP, 0);
   10247 OP2(SLJIT_ADD, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, limit), SLJIT_IMM, STACK_GROWTH_RATE);
   10248 
   10249 sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_stack_resize));
   10250 jump = CMP(SLJIT_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
   10251 OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
   10252 OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));
   10253 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, top));
   10254 OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, limit));
   10255 OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
   10256 sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
   10257 
   10258 /* Allocation failed. */
   10259 JUMPHERE(jump);
   10260 /* We break the return address cache here, but this is a really rare case. */
   10261 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_JIT_STACKLIMIT);
   10262 JUMPTO(SLJIT_JUMP, common->quit_label);
   10263 
   10264 /* Call limit reached. */
   10265 set_jumps(common->calllimit, LABEL());
   10266 OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_MATCHLIMIT);
   10267 JUMPTO(SLJIT_JUMP, common->quit_label);
   10268 
   10269 if (common->revertframes != NULL)
   10270   {
   10271   set_jumps(common->revertframes, LABEL());
   10272   do_revertframes(common);
   10273   }
   10274 if (common->wordboundary != NULL)
   10275   {
   10276   set_jumps(common->wordboundary, LABEL());
   10277   check_wordboundary(common);
   10278   }
   10279 if (common->anynewline != NULL)
   10280   {
   10281   set_jumps(common->anynewline, LABEL());
   10282   check_anynewline(common);
   10283   }
   10284 if (common->hspace != NULL)
   10285   {
   10286   set_jumps(common->hspace, LABEL());
   10287   check_hspace(common);
   10288   }
   10289 if (common->vspace != NULL)
   10290   {
   10291   set_jumps(common->vspace, LABEL());
   10292   check_vspace(common);
   10293   }
   10294 if (common->casefulcmp != NULL)
   10295   {
   10296   set_jumps(common->casefulcmp, LABEL());
   10297   do_casefulcmp(common);
   10298   }
   10299 if (common->caselesscmp != NULL)
   10300   {
   10301   set_jumps(common->caselesscmp, LABEL());
   10302   do_caselesscmp(common);
   10303   }
   10304 if (common->reset_match != NULL)
   10305   {
   10306   set_jumps(common->reset_match, LABEL());
   10307   do_reset_match(common, (re->top_bracket + 1) * 2);
   10308   CMPTO(SLJIT_GREATER, STR_PTR, 0, TMP1, 0, continue_match_label);
   10309   OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
   10310   JUMPTO(SLJIT_JUMP, reset_match_label);
   10311   }
   10312 #ifdef SUPPORT_UTF
   10313 #ifdef COMPILE_PCRE8
   10314 if (common->utfreadchar != NULL)
   10315   {
   10316   set_jumps(common->utfreadchar, LABEL());
   10317   do_utfreadchar(common);
   10318   }
   10319 if (common->utfreadchar16 != NULL)
   10320   {
   10321   set_jumps(common->utfreadchar16, LABEL());
   10322   do_utfreadchar16(common);
   10323   }
   10324 if (common->utfreadtype8 != NULL)
   10325   {
   10326   set_jumps(common->utfreadtype8, LABEL());
   10327   do_utfreadtype8(common);
   10328   }
   10329 #endif /* COMPILE_PCRE8 */
   10330 #endif /* SUPPORT_UTF */
   10331 #ifdef SUPPORT_UCP
   10332 if (common->getucd != NULL)
   10333   {
   10334   set_jumps(common->getucd, LABEL());
   10335   do_getucd(common);
   10336   }
   10337 #endif
   10338 
   10339 SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
   10340 SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
   10341 
   10342 executable_func = sljit_generate_code(compiler);
   10343 executable_size = sljit_get_generated_code_size(compiler);
   10344 label_addr = common->label_addrs;
   10345 while (label_addr != NULL)
   10346   {
   10347   *label_addr->update_addr = sljit_get_label_addr(label_addr->label);
   10348   label_addr = label_addr->next;
   10349   }
   10350 sljit_free_compiler(compiler);
   10351 if (executable_func == NULL)
   10352   {
   10353   free_read_only_data(common->read_only_data_head, compiler->allocator_data);
   10354   return;
   10355   }
   10356 
   10357 /* Reuse the function descriptor if possible. */
   10358 if ((extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 && extra->executable_jit != NULL)
   10359   functions = (executable_functions *)extra->executable_jit;
   10360 else
   10361   {
   10362   /* Note: If your memory-checker has flagged the allocation below as a
   10363    * memory leak, it is probably because you either forgot to call
   10364    * pcre_free_study() (or pcre16_free_study()) on the pcre_extra (or
   10365    * pcre16_extra) object, or you called said function after having
   10366    * cleared the PCRE_EXTRA_EXECUTABLE_JIT bit from the "flags" field
   10367    * of the object. (The function will only free the JIT data if the
   10368    * bit remains set, as the bit indicates that the pointer to the data
   10369    * is valid.)
   10370    */
   10371   functions = SLJIT_MALLOC(sizeof(executable_functions), compiler->allocator_data);
   10372   if (functions == NULL)
   10373     {
   10374     /* This case is highly unlikely since we just recently
   10375     freed a lot of memory. Not impossible though. */
   10376     sljit_free_code(executable_func);
   10377     free_read_only_data(common->read_only_data_head, compiler->allocator_data);
   10378     return;
   10379     }
   10380   memset(functions, 0, sizeof(executable_functions));
   10381   functions->top_bracket = (re->top_bracket + 1) * 2;
   10382   functions->limit_match = (re->flags & PCRE_MLSET) != 0 ? re->limit_match : 0;
   10383   extra->executable_jit = functions;
   10384   extra->flags |= PCRE_EXTRA_EXECUTABLE_JIT;
   10385   }
   10386 
   10387 functions->executable_funcs[mode] = executable_func;
   10388 functions->read_only_data_heads[mode] = common->read_only_data_head;
   10389 functions->executable_sizes[mode] = executable_size;
   10390 }
   10391 
   10392 static SLJIT_NOINLINE int jit_machine_stack_exec(jit_arguments *arguments, void *executable_func)
   10393 {
   10394 union {
   10395    void *executable_func;
   10396    jit_function call_executable_func;
   10397 } convert_executable_func;
   10398 pcre_uint8 local_space[MACHINE_STACK_SIZE];
   10399 struct sljit_stack local_stack;
   10400 
   10401 local_stack.top = (sljit_sw)&local_space;
   10402 local_stack.base = local_stack.top;
   10403 local_stack.limit = local_stack.base + MACHINE_STACK_SIZE;
   10404 local_stack.max_limit = local_stack.limit;
   10405 arguments->stack = &local_stack;
   10406 convert_executable_func.executable_func = executable_func;
   10407 return convert_executable_func.call_executable_func(arguments);
   10408 }
   10409 
   10410 int
   10411 PRIV(jit_exec)(const PUBL(extra) *extra_data, const pcre_uchar *subject,
   10412   int length, int start_offset, int options, int *offsets, int offset_count)
   10413 {
   10414 executable_functions *functions = (executable_functions *)extra_data->executable_jit;
   10415 union {
   10416    void *executable_func;
   10417    jit_function call_executable_func;
   10418 } convert_executable_func;
   10419 jit_arguments arguments;
   10420 int max_offset_count;
   10421 int retval;
   10422 int mode = JIT_COMPILE;
   10423 
   10424 if ((options & PCRE_PARTIAL_HARD) != 0)
   10425   mode = JIT_PARTIAL_HARD_COMPILE;
   10426 else if ((options & PCRE_PARTIAL_SOFT) != 0)
   10427   mode = JIT_PARTIAL_SOFT_COMPILE;
   10428 
   10429 if (functions->executable_funcs[mode] == NULL)
   10430   return PCRE_ERROR_JIT_BADOPTION;
   10431 
   10432 /* Sanity checks should be handled by pcre_exec. */
   10433 arguments.str = subject + start_offset;
   10434 arguments.begin = subject;
   10435 arguments.end = subject + length;
   10436 arguments.mark_ptr = NULL;
   10437 /* JIT decreases this value less frequently than the interpreter. */
   10438 arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (pcre_uint32)(extra_data->match_limit);
   10439 if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)
   10440   arguments.limit_match = functions->limit_match;
   10441 arguments.notbol = (options & PCRE_NOTBOL) != 0;
   10442 arguments.noteol = (options & PCRE_NOTEOL) != 0;
   10443 arguments.notempty = (options & PCRE_NOTEMPTY) != 0;
   10444 arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
   10445 arguments.offsets = offsets;
   10446 arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;
   10447 arguments.real_offset_count = offset_count;
   10448 
   10449 /* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of
   10450 the output vector for storing captured strings, with the remainder used as
   10451 workspace. We don't need the workspace here. For compatibility, we limit the
   10452 number of captured strings in the same way as pcre_exec(), so that the user
   10453 gets the same result with and without JIT. */
   10454 
   10455 if (offset_count != 2)
   10456   offset_count = ((offset_count - (offset_count % 3)) * 2) / 3;
   10457 max_offset_count = functions->top_bracket;
   10458 if (offset_count > max_offset_count)
   10459   offset_count = max_offset_count;
   10460 arguments.offset_count = offset_count;
   10461 
   10462 if (functions->callback)
   10463   arguments.stack = (struct sljit_stack *)functions->callback(functions->userdata);
   10464 else
   10465   arguments.stack = (struct sljit_stack *)functions->userdata;
   10466 
   10467 if (arguments.stack == NULL)
   10468   retval = jit_machine_stack_exec(&arguments, functions->executable_funcs[mode]);
   10469 else
   10470   {
   10471   convert_executable_func.executable_func = functions->executable_funcs[mode];
   10472   retval = convert_executable_func.call_executable_func(&arguments);
   10473   }
   10474 
   10475 if (retval * 2 > offset_count)
   10476   retval = 0;
   10477 if ((extra_data->flags & PCRE_EXTRA_MARK) != 0)
   10478   *(extra_data->mark) = arguments.mark_ptr;
   10479 
   10480 return retval;
   10481 }
   10482 
   10483 #if defined COMPILE_PCRE8
   10484 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
   10485 pcre_jit_exec(const pcre *argument_re, const pcre_extra *extra_data,
   10486   PCRE_SPTR subject, int length, int start_offset, int options,
   10487   int *offsets, int offset_count, pcre_jit_stack *stack)
   10488 #elif defined COMPILE_PCRE16
   10489 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
   10490 pcre16_jit_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
   10491   PCRE_SPTR16 subject, int length, int start_offset, int options,
   10492   int *offsets, int offset_count, pcre16_jit_stack *stack)
   10493 #elif defined COMPILE_PCRE32
   10494 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
   10495 pcre32_jit_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
   10496   PCRE_SPTR32 subject, int length, int start_offset, int options,
   10497   int *offsets, int offset_count, pcre32_jit_stack *stack)
   10498 #endif
   10499 {
   10500 pcre_uchar *subject_ptr = (pcre_uchar *)subject;
   10501 executable_functions *functions = (executable_functions *)extra_data->executable_jit;
   10502 union {
   10503    void *executable_func;
   10504    jit_function call_executable_func;
   10505 } convert_executable_func;
   10506 jit_arguments arguments;
   10507 int max_offset_count;
   10508 int retval;
   10509 int mode = JIT_COMPILE;
   10510 
   10511 SLJIT_UNUSED_ARG(argument_re);
   10512 
   10513 /* Plausibility checks */
   10514 if ((options & ~PUBLIC_JIT_EXEC_OPTIONS) != 0) return PCRE_ERROR_JIT_BADOPTION;
   10515 
   10516 if ((options & PCRE_PARTIAL_HARD) != 0)
   10517   mode = JIT_PARTIAL_HARD_COMPILE;
   10518 else if ((options & PCRE_PARTIAL_SOFT) != 0)
   10519   mode = JIT_PARTIAL_SOFT_COMPILE;
   10520 
   10521 if (functions->executable_funcs[mode] == NULL)
   10522   return PCRE_ERROR_JIT_BADOPTION;
   10523 
   10524 /* Sanity checks should be handled by pcre_exec. */
   10525 arguments.stack = (struct sljit_stack *)stack;
   10526 arguments.str = subject_ptr + start_offset;
   10527 arguments.begin = subject_ptr;
   10528 arguments.end = subject_ptr + length;
   10529 arguments.mark_ptr = NULL;
   10530 /* JIT decreases this value less frequently than the interpreter. */
   10531 arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (pcre_uint32)(extra_data->match_limit);
   10532 if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)
   10533   arguments.limit_match = functions->limit_match;
   10534 arguments.notbol = (options & PCRE_NOTBOL) != 0;
   10535 arguments.noteol = (options & PCRE_NOTEOL) != 0;
   10536 arguments.notempty = (options & PCRE_NOTEMPTY) != 0;
   10537 arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
   10538 arguments.offsets = offsets;
   10539 arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;
   10540 arguments.real_offset_count = offset_count;
   10541 
   10542 /* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of
   10543 the output vector for storing captured strings, with the remainder used as
   10544 workspace. We don't need the workspace here. For compatibility, we limit the
   10545 number of captured strings in the same way as pcre_exec(), so that the user
   10546 gets the same result with and without JIT. */
   10547 
   10548 if (offset_count != 2)
   10549   offset_count = ((offset_count - (offset_count % 3)) * 2) / 3;
   10550 max_offset_count = functions->top_bracket;
   10551 if (offset_count > max_offset_count)
   10552   offset_count = max_offset_count;
   10553 arguments.offset_count = offset_count;
   10554 
   10555 convert_executable_func.executable_func = functions->executable_funcs[mode];
   10556 retval = convert_executable_func.call_executable_func(&arguments);
   10557 
   10558 if (retval * 2 > offset_count)
   10559   retval = 0;
   10560 if ((extra_data->flags & PCRE_EXTRA_MARK) != 0)
   10561   *(extra_data->mark) = arguments.mark_ptr;
   10562 
   10563 return retval;
   10564 }
   10565 
   10566 void
   10567 PRIV(jit_free)(void *executable_funcs)
   10568 {
   10569 int i;
   10570 executable_functions *functions = (executable_functions *)executable_funcs;
   10571 for (i = 0; i < JIT_NUMBER_OF_COMPILE_MODES; i++)
   10572   {
   10573   if (functions->executable_funcs[i] != NULL)
   10574     sljit_free_code(functions->executable_funcs[i]);
   10575   free_read_only_data(functions->read_only_data_heads[i], NULL);
   10576   }
   10577 SLJIT_FREE(functions, compiler->allocator_data);
   10578 }
   10579 
   10580 int
   10581 PRIV(jit_get_size)(void *executable_funcs)
   10582 {
   10583 int i;
   10584 sljit_uw size = 0;
   10585 sljit_uw *executable_sizes = ((executable_functions *)executable_funcs)->executable_sizes;
   10586 for (i = 0; i < JIT_NUMBER_OF_COMPILE_MODES; i++)
   10587   size += executable_sizes[i];
   10588 return (int)size;
   10589 }
   10590 
   10591 const char*
   10592 PRIV(jit_get_target)(void)
   10593 {
   10594 return sljit_get_platform_name();
   10595 }
   10596 
   10597 #if defined COMPILE_PCRE8
   10598 PCRE_EXP_DECL pcre_jit_stack *
   10599 pcre_jit_stack_alloc(int startsize, int maxsize)
   10600 #elif defined COMPILE_PCRE16
   10601 PCRE_EXP_DECL pcre16_jit_stack *
   10602 pcre16_jit_stack_alloc(int startsize, int maxsize)
   10603 #elif defined COMPILE_PCRE32
   10604 PCRE_EXP_DECL pcre32_jit_stack *
   10605 pcre32_jit_stack_alloc(int startsize, int maxsize)
   10606 #endif
   10607 {
   10608 if (startsize < 1 || maxsize < 1)
   10609   return NULL;
   10610 if (startsize > maxsize)
   10611   startsize = maxsize;
   10612 startsize = (startsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);
   10613 maxsize = (maxsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);
   10614 return (PUBL(jit_stack)*)sljit_allocate_stack(startsize, maxsize, NULL);
   10615 }
   10616 
   10617 #if defined COMPILE_PCRE8
   10618 PCRE_EXP_DECL void
   10619 pcre_jit_stack_free(pcre_jit_stack *stack)
   10620 #elif defined COMPILE_PCRE16
   10621 PCRE_EXP_DECL void
   10622 pcre16_jit_stack_free(pcre16_jit_stack *stack)
   10623 #elif defined COMPILE_PCRE32
   10624 PCRE_EXP_DECL void
   10625 pcre32_jit_stack_free(pcre32_jit_stack *stack)
   10626 #endif
   10627 {
   10628 sljit_free_stack((struct sljit_stack *)stack, NULL);
   10629 }
   10630 
   10631 #if defined COMPILE_PCRE8
   10632 PCRE_EXP_DECL void
   10633 pcre_assign_jit_stack(pcre_extra *extra, pcre_jit_callback callback, void *userdata)
   10634 #elif defined COMPILE_PCRE16
   10635 PCRE_EXP_DECL void
   10636 pcre16_assign_jit_stack(pcre16_extra *extra, pcre16_jit_callback callback, void *userdata)
   10637 #elif defined COMPILE_PCRE32
   10638 PCRE_EXP_DECL void
   10639 pcre32_assign_jit_stack(pcre32_extra *extra, pcre32_jit_callback callback, void *userdata)
   10640 #endif
   10641 {
   10642 executable_functions *functions;
   10643 if (extra != NULL &&
   10644     (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
   10645     extra->executable_jit != NULL)
   10646   {
   10647   functions = (executable_functions *)extra->executable_jit;
   10648   functions->callback = callback;
   10649   functions->userdata = userdata;
   10650   }
   10651 }
   10652 
   10653 #if defined COMPILE_PCRE8
   10654 PCRE_EXP_DECL void
   10655 pcre_jit_free_unused_memory(void)
   10656 #elif defined COMPILE_PCRE16
   10657 PCRE_EXP_DECL void
   10658 pcre16_jit_free_unused_memory(void)
   10659 #elif defined COMPILE_PCRE32
   10660 PCRE_EXP_DECL void
   10661 pcre32_jit_free_unused_memory(void)
   10662 #endif
   10663 {
   10664 sljit_free_unused_memory_exec();
   10665 }
   10666 
   10667 #else  /* SUPPORT_JIT */
   10668 
   10669 /* These are dummy functions to avoid linking errors when JIT support is not
   10670 being compiled. */
   10671 
   10672 #if defined COMPILE_PCRE8
   10673 PCRE_EXP_DECL pcre_jit_stack *
   10674 pcre_jit_stack_alloc(int startsize, int maxsize)
   10675 #elif defined COMPILE_PCRE16
   10676 PCRE_EXP_DECL pcre16_jit_stack *
   10677 pcre16_jit_stack_alloc(int startsize, int maxsize)
   10678 #elif defined COMPILE_PCRE32
   10679 PCRE_EXP_DECL pcre32_jit_stack *
   10680 pcre32_jit_stack_alloc(int startsize, int maxsize)
   10681 #endif
   10682 {
   10683 (void)startsize;
   10684 (void)maxsize;
   10685 return NULL;
   10686 }
   10687 
   10688 #if defined COMPILE_PCRE8
   10689 PCRE_EXP_DECL void
   10690 pcre_jit_stack_free(pcre_jit_stack *stack)
   10691 #elif defined COMPILE_PCRE16
   10692 PCRE_EXP_DECL void
   10693 pcre16_jit_stack_free(pcre16_jit_stack *stack)
   10694 #elif defined COMPILE_PCRE32
   10695 PCRE_EXP_DECL void
   10696 pcre32_jit_stack_free(pcre32_jit_stack *stack)
   10697 #endif
   10698 {
   10699 (void)stack;
   10700 }
   10701 
   10702 #if defined COMPILE_PCRE8
   10703 PCRE_EXP_DECL void
   10704 pcre_assign_jit_stack(pcre_extra *extra, pcre_jit_callback callback, void *userdata)
   10705 #elif defined COMPILE_PCRE16
   10706 PCRE_EXP_DECL void
   10707 pcre16_assign_jit_stack(pcre16_extra *extra, pcre16_jit_callback callback, void *userdata)
   10708 #elif defined COMPILE_PCRE32
   10709 PCRE_EXP_DECL void
   10710 pcre32_assign_jit_stack(pcre32_extra *extra, pcre32_jit_callback callback, void *userdata)
   10711 #endif
   10712 {
   10713 (void)extra;
   10714 (void)callback;
   10715 (void)userdata;
   10716 }
   10717 
   10718 #if defined COMPILE_PCRE8
   10719 PCRE_EXP_DECL void
   10720 pcre_jit_free_unused_memory(void)
   10721 #elif defined COMPILE_PCRE16
   10722 PCRE_EXP_DECL void
   10723 pcre16_jit_free_unused_memory(void)
   10724 #elif defined COMPILE_PCRE32
   10725 PCRE_EXP_DECL void
   10726 pcre32_jit_free_unused_memory(void)
   10727 #endif
   10728 {
   10729 }
   10730 
   10731 #endif
   10732 
   10733 /* End of pcre_jit_compile.c */
   10734