Lines Matching defs:cc
245 PCRE2_SPTR cc;
532 #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
580 static PCRE2_SPTR bracketend(PCRE2_SPTR cc)
582 SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
583 do cc += GET(cc, 1); while (*cc == OP_ALT);
584 SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
585 cc += 1 + LINK_SIZE;
586 return cc;
589 static int no_alternatives(PCRE2_SPTR cc)
592 SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
595 cc += GET(cc, 1);
598 while (*cc == OP_ALT);
599 SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
615 static PCRE2_SPTR next_opcode(compiler_common *common, PCRE2_SPTR cc)
618 switch(*cc)
707 return cc + PRIV(OP_lengths)[*cc];
765 cc += PRIV(OP_lengths)[*cc];
767 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
769 return cc;
785 return cc + PRIV(OP_lengths)[*cc] - 1;
791 return cc + 1;
794 return cc + GET(cc, 1 + 2*LINK_SIZE);
798 return cc + GET(cc, 1);
805 return cc + 1 + 2 + cc[1];
814 static BOOL check_opcode_types(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend)
818 PCRE2_SPTR assert_back_end = cc - 1;
821 while (cc < ccend)
823 switch(*cc)
828 cc += 1;
833 common->optimized_cbracket[GET2(cc, 1)] = 0;
834 cc += 1 + IMM2_SIZE;
839 common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
840 cc += 1 + LINK_SIZE + IMM2_SIZE;
847 if (cc[1 + LINK_SIZE] == OP_CALLOUT || cc[1 + LINK_SIZE] == OP_CALLOUT_STR)
849 cc += 1 + LINK_SIZE;
853 common->optimized_cbracket[GET2(cc, 1)] = 0;
854 cc += 1 + IMM2_SIZE;
860 count = GET2(cc, 1 + IMM2_SIZE);
861 slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
867 cc += 1 + 2 * IMM2_SIZE;
877 cc += 1 + LINK_SIZE;
887 cc += (*cc == OP_CALLOUT) ? PRIV(OP_lengths)[OP_CALLOUT] : GET(cc, 1 + 2*LINK_SIZE);
891 slot = bracketend(cc);
894 cc += 1 + LINK_SIZE;
909 cc += 1 + 2 + cc[1];
915 cc += 1;
919 if (cc < assert_back_end)
921 cc += 1;
927 if (cc < assert_back_end)
929 cc += 1 + 2 + cc[1];
933 cc = next_opcode(common, cc);
934 if (cc == NULL)
942 static BOOL is_accelerated_repeat(PCRE2_SPTR cc)
944 switch(*cc)
952 return (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI);
987 cc += (*cc == OP_XCLASS) ? GET(cc, 1) : (int)(1 + (32 / sizeof(PCRE2_UCHAR)));
989 cc += (1 + (32 / sizeof(PCRE2_UCHAR)));
992 switch(*cc)
1009 PCRE2_SPTR cc = common->start;
1015 switch(*cc)
1029 cc++;
1033 if (*cc != OP_BRA && *cc != OP_CBRA)
1036 end = cc + GET(cc, 1);
1039 if (*cc == OP_CBRA)
1041 if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
1043 cc += IMM2_SIZE;
1045 cc += 1 + LINK_SIZE;
1048 if (is_accelerated_repeat(cc))
1050 common->fast_forward_bc_ptr = cc;
1051 common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;
1058 static SLJIT_INLINE void detect_fast_fail(compiler_common *common, PCRE2_SPTR cc, int *private_data_start, sljit_s32 depth)
1062 SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA);
1064 if (*cc == OP_CBRA && common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
1067 next_alt = bracketend(cc) - (1 + LINK_SIZE);
1073 next_alt = cc + GET(cc, 1);
1075 cc += 1 + LINK_SIZE + ((*cc == OP_CBRA) ? IMM2_SIZE : 0);
1079 switch(*cc)
1093 cc++;
1099 if (depth > 0 && (*cc == OP_BRA || *cc == OP_CBRA))
1100 detect_fast_fail(common, cc, private_data_start, depth - 1);
1102 if (is_accelerated_repeat(cc))
1104 common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;
1116 cc = next_alt;
1118 while (*cc == OP_ALT);
1121 static int get_class_iterator_size(PCRE2_SPTR cc)
1125 switch(*cc)
1139 min = GET2(cc, 1);
1140 max = GET2(cc, 1 + IMM2_SIZE);
1142 return (*cc == OP_CRRANGE) ? 2 : 1;
1292 PCRE2_SPTR cc = common->start;
1299 while (cc < ccend)
1307 if (repeat_check && (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND))
1309 if (detect_repeat(common, cc))
1313 if (cc >= end)
1314 end = bracketend(cc);
1319 switch(*cc)
1322 if (common->private_data_ptrs[cc + 1 - common->start] != 0)
1324 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1326 cc += common->private_data_ptrs[cc + 1 - common->start];
1328 cc += 1 + LINK_SIZE;
1341 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1348 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1355 alternative = cc + GET(cc, 1);
1358 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1401 if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
1407 if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
1419 space = get_class_iterator_size(cc + size);
1425 space = get_class_iterator_size(cc + size);
1426 size = GET(cc, 1);
1431 cc = next_opcode(common, cc);
1432 SLJIT_ASSERT(cc != NULL);
1438 if (space > 0 && cc >= end)
1440 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1448 cc += -size;
1450 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1454 cc += size;
1459 if (cc >= end)
1461 end = bracketend(cc);
1465 cc += bracketlen;
1472 static int get_framesize(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, BOOL recursive, BOOL *needs_control_head)
1491 ccend = bracketend(cc) - (1 + LINK_SIZE);
1492 if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
1498 cc = next_opcode(common, cc);
1501 SLJIT_ASSERT(cc != NULL);
1502 while (cc < ccend)
1503 switch(*cc)
1513 cc += 1;
1528 cc += 1 + 2 + cc[1];
1548 cc += 1 + LINK_SIZE;
1562 cc += 1 + LINK_SIZE + IMM2_SIZE;
1569 cc ++;
1643 cc = next_opcode(common, cc);
1644 SLJIT_ASSERT(cc != NULL);
1657 static void init_frame(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, int stackpos, int stacktop, BOOL recursive)
1673 ccend = bracketend(cc) - (1 + LINK_SIZE);
1674 if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
1675 cc = next_opcode(common, cc);
1678 SLJIT_ASSERT(cc != NULL);
1679 while (cc < ccend)
1680 switch(*cc)
1693 cc += 1;
1709 cc += 1 + 2 + cc[1];
1740 cc += 1 + LINK_SIZE;
1756 offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
1766 cc += 1 + LINK_SIZE + IMM2_SIZE;
1770 cc = next_opcode(common, cc);
1771 SLJIT_ASSERT(cc != NULL);
1779 static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, BOOL needs_control_head)
1785 while (cc < ccend)
1788 switch(*cc)
1791 if (PRIVATE_DATA(cc) != 0)
1794 SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
1795 cc += PRIVATE_DATA(cc + 1);
1797 cc += 1 + LINK_SIZE;
1811 SLJIT_ASSERT(PRIVATE_DATA(cc) != 0);
1812 cc += 1 + LINK_SIZE;
1817 if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
1819 cc += 1 + LINK_SIZE + IMM2_SIZE;
1825 cc += 1 + LINK_SIZE + IMM2_SIZE;
1830 alternative = cc + GET(cc, 1);
1833 cc += 1 + LINK_SIZE;
1837 if (PRIVATE_DATA(cc))
1839 cc += 2;
1841 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1846 if (PRIVATE_DATA(cc))
1848 cc += 2;
1850 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1855 if (PRIVATE_DATA(cc))
1857 cc += 2 + IMM2_SIZE;
1859 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1864 if (PRIVATE_DATA(cc))
1866 cc += 1;
1870 if (PRIVATE_DATA(cc))
1872 cc += 1;
1876 if (PRIVATE_DATA(cc))
1878 cc += 1 + IMM2_SIZE;
1885 size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(PCRE2_UCHAR);
1889 if (PRIVATE_DATA(cc))
1890 private_data_length += get_class_iterator_size(cc + size);
1891 cc += size;
1895 cc = next_opcode(common, cc);
1896 SLJIT_ASSERT(cc != NULL);
1900 SLJIT_ASSERT(cc == ccend);
1904 static void copy_private_data(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend,
1961 if (cc >= ccend)
1967 switch(*cc)
1970 if (PRIVATE_DATA(cc) != 0)
1973 srcw[0] = PRIVATE_DATA(cc);
1974 SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
1975 cc += PRIVATE_DATA(cc + 1);
1977 cc += 1 + LINK_SIZE;
1991 srcw[0] = PRIVATE_DATA(cc);
1993 cc += 1 + LINK_SIZE;
1998 if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
2001 srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
2003 cc += 1 + LINK_SIZE + IMM2_SIZE;
2009 srcw[0] = PRIVATE_DATA(cc);
2010 srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
2012 cc += 1 + LINK_SIZE + IMM2_SIZE;
2017 alternative = cc + GET(cc, 1);
2021 srcw[0] = PRIVATE_DATA(cc);
2024 cc += 1 + LINK_SIZE;
2028 if (PRIVATE_DATA(cc))
2031 srcw[0] = PRIVATE_DATA(cc);
2033 cc += 2;
2035 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
2040 if (PRIVATE_DATA(cc))
2043 srcw[0] = PRIVATE_DATA(cc);
2044 srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
2046 cc += 2;
2048 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
2053 if (PRIVATE_DATA(cc))
2056 srcw[0] = PRIVATE_DATA(cc);
2057 srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
2059 cc += 2 + IMM2_SIZE;
2061 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
2066 if (PRIVATE_DATA(cc))
2069 srcw[0] = PRIVATE_DATA(cc);
2071 cc += 1;
2075 if (PRIVATE_DATA(cc))
2078 srcw[0] = PRIVATE_DATA(cc);
2081 cc += 1;
2085 if (PRIVATE_DATA(cc))
2088 srcw[0] = PRIVATE_DATA(cc);
2091 cc += 1 + IMM2_SIZE;
2098 size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(PCRE2_UCHAR);
2102 if (PRIVATE_DATA(cc))
2103 switch(get_class_iterator_size(cc + size))
2107 srcw[0] = PRIVATE_DATA(cc);
2112 srcw[0] = PRIVATE_DATA(cc);
2120 cc += size;
2124 cc = next_opcode(common, cc);
2125 SLJIT_ASSERT(cc != NULL);
2223 SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
2226 static SLJIT_INLINE PCRE2_SPTR set_then_offsets(compiler_common *common, PCRE2_SPTR cc, sljit_u8 *current_offset)
2228 PCRE2_SPTR end = bracketend(cc);
2229 BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
2232 if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
2235 if (*cc == OP_COND || *cc == OP_SCOND)
2238 cc = next_opcode(common, cc);
2240 current_offset = common->then_offsets + (cc - common->start);
2242 while (cc < end)
2244 if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
2245 cc = set_then_offsets(common, cc, current_offset);
2248 if (*cc == OP_ALT && has_alternatives)
2249 current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);
2250 if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)
2252 cc = next_opcode(common, cc);
2601 static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, PCRE2_SPTR cc)
2609 GETCHAR(c, cc);
2620 c = *cc;
2636 static unsigned int char_get_othercase_bit(compiler_common *common, PCRE2_SPTR cc)
2647 GETCHAR(c, cc);
2657 c = *cc;
2661 c = *cc;
2681 n = GET_EXTRALEN(*cc);
3481 static int scan_prefix(compiler_common *common, PCRE2_SPTR cc, PCRE2_UCHAR *chars, int max_chars, sljit_u32 *rec_count)
3509 switch (*cc)
3515 cc++;
3530 cc++;
3537 cc = bracketend(cc);
3547 cc++;
3553 repeat = GET2(cc, 1);
3555 cc += 1 + IMM2_SIZE;
3566 cc++;
3568 if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3570 max_chars = scan_prefix(common, cc + len, chars, max_chars, rec_count);
3577 cc += 1 + LINK_SIZE;
3581 cc += GET(cc, 1);
3590 alternative = cc + GET(cc, 1);
3599 if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
3600 cc += IMM2_SIZE;
3601 cc += 1 + LINK_SIZE;
3606 if (common->utf && !is_char7_bitset((const sljit_u8 *)(cc + 1), FALSE))
3625 cc += GET(cc, 1);
3635 cc++;
3644 cc++;
3653 cc++;
3658 cc++;
3669 cc++;
3679 cc += 1 + 2;
3684 repeat = GET2(cc, 1);
3685 cc += 1 + IMM2_SIZE;
3694 repeat = GET2(cc, 1);
3695 cc += 1 + IMM2_SIZE + 1;
3721 bytes = (sljit_u8*) (cc + 1);
3722 cc += 1 + 32 / sizeof(PCRE2_UCHAR);
3724 switch (*cc)
3732 max_chars = scan_prefix(common, cc + 1, chars, max_chars, rec_count);
3746 repeat = GET2(cc, 1);
3790 switch (*cc)
3800 cc++;
3806 if (GET2(cc, 1) != GET2(cc, 1 + IMM2_SIZE))
3808 cc += 1 + 2 * IMM2_SIZE;
3818 if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3821 if (caseless && char_has_othercase(common, cc))
3826 GETCHAR(chr, cc);
3833 chr = *cc;
3844 cc_save = cc;
3850 chr = *cc;
3851 add_prefix_char(*cc, chars);
3861 cc++;
3870 cc = cc_save;
5300 static PCRE2_SPTR byte_sequence_compare(compiler_common *common, BOOL caseless, PCRE2_SPTR cc,
5310 if (caseless && char_has_othercase(common, cc))
5312 othercasebit = char_get_othercase_bit(common, cc);
5316 othercasechar = cc + (othercasebit >> 8);
5323 othercasechar = cc + (othercasebit >> 9);
5357 if (common->utf && HAS_EXTRALEN(*cc))
5358 utflength += GET_EXTRALEN(*cc);
5368 if (othercasebit != 0 && othercasechar == cc)
5370 context->c.asuchars[context->ucharptr] = *cc | othercasebit;
5375 context->c.asuchars[context->ucharptr] = *cc;
5433 if (othercasebit != 0 && othercasechar == cc)
5436 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
5439 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
5443 cc++;
5450 return cc;
5475 static PCRE2_SPTR compile_char1_matchingpath(compiler_common *common, PCRE2_UCHAR type, PCRE2_SPTR cc, jump_list **backtracks, BOOL check_str_ptr);
5477 static void compile_xclass_matchingpath(compiler_common *common, PCRE2_SPTR cc, jump_list **backtracks)
5481 jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks;
5499 cc++;
5500 ccbegin = cc;
5503 if (cc[-1] & XCL_MAP)
5506 cc += 32 / sizeof(PCRE2_UCHAR);
5509 while (*cc != XCL_END)
5512 if (*cc == XCL_SINGLE)
5514 cc ++;
5515 GETCHARINCTEST(c, cc);
5522 else if (*cc == XCL_RANGE)
5524 cc ++;
5525 GETCHARINCTEST(c, cc);
5527 GETCHARINCTEST(c, cc);
5536 SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
5537 cc++;
5538 if (*cc == PT_CLIST)
5540 other_cases = PRIV(ucd_caseless_sets) + cc[1];
5554 switch(*cc)
5558 if (cc[-1] == XCL_PROP)
5560 compile_char1_matchingpath(common, OP_ALLANY, cc, backtracks, FALSE);
5597 cc += 2;
5604 cc = ccbegin;
5605 read_char_range(common, min, max, (cc[-1] & XCL_NOT) != 0);
5607 if ((cc[-1] & XCL_HASPROP) == 0)
5609 if ((cc[-1] & XCL_MAP) != 0)
5612 if (!check_class_ranges(common, (const sljit_u8 *)cc, (((const sljit_u8 *)cc)[31] & 0x80) != 0, TRUE, &found))
5616 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
5625 cc += 32 / sizeof(PCRE2_UCHAR);
5630 add_jump(compiler, (cc[-1] & XCL_NOT) == 0 ? backtracks : &found, CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, max - min));
5633 else if ((cc[-1] & XCL_MAP) != 0)
5639 if (!check_class_ranges(common, (const sljit_u8 *)cc, FALSE, TRUE, list))
5649 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
5661 cc += 32 / sizeof(PCRE2_UCHAR);
5684 ccbegin = cc;
5686 while (*cc != XCL_END)
5688 if (*cc == XCL_SINGLE)
5690 cc ++;
5691 GETCHARINCTEST(c, cc);
5693 else if (*cc == XCL_RANGE)
5695 cc ++;
5696 GETCHARINCTEST(c, cc);
5697 GETCHARINCTEST(c, cc);
5701 SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
5702 cc++;
5703 if (*cc == PT_SC)
5707 if (cc[-1] == XCL_NOTPROP)
5709 jump = CMP(SLJIT_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (int)cc[1]);
5712 cc += 2;
5716 cc = ccbegin;
5748 while (*cc != XCL_END)
5754 if (*cc == XCL_SINGLE)
5756 cc ++;
5757 GETCHARINCTEST(c, cc);
5759 if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
5778 else if (*cc == XCL_RANGE)
5780 cc ++;
5781 GETCHARINCTEST(c, cc);
5783 GETCHARINCTEST(c, cc);
5785 if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
5807 SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
5808 if (*cc == XCL_NOTPROP)
5810 cc++;
5811 switch(*cc)
5829 c = PRIV(ucp_typerange)[(int)cc[1] * 2];
5831 jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c);
5835 jump = CMP(SLJIT_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset);
5869 OP_FLAGS((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, (*cc == PT_ALNUM) ? SLJIT_UNUSED : TMP2, 0, SLJIT_LESS_EQUAL);
5877 other_cases = PRIV(ucd_caseless_sets) + cc[1];
6011 cc += 2;
6028 static PCRE2_SPTR compile_simple_assertion_matchingpath(compiler_common *common, PCRE2_UCHAR type, PCRE2_SPTR cc, jump_list **backtracks)
6043 return cc;
6049 return cc;
6055 return cc;
6123 return cc;
6128 return cc;
6136 compile_simple_assertion_matchingpath(common, OP_EODN, cc, backtracks);
6142 return cc;
6179 return cc;
6187 return cc;
6217 return cc;
6220 length = GET(cc, 0);
6222 return cc + LINK_SIZE;
6243 return cc + LINK_SIZE;
6246 return cc;
6249 static PCRE2_SPTR compile_char1_matchingpath(compiler_common *common, PCRE2_UCHAR type, PCRE2_SPTR cc, jump_list **backtracks, BOOL check_str_ptr)
6278 return cc;
6292 return cc;
6306 return cc;
6328 return cc;
6353 return cc;
6357 return cc;
6363 return cc;
6370 propdata[2] = cc[0];
6371 propdata[3] = cc[1];
6376 return cc + 2;
6399 return cc;
6408 return cc;
6417 return cc;
6456 return cc;
6463 if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);
6466 && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))
6476 return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);
6484 GETCHAR(c, cc);
6488 c = *cc;
6490 if (type == OP_CHAR || !char_has_othercase(common, cc))
6494 return cc + length;
6503 return cc + length;
6508 return cc + length;
6520 c = *cc;
6524 if (type == OP_NOT || !char_has_othercase(common, cc))
6538 return cc + 1;
6543 GETCHARLEN(c, cc, length);
6548 c = *cc;
6550 if (type == OP_NOT || !char_has_othercase(common, cc))
6571 return cc + length;
6579 bit = (common->utf && is_char7_bitset((const sljit_u8 *)cc, type == OP_NCLASS)) ? 127 : 255;
6585 if (check_class_ranges(common, (const sljit_u8 *)cc, type == OP_NCLASS, FALSE, backtracks))
6586 return cc + 32 / sizeof(PCRE2_UCHAR);
6610 OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
6619 return cc + 32 / sizeof(PCRE2_UCHAR);
6625 compile_xclass_matchingpath(common, cc + LINK_SIZE, backtracks);
6626 return cc + GET(cc, 0) - 1;
6630 return cc;
6633 static SLJIT_INLINE PCRE2_SPTR compile_charn_matchingpath(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, jump_list **backtracks)
6638 PCRE2_SPTR ccbegin = cc;
6645 if (cc >= ccend)
6648 if (*cc == OP_CHAR)
6652 if (common->utf && HAS_EXTRALEN(cc[1]))
6653 size += GET_EXTRALEN(cc[1]);
6656 else if (*cc == OP_CHARI)
6662 if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
6664 else if (HAS_EXTRALEN(cc[1]))
6665 size += GET_EXTRALEN(cc[1]);
6669 if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
6675 cc += 1 + size;
6680 cc = ccbegin;
6691 do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, backtracks); while (context.length > 0);
6692 return cc;
6696 return compile_char1_matchingpath(common, *cc, cc + 1, backtracks, TRUE);
6711 backtrack->cc = (ccstart); \
6724 backtrack->cc = (ccstart); \
6731 static void compile_dnref_search(compiler_common *common, PCRE2_SPTR cc, jump_list **backtracks)
6735 int count = GET2(cc, 1 + IMM2_SIZE);
6736 PCRE2_SPTR slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
6740 SLJIT_ASSERT(*cc == OP_DNREF || *cc == OP_DNREFI);
6761 static void compile_ref_matchingpath(compiler_common *common, PCRE2_SPTR cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
6764 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
6772 offset = GET2(cc, 1) << 1;
6782 if (common->utf && *cc == OP_REFI)
6827 add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
6839 add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
6857 static SLJIT_INLINE PCRE2_SPTR compile_ref_iterator_matchingpath(compiler_common *common, PCRE2_SPTR cc, backtrack_common *parent)
6860 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
6867 PCRE2_SPTR ccbegin = cc;
6871 PUSH_BACKTRACK(sizeof(ref_iterator_backtrack), cc, NULL);
6874 offset = GET2(cc, 1) << 1;
6876 cc += IMM2_SIZE;
6877 type = cc[1 + IMM2_SIZE];
6887 cc += 1 + IMM2_SIZE + 1;
6893 cc += 1 + IMM2_SIZE + 1;
6899 cc += 1 + IMM2_SIZE + 1;
6903 min = GET2(cc, 1 + IMM2_SIZE + 1);
6904 max = GET2(cc, 1 + IMM2_SIZE + 1 + IMM2_SIZE);
6905 cc += 1 + IMM2_SIZE + 1 + 2 * IMM2_SIZE;
6994 return cc;
7061 return cc;
7064 static SLJIT_INLINE PCRE2_SPTR compile_recurse_matchingpath(compiler_common *common, PCRE2_SPTR cc, backtrack_common *parent)
7070 sljit_sw start = GET(cc, 1);
7074 PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
7082 return cc + 1 + LINK_SIZE;
7130 return cc + 1 + LINK_SIZE;
7175 static SLJIT_INLINE PCRE2_SPTR compile_callout_matchingpath(compiler_common *common, PCRE2_SPTR cc, backtrack_common *parent)
7180 unsigned int callout_length = (*cc == OP_CALLOUT)
7181 ? PRIV(OP_lengths)[OP_CALLOUT] : GET(cc, 1 + 2 * LINK_SIZE);
7186 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
7193 value1 = (*cc == OP_CALLOUT) ? cc[1 + 2 * LINK_SIZE] : 0;
7205 OP1(mov_opcode, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 1));
7206 cc, 1 + LINK_SIZE));
7208 if (*cc == OP_CALLOUT)
7216 value1 = (sljit_sw) (cc + (1 + 4*LINK_SIZE) + 1);
7218 value3 = (sljit_sw) (GET(cc, 1 + 3*LINK_SIZE));
7242 return cc + callout_length;
7248 static SLJIT_INLINE BOOL assert_needs_str_ptr_saving(PCRE2_SPTR cc)
7252 switch (*cc)
7255 cc += GET(cc, 1 + 2*LINK_SIZE);
7266 cc += PRIV(OP_lengths)[*cc];
7278 static PCRE2_SPTR compile_assert_matchingpath(compiler_common *common, PCRE2_SPTR cc, assert_backtrack *backtrack, BOOL conditional)
7307 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
7310 bra = *cc;
7311 cc++;
7313 private_data_ptr = PRIVATE_DATA(cc);
7315 framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
7318 opcode = *cc;
7321 ccbegin = cc;
7322 cc += GET(cc, 1);
7407 altbacktrack.cc = ccbegin;
7408 compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
7504 if (*cc != OP_ALT)
7507 ccbegin = cc;
7508 cc += GET(cc, 1);
7697 return cc + 1 + LINK_SIZE;
7827 static PCRE2_SPTR compile_bracket_matchingpath(compiler_common *common, PCRE2_SPTR cc, backtrack_common *parent)
7850 PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
7852 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
7854 bra = *cc;
7855 cc++;
7856 opcode = *cc;
7859 opcode = *cc;
7860 ccbegin = cc;
7861 matchingpath = bracketend(cc) - 1 - LINK_SIZE;
7879 cc += GET(cc, 1);
7881 has_alternatives = *cc == OP_ALT;
7889 if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
8198 if (*cc == OP_ALT)
8200 matchingpath = cc + 1 + LINK_SIZE;
8201 cc += GET(cc, 1);
8204 matchingpath = cc;
8215 assert->common.cc = matchingpath;
8221 compile_matchingpath(common, matchingpath, cc, backtrack);
8360 while (*cc == OP_ALT)
8361 cc += GET(cc, 1);
8362 cc += 1 + LINK_SIZE;
8371 return cc + repeat_length;
8374 static PCRE2_SPTR compile_bracketpos_matchingpath(compiler_common *common, PCRE2_SPTR cc, backtrack_common *parent)
8391 PUSH_BACKTRACK(sizeof(bracketpos_backtrack), cc, NULL);
8392 if (*cc == OP_BRAPOSZERO)
8395 cc++;
8398 opcode = *cc;
8399 private_data_ptr = PRIVATE_DATA(cc);
8406 ccbegin = cc + 1 + LINK_SIZE;
8411 offset = GET2(cc, 1 + LINK_SIZE);
8417 ccbegin = cc + 1 + LINK_SIZE + IMM2_SIZE;
8425 framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
8518 init_frame(common, cc, NULL, stacksize - 1, stacksize - framesize, FALSE);
8526 while (*cc != OP_KETRPOS)
8530 cc += GET(cc, 1);
8532 compile_matchingpath(common, ccbegin, cc, backtrack);
8624 if (*cc == OP_KETRPOS)
8635 if (*cc == OP_KETRPOS)
8637 ccbegin = cc + 1 + LINK_SIZE;
8654 return cc + 1 + LINK_SIZE;
8657 static SLJIT_INLINE PCRE2_SPTR get_iterator_parameters(compiler_common *common, PCRE2_SPTR cc, PCRE2_UCHAR *opcode, PCRE2_UCHAR *type, sljit_u32 *max, sljit_u32 *exact, PCRE2_SPTR *end)
8661 *opcode = *cc;
8666 cc++;
8671 cc++;
8677 cc++;
8683 cc++;
8689 cc++;
8697 cc++;
8698 class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(PCRE2_UCHAR))) : GET(cc, 0);
8699 *opcode = cc[class_len - 1];
8704 cc + class_len;
8715 *end = cc + class_len;
8726 *max = GET2(cc, (class_len + IMM2_SIZE));
8727 *exact = GET2(cc, class_len);
8756 *end = cc + class_len + 2 * IMM2_SIZE;
8758 return cc;
8764 *exact = GET2(cc, 0);
8765 cc += IMM2_SIZE;
8782 *max = GET2(cc, 0);
8783 cc += IMM2_SIZE;
8789 *type = *cc;
8790 *end = next_opcode(common, cc);
8791 cc++;
8792 return cc;
8795 *end = cc + 1;
8797 if (common->utf && HAS_EXTRALEN(*cc)) *end += GET_EXTRALEN(*cc);
8799 return cc;
8802 static PCRE2_SPTR compile_iterator_matchingpath(compiler_common *common, PCRE2_SPTR cc, backtrack_common *parent)
8819 int private_data_ptr = PRIVATE_DATA(cc);
8825 PUSH_BACKTRACK(sizeof(char_iterator_backtrack), cc, NULL);
8827 fast_str_ptr = PRIVATE_DATA(cc + 1);
8830 SLJIT_ASSERT(common->fast_forward_bc_ptr == NULL || fast_str_ptr == 0 || cc == common->fast_forward_bc_ptr);
8832 if (cc == common->fast_forward_bc_ptr)
8840 cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &exact, &end);
8870 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, FALSE);
8878 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, TRUE);
8884 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, TRUE);
8905 compile_char1_matchingpath(common, type, cc, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, TRUE);
8974 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, FALSE);
8997 compile_char1_matchingpath(common, type, cc, &no_match, FALSE);
9042 compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
9070 compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
9116 compile_char1_matchingpath(common, type, cc, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, TRUE);
9129 compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
9141 compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
9158 compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
9170 compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
9182 compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
9197 static SLJIT_INLINE PCRE2_SPTR compile_fail_accept_matchingpath(compiler_common *common, PCRE2_SPTR cc, backtrack_common *parent)
9202 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
9204 if (*cc == OP_FAIL)
9207 return cc + 1;
9210 if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL || !common->might_be_empty)
9217 return cc + 1;
9239 return cc + 1;
9242 static SLJIT_INLINE PCRE2_SPTR compile_close_matchingpath(compiler_common *common, PCRE2_SPTR cc)
9245 int offset = GET2(cc, 1);
9250 return cc + 1 + IMM2_SIZE;
9258 return cc + 1 + IMM2_SIZE;
9261 static SLJIT_INLINE PCRE2_SPTR compile_control_verb_matchingpath(compiler_common *common, PCRE2_SPTR cc, backtrack_common *parent)
9265 PCRE2_UCHAR opcode = *cc;
9266 PCRE2_SPTR ccend = cc + 1;
9269 ccend += 2 + cc[1];
9271 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
9283 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
9293 static SLJIT_INLINE void compile_then_trap_matchingpath(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, backtrack_common *parent)
9300 PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
9302 BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
9303 BACKTRACK_AS(then_trap_backtrack)->start = (sljit_sw)(cc - common->start);
9304 BACKTRACK_AS(then_trap_backtrack)->framesize = get_framesize(common, cc, ccend, FALSE, &needs_control_head);
9321 init_frame(common, cc, ccend, size - 1, 0, FALSE);
9324 static void compile_matchingpath(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, backtrack_common *parent)
9333 if (common->has_then && common->then_offsets[cc - common->start] != 0)
9339 compile_then_trap_matchingpath(common, cc, ccend, parent);
9342 while (cc < ccend)
9344 switch(*cc)
9357 cc = compile_simple_assertion_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
9379 cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);
9383 PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
9388 cc++;
9394 cc = compile_charn_matchingpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
9396 cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);
9464 cc = compile_iterator_matchingpath(common, cc, parent);
9469 if (cc[1 + (32 / sizeof(PCRE2_UCHAR))] >= OP_CRSTAR && cc[1 + (32 / sizeof(PCRE2_UCHAR))] <= OP_CRPOSRANGE)
9470 cc = compile_iterator_matchingpath(common, cc, parent);
9472 cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);
9477 if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRPOSRANGE)
9478 cc = compile_iterator_matchingpath(common, cc, parent);
9480 cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);
9486 if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRPOSRANGE)
9487 cc = compile_ref_iterator_matchingpath(common, cc, parent);
9490 compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
9491 cc += 1 + IMM2_SIZE;
9497 if (cc[1 + 2 * IMM2_SIZE] >= OP_CRSTAR && cc[1 + 2 * IMM2_SIZE] <= OP_CRPOSRANGE)
9498 cc = compile_ref_iterator_matchingpath(common, cc, parent);
9501 compile_dnref_search(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
9502 compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
9503 cc += 1 + 2 * IMM2_SIZE;
9508 cc = compile_recurse_matchingpath(common, cc, parent);
9513 cc = compile_callout_matchingpath(common, cc, parent);
9520 PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
9521 cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
9525 PUSH_BACKTRACK_NOVALUE(sizeof(braminzero_backtrack), cc);
9526 cc = bracketend(cc + 1);
9527 if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)
9550 cc = compile_bracket_matchingpath(common, cc, parent);
9554 if (cc[1] > OP_ASSERTBACK_NOT)
9555 cc = compile_bracket_matchingpath(common, cc, parent);
9558 PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
9559 cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
9568 cc = compile_bracketpos_matchingpath(common, cc, parent);
9572 PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
9578 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
9586 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), SLJIT_IMM, (sljit_sw)(cc + 2));
9590 cc += 1 + 2 + cc[1];
9600 cc = compile_control_verb_matchingpath(common, cc, parent);
9606 cc = compile_fail_accept_matchingpath(common, cc, parent);
9610 cc = compile_close_matchingpath(common, cc);
9614 cc = bracketend(cc + 1);
9621 if (cc == NULL)
9628 PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
9629 BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
9633 SLJIT_ASSERT(cc == ccend);
9654 PCRE2_SPTR cc = current->cc;
9662 int private_data_ptr = PRIVATE_DATA(cc);
9667 cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &exact, &end);
9715 compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);
9730 compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);
9757 compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);
9782 PCRE2_SPTR cc = current->cc;
9783 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
9786 type = cc[ref ? 1 + IMM2_SIZE : 1 + 2 * IMM2_SIZE];
9833 PCRE2_SPTR cc = current->cc;
9837 SLJIT_ASSERT(*cc != OP_BRAMINZERO);
9838 if (*cc == OP_BRAZERO)
9840 bra = *cc;
9841 cc++;
9865 if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)
9876 if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)
9904 PCRE2_SPTR cc = current->cc;
9921 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
9923 bra = *cc;
9924 cc++;
9927 opcode = *cc;
9928 ccbegin = bracketend(cc) - 1 - LINK_SIZE;
9941 ccbegin = cc;
9942 cc += GET(cc, 1);
9943 has_alternatives = *cc == OP_ALT;
9948 if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
10133 if (*cc == OP_ALT)
10135 ccprev = cc + 1 + LINK_SIZE;
10136 cc += GET(cc, 1);
10149 compile_matchingpath(common, ccprev, cc, current);
10240 while (*cc == OP_ALT);
10285 cc = ccbegin + GET(ccbegin, 1);
10291 stacksize += CURRENT_AS(bracket_backtrack)->u.framesize + ((ket != OP_KET || *cc == OP_ALT) ? 2 : 1);
10293 else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
10367 if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)
10369 offset = (GET2(current->cc, 1 + LINK_SIZE)) << 1;
10405 if (current->cc[1] > OP_ASSERTBACK_NOT)
10408 compile_bracket_matchingpath(common, current->cc, current);
10414 backtrack.common.cc = current->cc;
10417 compile_assert_matchingpath(common, current->cc, &backtrack, FALSE);
10425 PCRE2_UCHAR opcode = *current->cc;
10469 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, (sljit_sw)(current->cc + 2));
10524 switch(*current->cc)
10635 if (current->cc[1] > OP_ASSERTBACK_NOT)
10706 PCRE2_SPTR cc = common->start + common->currententry->start;
10707 PCRE2_SPTR ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);
10708 PCRE2_SPTR ccend = bracketend(cc) - (1 + LINK_SIZE);
10710 int framesize = get_framesize(common, cc, NULL, TRUE, &needs_control_head);
10720 SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);
10724 alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;
10739 init_frame(common, cc, NULL, framesize + alternativesize - 1, alternativesize, TRUE);
10749 altbacktrack.cc = ccbegin;
10750 cc += GET(cc, 1);
10756 if (altbacktrack.cc != ccbegin)
10759 compile_matchingpath(common, altbacktrack.cc, cc, &altbacktrack);
10770 if (*cc != OP_ALT)
10773 altbacktrack.cc = cc + 1 + LINK_SIZE;
10774 cc += GET(cc, 1);
10863 rootbacktrack.cc = common->name_table + re->name_count * re->name_entry_size;
10865 common->start = rootbacktrack.cc;
