49 #ifndef PLATFORM_UNALIGNED_WORD_ACCESS 57 ptrdiff_t len =
end - s;
74 c = *a; *a = *b; *b = c;
79 size_t len = sn->
end - sn->
s;
81 sn->
end = sn->
s + len;
88 size_t len = sn->
end - sn->
s;
90 sn->
end = sn->
s + len;
109 if (m == 0)
return 0;
122 if (bs[i] != 0)
return 0;
129 onig_is_prelude(
void)
159 buf->alloc = (
unsigned int )
size;
165 #ifdef USE_SUBEXP_CALL 216 #ifdef USE_COMBINATION_EXPLOSION_CHECK 218 add_state_check_num(
regex_t* reg,
int num)
319 #define IS_NEED_STR_LEN_OP_EXACT(op) \ 320 ((op) == OP_EXACTN || (op) == OP_EXACTMB2N ||\ 321 (op) == OP_EXACTMB3N || (op) == OP_EXACTMBN || (op) == OP_EXACTN_IC) 374 if (empty_info != 0) {
385 if (empty_info != 0) {
399 #ifdef USE_SUBEXP_CALL 420 for (i = 0; i < n; i++) {
440 len += mb_len * (int )str_len;
469 int rlen, r, len, prev_len, slen, ambig;
475 if (sn->
end <= sn->
s)
486 for (; p < sn->
end; ) {
488 if (len == prev_len) {
508 if (sn->
end <= sn->
s)
517 int r, len, prev_len, slen, ambig;
523 if (sn->
end <= sn->
s)
536 if (len == prev_len) {
556 if (sn->
end <= sn->
s)
565 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS 605 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS 661 #define REPEAT_RANGE_ALLOC 4 735 #define QUANTIFIER_EXPAND_LIMIT_SIZE 50 736 #define CKN_ON (ckn > 0) 738 #ifdef USE_COMBINATION_EXPLOSION_CHECK 743 int len, mod_tlen, cklen;
749 if (tlen < 0)
return tlen;
757 if (qn->
greedy && infinite) {
770 if (infinite && qn->
lower <= 1) {
788 else if (qn->
upper == 0) {
795 if (qn->
lower == 0) {
797 len = SIZE_OP_STATE_CHECK_PUSH + tlen;
814 len += SIZE_OP_STATE_CHECK;
829 if (tlen < 0)
return tlen;
843 r = add_state_check_num(reg, ckn);
862 r = add_state_check_num(reg, ckn);
873 if (infinite && qn->
lower <= 1) {
875 if (qn->
lower == 1) {
884 r = add_state_check_num(reg, ckn);
899 if (qn->
lower == 0) {
908 r = add_state_check_num(reg, ckn);
911 -(mod_tlen + (
int )SIZE_OP_STATE_CHECK_PUSH_OR_JUMP));
917 else if (qn->
upper == 0) {
927 if (qn->
lower == 0) {
931 r = add_state_check_num(reg, ckn);
947 r = add_state_check_num(reg, ckn);
966 r = add_state_check_num(reg, ckn);
982 if (tlen < 0)
return tlen;
986 if (qn->
greedy && infinite) {
1005 len = tlen * qn->
lower;
1022 else if (!infinite && qn->
greedy &&
1025 len = tlen * qn->
lower;
1047 if (tlen < 0)
return tlen;
1068 if (empty_info != 0)
1137 else if (!infinite && qn->
greedy &&
1145 for (i = 0; i < n; i++) {
1177 if (tlen < 0)
return tlen;
1224 if (tlen < 0)
return tlen;
1229 switch (node->
type) {
1231 #ifdef USE_SUBEXP_CALL 1259 if (tlen < 0)
return tlen;
1261 len = tlen * qn->
lower 1275 if (tlen < 0)
return tlen;
1280 if (tlen < 0)
return tlen;
1307 switch (node->
type) {
1309 #ifdef USE_SUBEXP_CALL 1339 #ifdef USE_SUBEXP_CALL 1372 if (len < 0)
return len;
1403 if (len < 0)
return len;
1407 if (len2 < 0)
return len2;
1441 if (tlen < 0)
return tlen;
1444 switch (node->
type) {
1471 switch (node->
type) {
1490 #ifdef USE_WORD_BEGIN_END 1512 if (len < 0)
return len;
1577 if (r < 0)
return r;
1616 #ifdef USE_BACKREF_WITH_LEVEL 1633 #ifdef USE_SUBEXP_CALL 1662 int n,
type, len, pos, r = 0;
1682 pos = reg->
used + len;
1716 switch (
NCTYPE(node)->ctype) {
1718 if (
NCTYPE(node)->ascii_range != 0) {
1746 #ifdef USE_BACKREF_WITH_LEVEL 1755 goto add_bacref_mems;
1790 #ifdef USE_BACKREF_WITH_LEVEL 1796 for (i = br->
back_num - 1; i >= 0; i--) {
1804 #ifdef USE_SUBEXP_CALL 1824 fprintf(stderr,
"compile_tree: undefined node type %d\n",
NTYPE(node));
1832 #ifdef USE_NAMED_GROUP 1838 Node* node = *plink;
1840 switch (
NTYPE(node)) {
1850 Node** ptarget = &(
NQTFR(node)->target);
1851 Node* old = *ptarget;
1905 int i, pos, n, old_num;
1918 for (i = 0, pos = 0; i < old_num; i++) {
1935 switch (
NTYPE(node)) {
1984 switch (
NTYPE(node)) {
2013 int r, i, pos, counter;
2019 for (i = 1; i <=
env->num_mem; i++) {
2024 if (r != 0)
return r;
2027 if (r != 0)
return r;
2029 for (i = 1, pos = 1; i <=
env->num_mem; i++) {
2030 if (map[i].new_val > 0) {
2036 loc =
env->capture_history;
2044 env->num_mem =
env->num_named;
2051 #ifdef USE_SUBEXP_CALL 2059 for (i = 0; i < uslist->
num; i++) {
2071 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT 2077 switch (
NTYPE(node)) {
2089 #ifdef USE_SUBEXP_CALL 2102 if (qn->
upper != 0) {
2148 switch (
NTYPE(node)) {
2161 for (i = 1; i < br->
back_num; i++) {
2165 if (*min > tmin) *min = tmin;
2170 #ifdef USE_SUBEXP_CALL 2185 if (r == 0) *min += tmin;
2197 if (y == node) *min = tmin;
2198 else if (*min > tmin) *min = tmin;
2206 *min = sn->
end - sn->
s;
2223 if (qn->
lower > 0) {
2236 #ifdef USE_SUBEXP_CALL 2272 switch (
NTYPE(node)) {
2284 if (r == 0 && *
max < tmax) *
max = tmax;
2315 for (i = 0; i < br->
back_num; i++) {
2319 if (*
max < tmax) *
max = tmax;
2324 #ifdef USE_SUBEXP_CALL 2337 if (qn->
upper != 0) {
2339 if (r == 0 && *
max != 0) {
2354 #ifdef USE_SUBEXP_CALL 2383 #define GET_CHAR_LEN_VARLEN -1 2384 #define GET_CHAR_LEN_TOP_ALT_VARLEN -2 2395 switch (
NTYPE(node)) {
2434 while (s < sn->
end) {
2454 #ifdef USE_SUBEXP_CALL 2477 #ifdef USE_SUBEXP_CALL 2546 tmp = x; x = y; y = tmp;
2566 switch (
NCTYPE(y)->ctype) {
2568 if (
NCTYPE(y)->not == 0) {
2572 if (
NCTYPE(y)->ascii_range) {
2587 if (
NCTYPE(y)->ascii_range)
2651 switch (
NCTYPE(y)->ctype) {
2653 if (
NCTYPE(y)->ascii_range) {
2657 return !(
NCTYPE(y)->not);
2663 return !(
NCTYPE(y)->not);
2692 for (i = 0, p = ys->
s, q = xs->
s; (
OnigDistance )i < len; i++, p++, q++) {
2693 if (*p != *q)
return 1;
2717 switch (
NTYPE(node)) {
2721 #ifdef USE_SUBEXP_CALL 2741 if (sn->
end <= sn->
s)
2756 if (qn->
lower > 0) {
2826 if ((en->
type & enclose_mask) == 0)
2835 if ((
type & anchor_mask) == 0)
2840 type_mask, enclose_mask, anchor_mask);
2849 #ifdef USE_SUBEXP_CALL 2851 #define RECURSION_EXIST 1 2852 #define RECURSION_INFINITE 2 2875 if (ret != 0)
return ret;
2876 if (min != 0)
head = 0;
2897 if (
NQTFR(node)->lower == 0) r = 0;
2998 switch (
NTYPE(node)) {
3052 #define FOUND_CALLED_NODE 1 3066 else if (ret < 0)
return ret;
3073 if (
NQTFR(node)->upper == 0) {
3075 NQTFR(node)->is_refered = 1;
3153 #ifdef USE_NAMED_GROUP 3154 if (
env->num_named > 0 &&
3160 if (gnum >
env->num_mem) {
3166 #ifdef USE_NAMED_GROUP 3179 #ifdef USE_NAMED_GROUP 3180 #ifdef USE_PERL_SUBEXP_CALL 3242 int anc_type = an->
type;
3255 NCAR(np) = insert_node;
3298 #ifdef USE_QTFR_PEEK_NEXT 3306 if (qn->
lower <= 1) {
3324 #ifndef ONIG_DONT_OPTIMIZE 3362 UChar *sbuf, *ebuf, *sp;
3368 sbuf_size = (
end - sn->
s) * 2;
3371 ebuf = sbuf + sbuf_size;
3377 for (i = 0; i < len; i++) {
3385 sp = sbuf + sbuf_size;
3387 ebuf = sbuf + sbuf_size;
3431 int r, i, j, len, varlen, varclen;
3432 Node *anode, *var_anode, *snode, *xnode, *an;
3439 for (i = 0; i < item_num; i++) {
3440 if (items[i].byte_len != slen) {
3444 if (items[i].code_len != 1) {
3454 if (
IS_NULL(xnode))
goto mem_err;
3455 NCAR(var_anode) = xnode;
3458 if (
IS_NULL(anode))
goto mem_err;
3459 NCAR(xnode) = anode;
3467 if (
IS_NULL(snode))
goto mem_err;
3469 NCAR(anode) = snode;
3471 for (i = 0; i < item_num; i++) {
3473 if (
IS_NULL(snode))
goto mem_err;
3475 for (j = 0; j < items[i].
code_len; j++) {
3483 if (r != 0)
goto mem_err2;
3491 if (items[i].byte_len != slen) {
3521 NCDR(var_anode) = an;
3531 if (varclen && !varlen)
3547 #define THRESHOLD_CASE_FOLD_ALT_FOR_EXPANSION 8 3549 int r, n, len, alt_num;
3552 Node *top_root, *root, *snode, *prev_node;
3560 if (start >=
end)
return 0;
3563 top_root = root = prev_node = snode =
NULL_NODE;
3587 if (
IS_NULL(snode))
goto mem_err;
3597 if (r != 0)
goto err;
3612 if (r < 0)
goto mem_err;
3613 if (r > 0) varlen = 1;
3616 top_root = prev_node;
3625 root =
NCAR(prev_node);
3646 if (r != 0)
goto mem_err;
3669 top_root = (
IS_NOT_NULL(top_root) ? top_root : prev_node);
3694 #ifdef USE_COMBINATION_EXPLOSION_CHECK 3696 #define CEC_THRES_NUM_BIG_REPEAT 512 3697 #define CEC_INFINITE_NUM 0x7fffffff 3699 #define CEC_IN_INFINITE_REPEAT (1<<0) 3700 #define CEC_IN_FINITE_REPEAT (1<<1) 3701 #define CEC_CONT_BIG_REPEAT (1<<2) 3715 r = setup_comb_exp_check(
NCAR(node), r,
env);
3725 ret = setup_comb_exp_check(
NCAR(node), state,
env);
3733 int child_state = state;
3740 if (qn->
upper > 1) {
3742 child_state |= CEC_IN_FINITE_REPEAT;
3745 if (
env->backrefed_mem == 0) {
3755 child_state = state;
3764 if (state & CEC_IN_FINITE_REPEAT) {
3765 qn->comb_exp_check_num = -1;
3769 var_num = CEC_INFINITE_NUM;
3770 child_state |= CEC_IN_INFINITE_REPEAT;
3776 if (var_num >= CEC_THRES_NUM_BIG_REPEAT)
3777 add_state |= CEC_CONT_BIG_REPEAT;
3779 if (((state & CEC_IN_INFINITE_REPEAT) != 0 && var_num != 0) ||
3780 ((state & CEC_CONT_BIG_REPEAT) != 0 &&
3781 var_num >= CEC_THRES_NUM_BIG_REPEAT)) {
3782 if (qn->comb_exp_check_num == 0) {
3783 env->num_comb_exp_check++;
3784 qn->comb_exp_check_num =
env->num_comb_exp_check;
3785 if (
env->curr_max_regnum >
env->comb_exp_max_regnum)
3786 env->comb_exp_max_regnum =
env->curr_max_regnum;
3791 r = setup_comb_exp_check(target, child_state,
env);
3806 r = setup_comb_exp_check(en->
target, state,
env);
3811 r = setup_comb_exp_check(en->
target, state,
env);
3817 #ifdef USE_SUBEXP_CALL 3820 env->has_recursion = 1;
3822 r = setup_comb_exp_check(
NCALL(node)->target, state,
env);
3834 #define IN_ALT (1<<0) 3835 #define IN_NOT (1<<1) 3836 #define IN_REPEAT (1<<2) 3837 #define IN_VAR_REPEAT (1<<3) 3838 #define IN_ROOT (1<<4) 3853 int in_root = state &
IN_ROOT;
3862 int prev_in_root = 0;
3870 prev_in_root = state &
IN_ROOT;
3895 #ifdef USE_SUBEXP_CALL 3907 for (i = 0; i < br->
back_num; i++) {
3911 #ifdef USE_BACKREF_WITH_LEVEL 3936 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT 3945 if (r == 0 && d == 0) {
3964 #define EXPAND_STRING_MAX_LENGTH 100 3966 if (qn->
lower > 1) {
3967 int i, n = qn->
lower;
4010 #ifdef USE_OP_PUSH_OR_JUMP_EXACT 4067 #ifdef USE_NAMED_GROUP 4069 env->num_named > 0 &&
4094 #define ALLOWED_TYPE_IN_LB \ 4095 ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ 4096 BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) 4098 #define ALLOWED_ENCLOSE_IN_LB ( ENCLOSE_MEMORY | ENCLOSE_OPTION ) 4099 #define ALLOWED_ENCLOSE_IN_LB_NOT ENCLOSE_OPTION 4101 #define ALLOWED_ANCHOR_IN_LB \ 4102 ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ 4103 ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ 4104 ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \ 4105 ANCHOR_WORD_BEGIN | ANCHOR_WORD_END ) 4106 #define ALLOWED_ANCHOR_IN_LB_NOT \ 4107 ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ 4108 ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ 4109 ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \ 4110 ANCHOR_WORD_BEGIN | ANCHOR_WORD_END ) 4116 if (r < 0)
return r;
4119 if (r != 0)
return r;
4129 if (r < 0)
return r;
4132 if (r != 0)
return r;
4148 #ifndef USE_SUNDAY_QUICK_SEARCH 4152 UChar skip[],
int** int_skip,
int ignore_case)
4155 int clen, flen, n, j, k;
4165 for (i = 0; i < len - 1; i += clen) {
4172 for (j = 0; j < n; j++) {
4173 if ((items[j].code_len != 1) || (items[j].byte_len != clen))
4179 for (j = 0; j < clen; j++) {
4180 skip[s[i + j]] = (
UChar )(len - 1 - i - j);
4181 for (k = 0; k < n; k++) {
4182 skip[
buf[k][j]] = (
UChar )(len - 1 - i - j);
4195 for (i = 0; i < len - 1; i += clen) {
4202 for (j = 0; j < n; j++) {
4203 if ((items[j].code_len != 1) || (items[j].byte_len != clen))
4209 for (j = 0; j < clen; j++) {
4210 (*int_skip)[s[i + j]] = (int )(len - 1 - i - j);
4211 for (k = 0; k < n; k++) {
4212 (*int_skip)[
buf[k][j]] = (int )(len - 1 - i - j);
4225 UChar skip[],
int** int_skip,
int ignore_case)
4228 int clen, flen, n, j, k;
4238 for (i = 0; i < len; i += clen) {
4245 for (j = 0; j < n; j++) {
4246 if ((items[j].code_len != 1) || (items[j].byte_len != clen))
4252 for (j = 0; j < clen; j++) {
4253 skip[s[i + j]] = (
UChar )(len - i - j);
4254 for (k = 0; k < n; k++) {
4255 skip[
buf[k][j]] = (
UChar )(len - i - j);
4268 for (i = 0; i < len; i += clen) {
4275 for (j = 0; j < n; j++) {
4276 if ((items[j].code_len != 1) || (items[j].byte_len != clen))
4282 for (j = 0; j < clen; j++) {
4283 (*int_skip)[s[i + j]] = (int )(len - i - j);
4284 for (k = 0; k < n; k++) {
4285 (*int_skip)[
buf[k][j]] = (int )(len - i - j);
4294 #define OPT_EXACT_MAXLEN 24 4347 static const short int ByteValTable[] = {
4348 5, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 1, 1, 10, 1, 1,
4349 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4350 12, 4, 7, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
4351 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5,
4352 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
4353 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 5, 5, 5,
4354 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
4355 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 1
4358 if (i < (
int )(
sizeof(ByteValTable)/
sizeof(ByteValTable[0]))) {
4362 return (
int )ByteValTable[i];
4372 static const short int dist_vals[] = {
4373 1000, 500, 333, 250, 200, 167, 143, 125, 111, 100,
4374 91, 83, 77, 71, 67, 63, 59, 56, 53, 50,
4375 48, 45, 43, 42, 40, 38, 37, 36, 34, 33,
4376 32, 31, 30, 29, 29, 28, 27, 26, 26, 25,
4377 24, 24, 23, 23, 22, 22, 21, 21, 20, 20,
4378 20, 19, 19, 19, 18, 18, 18, 17, 17, 17,
4379 16, 16, 16, 16, 15, 15, 15, 15, 14, 14,
4380 14, 14, 14, 14, 13, 13, 13, 13, 13, 13,
4381 12, 12, 12, 12, 12, 12, 11, 11, 11, 11,
4382 11, 11, 11, 11, 11, 10, 10, 10, 10, 10
4390 if (d <
sizeof(dist_vals)/
sizeof(dist_vals[0]))
4392 return (
int )dist_vals[d];
4400 if (v2 <= 0)
return -1;
4401 if (v1 <= 0)
return 1;
4406 if (v2 > v1)
return 1;
4407 if (v2 < v1)
return -1;
4409 if (d2->
min <
d1->min)
return 1;
4410 if (d2->
min >
d1->min)
return -1;
4490 if (left_len == 0) {
4495 if (right_len == 0) {
4584 for (i = to->
len; p < end; ) {
4585 len =
enclen(enc, p, end);
4587 for (j = 0; j < len && p < end; j++)
4607 len =
enclen(enc, p, end);
4609 for (j = 0; j < len && p < end; j++)
4621 if (
add->len == 0 || to->
len == 0) {
4631 for (i = 0; i < to->
len && i <
add->len; ) {
4632 if (to->
s[i] !=
add->s[i])
break;
4635 for (j = 1; j < len; j++) {
4636 if (to->
s[i+j] !=
add->s[i+j])
break;
4642 if (!
add->reach_end || i < add->len || i < to->len) {
4648 else if (
add->ignore_case >= 0)
4670 else if (v1 <= 2 && v2 <= 2) {
4675 if (now->
len > 1) v1 += 5;
4676 if (alt->
len > 1) v2 += 5;
4692 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4693 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4694 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4695 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4696 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4697 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4698 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4699 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4700 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4701 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4702 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4703 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4704 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4705 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4706 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4707 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
4723 if (map->
map[c] == 0) {
4741 if (n < 0)
return n;
4743 for (i = 0; i < n; i++) {
4754 const int z = 1<<15;
4758 if (alt->
value == 0) return ;
4759 if (now->
value == 0) {
4764 v1 = z / now->
value;
4765 v2 = z / alt->
value;
4773 #define COMP_EM_BASE 20 4776 if (m->
value <= 0)
return -1;
4789 if (to->
value == 0) return ;
4838 int exb_reach, exm_reach;
4844 if (
add->exb.len > 0 && to->
len.
max == 0) {
4850 if (
add->map.value > 0 && to->
len.
max == 0) {
4851 if (
add->map.mmd.max == 0)
4858 if (
add->len.max != 0)
4861 if (
add->exb.len > 0) {
4866 else if (exm_reach) {
4875 if (
add->len.max > 0) {
4885 else if (
add->expr.len > 0) {
4907 #define MAX_NODE_OPT_INFO_REF_COUNT 5 4981 env->enc,
env->case_fold_flag);
5032 switch (
NCTYPE(node)->ctype) {
5034 if (
NCTYPE(node)->not != 0) {
5042 for (i = 0; i < maxcode; i++) {
5087 else if (nopt.
exm.
len > 0)
5120 for (i = 1; i < br->
back_num; i++) {
5125 if (min > tmin) min = tmin;
5126 if (
max < tmax)
max = tmax;
5132 #ifdef USE_SUBEXP_CALL 5140 env->options = save;
5156 if (
env->mmd.max == 0 &&
5166 if (qn->
lower > 0) {
5170 for (i = 2; i <= qn->
lower &&
5174 if (i < qn->lower) {
5210 env->options = save;
5215 #ifdef USE_SUBEXP_CALL 5248 if (!onig_is_prelude()) fprintf(stderr,
"optimize_node_left: undefined node type %d\n",
5264 if (e->
len == 0)
return 0;
5275 if (e->
len >= 3 || (e->
len >= 2 && allow_reverse)) {
5279 reg->
optimize = (allow_reverse != 0
5291 if (e->
len >= 3 || (e->
len >= 2 && allow_reverse)) {
5296 reg->
optimize = (allow_reverse != 0
5339 static void print_optimize_info(
FILE*
f,
regex_t* reg);
5353 env.scan_env = scan_env;
5393 #if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH) 5394 if (!onig_is_prelude()) print_optimize_info(stderr, reg);
5420 fprintf(fp,
"\nPATTERN: /");
5430 fprintf(fp,
" 0x%04x ", (
int )code);
5433 fputc((
int )code, fp);
5436 p +=
enclen(enc, p, end);
5441 fputc((
int )*s, fp);
5446 fprintf(fp,
"/ (%s)\n", enc->
name);
5466 print_anchor(
FILE*
f,
int anchor)
5473 fprintf(
f,
"begin-buf");
5477 if (q) fprintf(
f,
", ");
5479 fprintf(
f,
"begin-line");
5482 if (q) fprintf(
f,
", ");
5484 fprintf(
f,
"begin-pos");
5487 if (q) fprintf(
f,
", ");
5489 fprintf(
f,
"end-buf");
5492 if (q) fprintf(
f,
", ");
5494 fprintf(
f,
"semi-end-buf");
5497 if (q) fprintf(
f,
", ");
5499 fprintf(
f,
"end-line");
5502 if (q) fprintf(
f,
", ");
5504 fprintf(
f,
"anychar-star");
5507 if (q) fprintf(
f,
", ");
5508 fprintf(
f,
"anychar-star-ml");
5517 static const char* on[] = {
"NONE",
"EXACT",
"EXACT_BM",
"EXACT_BM_NOT_REV",
5519 "EXACT_BM_IC",
"EXACT_BM_NOT_REV_IC" };
5521 fprintf(
f,
"optimize: %s\n", on[reg->
optimize]);
5522 fprintf(
f,
" anchor: "); print_anchor(
f, reg->
anchor);
5528 fprintf(
f,
" sub anchor: "); print_anchor(
f, reg->
sub_anchor);
5535 fprintf(
f,
"exact: [");
5536 for (p = reg->
exact; p < reg->exact_end; p++) {
5545 if (reg->
map[i]) n++;
5547 fprintf(
f,
"map: n=%d\n", n);
5552 if (reg->
map[i] != 0) {
5553 if (c > 0) fputs(
", ",
f);
5559 fprintf(
f,
"%d", i);
5580 #ifdef USE_NAMED_GROUP 5613 size_t size =
sizeof(*regs);
5619 #define REGEX_TRANSFER(to,from) do {\ 5620 (to)->state = ONIG_STATE_MODIFY;\ 5621 onig_free_body(to);\ 5622 xmemcpy(to, from, sizeof(regex_t));\ 5634 #define REGEX_CHAIN_HEAD(reg) do {\ 5635 while (IS_NOT_NULL((reg)->chain)) {\ 5636 (reg) = (reg)->chain;\ 5668 static void print_compiled_byte_code_list
P_((
FILE*
f,
regex_t* reg));
5670 #ifdef ONIG_DEBUG_PARSE_TREE 5676 OnigErrorInfo* einfo,
const char *sourcefile,
int sourceline)
5678 #define COMPILE_INIT_SIZE 20 5684 #ifdef USE_SUBEXP_CALL 5695 if (!onig_is_prelude()) print_enc_string(stderr, reg->
enc, pattern, pattern_end);
5698 if (reg->
alloc == 0) {
5699 init_size = (pattern_end - pattern) * 2;
5702 if (r != 0)
goto end;
5712 #ifdef USE_COMBINATION_EXPLOSION_CHECK 5717 if (r != 0)
goto err;
5719 #ifdef ONIG_DEBUG_PARSE_TREE 5721 fprintf(stderr,
"ORIGINAL PARSE TREE:\n");
5722 if (!onig_is_prelude()) {
5723 print_tree(stderr, root);
5728 #ifdef USE_NAMED_GROUP 5738 if (r != 0)
goto err;
5742 #ifdef USE_SUBEXP_CALL 5745 if (r != 0)
goto err;
5748 if (r != 0)
goto err_unset;
5750 if (r < 0)
goto err_unset;
5752 if (r != 0)
goto err_unset;
5761 if (r != 0)
goto err_unset;
5763 #ifdef ONIG_DEBUG_PARSE_TREE 5764 if (!onig_is_prelude()) print_tree(stderr, root);
5777 #ifdef USE_COMBINATION_EXPLOSION_CHECK 5783 setup_comb_exp_check(root, 0, &scan_env);
5784 #ifdef USE_SUBEXP_CALL 5785 if (scan_env.has_recursion != 0) {
5786 scan_env.num_comb_exp_check = 0;
5790 if (scan_env.comb_exp_max_regnum > 0) {
5792 for (i = 1; i <= scan_env.comb_exp_max_regnum; i++) {
5794 scan_env.num_comb_exp_check = 0;
5805 #ifndef ONIG_DONT_OPTIMIZE 5807 if (r != 0)
goto err_unset;
5818 #ifdef USE_SUBEXP_CALL 5835 #ifdef USE_SUBEXP_CALL 5842 #ifdef ONIG_DEBUG_COMPILE 5843 #ifdef USE_NAMED_GROUP 5844 if (!onig_is_prelude()) onig_print_names(stderr, reg);
5846 if (!onig_is_prelude()) print_compiled_byte_code_list(stderr, reg);
5854 #ifdef USE_SUBEXP_CALL 5862 einfo->
enc = scan_env.
enc;
5874 #ifdef USE_RECOMPILE_API 5883 r =
onig_new(&new_reg, pattern, pattern_end, option, enc, syntax, einfo);
5927 (reg)->syntax = syntax;
5928 (reg)->optimize = 0;
5930 (reg)->int_map = (
int* )
NULL;
5931 (reg)->int_map_backward = (
int* )
NULL;
5937 (reg)->name_table = (
void* )
NULL;
5939 (reg)->case_fold_flag = case_fold_flag;
5994 #ifdef ONIG_DEBUG_STATISTICS 5995 onig_statistics_init();
6008 #ifdef ONIG_DEBUG_STATISTICS 6009 if (!onig_is_prelude()) onig_print_statistics(stderr);
6012 #ifdef USE_SHARED_CCLASS_TABLE 6016 #ifdef USE_PARSE_TREE_NODE_RECYCLE 6037 for (low = 0, high = n; low < high; ) {
6038 x = (low + high) >> 1;
6039 if (code > data[x * 2 + 1])
6045 return ((low < n && code >= data[low * 2]) ? 1 : 0);
6089 #define ARG_SPECIAL -1 6091 #define ARG_RELADDR 1 6092 #define ARG_ABSADDR 2 6093 #define ARG_LENGTH 3 6094 #define ARG_MEMNUM 4 6095 #define ARG_OPTION 5 6096 #define ARG_STATE_CHECK 6 6098 OnigOpInfoType OnigOpInfo[] = {
6100 {
OP_END,
"end", ARG_NON },
6164 {
OP_JUMP,
"jump", ARG_RELADDR },
6165 {
OP_PUSH,
"push", ARG_RELADDR },
6166 {
OP_POP,
"pop", ARG_NON },
6188 {
OP_CALL,
"call", ARG_ABSADDR },
6196 "state-check-anychar-ml*", ARG_STATE_CHECK },
6205 for (i = 0; OnigOpInfo[i].opcode >= 0; i++) {
6206 if (opcode == OnigOpInfo[i].opcode)
6207 return OnigOpInfo[i].name;
6213 op2arg_type(
int opcode)
6217 for (i = 0; OnigOpInfo[i].opcode >= 0; i++) {
6218 if (opcode == OnigOpInfo[i].opcode)
6219 return OnigOpInfo[i].arg_type;
6225 Indent(
FILE*
f,
int indent)
6228 for (i = 0; i < indent; i++)
putc(
' ',
f);
6235 while (len-- > 0) { fputc(*s++,
f); }
6241 int x = len * mb_len;
6243 fprintf(
f,
":%d:", len);
6244 while (x-- > 0) { fputc(*s++,
f); }
6259 fprintf(
f,
"[%s", op2name(*
bp));
6260 arg_type = op2arg_type(*
bp);
6261 if (arg_type != ARG_SPECIAL) {
6268 fprintf(
f,
":(%d)", addr);
6272 fprintf(
f,
":(%d)", addr);
6276 fprintf(
f,
":%d", len);
6281 fprintf(
f,
":%d", mem);
6287 fprintf(
f,
":%d", option);
6291 case ARG_STATE_CHECK:
6294 fprintf(
f,
":%d", scn);
6303 p_string(
f, 1,
bp++);
break;
6305 p_string(
f, 2,
bp);
bp += 2;
break;
6307 p_string(
f, 3,
bp);
bp += 3;
break;
6309 p_string(
f, 4,
bp);
bp += 4;
break;
6311 p_string(
f, 5,
bp);
bp += 5;
break;
6314 p_len_string(
f, len, 1,
bp);
6319 p_string(
f, 2,
bp);
bp += 2;
break;
6321 p_string(
f, 4,
bp);
bp += 4;
break;
6323 p_string(
f, 6,
bp);
bp += 6;
break;
6326 p_len_string(
f, len, 2,
bp);
6331 p_len_string(
f, len, 3,
bp);
6340 fprintf(
f,
":%d:%d:", mb_len, len);
6342 while (n-- > 0) { fputc(*
bp++,
f); }
6348 p_string(
f, len,
bp);
6353 p_len_string(
f, len, 1,
bp);
6360 fprintf(
f,
":%d", n);
6366 fprintf(
f,
":%d", n);
6373 #ifndef PLATFORM_UNALIGNED_WORD_ACCESS 6378 fprintf(
f,
":%d:%d", (
int )code, len);
6387 #ifndef PLATFORM_UNALIGNED_WORD_ACCESS 6392 fprintf(
f,
":%d:%d:%d", n, (
int )code, len);
6400 n = bitset_on_num(cc->
bs);
6401 fprintf(
f,
":%"PRIuPTR
":%d", (
uintptr_t)cc, n);
6408 fprintf(
f,
":%d", mem);
6415 for (i = 0; i < len; i++) {
6417 if (i > 0) fputs(
", ",
f);
6418 fprintf(
f,
"%d", mem);
6428 fprintf(
f,
":%d", option);
6430 fprintf(
f,
":%d",
level);
6434 for (i = 0; i < len; i++) {
6436 if (i > 0) fputs(
", ",
f);
6437 fprintf(
f,
"%d", mem);
6449 fprintf(
f,
":%d:%d", mem, addr);
6457 fprintf(
f,
":(%d)", addr);
6464 fprintf(
f,
":%d", len);
6470 fprintf(
f,
":%d:(%d)", len, addr);
6479 fprintf(
f,
":%d:(%d)", scn, addr);
6485 fprintf(
f,
":%d:(%d)", mem, addr);
6489 fprintf(stderr,
"onig_print_compiled_byte_code: undefined code %d\n",
6494 if (nextp) *nextp =
bp;
6504 fprintf(
f,
"code length: %d", reg->
used);
6510 fprintf(
f,
"\n%ld:",
bp - reg->
p);
6512 fprintf(
f,
" %ld:",
bp - reg->
p);
6520 print_indent_tree(
FILE*
f,
Node* node,
int indent)
6522 int i,
type, container_p = 0;
6528 fprintf(
f,
"ERROR: null node!!!\n");
6537 fprintf(
f,
"<list:%"PRIxPTR
">\n", (
intptr_t)node);
6539 fprintf(
f,
"<alt:%"PRIxPTR
">\n", (
intptr_t)node);
6541 print_indent_tree(
f,
NCAR(node), indent +
add);
6544 fprintf(
f,
"ERROR: list/alt right is not a cons. %d\n",
NTYPE(node));
6547 print_indent_tree(
f,
NCAR(node), indent +
add);
6552 fprintf(
f,
"<string%s:%"PRIxPTR
">",
6554 for (p =
NSTR(node)->s; p <
NSTR(node)->end; p++) {
6555 if (*p >= 0x20 && *p < 0x7f)
6558 fprintf(
f,
" 0x%02x", *p);
6564 fprintf(
f,
"<cclass:%"PRIxPTR
">", (
intptr_t)node);
6568 for (i = 0; i < (int )bbuf->
used; i++) {
6569 if (i > 0) fprintf(
f,
",");
6570 fprintf(
f,
"%0x", bbuf->
p[i]);
6576 fprintf(
f,
"<ctype:%"PRIxPTR
"> ", (
intptr_t)node);
6577 switch (
NCTYPE(node)->ctype) {
6579 if (
NCTYPE(node)->not != 0)
6580 fputs(
"not word",
f);
6586 fprintf(
f,
"ERROR: undefined ctype.\n");
6592 fprintf(
f,
"<anychar:%"PRIxPTR
">", (
intptr_t)node);
6596 fprintf(
f,
"<anchor:%"PRIxPTR
"> ", (
intptr_t)node);
6608 #ifdef USE_WORD_BEGIN_END 6619 fprintf(
f,
"ERROR: undefined anchor type.\n");
6629 fprintf(
f,
"<backref:%"PRIxPTR
">", (
intptr_t)node);
6630 for (i = 0; i < br->
back_num; i++) {
6631 if (i > 0) fputs(
", ",
f);
6632 fprintf(
f,
"%d", p[i]);
6637 #ifdef USE_SUBEXP_CALL 6641 fprintf(
f,
"<call:%"PRIxPTR
">", (
intptr_t)node);
6648 fprintf(
f,
"<quantifier:%"PRIxPTR
">{%d,%d}%s\n", (
intptr_t)node,
6650 (
NQTFR(node)->greedy ?
"" :
"?"));
6651 print_indent_tree(
f,
NQTFR(node)->target, indent +
add);
6655 fprintf(
f,
"<enclose:%"PRIxPTR
"> ", (
intptr_t)node);
6658 fprintf(
f,
"option:%d",
NENCLOSE(node)->option);
6661 fprintf(
f,
"memory:%d",
NENCLOSE(node)->regnum);
6664 fprintf(
f,
"stop-bt");
6667 fprintf(
f,
"condition:%d",
NENCLOSE(node)->regnum);
6674 print_indent_tree(
f,
NENCLOSE(node)->target, indent +
add);
6678 fprintf(
f,
"print_indent_tree: undefined node type %d\n",
NTYPE(node));
6686 if (container_p) print_indent_tree(
f,
NANCHOR(node)->target, indent +
add);
6692 #ifdef ONIG_DEBUG_PARSE_TREE 6696 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)
#define ONIGERR_INVALID_CONDITION_PATTERN
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)
static int max(int a, int b)
#define BBUF_ADD1(buf, byte)
#define ANCHOR_WORD_BEGIN
#define IS_ENCLOSE_RECURSION(en)
#define SIZE_OP_REPEAT_INC
#define NSTRING_IS_AMBIG(node)
static int compile_call(CallNode *node, regex_t *reg)
#define BBUF_WRITE(buf, pos, bytes, n)
static int add_multi_byte_cclass(BBuf *mbuf, regex_t *reg)
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)
#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 subexp_recursive_check(Node *node)
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)
if((ID)(DISPID) nameid !=nameid)
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 int subexp_recursive_check_trav(Node *node, ScanEnv *env)
#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_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME_CALL
#define ONIG_STATE_MODIFY
OnigCaseFoldType case_fold_flag
void onig_chain_link_add(regex_t *to, regex_t *add)
#define RECURSION_INFINITE
#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
#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)
static void unset_addr_list_end(UnsetAddrList *uslist)
#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)
static int numbered_ref_check(Node *node)
#define SIZE_OP_CONDITION
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 STACK_POP_LEVEL_ALL
#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC
static int quantifiers_memory_node_info(Node *node)
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
static int disable_noname_group_capture(Node **root, regex_t *reg, ScanEnv *env)
#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
size_t onig_region_memsize(const OnigRegion *regs)
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)
static int setup_subexp_call(Node *node, ScanEnv *env)
short int StateCheckNumType
struct re_pattern_buffer * chain
static void clear_optimize_info(regex_t *reg)
#define FOUND_CALLED_NODE
#define SIZE_OP_ANYCHAR_STAR
#define ALLOWED_TYPE_IN_LB
static int unset_addr_list_init(UnsetAddrList *uslist, int size)
#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
static int set_bm_skip(UChar *s, UChar *end, regex_t *reg, UChar skip[], int **int_skip, int ignore_case)
#define ONIGENC_CODE_TO_MBCLEN(enc, code)
#define SIZE_OP_MEMORY_END
#define ONIG_OPTIMIZE_EXACT_BM_IC
#define SIZE_OP_MEMORY_START_PUSH
static void alt_merge_node_opt_info(NodeOptInfo *to, NodeOptInfo *add, OptEnv *env)
static int noname_disable_map(Node **plink, GroupNumRemap *map, int *counter)
#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 IS_ENCLOSE_NAME_REF(en)
#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)
static int renumber_node_backref(Node *node, GroupNumRemap *map)
#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)
#define ONIGENC_IS_MBC_ASCII_WORD(enc, s, end)
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
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
static int subexp_inf_recursive_check(Node *node, ScanEnv *env, int head)
#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)
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
#define ENCLOSE_CONDITION
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 int renumber_by_map(Node *node, GroupNumRemap *map)
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 ONIGERR_DEFAULT_ENCODING_IS_NOT_SET
#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)
static int next_setup(Node *node, Node *next_node, int in_root, regex_t *reg)
UChar map[ONIG_CHAR_TABLE_SIZE]
BitStatusType bt_mem_start
static int subexp_inf_recursive_check_trav(Node *node, ScanEnv *env)
#define NSTRING_SET_DONT_GET_OPT_INFO(node)
#define SIZE_OP_PUSH_POS_NOT
#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)
void onig_free(regex_t *reg)
static int compile_length_enclose_node(EncloseNode *node, regex_t *reg)
static int unset_addr_list_add(UnsetAddrList *uslist, int offset, struct _Node *node)
#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)
static int unset_addr_list_fix(UnsetAddrList *uslist, regex_t *reg)
#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 enclen(enc, p, e)
#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)