49#ifndef PLATFORM_UNALIGNED_WORD_ACCESS
57 ptrdiff_t
len = end - s;
74 c = *a; *a = *b; *b = c;
109 if (m == 0)
return 0;
122 if (bs[i] != 0)
return 0;
159 }
while ((reg = reg->
chain) != 0);
180#ifdef USE_SUBEXP_CALL
225add_opcode(
regex_t* reg,
int opcode)
231#ifdef USE_COMBINATION_EXPLOSION_CHECK
243add_rel_addr(
regex_t* reg,
int addr)
252add_abs_addr(
regex_t* reg,
int addr)
280add_pointer(
regex_t* reg,
void* addr)
297add_opcode_rel_addr(
regex_t* reg,
int opcode,
int addr)
301 r = add_opcode(reg, opcode);
303 r = add_rel_addr(reg, addr);
326 r = add_opcode(reg, opcode);
328 r = add_option(reg, option);
332static int compile_length_tree(
Node* node,
regex_t* reg);
336#define IS_NEED_STR_LEN_OP_EXACT(op) \
337 ((op) == OP_EXACTN || (op) == OP_EXACTMB2N ||\
338 (op) == OP_EXACTMB3N || (op) == OP_EXACTMBN || (op) == OP_EXACTN_IC)
341select_str_opcode(
int mb_len,
OnigDistance byte_len,
int ignore_case)
344 OnigDistance str_len = (byte_len + mb_len - 1) / mb_len;
387compile_tree_empty_check(
Node* node,
regex_t* reg,
int empty_info)
392 if (empty_info != 0) {
400 r = compile_tree(node, reg);
403 if (empty_info != 0) {
412 r = add_mem_num(reg, saved_num_null_check);
417#ifdef USE_SUBEXP_CALL
428 r = add_abs_addr(reg, 0 );
434compile_tree_n_times(
Node* node,
int n,
regex_t* reg)
438 for (i = 0; i < n; i++) {
439 r = compile_tree(node, reg);
450 int op = select_str_opcode(mb_len, byte_len, ignore_case);
466 int op = select_str_opcode(mb_len, byte_len, ignore_case);
470 add_length(reg, mb_len);
474 add_length(reg, byte_len);
476 add_length(reg, byte_len / mb_len);
479 add_bytes(reg, s, byte_len);
485compile_length_string_node(
Node* node,
regex_t* reg)
487 int rlen, r,
len, prev_len, blen, ambig;
493 if (sn->
end <= sn->
s)
504 for (; p < sn->
end; ) {
506 if (
len == prev_len || ambig) {
510 r = add_compile_string_length(prev, prev_len, blen, reg, ambig);
518 r = add_compile_string_length(prev, prev_len, blen, reg, ambig);
526 if (sn->
end <= sn->
s)
529 return add_compile_string_length(sn->
s, 1 , sn->
end - sn->
s, reg, 0);
535 int r,
len, prev_len, blen, ambig;
537 UChar *p, *prev, *end;
541 if (sn->
end <= sn->
s)
548 prev_len =
enclen(enc, p, end);
554 if (
len == prev_len || ambig) {
558 r = add_compile_string(prev, prev_len, blen, reg, ambig);
568 return add_compile_string(prev, prev_len, blen, reg, ambig);
574 if (sn->
end <= sn->
s)
577 return add_compile_string(sn->
s, 1 , sn->
end - sn->
s, reg, 0);
583#ifdef PLATFORM_UNALIGNED_WORD_ACCESS
584 add_length(reg, mbuf->
used);
585 return add_bytes(reg, mbuf->
p, mbuf->
used);
592 if (pad_size != 0) add_bytes(reg, PadBuf, pad_size);
594 r = add_bytes(reg, mbuf->
p, mbuf->
used);
598 if (pad_size != 0) add_bytes(reg, PadBuf, pad_size);
618#ifdef PLATFORM_UNALIGNED_WORD_ACCESS
639 r = add_bitset(reg, cc->
bs);
648 r = add_multi_byte_cclass(cc->
mbuf, reg);
656 r = add_bitset(reg, cc->
bs);
658 r = add_multi_byte_cclass(cc->
mbuf, reg);
666entry_repeat_range(
regex_t* reg,
int id,
int lower,
int upper)
668#define REPEAT_RANGE_ALLOC 4
697compile_range_repeat_node(
QtfrNode* qn,
int target_len,
int empty_info,
705 r = add_mem_num(reg, num_repeat);
711 r = entry_repeat_range(reg, num_repeat, qn->
lower, qn->
upper);
714 r = compile_tree_empty_check(qn->
target, reg, empty_info);
728 r = add_mem_num(reg, num_repeat);
733is_anychar_star_quantifier(
QtfrNode* qn)
742#define QUANTIFIER_EXPAND_LIMIT_SIZE 50
743#define CKN_ON (ckn > 0)
745#ifdef USE_COMBINATION_EXPLOSION_CHECK
750 int len, mod_tlen, cklen;
754 int tlen = compile_length_tree(qn->
target, reg);
756 if (tlen < 0)
return tlen;
764 if (qn->
greedy && infinite) {
777 if (infinite && qn->
lower <= 1) {
795 else if (qn->
upper == 0) {
802 if (qn->
lower == 0) {
804 len = SIZE_OP_STATE_CHECK_PUSH + tlen;
821 len += SIZE_OP_STATE_CHECK;
834 int tlen = compile_length_tree(qn->
target, reg);
836 if (tlen < 0)
return tlen;
840 if (is_anychar_star_quantifier(qn)) {
841 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
850 r = add_state_check_num(reg, ckn);
858 r = add_opcode(reg, (
CKN_ON ?
863 r = add_opcode(reg, (
CKN_ON ?
869 r = add_state_check_num(reg, ckn);
880 if (infinite && qn->
lower <= 1) {
882 if (qn->
lower == 1) {
883 r = add_opcode_rel_addr(reg,
OP_JUMP,
891 r = add_state_check_num(reg, ckn);
899 r = compile_tree_empty_check(qn->
target, reg, empty_info);
901 r = add_opcode_rel_addr(reg,
OP_JUMP,
906 if (qn->
lower == 0) {
907 r = add_opcode_rel_addr(reg,
OP_JUMP, mod_tlen);
910 r = compile_tree_empty_check(qn->
target, reg, empty_info);
915 r = add_state_check_num(reg, ckn);
917 r = add_rel_addr(reg,
918 -(mod_tlen + (
int )SIZE_OP_STATE_CHECK_PUSH_OR_JUMP));
924 else if (qn->
upper == 0) {
926 r = add_opcode_rel_addr(reg,
OP_JUMP, tlen);
928 r = compile_tree(qn->
target, reg);
934 if (qn->
lower == 0) {
938 r = add_state_check_num(reg, ckn);
940 r = add_rel_addr(reg, tlen);
943 r = add_opcode_rel_addr(reg,
OP_PUSH, tlen);
948 r = compile_tree(qn->
target, reg);
954 r = add_state_check_num(reg, ckn);
963 r = add_opcode_rel_addr(reg,
OP_JUMP, tlen);
965 r = compile_tree(qn->
target, reg);
968 r = compile_range_repeat_node(qn, mod_tlen, empty_info, reg);
973 r = add_state_check_num(reg, ckn);
987 int tlen = compile_length_tree(qn->
target, reg);
989 if (tlen < 0)
return tlen;
993 if (qn->
greedy && infinite) {
1001 if (empty_info != 0)
1016#ifdef USE_OP_PUSH_OR_JUMP_EXACT
1032 else if (!infinite && qn->
greedy &&
1055 int tlen = compile_length_tree(qn->
target, reg);
1057 if (tlen < 0)
return tlen;
1059 if (is_anychar_star_quantifier(qn)) {
1060 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
1078 if (empty_info != 0)
1087#ifdef USE_OP_PUSH_OR_JUMP_EXACT
1103 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
1108#ifdef USE_OP_PUSH_OR_JUMP_EXACT
1114 r = compile_tree_empty_check(qn->
target, reg, empty_info);
1116 r = add_opcode_rel_addr(reg,
OP_JUMP,
1126 r = compile_tree_empty_check(qn->
target, reg, empty_info);
1128 r = add_opcode_rel_addr(reg,
OP_JUMP,
1134 r = compile_tree_empty_check(qn->
target, reg, empty_info);
1136 r = add_opcode_rel_addr(reg,
OP_JUMP,
1141 r = add_opcode_rel_addr(reg,
OP_JUMP, mod_tlen);
1143 r = compile_tree_empty_check(qn->
target, reg, empty_info);
1149 r = add_opcode_rel_addr(reg,
OP_JUMP, tlen);
1151 r = compile_tree(qn->
target, reg);
1153 else if (!infinite && qn->
greedy &&
1158 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
1161 for (i = 0; i < n; i++) {
1162 r = add_opcode_rel_addr(reg,
OP_PUSH,
1165 r = compile_tree(qn->
target, reg);
1172 r = add_opcode_rel_addr(reg,
OP_JUMP, tlen);
1174 r = compile_tree(qn->
target, reg);
1177 r = compile_range_repeat_node(qn, mod_tlen, empty_info, reg);
1190 tlen = compile_length_tree(node->
target, reg);
1193 if (tlen < 0)
return tlen;
1219 r = compile_tree(node->
target, reg);
1236 return compile_length_option_node(node, reg);
1239 tlen = compile_length_tree(node->
target, reg);
1240 if (tlen < 0)
return tlen;
1245 switch (node->
type) {
1247#ifdef USE_SUBEXP_CALL
1279 tlen = compile_length_tree(qn->
target, reg);
1280 if (tlen < 0)
return tlen;
1295 tlen = compile_length_tree(
NCAR(x), reg);
1296 if (tlen < 0)
return tlen;
1300 tlen = compile_length_tree(
NCAR(x), reg);
1301 if (tlen < 0)
return tlen;
1322static int get_char_length_tree(
Node* node,
regex_t* reg,
int*
len);
1330 return compile_option_node(node, reg);
1332 switch (node->
type) {
1334#ifdef USE_SUBEXP_CALL
1340 r = add_abs_addr(reg, (
int )node->
call_addr);
1342 len = compile_length_tree(node->
target, reg);
1360 r = add_mem_num(reg, node->
regnum);
1362 r = compile_tree(node->
target, reg);
1364#ifdef USE_SUBEXP_CALL
1374 r = add_mem_num(reg, node->
regnum);
1384 r = add_mem_num(reg, node->
regnum);
1394 r = add_mem_num(reg, node->
regnum);
1401 r = compile_tree_n_times(qn->
target, qn->
lower, reg);
1404 len = compile_length_tree(qn->
target, reg);
1409 r = compile_tree(qn->
target, reg);
1411 r = add_opcode(reg,
OP_POP);
1413 r = add_opcode_rel_addr(reg,
OP_JUMP,
1419 r = compile_tree(node->
target, reg);
1428 r = add_mem_num(reg, node->
regnum);
1435 len = compile_length_tree(
NCAR(x), reg);
1439 len2 = compile_length_tree(
NCAR(x), reg);
1440 if (len2 < 0)
return len2;
1446 r = compile_tree(
NCAR(x), reg);
1448 r = add_opcode_rel_addr(reg,
OP_JUMP, len2);
1451 r = compile_tree(
NCAR(x), reg);
1459 len = compile_length_tree(node->
target, reg);
1466 r = compile_tree(node->
target, reg);
1486 tlen = compile_length_tree(node->
target, reg);
1487 if (tlen < 0)
return tlen;
1490 switch (node->
type) {
1517 switch (node->
type) {
1533#ifdef USE_WORD_BEGIN_END
1548 r = compile_tree(node->
target, reg);
1554 len = compile_length_tree(node->
target, reg);
1558 r = compile_tree(node->
target, reg);
1569 r = get_char_length_tree(node->
target, reg, &n);
1574 r = add_length(reg, n);
1576 r = compile_tree(node->
target, reg);
1583 len = compile_length_tree(node->
target, reg);
1588 r = get_char_length_tree(node->
target, reg, &n);
1593 r = add_length(reg, n);
1595 r = compile_tree(node->
target, reg);
1619 r = compile_length_tree(
NCAR(node), reg);
1620 if (r < 0)
return r;
1631 r = compile_length_tree(
NCAR(node), reg);
1632 if (r < 0)
return r;
1643 r = compile_length_string_raw_node(
NSTR(node), reg);
1645 r = compile_length_string_node(node, reg);
1649 r = compile_length_cclass_node(
NCCLASS(node), reg);
1661#ifdef USE_BACKREF_WITH_LEVEL
1678#ifdef USE_SUBEXP_CALL
1685 r = compile_length_quantifier_node(
NQTFR(node), reg);
1689 r = compile_length_enclose_node(
NENCLOSE(node), reg);
1693 r = compile_length_anchor_node(
NANCHOR(node), reg);
1713 r = compile_tree(
NCAR(node), reg);
1722 len += compile_length_tree(
NCAR(x), reg);
1730 len = compile_length_tree(
NCAR(node), reg);
1735 r = compile_tree(
NCAR(node), reg);
1748 r = compile_string_raw_node(
NSTR(node), reg);
1750 r = compile_string_node(node, reg);
1754 r = compile_cclass_node(
NCCLASS(node), reg);
1761 switch (
NCTYPE(node)->ctype) {
1763 if (
NCTYPE(node)->ascii_range != 0) {
1776 r = add_opcode(reg, op);
1791#ifdef USE_BACKREF_WITH_LEVEL
1800 goto add_bacref_mems;
1809 r = add_mem_num(reg, n);
1818 r = add_mem_num(reg, n);
1835#ifdef USE_BACKREF_WITH_LEVEL
1841 for (i = br->
back_num - 1; i >= 0; i--) {
1842 r = add_mem_num(reg, p[i]);
1849#ifdef USE_SUBEXP_CALL
1851 r = compile_call(
NCALL(node), reg);
1856 r = compile_quantifier_node(
NQTFR(node), reg);
1860 r = compile_enclose_node(
NENCLOSE(node), reg);
1864 r = compile_anchor_node(
NANCHOR(node), reg);
1869 fprintf(stderr,
"compile_tree: undefined node type %d\n",
NTYPE(node));
1877#ifdef USE_NAMED_GROUP
1883 Node* node = *plink;
1885 switch (
NTYPE(node)) {
1889 r = noname_disable_map(&(
NCAR(node)),
map, counter);
1895 Node** ptarget = &(
NQTFR(node)->target);
1896 Node* old = *ptarget;
1897 r = noname_disable_map(ptarget,
map, counter);
1913 else if (en->
regnum != 0) {
1917 r = noname_disable_map(plink,
map, counter);
1921 r = noname_disable_map(&(en->
target),
map, counter);
1927 r = noname_disable_map(&(
NANCHOR(node)->target),
map, counter);
1940 int i, pos, n, old_num;
1953 for (i = 0, pos = 0; i < old_num; i++) {
1955 n =
map[backs[i]].new_val;
1971 switch (
NTYPE(node)) {
1975 r = renumber_by_map(
NCAR(node),
map, num_mem);
1979 r = renumber_by_map(
NQTFR(node)->target,
map, num_mem);
1988 r = renumber_by_map(en->
target,
map, num_mem);
1993 r = renumber_node_backref(node,
map, num_mem);
1998 r = renumber_by_map(
NANCHOR(node)->target,
map, num_mem);
2009numbered_ref_check(
Node* node)
2013 switch (
NTYPE(node)) {
2017 r = numbered_ref_check(
NCAR(node));
2021 r = numbered_ref_check(
NQTFR(node)->target);
2024 r = numbered_ref_check(
NENCLOSE(node)->target);
2034 r = numbered_ref_check(
NANCHOR(node)->target);
2047 int r, i, pos, counter;
2053 for (i = 1; i <=
env->num_mem; i++) {
2057 r = noname_disable_map(
root,
map, &counter);
2058 if (r != 0)
return r;
2060 r = renumber_by_map(*
root,
map,
env->num_mem);
2061 if (r != 0)
return r;
2063 for (i = 1, pos = 1; i <=
env->num_mem; i++) {
2064 if (
map[i].new_val > 0) {
2070 loc =
env->capture_history;
2078 env->num_mem =
env->num_named;
2085#ifdef USE_SUBEXP_CALL
2093 for (i = 0; i < uslist->
num; i++) {
2105#ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
2107quantifiers_memory_node_info(
Node* node)
2111 switch (
NTYPE(node)) {
2117 v = quantifiers_memory_node_info(
NCAR(node));
2123# ifdef USE_SUBEXP_CALL
2129 r = quantifiers_memory_node_info(
NCALL(node)->target);
2136 if (qn->
upper != 0) {
2137 r = quantifiers_memory_node_info(qn->
target);
2154 r = quantifiers_memory_node_info(en->
target);
2183 switch (
NTYPE(node)) {
2194 r = get_min_match_length(nodes[backs[0]], min,
env);
2196 for (i = 1; i < br->
back_num; i++) {
2198 r = get_min_match_length(nodes[backs[i]], &tmin,
env);
2200 if (*min > tmin) *min = tmin;
2205#ifdef USE_SUBEXP_CALL
2213 r = get_min_match_length(
NCALL(node)->target, min,
env);
2219 r = get_min_match_length(
NCAR(node), &tmin,
env);
2220 if (r == 0) *min += tmin;
2230 r = get_min_match_length(x, &tmin,
env);
2232 if (y == node) *min = tmin;
2233 else if (*min > tmin) *min = tmin;
2241 *min = sn->
end - sn->
s;
2258 if (qn->
lower > 0) {
2259 r = get_min_match_length(qn->
target, min,
env);
2261 *min = distance_multiply(*min, qn->
lower);
2278 r = get_min_match_length(en->
target, min,
env);
2291 r = get_min_match_length(en->
target, min,
env);
2315 switch (
NTYPE(node)) {
2318 r = get_max_match_length(
NCAR(node), &tmax,
env);
2320 *
max = distance_add(*
max, tmax);
2326 r = get_max_match_length(
NCAR(node), &tmax,
env);
2327 if (r == 0 && *
max < tmax) *
max = tmax;
2358 for (i = 0; i < br->
back_num; i++) {
2360 r = get_max_match_length(nodes[backs[i]], &tmax,
env);
2362 if (*
max < tmax) *
max = tmax;
2367#ifdef USE_SUBEXP_CALL
2370 r = get_max_match_length(
NCALL(node)->target,
max,
env);
2380 if (qn->
upper != 0) {
2382 if (r == 0 && *
max != 0) {
2434#define GET_CHAR_LEN_VARLEN -1
2435#define GET_CHAR_LEN_TOP_ALT_VARLEN -2
2439get_char_length_tree1(
Node* node,
regex_t* reg,
int*
len,
int level)
2446 switch (
NTYPE(node)) {
2449 r = get_char_length_tree1(
NCAR(node), reg, &tlen, level);
2460 r = get_char_length_tree1(
NCAR(node), reg, &tlen, level);
2462 r = get_char_length_tree1(
NCAR(node), reg, &tlen2, level);
2485 while (s < sn->end) {
2496 r = get_char_length_tree1(qn->
target, reg, &tlen, level);
2505#ifdef USE_SUBEXP_CALL
2508 r = get_char_length_tree1(
NCALL(node)->target, reg,
len, level);
2528#ifdef USE_SUBEXP_CALL
2532 r = get_char_length_tree1(en->
target, reg,
len, level);
2543 r = get_char_length_tree1(en->
target, reg,
len, level);
2566 return get_char_length_tree1(node, reg,
len, 0);
2598 tmp = x; x = y; y = tmp;
2618 switch (
NCTYPE(y)->ctype) {
2620 if (
NCTYPE(y)->not == 0) {
2624 if (
NCTYPE(y)->ascii_range) {
2640 if (
NCTYPE(y)->ascii_range)
2704 switch (
NCTYPE(y)->ctype) {
2706 if (
NCTYPE(y)->ascii_range) {
2710 return !(
NCTYPE(y)->not);
2716 return !(
NCTYPE(y)->not);
2746 if (*p != *q)
return 1;
2766get_head_value_node(
Node* node,
int exact,
regex_t* reg)
2770 switch (
NTYPE(node)) {
2774#ifdef USE_SUBEXP_CALL
2787 n = get_head_value_node(
NCAR(node), exact, reg);
2794 if (sn->
end <= sn->
s)
2809 if (qn->
lower > 0) {
2810#ifdef USE_OP_PUSH_OR_JUMP_EXACT
2815 n = get_head_value_node(qn->
target, exact, reg);
2829 n = get_head_value_node(
NENCLOSE(node)->target, exact, reg);
2837 n = get_head_value_node(en->
target, exact, reg);
2848 n = get_head_value_node(
NANCHOR(node)->target, exact, reg);
2859check_type_tree(
Node* node,
int type_mask,
int enclose_mask,
int anchor_mask)
2871 r = check_type_tree(
NCAR(node), type_mask, enclose_mask,
2877 r = check_type_tree(
NQTFR(node)->target, type_mask, enclose_mask,
2884 if ((en->
type & enclose_mask) == 0)
2887 r = check_type_tree(en->
target, type_mask, enclose_mask, anchor_mask);
2893 if ((type & anchor_mask) == 0)
2897 r = check_type_tree(
NANCHOR(node)->target,
2898 type_mask, enclose_mask, anchor_mask);
2907#ifdef USE_SUBEXP_CALL
2909# define RECURSION_EXIST 1
2910# define RECURSION_INFINITE 2
2928 ret = subexp_inf_recursive_check(
NCAR(x),
env, head);
2932 ret = get_min_match_length(
NCAR(x), &min,
env);
2933 if (ret != 0)
return ret;
2934 if (min != 0) head = 0;
2945 ret = subexp_inf_recursive_check(
NCAR(node),
env, head);
2953 r = subexp_inf_recursive_check(
NQTFR(node)->target,
env, head);
2955 if (
NQTFR(node)->lower == 0) r = 0;
2967 r = subexp_inf_recursive_check(an->
target,
env, head);
2974 r = subexp_inf_recursive_check(
NCALL(node)->target,
env, head);
2984 r = subexp_inf_recursive_check(
NENCLOSE(node)->target,
env, head);
3007 r = subexp_inf_recursive_check_trav(
NCAR(node),
env);
3012 r = subexp_inf_recursive_check_trav(
NQTFR(node)->target,
env);
3023 r = subexp_inf_recursive_check_trav(an->
target,
env);
3035 r = subexp_inf_recursive_check(en->
target,
env, 1);
3039 r = subexp_inf_recursive_check_trav(en->
target,
env);
3052subexp_recursive_check(
Node* node)
3056 switch (
NTYPE(node)) {
3060 r |= subexp_recursive_check(
NCAR(node));
3065 r = subexp_recursive_check(
NQTFR(node)->target);
3076 r = subexp_recursive_check(an->
target);
3083 r = subexp_recursive_check(
NCALL(node)->target);
3094 r = subexp_recursive_check(
NENCLOSE(node)->target);
3110# define FOUND_CALLED_NODE 1
3122 ret = subexp_recursive_check_trav(
NCAR(node),
env);
3124 else if (ret < 0)
return ret;
3130 r = subexp_recursive_check_trav(
NQTFR(node)->target,
env);
3131 if (
NQTFR(node)->upper == 0) {
3133 NQTFR(node)->is_referred = 1;
3145 r = subexp_recursive_check_trav(an->
target,
env);
3158 r = subexp_recursive_check(en->
target);
3163 r = subexp_recursive_check_trav(en->
target,
env);
3186 r = setup_subexp_call(
NCAR(node),
env);
3192 r = setup_subexp_call(
NCAR(node),
env);
3197 r = setup_subexp_call(
NQTFR(node)->target,
env);
3200 r = setup_subexp_call(
NENCLOSE(node)->target,
env);
3211# ifdef USE_NAMED_GROUP
3212 if (
env->num_named > 0 &&
3218 if (gnum >
env->num_mem) {
3224# ifdef USE_NAMED_GROUP
3237# ifdef USE_NAMED_GROUP
3238# ifdef USE_PERL_SUBEXP_CALL
3296divide_look_behind_alternatives(
Node* node)
3298 Node *head, *np, *insert_node;
3300 int anc_type = an->
type;
3304 swap_node(node, head);
3313 NCAR(np) = insert_node;
3331 r = get_char_length_tree(an->
target, reg, &
len);
3338 r = divide_look_behind_alternatives(node);
3356#ifdef USE_QTFR_PEEK_NEXT
3357 Node* n = get_head_value_node(next_node, 1, reg);
3364 if (qn->
lower <= 1) {
3368 x = get_head_value_node(qn->
target, 0, reg);
3370 y = get_head_value_node(next_node, 0, reg);
3371 if (
IS_NOT_NULL(y) && is_not_included(x, y, reg)) {
3375 swap_node(node, en);
3395update_string_node_case_fold(
regex_t* reg,
Node *node)
3398 UChar *sbuf, *ebuf, *sp;
3404 sbuf_size = (end - sn->
s) * 2;
3407 ebuf = sbuf + sbuf_size;
3413 for (i = 0; i <
len; i++) {
3421 sp = sbuf + sbuf_size;
3423 ebuf = sbuf + sbuf_size;
3437expand_case_fold_make_rem_string(
Node** rnode,
UChar *s,
UChar *end,
3446 r = update_string_node_case_fold(reg, node);
3464 for (i = 0; i < item_num; i++) {
3465 if (items[i].byte_len != slen) {
3468 if (items[i].code_len != 1) {
3480 int r, i, j,
len, varlen;
3481 Node *anode, *var_anode, *snode, *xnode, *an;
3487 for (i = 0; i < item_num; i++) {
3488 if (items[i].byte_len != slen) {
3499 if (
IS_NULL(xnode))
goto mem_err;
3500 NCAR(var_anode) = xnode;
3503 if (
IS_NULL(anode))
goto mem_err;
3504 NCAR(xnode) = anode;
3512 if (
IS_NULL(snode))
goto mem_err;
3514 NCAR(anode) = snode;
3516 for (i = 0; i < item_num; i++) {
3518 if (
IS_NULL(snode))
goto mem_err;
3520 for (j = 0; j < items[i].
code_len; j++) {
3528 if (r != 0)
goto mem_err2;
3536 if (items[i].byte_len != slen) {
3541 r = expand_case_fold_make_rem_string(&rem, q, end, reg);
3566 NCDR(var_anode) = an;
3590#define THRESHOLD_CASE_FOLD_ALT_FOR_EXPANSION 8
3592 int r, n,
len, alt_num;
3594 UChar *start, *end, *p;
3595 Node *top_root, *
root, *snode, *prev_node;
3603 if (start >= end)
return 0;
3619 varlen = is_case_fold_variable_len(n, items,
len);
3620 if (n == 0 || varlen == 0) {
3632 if (
IS_NULL(snode))
goto mem_err;
3642 if (r != 0)
goto err;
3649 r = update_string_node_case_fold(reg, snode);
3663 r = expand_case_fold_string_alt(n, items, p,
len, end, reg, &prev_node);
3664 if (r < 0)
goto mem_err;
3667 top_root = prev_node;
3693 r = update_string_node_case_fold(reg, snode);
3702 r = expand_case_fold_make_rem_string(&srem, p, end, reg);
3703 if (r != 0)
goto mem_err;
3727 top_root = (
IS_NOT_NULL(top_root) ? top_root : prev_node);
3728 swap_node(node, top_root);
3741#ifdef USE_COMBINATION_EXPLOSION_CHECK
3743# define CEC_THRES_NUM_BIG_REPEAT 512
3744# define CEC_INFINITE_NUM 0x7fffffff
3746# define CEC_IN_INFINITE_REPEAT (1<<0)
3747# define CEC_IN_FINITE_REPEAT (1<<1)
3748# define CEC_CONT_BIG_REPEAT (1<<2)
3762 r = setup_comb_exp_check(
NCAR(node), r,
env);
3780 int child_state =
state;
3787 if (qn->
upper > 1) {
3789 child_state |= CEC_IN_FINITE_REPEAT;
3792 if (
env->backrefed_mem == 0) {
3802 child_state =
state;
3811 if (
state & CEC_IN_FINITE_REPEAT) {
3812 qn->comb_exp_check_num = -1;
3816 var_num = CEC_INFINITE_NUM;
3817 child_state |= CEC_IN_INFINITE_REPEAT;
3823 if (var_num >= CEC_THRES_NUM_BIG_REPEAT)
3824 add_state |= CEC_CONT_BIG_REPEAT;
3826 if (((
state & CEC_IN_INFINITE_REPEAT) != 0 && var_num != 0) ||
3827 ((
state & CEC_CONT_BIG_REPEAT) != 0 &&
3828 var_num >= CEC_THRES_NUM_BIG_REPEAT)) {
3829 if (qn->comb_exp_check_num == 0) {
3830 env->num_comb_exp_check++;
3831 qn->comb_exp_check_num =
env->num_comb_exp_check;
3832 if (
env->curr_max_regnum >
env->comb_exp_max_regnum)
3833 env->comb_exp_max_regnum =
env->curr_max_regnum;
3838 r = setup_comb_exp_check(target, child_state,
env);
3864# ifdef USE_SUBEXP_CALL
3867 env->has_recursion = 1;
3881#define IN_ALT (1<<0)
3882#define IN_NOT (1<<1)
3883#define IN_REPEAT (1<<2)
3884#define IN_VAR_REPEAT (1<<3)
3885#define IN_CALL (1<<4)
3886#define IN_RECCALL (1<<5)
3911 r = next_setup(prev,
NCAR(node), reg);
3929 r = expand_case_fold_string(node, reg);
3937#ifdef USE_SUBEXP_CALL
3949 for (i = 0; i < br->
back_num; i++) {
3953#ifdef USE_BACKREF_WITH_LEVEL
3974 r = get_min_match_length(target, &d,
env);
3978#ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
3979 r = quantifiers_memory_node_info(target);
3986 r = get_max_match_length(target, &d,
env);
3987 if (r == 0 && d == 0) {
4002 r = setup_tree(target, reg,
state,
env);
4006#define EXPAND_STRING_MAX_LENGTH 100
4008 if (qn->
lower > 1) {
4009 int i, n = qn->
lower;
4037 swap_node(np1, node);
4045 swap_node(np, node);
4052#ifdef USE_OP_PUSH_OR_JUMP_EXACT
4100 r = setup_tree(target, reg,
state,
env);
4114#ifdef USE_NAMED_GROUP
4116 env->num_named > 0 &&
4147#define ALLOWED_TYPE_IN_LB \
4148 ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \
4149 BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL )
4151#define ALLOWED_ENCLOSE_IN_LB ( ENCLOSE_MEMORY | ENCLOSE_OPTION )
4152#define ALLOWED_ENCLOSE_IN_LB_NOT ENCLOSE_OPTION
4154#define ALLOWED_ANCHOR_IN_LB \
4155( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \
4156 ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \
4157 ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \
4158 ANCHOR_WORD_BEGIN | ANCHOR_WORD_END )
4159#define ALLOWED_ANCHOR_IN_LB_NOT \
4160( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \
4161 ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \
4162 ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \
4163 ANCHOR_WORD_BEGIN | ANCHOR_WORD_END )
4169 if (r < 0)
return r;
4173 if (r != 0)
return r;
4174 r = setup_look_behind(node, reg,
env);
4182 if (r < 0)
return r;
4186 if (r != 0)
return r;
4187 r = setup_look_behind(node, reg,
env);
4201#ifndef USE_SUNDAY_QUICK_SEARCH
4205 UChar skip[],
int** int_skip,
int ignore_case)
4208 int clen, flen, n, j, k;
4218 for (i = 0; i <
len - 1; i += clen) {
4223 clen =
enclen(enc, p, end);
4225 clen = (
int )(end - p);
4227 for (j = 0; j < n; j++) {
4228 if ((items[j].code_len != 1) || (items[j].
byte_len != clen))
4234 for (j = 0; j < clen; j++) {
4236 for (k = 0; k < n; k++) {
4243# if OPT_EXACT_MAXLEN < ONIG_CHAR_TABLE_SIZE
4254 for (i = 0; i <
len - 1; i += clen) {
4259 clen =
enclen(enc, p, end);
4261 clen = (
int )(end - p);
4263 for (j = 0; j < n; j++) {
4264 if ((items[j].code_len != 1) || (items[j].
byte_len != clen))
4270 for (j = 0; j < clen; j++) {
4271 (*int_skip)[s[i + j]] = (
int )(
len - 1 - i - j);
4272 for (k = 0; k < n; k++) {
4273 (*int_skip)[
buf[k][j]] = (
int )(
len - 1 - i - j);
4287 UChar skip[],
int** int_skip,
int ignore_case)
4290 int clen, flen, n, j, k;
4300 for (i = 0; i <
len; i += clen) {
4305 clen =
enclen(enc, p, end);
4307 clen = (
int )(end - p);
4309 for (j = 0; j < n; j++) {
4310 if ((items[j].code_len != 1) || (items[j].
byte_len != clen))
4316 for (j = 0; j < clen; j++) {
4318 for (k = 0; k < n; k++) {
4325# if OPT_EXACT_MAXLEN < ONIG_CHAR_TABLE_SIZE
4336 for (i = 0; i <
len; i += clen) {
4341 clen =
enclen(enc, p, end);
4343 clen = (
int )(end - p);
4345 for (j = 0; j < n; j++) {
4346 if ((items[j].code_len != 1) || (items[j].
byte_len != clen))
4352 for (j = 0; j < clen; j++) {
4353 (*int_skip)[s[i + j]] = (
int )(
len - i - j);
4354 for (k = 0; k < n; k++) {
4355 (*int_skip)[
buf[k][j]] = (
int )(
len - i - j);
4416 static const short int ByteValTable[] = {
4417 5, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 1, 1, 10, 1, 1,
4418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4419 12, 4, 7, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
4420 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5,
4421 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
4422 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 5, 5, 5,
4423 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
4424 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 1
4431 return (
int )ByteValTable[i];
4441 static const short int dist_vals[] = {
4442 1000, 500, 333, 250, 200, 167, 143, 125, 111, 100,
4443 91, 83, 77, 71, 67, 63, 59, 56, 53, 50,
4444 48, 45, 43, 42, 40, 38, 37, 36, 34, 33,
4445 32, 31, 30, 29, 29, 28, 27, 26, 26, 25,
4446 24, 24, 23, 23, 22, 22, 21, 21, 20, 20,
4447 20, 19, 19, 19, 18, 18, 18, 17, 17, 17,
4448 16, 16, 16, 16, 15, 15, 15, 15, 14, 14,
4449 14, 14, 14, 14, 13, 13, 13, 13, 13, 13,
4450 12, 12, 12, 12, 12, 12, 11, 11, 11, 11,
4451 11, 11, 11, 11, 11, 10, 10, 10, 10, 10
4461 return (
int )dist_vals[d];
4469 if (v2 <= 0)
return -1;
4470 if (v1 <= 0)
return 1;
4472 v1 *= distance_value(
d1);
4473 v2 *= distance_value(d2);
4475 if (v2 > v1)
return 1;
4476 if (v2 < v1)
return -1;
4478 if (d2->
min <
d1->min)
return 1;
4479 if (d2->
min >
d1->min)
return -1;
4513 to->
min = distance_add(to->
min, from->
min);
4514 to->
max = distance_add(to->
max, from->
max);
4556 clear_opt_anc_info(to);
4559 if (left_len == 0) {
4564 if (right_len == 0) {
4573is_left_anchor(
int anc)
4594 if (is_left_anchor(anc))
4603 if (is_left_anchor(anc))
4625 clear_mml(&ex->
mmd);
4626 clear_opt_anc_info(&ex->
anc);
4653 for (i = to->
len; p < end; ) {
4656 for (j = 0; j <
len && p < end; j++)
4663 concat_opt_anc_info(&tanc, &to->
anc, &
add->anc, 1, 1);
4665 copy_opt_anc_info(&to->
anc, &tanc);
4678 for (j = 0; j <
len && p < end; j++)
4690 if (
add->len == 0 || to->
len == 0) {
4691 clear_opt_exact_info(to);
4695 if (! is_equal_mml(&to->
mmd, &
add->mmd)) {
4696 clear_opt_exact_info(to);
4700 for (i = 0; i < to->
len && i <
add->len; ) {
4701 if (to->
s[i] !=
add->s[i])
break;
4704 for (j = 1; j <
len; j++) {
4705 if (to->
s[i+j] !=
add->s[i+j])
break;
4711 if (!
add->reach_end || i < add->
len || i < to->
len) {
4717 else if (
add->ignore_case >= 0)
4720 alt_merge_opt_anc_info(&to->
anc, &
add->anc);
4736 copy_opt_exact_info(now, alt);
4739 else if (v1 <= 2 && v2 <= 2) {
4741 v2 = map_position_value(enc, now->
s[0]);
4742 v1 = map_position_value(enc, alt->
s[0]);
4744 if (now->
len > 1) v1 += 5;
4745 if (alt->
len > 1) v2 += 5;
4751 if (comp_distance_value(&now->
mmd, &alt->
mmd, v1, v2) > 0)
4752 copy_opt_exact_info(now, alt);
4761 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4762 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4763 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4764 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4765 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4766 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4767 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4768 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4769 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4770 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4771 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4772 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4773 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4774 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4775 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4776 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
4792 if (
map->map[c] == 0) {
4794 map->value += map_position_value(enc, c);
4806 add_char_opt_map_info(
map, p[0], enc);
4810 if (n < 0)
return n;
4812 for (i = 0; i < n; i++) {
4814 add_char_opt_map_info(
map,
buf[0], enc);
4823 const int z = 1<<15;
4827 if (alt->
value == 0) return ;
4828 if (now->
value == 0) {
4829 copy_opt_map_info(now, alt);
4833 v1 = z / now->
value;
4834 v2 = z / alt->
value;
4835 if (comp_distance_value(&now->
mmd, &alt->
mmd, v1, v2) > 0)
4836 copy_opt_map_info(now, alt);
4842#define COMP_EM_BASE 20
4845 if (m->
value <= 0)
return -1;
4849 return comp_distance_value(&e->
mmd, &m->
mmd, ve, vm);
4858 if (to->
value == 0) return ;
4860 clear_opt_map_info(to);
4864 alt_merge_mml(&to->
mmd, &
add->mmd);
4872 val += map_position_value(enc, i);
4876 alt_merge_opt_anc_info(&to->
anc, &
add->anc);
4882 copy_mml(&(opt->
exb.
mmd), mmd);
4883 copy_mml(&(opt->
expr.
mmd), mmd);
4884 copy_mml(&(opt->
map.
mmd), mmd);
4890 clear_mml(&opt->
len);
4891 clear_opt_anc_info(&opt->
anc);
4892 clear_opt_exact_info(&opt->
exb);
4893 clear_opt_exact_info(&opt->
exm);
4894 clear_opt_exact_info(&opt->
expr);
4895 clear_opt_map_info(&opt->
map);
4907 int exb_reach, exm_reach;
4910 concat_opt_anc_info(&tanc, &to->
anc, &
add->anc, to->
len.
max,
add->len.max);
4911 copy_opt_anc_info(&to->
anc, &tanc);
4913 if (
add->exb.len > 0 && to->
len.
max == 0) {
4914 concat_opt_anc_info(&tanc, &to->
anc, &
add->exb.anc,
4916 copy_opt_anc_info(&
add->exb.anc, &tanc);
4919 if (
add->map.value > 0 && to->
len.
max == 0) {
4920 if (
add->map.mmd.max == 0)
4927 if (
add->len.max != 0)
4930 if (
add->exb.len > 0) {
4932 concat_opt_exact_info(&to->
exb, &
add->exb, enc);
4933 clear_opt_exact_info(&
add->exb);
4935 else if (exm_reach) {
4936 concat_opt_exact_info(&to->
exm, &
add->exb, enc);
4937 clear_opt_exact_info(&
add->exb);
4940 select_opt_exact_info(enc, &to->
exm, &
add->exb);
4941 select_opt_exact_info(enc, &to->
exm, &
add->exm);
4944 if (
add->len.max > 0) {
4949 select_opt_exact_info(enc, &to->
exb, &to->
expr);
4951 select_opt_exact_info(enc, &to->
exm, &to->
expr);
4954 else if (
add->expr.len > 0) {
4955 copy_opt_exact_info(&to->
expr, &
add->expr);
4958 select_opt_map_info(&to->
map, &
add->map);
4960 add_mml(&to->
len, &
add->len);
4966 alt_merge_opt_anc_info (&to->
anc, &
add->anc);
4967 alt_merge_opt_exact_info(&to->
exb, &
add->exb,
env);
4968 alt_merge_opt_exact_info(&to->
exm, &
add->exm,
env);
4969 alt_merge_opt_exact_info(&to->
expr, &
add->expr,
env);
4970 alt_merge_opt_map_info(
env->enc, &to->
map, &
add->map);
4972 alt_merge_mml(&to->
len, &
add->len);
4976#define MAX_NODE_OPT_INFO_REF_COUNT 5
4984 clear_node_opt_info(opt);
4985 set_bound_node_opt_info(opt, &
env->mmd);
4995 copy_opt_env(&nenv,
env);
4997 r = optimize_node_left(
NCAR(nd), &nopt, &nenv);
4999 add_mml(&nenv.
mmd, &nopt.
len);
5000 concat_left_node_opt_info(
env->enc, opt, &nopt);
5012 r = optimize_node_left(
NCAR(nd), &nopt,
env);
5014 if (nd == node) copy_node_opt_info(opt, &nopt);
5015 else alt_merge_node_opt_info(opt, &nopt,
env);
5028 concat_opt_exact_info_str(&opt->
exb, sn->
s, sn->
end,
5032 add_char_opt_map_info(&opt->
map, *(sn->
s),
env->enc);
5034 set_mml(&opt->
len, slen, slen);
5044 concat_opt_exact_info_str(&opt->
exb, sn->
s, sn->
end,
5049 r = add_char_amb_opt_map_info(&opt->
map, sn->
s, sn->
end,
5050 env->enc,
env->case_fold_flag);
5057 set_mml(&opt->
len, slen,
max);
5076 set_mml(&opt->
len, min,
max);
5082 add_char_opt_map_info(&opt->
map, (
UChar )i,
env->enc);
5085 set_mml(&opt->
len, 1, 1);
5101 switch (
NCTYPE(node)->ctype) {
5103 if (
NCTYPE(node)->not != 0) {
5106 add_char_opt_map_info(&opt->
map, (
UChar )i,
env->enc);
5111 for (i = 0; i < maxcode; i++) {
5113 add_char_opt_map_info(&opt->
map, (
UChar )i,
env->enc);
5123 set_mml(&opt->
len, min,
max);
5131 set_mml(&opt->
len, min,
max);
5136 switch (
NANCHOR(node)->type) {
5145 add_opt_anc_info(&opt->
anc,
NANCHOR(node)->type);
5152 r = optimize_node_left(
NANCHOR(node)->target, &nopt,
env);
5155 copy_opt_exact_info(&opt->
expr, &nopt.
exb);
5156 else if (nopt.
exm.
len > 0)
5157 copy_opt_exact_info(&opt->
expr, &nopt.
exm);
5162 copy_opt_map_info(&opt->
map, &nopt.
map);
5185 r = get_min_match_length(nodes[backs[0]], &min,
env->scan_env);
5187 r = get_max_match_length(nodes[backs[0]], &
max,
env->scan_env);
5189 for (i = 1; i < br->
back_num; i++) {
5190 r = get_min_match_length(nodes[backs[i]], &tmin,
env->scan_env);
5192 r = get_max_match_length(nodes[backs[i]], &tmax,
env->scan_env);
5194 if (min > tmin) min = tmin;
5195 if (
max < tmax)
max = tmax;
5197 if (r == 0) set_mml(&opt->
len, min,
max);
5201#ifdef USE_SUBEXP_CALL
5208 r = optimize_node_left(
NCALL(node)->target, opt,
env);
5209 env->options = save;
5221 r = optimize_node_left(qn->
target, &nopt,
env);
5225 if (
env->mmd.max == 0 &&
5235 if (qn->
lower > 0) {
5236 copy_node_opt_info(opt, &nopt);
5239 for (i = 2; i <= qn->
lower &&
5240 ! is_full_opt_exact_info(&opt->
exb); i++) {
5241 concat_opt_exact_info(&opt->
exb, &nopt.
exb,
env->enc);
5243 if (i < qn->lower) {
5264 set_mml(&opt->
len, min,
max);
5278 r = optimize_node_left(en->
target, opt,
env);
5279 env->options = save;
5284#ifdef USE_SUBEXP_CALL
5293 set_mml(&opt->
len, min,
max);
5298 r = optimize_node_left(en->
target, opt,
env);
5309 r = optimize_node_left(en->
target, opt,
env);
5321 fprintf(stderr,
"optimize_node_left: undefined node type %d\n",
5337 if (e->
len == 0)
return 0;
5348 if (e->
len >= 3 || (e->
len >= 2 && allow_reverse)) {
5352 reg->
optimize = (allow_reverse != 0
5364 if (e->
len >= 3 || (e->
len >= 2 && allow_reverse)) {
5368 reg->
optimize = (allow_reverse != 0
5414#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH)
5429 env.scan_env = scan_env;
5430 clear_mml(&
env.mmd);
5432 r = optimize_node_left(node, &opt, &
env);
5451 select_opt_exact_info(reg->
enc, &opt.
exb, &opt.
exm);
5453 comp_opt_exact_or_map_info(&opt.
exb, &opt.
map) > 0) {
5457 r = set_optimize_exact_info(reg, &opt.
exb);
5458 set_sub_anchor(reg, &opt.
exb.
anc);
5463 set_optimize_map_info(reg, &opt.
map);
5464 set_sub_anchor(reg, &opt.
map.
anc);
5472#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH)
5473 print_optimize_info(stderr, reg);
5479clear_optimize_info(
regex_t* reg)
5499 fprintf(fp,
"\nPATTERN: /");
5509 fprintf(fp,
" 0x%04x ", (
int )
code);
5512 fputc((
int )
code, fp);
5515 p +=
enclen(enc, p, end);
5520 fputc((
int )*s, fp);
5525 fprintf(fp,
"/ (%s)\n", enc->
name);
5529#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH)
5547print_anchor(
FILE*
f,
int anchor)
5554 fprintf(
f,
"begin-buf");
5558 if (q) fprintf(
f,
", ");
5560 fprintf(
f,
"begin-line");
5563 if (q) fprintf(
f,
", ");
5565 fprintf(
f,
"begin-pos");
5568 if (q) fprintf(
f,
", ");
5570 fprintf(
f,
"end-buf");
5573 if (q) fprintf(
f,
", ");
5575 fprintf(
f,
"semi-end-buf");
5578 if (q) fprintf(
f,
", ");
5580 fprintf(
f,
"end-line");
5583 if (q) fprintf(
f,
", ");
5585 fprintf(
f,
"anychar-star");
5588 if (q) fprintf(
f,
", ");
5589 fprintf(
f,
"anychar-star-ml");
5598 static const char* on[] = {
"NONE",
"EXACT",
"EXACT_BM",
"EXACT_BM_NOT_REV",
5600 "EXACT_BM_IC",
"EXACT_BM_NOT_REV_IC" };
5602 fprintf(
f,
"optimize: %s\n", on[reg->
optimize]);
5603 fprintf(
f,
" anchor: "); print_anchor(
f, reg->
anchor);
5609 fprintf(
f,
" sub anchor: "); print_anchor(
f, reg->
sub_anchor);
5616 fprintf(
f,
"exact: [");
5617 for (p = reg->
exact; p < reg->exact_end; p++) {
5626 if (reg->
map[i]) n++;
5628 fprintf(
f,
"map: n=%d\n", n);
5633 if (reg->
map[i] != 0) {
5634 if (c > 0) fputs(
", ",
f);
5640 fprintf(
f,
"%d", i);
5661#ifdef USE_NAMED_GROUP
5695 size_t size =
sizeof(*regs);
5702#define REGEX_TRANSFER(to,from) do {\
5703 onig_free_body(to);\
5704 xmemcpy(to, from, sizeof(regex_t));\
5716#ifdef ONIG_DEBUG_COMPILE
5717static void print_compiled_byte_code_list(
FILE*
f,
regex_t* reg);
5719#ifdef ONIG_DEBUG_PARSE_TREE
5720static void print_tree(
FILE*
f,
Node* node);
5735 OnigErrorInfo* einfo,
const char *sourcefile,
int sourceline)
5742#define COMPILE_INIT_SIZE 20
5748#ifdef USE_SUBEXP_CALL
5760 print_enc_string(stderr, reg->
enc, pattern, pattern_end);
5763 if (reg->
alloc == 0) {
5764 init_size = (pattern_end - pattern) * 2;
5767 if (r != 0)
goto end;
5777#ifdef USE_COMBINATION_EXPLOSION_CHECK
5782 if (r != 0)
goto err;
5784#ifdef ONIG_DEBUG_PARSE_TREE
5786 fprintf(stderr,
"ORIGINAL PARSE TREE:\n");
5787 print_tree(stderr,
root);
5791#ifdef USE_NAMED_GROUP
5797 r = disable_noname_group_capture(&
root, reg, &scan_env);
5799 r = numbered_ref_check(
root);
5801 if (r != 0)
goto err;
5805#ifdef USE_SUBEXP_CALL
5807 r = unset_addr_list_init(&uslist, scan_env.
num_call);
5808 if (r != 0)
goto err;
5810 r = setup_subexp_call(
root, &scan_env);
5811 if (r != 0)
goto err_unset;
5812 r = subexp_recursive_check_trav(
root, &scan_env);
5813 if (r < 0)
goto err_unset;
5814 r = subexp_inf_recursive_check_trav(
root, &scan_env);
5815 if (r != 0)
goto err_unset;
5823 r = setup_tree(
root, reg, 0, &scan_env);
5824 if (r != 0)
goto err_unset;
5826#ifdef ONIG_DEBUG_PARSE_TREE
5827 print_tree(stderr,
root);
5840#ifdef USE_COMBINATION_EXPLOSION_CHECK
5846 setup_comb_exp_check(
root, 0, &scan_env);
5847# ifdef USE_SUBEXP_CALL
5848 if (scan_env.has_recursion != 0) {
5849 scan_env.num_comb_exp_check = 0;
5853 if (scan_env.comb_exp_max_regnum > 0) {
5855 for (i = 1; i <= scan_env.comb_exp_max_regnum; i++) {
5857 scan_env.num_comb_exp_check = 0;
5867 clear_optimize_info(reg);
5868#ifndef ONIG_DONT_OPTIMIZE
5869 r = set_optimize_info_from_tree(
root, reg, &scan_env);
5870 if (r != 0)
goto err_unset;
5878 r = compile_tree(
root, reg);
5880 r = add_opcode(reg,
OP_END);
5881#ifdef USE_SUBEXP_CALL
5883 r = unset_addr_list_fix(&uslist, reg);
5884 unset_addr_list_end(&uslist);
5898#ifdef USE_SUBEXP_CALL
5900 unset_addr_list_end(&uslist);
5905#ifdef ONIG_DEBUG_COMPILE
5906# ifdef USE_NAMED_GROUP
5907 onig_print_names(stderr, reg);
5909 print_compiled_byte_code_list(stderr, reg);
5913 onig_reg_resize(reg);
5917#ifdef USE_SUBEXP_CALL
5919 unset_addr_list_end(&uslist);
5925 einfo->
enc = scan_env.
enc;
5937static int onig_inited = 0;
5960 option &= ~ONIG_OPTION_SINGLELINE;
5966 (reg)->options = option;
5967 (reg)->syntax = syntax;
5968 (reg)->optimize = 0;
5970 (reg)->int_map = (
int* )
NULL;
5971 (reg)->int_map_backward = (
int* )
NULL;
5977 (reg)->name_table = (
void* )
NULL;
5979 (reg)->case_fold_flag = case_fold_flag;
6028 if (onig_inited != 0)
6033#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER)
6034 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
6040#ifdef ONIG_DEBUG_STATISTICS
6041 onig_statistics_init();
6055 if (item == 0) return ;
6057 item->
next = EndCallTop;
6064exec_end_call_list(
void)
6069 while (EndCallTop != 0) {
6070 func = EndCallTop->
func;
6074 EndCallTop = EndCallTop->
next;
6082 exec_end_call_list();
6084#ifdef ONIG_DEBUG_STATISTICS
6085 onig_print_statistics(stderr);
6088#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER)
6089 _CrtDumpMemoryLeaks();
6107 for (low = 0, high = n; low < high; ) {
6108 x = (low + high) >> 1;
6109 if (
code > data[x * 2 + 1])
6115 return ((low < n && code >= data[low * 2]) ? 1 : 0);
6159# define ARG_SPECIAL -1
6161# define ARG_RELADDR 1
6162# define ARG_ABSADDR 2
6163# define ARG_LENGTH 3
6164# define ARG_MEMNUM 4
6165# define ARG_OPTION 5
6166# define ARG_STATE_CHECK 6
6168OnigOpInfoType OnigOpInfo[] = {
6170 {
OP_END,
"end", ARG_NON },
6232 {
OP_JUMP,
"jump", ARG_RELADDR },
6233 {
OP_PUSH,
"push", ARG_RELADDR },
6234 {
OP_POP,
"pop", ARG_NON },
6259 {
OP_CALL,
"call", ARG_ABSADDR },
6267 "state-check-anychar-ml*", ARG_STATE_CHECK },
6276 for (i = 0; OnigOpInfo[i].opcode >= 0; i++) {
6277 if (opcode == OnigOpInfo[i].opcode)
6278 return OnigOpInfo[i].name;
6284op2arg_type(
int opcode)
6288 for (i = 0; OnigOpInfo[i].opcode >= 0; i++) {
6289 if (opcode == OnigOpInfo[i].opcode)
6290 return OnigOpInfo[i].arg_type;
6295# ifdef ONIG_DEBUG_PARSE_TREE
6297Indent(
FILE*
f,
int indent)
6300 for (i = 0; i < indent; i++) putc(
' ',
f);
6308 while (
len-- > 0) { fputc(*s++,
f); }
6314 int x =
len * mb_len;
6316 fprintf(
f,
":%d:",
len);
6317 while (x-- > 0) { fputc(*s++,
f); }
6332 fprintf(
f,
"[%s", op2name(*
bp));
6333 arg_type = op2arg_type(*
bp);
6334 if (arg_type != ARG_SPECIAL) {
6341 fprintf(
f,
":(%s%d)", (addr >= 0) ?
"+" :
"", addr);
6345 fprintf(
f,
":(%d)", addr);
6349 fprintf(
f,
":%d",
len);
6354 fprintf(
f,
":%d", mem);
6360 fprintf(
f,
":%d", option);
6364 case ARG_STATE_CHECK:
6367 fprintf(
f,
":%d", scn);
6376 p_string(
f, 1,
bp++);
break;
6378 p_string(
f, 2,
bp);
bp += 2;
break;
6380 p_string(
f, 3,
bp);
bp += 3;
break;
6382 p_string(
f, 4,
bp);
bp += 4;
break;
6384 p_string(
f, 5,
bp);
bp += 5;
break;
6387 p_len_string(
f,
len, 1,
bp);
6392 p_string(
f, 2,
bp);
bp += 2;
break;
6394 p_string(
f, 4,
bp);
bp += 4;
break;
6396 p_string(
f, 6,
bp);
bp += 6;
break;
6399 p_len_string(
f,
len, 2,
bp);
6404 p_len_string(
f,
len, 3,
bp);
6413 fprintf(
f,
":%d:%d:", mb_len,
len);
6415 while (n-- > 0) { fputc(*
bp++,
f); }
6426 p_len_string(
f,
len, 1,
bp);
6433 fprintf(
f,
":%d", n);
6439 fprintf(
f,
":%d", n);
6446# ifndef PLATFORM_UNALIGNED_WORD_ACCESS
6451 fprintf(
f,
":%d:%d", (
int )
code,
len);
6460# ifndef PLATFORM_UNALIGNED_WORD_ACCESS
6465 fprintf(
f,
":%d:%d:%d", n, (
int )
code,
len);
6471 fprintf(
f,
":%d", mem);
6478 for (i = 0; i <
len; i++) {
6480 if (i > 0) fputs(
", ",
f);
6481 fprintf(
f,
"%d", mem);
6491 fprintf(
f,
":%d", option);
6493 fprintf(
f,
":%d", level);
6497 for (i = 0; i <
len; i++) {
6499 if (i > 0) fputs(
", ",
f);
6500 fprintf(
f,
"%d", mem);
6512 fprintf(
f,
":%d:%d", mem, addr);
6520 fprintf(
f,
":(%s%d)", (addr >= 0) ?
"+" :
"", addr);
6527 fprintf(
f,
":%d",
len);
6533 fprintf(
f,
":%d:(%s%d)",
len, (addr >= 0) ?
"+" :
"", addr);
6542 fprintf(
f,
":%d:(%s%d)", scn, (addr >= 0) ?
"+" :
"", addr);
6548 fprintf(
f,
":%d:(%s%d)", mem, (addr >= 0) ?
"+" :
"", addr);
6552 fprintf(stderr,
"onig_print_compiled_byte_code: undefined code %d\n",
6557 if (nextp) *nextp =
bp;
6560# ifdef ONIG_DEBUG_COMPILE
6568 fprintf(
f,
"code length: %d", reg->
used);
6574 fprintf(
f,
"\n%ld:",
bp - reg->
p);
6576 fprintf(
f,
" %ld:",
bp - reg->
p);
6577 onig_print_compiled_byte_code(
f,
bp, end, &
bp, reg->
enc);
6584# ifdef ONIG_DEBUG_PARSE_TREE
6586print_indent_tree(
FILE*
f,
Node* node,
int indent)
6588 int i,
type, container_p = 0;
6594 fprintf(
f,
"ERROR: null node!!!\n");
6607 print_indent_tree(
f,
NCAR(node), indent +
add);
6609 if (
NTYPE(node) != type) {
6610 fprintf(
f,
"ERROR: list/alt right is not a cons. %d\n",
NTYPE(node));
6613 print_indent_tree(
f,
NCAR(node), indent +
add);
6618 fprintf(
f,
"<string%s:%"PRIxPTR">",
6620 for (p =
NSTR(node)->s; p <
NSTR(node)->end; p++) {
6621 if (*p >= 0x20 && *p < 0x7f)
6624 fprintf(
f,
" 0x%02x", *p);
6636 fprintf(
f,
"%d", *data++);
6637 for (; data < end; data+=2) {
6639 fprintf(
f,
"%04x-%04x", data[0], data[1]);
6646 switch (
NCTYPE(node)->ctype) {
6648 if (
NCTYPE(node)->not != 0)
6649 fputs(
"not word",
f);
6655 fprintf(
f,
"ERROR: undefined ctype.\n");
6666 switch (
NANCHOR(node)->type) {
6676# ifdef USE_WORD_BEGIN_END
6687 fprintf(
f,
"ERROR: undefined anchor type.\n");
6698 for (i = 0; i < br->
back_num; i++) {
6699 if (i > 0) fputs(
", ",
f);
6700 fprintf(
f,
"%d", p[i]);
6705# ifdef USE_SUBEXP_CALL
6718 (
NQTFR(node)->greedy ?
"" :
"?"));
6719 print_indent_tree(
f,
NQTFR(node)->target, indent +
add);
6726 fprintf(
f,
"option:%d",
NENCLOSE(node)->option);
6729 fprintf(
f,
"memory:%d",
NENCLOSE(node)->regnum);
6732 fprintf(
f,
"stop-bt");
6735 fprintf(
f,
"condition:%d",
NENCLOSE(node)->regnum);
6738 fprintf(
f,
"absent");
6745 print_indent_tree(
f,
NENCLOSE(node)->target, indent +
add);
6749 fprintf(
f,
"print_indent_tree: undefined node type %d\n",
NTYPE(node));
6757 if (container_p) print_indent_tree(
f,
NANCHOR(node)->target, indent +
add);
6765 print_indent_tree(
f, node, 0);
size_t map(int syms, int left, int len)
void skip(file *in, unsigned n)
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
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]
if((ID)(DISPID) nameid !=nameid)