47 #ifndef PLATFORM_UNALIGNED_WORD_ACCESS
54 ptrdiff_t
len = end - s;
70 c = *a; *a = *b; *b = c;
105 if (m == 0)
return 0;
118 if (bs[i] != 0)
return 0;
125 onig_is_prelude(
void)
155 buf->
alloc = (
unsigned int)size;
161 #ifdef USE_SUBEXP_CALL
190 size = uslist->
alloc * 2;
212 #ifdef USE_COMBINATION_EXPLOSION_CHECK
214 add_state_check_num(
regex_t* reg,
int num)
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)
370 if (empty_info != 0) {
381 if (empty_info != 0) {
395 #ifdef USE_SUBEXP_CALL
416 for (i = 0; i < n; i++) {
425 regex_t* reg ARG_UNUSED,
int ignore_case)
436 len += mb_len * str_len;
465 int rlen, r,
len, prev_len, slen, ambig;
471 if (sn->
end <= sn->
s)
482 for (; p < sn->
end; ) {
484 if (len == prev_len) {
504 if (sn->
end <= sn->
s)
513 int r,
len, prev_len, slen, ambig;
519 if (sn->
end <= sn->
s)
526 prev_len =
enclen(enc, p, end);
531 len =
enclen(enc, p, end);
532 if (len == prev_len) {
552 if (sn->
end <= sn->
s)
561 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS
601 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS
657 #define REPEAT_RANGE_ALLOC 4
731 #define QUANTIFIER_EXPAND_LIMIT_SIZE 50
732 #define CKN_ON (ckn > 0)
734 #ifdef USE_COMBINATION_EXPLOSION_CHECK
739 int len, mod_tlen, cklen;
745 if (tlen < 0)
return tlen;
753 if (qn->
greedy && infinite) {
766 if (infinite && qn->
lower <= 1) {
784 else if (qn->
upper == 0) {
791 if (qn->
lower == 0) {
793 len = SIZE_OP_STATE_CHECK_PUSH + tlen;
810 len += SIZE_OP_STATE_CHECK;
825 if (tlen < 0)
return tlen;
839 r = add_state_check_num(reg, ckn);
858 r = add_state_check_num(reg, ckn);
869 if (infinite && qn->
lower <= 1) {
871 if (qn->
lower == 1) {
880 r = add_state_check_num(reg, ckn);
895 if (qn->
lower == 0) {
904 r = add_state_check_num(reg, ckn);
907 -(mod_tlen + (
int )SIZE_OP_STATE_CHECK_PUSH_OR_JUMP));
913 else if (qn->
upper == 0) {
923 if (qn->
lower == 0) {
927 r = add_state_check_num(reg, ckn);
943 r = add_state_check_num(reg, ckn);
962 r = add_state_check_num(reg, ckn);
978 if (tlen < 0)
return tlen;
982 if (qn->
greedy && infinite) {
1001 len = tlen * qn->
lower;
1018 else if (!infinite && qn->
greedy &&
1021 len = tlen * qn->
lower;
1043 if (tlen < 0)
return tlen;
1064 if (empty_info != 0)
1133 else if (!infinite && qn->
greedy &&
1141 for (i = 0; i < n; i++) {
1173 if (tlen < 0)
return tlen;
1220 if (tlen < 0)
return tlen;
1225 switch (node->
type) {
1227 #ifdef USE_SUBEXP_CALL
1255 if (tlen < 0)
return tlen;
1257 len = tlen * qn->
lower
1283 switch (node->
type) {
1285 #ifdef USE_SUBEXP_CALL
1315 #ifdef USE_SUBEXP_CALL
1348 if (len < 0)
return len;
1384 if (tlen < 0)
return tlen;
1387 switch (node->
type) {
1414 switch (node->
type) {
1424 #ifdef USE_WORD_BEGIN_END
1439 if (len < 0)
return len;
1504 if (r < 0)
return r;
1543 #ifdef USE_BACKREF_WITH_LEVEL
1560 #ifdef USE_SUBEXP_CALL
1643 switch (
NCTYPE(node)->ctype) {
1667 #ifdef USE_BACKREF_WITH_LEVEL
1676 goto add_bacref_mems;
1711 #ifdef USE_BACKREF_WITH_LEVEL
1717 for (i = br->
back_num - 1; i >= 0; i--) {
1725 #ifdef USE_SUBEXP_CALL
1727 r = compile_call(
NCALL(node), reg);
1745 fprintf(stderr,
"compile_tree: undefined node type %d\n",
NTYPE(node));
1753 #ifdef USE_NAMED_GROUP
1759 Node* node = *plink;
1761 switch (
NTYPE(node)) {
1765 r = noname_disable_map(&(
NCAR(node)), map, counter);
1771 Node** ptarget = &(
NQTFR(node)->target);
1772 Node* old = *ptarget;
1773 r = noname_disable_map(ptarget, map, counter);
1788 r = noname_disable_map(&(en->
target), map, counter);
1794 r = noname_disable_map(plink, map, counter);
1798 r = noname_disable_map(&(en->
target), map, counter);
1810 r = noname_disable_map(&(an->
target), map, counter);
1826 int i, pos, n, old_num;
1839 for (i = 0, pos = 0; i < old_num; i++) {
1856 switch (
NTYPE(node)) {
1860 r = renumber_by_map(
NCAR(node), map);
1864 r = renumber_by_map(
NQTFR(node)->target, map);
1867 r = renumber_by_map(
NENCLOSE(node)->target, map);
1871 r = renumber_node_backref(node, map);
1882 r = renumber_by_map(an->
target, map);
1896 numbered_ref_check(
Node* node)
1900 switch (
NTYPE(node)) {
1904 r = numbered_ref_check(
NCAR(node));
1908 r = numbered_ref_check(
NQTFR(node)->target);
1911 r = numbered_ref_check(
NENCLOSE(node)->target);
1929 int r,
i, pos, counter;
1935 for (i = 1; i <= env->
num_mem; i++) {
1939 r = noname_disable_map(root, map, &counter);
1940 if (r != 0)
return r;
1942 r = renumber_by_map(*root, map);
1943 if (r != 0)
return r;
1945 for (i = 1, pos = 1; i <= env->
num_mem; i++) {
1946 if (map[i].new_val > 0) {
1967 #ifdef USE_SUBEXP_CALL
1975 for (i = 0; i < uslist->
num; i++) {
1987 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
1989 quantifiers_memory_node_info(
Node* node)
1993 switch (
NTYPE(node)) {
1999 v = quantifiers_memory_node_info(
NCAR(node));
2005 #ifdef USE_SUBEXP_CALL
2011 r = quantifiers_memory_node_info(
NCALL(node)->target);
2018 if (qn->
upper != 0) {
2019 r = quantifiers_memory_node_info(qn->
target);
2034 r = quantifiers_memory_node_info(en->
target);
2063 switch (
NTYPE(node)) {
2076 for (i = 1; i < br->
back_num; i++) {
2080 if (*min > tmin) *min = tmin;
2085 #ifdef USE_SUBEXP_CALL
2100 if (r == 0) *min += tmin;
2112 if (y == node) *min = tmin;
2113 else if (*min > tmin) *min = tmin;
2121 *min = sn->
end - sn->
s;
2138 if (qn->
lower > 0) {
2151 #ifdef USE_SUBEXP_CALL
2186 switch (
NTYPE(node)) {
2198 if (r == 0 && *max < tmax) *max = tmax;
2205 *max = sn->
end - sn->
s;
2229 for (i = 0; i < br->
back_num; i++) {
2233 if (*max < tmax) *max = tmax;
2238 #ifdef USE_SUBEXP_CALL
2251 if (qn->
upper != 0) {
2253 if (r == 0 && *max != 0) {
2268 #ifdef USE_SUBEXP_CALL
2296 #define GET_CHAR_LEN_VARLEN -1
2297 #define GET_CHAR_LEN_TOP_ALT_VARLEN -2
2308 switch (
NTYPE(node)) {
2347 while (s < sn->
end) {
2367 #ifdef USE_SUBEXP_CALL
2390 #ifdef USE_SUBEXP_CALL
2457 tmp = x; x = y; y = tmp;
2477 switch (
NCTYPE(y)->ctype) {
2479 if (
NCTYPE(y)->not == 0) {
2553 switch (
NCTYPE(y)->ctype) {
2558 return !(
NCTYPE(y)->not);
2586 for (i = 0, p = ys->
s, q = xs->
s; (
OnigDistance)i < len; i++, p++, q++) {
2587 if (*p != *q)
return 1;
2611 switch (
NTYPE(node)) {
2615 #ifdef USE_SUBEXP_CALL
2635 if (sn->
end <= sn->
s)
2650 if (qn->
lower > 0) {
2719 if ((en->
type & enclose_mask) == 0)
2728 if ((type & anchor_mask) == 0)
2733 type_mask, enclose_mask, anchor_mask);
2742 #ifdef USE_SUBEXP_CALL
2744 #define RECURSION_EXIST 1
2745 #define RECURSION_INFINITE 2
2748 subexp_inf_recursive_check(
Node* node,
ScanEnv* env,
int head)
2763 ret = subexp_inf_recursive_check(
NCAR(x), env, head);
2764 if (ret < 0 || ret == RECURSION_INFINITE)
return ret;
2768 if (ret != 0)
return ret;
2769 if (min != 0) head = 0;
2778 r = RECURSION_EXIST;
2780 ret = subexp_inf_recursive_check(
NCAR(node), env, head);
2781 if (ret < 0 || ret == RECURSION_INFINITE)
return ret;
2788 r = subexp_inf_recursive_check(
NQTFR(node)->target, env, head);
2789 if (r == RECURSION_EXIST) {
2790 if (
NQTFR(node)->lower == 0) r = 0;
2802 r = subexp_inf_recursive_check(an->
target, env, head);
2809 r = subexp_inf_recursive_check(
NCALL(node)->target, env, head);
2816 return (head == 0 ? RECURSION_EXIST : RECURSION_INFINITE);
2819 r = subexp_inf_recursive_check(
NENCLOSE(node)->target, env, head);
2832 subexp_inf_recursive_check_trav(
Node* node,
ScanEnv* env)
2842 r = subexp_inf_recursive_check_trav(
NCAR(node), env);
2847 r = subexp_inf_recursive_check_trav(
NQTFR(node)->target, env);
2858 r = subexp_inf_recursive_check_trav(an->
target, env);
2870 r = subexp_inf_recursive_check(en->
target, env, 1);
2874 r = subexp_inf_recursive_check_trav(en->
target, env);
2887 subexp_recursive_check(
Node* node)
2891 switch (
NTYPE(node)) {
2895 r |= subexp_recursive_check(
NCAR(node));
2900 r = subexp_recursive_check(
NQTFR(node)->target);
2911 r = subexp_recursive_check(an->
target);
2918 r = subexp_recursive_check(
NCALL(node)->target);
2929 r = subexp_recursive_check(
NENCLOSE(node)->target);
2943 subexp_recursive_check_trav(
Node* node,
ScanEnv* env)
2945 #define FOUND_CALLED_NODE 1
2957 ret = subexp_recursive_check_trav(
NCAR(node), env);
2958 if (ret == FOUND_CALLED_NODE) r = FOUND_CALLED_NODE;
2959 else if (ret < 0)
return ret;
2965 r = subexp_recursive_check_trav(
NQTFR(node)->target, env);
2966 if (
NQTFR(node)->upper == 0) {
2967 if (r == FOUND_CALLED_NODE)
2968 NQTFR(node)->is_refered = 1;
2980 r = subexp_recursive_check_trav(an->
target, env);
2993 r = subexp_recursive_check(en->
target);
2998 r = subexp_recursive_check_trav(en->
target, env);
3000 r |= FOUND_CALLED_NODE;
3021 r = setup_subexp_call(
NCAR(node), env);
3027 r = setup_subexp_call(
NCAR(node), env);
3032 r = setup_subexp_call(
NQTFR(node)->target, env);
3035 r = setup_subexp_call(
NENCLOSE(node)->target, env);
3046 #ifdef USE_NAMED_GROUP
3059 #ifdef USE_NAMED_GROUP
3072 #ifdef USE_NAMED_GROUP
3106 r = setup_subexp_call(an->
target, env);
3127 Node *head, *np, *insert_node;
3129 int anc_type = an->
type;
3142 NCAR(np) = insert_node;
3185 #ifdef USE_QTFR_PEEK_NEXT
3193 if (qn->
lower <= 1) {
3227 UChar *sbuf, *ebuf, *sp;
3233 sbuf_size = (end - sn->
s) * 2;
3236 ebuf = sbuf + sbuf_size;
3243 for (i = 0; i <
len; i++) {
3247 sp = sbuf + sbuf_size;
3249 ebuf = sbuf + sbuf_size;
3293 int r,
i, j,
len, varlen;
3294 Node *anode, *var_anode, *snode, *xnode, *an;
3300 for (i = 0; i < item_num; i++) {
3301 if (items[i].byte_len != slen) {
3312 if (
IS_NULL(xnode))
goto mem_err;
3313 NCAR(var_anode) = xnode;
3316 if (
IS_NULL(anode))
goto mem_err;
3317 NCAR(xnode) = anode;
3325 if (
IS_NULL(snode))
goto mem_err;
3327 NCAR(anode) = snode;
3329 for (i = 0; i < item_num; i++) {
3331 if (
IS_NULL(snode))
goto mem_err;
3333 for (j = 0; j < items[
i].
code_len; j++) {
3341 if (r != 0)
goto mem_err2;
3349 if (items[i].byte_len != slen) {
3379 NCDR(var_anode) = an;
3403 #define THRESHOLD_CASE_FOLD_ALT_FOR_EXPANSION 8
3405 int r, n,
len, alt_num;
3407 Node *top_root, *root, *snode, *prev_node;
3415 if (start >= end)
return 0;
3418 top_root = root = prev_node = snode =
NULL_NODE;
3442 if (
IS_NULL(snode))
goto mem_err;
3452 if (r != 0)
goto err;
3467 if (r < 0)
goto mem_err;
3470 top_root = prev_node;
3479 root =
NCAR(prev_node);
3500 if (r != 0)
goto mem_err;
3523 top_root = (
IS_NOT_NULL(top_root) ? top_root : prev_node);
3537 #ifdef USE_COMBINATION_EXPLOSION_CHECK
3539 #define CEC_THRES_NUM_BIG_REPEAT 512
3540 #define CEC_INFINITE_NUM 0x7fffffff
3542 #define CEC_IN_INFINITE_REPEAT (1<<0)
3543 #define CEC_IN_FINITE_REPEAT (1<<1)
3544 #define CEC_CONT_BIG_REPEAT (1<<2)
3558 r = setup_comb_exp_check(
NCAR(node), r, env);
3568 ret = setup_comb_exp_check(
NCAR(node), state, env);
3576 int child_state =
state;
3583 if (qn->
upper > 1) {
3585 child_state |= CEC_IN_FINITE_REPEAT;
3598 child_state =
state;
3607 if (state & CEC_IN_FINITE_REPEAT) {
3608 qn->comb_exp_check_num = -1;
3612 var_num = CEC_INFINITE_NUM;
3613 child_state |= CEC_IN_INFINITE_REPEAT;
3619 if (var_num >= CEC_THRES_NUM_BIG_REPEAT)
3620 add_state |= CEC_CONT_BIG_REPEAT;
3622 if (((state & CEC_IN_INFINITE_REPEAT) != 0 && var_num != 0) ||
3623 ((state & CEC_CONT_BIG_REPEAT) != 0 &&
3624 var_num >= CEC_THRES_NUM_BIG_REPEAT)) {
3625 if (qn->comb_exp_check_num == 0) {
3626 env->num_comb_exp_check++;
3627 qn->comb_exp_check_num = env->num_comb_exp_check;
3628 if (env->curr_max_regnum > env->comb_exp_max_regnum)
3629 env->comb_exp_max_regnum = env->curr_max_regnum;
3634 r = setup_comb_exp_check(target, child_state, env);
3646 if (env->curr_max_regnum < en->
regnum)
3647 env->curr_max_regnum = en->
regnum;
3649 r = setup_comb_exp_check(en->
target, state, env);
3654 r = setup_comb_exp_check(en->
target, state, env);
3660 #ifdef USE_SUBEXP_CALL
3663 env->has_recursion = 1;
3665 r = setup_comb_exp_check(
NCALL(node)->target, state, env);
3677 #define IN_ALT (1<<0)
3678 #define IN_NOT (1<<1)
3679 #define IN_REPEAT (1<<2)
3680 #define IN_VAR_REPEAT (1<<3)
3731 #ifdef USE_SUBEXP_CALL
3743 for (i = 0; i < br->
back_num; i++) {
3747 #ifdef USE_BACKREF_WITH_LEVEL
3772 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
3773 r = quantifiers_memory_node_info(target);
3781 if (r == 0 && d == 0) {
3800 #define EXPAND_STRING_MAX_LENGTH 100
3810 for (i = 0; i < n; i++) {
3820 #ifdef USE_OP_PUSH_OR_JUMP_EXACT
3891 #define ALLOWED_TYPE_IN_LB \
3892 ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \
3893 BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL )
3895 #define ALLOWED_ENCLOSE_IN_LB ( ENCLOSE_MEMORY )
3896 #define ALLOWED_ENCLOSE_IN_LB_NOT 0
3898 #define ALLOWED_ANCHOR_IN_LB \
3899 ( ANCHOR_LOOK_BEHIND | ANCHOR_BEGIN_LINE | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION )
3900 #define ALLOWED_ANCHOR_IN_LB_NOT \
3901 ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION )
3907 if (r < 0)
return r;
3910 if (r != 0)
return r;
3920 if (r < 0)
return r;
3923 if (r != 0)
return r;
3942 UChar skip[],
int** int_skip)
3950 for (i = 0; i < len - 1; i++)
3951 skip[s[i]] = len - 1 - i;
3960 for (i = 0; i < len - 1; i++)
3961 (*int_skip)[s[
i]] = (int)(len - 1 - i);
3966 #define OPT_EXACT_MAXLEN 24
4019 static const short int ByteValTable[] = {
4020 5, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 1, 1, 10, 1, 1,
4021 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4022 12, 4, 7, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
4023 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5,
4024 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
4025 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 5, 5, 5,
4026 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
4027 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 1
4030 if (i < (
int )(
sizeof(ByteValTable)/
sizeof(ByteValTable[0]))) {
4034 return (
int )ByteValTable[
i];
4044 static const short int dist_vals[] = {
4045 1000, 500, 333, 250, 200, 167, 143, 125, 111, 100,
4046 91, 83, 77, 71, 67, 63, 59, 56, 53, 50,
4047 48, 45, 43, 42, 40, 38, 37, 36, 34, 33,
4048 32, 31, 30, 29, 29, 28, 27, 26, 26, 25,
4049 24, 24, 23, 23, 22, 22, 21, 21, 20, 20,
4050 20, 19, 19, 19, 18, 18, 18, 17, 17, 17,
4051 16, 16, 16, 16, 15, 15, 15, 15, 14, 14,
4052 14, 14, 14, 14, 13, 13, 13, 13, 13, 13,
4053 12, 12, 12, 12, 12, 12, 11, 11, 11, 11,
4054 11, 11, 11, 11, 11, 10, 10, 10, 10, 10
4062 if (d <
sizeof(dist_vals)/
sizeof(dist_vals[0]))
4064 return (
int )dist_vals[d];
4072 if (v2 <= 0)
return -1;
4073 if (v1 <= 0)
return 1;
4078 if (v2 > v1)
return 1;
4079 if (v2 < v1)
return -1;
4081 if (d2->
min < d1->
min)
return 1;
4082 if (d2->
min > d1->
min)
return -1;
4162 if (left_len == 0) {
4167 if (right_len == 0) {
4254 for (i = to->
len; p < end; ) {
4255 len =
enclen(enc, p, end);
4257 for (j = 0; j < len && p < end; j++)
4277 len =
enclen(enc, p, end);
4279 for (j = 0; j < len && p < end; j++)
4291 if (add->
len == 0 || to->
len == 0) {
4301 for (i = 0; i < to->
len && i < add->
len; ) {
4302 if (to->
s[i] != add->
s[i])
break;
4305 for (j = 1; j <
len; j++) {
4306 if (to->
s[i+j] != add->
s[i+j])
break;
4312 if (! add->
reach_end || i < add->len || i < to->len) {
4337 else if (v1 <= 2 && v2 <= 2) {
4342 if (now->
len > 1) v1 += 5;
4343 if (alt->
len > 1) v2 += 5;
4359 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4360 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4361 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4362 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4363 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4364 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4365 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4366 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4367 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4368 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4369 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4370 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4371 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4372 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4373 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4374 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
4390 if (map->
map[c] == 0) {
4408 if (n < 0)
return n;
4410 for (i = 0; i < n; i++) {
4421 const int z = 1<<15;
4426 if (now->
value == 0) {
4431 v1 = z / now->
value;
4432 v2 = z / alt->
value;
4440 #define COMP_EM_BASE 20
4443 if (m->
value <= 0)
return -1;
4505 int exb_reach, exm_reach;
4533 else if (exm_reach) {
4574 #define MAX_NODE_OPT_INFO_REF_COUNT 5
4696 switch (
NCTYPE(node)->ctype) {
4698 if (
NCTYPE(node)->not != 0) {
4731 switch (
NANCHOR(node)->type) {
4750 else if (nopt.
exm.
len > 0)
4784 for (i = 1; i < br->
back_num; i++) {
4789 if (min > tmin) min = tmin;
4790 if (max < tmax) max = tmax;
4796 #ifdef USE_SUBEXP_CALL
4829 if (qn->
lower > 0) {
4833 for (i = 2; i <= qn->
lower &&
4837 if (i < qn->lower) {
4878 #ifdef USE_SUBEXP_CALL
4910 if (!onig_is_prelude()) fprintf(stderr,
"optimize_node_left: undefined node type %d\n",
4925 if (e->
len == 0)
return 0;
4944 if (e->
len >= 3 || (e->
len >= 2 && allow_reverse)) {
4949 reg->
optimize = (allow_reverse != 0
4992 static void print_optimize_info(
FILE* f,
regex_t* reg);
5045 #if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH)
5046 if (!onig_is_prelude()) print_optimize_info(stderr, reg);
5072 fprintf(fp,
"\nPATTERN: /");
5082 fprintf(fp,
" 0x%04x ", (
int )code);
5085 fputc((
int )code, fp);
5088 p +=
enclen(enc, p, end);
5093 fputc((
int )*s, fp);
5098 fprintf(fp,
"/ (%s)\n", enc->
name);
5118 print_anchor(
FILE* f,
int anchor)
5125 fprintf(f,
"begin-buf");
5129 if (q) fprintf(f,
", ");
5131 fprintf(f,
"begin-line");
5134 if (q) fprintf(f,
", ");
5136 fprintf(f,
"begin-pos");
5139 if (q) fprintf(f,
", ");
5141 fprintf(f,
"end-buf");
5144 if (q) fprintf(f,
", ");
5146 fprintf(f,
"semi-end-buf");
5149 if (q) fprintf(f,
", ");
5151 fprintf(f,
"end-line");
5154 if (q) fprintf(f,
", ");
5156 fprintf(f,
"anychar-star");
5159 if (q) fprintf(f,
", ");
5160 fprintf(f,
"anychar-star-pl");
5169 static const char* on[] = {
"NONE",
"EXACT",
"EXACT_BM",
"EXACT_BM_NOT_REV",
5170 "EXACT_IC",
"MAP" };
5172 fprintf(f,
"optimize: %s\n", on[reg->
optimize]);
5173 fprintf(f,
" anchor: "); print_anchor(f, reg->
anchor);
5179 fprintf(f,
" sub anchor: "); print_anchor(f, reg->
sub_anchor);
5186 fprintf(f,
"exact: [");
5187 for (p = reg->
exact; p < reg->exact_end; p++) {
5196 if (reg->
map[i]) n++;
5198 fprintf(f,
"map: n=%d\n", n);
5203 if (reg->
map[i] != 0) {
5204 if (c > 0) fputs(
", ", f);
5210 fprintf(f,
"%d", i);
5231 #ifdef USE_NAMED_GROUP
5249 size_t size =
sizeof(
regex_t);
5260 #define REGEX_TRANSFER(to,from) do {\
5261 (to)->state = ONIG_STATE_MODIFY;\
5262 onig_free_body(to);\
5263 xmemcpy(to, from, sizeof(regex_t));\
5275 #define REGEX_CHAIN_HEAD(reg) do {\
5276 while (IS_NOT_NULL((reg)->chain)) {\
5277 (reg) = (reg)->chain;\
5309 static void print_compiled_byte_code_list
P_((
FILE* f,
regex_t* reg));
5311 #ifdef ONIG_DEBUG_PARSE_TREE
5312 static void print_tree
P_((
FILE* f,
Node* node));
5317 OnigErrorInfo* einfo,
const char *sourcefile,
int sourceline)
5319 #define COMPILE_INIT_SIZE 20
5325 #ifdef USE_SUBEXP_CALL
5336 if (!onig_is_prelude()) print_enc_string(stderr, reg->
enc, pattern, pattern_end);
5339 if (reg->
alloc == 0) {
5340 init_size = (pattern_end - pattern) * 2;
5343 if (r != 0)
goto end;
5353 #ifdef USE_COMBINATION_EXPLOSION_CHECK
5358 if (r != 0)
goto err;
5360 #ifdef ONIG_DEBUG_PARSE_TREE
5362 fprintf(stderr,
"ORIGINAL PARSE TREE:\n");
5363 if (!onig_is_prelude()) {
5364 print_tree(stderr, root);
5369 #ifdef USE_NAMED_GROUP
5375 r = disable_noname_group_capture(&root, reg, &scan_env);
5377 r = numbered_ref_check(root);
5379 if (r != 0)
goto err;
5383 #ifdef USE_SUBEXP_CALL
5385 r = unset_addr_list_init(&uslist, scan_env.
num_call);
5386 if (r != 0)
goto err;
5388 r = setup_subexp_call(root, &scan_env);
5389 if (r != 0)
goto err_unset;
5390 r = subexp_recursive_check_trav(root, &scan_env);
5391 if (r < 0)
goto err_unset;
5392 r = subexp_inf_recursive_check_trav(root, &scan_env);
5393 if (r != 0)
goto err_unset;
5402 if (r != 0)
goto err_unset;
5404 #ifdef ONIG_DEBUG_PARSE_TREE
5405 if (!onig_is_prelude()) print_tree(stderr, root);
5418 #ifdef USE_COMBINATION_EXPLOSION_CHECK
5424 setup_comb_exp_check(root, 0, &scan_env);
5425 #ifdef USE_SUBEXP_CALL
5426 if (scan_env.has_recursion != 0) {
5427 scan_env.num_comb_exp_check = 0;
5431 if (scan_env.comb_exp_max_regnum > 0) {
5433 for (i = 1; i <= scan_env.comb_exp_max_regnum; i++) {
5435 scan_env.num_comb_exp_check = 0;
5446 #ifndef ONIG_DONT_OPTIMIZE
5448 if (r != 0)
goto err_unset;
5459 #ifdef USE_SUBEXP_CALL
5461 r = unset_addr_list_fix(&uslist, reg);
5462 unset_addr_list_end(&uslist);
5476 #ifdef USE_SUBEXP_CALL
5478 unset_addr_list_end(&uslist);
5483 #ifdef ONIG_DEBUG_COMPILE
5484 #ifdef USE_NAMED_GROUP
5485 if (!onig_is_prelude()) onig_print_names(stderr, reg);
5487 if (!onig_is_prelude()) print_compiled_byte_code_list(stderr, reg);
5495 #ifdef USE_SUBEXP_CALL
5497 unset_addr_list_end(&uslist);
5503 einfo->
enc = scan_env.
enc;
5515 #ifdef USE_RECOMPILE_API
5524 r =
onig_new(&new_reg, pattern, pattern_end, option, enc, syntax, einfo);
5568 (reg)->syntax = syntax;
5569 (reg)->optimize = 0;
5571 (reg)->int_map = (
int* )
NULL;
5572 (reg)->int_map_backward = (
int* )
NULL;
5578 (reg)->name_table = (
void* )
NULL;
5580 (reg)->case_fold_flag = case_fold_flag;
5624 if (onig_inited != 0)
5635 #ifdef ONIG_DEBUG_STATISTICS
5636 onig_statistics_init();
5649 #ifdef ONIG_DEBUG_STATISTICS
5650 if (!onig_is_prelude()) onig_print_statistics(stderr);
5653 #ifdef USE_SHARED_CCLASS_TABLE
5657 #ifdef USE_PARSE_TREE_NODE_RECYCLE
5678 for (low = 0, high = n; low < high; ) {
5679 x = (low + high) >> 1;
5680 if (code > data[x * 2 + 1])
5686 return ((low < n && code >= data[low * 2]) ? 1 : 0);
5694 if (elen > 1 || (code >= SINGLE_BYTE_SIZE)) {
5730 #define ARG_SPECIAL -1
5732 #define ARG_RELADDR 1
5733 #define ARG_ABSADDR 2
5734 #define ARG_LENGTH 3
5735 #define ARG_MEMNUM 4
5736 #define ARG_OPTION 5
5737 #define ARG_STATE_CHECK 6
5739 OnigOpInfoType OnigOpInfo[] = {
5741 {
OP_END,
"end", ARG_NON },
5797 {
OP_JUMP,
"jump", ARG_RELADDR },
5798 {
OP_PUSH,
"push", ARG_RELADDR },
5799 {
OP_POP,
"pop", ARG_NON },
5821 {
OP_CALL,
"call", ARG_ABSADDR },
5828 "state-check-anychar-ml*", ARG_STATE_CHECK },
5837 for (i = 0; OnigOpInfo[
i].opcode >= 0; i++) {
5838 if (opcode == OnigOpInfo[i].opcode)
5839 return OnigOpInfo[
i].name;
5845 op2arg_type(
int opcode)
5849 for (i = 0; OnigOpInfo[
i].opcode >= 0; i++) {
5850 if (opcode == OnigOpInfo[i].opcode)
5851 return OnigOpInfo[
i].arg_type;
5857 Indent(
FILE* f,
int indent)
5860 for (i = 0; i < indent; i++)
putc(
' ', f);
5867 while (len-- > 0) { fputc(*s++, f); }
5873 int x = len * mb_len;
5875 fprintf(f,
":%d:", len);
5876 while (x-- > 0) { fputc(*s++, f); }
5891 fprintf(f,
"[%s", op2name(*bp));
5892 arg_type = op2arg_type(*bp);
5893 if (arg_type != ARG_SPECIAL) {
5900 fprintf(f,
":(%d)", addr);
5904 fprintf(f,
":(%d)", addr);
5908 fprintf(f,
":%d", len);
5913 fprintf(f,
":%d", mem);
5919 fprintf(f,
":%d", option);
5923 case ARG_STATE_CHECK:
5926 fprintf(f,
":%d", scn);
5935 p_string(f, 1, bp++);
break;
5937 p_string(f, 2, bp); bp += 2;
break;
5939 p_string(f, 3, bp); bp += 3;
break;
5941 p_string(f, 4, bp); bp += 4;
break;
5943 p_string(f, 5, bp); bp += 5;
break;
5946 p_len_string(f, len, 1, bp);
5951 p_string(f, 2, bp); bp += 2;
break;
5953 p_string(f, 4, bp); bp += 4;
break;
5955 p_string(f, 6, bp); bp += 6;
break;
5958 p_len_string(f, len, 2, bp);
5963 p_len_string(f, len, 3, bp);
5972 fprintf(f,
":%d:%d:", mb_len, len);
5974 while (n-- > 0) { fputc(*bp++, f); }
5979 len =
enclen(enc, bp, bpend);
5980 p_string(f, len, bp);
5985 p_len_string(f, len, 1, bp);
5992 fprintf(f,
":%d", n);
5998 fprintf(f,
":%d", n);
6005 #ifndef PLATFORM_UNALIGNED_WORD_ACCESS
6010 fprintf(f,
":%d:%d", (
int )code, len);
6019 #ifndef PLATFORM_UNALIGNED_WORD_ACCESS
6024 fprintf(f,
":%d:%d:%d", n, (
int )code, len);
6032 n = bitset_on_num(cc->
bs);
6033 fprintf(f,
":%"PRIuPTR
":%d", (
uintptr_t)cc, n);
6040 fprintf(f,
":%d", mem);
6047 for (i = 0; i <
len; i++) {
6049 if (i > 0) fputs(
", ", f);
6050 fprintf(f,
"%d", mem);
6060 fprintf(f,
":%d", option);
6062 fprintf(f,
":%d", level);
6066 for (i = 0; i <
len; i++) {
6068 if (i > 0) fputs(
", ", f);
6069 fprintf(f,
"%d", mem);
6081 fprintf(f,
":%d:%d", mem, addr);
6089 fprintf(f,
":(%d)", addr);
6096 fprintf(f,
":%d", len);
6102 fprintf(f,
":%d:(%d)", len, addr);
6111 fprintf(f,
":%d:(%d)", scn, addr);
6115 fprintf(stderr,
"onig_print_compiled_byte_code: undefined code %d\n",
6120 if (nextp) *nextp =
bp;
6124 print_compiled_byte_code_list(
FILE* f,
regex_t* reg)
6130 fprintf(f,
"code length: %d\n", reg->
used);
6137 fprintf(f,
"\n%ld:", bp-reg->
p);
6139 fprintf(f,
" %ld:", bp-reg->
p);
6148 print_indent_tree(
FILE* f,
Node* node,
int indent)
6150 int i,
type, container_p = 0;
6156 fprintf(f,
"ERROR: null node!!!\n");
6165 fprintf(f,
"<list:%"PRIxPTR
">\n", (
intptr_t)node);
6167 fprintf(f,
"<alt:%"PRIxPTR
">\n", (
intptr_t)node);
6169 print_indent_tree(f,
NCAR(node), indent + add);
6171 if (
NTYPE(node) != type) {
6172 fprintf(f,
"ERROR: list/alt right is not a cons. %d\n",
NTYPE(node));
6175 print_indent_tree(f,
NCAR(node), indent + add);
6180 fprintf(f,
"<string%s:%"PRIxPTR
">",
6182 for (p =
NSTR(node)->s; p <
NSTR(node)->end; p++) {
6183 if (*p >= 0x20 && *p < 0x7f)
6186 fprintf(f,
" 0x%02x", *p);
6192 fprintf(f,
"<cclass:%"PRIxPTR
">", (
intptr_t)node);
6196 for (i = 0; i < (int)bbuf->
used; i++) {
6197 if (i > 0) fprintf(f,
",");
6198 fprintf(f,
"%0x", bbuf->
p[i]);
6204 fprintf(f,
"<ctype:%"PRIxPTR
"> ", (
intptr_t)node);
6205 switch (
NCTYPE(node)->ctype) {
6207 if (
NCTYPE(node)->not != 0)
6208 fputs(
"not word", f);
6214 fprintf(f,
"ERROR: undefined ctype.\n");
6220 fprintf(f,
"<anychar:%"PRIxPTR
">", (
intptr_t)node);
6224 fprintf(f,
"<anchor:%"PRIxPTR
"> ", (
intptr_t)node);
6225 switch (
NANCHOR(node)->type) {
6226 case ANCHOR_BEGIN_BUF: fputs(
"begin buf", f);
break;
6227 case ANCHOR_END_BUF: fputs(
"end buf", f);
break;
6228 case ANCHOR_BEGIN_LINE: fputs(
"begin line", f);
break;
6229 case ANCHOR_END_LINE: fputs(
"end line", f);
break;
6230 case ANCHOR_SEMI_END_BUF: fputs(
"semi end buf", f);
break;
6231 case ANCHOR_BEGIN_POSITION: fputs(
"begin position", f);
break;
6235 #ifdef USE_WORD_BEGIN_END
6245 fprintf(f,
"ERROR: undefined anchor type.\n");
6255 fprintf(f,
"<backref:%"PRIxPTR
">", (
intptr_t)node);
6256 for (i = 0; i < br->
back_num; i++) {
6257 if (i > 0) fputs(
", ", f);
6258 fprintf(f,
"%d", p[i]);
6263 #ifdef USE_SUBEXP_CALL
6267 fprintf(f,
"<call:%"PRIxPTR
">", (
intptr_t)node);
6274 fprintf(f,
"<quantifier:%"PRIxPTR
">{%d,%d}%s\n", (
intptr_t)node,
6276 (
NQTFR(node)->greedy ?
"" :
"?"));
6277 print_indent_tree(f,
NQTFR(node)->target, indent + add);
6281 fprintf(f,
"<enclose:%"PRIxPTR
"> ", (
intptr_t)node);
6284 fprintf(f,
"option:%d\n",
NENCLOSE(node)->option);
6285 print_indent_tree(f,
NENCLOSE(node)->target, indent + add);
6288 fprintf(f,
"memory:%d",
NENCLOSE(node)->regnum);
6291 fprintf(f,
"stop-bt");
6298 print_indent_tree(f,
NENCLOSE(node)->target, indent + add);
6302 fprintf(f,
"print_indent_tree: undefined node type %d\n",
NTYPE(node));
6310 if (container_p) print_indent_tree(f,
NANCHOR(node)->target, indent + add);
6316 #ifdef ONIG_DEBUG_PARSE_TREE
6320 print_indent_tree(f, node, 0);
#define SIZE_OP_SET_OPTION_PUSH
void onig_transfer(regex_t *to, regex_t *from)
#define ANCHOR_ANYCHAR_STAR_ML
#define SIZE_OP_MEMORY_END_PUSH_REC
#define IS_DYNAMIC_OPTION(option)
#define NSTRING_SET_AMBIG(node)
#define BIT_STATUS_AT(stats, n)
#define IS_ENCLOSE_CALLED(en)
void onig_scan_env_set_error_string(ScanEnv *env, int ecode ARG_UNUSED, UChar *arg, UChar *arg_end)
int onig_new_without_alloc(regex_t *reg, const UChar *pattern, const UChar *pattern_end, OnigOptionType option, OnigEncoding enc, OnigSyntaxType *syntax, OnigErrorInfo *einfo)
static int add_bitset(regex_t *reg, BitSetRef bs)
static void concat_opt_exact_info_str(OptExactInfo *to, UChar *s, UChar *end, int raw ARG_UNUSED, OnigEncoding enc)
unsigned int OnigCodePoint
#define ONIGENC_CASE_FOLD_DEFAULT
int onig_new(regex_t **reg, const UChar *pattern, const UChar *pattern_end, OnigOptionType option, OnigEncoding enc, const OnigSyntaxType *syntax, OnigErrorInfo *einfo)
#define IS_REPEAT_INFINITE(n)
int onig_free_node_list(void)
#define ALLOWED_ANCHOR_IN_LB_NOT
#define ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL
int onig_node_str_cat(Node *node, const UChar *s, const UChar *end)
Node * onig_node_list_add(Node *list, Node *x)
#define IS_SYNTAX_BV(syn, bvm)
static void alt_merge_opt_exact_info(OptExactInfo *to, OptExactInfo *add, OptEnv *env)
static int get_char_length_tree(Node *node, regex_t *reg, int *len)
static void concat_opt_anc_info(OptAncInfo *to, OptAncInfo *left, OptAncInfo *right, OnigDistance left_len, OnigDistance right_len)
#define ONIGENC_IS_CODE_WORD(enc, code)
#define NSTRING_IS_RAW(node)
void onig_print_compiled_byte_code(FILE *f, UChar *bp, UChar *bpend, UChar **nextp, OnigEncoding enc)
#define WORD_ALIGNMENT_SIZE
#define ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM
#define BIT_STATUS_ON_AT(stats, n)
#define ONIG_OPTION_SINGLELINE
#define ONIG_OPTIMIZE_EXACT
#define THRESHOLD_CASE_FOLD_ALT_FOR_EXPANSION
static int compile_length_quantifier_node(QtfrNode *qn, regex_t *reg)
#define BBUF_ADD1(buf, byte)
static int max(int a, int b)
#define ANCHOR_WORD_BEGIN
#define IS_ENCLOSE_RECURSION(en)
#define SIZE_OP_REPEAT_INC
#define NSTRING_IS_AMBIG(node)
#define BBUF_WRITE(buf, pos, bytes, n)
static int add_multi_byte_cclass(BBuf *mbuf, regex_t *reg)
if(len<=MAX_WORD_LENGTH &&len >=MIN_WORD_LENGTH)
static int get_char_length_tree1(Node *node, regex_t *reg, int *len, int level)
unsigned int OnigCaseFoldType
#define ONIGENC_MBC_CASE_FOLD(enc, flag, pp, end, buf)
static void swap_node(Node *a, Node *b)
#define REGEX_CHAIN_HEAD(reg)
#define IS_ENCLOSE_MAX_FIXED(en)
static int comp_distance_value(MinMaxLen *d1, MinMaxLen *d2, int v1, int v2)
#define SCANENV_MEM_NODES(senv)
size_t onig_memsize(const regex_t *reg)
#define THREAD_SYSTEM_END
static int add_bytes(regex_t *reg, UChar *bytes, OnigDistance len)
#define IS_CODE_SB_WORD(enc, code)
int onig_names_free(regex_t *reg)
static int set_bm_skip(UChar *s, UChar *end, OnigEncoding enc ARG_UNUSED, UChar skip[], int **int_skip)
#define ANCHOR_BEGIN_LINE
static void select_opt_exact_info(OnigEncoding enc, OptExactInfo *now, OptExactInfo *alt)
int onig_is_in_code_range(const UChar *p, OnigCodePoint code)
#define QUANTIFIER_EXPAND_LIMIT_SIZE
int onig_node_str_set(Node *node, const UChar *s, const UChar *end)
OnigCaseFoldType onig_get_default_case_fold_flag(void)
#define IS_NCCLASS_NOT(nd)
#define ONIGENC_IS_CODE_PRINT(enc, code)
static void concat_left_node_opt_info(OnigEncoding enc, NodeOptInfo *to, NodeOptInfo *add)
#define GET_CHAR_LEN_VARLEN
static OnigDistance distance_add(OnigDistance d1, OnigDistance d2)
static int compile_length_string_raw_node(StrNode *sn, regex_t *reg)
#define IS_ENCLOSE_MIN_FIXED(en)
UnsetAddrList * unset_addr_list
#define IS_BACKREF_NEST_LEVEL(bn)
#define ONIGERR_INVALID_COMBINATION_OF_OPTIONS
static int map_position_value(OnigEncoding enc, int i)
struct _Node * next_head_exact
int onigenc_strlen(OnigEncoding enc, const UChar *p, const UChar *end)
static void set_optimize_map_info(regex_t *reg, OptMapInfo *m)
#define GET_CODE_POINT(code, p)
#define ONIGERR_NEVER_ENDING_RECURSION
Node * onig_node_new_alt(Node *left, Node *right)
#define NQ_TARGET_IS_EMPTY_MEM
int rb_const_defined(VALUE, ID)
unsigned char map[ONIG_CHAR_TABLE_SIZE]
#define IS_CALL_RECURSION(cn)
#define BIT_STATUS_ON_AT_SIMPLE(stats, n)
#define ALLOWED_ANCHOR_IN_LB
static UChar * str_dup(UChar *s, UChar *end)
#define ONIGENC_CODE_TO_MBC_MAXLEN
#define REPEAT_RANGE_ALLOC
static int optimize_node_left(Node *node, NodeOptInfo *opt, OptEnv *env)
static int compile_string_node(Node *node, regex_t *reg)
#define ONIG_OPTIMIZE_EXACT_IC
#define NST_MEM_BACKREFED
static int add_opcode_rel_addr(regex_t *reg, int opcode, int addr)
#define GET_OPTION_INC(option, p)
#define GET_LENGTH_INC(len, p)
#define ANCHOR_BEGIN_POSITION
#define ONIG_STATE_MODIFY
OnigCaseFoldType case_fold_flag
void onig_chain_link_add(regex_t *to, regex_t *add)
#define ONIGERR_INVALID_LOOK_BEHIND_PATTERN
unsigned int OnigOptionType
static int set_optimize_exact_info(regex_t *reg, OptExactInfo *e)
UChar buf[NODE_STR_BUF_SIZE]
#define ONIGENC_CTYPE_WORD
static int min(int a, int b)
#define ANCHOR_NOT_WORD_BOUND
unsigned int bt_mem_start
#define ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, case_fold_flag, p, end, acs)
unsigned int BitStatusType
#define BIT_STATUS_ON_ALL(stats)
#define SIZE_OP_ANYCHAR_STAR_PEEK_NEXT
static int add_opcode_option(regex_t *reg, int opcode, OnigOptionType option)
static int compile_tree_empty_check(Node *node, regex_t *reg, int empty_info)
#define SIZE_STATE_CHECK_NUM
#define IS_ENCLOSE_CLEN_FIXED(en)
#define ALLOWED_ENCLOSE_IN_LB
void onig_free_body(regex_t *reg)
#define COMPILE_INIT_SIZE
#define BIT_STATUS_CLEAR(stats)
#define SIZE_OP_MEMORY_START
UnsetAddrList * unset_addr_list
static int compile_cclass_node(CClassNode *cc, regex_t *reg)
static int setup_tree(Node *node, regex_t *reg, int state, ScanEnv *env)
static int compile_quantifier_node(QtfrNode *qn, regex_t *reg)
int onig_compile(regex_t *reg, const UChar *pattern, const UChar *pattern_end, OnigErrorInfo *einfo, const char *sourcefile, int sourceline)
#define SIZE_OP_PUSH_STOP_BT
struct _Node * head_exact
static int add_option(regex_t *reg, OnigOptionType option)
#define ALLOWED_ENCLOSE_IN_LB_NOT
#define IS_IGNORECASE(option)
void onig_chain_reduce(regex_t *reg)
static int is_full_opt_exact_info(OptExactInfo *ex)
OnigRepeatRange * repeat_range
#define GET_MEMNUM_INC(num, p)
static int set_optimize_info_from_tree(Node *node, regex_t *reg, ScanEnv *scan_env)
#define STACK_POP_LEVEL_MEM_START
static int add_rel_addr(regex_t *reg, int addr)
#define enclen(enc, p, e)
#define STACK_POP_LEVEL_ALL
static int compile_length_option_node(EncloseNode *node, regex_t *reg)
int onig_bbuf_init(BBuf *buf, OnigDistance size)
#define THREAD_ATOMIC_END
#define SIZE_OP_NULL_CHECK_START
static void add_mml(MinMaxLen *to, MinMaxLen *from)
#define putc(_c, _stream)
#define IS_NCCLASS_SHARE(nd)
#define ONIG_IS_OPTION_ON(options, option)
static int compile_length_tree(Node *node, regex_t *reg)
static int check_type_tree(Node *node, int type_mask, int enclose_mask, int anchor_mask)
#define GET_CHAR_LEN_TOP_ALT_VARLEN
OnigCaseFoldType case_fold_flag
#define MAX_NODE_OPT_INFO_REF_COUNT
static void set_mml(MinMaxLen *mml, OnigDistance min, OnigDistance max)
#define ONIG_CHAR_TABLE_SIZE
static void clear_opt_exact_info(OptExactInfo *ex)
#define ONIG_OPTION_NEGATE_SINGLELINE
#define BBUF_INIT(buf, size)
#define ONIG_STATE_COMPILING
#define SET_ENCLOSE_STATUS(node, f)
const OnigSyntaxType * syntax
#define ONIG_STATE_NORMAL
static void copy_mml(MinMaxLen *to, MinMaxLen *from)
#define IS_MULTILINE(option)
static void alt_merge_mml(MinMaxLen *to, MinMaxLen *from)
static int expand_case_fold_string(Node *node, regex_t *reg)
#define ALIGNMENT_RIGHT(addr)
static int is_equal_mml(MinMaxLen *a, MinMaxLen *b)
#define ONIGERR_INVALID_BACKREF
#define DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag)
static int divide_look_behind_alternatives(Node *node)
#define SIZE_OP_PUSH_LOOK_BEHIND_NOT
#define NQ_TARGET_IS_EMPTY_REC
#define BITSET_AT(bs, pos)
int onig_free_shared_cclass_table(void)
OnigCaseFoldType OnigDefaultCaseFoldFlag
static int distance_value(MinMaxLen *mm)
#define CHECK_NULL_RETURN_MEMERR(p)
Node * onig_node_new_enclose(int type)
int onig_reg_init(regex_t *reg, OnigOptionType option, OnigCaseFoldType case_fold_flag, OnigEncoding enc, const OnigSyntaxType *syntax)
#define ONIG_OPTIMIZE_MAP
#define SIZE_OP_MEMORY_END_PUSH
#define NQ_TARGET_IS_EMPTY
static void clear_node_opt_info(NodeOptInfo *opt)
static int compile_tree_n_times(Node *node, int n, regex_t *reg)
static void alt_merge_opt_anc_info(OptAncInfo *to, OptAncInfo *add)
short int StateCheckNumType
struct re_pattern_buffer * chain
static void clear_optimize_info(regex_t *reg)
#define SIZE_OP_ANYCHAR_STAR
#define ALLOWED_TYPE_IN_LB
#define GET_ALIGNMENT_PAD_SIZE(addr, pad_size)
static int compile_length_string_node(Node *node, regex_t *reg)
static void copy_opt_anc_info(OptAncInfo *to, OptAncInfo *from)
static int update_string_node_case_fold(regex_t *reg, Node *node)
#define ONIGERR_UNDEFINED_NAME_REFERENCE
#define EXPAND_STRING_MAX_LENGTH
#define ONIGENC_CODE_TO_MBCLEN(enc, code)
#define SIZE_OP_MEMORY_END
#define SIZE_OP_MEMORY_START_PUSH
void onig_node_conv_to_str_node(Node *node, int flag)
static void alt_merge_node_opt_info(NodeOptInfo *to, NodeOptInfo *add, OptEnv *env)
#define THREAD_ATOMIC_START
#define ONIGENC_IS_MBC_WORD(enc, s, end)
#define ONIGENC_CASE_FOLD_MIN
static int compile_anchor_node(AnchorNode *node, regex_t *reg)
#define SIZE_OP_PUSH_IF_PEEK_NEXT
#define ONIGENC_MBC_CASE_FOLD_MAXLEN
int onig_name_to_group_numbers(regex_t *reg, const UChar *name, const UChar *name_end, int **nums)
#define ANCHOR_END_BUF_MASK
static int get_max_match_length(Node *node, OnigDistance *max, ScanEnv *env)
unsigned char buf[MIME_BUF_SIZE]
#define IS_QUANTIFIER_IN_REPEAT(qn)
static int expand_case_fold_string_alt(int item_num, OnigCaseFoldCodeItem items[], UChar *p, int slen, UChar *end, regex_t *reg, Node **rnode)
static int add_compile_string_length(UChar *s ARG_UNUSED, int mb_len, OnigDistance str_len, regex_t *reg ARG_UNUSED, int ignore_case)
int onig_is_code_in_cc(OnigEncoding enc, OnigCodePoint code, CClassNode *cc)
static int is_anychar_star_quantifier(QtfrNode *qn)
#define ANCHOR_LOOK_BEHIND_NOT
BitStatusType backrefed_mem
static int options(unsigned char *cp)
#define SIZE_OP_NULL_CHECK_END
static int compile_length_anchor_node(AnchorNode *node, regex_t *reg)
static int expand_case_fold_make_rem_string(Node **rnode, UChar *s, UChar *end, regex_t *reg)
RUBY_EXTERN VALUE rb_cThread
static void alt_merge_opt_map_info(OnigEncoding enc, OptMapInfo *to, OptMapInfo *add)
#define ONIGENC_CODE_TO_MBC(enc, code, buf)
Node * onig_node_new_list(Node *left, Node *right)
#define NSTRING_IS_DONT_GET_OPT_INFO(node)
#define IS_ENCLOSE_ADDR_FIXED(en)
static int add_pointer(regex_t *reg, void *addr)
#define IS_BACKREF_NAME_REF(bn)
static int is_set_opt_anc_info(OptAncInfo *to, int anc)
static Node * get_head_value_node(Node *node, int exact, regex_t *reg)
#define SIZE_OP_POP_STOP_BT
static int setup_look_behind(Node *node, regex_t *reg, ScanEnv *env)
#define ONIGERR_PARSER_BUG
#define ANCHOR_SEMI_END_BUF
#define ONIG_OPTIMIZE_NONE
register unsigned int len
Node * onig_node_new_str(const UChar *s, const UChar *end)
#define IS_ENCLOSE_MARK1(en)
#define ONIG_INFINITE_DISTANCE
#define SIZE_OP_FAIL_LOOK_BEHIND_NOT
Node ** mem_nodes_dynamic
static void set_sub_anchor(regex_t *reg, OptAncInfo *anc)
UChar s[OPT_EXACT_MAXLEN]
#define ONIG_OPTION_CAPTURE_GROUP
static int add_opcode(regex_t *reg, int opcode)
#define ONIGENC_MBC_TO_CODE(enc, p, end)
static void copy_node_opt_info(NodeOptInfo *to, NodeOptInfo *from)
#define ONIGENC_MBC_MINLEN(enc)
#define ENCLOSE_STOP_BACKTRACK
static int is_left_anchor(int anc)
void onig_node_free(Node *node)
#define ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED
#define NST_STOP_BT_SIMPLE_REPEAT
static int add_char_amb_opt_map_info(OptMapInfo *map, UChar *p, UChar *end, OnigEncoding enc, OnigCaseFoldType case_fold_flag)
#define ANCHOR_ANYCHAR_STAR
static unsigned char PadBuf[WORD_ALIGNMENT_SIZE]
#define IS_NEED_STR_LEN_OP_EXACT(op)
#define NULL_NODE(parser, node)
static int compile_string_raw_node(StrNode *sn, regex_t *reg)
#define STACK_POP_LEVEL_FREE
static void add_char_opt_map_info(OptMapInfo *map, UChar c, OnigEncoding enc)
#define CHECK_NULL_RETURN(p)
unsigned char * exact_end
static int add_length(regex_t *reg, OnigDistance len)
static void copy_opt_map_info(OptMapInfo *to, OptMapInfo *from)
static void clear_opt_anc_info(OptAncInfo *anc)
#define ONIGENC_IS_UNDEF(enc)
static int compile_tree(Node *node, regex_t *reg)
#define ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc, s, end)
#define SIZE_OP_SET_OPTION
#define ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP
#define GET_RELADDR_INC(addr, p)
#define ONIG_MAX_CAPTURE_HISTORY_GROUP
static int add_compile_string(UChar *s, int mb_len, OnigDistance str_len, regex_t *reg, int ignore_case)
#define ANCHOR_PREC_READ_NOT
void onig_reduce_nested_quantifier(Node *pnode, Node *cnode)
static int is_not_included(Node *x, Node *y, regex_t *reg)
unsigned int capture_history
#define IS_ENCLOSE_STOP_BT_SIMPLE_REPEAT(en)
#define IS_FIND_CONDITION(option)
#define THREAD_SYSTEM_INIT
static OnigDistance distance_multiply(OnigDistance d, int m)
static void clear_opt_map_info(OptMapInfo *map)
static void select_opt_map_info(OptMapInfo *now, OptMapInfo *alt)
#define SIZE_OP_MEMORY_END_REC
OnigCodePoint code[ONIGENC_MAX_COMP_CASE_FOLD_CODE_LEN]
#define ANCHOR_ANYCHAR_STAR_MASK
static void concat_opt_exact_info(OptExactInfo *to, OptExactInfo *add, OnigEncoding enc)
static void set_bound_node_opt_info(NodeOptInfo *opt, MinMaxLen *mmd)
#define ONIGENC_MBC_MAXLEN_DIST(enc)
static int get_min_match_length(Node *node, OnigDistance *min, ScanEnv *env)
#define CLEAR_ENCLOSE_STATUS(node, f)
static int compile_range_repeat_node(QtfrNode *qn, int target_len, int empty_info, regex_t *reg)
static int compile_enclose_node(EncloseNode *node, regex_t *reg)
#define ONIG_OPTION_DONT_CAPTURE_GROUP
#define ONIGERR_INVALID_ARGUMENT
int onig_is_code_in_cc_len(int elen, OnigCodePoint code, CClassNode *cc)
int onig_parse_make_tree(Node **root, const UChar *pattern, const UChar *end, regex_t *reg, ScanEnv *env)
#define ONIG_OPTION_IGNORECASE
#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV
static int compile_length_cclass_node(CClassNode *cc, regex_t *reg)
#define SIZE_OP_PUSH_OR_JUMP_EXACT1
static void copy_opt_env(OptEnv *to, OptEnv *from)
static void copy_opt_exact_info(OptExactInfo *to, OptExactInfo *from)
static int entry_repeat_range(regex_t *reg, int id, int lower, int upper)
#define IS_NODE_TYPE_SIMPLE(type)
#define ANCHOR_LOOK_BEHIND
#define IS_ENCLOSE_MARK2(en)
static int add_abs_addr(regex_t *reg, int addr)
static int add_mem_num(regex_t *reg, int num)
#define GET_POINTER_INC(ptr, p)
#define NSTRING_LEN(node)
#define IS_ENCLOSE_NAMED_GROUP(en)
static void clear_mml(MinMaxLen *mml)
#define rb_intern_const(str)
static void remove_opt_anc_info(OptAncInfo *to, int anc)
UChar map[ONIG_CHAR_TABLE_SIZE]
BitStatusType bt_mem_start
#define NSTRING_SET_DONT_GET_OPT_INFO(node)
#define SIZE_OP_PUSH_POS_NOT
#define ONIGERR_DEFAULT_ENCODING_IS_NOT_SETTED
#define ANCHOR_WORD_BOUND
static int comp_opt_exact_or_map_info(OptExactInfo *e, OptMapInfo *m)
#define ONIG_OPTIMIZE_EXACT_BM
int onig_renumber_name_table(regex_t *reg, GroupNumRemap *map)
static int next_setup(Node *node, Node *next_node, regex_t *reg)
void onig_free(regex_t *reg)
static int compile_length_enclose_node(EncloseNode *node, regex_t *reg)
#define GET_ABSADDR_INC(addr, p)
#define ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND
static int compile_option_node(EncloseNode *node, regex_t *reg)
#define SET_CALL_RECURSION(node)
#define BBUF_GET_OFFSET_POS(buf)
#define SET_NTYPE(node, ntype)
#define REGEX_TRANSFER(to, from)
static int bitset_is_empty(BitSetRef bs)
int onig_set_default_case_fold_flag(OnigCaseFoldType case_fold_flag)
static void add_opt_anc_info(OptAncInfo *to, int anc)
#define ONIGERR_UNDEFINED_GROUP_REFERENCE
#define BBUF_GET_ADD_ADDRESS(buf)
#define SIZE_OP_LOOK_BEHIND
#define BBUF_ADD(buf, bytes, n)
static int select_str_opcode(int mb_len, OnigDistance str_len, int ignore_case)
BitStatusType capture_history
#define ONIGENC_MBC_MAXLEN(enc)
int back_static[NODE_BACKREFS_SIZE]
Node * onig_node_new_anchor(int type)