49#ifndef PLATFORM_UNALIGNED_WORD_ACCESS
74 c = *a; *a = *b; *b = c;
109 if (m == 0)
return 0;
122 if (bs[
i] != 0)
return 0;
159#ifdef USE_SUBEXP_CALL
204add_opcode(
regex_t* reg,
int opcode)
210#ifdef USE_COMBINATION_EXPLOSION_CHECK
212add_state_check_num(
regex_t* reg,
int num)
222add_rel_addr(
regex_t* reg,
int addr)
231add_abs_addr(
regex_t* reg,
int addr)
249add_mem_num(
regex_t* reg,
int num)
259add_pointer(
regex_t* reg,
void* addr)
276add_opcode_rel_addr(
regex_t* reg,
int opcode,
int addr)
280 r = add_opcode(reg, opcode);
282 r = add_rel_addr(reg, addr);
305 r = add_opcode(reg, opcode);
307 r = add_option(reg, option);
311static int compile_length_tree(
Node* node,
regex_t* reg);
315#define IS_NEED_STR_LEN_OP_EXACT(op) \
316 ((op) == OP_EXACTN || (op) == OP_EXACTMB2N ||\
317 (op) == OP_EXACTMB3N || (op) == OP_EXACTMBN || (op) == OP_EXACTN_IC)
320select_str_opcode(
int mb_len,
OnigDistance byte_len,
int ignore_case)
323 OnigDistance str_len = (byte_len + mb_len - 1) / mb_len;
366compile_tree_empty_check(
Node* node,
regex_t* reg,
int empty_info)
371 if (empty_info != 0) {
379 r = compile_tree(node, reg);
382 if (empty_info != 0) {
391 r = add_mem_num(reg, saved_num_null_check);
396#ifdef USE_SUBEXP_CALL
407 r = add_abs_addr(reg, 0 );
417 for (
i = 0;
i <
n;
i++) {
418 r = compile_tree(node, reg);
429 int op = select_str_opcode(mb_len, byte_len, ignore_case);
445 int op = select_str_opcode(mb_len, byte_len, ignore_case);
449 add_length(reg, mb_len);
453 add_length(reg, byte_len);
455 add_length(reg, byte_len / mb_len);
458 add_bytes(reg, s, byte_len);
464compile_length_string_node(
Node* node,
regex_t* reg)
466 int rlen, r,
len, prev_len, blen, ambig;
472 if (sn->
end <= sn->
s)
483 for (; p < sn->
end; ) {
485 if (
len == prev_len || ambig) {
489 r = add_compile_string_length(prev, prev_len, blen, reg, ambig);
497 r = add_compile_string_length(prev, prev_len, blen, reg, ambig);
505 if (sn->
end <= sn->
s)
508 return add_compile_string_length(sn->
s, 1 , sn->
end - sn->
s, reg, 0);
514 int r,
len, prev_len, blen, ambig;
516 UChar *p, *prev, *end;
520 if (sn->
end <= sn->
s)
527 prev_len =
enclen(enc, p, end);
533 if (
len == prev_len || ambig) {
537 r = add_compile_string(prev, prev_len, blen, reg, ambig);
547 return add_compile_string(prev, prev_len, blen, reg, ambig);
553 if (sn->
end <= sn->
s)
556 return add_compile_string(sn->
s, 1 , sn->
end - sn->
s, reg, 0);
562#ifdef PLATFORM_UNALIGNED_WORD_ACCESS
563 add_length(reg, mbuf->
used);
564 return add_bytes(reg, mbuf->
p, mbuf->
used);
571 if (pad_size != 0) add_bytes(reg, PadBuf, pad_size);
573 r = add_bytes(reg, mbuf->
p, mbuf->
used);
577 if (pad_size != 0) add_bytes(reg, PadBuf, pad_size);
597#ifdef PLATFORM_UNALIGNED_WORD_ACCESS
618 r = add_bitset(reg,
cc->bs);
627 r = add_multi_byte_cclass(
cc->mbuf, reg);
635 r = add_bitset(reg,
cc->bs);
637 r = add_multi_byte_cclass(
cc->mbuf, reg);
645entry_repeat_range(
regex_t* reg,
int id,
int lower,
int upper)
647#define REPEAT_RANGE_ALLOC 4
676compile_range_repeat_node(
QtfrNode* qn,
int target_len,
int empty_info,
684 r = add_mem_num(reg, num_repeat);
690 r = entry_repeat_range(reg, num_repeat, qn->
lower, qn->
upper);
693 r = compile_tree_empty_check(qn->
target, reg, empty_info);
707 r = add_mem_num(reg, num_repeat);
712is_anychar_star_quantifier(
QtfrNode* qn)
721#define QUANTIFIER_EXPAND_LIMIT_SIZE 50
722#define CKN_ON (ckn > 0)
724#ifdef USE_COMBINATION_EXPLOSION_CHECK
729 int len, mod_tlen, cklen;
733 int tlen = compile_length_tree(qn->
target, reg);
735 if (tlen < 0)
return tlen;
743 if (qn->
greedy && infinite) {
756 if (infinite && qn->
lower <= 1) {
774 else if (qn->
upper == 0) {
781 if (qn->
lower == 0) {
783 len = SIZE_OP_STATE_CHECK_PUSH + tlen;
800 len += SIZE_OP_STATE_CHECK;
813 int tlen = compile_length_tree(qn->
target, reg);
815 if (tlen < 0)
return tlen;
819 if (is_anychar_star_quantifier(qn)) {
820 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
829 r = add_state_check_num(reg, ckn);
837 r = add_opcode(reg, (
CKN_ON ?
842 r = add_opcode(reg, (
CKN_ON ?
848 r = add_state_check_num(reg, ckn);
859 if (infinite && qn->
lower <= 1) {
861 if (qn->
lower == 1) {
862 r = add_opcode_rel_addr(reg,
OP_JUMP,
870 r = add_state_check_num(reg, ckn);
878 r = compile_tree_empty_check(qn->
target, reg, empty_info);
880 r = add_opcode_rel_addr(reg,
OP_JUMP,
885 if (qn->
lower == 0) {
886 r = add_opcode_rel_addr(reg,
OP_JUMP, mod_tlen);
889 r = compile_tree_empty_check(qn->
target, reg, empty_info);
894 r = add_state_check_num(reg, ckn);
896 r = add_rel_addr(reg,
897 -(mod_tlen + (
int )SIZE_OP_STATE_CHECK_PUSH_OR_JUMP));
903 else if (qn->
upper == 0) {
905 r = add_opcode_rel_addr(reg,
OP_JUMP, tlen);
907 r = compile_tree(qn->
target, reg);
913 if (qn->
lower == 0) {
917 r = add_state_check_num(reg, ckn);
919 r = add_rel_addr(reg, tlen);
922 r = add_opcode_rel_addr(reg,
OP_PUSH, tlen);
927 r = compile_tree(qn->
target, reg);
933 r = add_state_check_num(reg, ckn);
942 r = add_opcode_rel_addr(reg,
OP_JUMP, tlen);
944 r = compile_tree(qn->
target, reg);
947 r = compile_range_repeat_node(qn, mod_tlen, empty_info, reg);
952 r = add_state_check_num(reg, ckn);
966 int tlen = compile_length_tree(qn->
target, reg);
968 if (tlen < 0)
return tlen;
972 if (qn->
greedy && infinite) {
995#ifdef USE_OP_PUSH_OR_JUMP_EXACT
1011 else if (!infinite && qn->
greedy &&
1034 int tlen = compile_length_tree(qn->
target, reg);
1036 if (tlen < 0)
return tlen;
1038 if (is_anychar_star_quantifier(qn)) {
1039 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
1057 if (empty_info != 0)
1066#ifdef USE_OP_PUSH_OR_JUMP_EXACT
1082 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
1087#ifdef USE_OP_PUSH_OR_JUMP_EXACT
1093 r = compile_tree_empty_check(qn->
target, reg, empty_info);
1095 r = add_opcode_rel_addr(reg,
OP_JUMP,
1105 r = compile_tree_empty_check(qn->
target, reg, empty_info);
1107 r = add_opcode_rel_addr(reg,
OP_JUMP,
1113 r = compile_tree_empty_check(qn->
target, reg, empty_info);
1115 r = add_opcode_rel_addr(reg,
OP_JUMP,
1120 r = add_opcode_rel_addr(reg,
OP_JUMP, mod_tlen);
1122 r = compile_tree_empty_check(qn->
target, reg, empty_info);
1128 r = add_opcode_rel_addr(reg,
OP_JUMP, tlen);
1130 r = compile_tree(qn->
target, reg);
1132 else if (!infinite && qn->
greedy &&
1137 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
1140 for (
i = 0;
i <
n;
i++) {
1141 r = add_opcode_rel_addr(reg,
OP_PUSH,
1144 r = compile_tree(qn->
target, reg);
1151 r = add_opcode_rel_addr(reg,
OP_JUMP, tlen);
1153 r = compile_tree(qn->
target, reg);
1156 r = compile_range_repeat_node(qn, mod_tlen, empty_info, reg);
1169 tlen = compile_length_tree(node->
target, reg);
1172 if (tlen < 0)
return tlen;
1198 r = compile_tree(node->
target, reg);
1215 return compile_length_option_node(node, reg);
1218 tlen = compile_length_tree(node->
target, reg);
1219 if (tlen < 0)
return tlen;
1224 switch (node->
type) {
1226#ifdef USE_SUBEXP_CALL
1258 tlen = compile_length_tree(qn->
target, reg);
1259 if (tlen < 0)
return tlen;
1274 tlen = compile_length_tree(
NCAR(x), reg);
1275 if (tlen < 0)
return tlen;
1279 tlen = compile_length_tree(
NCAR(x), reg);
1280 if (tlen < 0)
return tlen;
1301static int get_char_length_tree(
Node* node,
regex_t* reg,
int*
len);
1309 return compile_option_node(node, reg);
1311 switch (node->
type) {
1313#ifdef USE_SUBEXP_CALL
1319 r = add_abs_addr(reg, (
int )node->
call_addr);
1321 len = compile_length_tree(node->
target, reg);
1339 r = add_mem_num(reg, node->
regnum);
1341 r = compile_tree(node->
target, reg);
1343#ifdef USE_SUBEXP_CALL
1353 r = add_mem_num(reg, node->
regnum);
1363 r = add_mem_num(reg, node->
regnum);
1373 r = add_mem_num(reg, node->
regnum);
1380 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
1383 len = compile_length_tree(qn->
target, reg);
1388 r = compile_tree(qn->
target, reg);
1390 r = add_opcode(reg,
OP_POP);
1392 r = add_opcode_rel_addr(reg,
OP_JUMP,
1398 r = compile_tree(node->
target, reg);
1407 r = add_mem_num(reg, node->
regnum);
1414 len = compile_length_tree(
NCAR(x), reg);
1418 len2 = compile_length_tree(
NCAR(x), reg);
1419 if (len2 < 0)
return len2;
1425 r = compile_tree(
NCAR(x), reg);
1427 r = add_opcode_rel_addr(reg,
OP_JUMP, len2);
1430 r = compile_tree(
NCAR(x), reg);
1438 len = compile_length_tree(node->
target, reg);
1445 r = compile_tree(node->
target, reg);
1465 tlen = compile_length_tree(node->
target, reg);
1466 if (tlen < 0)
return tlen;
1469 switch (node->
type) {
1496 switch (node->
type) {
1512#ifdef USE_WORD_BEGIN_END
1527 r = compile_tree(node->
target, reg);
1533 len = compile_length_tree(node->
target, reg);
1537 r = compile_tree(node->
target, reg);
1548 r = get_char_length_tree(node->
target, reg, &
n);
1553 r = add_length(reg,
n);
1555 r = compile_tree(node->
target, reg);
1562 len = compile_length_tree(node->
target, reg);
1567 r = get_char_length_tree(node->
target, reg, &
n);
1572 r = add_length(reg,
n);
1574 r = compile_tree(node->
target, reg);
1598 r = compile_length_tree(
NCAR(node), reg);
1599 if (r < 0)
return r;
1610 r = compile_length_tree(
NCAR(node), reg);
1611 if (r < 0)
return r;
1622 r = compile_length_string_raw_node(
NSTR(node), reg);
1624 r = compile_length_string_node(node, reg);
1628 r = compile_length_cclass_node(
NCCLASS(node), reg);
1640#ifdef USE_BACKREF_WITH_LEVEL
1657#ifdef USE_SUBEXP_CALL
1664 r = compile_length_quantifier_node(
NQTFR(node), reg);
1668 r = compile_length_enclose_node(
NENCLOSE(node), reg);
1672 r = compile_length_anchor_node(
NANCHOR(node), reg);
1692 r = compile_tree(
NCAR(node), reg);
1701 len += compile_length_tree(
NCAR(x), reg);
1709 len = compile_length_tree(
NCAR(node), reg);
1714 r = compile_tree(
NCAR(node), reg);
1727 r = compile_string_raw_node(
NSTR(node), reg);
1729 r = compile_string_node(node, reg);
1733 r = compile_cclass_node(
NCCLASS(node), reg);
1740 switch (
NCTYPE(node)->ctype) {
1742 if (
NCTYPE(node)->ascii_range != 0) {
1755 r = add_opcode(reg, op);
1770#ifdef USE_BACKREF_WITH_LEVEL
1779 goto add_bacref_mems;
1788 r = add_mem_num(reg,
n);
1797 r = add_mem_num(reg,
n);
1814#ifdef USE_BACKREF_WITH_LEVEL
1821 r = add_mem_num(reg, p[
i]);
1828#ifdef USE_SUBEXP_CALL
1830 r = compile_call(
NCALL(node), reg);
1835 r = compile_quantifier_node(
NQTFR(node), reg);
1839 r = compile_enclose_node(
NENCLOSE(node), reg);
1843 r = compile_anchor_node(
NANCHOR(node), reg);
1856#ifdef USE_NAMED_GROUP
1862 Node* node = *plink;
1864 switch (
NTYPE(node)) {
1868 r = noname_disable_map(&(
NCAR(node)), map, counter);
1874 Node** ptarget = &(
NQTFR(node)->target);
1876 r = noname_disable_map(ptarget, map, counter);
1892 else if (en->
regnum != 0) {
1896 r = noname_disable_map(plink, map, counter);
1900 r = noname_disable_map(&(en->
target), map, counter);
1906 r = noname_disable_map(&(
NANCHOR(node)->target), map, counter);
1919 int i, pos,
n, old_num;
1932 for (
i = 0, pos = 0;
i < old_num;
i++) {
1950 switch (
NTYPE(node)) {
1954 r = renumber_by_map(
NCAR(node), map, num_mem);
1958 r = renumber_by_map(
NQTFR(node)->target, map, num_mem);
1967 r = renumber_by_map(en->
target, map, num_mem);
1972 r = renumber_node_backref(node, map, num_mem);
1977 r = renumber_by_map(
NANCHOR(node)->target, map, num_mem);
1988numbered_ref_check(
Node* node)
1992 switch (
NTYPE(node)) {
1996 r = numbered_ref_check(
NCAR(node));
2000 r = numbered_ref_check(
NQTFR(node)->target);
2003 r = numbered_ref_check(
NENCLOSE(node)->target);
2013 r = numbered_ref_check(
NANCHOR(node)->target);
2026 int r,
i, pos, counter;
2032 for (
i = 1;
i <=
env->num_mem;
i++) {
2036 r = noname_disable_map(root, map, &counter);
2037 if (r != 0)
return r;
2039 r = renumber_by_map(*root, map,
env->num_mem);
2040 if (r != 0)
return r;
2042 for (
i = 1, pos = 1;
i <=
env->num_mem;
i++) {
2043 if (map[
i].new_val > 0) {
2049 loc =
env->capture_history;
2057 env->num_mem =
env->num_named;
2064#ifdef USE_SUBEXP_CALL
2072 for (
i = 0;
i < uslist->
num;
i++) {
2084#ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
2086quantifiers_memory_node_info(
Node* node)
2090 switch (
NTYPE(node)) {
2096 v = quantifiers_memory_node_info(
NCAR(node));
2102# ifdef USE_SUBEXP_CALL
2108 r = quantifiers_memory_node_info(
NCALL(node)->target);
2115 if (qn->
upper != 0) {
2116 r = quantifiers_memory_node_info(qn->
target);
2133 r = quantifiers_memory_node_info(en->
target);
2162 switch (
NTYPE(node)) {
2173 r = get_min_match_length(nodes[backs[0]], min,
env);
2177 r = get_min_match_length(nodes[backs[
i]], &tmin,
env);
2179 if (*min > tmin) *min = tmin;
2184#ifdef USE_SUBEXP_CALL
2192 r = get_min_match_length(
NCALL(node)->target, min,
env);
2198 r = get_min_match_length(
NCAR(node), &tmin,
env);
2199 if (r == 0) *min += tmin;
2209 r = get_min_match_length(x, &tmin,
env);
2211 if (y == node) *min = tmin;
2212 else if (*min > tmin) *min = tmin;
2220 *min = sn->
end - sn->
s;
2237 if (qn->
lower > 0) {
2238 r = get_min_match_length(qn->
target, min,
env);
2240 *min = distance_multiply(*min, qn->
lower);
2257 r = get_min_match_length(en->
target, min,
env);
2270 r = get_min_match_length(en->
target, min,
env);
2294 switch (
NTYPE(node)) {
2297 r = get_max_match_length(
NCAR(node), &tmax,
env);
2299 *max = distance_add(*max, tmax);
2305 r = get_max_match_length(
NCAR(node), &tmax,
env);
2306 if (r == 0 && *max < tmax) *max = tmax;
2313 *max = sn->
end - sn->
s;
2339 r = get_max_match_length(nodes[backs[
i]], &tmax,
env);
2341 if (*max < tmax) *max = tmax;
2346#ifdef USE_SUBEXP_CALL
2349 r = get_max_match_length(
NCALL(node)->target, max,
env);
2359 if (qn->
upper != 0) {
2360 r = get_max_match_length(qn->
target, max,
env);
2361 if (r == 0 && *max != 0) {
2363 *max = distance_multiply(*max, qn->
upper);
2383 r = get_max_match_length(en->
target, max,
env);
2396 r = get_max_match_length(en->
target, max,
env);
2413#define GET_CHAR_LEN_VARLEN -1
2414#define GET_CHAR_LEN_TOP_ALT_VARLEN -2
2418get_char_length_tree1(
Node* node,
regex_t* reg,
int*
len,
int level)
2425 switch (
NTYPE(node)) {
2428 r = get_char_length_tree1(
NCAR(node), reg, &tlen, level);
2439 r = get_char_length_tree1(
NCAR(node), reg, &tlen, level);
2441 r = get_char_length_tree1(
NCAR(node), reg, &tlen2, level);
2464 while (s < sn->end) {
2475 r = get_char_length_tree1(qn->
target, reg, &tlen, level);
2484#ifdef USE_SUBEXP_CALL
2487 r = get_char_length_tree1(
NCALL(node)->target, reg,
len, level);
2507#ifdef USE_SUBEXP_CALL
2511 r = get_char_length_tree1(en->
target, reg,
len, level);
2522 r = get_char_length_tree1(en->
target, reg,
len, level);
2545 return get_char_length_tree1(node, reg,
len, 0);
2577 tmp = x; x = y; y = tmp;
2597 switch (
NCTYPE(y)->ctype) {
2599 if (
NCTYPE(y)->not == 0) {
2603 if (
NCTYPE(y)->ascii_range) {
2619 if (
NCTYPE(y)->ascii_range)
2683 switch (
NCTYPE(y)->ctype) {
2685 if (
NCTYPE(y)->ascii_range) {
2689 return !(
NCTYPE(y)->not);
2695 return !(
NCTYPE(y)->not);
2725 if (*p != *q)
return 1;
2745get_head_value_node(
Node* node,
int exact,
regex_t* reg)
2749 switch (
NTYPE(node)) {
2753#ifdef USE_SUBEXP_CALL
2766 n = get_head_value_node(
NCAR(node), exact, reg);
2773 if (sn->
end <= sn->
s)
2788 if (qn->
lower > 0) {
2789#ifdef USE_OP_PUSH_OR_JUMP_EXACT
2794 n = get_head_value_node(qn->
target, exact, reg);
2808 n = get_head_value_node(
NENCLOSE(node)->target, exact, reg);
2816 n = get_head_value_node(en->
target, exact, reg);
2827 n = get_head_value_node(
NANCHOR(node)->target, exact, reg);
2838check_type_tree(
Node* node,
int type_mask,
int enclose_mask,
int anchor_mask)
2850 r = check_type_tree(
NCAR(node), type_mask, enclose_mask,
2856 r = check_type_tree(
NQTFR(node)->target, type_mask, enclose_mask,
2863 if ((en->
type & enclose_mask) == 0)
2866 r = check_type_tree(en->
target, type_mask, enclose_mask, anchor_mask);
2872 if ((
type & anchor_mask) == 0)
2876 r = check_type_tree(
NANCHOR(node)->target,
2877 type_mask, enclose_mask, anchor_mask);
2886#ifdef USE_SUBEXP_CALL
2888# define RECURSION_EXIST 1
2889# define RECURSION_INFINITE 2
2907 ret = subexp_inf_recursive_check(
NCAR(x),
env, head);
2911 ret = get_min_match_length(
NCAR(x), &min,
env);
2912 if (ret != 0)
return ret;
2913 if (min != 0) head = 0;
2924 ret = subexp_inf_recursive_check(
NCAR(node),
env, head);
2932 r = subexp_inf_recursive_check(
NQTFR(node)->target,
env, head);
2934 if (
NQTFR(node)->lower == 0) r = 0;
2946 r = subexp_inf_recursive_check(an->
target,
env, head);
2953 r = subexp_inf_recursive_check(
NCALL(node)->target,
env, head);
2963 r = subexp_inf_recursive_check(
NENCLOSE(node)->target,
env, head);
2986 r = subexp_inf_recursive_check_trav(
NCAR(node),
env);
2991 r = subexp_inf_recursive_check_trav(
NQTFR(node)->target,
env);
3002 r = subexp_inf_recursive_check_trav(an->
target,
env);
3014 r = subexp_inf_recursive_check(en->
target,
env, 1);
3018 r = subexp_inf_recursive_check_trav(en->
target,
env);
3031subexp_recursive_check(
Node* node)
3035 switch (
NTYPE(node)) {
3039 r |= subexp_recursive_check(
NCAR(node));
3044 r = subexp_recursive_check(
NQTFR(node)->target);
3055 r = subexp_recursive_check(an->
target);
3062 r = subexp_recursive_check(
NCALL(node)->target);
3073 r = subexp_recursive_check(
NENCLOSE(node)->target);
3089# define FOUND_CALLED_NODE 1
3101 ret = subexp_recursive_check_trav(
NCAR(node),
env);
3103 else if (ret < 0)
return ret;
3109 r = subexp_recursive_check_trav(
NQTFR(node)->target,
env);
3110 if (
NQTFR(node)->upper == 0) {
3112 NQTFR(node)->is_referred = 1;
3124 r = subexp_recursive_check_trav(an->
target,
env);
3137 r = subexp_recursive_check(en->
target);
3142 r = subexp_recursive_check_trav(en->
target,
env);
3165 r = setup_subexp_call(
NCAR(node),
env);
3171 r = setup_subexp_call(
NCAR(node),
env);
3176 r = setup_subexp_call(
NQTFR(node)->target,
env);
3179 r = setup_subexp_call(
NENCLOSE(node)->target,
env);
3190# ifdef USE_NAMED_GROUP
3191 if (
env->num_named > 0 &&
3197 if (gnum >
env->num_mem) {
3203# ifdef USE_NAMED_GROUP
3216# ifdef USE_NAMED_GROUP
3217# ifdef USE_PERL_SUBEXP_CALL
3275divide_look_behind_alternatives(
Node* node)
3277 Node *head, *np, *insert_node;
3279 int anc_type = an->
type;
3283 swap_node(node, head);
3292 NCAR(np) = insert_node;
3310 r = get_char_length_tree(an->
target, reg, &
len);
3317 r = divide_look_behind_alternatives(node);
3335#ifdef USE_QTFR_PEEK_NEXT
3336 Node*
n = get_head_value_node(next_node, 1, reg);
3343 if (qn->
lower <= 1) {
3347 x = get_head_value_node(qn->
target, 0, reg);
3349 y = get_head_value_node(next_node, 0, reg);
3350 if (
IS_NOT_NULL(y) && is_not_included(x, y, reg)) {
3354 swap_node(node, en);
3374update_string_node_case_fold(
regex_t* reg,
Node *node)
3377 UChar *sbuf, *ebuf, *sp;
3383 sbuf_size = (end - sn->
s) * 2;
3386 ebuf = sbuf + sbuf_size;
3392 for (
i = 0;
i <
len;
i++) {
3400 sp = sbuf + sbuf_size;
3402 ebuf = sbuf + sbuf_size;
3416expand_case_fold_make_rem_string(
Node** rnode,
UChar *s,
UChar *end,
3425 r = update_string_node_case_fold(reg, node);
3443 for (
i = 0;
i < item_num;
i++) {
3444 if (items[
i].byte_len != slen) {
3447 if (items[
i].code_len != 1) {
3459 int r,
i, j,
len, varlen;
3460 Node *anode, *var_anode, *snode, *xnode, *an;
3466 for (
i = 0;
i < item_num;
i++) {
3467 if (items[
i].byte_len != slen) {
3478 if (
IS_NULL(xnode))
goto mem_err;
3479 NCAR(var_anode) = xnode;
3482 if (
IS_NULL(anode))
goto mem_err;
3483 NCAR(xnode) = anode;
3491 if (
IS_NULL(snode))
goto mem_err;
3493 NCAR(anode) = snode;
3495 for (
i = 0;
i < item_num;
i++) {
3497 if (
IS_NULL(snode))
goto mem_err;
3499 for (j = 0; j < items[
i].
code_len; j++) {
3507 if (r != 0)
goto mem_err2;
3515 if (items[
i].byte_len != slen) {
3520 r = expand_case_fold_make_rem_string(&rem, q, end, reg);
3545 NCDR(var_anode) = an;
3569#define THRESHOLD_CASE_FOLD_ALT_FOR_EXPANSION 8
3571 int r,
n,
len, alt_num;
3573 UChar *start, *end, *p;
3574 Node *top_root, *root, *snode, *prev_node;
3582 if (start >= end)
return 0;
3585 top_root = root = prev_node = snode =
NULL_NODE;
3598 varlen = is_case_fold_variable_len(
n, items,
len);
3599 if (
n == 0 || varlen == 0) {
3611 if (
IS_NULL(snode))
goto mem_err;
3621 if (r != 0)
goto err;
3628 r = update_string_node_case_fold(reg, snode);
3642 r = expand_case_fold_string_alt(
n, items, p,
len, end, reg, &prev_node);
3643 if (r < 0)
goto mem_err;
3646 top_root = prev_node;
3655 root =
NCAR(prev_node);
3672 r = update_string_node_case_fold(reg, snode);
3681 r = expand_case_fold_make_rem_string(&srem, p, end, reg);
3682 if (r != 0)
goto mem_err;
3706 top_root = (
IS_NOT_NULL(top_root) ? top_root : prev_node);
3707 swap_node(node, top_root);
3720#ifdef USE_COMBINATION_EXPLOSION_CHECK
3722# define CEC_THRES_NUM_BIG_REPEAT 512
3723# define CEC_INFINITE_NUM 0x7fffffff
3725# define CEC_IN_INFINITE_REPEAT (1<<0)
3726# define CEC_IN_FINITE_REPEAT (1<<1)
3727# define CEC_CONT_BIG_REPEAT (1<<2)
3741 r = setup_comb_exp_check(
NCAR(node), r,
env);
3751 ret = setup_comb_exp_check(
NCAR(node), state,
env);
3759 int child_state = state;
3766 if (qn->
upper > 1) {
3768 child_state |= CEC_IN_FINITE_REPEAT;
3771 if (
env->backrefed_mem == 0) {
3781 child_state = state;
3790 if (state & CEC_IN_FINITE_REPEAT) {
3791 qn->comb_exp_check_num = -1;
3795 var_num = CEC_INFINITE_NUM;
3796 child_state |= CEC_IN_INFINITE_REPEAT;
3802 if (var_num >= CEC_THRES_NUM_BIG_REPEAT)
3803 add_state |= CEC_CONT_BIG_REPEAT;
3805 if (((state & CEC_IN_INFINITE_REPEAT) != 0 && var_num != 0) ||
3806 ((state & CEC_CONT_BIG_REPEAT) != 0 &&
3807 var_num >= CEC_THRES_NUM_BIG_REPEAT)) {
3808 if (qn->comb_exp_check_num == 0) {
3809 env->num_comb_exp_check++;
3810 qn->comb_exp_check_num =
env->num_comb_exp_check;
3811 if (
env->curr_max_regnum >
env->comb_exp_max_regnum)
3812 env->comb_exp_max_regnum =
env->curr_max_regnum;
3817 r = setup_comb_exp_check(target, child_state,
env);
3832 r = setup_comb_exp_check(en->
target, state,
env);
3837 r = setup_comb_exp_check(en->
target, state,
env);
3843# ifdef USE_SUBEXP_CALL
3846 env->has_recursion = 1;
3848 r = setup_comb_exp_check(
NCALL(node)->target, state,
env);
3860#define IN_ALT (1<<0)
3861#define IN_NOT (1<<1)
3862#define IN_REPEAT (1<<2)
3863#define IN_VAR_REPEAT (1<<3)
3864#define IN_CALL (1<<4)
3865#define IN_RECCALL (1<<5)
3888 r = setup_tree(
NCAR(node), reg, state,
env);
3890 r = next_setup(prev,
NCAR(node), reg);
3908 r = expand_case_fold_string(node, reg);
3916#ifdef USE_SUBEXP_CALL
3932#ifdef USE_BACKREF_WITH_LEVEL
3953 r = get_min_match_length(target, &d,
env);
3957#ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
3958 r = quantifiers_memory_node_info(target);
3965 r = get_max_match_length(target, &d,
env);
3966 if (r == 0 && d == 0) {
3981 r = setup_tree(target, reg, state,
env);
3985#define EXPAND_STRING_MAX_LENGTH 100
3987 if (qn->
lower > 1) {
4016 swap_node(np1, node);
4024 swap_node(np, node);
4031#ifdef USE_OP_PUSH_OR_JUMP_EXACT
4057 r = setup_tree(
NENCLOSE(node)->target, reg, state,
env);
4073 r = setup_tree(en->
target, reg, state,
env);
4079 r = setup_tree(target, reg, state,
env);
4093#ifdef USE_NAMED_GROUP
4095 env->num_named > 0 &&
4103 r = setup_tree(
NENCLOSE(node)->target, reg, state,
env);
4107 r = setup_tree(
NENCLOSE(node)->target, reg, state,
env);
4119 r = setup_tree(an->
target, reg, state,
env);
4126#define ALLOWED_TYPE_IN_LB \
4127 ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \
4128 BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL )
4130#define ALLOWED_ENCLOSE_IN_LB ( ENCLOSE_MEMORY | ENCLOSE_OPTION )
4131#define ALLOWED_ENCLOSE_IN_LB_NOT ENCLOSE_OPTION
4133#define ALLOWED_ANCHOR_IN_LB \
4134( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \
4135 ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \
4136 ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \
4137 ANCHOR_WORD_BEGIN | ANCHOR_WORD_END )
4138#define ALLOWED_ANCHOR_IN_LB_NOT \
4139( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \
4140 ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \
4141 ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \
4142 ANCHOR_WORD_BEGIN | ANCHOR_WORD_END )
4148 if (r < 0)
return r;
4151 r = setup_tree(an->
target, reg, state,
env);
4152 if (r != 0)
return r;
4153 r = setup_look_behind(node, reg,
env);
4161 if (r < 0)
return r;
4165 if (r != 0)
return r;
4166 r = setup_look_behind(node, reg,
env);
4180#ifndef USE_SUNDAY_QUICK_SEARCH
4184 UChar skip[],
int** int_skip,
int ignore_case)
4187 int clen, flen,
n, j, k;
4197 for (
i = 0;
i <
len - 1;
i += clen) {
4202 clen =
enclen(enc, p, end);
4204 clen = (
int )(end - p);
4206 for (j = 0; j <
n; j++) {
4207 if ((items[j].code_len != 1) || (items[j].
byte_len != clen))
4213 for (j = 0; j < clen; j++) {
4215 for (k = 0; k <
n; k++) {
4222# if OPT_EXACT_MAXLEN < ONIG_CHAR_TABLE_SIZE
4233 for (
i = 0;
i <
len - 1;
i += clen) {
4238 clen =
enclen(enc, p, end);
4240 clen = (
int )(end - p);
4242 for (j = 0; j <
n; j++) {
4243 if ((items[j].code_len != 1) || (items[j].
byte_len != clen))
4249 for (j = 0; j < clen; j++) {
4250 (*int_skip)[s[
i + j]] = (
int )(
len - 1 -
i - j);
4251 for (k = 0; k <
n; k++) {
4252 (*int_skip)[
buf[k][j]] = (
int )(
len - 1 -
i - j);
4266 UChar skip[],
int** int_skip,
int ignore_case)
4269 int clen, flen,
n, j, k;
4279 for (
i = 0;
i <
len;
i += clen) {
4284 clen =
enclen(enc, p, end);
4286 clen = (
int )(end - p);
4288 for (j = 0; j <
n; j++) {
4289 if ((items[j].code_len != 1) || (items[j].
byte_len != clen))
4295 for (j = 0; j < clen; j++) {
4297 for (k = 0; k <
n; k++) {
4304# if OPT_EXACT_MAXLEN < ONIG_CHAR_TABLE_SIZE
4315 for (
i = 0;
i <
len;
i += clen) {
4320 clen =
enclen(enc, p, end);
4322 clen = (
int )(end - p);
4324 for (j = 0; j <
n; j++) {
4325 if ((items[j].code_len != 1) || (items[j].
byte_len != clen))
4331 for (j = 0; j < clen; j++) {
4332 (*int_skip)[s[
i + j]] = (
int )(
len -
i - j);
4333 for (k = 0; k <
n; k++) {
4334 (*int_skip)[
buf[k][j]] = (
int )(
len -
i - j);
4395 static const short int ByteValTable[] = {
4396 5, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 1, 1, 10, 1, 1,
4397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4398 12, 4, 7, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
4399 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5,
4400 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
4401 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 5, 5, 5,
4402 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
4403 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 1
4410 return (
int )ByteValTable[
i];
4420 static const short int dist_vals[] = {
4421 1000, 500, 333, 250, 200, 167, 143, 125, 111, 100,
4422 91, 83, 77, 71, 67, 63, 59, 56, 53, 50,
4423 48, 45, 43, 42, 40, 38, 37, 36, 34, 33,
4424 32, 31, 30, 29, 29, 28, 27, 26, 26, 25,
4425 24, 24, 23, 23, 22, 22, 21, 21, 20, 20,
4426 20, 19, 19, 19, 18, 18, 18, 17, 17, 17,
4427 16, 16, 16, 16, 15, 15, 15, 15, 14, 14,
4428 14, 14, 14, 14, 13, 13, 13, 13, 13, 13,
4429 12, 12, 12, 12, 12, 12, 11, 11, 11, 11,
4430 11, 11, 11, 11, 11, 10, 10, 10, 10, 10
4440 return (
int )dist_vals[d];
4448 if (v2 <= 0)
return -1;
4449 if (v1 <= 0)
return 1;
4451 v1 *= distance_value(
d1);
4452 v2 *= distance_value(d2);
4454 if (v2 > v1)
return 1;
4455 if (v2 < v1)
return -1;
4457 if (d2->
min <
d1->min)
return 1;
4458 if (d2->
min >
d1->min)
return -1;
4492 to->
min = distance_add(to->
min, from->
min);
4493 to->
max = distance_add(to->
max, from->
max);
4535 clear_opt_anc_info(to);
4538 if (left_len == 0) {
4543 if (right_len == 0) {
4552is_left_anchor(
int anc)
4573 if (is_left_anchor(anc))
4582 if (is_left_anchor(anc))
4604 clear_mml(&ex->
mmd);
4605 clear_opt_anc_info(&ex->
anc);
4632 for (
i = to->
len; p < end; ) {
4635 for (j = 0; j <
len && p < end; j++)
4642 concat_opt_anc_info(&tanc, &to->
anc, &
add->anc, 1, 1);
4644 copy_opt_anc_info(&to->
anc, &tanc);
4657 for (j = 0; j <
len && p < end; j++)
4669 if (
add->len == 0 || to->
len == 0) {
4670 clear_opt_exact_info(to);
4674 if (! is_equal_mml(&to->
mmd, &
add->mmd)) {
4675 clear_opt_exact_info(to);
4679 for (
i = 0;
i < to->
len &&
i <
add->len; ) {
4680 if (to->
s[
i] !=
add->s[
i])
break;
4683 for (j = 1; j <
len; j++) {
4684 if (to->
s[
i+j] !=
add->s[
i+j])
break;
4690 if (!
add->reach_end || i < add->
len || i < to->
len) {
4696 else if (
add->ignore_case >= 0)
4699 alt_merge_opt_anc_info(&to->
anc, &
add->anc);
4715 copy_opt_exact_info(now, alt);
4718 else if (v1 <= 2 && v2 <= 2) {
4720 v2 = map_position_value(enc, now->
s[0]);
4721 v1 = map_position_value(enc, alt->
s[0]);
4723 if (now->
len > 1) v1 += 5;
4724 if (alt->
len > 1) v2 += 5;
4730 if (comp_distance_value(&now->
mmd, &alt->
mmd, v1, v2) > 0)
4731 copy_opt_exact_info(now, alt);
4740 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4741 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4742 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4743 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4744 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4745 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4746 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4747 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4748 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4750 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4751 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4752 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4753 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4754 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4755 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
4771 if (map->
map[c] == 0) {
4773 map->
value += map_position_value(enc, c);
4785 add_char_opt_map_info(map, p[0], enc);
4789 if (
n < 0)
return n;
4791 for (
i = 0;
i <
n;
i++) {
4793 add_char_opt_map_info(map,
buf[0], enc);
4802 const int z = 1<<15;
4806 if (alt->
value == 0) return ;
4807 if (now->
value == 0) {
4808 copy_opt_map_info(now, alt);
4812 v1 = z / now->
value;
4813 v2 = z / alt->
value;
4814 if (comp_distance_value(&now->
mmd, &alt->
mmd, v1, v2) > 0)
4815 copy_opt_map_info(now, alt);
4821#define COMP_EM_BASE 20
4824 if (m->
value <= 0)
return -1;
4828 return comp_distance_value(&e->
mmd, &m->
mmd, ve, vm);
4837 if (to->
value == 0) return ;
4839 clear_opt_map_info(to);
4843 alt_merge_mml(&to->
mmd, &
add->mmd);
4851 val += map_position_value(enc,
i);
4855 alt_merge_opt_anc_info(&to->
anc, &
add->anc);
4861 copy_mml(&(opt->
exb.
mmd), mmd);
4862 copy_mml(&(opt->
expr.
mmd), mmd);
4863 copy_mml(&(opt->
map.
mmd), mmd);
4869 clear_mml(&opt->
len);
4870 clear_opt_anc_info(&opt->
anc);
4871 clear_opt_exact_info(&opt->
exb);
4872 clear_opt_exact_info(&opt->
exm);
4873 clear_opt_exact_info(&opt->
expr);
4874 clear_opt_map_info(&opt->
map);
4886 int exb_reach, exm_reach;
4889 concat_opt_anc_info(&tanc, &to->
anc, &
add->anc, to->
len.
max,
add->len.max);
4890 copy_opt_anc_info(&to->
anc, &tanc);
4892 if (
add->exb.len > 0 && to->
len.
max == 0) {
4893 concat_opt_anc_info(&tanc, &to->
anc, &
add->exb.anc,
4895 copy_opt_anc_info(&
add->exb.anc, &tanc);
4898 if (
add->map.value > 0 && to->
len.
max == 0) {
4899 if (
add->map.mmd.max == 0)
4906 if (
add->len.max != 0)
4909 if (
add->exb.len > 0) {
4911 concat_opt_exact_info(&to->
exb, &
add->exb, enc);
4912 clear_opt_exact_info(&
add->exb);
4914 else if (exm_reach) {
4915 concat_opt_exact_info(&to->
exm, &
add->exb, enc);
4916 clear_opt_exact_info(&
add->exb);
4919 select_opt_exact_info(enc, &to->
exm, &
add->exb);
4920 select_opt_exact_info(enc, &to->
exm, &
add->exm);
4923 if (
add->len.max > 0) {
4928 select_opt_exact_info(enc, &to->
exb, &to->
expr);
4930 select_opt_exact_info(enc, &to->
exm, &to->
expr);
4933 else if (
add->expr.len > 0) {
4934 copy_opt_exact_info(&to->
expr, &
add->expr);
4937 select_opt_map_info(&to->
map, &
add->map);
4939 add_mml(&to->
len, &
add->len);
4945 alt_merge_opt_anc_info (&to->
anc, &
add->anc);
4946 alt_merge_opt_exact_info(&to->
exb, &
add->exb,
env);
4947 alt_merge_opt_exact_info(&to->
exm, &
add->exm,
env);
4948 alt_merge_opt_exact_info(&to->
expr, &
add->expr,
env);
4949 alt_merge_opt_map_info(
env->enc, &to->
map, &
add->map);
4951 alt_merge_mml(&to->
len, &
add->len);
4955#define MAX_NODE_OPT_INFO_REF_COUNT 5
4963 clear_node_opt_info(opt);
4964 set_bound_node_opt_info(opt, &
env->mmd);
4974 copy_opt_env(&nenv,
env);
4976 r = optimize_node_left(
NCAR(nd), &nopt, &nenv);
4978 add_mml(&nenv.
mmd, &nopt.
len);
4979 concat_left_node_opt_info(
env->enc, opt, &nopt);
4991 r = optimize_node_left(
NCAR(nd), &nopt,
env);
4993 if (nd == node) copy_node_opt_info(opt, &nopt);
4994 else alt_merge_node_opt_info(opt, &nopt,
env);
5007 concat_opt_exact_info_str(&opt->
exb, sn->
s, sn->
end,
5011 add_char_opt_map_info(&opt->
map, *(sn->
s),
env->enc);
5013 set_mml(&opt->
len, slen, slen);
5023 concat_opt_exact_info_str(&opt->
exb, sn->
s, sn->
end,
5028 r = add_char_amb_opt_map_info(&opt->
map, sn->
s, sn->
end,
5029 env->enc,
env->case_fold_flag);
5036 set_mml(&opt->
len, slen, max);
5055 set_mml(&opt->
len, min, max);
5064 set_mml(&opt->
len, 1, 1);
5080 switch (
NCTYPE(node)->ctype) {
5082 if (
NCTYPE(node)->not != 0) {
5090 for (
i = 0;
i < maxcode;
i++) {
5102 set_mml(&opt->
len, min, max);
5110 set_mml(&opt->
len, min, max);
5131 r = optimize_node_left(
NANCHOR(node)->target, &nopt,
env);
5134 copy_opt_exact_info(&opt->
expr, &nopt.
exb);
5135 else if (nopt.
exm.
len > 0)
5136 copy_opt_exact_info(&opt->
expr, &nopt.
exm);
5141 copy_opt_map_info(&opt->
map, &nopt.
map);
5164 r = get_min_match_length(nodes[backs[0]], &min,
env->scan_env);
5166 r = get_max_match_length(nodes[backs[0]], &max,
env->scan_env);
5169 r = get_min_match_length(nodes[backs[
i]], &tmin,
env->scan_env);
5171 r = get_max_match_length(nodes[backs[
i]], &tmax,
env->scan_env);
5173 if (min > tmin) min = tmin;
5174 if (max < tmax) max = tmax;
5176 if (r == 0) set_mml(&opt->
len, min, max);
5180#ifdef USE_SUBEXP_CALL
5187 r = optimize_node_left(
NCALL(node)->target, opt,
env);
5188 env->options = save;
5200 r = optimize_node_left(qn->
target, &nopt,
env);
5204 if (
env->mmd.max == 0 &&
5214 if (qn->
lower > 0) {
5215 copy_node_opt_info(opt, &nopt);
5219 ! is_full_opt_exact_info(&opt->
exb);
i++) {
5220 concat_opt_exact_info(&opt->
exb, &nopt.
exb,
env->enc);
5222 if (i < qn->lower) {
5243 set_mml(&opt->
len, min, max);
5257 r = optimize_node_left(en->
target, opt,
env);
5258 env->options = save;
5263#ifdef USE_SUBEXP_CALL
5272 set_mml(&opt->
len, min, max);
5277 r = optimize_node_left(en->
target, opt,
env);
5288 r = optimize_node_left(en->
target, opt,
env);
5300 fprintf(
stderr,
"optimize_node_left: undefined node type %d\n",
5316 if (e->
len == 0)
return 0;
5327 if (e->
len >= 3 || (e->
len >= 2 && allow_reverse)) {
5331 reg->
optimize = (allow_reverse != 0
5343 if (e->
len >= 3 || (e->
len >= 2 && allow_reverse)) {
5347 reg->
optimize = (allow_reverse != 0
5393#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH)
5408 env.scan_env = scan_env;
5409 clear_mml(&
env.mmd);
5411 r = optimize_node_left(node, &opt, &
env);
5430 select_opt_exact_info(reg->
enc, &opt.
exb, &opt.
exm);
5432 comp_opt_exact_or_map_info(&opt.
exb, &opt.
map) > 0) {
5436 r = set_optimize_exact_info(reg, &opt.
exb);
5437 set_sub_anchor(reg, &opt.
exb.
anc);
5442 set_optimize_map_info(reg, &opt.
map);
5443 set_sub_anchor(reg, &opt.
map.
anc);
5451#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH)
5452 print_optimize_info(
stderr, reg);
5458clear_optimize_info(
regex_t* reg)
5488 fprintf(fp,
" 0x%04x ", (
int )code);
5491 fputc((
int )code, fp);
5494 p +=
enclen(enc, p, end);
5499 fputc((
int )*s, fp);
5508#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH)
5526print_anchor(
FILE*
f,
int anchor)
5577 static const char* on[] = {
"NONE",
"EXACT",
"EXACT_BM",
"EXACT_BM_NOT_REV",
5579 "EXACT_BM_IC",
"EXACT_BM_NOT_REV_IC" };
5596 for (p = reg->
exact; p < reg->exact_end; p++) {
5605 if (reg->
map[
i])
n++;
5612 if (reg->
map[
i] != 0) {
5613 if (c > 0)
fputs(
", ",
f);
5640#ifdef USE_NAMED_GROUP
5674 size_t size =
sizeof(*regs);
5681#define REGEX_TRANSFER(to,from) do {\
5682 onig_free_body(to);\
5683 xmemcpy(to, from, sizeof(regex_t));\
5695#ifdef ONIG_DEBUG_COMPILE
5696static void print_compiled_byte_code_list(
FILE*
f,
regex_t* reg);
5698#ifdef ONIG_DEBUG_PARSE_TREE
5699static void print_tree(
FILE*
f,
Node* node);
5714 OnigErrorInfo* einfo,
const char *sourcefile,
int sourceline)
5721#define COMPILE_INIT_SIZE 20
5727#ifdef USE_SUBEXP_CALL
5739 print_enc_string(
stderr, reg->
enc, pattern, pattern_end);
5742 if (reg->
alloc == 0) {
5743 init_size = (pattern_end - pattern) * 2;
5746 if (r != 0)
goto end;
5756#ifdef USE_COMBINATION_EXPLOSION_CHECK
5761 if (r != 0)
goto err;
5763#ifdef ONIG_DEBUG_PARSE_TREE
5766 print_tree(
stderr, root);
5770#ifdef USE_NAMED_GROUP
5776 r = disable_noname_group_capture(&root, reg, &scan_env);
5778 r = numbered_ref_check(root);
5780 if (r != 0)
goto err;
5784#ifdef USE_SUBEXP_CALL
5786 r = unset_addr_list_init(&uslist, scan_env.
num_call);
5787 if (r != 0)
goto err;
5789 r = setup_subexp_call(root, &scan_env);
5790 if (r != 0)
goto err_unset;
5791 r = subexp_recursive_check_trav(root, &scan_env);
5792 if (r < 0)
goto err_unset;
5793 r = subexp_inf_recursive_check_trav(root, &scan_env);
5794 if (r != 0)
goto err_unset;
5802 r = setup_tree(root, reg, 0, &scan_env);
5803 if (r != 0)
goto err_unset;
5805#ifdef ONIG_DEBUG_PARSE_TREE
5806 print_tree(
stderr, root);
5819#ifdef USE_COMBINATION_EXPLOSION_CHECK
5825 setup_comb_exp_check(root, 0, &scan_env);
5826# ifdef USE_SUBEXP_CALL
5827 if (scan_env.has_recursion != 0) {
5828 scan_env.num_comb_exp_check = 0;
5832 if (scan_env.comb_exp_max_regnum > 0) {
5834 for (
i = 1;
i <= scan_env.comb_exp_max_regnum;
i++) {
5836 scan_env.num_comb_exp_check = 0;
5846 clear_optimize_info(reg);
5847#ifndef ONIG_DONT_OPTIMIZE
5848 r = set_optimize_info_from_tree(root, reg, &scan_env);
5849 if (r != 0)
goto err_unset;
5857 r = compile_tree(root, reg);
5859 r = add_opcode(reg,
OP_END);
5860#ifdef USE_SUBEXP_CALL
5862 r = unset_addr_list_fix(&uslist, reg);
5863 unset_addr_list_end(&uslist);
5877#ifdef USE_SUBEXP_CALL
5879 unset_addr_list_end(&uslist);
5884#ifdef ONIG_DEBUG_COMPILE
5885# ifdef USE_NAMED_GROUP
5886 onig_print_names(
stderr, reg);
5888 print_compiled_byte_code_list(
stderr, reg);
5895#ifdef USE_SUBEXP_CALL
5897 unset_addr_list_end(&uslist);
5903 einfo->
enc = scan_env.
enc;
5915static int onig_inited = 0;
5938 option &= ~ONIG_OPTION_SINGLELINE;
5944 (reg)->options = option;
5945 (reg)->syntax = syntax;
5946 (reg)->optimize = 0;
5948 (reg)->int_map = (
int* )
NULL;
5949 (reg)->int_map_backward = (
int* )
NULL;
5955 (reg)->name_table = (
void* )
NULL;
5957 (reg)->case_fold_flag = case_fold_flag;
6006 if (onig_inited != 0)
6011#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER)
6012 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
6018#ifdef ONIG_DEBUG_STATISTICS
6019 onig_statistics_init();
6033 if (item == 0) return ;
6035 item->
next = EndCallTop;
6042exec_end_call_list(
void)
6047 while (EndCallTop != 0) {
6048 func = EndCallTop->
func;
6052 EndCallTop = EndCallTop->
next;
6060 exec_end_call_list();
6062#ifdef ONIG_DEBUG_STATISTICS
6063 onig_print_statistics(
stderr);
6066#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER)
6067 _CrtDumpMemoryLeaks();
6085 for (low = 0, high =
n; low < high; ) {
6086 x = (low + high) >> 1;
6087 if (code > data[x * 2 + 1])
6093 return ((low < n && code >= data[low * 2]) ? 1 : 0);
6137# define ARG_SPECIAL -1
6139# define ARG_RELADDR 1
6140# define ARG_ABSADDR 2
6141# define ARG_LENGTH 3
6142# define ARG_MEMNUM 4
6143# define ARG_OPTION 5
6144# define ARG_STATE_CHECK 6
6146OnigOpInfoType OnigOpInfo[] = {
6148 {
OP_END,
"end", ARG_NON },
6210 {
OP_JUMP,
"jump", ARG_RELADDR },
6211 {
OP_PUSH,
"push", ARG_RELADDR },
6212 {
OP_POP,
"pop", ARG_NON },
6237 {
OP_CALL,
"call", ARG_ABSADDR },
6245 "state-check-anychar-ml*", ARG_STATE_CHECK },
6254 for (
i = 0; OnigOpInfo[
i].opcode >= 0;
i++) {
6255 if (opcode == OnigOpInfo[
i].opcode)
6256 return OnigOpInfo[
i].name;
6262op2arg_type(
int opcode)
6266 for (
i = 0; OnigOpInfo[
i].opcode >= 0;
i++) {
6267 if (opcode == OnigOpInfo[
i].opcode)
6268 return OnigOpInfo[
i].arg_type;
6273# ifdef ONIG_DEBUG_PARSE_TREE
6275Indent(
FILE*
f,
int indent)
6278 for (
i = 0;
i < indent;
i++)
putc(
' ',
f);
6292 int x =
len * mb_len;
6295 while (x-- > 0) {
fputc(*s++,
f); }
6311 arg_type = op2arg_type(*
bp);
6312 if (arg_type != ARG_SPECIAL) {
6319 fprintf(
f,
":(%s%d)", (addr >= 0) ?
"+" :
"", addr);
6342 case ARG_STATE_CHECK:
6354 p_string(
f, 1,
bp++);
break;
6356 p_string(
f, 2,
bp);
bp += 2;
break;
6358 p_string(
f, 3,
bp);
bp += 3;
break;
6360 p_string(
f, 4,
bp);
bp += 4;
break;
6362 p_string(
f, 5,
bp);
bp += 5;
break;
6365 p_len_string(
f,
len, 1,
bp);
6370 p_string(
f, 2,
bp);
bp += 2;
break;
6372 p_string(
f, 4,
bp);
bp += 4;
break;
6374 p_string(
f, 6,
bp);
bp += 6;
break;
6377 p_len_string(
f,
len, 2,
bp);
6382 p_len_string(
f,
len, 3,
bp);
6404 p_len_string(
f,
len, 1,
bp);
6424# ifndef PLATFORM_UNALIGNED_WORD_ACCESS
6438# ifndef PLATFORM_UNALIGNED_WORD_ACCESS
6456 for (
i = 0;
i <
len;
i++) {
6475 for (
i = 0;
i <
len;
i++) {
6498 fprintf(
f,
":(%s%d)", (addr >= 0) ?
"+" :
"", addr);
6511 fprintf(
f,
":%d:(%s%d)",
len, (addr >= 0) ?
"+" :
"", addr);
6520 fprintf(
f,
":%d:(%s%d)", scn, (addr >= 0) ?
"+" :
"", addr);
6526 fprintf(
f,
":%d:(%s%d)", mem, (addr >= 0) ?
"+" :
"", addr);
6530 fprintf(
stderr,
"onig_print_compiled_byte_code: undefined code %d\n",
6535 if (nextp) *nextp =
bp;
6538# ifdef ONIG_DEBUG_COMPILE
6555 onig_print_compiled_byte_code(
f,
bp, end, &
bp, reg->
enc);
6562# ifdef ONIG_DEBUG_PARSE_TREE
6564print_indent_tree(
FILE*
f,
Node* node,
int indent)
6566 int i,
type, container_p = 0;
6572 fprintf(
f,
"ERROR: null node!!!\n");
6585 print_indent_tree(
f,
NCAR(node), indent +
add);
6588 fprintf(
f,
"ERROR: list/alt right is not a cons. %d\n",
NTYPE(node));
6591 print_indent_tree(
f,
NCAR(node), indent +
add);
6598 for (p =
NSTR(node)->s; p <
NSTR(node)->end; p++) {
6599 if (*p >= 0x20 && *p < 0x7f)
6615 for (; data < end; data+=2) {
6617 fprintf(
f,
"%04x-%04x", data[0], data[1]);
6624 switch (
NCTYPE(node)->ctype) {
6626 if (
NCTYPE(node)->not != 0)
6633 fprintf(
f,
"ERROR: undefined ctype.\n");
6654# ifdef USE_WORD_BEGIN_END
6665 fprintf(
f,
"ERROR: undefined anchor type.\n");
6683# ifdef USE_SUBEXP_CALL
6696 (
NQTFR(node)->greedy ?
"" :
"?"));
6697 print_indent_tree(
f,
NQTFR(node)->target, indent +
add);
6723 print_indent_tree(
f,
NENCLOSE(node)->target, indent +
add);
6727 fprintf(
f,
"print_indent_tree: undefined node type %d\n",
NTYPE(node));
6735 if (container_p) print_indent_tree(
f,
NANCHOR(node)->target, indent +
add);
6743 print_indent_tree(
f, node, 0);
VALUE type(ANYARGS)
ANYARGS-ed function type.
#define ONIG_INFINITE_DISTANCE
#define ONIG_OPTION_DONT_CAPTURE_GROUP
#define ONIGENC_IS_CODE_PRINT(enc, code)
#define ONIGENC_MBC_MAXLEN_DIST(enc)
#define ONIGENC_CODE_TO_MBC(enc, code, buf)
#define ONIG_IS_OPTION_ON(options, option)
#define ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL
unsigned int OnigCaseFoldType
#define ONIGENC_MBC_TO_CODE(enc, p, end)
#define ONIGERR_INVALID_ARGUMENT
#define ONIGERR_NEVER_ENDING_RECURSION
#define ONIGERR_PARSER_BUG
#define ONIGENC_IS_MBC_ASCII_WORD(enc, s, end)
#define ONIGENC_CODE_TO_MBC_MAXLEN
#define ONIGENC_CTYPE_WORD
#define ONIGERR_UNDEFINED_NAME_REFERENCE
#define ONIGENC_IS_UNDEF(enc)
#define ONIGENC_CASE_FOLD_DEFAULT
#define ONIGERR_INVALID_LOOK_BEHIND_PATTERN
#define ONIGENC_IS_CODE_WORD(enc, code)
unsigned int OnigCodePoint
#define ONIG_OPTION_IGNORECASE
#define ONIG_OPTION_NEGATE_SINGLELINE
ONIG_EXTERN int onig_name_to_group_numbers(OnigRegex reg, const OnigUChar *name, const OnigUChar *name_end, int **nums)
#define ONIG_OPTION_CAPTURE_GROUP
#define ONIG_MAX_CAPTURE_HISTORY_GROUP
#define ONIGERR_UNDEFINED_GROUP_REFERENCE
#define ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED
#define ONIGENC_MBC_MAXLEN(enc)
#define ONIGENC_MBC_MINLEN(enc)
#define ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc, s, end)
#define ONIGENC_MBC_CASE_FOLD(enc, flag, pp, end, buf)
#define ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, case_fold_flag, p, end, acs)
#define ONIG_CHAR_TABLE_SIZE
#define ONIGERR_INVALID_COMBINATION_OF_OPTIONS
#define ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME_CALL
#define ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP
ONIG_EXTERN int onigenc_init(void)
#define ONIGENC_MBC_CASE_FOLD_MAXLEN
#define ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM
#define ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND
#define ONIGERR_INVALID_CONDITION_PATTERN
unsigned int OnigOptionType
#define ONIGERR_INVALID_BACKREF
ONIG_EXTERN int onigenc_strlen(OnigEncoding enc, const OnigUChar *p, const OnigUChar *end)
#define ONIGENC_CODE_TO_MBCLEN(enc, code)
#define ONIGENC_CASE_FOLD_MIN
#define ONIGERR_DEFAULT_ENCODING_IS_NOT_SET
#define ONIGENC_IS_MBC_WORD(enc, s, end)
int onig_is_in_code_range(const UChar *p, OnigCodePoint code)
int onig_new_without_alloc(regex_t *reg, const UChar *pattern, const UChar *pattern_end, OnigOptionType option, OnigEncoding enc, const OnigSyntaxType *syntax, OnigErrorInfo *einfo)
OnigCaseFoldType onig_get_default_case_fold_flag(void)
#define EXPAND_STRING_MAX_LENGTH
int onig_reg_init(regex_t *reg, OnigOptionType option, OnigCaseFoldType case_fold_flag, OnigEncoding enc, const OnigSyntaxType *syntax)
#define QUANTIFIER_EXPAND_LIMIT_SIZE
#define RECURSION_INFINITE
int onig_initialize(OnigEncoding encodings[] ARG_UNUSED, int n ARG_UNUSED)
int onig_set_default_case_fold_flag(OnigCaseFoldType case_fold_flag)
#define REPEAT_RANGE_ALLOC
#define THRESHOLD_CASE_FOLD_ALT_FOR_EXPANSION
#define GET_CHAR_LEN_TOP_ALT_VARLEN
int onig_new(regex_t **reg, const UChar *pattern, const UChar *pattern_end, OnigOptionType option, OnigEncoding enc, const OnigSyntaxType *syntax, OnigErrorInfo *einfo)
#define ALLOWED_ANCHOR_IN_LB_NOT
#define ALLOWED_TYPE_IN_LB
int onig_bbuf_init(BBuf *buf, OnigDistance size)
#define ALLOWED_ANCHOR_IN_LB
void onig_free_body(regex_t *reg)
size_t onig_region_memsize(const OnigRegion *regs)
int onig_is_code_in_cc(OnigEncoding enc, OnigCodePoint code, CClassNode *cc)
OnigCaseFoldType OnigDefaultCaseFoldFlag
int onig_is_code_in_cc_len(int elen, OnigCodePoint code, CClassNode *cc)
#define GET_CHAR_LEN_VARLEN
int onig_compile(regex_t *reg, const UChar *pattern, const UChar *pattern_end, OnigErrorInfo *einfo)
#define ALLOWED_ENCLOSE_IN_LB
#define IS_NEED_STR_LEN_OP_EXACT(op)
size_t onig_memsize(const regex_t *reg)
void onig_add_end_call(void(*func)(void))
#define COMPILE_INIT_SIZE
#define FOUND_CALLED_NODE
void onig_free(regex_t *reg)
#define REGEX_TRANSFER(to, from)
#define MAX_NODE_OPT_INFO_REF_COUNT
#define ALLOWED_ENCLOSE_IN_LB_NOT
int onig_compile_ruby(regex_t *reg, const UChar *pattern, const UChar *pattern_end, OnigErrorInfo *einfo, const char *sourcefile, int sourceline)
#define enclen(enc, p, e)
#define GET_ALIGNMENT_PAD_SIZE(addr, pad_size)
#define SIZE_OP_PUSH_IF_PEEK_NEXT
#define ANCHOR_BEGIN_LINE
#define SIZE_OP_PUSH_ABSENT_POS
#define SIZE_OP_ABSENT_END
#define CHECK_NULL_RETURN_MEMERR(p)
#define SIZE_OP_POP_STOP_BT
#define ANCHOR_PREC_READ_NOT
#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC
#define IS_DYNAMIC_OPTION(option)
#define ONIG_OPTIMIZE_MAP
#define ONIG_OPTIMIZE_EXACT
#define GET_OPTION_INC(option, p)
#define BIT_STATUS_ON_ALL(stats)
#define ANCHOR_BEGIN_POSITION
#define SIZE_OP_PUSH_OR_JUMP_EXACT1
#define GET_MEMNUM_INC(num, p)
#define STACK_POP_LEVEL_ALL
#define SIZE_OP_MEMORY_END_PUSH
#define ONIG_OPTIMIZE_EXACT_BM
#define BITSET_AT(bs, pos)
#define SIZE_OP_MEMORY_END
#define CHECK_NULL_RETURN(p)
#define ANCHOR_LOOK_BEHIND
#define BBUF_GET_ADD_ADDRESS(buf)
#define ANCHOR_WORD_BOUND
#define SIZE_OP_PUSH_STOP_BT
#define SIZE_OP_NULL_CHECK_END
#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV
#define SIZE_OP_MEMORY_START
#define STACK_POP_LEVEL_MEM_START
#define BIT_STATUS_ON_AT(stats, n)
#define ANCHOR_WORD_BEGIN
#define SIZE_OP_MEMORY_END_PUSH_REC
#define ANCHOR_ANYCHAR_STAR_ML
#define STACK_POP_LEVEL_FREE
#define BBUF_INIT(buf, size)
#define IS_REPEAT_INFINITE(n)
#define SIZE_OP_PUSH_POS_NOT
#define WORD_ALIGNMENT_SIZE
#define SIZE_OP_ANYCHAR_STAR_PEEK_NEXT
#define GET_LENGTH_INC(len, p)
#define ANCHOR_LOOK_BEHIND_NOT
unsigned int BitStatusType
#define GET_CODE_POINT(code, p)
#define ANCHOR_SEMI_END_BUF
void onig_transfer(regex_t *to, regex_t *from)
#define IS_MULTILINE(option)
#define BBUF_ADD1(buf, byte)
#define SIZE_OP_ANYCHAR_STAR
#define ALIGNMENT_RIGHT(addr)
#define ONIG_OPTIMIZE_EXACT_IC
#define SIZE_OP_MEMORY_START_PUSH
#define IS_NCCLASS_NOT(nd)
short int StateCheckNumType
#define ONIG_OPTIMIZE_NONE
#define BBUF_ADD(buf, bytes, n)
#define ANCHOR_NOT_WORD_BOUND
#define SIZE_OP_PUSH_LOOK_BEHIND_NOT
#define BBUF_GET_OFFSET_POS(buf)
#define SIZE_OP_NULL_CHECK_START
@ OP_STATE_CHECK_PUSH_OR_JUMP
@ OP_STATE_CHECK_ANYCHAR_STAR
@ OP_ANYCHAR_STAR_PEEK_NEXT
@ OP_PUSH_LOOK_BEHIND_NOT
@ OP_NOT_ASCII_WORD_BOUND
@ OP_NULL_CHECK_END_MEMST_PUSH
@ OP_STATE_CHECK_ANYCHAR_ML_STAR
@ OP_ANYCHAR_ML_STAR_PEEK_NEXT
@ OP_FAIL_LOOK_BEHIND_NOT
@ OP_NULL_CHECK_END_MEMST
#define IS_CODE_SB_WORD(enc, code)
#define IS_FIND_CONDITION(option)
#define SIZE_OP_SET_OPTION_PUSH
#define SIZE_STATE_CHECK_NUM
#define SIZE_OP_REPEAT_INC
#define BIT_STATUS_CLEAR(stats)
#define ANCHOR_ANYCHAR_STAR
#define ONIG_OPTIMIZE_EXACT_BM_IC
#define GET_ABSADDR_INC(addr, p)
#define IS_IGNORECASE(option)
#define SIZE_OP_CONDITION
#define BIT_STATUS_ON_AT_SIMPLE(stats, n)
#define SIZE_OP_MEMORY_END_REC
#define DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag)
#define BIT_STATUS_AT(stats, n)
#define SIZE_OP_LOOK_BEHIND
#define GET_RELADDR_INC(addr, p)
#define BBUF_WRITE(buf, pos, bytes, n)
#define SIZE_OP_SET_OPTION
#define SIZE_OP_FAIL_LOOK_BEHIND_NOT
Node * onig_node_new_list(Node *left, Node *right)
Node * onig_node_new_anchor(int type)
int onig_node_str_cat(Node *node, const UChar *s, const UChar *end)
int onig_parse_make_tree(Node **root, const UChar *pattern, const UChar *end, regex_t *reg, ScanEnv *env)
void onig_scan_env_set_error_string(ScanEnv *env, int ecode ARG_UNUSED, UChar *arg, UChar *arg_end)
Node * onig_node_list_add(Node *list, Node *x)
void onig_node_free(Node *node)
Node * onig_node_new_enclose(int type)
Node * onig_node_new_alt(Node *left, Node *right)
Node * onig_node_new_str(const UChar *s, const UChar *end)
int onig_node_str_set(Node *node, const UChar *s, const UChar *end)
int onig_names_free(regex_t *reg)
void onig_reduce_nested_quantifier(Node *pnode, Node *cnode)
int onig_renumber_name_table(regex_t *reg, GroupNumRemap *map)
#define IS_ENCLOSE_MAX_FIXED(en)
#define IS_BACKREF_NAME_REF(bn)
#define IS_SYNTAX_BV(syn, bvm)
#define IS_QUANTIFIER_IN_REPEAT(qn)
#define NST_MEM_BACKREFED
#define IS_CALL_RECURSION(cn)
#define NSTRING_IS_AMBIG(node)
#define IS_ENCLOSE_ADDR_FIXED(en)
#define IS_ENCLOSE_CLEN_FIXED(en)
#define IS_ENCLOSE_NAME_REF(en)
#define ANCHOR_END_BUF_MASK
#define IS_ENCLOSE_CALLED(en)
#define IS_BACKREF_NEST_LEVEL(bn)
#define IS_ENCLOSE_MARK2(en)
#define NQ_TARGET_IS_EMPTY_MEM
#define SET_CALL_RECURSION(node)
#define IS_ENCLOSE_RECURSION(en)
#define ENCLOSE_CONDITION
#define SET_ENCLOSE_STATUS(node, f)
#define IS_ENCLOSE_MIN_FIXED(en)
#define SCANENV_MEM_NODES(senv)
#define NSTRING_LEN(node)
#define ENCLOSE_STOP_BACKTRACK
#define IS_ENCLOSE_NAMED_GROUP(en)
#define NQ_TARGET_IS_EMPTY
#define NST_STOP_BT_SIMPLE_REPEAT
#define NSTRING_SET_AMBIG(node)
#define SET_NTYPE(node, ntype)
#define NQ_TARGET_IS_EMPTY_REC
#define IS_NODE_TYPE_SIMPLE(type)
#define IS_ENCLOSE_MARK1(en)
#define CLEAR_ENCLOSE_STATUS(node, f)
#define ANCHOR_ANYCHAR_STAR_MASK
#define NSTRING_IS_DONT_GET_OPT_INFO(node)
#define NSTRING_IS_RAW(node)
#define NSTRING_SET_DONT_GET_OPT_INFO(node)
#define IS_ENCLOSE_STOP_BT_SIMPLE_REPEAT(en)
int back_static[NODE_BACKREFS_SIZE]
UnsetAddrList * unset_addr_list
struct OnigEndCallListItem * next
OnigCaseFoldType case_fold_flag
UChar s[OPT_EXACT_MAXLEN]
UChar map[ONIG_CHAR_TABLE_SIZE]
struct _Node * head_exact
struct _Node * next_head_exact
Node ** mem_nodes_dynamic
BitStatusType bt_mem_start
UnsetAddrList * unset_addr_list
BitStatusType backrefed_mem
BitStatusType capture_history
const OnigSyntaxType * syntax
UChar buf[NODE_STR_BUF_SIZE]
unsigned char * exact_end
unsigned int capture_history
unsigned int bt_mem_start
OnigCaseFoldType case_fold_flag
struct re_pattern_buffer * chain
OnigRepeatRange * repeat_range
unsigned char map[ONIG_CHAR_TABLE_SIZE]