Lines Matching defs:cc
231 pcre_uchar *cc;
501 #define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
544 static pcre_uchar *bracketend(pcre_uchar *cc)
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;
553 static int no_alternatives(pcre_uchar *cc)
556 SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
559 cc += GET(cc, 1);
562 while (*cc == OP_ALT);
563 SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
584 static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
587 switch(*cc)
675 return cc + PRIV(OP_lengths)[*cc];
733 cc += PRIV(OP_lengths)[*cc];
735 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
737 return cc;
753 return cc + PRIV(OP_lengths)[*cc] - 1;
759 return cc + 1;
763 return cc + GET(cc, 1);
770 return cc + 1 + 2 + cc[1];
779 static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
785 while (cc < ccend)
787 switch(*cc)
792 cc += 1;
797 common->optimized_cbracket[GET2(cc, 1)] = 0;
798 cc += 1 + IMM2_SIZE;
803 common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
804 cc += 1 + LINK_SIZE + IMM2_SIZE;
811 if (cc[1 + LINK_SIZE] == OP_CALLOUT)
813 cc += 1 + LINK_SIZE;
817 common->optimized_cbracket[GET2(cc, 1)] = 0;
818 cc += 1 + IMM2_SIZE;
824 count = GET2(cc, 1 + IMM2_SIZE);
825 slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
831 cc += 1 + 2 * IMM2_SIZE;
841 cc += 1 + LINK_SIZE;
850 cc += 2 + 2 * LINK_SIZE;
868 cc += 1 + 2 + cc[1];
879 cc += 1;
885 cc += 1 + 2 + cc[1];
889 cc = next_opcode(common, cc);
890 if (cc == NULL)
898 static int get_class_iterator_size(pcre_uchar *cc)
900 switch(*cc)
914 if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))
1062 pcre_uchar *cc = common->start;
1069 while (cc < ccend)
1077 if (repeat_check && (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND))
1079 if (detect_repeat(common, cc))
1083 if (cc >= end)
1084 end = bracketend(cc);
1089 switch(*cc)
1092 if (common->private_data_ptrs[cc + 1 - common->start] != 0)
1094 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1096 cc += common->private_data_ptrs[cc + 1 - common->start];
1098 cc += 1 + LINK_SIZE;
1111 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1118 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1125 alternative = cc + GET(cc, 1);
1128 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1171 if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
1177 if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
1190 space = get_class_iterator_size(cc + size);
1195 size = GET(cc, 1);
1196 space = get_class_iterator_size(cc + size);
1201 cc = next_opcode(common, cc);
1202 SLJIT_ASSERT(cc != NULL);
1208 if (space > 0 && cc >= end)
1210 common->private_data_ptrs[cc - common->start] = private_data_ptr;
1218 cc += -size;
1220 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1224 cc += size;
1229 if (cc >= end)
1231 end = bracketend(cc);
1235 cc += bracketlen;
1242 static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL *needs_control_head)
1261 ccend = bracketend(cc) - (1 + LINK_SIZE);
1262 if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
1268 cc = next_opcode(common, cc);
1271 SLJIT_ASSERT(cc != NULL);
1272 while (cc < ccend)
1273 switch(*cc)
1283 cc += 1;
1298 cc += 1 + 2 + cc[1];
1318 cc += 1 + LINK_SIZE;
1332 cc += 1 + LINK_SIZE + IMM2_SIZE;
1339 cc ++;
1410 cc = next_opcode(common, cc);
1411 SLJIT_ASSERT(cc != NULL);
1424 static void init_frame(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, int stackpos, int stacktop, BOOL recursive)
1440 ccend = bracketend(cc) - (1 + LINK_SIZE);
1441 if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
1442 cc = next_opcode(common, cc);
1445 SLJIT_ASSERT(cc != NULL);
1446 while (cc < ccend)
1447 switch(*cc)
1460 cc += 1;
1476 cc += 1 + 2 + cc[1];
1507 cc += 1 + LINK_SIZE;
1523 offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
1533 cc += 1 + LINK_SIZE + IMM2_SIZE;
1537 cc = next_opcode(common, cc);
1538 SLJIT_ASSERT(cc != NULL);
1546 static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)
1552 while (cc < ccend)
1555 switch(*cc)
1558 if (PRIVATE_DATA(cc) != 0)
1561 SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
1562 cc += PRIVATE_DATA(cc + 1);
1564 cc += 1 + LINK_SIZE;
1578 SLJIT_ASSERT(PRIVATE_DATA(cc) != 0);
1579 cc += 1 + LINK_SIZE;
1584 if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
1586 cc += 1 + LINK_SIZE + IMM2_SIZE;
1592 cc += 1 + LINK_SIZE + IMM2_SIZE;
1597 alternative = cc + GET(cc, 1);
1600 cc += 1 + LINK_SIZE;
1604 if (PRIVATE_DATA(cc))
1606 cc += 2;
1608 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1613 if (PRIVATE_DATA(cc))
1615 cc += 2;
1617 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1622 if (PRIVATE_DATA(cc))
1624 cc += 2 + IMM2_SIZE;
1626 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1631 if (PRIVATE_DATA(cc))
1633 cc += 1;
1637 if (PRIVATE_DATA(cc))
1639 cc += 1;
1643 if (PRIVATE_DATA(cc))
1645 cc += 1 + IMM2_SIZE;
1652 size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);
1656 if (PRIVATE_DATA(cc))
1657 private_data_length += get_class_iterator_size(cc + size);
1658 cc += size;
1662 cc = next_opcode(common, cc);
1663 SLJIT_ASSERT(cc != NULL);
1667 SLJIT_ASSERT(cc == ccend);
1671 static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
1728 if (cc >= ccend)
1734 switch(*cc)
1737 if (PRIVATE_DATA(cc) != 0)
1740 srcw[0] = PRIVATE_DATA(cc);
1741 SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
1742 cc += PRIVATE_DATA(cc + 1);
1744 cc += 1 + LINK_SIZE;
1758 srcw[0] = PRIVATE_DATA(cc);
1760 cc += 1 + LINK_SIZE;
1765 if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
1768 srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
1770 cc += 1 + LINK_SIZE + IMM2_SIZE;
1776 srcw[0] = PRIVATE_DATA(cc);
1777 srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
1779 cc += 1 + LINK_SIZE + IMM2_SIZE;
1784 alternative = cc + GET(cc, 1);
1788 srcw[0] = PRIVATE_DATA(cc);
1791 cc += 1 + LINK_SIZE;
1795 if (PRIVATE_DATA(cc))
1798 srcw[0] = PRIVATE_DATA(cc);
1800 cc += 2;
1802 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1807 if (PRIVATE_DATA(cc))
1810 srcw[0] = PRIVATE_DATA(cc);
1811 srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
1813 cc += 2;
1815 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1820 if (PRIVATE_DATA(cc))
1823 srcw[0] = PRIVATE_DATA(cc);
1824 srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
1826 cc += 2 + IMM2_SIZE;
1828 if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
1833 if (PRIVATE_DATA(cc))
1836 srcw[0] = PRIVATE_DATA(cc);
1838 cc += 1;
1842 if (PRIVATE_DATA(cc))
1845 srcw[0] = PRIVATE_DATA(cc);
1848 cc += 1;
1852 if (PRIVATE_DATA(cc))
1855 srcw[0] = PRIVATE_DATA(cc);
1858 cc += 1 + IMM2_SIZE;
1865 size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);
1869 if (PRIVATE_DATA(cc))
1870 switch(get_class_iterator_size(cc + size))
1874 srcw[0] = PRIVATE_DATA(cc);
1879 srcw[0] = PRIVATE_DATA(cc);
1887 cc += size;
1891 cc = next_opcode(common, cc);
1892 SLJIT_ASSERT(cc != NULL);
1990 SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
1993 static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)
1995 pcre_uchar *end = bracketend(cc);
1996 BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
1999 if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
2002 if (*cc == OP_COND || *cc == OP_SCOND)
2005 cc = next_opcode(common, cc);
2007 current_offset = common->then_offsets + (cc - common->start);
2009 while (cc < end)
2011 if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
2012 cc = set_then_offsets(common, cc, current_offset);
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)
2019 cc = next_opcode(common, cc);
2368 static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar *cc)
2376 GETCHAR(c, cc);
2391 c = *cc;
2411 static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar *cc)
2422 GETCHAR(c, cc);
2436 c = *cc;
2440 c = *cc;
2460 n = GET_EXTRALEN(*cc);
3236 static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uint32 *chars, pcre_uint8 *bytes, int max_chars, pcre_uint32 *rec_count)
3262 switch (*cc)
3268 cc++;
3283 cc++;
3290 cc = bracketend(cc);
3300 cc++;
3306 repeat = GET2(cc, 1);
3308 cc += 1 + IMM2_SIZE;
3319 cc++;
3321 if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3323 max_chars = scan_prefix(common, cc + len, chars, bytes, max_chars, rec_count);
3330 cc += 1 + LINK_SIZE;
3334 cc += GET(cc, 1);
3343 alternative = cc + GET(cc, 1);
3352 if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
3353 cc += IMM2_SIZE;
3354 cc += 1 + LINK_SIZE;
3359 if (common->utf && !is_char7_bitset((const pcre_uint8 *)(cc + 1), FALSE)) return consumed;
3362 cc += 1 + 32 / sizeof(pcre_uchar);
3370 cc += 1 + 32 / sizeof(pcre_uchar);
3379 cc += GET(cc, 1);
3389 cc++;
3398 cc++;
3407 cc++;
3412 cc++;
3423 cc++;
3433 cc += 1 + 2;
3438 repeat = GET2(cc, 1);
3439 cc += 1 + IMM2_SIZE;
3448 repeat = GET2(cc, 1);
3449 cc += 1 + IMM2_SIZE + 1;
3488 if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3491 if (caseless && char_has_othercase(common, cc))
3496 GETCHAR(chr, cc);
3503 chr = *cc;
3511 cc_save = cc;
3517 chr = *cc;
3528 mask = *cc ^ *oc;
3555 cc++;
3564 cc = cc_save;
4605 static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,
4615 if (caseless && char_has_othercase(common, cc))
4617 othercasebit = char_get_othercase_bit(common, cc);
4621 othercasechar = cc + (othercasebit >> 8);
4628 othercasechar = cc + (othercasebit >> 9);
4662 if (common->utf && HAS_EXTRALEN(*cc))
4663 utflength += GET_EXTRALEN(*cc);
4673 if (othercasebit != 0 && othercasechar == cc)
4675 context->c.asuchars[context->ucharptr] = *cc | othercasebit;
4680 context->c.asuchars[context->ucharptr] = *cc;
4738 if (othercasebit != 0 && othercasechar == cc)
4741 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
4744 add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
4748 cc++;
4755 return cc;
4780 static void compile_xclass_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
4784 jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks;
4802 cc++;
4803 ccbegin = cc;
4805 if (cc[-1] & XCL_MAP)
4808 cc += 32 / sizeof(pcre_uchar);
4811 while (*cc != XCL_END)
4814 if (*cc == XCL_SINGLE)
4816 cc ++;
4817 GETCHARINCTEST(c, cc);
4824 else if (*cc == XCL_RANGE)
4826 cc ++;
4827 GETCHARINCTEST(c, cc);
4829 GETCHARINCTEST(c, cc);
4838 SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
4839 cc++;
4840 if (*cc == PT_CLIST)
4842 other_cases = PRIV(ucd_caseless_sets) + cc[1];
4856 switch(*cc)
4891 cc += 2;
4897 cc = ccbegin;
4899 read_char_range(common, min, max, (cc[-1] & XCL_NOT) != 0);
4901 if ((cc[-1] & XCL_HASPROP) == 0)
4903 if ((cc[-1] & XCL_MAP) != 0)
4906 if (!check_class_ranges(common, (const pcre_uint8 *)cc, (((const pcre_uint8 *)cc)[31] & 0x80) != 0, TRUE, &found))
4910 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
4919 cc += 32 / sizeof(pcre_uchar);
4924 add_jump(compiler, (cc[-1] & XCL_NOT) == 0 ? backtracks : &found, CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, max - min));
4927 else if ((cc[-1] & XCL_MAP) != 0)
4933 if (!check_class_ranges(common, (const pcre_uint8 *)cc, FALSE, TRUE, list))
4943 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
4955 cc += 32 / sizeof(pcre_uchar);
5005 while (*cc != XCL_END)
5011 if (*cc == XCL_SINGLE)
5013 cc ++;
5014 GETCHARINCTEST(c, cc);
5016 if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
5035 else if (*cc == XCL_RANGE)
5037 cc ++;
5038 GETCHARINCTEST(c, cc);
5040 GETCHARINCTEST(c, cc);
5042 if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
5064 if (*cc == XCL_NOTPROP)
5066 cc++;
5067 switch(*cc)
5072 if ((cc[-1] == XCL_NOTPROP && compares > 0) || (cc[-1] == XCL_PROP && compares == 0))
5075 else if (cc[-1] == XCL_NOTPROP)
5091 c = PRIV(ucp_typerange)[(int)cc[1] * 2];
5093 jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c);
5097 jump = CMP(SLJIT_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset);
5101 jump = CMP(SLJIT_EQUAL ^ invertcmp, scriptreg, 0, SLJIT_IMM, (int)cc[1]);
5130 OP_FLAGS((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, (*cc == PT_ALNUM) ? SLJIT_UNUSED : TMP2, 0, SLJIT_LESS_EQUAL);
5138 other_cases = PRIV(ucd_caseless_sets) + cc[1];
5268 cc += 2;
5285 static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)
5306 return cc;
5312 return cc;
5318 return cc;
5333 return cc;
5346 return cc;
5359 return cc;
5380 return cc;
5404 return cc;
5408 return cc;
5413 return cc;
5421 propdata[2] = cc[0];
5422 propdata[3] = cc[1];
5425 return cc + 2;
5448 return cc;
5456 return cc;
5464 return cc;
5502 return cc;
5571 return cc;
5576 return cc;
5584 return cc;
5612 return cc;
5620 compile_char1_matchingpath(common, OP_EODN, cc, backtracks);
5626 return cc;
5663 return cc;
5669 if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);
5671 if (common->mode == JIT_COMPILE && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))
5681 return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);
5688 GETCHAR(c, cc);
5692 c = *cc;
5694 if (type == OP_CHAR || !char_has_othercase(common, cc))
5698 return cc + length;
5707 return cc + length;
5712 return cc + length;
5722 c = *cc;
5726 if (type == OP_NOT || !char_has_othercase(common, cc))
5740 return cc + 1;
5745 GETCHARLEN(c, cc, length);
5750 c = *cc;
5752 if (type == OP_NOT || !char_has_othercase(common, cc))
5773 return cc + length;
5780 bit = (common->utf && is_char7_bitset((const pcre_uint8 *)cc, type == OP_NCLASS)) ? 127 : 255;
5786 if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, FALSE, backtracks))
5787 return cc + 32 / sizeof(pcre_uchar);
5811 OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
5821 return cc + 32 / sizeof(pcre_uchar);
5825 compile_xclass_matchingpath(common, cc + LINK_SIZE, backtracks);
5826 return cc + GET(cc, 0) - 1;
5830 length = GET(cc, 0);
5832 return cc + LINK_SIZE;
5853 return cc + LINK_SIZE;
5856 return cc;
5859 static SLJIT_INLINE pcre_uchar *compile_charn_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **backtracks)
5864 pcre_uchar *ccbegin = cc;
5871 if (cc >= ccend)
5874 if (*cc == OP_CHAR)
5878 if (common->utf && HAS_EXTRALEN(cc[1]))
5879 size += GET_EXTRALEN(cc[1]);
5882 else if (*cc == OP_CHARI)
5888 if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
5890 else if (HAS_EXTRALEN(cc[1]))
5891 size += GET_EXTRALEN(cc[1]);
5895 if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
5901 cc += 1 + size;
5906 cc = ccbegin;
5917 do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, backtracks); while (context.length > 0);
5918 return cc;
5922 return compile_char1_matchingpath(common, *cc, cc + 1, backtracks);
5937 backtrack->cc = (ccstart); \
5950 backtrack->cc = (ccstart); \
5957 static void compile_dnref_search(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
5961 int count = GET2(cc, 1 + IMM2_SIZE);
5962 pcre_uchar *slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
5966 SLJIT_ASSERT(*cc == OP_DNREF || *cc == OP_DNREFI);
5987 static void compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
5990 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
5998 offset = GET2(cc, 1) << 1;
6008 if (common->utf && *cc == OP_REFI)
6053 add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
6065 add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
6083 static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
6086 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
6093 pcre_uchar *ccbegin = cc;
6097 PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
6100 offset = GET2(cc, 1) << 1;
6102 cc += IMM2_SIZE;
6103 type = cc[1 + IMM2_SIZE];
6113 cc += 1 + IMM2_SIZE + 1;
6119 cc
6125 cc += 1 + IMM2_SIZE + 1;
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;
6220 return cc;
6287 return cc;
6290 static SLJIT_INLINE pcre_uchar *compile_recurse_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
6296 sljit_sw start = GET(cc, 1);
6300 PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
6308 return cc + 1 + LINK_SIZE;
6356 return cc + 1 + LINK_SIZE;
6410 static SLJIT_INLINE pcre_uchar *compile_callout_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
6415 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
6422 OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);
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));
6452 return cc + 2 + 2 * LINK_SIZE;
6458 static pcre_uchar *compile_assert_matchingpath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)
6487 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
6490 bra = *cc;
6491 cc++;
6493 private_data_ptr = PRIVATE_DATA(cc);
6495 framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
6498 opcode = *cc;
6501 ccbegin = cc;
6502 cc += GET(cc, 1);
6571 altbacktrack.cc = ccbegin;
6572 compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
6664 if (*cc != OP_ALT)
6667 ccbegin = cc;
6668 cc += GET(cc, 1);
6853 return cc + 1 + LINK_SIZE;
6981 static pcre_uchar *compile_bracket_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
7004 PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
7006 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
7008 bra = *cc;
7009 cc++;
7010 opcode = *cc;
7013 opcode = *cc;
7014 ccbegin = cc;
7015 matchingpath = bracketend(cc) - 1 - LINK_SIZE;
7030 if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
7040 cc += GET(cc, 1);
7042 has_alternatives = *cc == OP_ALT;
7046 if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
7350 if (*cc == OP_ALT)
7352 matchingpath = cc + 1 + LINK_SIZE;
7353 cc += GET(cc, 1);
7356 matchingpath = cc;
7367 assert->common.cc = matchingpath;
7373 compile_matchingpath(common, matchingpath, cc, backtrack);
7512 while (*cc == OP_ALT)
7513 cc += GET(cc, 1);
7514 cc += 1 + LINK_SIZE;
7519 return cc + repeat_length;
7522 static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
7539 PUSH_BACKTRACK(sizeof(bracketpos_backtrack), cc, NULL);
7540 if (*cc == OP_BRAPOSZERO)
7543 cc++;
7546 opcode = *cc;
7547 private_data_ptr = PRIVATE_DATA(cc);
7554 ccbegin = cc + 1 + LINK_SIZE;
7559 offset = GET2(cc, 1 + LINK_SIZE);
7565 ccbegin = cc + 1 + LINK_SIZE + IMM2_SIZE;
7573 framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
7666 init_frame(common, cc, NULL, stacksize - 1, stacksize - framesize, FALSE);
7674 while (*cc != OP_KETRPOS)
7678 cc += GET(cc, 1);
7680 compile_matchingpath(common, ccbegin, cc, backtrack);
7772 if (*cc == OP_KETRPOS)
7783 if (*cc == OP_KETRPOS)
7785 ccbegin = cc + 1 + LINK_SIZE;
7802 return cc + 1 + LINK_SIZE;
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)
7809 *opcode = *cc;
7812 cc++;
7817 cc++;
7823 cc++;
7829 cc++;
7835 cc++;
7843 cc++;
7844 class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
7845 *opcode = cc[class_len - 1];
7850 *end = cc + class_len;
7856 *end = cc + class_len;
7861 *max = GET2(cc, (class_len + IMM2_SIZE));
7862 *min = GET2(cc, class_len);
7873 *end = cc + class_len + 2 * IMM2_SIZE;
7875 return cc;
7880 *max = GET2(cc, 0);
7881 cc += IMM2_SIZE;
7886 *type = *cc;
7888 *end = next_opcode(common, cc);
7889 cc++;
7890 return cc;
7895 *end = cc + 1;
7897 if (common->utf && HAS_EXTRALEN(*cc)) *end += GET_EXTRALEN(*cc);
7900 return cc;
7903 static pcre_uchar *compile_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
7914 int private_data_ptr = PRIVATE_DATA(cc);
7920 PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);
7922 cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, &end);
7988 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
8010 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
8019 compile_char1_matchingpath(common, type, cc, &nomatch);
8046 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
8070 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
8077 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
8086 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
8091 compile_char1_matchingpath(common, type, cc, &nomatch);
8106 compile_char1_matchingpath(common, type, cc, &nomatch);
8116 compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
8127 compile_char1_matchingpath(common, type, cc, &nomatch);
8149 static SLJIT_INLINE pcre_uchar *compile_fail_accept_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
8154 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
8156 if (*cc == OP_FAIL)
8159 return cc + 1;
8162 if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL || !common->might_be_empty)
8169 return cc + 1;
8190 return cc + 1;
8193 static SLJIT_INLINE pcre_uchar *compile_close_matchingpath(compiler_common *common, pcre_uchar *cc)
8196 int offset = GET2(cc, 1);
8201 return cc + 1 + IMM2_SIZE;
8209 return cc + 1 + IMM2_SIZE;
8212 static SLJIT_INLINE pcre_uchar *compile_control_verb_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
8216 pcre_uchar opcode = *cc;
8217 pcre_uchar *ccend = cc + 1;
8220 ccend += 2 + cc[1];
8222 PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
8234 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
8244 static SLJIT_INLINE void compile_then_trap_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
8251 PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
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);
8272 init_frame(common, cc, ccend, size - 1, 0, FALSE);
8275 static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
8284 if (common->has_then && common->then_offsets[cc - common->start] != 0)
8290 compile_then_trap_matchingpath(common, cc, ccend, parent);
8293 while (cc < ccend)
8295 switch(*cc)
8327 cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
8331 PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
8336 cc++;
8342 cc = compile_charn_matchingpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
8344 cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
8412 cc = compile_iterator_matchingpath(common, cc, parent);
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);
8420 cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
8425 if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRPOSRANGE)
8426 cc = compile_iterator_matchingpath(common, cc, parent);
8428 cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
8434 if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRPOSRANGE)
8435 cc = compile_ref_iterator_matchingpath(common, cc, parent);
8438 compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
8439 cc += 1 + IMM2_SIZE;
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);
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;
8456 cc = compile_recurse_matchingpath(common, cc, parent);
8460 cc = compile_callout_matchingpath(common, cc, parent);
8467 PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
8468 cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
8472 PUSH_BACKTRACK_NOVALUE(sizeof(braminzero_backtrack), cc);
8473 cc = bracketend(cc + 1);
8474 if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)
8497 cc = compile_bracket_matchingpath(common, cc, parent);
8501 if (cc[1] > OP_ASSERTBACK_NOT)
8502 cc = compile_bracket_matchingpath(common, cc, parent);
8505 PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
8506 cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
8515 cc = compile_bracketpos_matchingpath(common, cc, parent);
8519 PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
8525 OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
8533 OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), SLJIT_IMM, (sljit_sw)(cc + 2));
8537 cc += 1 + 2 + cc[1];
8547 cc = compile_control_verb_matchingpath(common, cc, parent);
8553 cc = compile_fail_accept_matchingpath(common, cc, parent);
8557 cc = compile_close_matchingpath(common, cc);
8561 cc = bracketend(cc + 1);
8568 if (cc == NULL)
8575 PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
8576 BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
8580 SLJIT_ASSERT(cc == ccend);
8601 pcre_uchar *cc = current->cc;
8608 int private_data_ptr = PRIVATE_DATA(cc);
8613 cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, NULL);
8661 compile_char1_matchingpath(common, type, cc, &jumplist);
8679 compile_char1_matchingpath(common, type, cc, &jumplist);
8717 compile_char1_matchingpath(common, type, cc, &jumplist);
8745 pcre_uchar *cc = current->cc;
8746 BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
8749 type = cc[ref ? 1 + IMM2_SIZE : 1 + 2 * IMM2_SIZE];
8796 pcre_uchar *cc = current->cc;
8800 SLJIT_ASSERT(*cc != OP_BRAMINZERO);
8801 if (*cc == OP_BRAZERO)
8803 bra = *cc;
8804 cc++;
8828 if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)
8839 if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)
8867 pcre_uchar *cc = current->cc;
8884 if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
8886 bra = *cc;
8887 cc++;
8890 opcode = *cc;
8891 ccbegin = bracketend(cc) - 1 - LINK_SIZE;
8904 ccbegin = cc;
8905 cc += GET(cc, 1);
8906 has_alternatives = *cc == OP_ALT;
8911 if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
9096 if (*cc == OP_ALT)
9098 ccprev = cc + 1 + LINK_SIZE;
9099 cc += GET(cc, 1);
9112 compile_matchingpath(common, ccprev, cc, current);
9203 while (*cc == OP_ALT);
9248 cc = ccbegin + GET(ccbegin, 1);
9254 stacksize += CURRENT_AS(bracket_backtrack)->u.framesize + ((ket != OP_KET || *cc == OP_ALT) ? 2 : 1);
9256 else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
9328 if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)
9330 offset = (GET2(current->cc, 1 + LINK_SIZE)) << 1;
9366 if (current->cc[1] > OP_ASSERTBACK_NOT)
9369 compile_bracket_matchingpath(common, current->cc, current);
9375 backtrack.common.cc = current->cc;
9378 compile_assert_matchingpath(common, current->cc, &backtrack, FALSE);
9386 pcre_uchar opcode = *current->cc;
9430 OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, (sljit_sw)(current->cc + 2));
9485 switch(*current->cc)
9596 if (current->cc[1] > OP_ASSERTBACK_NOT)
9666 pcre_uchar *cc = common->start + common->currententry->start;
9667 pcre_uchar *ccbegin = cccc == OP_BRA ? 0 : IMM2_SIZE);
9668 pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);
9670 int framesize = get_framesize(common, cc, NULL, TRUE, &needs_control_head);
9680 SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);
9684 alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;
9699 init_frame(common, cc, NULL, framesize + alternativesize - 1, alternativesize, TRUE);
9709 altbacktrack.cc = ccbegin;
9710 cc += GET(cc, 1);
9716 if (altbacktrack.cc != ccbegin)
9719 compile_matchingpath(common, altbacktrack.cc, cc, &altbacktrack);
9730 if (*cc != OP_ALT)
9733 altbacktrack.cc = cc + 1 + LINK_SIZE;
9734 cc += GET(cc, 1);
9826 rootbacktrack.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;
9828 common->start = rootbacktrack.cc;
