summaryrefslogtreecommitdiff
path: root/src/regcomp.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff.email>2023-11-20 20:10:50 +0100
committerJörg Frings-Fürst <debian@jff.email>2023-11-20 20:10:50 +0100
commit35e13e4c9637f5bf7bef6039c8c813207780a174 (patch)
treef2ea0b1aa455bb2552ffe8a7bb083f24e86d1f34 /src/regcomp.c
parentdb6f38bc1b73930f1da954525464cf1986f43a28 (diff)
New upstream version 6.9.9upstream/6.9.9upstream
Diffstat (limited to 'src/regcomp.c')
-rw-r--r--src/regcomp.c1772
1 files changed, 920 insertions, 852 deletions
diff --git a/src/regcomp.c b/src/regcomp.c
index d341c38..10da9c4 100644
--- a/src/regcomp.c
+++ b/src/regcomp.c
@@ -2,7 +2,7 @@
regcomp.c - Oniguruma (regular expression library)
**********************************************************************/
/*-
- * Copyright (c) 2002-2022 K.Kosako
+ * Copyright (c) 2002-2023 K.Kosako
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -31,8 +31,8 @@
#define OPS_INIT_SIZE 8
-#define NODE_IS_REAL_IGNORECASE(node) \
- (NODE_IS_IGNORECASE(node) && !NODE_STRING_IS_CRUDE(node))
+#define ND_IS_REAL_IGNORECASE(node) \
+ (ND_IS_IGNORECASE(node) && !ND_STRING_IS_CRUDE(node))
typedef struct {
OnigLen min;
@@ -360,7 +360,7 @@ node_swap(Node* a, Node* b)
c = *a; *a = *b; *b = c;
- if (NODE_TYPE(a) == NODE_STRING) {
+ if (ND_TYPE(a) == ND_STRING) {
StrNode* sn = STR_(a);
if (sn->capacity == 0) {
int len = (int )(sn->end - sn->s);
@@ -369,7 +369,7 @@ node_swap(Node* a, Node* b)
}
}
- if (NODE_TYPE(b) == NODE_STRING) {
+ if (ND_TYPE(b) == ND_STRING) {
StrNode* sn = STR_(b);
if (sn->capacity == 0) {
int len = (int )(sn->end - sn->s);
@@ -385,8 +385,8 @@ node_list_len(Node* list)
int len;
len = 1;
- while (IS_NOT_NULL(NODE_CDR(list))) {
- list = NODE_CDR(list);
+ while (IS_NOT_NULL(ND_CDR(list))) {
+ list = ND_CDR(list);
len++;
}
@@ -402,10 +402,10 @@ node_list_add(Node* list, Node* x)
if (IS_NULL(n)) return NULL_NODE;
if (IS_NOT_NULL(list)) {
- while (IS_NOT_NULL(NODE_CDR(list)))
- list = NODE_CDR(list);
+ while (IS_NOT_NULL(ND_CDR(list)))
+ list = ND_CDR(list);
- NODE_CDR(list) = n;
+ ND_CDR(list) = n;
}
return n;
@@ -416,7 +416,7 @@ node_str_node_cat(Node* node, Node* add)
{
int r;
- if (NODE_STATUS(node) != NODE_STATUS(add))
+ if (ND_STATUS(node) != ND_STATUS(add))
return ONIGERR_TYPE_BUG;
if (STR_(node)->flag != STR_(add)->flag)
@@ -432,8 +432,8 @@ static void
node_conv_to_str_node(Node* node, Node* ref_node)
{
xmemset(node, 0, sizeof(*node));
- NODE_SET_TYPE(node, NODE_STRING);
- NODE_STATUS(node) = NODE_STATUS(ref_node);
+ ND_SET_TYPE(node, ND_STRING);
+ ND_STATUS(node) = ND_STATUS(ref_node);
STR_(node)->flag = STR_(ref_node)->flag;
STR_(node)->s = STR_(node)->buf;
@@ -639,12 +639,12 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
level++;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
{
int first = TRUE;
do {
- r = node_char_len1(NODE_CAR(node), reg, &tci, env, level);
+ r = node_char_len1(ND_CAR(node), reg, &tci, env, level);
if (r < 0) break;
if (first == TRUE) {
*ci = tci;
@@ -652,20 +652,20 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
}
else
mmcl_add(ci, &tci);
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
}
break;
- case NODE_ALT:
+ case ND_ALT:
{
int fixed;
- r = node_char_len1(NODE_CAR(node), reg, ci, env, level);
+ r = node_char_len1(ND_CAR(node), reg, ci, env, level);
if (r < 0) break;
fixed = TRUE;
- while (IS_NOT_NULL(node = NODE_CDR(node))) {
- r = node_char_len1(NODE_CAR(node), reg, &tci, env, level);
+ while (IS_NOT_NULL(node = ND_CDR(node))) {
+ r = node_char_len1(ND_CAR(node), reg, &tci, env, level);
if (r < 0) break;
if (! mmcl_fixed(&tci))
fixed = FALSE;
@@ -682,13 +682,13 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
}
break;
- case NODE_STRING:
+ case ND_STRING:
{
OnigLen clen;
StrNode* sn = STR_(node);
UChar *s = sn->s;
- if (NODE_IS_REAL_IGNORECASE(node) &&
+ if (ND_IS_REAL_IGNORECASE(node) &&
CASE_FOLD_IS_NOT_ASCII_ONLY(env->case_fold_flag)) {
/* Such a case is possible.
ex. /(?i)(?<=\1)(a)/
@@ -707,7 +707,7 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
}
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
@@ -716,13 +716,13 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
mmcl_set(ci, 0);
}
else {
- r = node_char_len1(NODE_BODY(node), reg, ci, env, level);
+ r = node_char_len1(ND_BODY(node), reg, ci, env, level);
if (r < 0) break;
mmcl_multiply(ci, qn->lower);
}
}
else {
- r = node_char_len1(NODE_BODY(node), reg, ci, env, level);
+ r = node_char_len1(ND_BODY(node), reg, ci, env, level);
if (r < 0) break;
mmcl_repeat_range_multiply(ci, qn->lower, qn->upper);
}
@@ -730,44 +730,44 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
break;
#ifdef USE_CALL
- case NODE_CALL:
- if (NODE_IS_RECURSION(node))
+ case ND_CALL:
+ if (ND_IS_RECURSION(node))
mmcl_set_min_max(ci, 0, INFINITE_LEN, FALSE);
else
- r = node_char_len1(NODE_BODY(node), reg, ci, env, level);
+ r = node_char_len1(ND_BODY(node), reg, ci, env, level);
break;
#endif
- case NODE_CTYPE:
- case NODE_CCLASS:
+ case ND_CTYPE:
+ case ND_CCLASS:
mmcl_set(ci, 1);
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
switch (en->type) {
case BAG_MEMORY:
- if (NODE_IS_FIXED_CLEN(node)) {
+ if (ND_IS_FIXED_CLEN(node)) {
mmcl_set_min_max(ci, en->min_char_len, en->max_char_len,
- NODE_IS_FIXED_CLEN_MIN_SURE(node));
+ ND_IS_FIXED_CLEN_MIN_SURE(node));
}
else {
- if (NODE_IS_MARK1(node)) {
+ if (ND_IS_MARK1(node)) {
mmcl_set_min_max(ci, 0, INFINITE_LEN, FALSE);
}
else {
- NODE_STATUS_ADD(node, MARK1);
- r = node_char_len1(NODE_BODY(node), reg, ci, env, level);
- NODE_STATUS_REMOVE(node, MARK1);
+ ND_STATUS_ADD(node, MARK1);
+ r = node_char_len1(ND_BODY(node), reg, ci, env, level);
+ ND_STATUS_REMOVE(node, MARK1);
if (r < 0) break;
en->min_char_len = ci->min;
en->max_char_len = ci->max;
- NODE_STATUS_ADD(node, FIXED_CLEN);
+ ND_STATUS_ADD(node, FIXED_CLEN);
if (ci->min_is_sure != FALSE)
- NODE_STATUS_ADD(node, FIXED_CLEN_MIN_SURE);
+ ND_STATUS_ADD(node, FIXED_CLEN_MIN_SURE);
}
}
/* can't optimize look-behind if capture exists. */
@@ -775,13 +775,13 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
break;
case BAG_OPTION:
case BAG_STOP_BACKTRACK:
- r = node_char_len1(NODE_BODY(node), reg, ci, env, level);
+ r = node_char_len1(ND_BODY(node), reg, ci, env, level);
break;
case BAG_IF_ELSE:
{
MinMaxCharLen eci;
- r = node_char_len1(NODE_BODY(node), reg, ci, env, level);
+ r = node_char_len1(ND_BODY(node), reg, ci, env, level);
if (r < 0) break;
if (IS_NOT_NULL(en->te.Then)) {
@@ -808,24 +808,24 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
}
break;
- case NODE_GIMMICK:
+ case ND_GIMMICK:
mmcl_set(ci, 0);
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
zero:
mmcl_set(ci, 0);
/* can't optimize look-behind if anchor exists. */
ci->min_is_sure = FALSE;
break;
- case NODE_BACKREF:
- if (NODE_IS_CHECKER(node))
+ case ND_BACKREF:
+ if (ND_IS_CHECKER(node))
goto zero;
- if (NODE_IS_RECURSION(node)) {
+ if (ND_IS_RECURSION(node)) {
#ifdef USE_BACKREF_WITH_LEVEL
- if (NODE_IS_NEST_LEVEL(node)) {
+ if (ND_IS_NEST_LEVEL(node)) {
mmcl_set_min_max(ci, 0, INFINITE_LEN, FALSE);
break;
}
@@ -887,7 +887,7 @@ add_op(regex_t* reg, int opcode)
return 0;
}
-static int compile_length_tree(Node* node, regex_t* reg);
+static int compile_length_tree(Node* node, regex_t* reg, ParseEnv* env);
static int compile_tree(Node* node, regex_t* reg, ParseEnv* env);
@@ -936,16 +936,16 @@ select_str_opcode(int mb_len, int str_len)
static int
is_strict_real_node(Node* node)
{
- switch (NODE_TYPE(node)) {
- case NODE_STRING:
+ switch (ND_TYPE(node)) {
+ case ND_STRING:
{
StrNode* sn = STR_(node);
return (sn->end != sn->s);
}
break;
- case NODE_CCLASS:
- case NODE_CTYPE:
+ case ND_CCLASS:
+ case ND_CTYPE:
return 1;
break;
@@ -963,7 +963,7 @@ compile_quant_body_with_empty_check(QuantNode* qn, regex_t* reg, ParseEnv* env)
int emptiness;
Node* body;
- body = NODE_BODY((Node* )qn);
+ body = ND_BODY((Node* )qn);
emptiness = qn->emptiness;
saved_num_empty_check = reg->num_empty_check;
@@ -981,7 +981,7 @@ compile_quant_body_with_empty_check(QuantNode* qn, regex_t* reg, ParseEnv* env)
if (emptiness == BODY_MAY_BE_EMPTY)
r = add_op(reg, OP_EMPTY_CHECK_END);
else if (emptiness == BODY_MAY_BE_EMPTY_MEM) {
- if (NODE_IS_EMPTY_STATUS_CHECK(qn) != 0 && qn->empty_status_mem != 0) {
+ if (ND_IS_EMPTY_STATUS_CHECK(qn) != 0 && qn->empty_status_mem != 0) {
r = add_op(reg, OP_EMPTY_CHECK_END_MEMST);
if (r != 0) return r;
COP(reg)->empty_check_end.empty_status_mem = qn->empty_status_mem;
@@ -1019,7 +1019,7 @@ compile_call(CallNode* node, regex_t* reg, ParseEnv* env)
#endif
offset = COP_CURR_OFFSET_BYTES(reg, call.addr);
- r = unset_addr_list_add(env->unset_addr_list, offset, NODE_CALL_BODY(node));
+ r = unset_addr_list_add(env->unset_addr_list, offset, ND_CALL_BODY(node));
return r;
}
#endif
@@ -1312,7 +1312,7 @@ static int
is_anychar_infinite_greedy(QuantNode* qn)
{
if (qn->greedy && IS_INFINITE_REPEAT(qn->upper) &&
- NODE_IS_ANYCHAR(NODE_QUANT_BODY(qn)))
+ ND_IS_ANYCHAR(ND_QUANT_BODY(qn)))
return 1;
else
return 0;
@@ -1322,12 +1322,12 @@ is_anychar_infinite_greedy(QuantNode* qn)
#define CKN_ON (ckn > 0)
static int
-compile_length_quantifier_node(QuantNode* qn, regex_t* reg)
+compile_length_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
{
int len, mod_tlen;
int infinite = IS_INFINITE_REPEAT(qn->upper);
enum BodyEmptyType emptiness = qn->emptiness;
- int tlen = compile_length_tree(NODE_QUANT_BODY(qn), reg);
+ int tlen = compile_length_tree(ND_QUANT_BODY(qn), reg, env);
if (tlen < 0) return tlen;
if (tlen == 0) return 0;
@@ -1401,7 +1401,7 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
int i, r, mod_tlen;
int infinite = IS_INFINITE_REPEAT(qn->upper);
enum BodyEmptyType emptiness = qn->emptiness;
- int tlen = compile_length_tree(NODE_QUANT_BODY(qn), reg);
+ int tlen = compile_length_tree(ND_QUANT_BODY(qn), reg, env);
if (tlen < 0) return tlen;
if (tlen == 0) return 0;
@@ -1410,10 +1410,10 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
(qn->lower <= 1 ||
len_multiply_cmp((OnigLen )tlen, qn->lower,
QUANTIFIER_EXPAND_LIMIT_SIZE) <= 0)) {
- r = compile_tree_n_times(NODE_QUANT_BODY(qn), qn->lower, reg, env);
+ r = compile_tree_n_times(ND_QUANT_BODY(qn), qn->lower, reg, env);
if (r != 0) return r;
if (IS_NOT_NULL(qn->next_head_exact)) {
- r = add_op(reg, NODE_IS_MULTILINE(NODE_QUANT_BODY(qn)) ?
+ r = add_op(reg, ND_IS_MULTILINE(ND_QUANT_BODY(qn)) ?
OP_ANYCHAR_ML_STAR_PEEK_NEXT : OP_ANYCHAR_STAR_PEEK_NEXT);
if (r != 0) return r;
@@ -1421,7 +1421,7 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
return 0;
}
else {
- r = add_op(reg, NODE_IS_MULTILINE(NODE_QUANT_BODY(qn)) ?
+ r = add_op(reg, ND_IS_MULTILINE(ND_QUANT_BODY(qn)) ?
OP_ANYCHAR_ML_STAR : OP_ANYCHAR_STAR);
return r;
}
@@ -1456,7 +1456,7 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
}
}
else {
- r = compile_tree_n_times(NODE_QUANT_BODY(qn), qn->lower, reg, env);
+ r = compile_tree_n_times(ND_QUANT_BODY(qn), qn->lower, reg, env);
if (r != 0) return r;
}
@@ -1520,7 +1520,7 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
if (r != 0) return r;
COP(reg)->jump.addr = tlen + SIZE_INC;
- r = compile_tree(NODE_QUANT_BODY(qn), reg, env);
+ r = compile_tree(ND_QUANT_BODY(qn), reg, env);
}
else {
/* Nothing output */
@@ -1533,7 +1533,7 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
QUANTIFIER_EXPAND_LIMIT_SIZE) <= 0)) {
int n = qn->upper - qn->lower;
- r = compile_tree_n_times(NODE_QUANT_BODY(qn), qn->lower, reg, env);
+ r = compile_tree_n_times(ND_QUANT_BODY(qn), qn->lower, reg, env);
if (r != 0) return r;
for (i = 0; i < n; i++) {
@@ -1544,7 +1544,7 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
if (r != 0) return r;
COP(reg)->push.addr = v;
- r = compile_tree(NODE_QUANT_BODY(qn), reg, env);
+ r = compile_tree(ND_QUANT_BODY(qn), reg, env);
if (r != 0) return r;
}
}
@@ -1557,7 +1557,7 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
if (r != 0) return r;
COP(reg)->jump.addr = tlen + SIZE_INC;
- r = compile_tree(NODE_QUANT_BODY(qn), reg, env);
+ r = compile_tree(ND_QUANT_BODY(qn), reg, env);
}
else {
r = compile_range_repeat_node(qn, mod_tlen, emptiness, reg, env);
@@ -1566,11 +1566,11 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
}
static int
-compile_length_option_node(BagNode* node, regex_t* reg)
+compile_length_option_node(BagNode* node, regex_t* reg, ParseEnv* env)
{
int tlen;
- tlen = compile_length_tree(NODE_BAG_BODY(node), reg);
+ tlen = compile_length_tree(ND_BAG_BODY(node), reg, env);
return tlen;
}
@@ -1580,22 +1580,22 @@ compile_option_node(BagNode* node, regex_t* reg, ParseEnv* env)
{
int r;
- r = compile_tree(NODE_BAG_BODY(node), reg, env);
+ r = compile_tree(ND_BAG_BODY(node), reg, env);
return r;
}
static int
-compile_length_bag_node(BagNode* node, regex_t* reg)
+compile_length_bag_node(BagNode* node, regex_t* reg, ParseEnv* env)
{
int len;
int tlen;
if (node->type == BAG_OPTION)
- return compile_length_option_node(node, reg);
+ return compile_length_option_node(node, reg, env);
- if (NODE_BAG_BODY(node)) {
- tlen = compile_length_tree(NODE_BAG_BODY(node), reg);
+ if (ND_BAG_BODY(node)) {
+ tlen = compile_length_tree(ND_BAG_BODY(node), reg, env);
if (tlen < 0) return tlen;
}
else
@@ -1605,22 +1605,22 @@ compile_length_bag_node(BagNode* node, regex_t* reg)
case BAG_MEMORY:
#ifdef USE_CALL
- if (node->m.regnum == 0 && NODE_IS_CALLED(node)) {
+ if (node->m.regnum == 0 && ND_IS_CALLED(node)) {
len = tlen + OPSIZE_CALL + OPSIZE_JUMP + OPSIZE_RETURN;
return len;
}
- if (NODE_IS_CALLED(node)) {
+ if (ND_IS_CALLED(node)) {
len = OPSIZE_MEM_START_PUSH + tlen
+ OPSIZE_CALL + OPSIZE_JUMP + OPSIZE_RETURN;
if (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum))
- len += (NODE_IS_RECURSION(node)
+ len += (ND_IS_RECURSION(node)
? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_PUSH);
else
- len += (NODE_IS_RECURSION(node)
+ len += (ND_IS_RECURSION(node)
? OPSIZE_MEM_END_REC : OPSIZE_MEM_END);
}
- else if (NODE_IS_RECURSION(node)) {
+ else if (ND_IS_RECURSION(node)) {
len = OPSIZE_MEM_START_PUSH;
len += tlen + (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum)
? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_REC);
@@ -1639,12 +1639,12 @@ compile_length_bag_node(BagNode* node, regex_t* reg)
break;
case BAG_STOP_BACKTRACK:
- if (NODE_IS_STRICT_REAL_REPEAT(node)) {
+ if (ND_IS_STRICT_REAL_REPEAT(node)) {
int v;
QuantNode* qn;
- qn = QUANT_(NODE_BAG_BODY(node));
- tlen = compile_length_tree(NODE_QUANT_BODY(qn), reg);
+ qn = QUANT_(ND_BAG_BODY(node));
+ tlen = compile_length_tree(ND_QUANT_BODY(qn), reg, env);
if (tlen < 0) return tlen;
v = onig_positive_int_multiply(qn->lower, tlen);
@@ -1658,16 +1658,16 @@ compile_length_bag_node(BagNode* node, regex_t* reg)
case BAG_IF_ELSE:
{
- Node* cond = NODE_BAG_BODY(node);
+ Node* cond = ND_BAG_BODY(node);
Node* Then = node->te.Then;
Node* Else = node->te.Else;
- len = compile_length_tree(cond, reg);
+ len = compile_length_tree(cond, reg, env);
if (len < 0) return len;
len += OPSIZE_PUSH + OPSIZE_MARK + OPSIZE_CUT_TO_MARK;
if (IS_NOT_NULL(Then)) {
- tlen = compile_length_tree(Then, reg);
+ tlen = compile_length_tree(Then, reg, env);
if (tlen < 0) return tlen;
len += tlen;
}
@@ -1675,7 +1675,7 @@ compile_length_bag_node(BagNode* node, regex_t* reg)
len += OPSIZE_JUMP + OPSIZE_CUT_TO_MARK;
if (IS_NOT_NULL(Else)) {
- tlen = compile_length_tree(Else, reg);
+ tlen = compile_length_tree(Else, reg, env);
if (tlen < 0) return tlen;
len += tlen;
}
@@ -1686,6 +1686,10 @@ compile_length_bag_node(BagNode* node, regex_t* reg)
/* never come here, but set for escape warning */
len = 0;
break;
+
+ default:
+ return ONIGERR_TYPE_BUG;
+ break;
}
return len;
@@ -1697,38 +1701,38 @@ compile_bag_memory_node(BagNode* node, regex_t* reg, ParseEnv* env)
int r;
#ifdef USE_CALL
- if (NODE_IS_CALLED(node)) {
+ if (ND_IS_CALLED(node)) {
int len;
r = add_op(reg, OP_CALL);
if (r != 0) return r;
node->m.called_addr = COP_CURR_OFFSET(reg) + 1 + OPSIZE_JUMP;
- NODE_STATUS_ADD(node, FIXED_ADDR);
+ ND_STATUS_ADD(node, FIXED_ADDR);
COP(reg)->call.addr = (int )node->m.called_addr;
if (node->m.regnum == 0) {
- len = compile_length_tree(NODE_BAG_BODY(node), reg);
+ len = compile_length_tree(ND_BAG_BODY(node), reg, env);
len += OPSIZE_RETURN;
r = add_op(reg, OP_JUMP);
if (r != 0) return r;
COP(reg)->jump.addr = len + SIZE_INC;
- r = compile_tree(NODE_BAG_BODY(node), reg, env);
+ r = compile_tree(ND_BAG_BODY(node), reg, env);
if (r != 0) return r;
r = add_op(reg, OP_RETURN);
return r;
}
else {
- len = compile_length_tree(NODE_BAG_BODY(node), reg);
+ len = compile_length_tree(ND_BAG_BODY(node), reg, env);
len += (OPSIZE_MEM_START_PUSH + OPSIZE_RETURN);
if (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum))
- len += (NODE_IS_RECURSION(node)
+ len += (ND_IS_RECURSION(node)
? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_PUSH);
else
- len += (NODE_IS_RECURSION(node) ? OPSIZE_MEM_END_REC : OPSIZE_MEM_END);
+ len += (ND_IS_RECURSION(node) ? OPSIZE_MEM_END_REC : OPSIZE_MEM_END);
r = add_op(reg, OP_JUMP);
if (r != 0) return r;
@@ -1744,19 +1748,19 @@ compile_bag_memory_node(BagNode* node, regex_t* reg, ParseEnv* env)
if (r != 0) return r;
COP(reg)->memory_start.num = node->m.regnum;
- r = compile_tree(NODE_BAG_BODY(node), reg, env);
+ r = compile_tree(ND_BAG_BODY(node), reg, env);
if (r != 0) return r;
#ifdef USE_CALL
if (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum))
- r = add_op(reg, (NODE_IS_RECURSION(node)
+ r = add_op(reg, (ND_IS_RECURSION(node)
? OP_MEM_END_PUSH_REC : OP_MEM_END_PUSH));
else
- r = add_op(reg, (NODE_IS_RECURSION(node) ? OP_MEM_END_REC : OP_MEM_END));
+ r = add_op(reg, (ND_IS_RECURSION(node) ? OP_MEM_END_REC : OP_MEM_END));
if (r != 0) return r;
COP(reg)->memory_end.num = node->m.regnum;
- if (NODE_IS_CALLED(node)) {
+ if (ND_IS_CALLED(node)) {
r = add_op(reg, OP_RETURN);
}
#else
@@ -1786,19 +1790,19 @@ compile_bag_node(BagNode* node, regex_t* reg, ParseEnv* env)
break;
case BAG_STOP_BACKTRACK:
- if (NODE_IS_STRICT_REAL_REPEAT(node)) {
- QuantNode* qn = QUANT_(NODE_BAG_BODY(node));
- r = compile_tree_n_times(NODE_QUANT_BODY(qn), qn->lower, reg, env);
+ if (ND_IS_STRICT_REAL_REPEAT(node)) {
+ QuantNode* qn = QUANT_(ND_BAG_BODY(node));
+ r = compile_tree_n_times(ND_QUANT_BODY(qn), qn->lower, reg, env);
if (r != 0) return r;
- len = compile_length_tree(NODE_QUANT_BODY(qn), reg);
+ len = compile_length_tree(ND_QUANT_BODY(qn), reg, env);
if (len < 0) return len;
r = add_op(reg, OP_PUSH);
if (r != 0) return r;
COP(reg)->push.addr = SIZE_INC + len + OPSIZE_POP + OPSIZE_JUMP;
- r = compile_tree(NODE_QUANT_BODY(qn), reg, env);
+ r = compile_tree(ND_QUANT_BODY(qn), reg, env);
if (r != 0) return r;
r = add_op(reg, OP_POP);
if (r != 0) return r;
@@ -1816,7 +1820,7 @@ compile_bag_node(BagNode* node, regex_t* reg, ParseEnv* env)
COP(reg)->mark.id = mid;
COP(reg)->mark.save_pos = 0;
- r = compile_tree(NODE_BAG_BODY(node), reg, env);
+ r = compile_tree(ND_BAG_BODY(node), reg, env);
if (r != 0) return r;
r = add_op(reg, OP_CUT_TO_MARK);
if (r != 0) return r;
@@ -1829,7 +1833,7 @@ compile_bag_node(BagNode* node, regex_t* reg, ParseEnv* env)
{
int cond_len, then_len, else_len, jump_len;
MemNumType mid;
- Node* cond = NODE_BAG_BODY(node);
+ Node* cond = ND_BAG_BODY(node);
Node* Then = node->te.Then;
Node* Else = node->te.Else;
@@ -1840,10 +1844,10 @@ compile_bag_node(BagNode* node, regex_t* reg, ParseEnv* env)
COP(reg)->mark.id = mid;
COP(reg)->mark.save_pos = 0;
- cond_len = compile_length_tree(cond, reg);
+ cond_len = compile_length_tree(cond, reg, env);
if (cond_len < 0) return cond_len;
if (IS_NOT_NULL(Then)) {
- then_len = compile_length_tree(Then, reg);
+ then_len = compile_length_tree(Then, reg, env);
if (then_len < 0) return then_len;
}
else
@@ -1868,7 +1872,7 @@ compile_bag_node(BagNode* node, regex_t* reg, ParseEnv* env)
}
if (IS_NOT_NULL(Else)) {
- else_len = compile_length_tree(Else, reg);
+ else_len = compile_length_tree(Else, reg, env);
if (else_len < 0) return else_len;
}
else
@@ -1888,19 +1892,23 @@ compile_bag_node(BagNode* node, regex_t* reg, ParseEnv* env)
}
}
break;
+
+ default:
+ return ONIGERR_TYPE_BUG;
+ break;
}
return r;
}
static int
-compile_length_anchor_node(AnchorNode* node, regex_t* reg)
+compile_length_anchor_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
{
int len;
int tlen = 0;
- if (IS_NOT_NULL(NODE_ANCHOR_BODY(node))) {
- tlen = compile_length_tree(NODE_ANCHOR_BODY(node), reg);
+ if (IS_NOT_NULL(ND_ANCHOR_BODY(node))) {
+ tlen = compile_length_tree(ND_ANCHOR_BODY(node), reg, env);
if (tlen < 0) return tlen;
}
@@ -1918,11 +1926,14 @@ compile_length_anchor_node(AnchorNode* node, regex_t* reg)
len = OPSIZE_SAVE_VAL + OPSIZE_UPDATE_VAR + OPSIZE_MARK + OPSIZE_PUSH + OPSIZE_UPDATE_VAR + OPSIZE_FAIL + OPSIZE_JUMP + OPSIZE_STEP_BACK_START + OPSIZE_STEP_BACK_NEXT + tlen + OPSIZE_CHECK_POSITION + OPSIZE_CUT_TO_MARK + OPSIZE_UPDATE_VAR;
if (IS_NOT_NULL(node->lead_node)) {
- int llen = compile_length_tree(node->lead_node, reg);
+ int llen = compile_length_tree(node->lead_node, reg, env);
if (llen < 0) return llen;
len += OPSIZE_MOVE + llen;
}
+
+ if ((env->flags & PE_FLAG_HAS_ABSENT_STOPPER) != 0)
+ len += OPSIZE_SAVE_VAL + OPSIZE_UPDATE_VAR;
}
break;
case ANCR_LOOK_BEHIND_NOT:
@@ -1932,11 +1943,14 @@ compile_length_anchor_node(AnchorNode* node, regex_t* reg)
len = OPSIZE_SAVE_VAL + OPSIZE_UPDATE_VAR + OPSIZE_MARK + OPSIZE_PUSH + OPSIZE_STEP_BACK_START + OPSIZE_STEP_BACK_NEXT + tlen + OPSIZE_CHECK_POSITION + OPSIZE_POP_TO_MARK + OPSIZE_UPDATE_VAR + OPSIZE_POP + OPSIZE_FAIL + OPSIZE_UPDATE_VAR + OPSIZE_POP + OPSIZE_POP;
if (IS_NOT_NULL(node->lead_node)) {
- int llen = compile_length_tree(node->lead_node, reg);
+ int llen = compile_length_tree(node->lead_node, reg, env);
if (llen < 0) return llen;
len += OPSIZE_MOVE + llen;
}
+
+ if ((env->flags & PE_FLAG_HAS_ABSENT_STOPPER) != 0)
+ len += OPSIZE_SAVE_VAL + OPSIZE_UPDATE_VAR;
}
break;
@@ -1982,7 +1996,7 @@ compile_anchor_look_behind_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
COP(reg)->step_back_start.remaining = 0;
COP(reg)->step_back_start.addr = 1;
- r = compile_tree(NODE_ANCHOR_BODY(node), reg, env);
+ r = compile_tree(ND_ANCHOR_BODY(node), reg, env);
if (r != 0) return r;
r = add_op(reg, OP_CUT_TO_MARK);
@@ -1991,8 +2005,9 @@ compile_anchor_look_behind_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
COP(reg)->cut_to_mark.restore_pos = FALSE;
}
else {
- MemNumType mid1, mid2;
OnigLen diff;
+ MemNumType mid1, mid2;
+ MemNumType mid3 = 0; /* ignore uninitialized warning */
if (IS_NOT_NULL(node->lead_node)) {
MinMaxCharLen ci;
@@ -2038,6 +2053,14 @@ compile_anchor_look_behind_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
r = add_op(reg, OP_FAIL);
if (r != 0) return r;
+ if ((env->flags & PE_FLAG_HAS_ABSENT_STOPPER) != 0) {
+ ID_ENTRY(env, mid3);
+ r = add_op(reg, OP_SAVE_VAL);
+ if (r != 0) return r;
+ COP(reg)->save_val.type = SAVE_RIGHT_RANGE;
+ COP(reg)->save_val.id = mid3;
+ }
+
r = add_op(reg, OP_STEP_BACK_START);
if (r != 0) return r;
@@ -2053,9 +2076,17 @@ compile_anchor_look_behind_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
r = add_op(reg, OP_STEP_BACK_NEXT);
if (r != 0) return r;
- r = compile_tree(NODE_ANCHOR_BODY(node), reg, env);
+ r = compile_tree(ND_ANCHOR_BODY(node), reg, env);
if (r != 0) return r;
+ if ((env->flags & PE_FLAG_HAS_ABSENT_STOPPER) != 0) {
+ r = add_op(reg, OP_UPDATE_VAR);
+ if (r != 0) return r;
+ COP(reg)->update_var.type = UPDATE_VAR_RIGHT_RANGE_FROM_STACK;
+ COP(reg)->update_var.id = mid3;
+ COP(reg)->update_var.clear = FALSE;
+ }
+
r = add_op(reg, OP_CHECK_POSITION);
if (r != 0) return r;
COP(reg)->check_position.type = CHECK_POSITION_CURRENT_RIGHT_RANGE;
@@ -2082,7 +2113,7 @@ compile_anchor_look_behind_not_node(AnchorNode* node, regex_t* reg,
int r;
int len;
- len = compile_length_tree(NODE_ANCHOR_BODY(node), reg);
+ len = compile_length_tree(ND_ANCHOR_BODY(node), reg, env);
if (node->char_min_len == node->char_max_len) {
MemNumType mid;
@@ -2103,7 +2134,7 @@ compile_anchor_look_behind_not_node(AnchorNode* node, regex_t* reg,
COP(reg)->step_back_start.remaining = 0;
COP(reg)->step_back_start.addr = 1;
- r = compile_tree(NODE_ANCHOR_BODY(node), reg, env);
+ r = compile_tree(ND_ANCHOR_BODY(node), reg, env);
if (r != 0) return r;
r = add_op(reg, OP_POP_TO_MARK);
@@ -2114,8 +2145,9 @@ compile_anchor_look_behind_not_node(AnchorNode* node, regex_t* reg,
r = add_op(reg, OP_POP);
}
else {
- MemNumType mid1, mid2;
OnigLen diff;
+ MemNumType mid1, mid2;
+ MemNumType mid3 = 0; /* ignore uninitialized warning */
ID_ENTRY(env, mid1);
r = add_op(reg, OP_SAVE_VAL);
@@ -2135,13 +2167,16 @@ compile_anchor_look_behind_not_node(AnchorNode* node, regex_t* reg,
r = add_op(reg, OP_PUSH);
if (r != 0) return r;
+
COP(reg)->push.addr = SIZE_INC + OPSIZE_STEP_BACK_START + OPSIZE_STEP_BACK_NEXT + len + OPSIZE_CHECK_POSITION + OPSIZE_POP_TO_MARK + OPSIZE_UPDATE_VAR + OPSIZE_POP + OPSIZE_FAIL;
+ if ((env->flags & PE_FLAG_HAS_ABSENT_STOPPER) != 0)
+ COP(reg)->push.addr += OPSIZE_SAVE_VAL + OPSIZE_UPDATE_VAR;
if (IS_NOT_NULL(node->lead_node)) {
int clen;
MinMaxCharLen ci;
- clen = compile_length_tree(node->lead_node, reg);
+ clen = compile_length_tree(node->lead_node, reg, env);
COP(reg)->push.addr += OPSIZE_MOVE + clen;
r = node_char_len(node->lead_node, reg, &ci, env);
@@ -2154,6 +2189,14 @@ compile_anchor_look_behind_not_node(AnchorNode* node, regex_t* reg,
if (r != 0) return r;
}
+ if ((env->flags & PE_FLAG_HAS_ABSENT_STOPPER) != 0) {
+ ID_ENTRY(env, mid3);
+ r = add_op(reg, OP_SAVE_VAL);
+ if (r != 0) return r;
+ COP(reg)->save_val.type = SAVE_RIGHT_RANGE;
+ COP(reg)->save_val.id = mid3;
+ }
+
r = add_op(reg, OP_STEP_BACK_START);
if (r != 0) return r;
@@ -2169,9 +2212,17 @@ compile_anchor_look_behind_not_node(AnchorNode* node, regex_t* reg,
r = add_op(reg, OP_STEP_BACK_NEXT);
if (r != 0) return r;
- r = compile_tree(NODE_ANCHOR_BODY(node), reg, env);
+ r = compile_tree(ND_ANCHOR_BODY(node), reg, env);
if (r != 0) return r;
+ if ((env->flags & PE_FLAG_HAS_ABSENT_STOPPER) != 0) {
+ r = add_op(reg, OP_UPDATE_VAR);
+ if (r != 0) return r;
+ COP(reg)->update_var.type = UPDATE_VAR_RIGHT_RANGE_FROM_STACK;
+ COP(reg)->update_var.id = mid3;
+ COP(reg)->update_var.clear = FALSE;
+ }
+
r = add_op(reg, OP_CHECK_POSITION);
if (r != 0) return r;
COP(reg)->check_position.type = CHECK_POSITION_CURRENT_RIGHT_RANGE;
@@ -2254,7 +2305,7 @@ compile_anchor_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
type = EXTENDED_GRAPHEME_CLUSTER_BOUNDARY;
#ifdef USE_UNICODE_WORD_BREAK
- if (NODE_IS_TEXT_SEGMENT_WORD(node))
+ if (ND_IS_TEXT_SEGMENT_WORD(node))
type = WORD_BOUNDARY;
#endif
@@ -2272,7 +2323,7 @@ compile_anchor_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
COP(reg)->mark.id = mid;
COP(reg)->mark.save_pos = TRUE;
- r = compile_tree(NODE_ANCHOR_BODY(node), reg, env);
+ r = compile_tree(ND_ANCHOR_BODY(node), reg, env);
if (r != 0) return r;
r = add_op(reg, OP_CUT_TO_MARK);
@@ -2284,7 +2335,7 @@ compile_anchor_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
case ANCR_PREC_READ_NOT:
{
- len = compile_length_tree(NODE_ANCHOR_BODY(node), reg);
+ len = compile_length_tree(ND_ANCHOR_BODY(node), reg, env);
if (len < 0) return len;
ID_ENTRY(env, mid);
@@ -2298,7 +2349,7 @@ compile_anchor_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
COP(reg)->mark.id = mid;
COP(reg)->mark.save_pos = FALSE;
- r = compile_tree(NODE_ANCHOR_BODY(node), reg, env);
+ r = compile_tree(ND_ANCHOR_BODY(node), reg, env);
if (r != 0) return r;
r = add_op(reg, OP_POP_TO_MARK);
@@ -2416,78 +2467,82 @@ compile_length_gimmick_node(GimmickNode* node, regex_t* reg)
}
break;
#endif
+
+ default:
+ return ONIGERR_TYPE_BUG;
+ break;
}
return len;
}
static int
-compile_length_tree(Node* node, regex_t* reg)
+compile_length_tree(Node* node, regex_t* reg, ParseEnv* env)
{
int len, r;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
len = 0;
do {
- r = compile_length_tree(NODE_CAR(node), reg);
+ r = compile_length_tree(ND_CAR(node), reg, env);
if (r < 0) return r;
len += r;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
r = len;
break;
- case NODE_ALT:
+ case ND_ALT:
{
int n;
n = r = 0;
do {
- r += compile_length_tree(NODE_CAR(node), reg);
+ r += compile_length_tree(ND_CAR(node), reg, env);
n++;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
r += (OPSIZE_PUSH + OPSIZE_JUMP) * (n - 1);
}
break;
- case NODE_STRING:
- if (NODE_STRING_IS_CRUDE(node))
+ case ND_STRING:
+ if (ND_STRING_IS_CRUDE(node))
r = compile_length_string_crude_node(STR_(node), reg);
else
r = compile_length_string_node(node, reg);
break;
- case NODE_CCLASS:
+ case ND_CCLASS:
r = compile_length_cclass_node(CCLASS_(node), reg);
break;
- case NODE_CTYPE:
+ case ND_CTYPE:
r = SIZE_OPCODE;
break;
- case NODE_BACKREF:
+ case ND_BACKREF:
r = OPSIZE_BACKREF;
break;
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
r = OPSIZE_CALL;
break;
#endif
- case NODE_QUANT:
- r = compile_length_quantifier_node(QUANT_(node), reg);
+ case ND_QUANT:
+ r = compile_length_quantifier_node(QUANT_(node), reg, env);
break;
- case NODE_BAG:
- r = compile_length_bag_node(BAG_(node), reg);
+ case ND_BAG:
+ r = compile_length_bag_node(BAG_(node), reg, env);
break;
- case NODE_ANCHOR:
- r = compile_length_anchor_node(ANCHOR_(node), reg);
+ case ND_ANCHOR:
+ r = compile_length_anchor_node(ANCHOR_(node), reg, env);
break;
- case NODE_GIMMICK:
+ case ND_GIMMICK:
r = compile_length_gimmick_node(GIMMICK_(node), reg);
break;
@@ -2504,63 +2559,63 @@ compile_tree(Node* node, regex_t* reg, ParseEnv* env)
{
int n, len, pos, r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
do {
- r = compile_tree(NODE_CAR(node), reg, env);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = compile_tree(ND_CAR(node), reg, env);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ALT:
+ case ND_ALT:
{
Node* x = node;
len = 0;
do {
- len += compile_length_tree(NODE_CAR(x), reg);
- if (IS_NOT_NULL(NODE_CDR(x))) {
+ len += compile_length_tree(ND_CAR(x), reg, env);
+ if (IS_NOT_NULL(ND_CDR(x))) {
len += OPSIZE_PUSH + OPSIZE_JUMP;
}
- } while (IS_NOT_NULL(x = NODE_CDR(x)));
+ } while (IS_NOT_NULL(x = ND_CDR(x)));
pos = COP_CURR_OFFSET(reg) + 1 + len; /* goal position */
do {
- len = compile_length_tree(NODE_CAR(node), reg);
- if (IS_NOT_NULL(NODE_CDR(node))) {
- enum OpCode push = NODE_IS_SUPER(node) ? OP_PUSH_SUPER : OP_PUSH;
+ len = compile_length_tree(ND_CAR(node), reg, env);
+ if (IS_NOT_NULL(ND_CDR(node))) {
+ enum OpCode push = ND_IS_SUPER(node) ? OP_PUSH_SUPER : OP_PUSH;
r = add_op(reg, push);
if (r != 0) break;
COP(reg)->push.addr = SIZE_INC + len + OPSIZE_JUMP;
}
- r = compile_tree(NODE_CAR(node), reg, env);
+ r = compile_tree(ND_CAR(node), reg, env);
if (r != 0) break;
- if (IS_NOT_NULL(NODE_CDR(node))) {
+ if (IS_NOT_NULL(ND_CDR(node))) {
len = pos - (COP_CURR_OFFSET(reg) + 1);
r = add_op(reg, OP_JUMP);
if (r != 0) break;
COP(reg)->jump.addr = len;
}
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
}
break;
- case NODE_STRING:
- if (NODE_STRING_IS_CRUDE(node))
+ case ND_STRING:
+ if (ND_STRING_IS_CRUDE(node))
r = compile_string_crude_node(STR_(node), reg);
else
r = compile_string_node(node, reg);
break;
- case NODE_CCLASS:
+ case ND_CCLASS:
r = compile_cclass_node(CCLASS_(node), reg);
break;
- case NODE_CTYPE:
+ case ND_CTYPE:
{
int op;
switch (CTYPE_(node)->ctype) {
case CTYPE_ANYCHAR:
- r = add_op(reg, NODE_IS_MULTILINE(node) ? OP_ANYCHAR_ML : OP_ANYCHAR);
+ r = add_op(reg, ND_IS_MULTILINE(node) ? OP_ANYCHAR_ML : OP_ANYCHAR);
break;
case ONIGENC_CTYPE_WORD:
@@ -2580,13 +2635,13 @@ compile_tree(Node* node, regex_t* reg, ParseEnv* env)
}
break;
- case NODE_BACKREF:
+ case ND_BACKREF:
{
BackRefNode* br = BACKREF_(node);
- if (NODE_IS_CHECKER(node)) {
+ if (ND_IS_CHECKER(node)) {
#ifdef USE_BACKREF_WITH_LEVEL
- if (NODE_IS_NEST_LEVEL(node)) {
+ if (ND_IS_NEST_LEVEL(node)) {
r = add_op(reg, OP_BACKREF_CHECK_WITH_LEVEL);
if (r != 0) return r;
COP(reg)->backref_general.nest_level = br->nest_level;
@@ -2601,8 +2656,8 @@ compile_tree(Node* node, regex_t* reg, ParseEnv* env)
}
else {
#ifdef USE_BACKREF_WITH_LEVEL
- if (NODE_IS_NEST_LEVEL(node)) {
- if (NODE_IS_IGNORECASE(node))
+ if (ND_IS_NEST_LEVEL(node)) {
+ if (ND_IS_IGNORECASE(node))
r = add_op(reg, OP_BACKREF_WITH_LEVEL_IC);
else
r = add_op(reg, OP_BACKREF_WITH_LEVEL);
@@ -2615,7 +2670,7 @@ compile_tree(Node* node, regex_t* reg, ParseEnv* env)
#endif
if (br->back_num == 1) {
n = br->back_static[0];
- if (NODE_IS_IGNORECASE(node)) {
+ if (ND_IS_IGNORECASE(node)) {
r = add_op(reg, OP_BACKREF_N_IC);
if (r != 0) return r;
COP(reg)->backref_n.n1 = n;
@@ -2636,7 +2691,7 @@ compile_tree(Node* node, regex_t* reg, ParseEnv* env)
int num;
int* p;
- r = add_op(reg, NODE_IS_IGNORECASE(node) ?
+ r = add_op(reg, ND_IS_IGNORECASE(node) ?
OP_BACKREF_MULTI_IC : OP_BACKREF_MULTI);
if (r != 0) return r;
@@ -2664,30 +2719,30 @@ compile_tree(Node* node, regex_t* reg, ParseEnv* env)
break;
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
r = compile_call(CALL_(node), reg, env);
break;
#endif
- case NODE_QUANT:
+ case ND_QUANT:
r = compile_quantifier_node(QUANT_(node), reg, env);
break;
- case NODE_BAG:
+ case ND_BAG:
r = compile_bag_node(BAG_(node), reg, env);
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
r = compile_anchor_node(ANCHOR_(node), reg, env);
break;
- case NODE_GIMMICK:
+ case ND_GIMMICK:
r = compile_gimmick_node(GIMMICK_(node), reg);
break;
default:
#ifdef ONIG_DEBUG
- fprintf(DBGFP, "compile_tree: undefined node type %d\n", NODE_TYPE(node));
+ fprintf(DBGFP, "compile_tree: undefined node type %d\n", ND_TYPE(node));
#endif
break;
}
@@ -2701,40 +2756,40 @@ make_named_capture_number_map(Node** plink, GroupNumMap* map, int* counter)
int r;
Node* node = *plink;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = make_named_capture_number_map(&(NODE_CAR(node)), map, counter);
- } while (r >= 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = make_named_capture_number_map(&(ND_CAR(node)), map, counter);
+ } while (r >= 0 && IS_NOT_NULL(node = ND_CDR(node)));
if (r < 0) return r;
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
- Node** ptarget = &(NODE_BODY(node));
+ Node** ptarget = &(ND_BODY(node));
r = make_named_capture_number_map(ptarget, map, counter);
if (r < 0) return r;
- if (r == 1 && NODE_TYPE(*ptarget) == NODE_QUANT) {
+ if (r == 1 && ND_TYPE(*ptarget) == ND_QUANT) {
return onig_reduce_nested_quantifier(node);
}
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_NAMED_GROUP(node)) {
+ if (ND_IS_NAMED_GROUP(node)) {
(*counter)++;
map[en->m.regnum].new_val = *counter;
en->m.regnum = *counter;
- r = make_named_capture_number_map(&(NODE_BODY(node)), map, counter);
+ r = make_named_capture_number_map(&(ND_BODY(node)), map, counter);
if (r < 0) return r;
}
else {
- *plink = NODE_BODY(node);
- NODE_BODY(node) = NULL_NODE;
+ *plink = ND_BODY(node);
+ ND_BODY(node) = NULL_NODE;
onig_node_free(node);
r = make_named_capture_number_map(plink, map, counter);
if (r < 0) return r;
@@ -2742,7 +2797,7 @@ make_named_capture_number_map(Node** plink, GroupNumMap* map, int* counter)
}
}
else if (en->type == BAG_IF_ELSE) {
- r = make_named_capture_number_map(&(NODE_BAG_BODY(en)), map, counter);
+ r = make_named_capture_number_map(&(ND_BAG_BODY(en)), map, counter);
if (r < 0) return r;
if (IS_NOT_NULL(en->te.Then)) {
r = make_named_capture_number_map(&(en->te.Then), map, counter);
@@ -2754,15 +2809,15 @@ make_named_capture_number_map(Node** plink, GroupNumMap* map, int* counter)
}
}
else {
- r = make_named_capture_number_map(&(NODE_BODY(node)), map, counter);
+ r = make_named_capture_number_map(&(ND_BODY(node)), map, counter);
if (r < 0) return r;
}
}
break;
- case NODE_ANCHOR:
- if (IS_NOT_NULL(NODE_BODY(node))) {
- r = make_named_capture_number_map(&(NODE_BODY(node)), map, counter);
+ case ND_ANCHOR:
+ if (IS_NOT_NULL(ND_BODY(node))) {
+ r = make_named_capture_number_map(&(ND_BODY(node)), map, counter);
if (r < 0) return r;
}
break;
@@ -2781,7 +2836,7 @@ renumber_backref_node(Node* node, GroupNumMap* map)
int *backs;
BackRefNode* bn = BACKREF_(node);
- if (! NODE_IS_BY_NAME(node))
+ if (! ND_IS_BY_NAME(node))
return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
old_num = bn->back_num;
@@ -2807,23 +2862,23 @@ renumber_backref_traverse(Node* node, GroupNumMap* map)
{
int r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = renumber_backref_traverse(NODE_CAR(node), map);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = renumber_backref_traverse(ND_CAR(node), map);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
- r = renumber_backref_traverse(NODE_BODY(node), map);
+ case ND_QUANT:
+ r = renumber_backref_traverse(ND_BODY(node), map);
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
- r = renumber_backref_traverse(NODE_BODY(node), map);
+ r = renumber_backref_traverse(ND_BODY(node), map);
if (r != 0) return r;
if (en->type == BAG_IF_ELSE) {
@@ -2839,13 +2894,13 @@ renumber_backref_traverse(Node* node, GroupNumMap* map)
}
break;
- case NODE_BACKREF:
+ case ND_BACKREF:
r = renumber_backref_node(node, map);
break;
- case NODE_ANCHOR:
- if (IS_NOT_NULL(NODE_BODY(node)))
- r = renumber_backref_traverse(NODE_BODY(node), map);
+ case ND_ANCHOR:
+ if (IS_NOT_NULL(ND_BODY(node)))
+ r = renumber_backref_traverse(ND_BODY(node), map);
break;
default:
@@ -2860,27 +2915,27 @@ numbered_ref_check(Node* node)
{
int r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = numbered_ref_check(NODE_CAR(node));
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = numbered_ref_check(ND_CAR(node));
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ANCHOR:
- if (IS_NULL(NODE_BODY(node)))
+ case ND_ANCHOR:
+ if (IS_NULL(ND_BODY(node)))
break;
/* fall */
- case NODE_QUANT:
- r = numbered_ref_check(NODE_BODY(node));
+ case ND_QUANT:
+ r = numbered_ref_check(ND_BODY(node));
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
- r = numbered_ref_check(NODE_BODY(node));
+ r = numbered_ref_check(ND_BODY(node));
if (r != 0) return r;
if (en->type == BAG_IF_ELSE) {
@@ -2897,8 +2952,8 @@ numbered_ref_check(Node* node)
break;
- case NODE_BACKREF:
- if (! NODE_IS_BY_NAME(node))
+ case ND_BACKREF:
+ if (! ND_IS_BY_NAME(node))
return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
break;
@@ -2959,8 +3014,8 @@ fix_unset_addr_list(UnsetAddrList* uslist, regex_t* reg)
AbsAddrType* paddr;
for (i = 0; i < uslist->num; i++) {
- if (! NODE_IS_FIXED_ADDR(uslist->us[i].target)) {
- if (NODE_IS_CALLED(uslist->us[i].target))
+ if (! ND_IS_FIXED_ADDR(uslist->us[i].target)) {
+ if (ND_IS_CALLED(uslist->us[i].target))
return ONIGERR_PARSER_BUG;
else {
/* CASE: called node doesn't have called address.
@@ -2993,16 +3048,16 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
NodeType ytype;
retry:
- ytype = NODE_TYPE(y);
- switch (NODE_TYPE(x)) {
- case NODE_CTYPE:
+ ytype = ND_TYPE(y);
+ switch (ND_TYPE(x)) {
+ case ND_CTYPE:
{
if (CTYPE_(x)->ctype == CTYPE_ANYCHAR ||
CTYPE_(y)->ctype == CTYPE_ANYCHAR)
break;
switch (ytype) {
- case NODE_CTYPE:
+ case ND_CTYPE:
if (CTYPE_(y)->ctype == CTYPE_(x)->ctype &&
CTYPE_(y)->not != CTYPE_(x)->not &&
CTYPE_(y)->ascii_mode == CTYPE_(x)->ascii_mode)
@@ -3011,7 +3066,7 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
return 0;
break;
- case NODE_CCLASS:
+ case ND_CCLASS:
swap:
{
Node* tmp;
@@ -3020,7 +3075,7 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
}
break;
- case NODE_STRING:
+ case ND_STRING:
goto swap;
break;
@@ -3030,13 +3085,13 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
}
break;
- case NODE_CCLASS:
+ case ND_CCLASS:
{
int range;
CClassNode* xc = CCLASS_(x);
switch (ytype) {
- case NODE_CTYPE:
+ case ND_CTYPE:
switch (CTYPE_(y)->ctype) {
case CTYPE_ANYCHAR:
return 0;
@@ -3078,7 +3133,7 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
}
break;
- case NODE_CCLASS:
+ case ND_CCLASS:
{
int v;
CClassNode* yc = CCLASS_(y);
@@ -3099,7 +3154,7 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
}
break;
- case NODE_STRING:
+ case ND_STRING:
goto swap;
break;
@@ -3109,15 +3164,15 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
}
break;
- case NODE_STRING:
+ case ND_STRING:
{
StrNode* xs = STR_(x);
- if (NODE_STRING_LEN(x) == 0)
+ if (ND_STRING_LEN(x) == 0)
break;
switch (ytype) {
- case NODE_CTYPE:
+ case ND_CTYPE:
switch (CTYPE_(y)->ctype) {
case CTYPE_ANYCHAR:
break;
@@ -3141,7 +3196,7 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
}
break;
- case NODE_CCLASS:
+ case ND_CCLASS:
{
CClassNode* cc = CCLASS_(y);
@@ -3151,13 +3206,13 @@ is_exclusive(Node* x, Node* y, regex_t* reg)
}
break;
- case NODE_STRING:
+ case ND_STRING:
{
UChar *q;
StrNode* ys = STR_(y);
- len = NODE_STRING_LEN(x);
- if (len > NODE_STRING_LEN(y)) len = NODE_STRING_LEN(y);
+ len = ND_STRING_LEN(x);
+ if (len > ND_STRING_LEN(y)) len = ND_STRING_LEN(y);
for (i = 0, p = ys->s, q = xs->s; i < len; i++, p++, q++) {
if (*p != *q) return 1;
@@ -3183,73 +3238,74 @@ get_tree_head_literal(Node* node, int exact, regex_t* reg)
{
Node* n = NULL_NODE;
- switch (NODE_TYPE(node)) {
- case NODE_BACKREF:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_BACKREF:
+ case ND_ALT:
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
#endif
break;
- case NODE_CTYPE:
+ case ND_CTYPE:
if (CTYPE_(node)->ctype == CTYPE_ANYCHAR)
break;
/* fall */
- case NODE_CCLASS:
+ case ND_CCLASS:
if (exact == 0) {
n = node;
}
break;
- case NODE_LIST:
- n = get_tree_head_literal(NODE_CAR(node), exact, reg);
+ case ND_LIST:
+ n = get_tree_head_literal(ND_CAR(node), exact, reg);
break;
- case NODE_STRING:
+ case ND_STRING:
{
StrNode* sn = STR_(node);
if (sn->end <= sn->s)
break;
- if (exact == 0 || !NODE_IS_REAL_IGNORECASE(node)) {
+ if (exact == 0 || !ND_IS_REAL_IGNORECASE(node)) {
n = node;
}
}
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
if (qn->lower > 0) {
if (IS_NOT_NULL(qn->head_exact))
n = qn->head_exact;
else
- n = get_tree_head_literal(NODE_BODY(node), exact, reg);
+ n = get_tree_head_literal(ND_BODY(node), exact, reg);
}
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
switch (en->type) {
case BAG_OPTION:
case BAG_MEMORY:
case BAG_STOP_BACKTRACK:
- case BAG_IF_ELSE:
- n = get_tree_head_literal(NODE_BODY(node), exact, reg);
+ n = get_tree_head_literal(ND_BODY(node), exact, reg);
+ break;
+ default:
break;
}
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (ANCHOR_(node)->type == ANCR_PREC_READ)
- n = get_tree_head_literal(NODE_BODY(node), exact, reg);
+ n = get_tree_head_literal(ND_BODY(node), exact, reg);
break;
- case NODE_GIMMICK:
+ case ND_GIMMICK:
default:
break;
}
@@ -3275,37 +3331,37 @@ get_tree_tail_literal(Node* node, Node** rnode, regex_t* reg, int nest_level)
return GET_VALUE_NONE;
}
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- if (IS_NULL(NODE_CDR(node))) {
- r = get_tree_tail_literal(NODE_CAR(node), rnode, reg, nest_level);
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ if (IS_NULL(ND_CDR(node))) {
+ r = get_tree_tail_literal(ND_CAR(node), rnode, reg, nest_level);
}
else {
- r = get_tree_tail_literal(NODE_CDR(node), rnode, reg, nest_level);
+ r = get_tree_tail_literal(ND_CDR(node), rnode, reg, nest_level);
if (r == GET_VALUE_IGNORE) {
- r = get_tree_tail_literal(NODE_CAR(node), rnode, reg, nest_level);
+ r = get_tree_tail_literal(ND_CAR(node), rnode, reg, nest_level);
}
}
break;
#ifdef USE_CALL
- case NODE_CALL:
- r = get_tree_tail_literal(NODE_BODY(node), rnode, reg, nest_level);
+ case ND_CALL:
+ r = get_tree_tail_literal(ND_BODY(node), rnode, reg, nest_level);
break;
#endif
- case NODE_CTYPE:
+ case ND_CTYPE:
if (CTYPE_(node)->ctype == CTYPE_ANYCHAR) {
r = GET_VALUE_NONE;
break;
}
/* fall */
- case NODE_CCLASS:
+ case ND_CCLASS:
*rnode = node;
r = GET_VALUE_FOUND;
break;
- case NODE_STRING:
+ case ND_STRING:
{
StrNode* sn = STR_(node);
@@ -3314,7 +3370,7 @@ get_tree_tail_literal(Node* node, Node** rnode, regex_t* reg, int nest_level)
break;
}
- if (NODE_IS_REAL_IGNORECASE(node)) {
+ if (ND_IS_REAL_IGNORECASE(node)) {
r = GET_VALUE_NONE;
break;
}
@@ -3324,43 +3380,43 @@ get_tree_tail_literal(Node* node, Node** rnode, regex_t* reg, int nest_level)
}
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
if (qn->lower != 0) {
- r = get_tree_tail_literal(NODE_BODY(node), rnode, reg, nest_level);
+ r = get_tree_tail_literal(ND_BODY(node), rnode, reg, nest_level);
}
else
r = GET_VALUE_NONE;
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_MARK1(node))
+ if (ND_IS_MARK1(node))
r = GET_VALUE_NONE;
else {
- NODE_STATUS_ADD(node, MARK1);
- r = get_tree_tail_literal(NODE_BODY(node), rnode, reg, nest_level);
- NODE_STATUS_REMOVE(node, MARK1);
+ ND_STATUS_ADD(node, MARK1);
+ r = get_tree_tail_literal(ND_BODY(node), rnode, reg, nest_level);
+ ND_STATUS_REMOVE(node, MARK1);
}
}
else {
- r = get_tree_tail_literal(NODE_BODY(node), rnode, reg, nest_level);
+ r = get_tree_tail_literal(ND_BODY(node), rnode, reg, nest_level);
}
}
break;
- case NODE_ANCHOR:
- case NODE_GIMMICK:
+ case ND_ANCHOR:
+ case ND_GIMMICK:
r = GET_VALUE_IGNORE;
break;
- case NODE_ALT:
- case NODE_BACKREF:
+ case ND_ALT:
+ case ND_BACKREF:
default:
r = GET_VALUE_NONE;
break;
@@ -3376,33 +3432,33 @@ check_called_node_in_look_behind(Node* node, int not)
r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = check_called_node_in_look_behind(NODE_CAR(node), not);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = check_called_node_in_look_behind(ND_CAR(node), not);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
- r = check_called_node_in_look_behind(NODE_BODY(node), not);
+ case ND_QUANT:
+ r = check_called_node_in_look_behind(ND_BODY(node), not);
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_MARK1(node))
+ if (ND_IS_MARK1(node))
return 0;
else {
- NODE_STATUS_ADD(node, MARK1);
- r = check_called_node_in_look_behind(NODE_BODY(node), not);
- NODE_STATUS_REMOVE(node, MARK1);
+ ND_STATUS_ADD(node, MARK1);
+ r = check_called_node_in_look_behind(ND_BODY(node), not);
+ ND_STATUS_REMOVE(node, MARK1);
}
}
else {
- r = check_called_node_in_look_behind(NODE_BODY(node), not);
+ r = check_called_node_in_look_behind(ND_BODY(node), not);
if (r == 0 && en->type == BAG_IF_ELSE) {
if (IS_NOT_NULL(en->te.Then)) {
r = check_called_node_in_look_behind(en->te.Then, not);
@@ -3416,13 +3472,13 @@ check_called_node_in_look_behind(Node* node, int not)
}
break;
- case NODE_ANCHOR:
- if (IS_NOT_NULL(NODE_BODY(node)))
- r = check_called_node_in_look_behind(NODE_BODY(node), not);
+ case ND_ANCHOR:
+ if (IS_NOT_NULL(ND_BODY(node)))
+ r = check_called_node_in_look_behind(ND_BODY(node), not);
break;
- case NODE_GIMMICK:
- if (NODE_IS_ABSENT_WITH_SIDE_EFFECTS(node) != 0)
+ case ND_GIMMICK:
+ if (ND_IS_ABSENT_WITH_SIDE_EFFECTS(node) != 0)
return 1;
break;
@@ -3435,9 +3491,9 @@ check_called_node_in_look_behind(Node* node, int not)
/* allowed node types in look-behind */
#define ALLOWED_TYPE_IN_LB \
- ( NODE_BIT_LIST | NODE_BIT_ALT | NODE_BIT_STRING | NODE_BIT_CCLASS \
- | NODE_BIT_CTYPE | NODE_BIT_ANCHOR | NODE_BIT_BAG | NODE_BIT_QUANT \
- | NODE_BIT_CALL | NODE_BIT_BACKREF | NODE_BIT_GIMMICK)
+ ( ND_BIT_LIST | ND_BIT_ALT | ND_BIT_STRING | ND_BIT_CCLASS \
+ | ND_BIT_CTYPE | ND_BIT_ANCHOR | ND_BIT_BAG | ND_BIT_QUANT \
+ | ND_BIT_CALL | ND_BIT_BACKREF | ND_BIT_GIMMICK)
#define ALLOWED_BAG_IN_LB ( 1<<BAG_MEMORY | 1<<BAG_OPTION | 1<<BAG_STOP_BACKTRACK | 1<<BAG_IF_ELSE )
#define ALLOWED_BAG_IN_LB_NOT ( 1<<BAG_OPTION | 1<<BAG_STOP_BACKTRACK | 1<<BAG_IF_ELSE )
@@ -3467,34 +3523,34 @@ check_node_in_look_behind(Node* node, int not, int* used)
NodeType type;
int r = 0;
- type = NODE_TYPE(node);
- if ((NODE_TYPE2BIT(type) & ALLOWED_TYPE_IN_LB) == 0)
+ type = ND_TYPE(node);
+ if ((ND_TYPE2BIT(type) & ALLOWED_TYPE_IN_LB) == 0)
return 1;
switch (type) {
- case NODE_LIST:
- case NODE_ALT:
+ case ND_LIST:
+ case ND_ALT:
do {
- r = check_node_in_look_behind(NODE_CAR(node), not, used);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = check_node_in_look_behind(ND_CAR(node), not, used);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
- r = check_node_in_look_behind(NODE_BODY(node), not, used);
+ case ND_QUANT:
+ r = check_node_in_look_behind(ND_BODY(node), not, used);
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (((1<<en->type) & bag_mask[not]) == 0)
return 1;
- r = check_node_in_look_behind(NODE_BODY(node), not, used);
+ r = check_node_in_look_behind(ND_BODY(node), not, used);
if (r != 0) break;
if (en->type == BAG_MEMORY) {
- if (NODE_IS_BACKREF(node) || NODE_IS_CALLED(node)
- || NODE_IS_REFERENCED(node))
+ if (ND_IS_BACKREF(node) || ND_IS_CALLED(node)
+ || ND_IS_REFERENCED(node))
*used = TRUE;
}
else if (en->type == BAG_IF_ELSE) {
@@ -3509,17 +3565,17 @@ check_node_in_look_behind(Node* node, int not, int* used)
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
type = ANCHOR_(node)->type;
if ((type & anchor_mask[not]) == 0)
return 1;
- if (IS_NOT_NULL(NODE_BODY(node)))
- r = check_node_in_look_behind(NODE_BODY(node), not, used);
+ if (IS_NOT_NULL(ND_BODY(node)))
+ r = check_node_in_look_behind(ND_BODY(node), not, used);
break;
- case NODE_GIMMICK:
- if (NODE_IS_ABSENT_WITH_SIDE_EFFECTS(node) != 0)
+ case ND_GIMMICK:
+ if (ND_IS_ABSENT_WITH_SIDE_EFFECTS(node) != 0)
return 1;
{
@@ -3529,14 +3585,14 @@ check_node_in_look_behind(Node* node, int not, int* used)
}
break;
- case NODE_CALL:
- if (NODE_IS_RECURSION(node)) {
+ case ND_CALL:
+ if (ND_IS_RECURSION(node)) {
/* fix: Issue 38040 in oss-fuzz */
/* This node should be removed before recursive call check. */
*used = TRUE;
}
else
- r = check_called_node_in_look_behind(NODE_BODY(node), not);
+ r = check_called_node_in_look_behind(ND_BODY(node), not);
break;
default:
@@ -3552,14 +3608,14 @@ node_min_byte_len(Node* node, ParseEnv* env)
OnigLen tmin;
len = 0;
- switch (NODE_TYPE(node)) {
- case NODE_BACKREF:
- if (! NODE_IS_CHECKER(node)) {
+ switch (ND_TYPE(node)) {
+ case ND_BACKREF:
+ if (! ND_IS_CHECKER(node)) {
int i;
int* backs;
MemEnv* mem_env = PARSEENV_MEMENV(env);
BackRefNode* br = BACKREF_(node);
- if (NODE_IS_RECURSION(node)) break;
+ if (ND_IS_RECURSION(node)) break;
backs = BACKREFS_P(br);
len = node_min_byte_len(mem_env[backs[0]].mem_node, env);
@@ -3571,10 +3627,10 @@ node_min_byte_len(Node* node, ParseEnv* env)
break;
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
{
- Node* t = NODE_BODY(node);
- if (NODE_IS_FIXED_MIN(t))
+ Node* t = ND_BODY(node);
+ if (ND_IS_FIXED_MIN(t))
len = BAG_(t)->min_len;
else
len = node_min_byte_len(t, env);
@@ -3582,79 +3638,79 @@ node_min_byte_len(Node* node, ParseEnv* env)
break;
#endif
- case NODE_LIST:
+ case ND_LIST:
do {
- tmin = node_min_byte_len(NODE_CAR(node), env);
+ tmin = node_min_byte_len(ND_CAR(node), env);
len = distance_add(len, tmin);
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ALT:
+ case ND_ALT:
{
Node *x, *y;
y = node;
do {
- x = NODE_CAR(y);
+ x = ND_CAR(y);
tmin = node_min_byte_len(x, env);
if (y == node) len = tmin;
else if (len > tmin) len = tmin;
- } while (IS_NOT_NULL(y = NODE_CDR(y)));
+ } while (IS_NOT_NULL(y = ND_CDR(y)));
}
break;
- case NODE_STRING:
+ case ND_STRING:
{
StrNode* sn = STR_(node);
len = (int )(sn->end - sn->s);
}
break;
- case NODE_CTYPE:
- case NODE_CCLASS:
+ case ND_CTYPE:
+ case ND_CCLASS:
len = ONIGENC_MBC_MINLEN(env->enc);
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
if (qn->lower > 0) {
- len = node_min_byte_len(NODE_BODY(node), env);
+ len = node_min_byte_len(ND_BODY(node), env);
len = distance_multiply(len, qn->lower);
}
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
switch (en->type) {
case BAG_MEMORY:
- if (NODE_IS_FIXED_MIN(node))
+ if (ND_IS_FIXED_MIN(node))
len = en->min_len;
else {
- if (NODE_IS_MARK1(node))
+ if (ND_IS_MARK1(node))
len = 0; /* recursive */
else {
- NODE_STATUS_ADD(node, MARK1);
- len = node_min_byte_len(NODE_BODY(node), env);
- NODE_STATUS_REMOVE(node, MARK1);
+ ND_STATUS_ADD(node, MARK1);
+ len = node_min_byte_len(ND_BODY(node), env);
+ ND_STATUS_REMOVE(node, MARK1);
en->min_len = len;
- NODE_STATUS_ADD(node, FIXED_MIN);
+ ND_STATUS_ADD(node, FIXED_MIN);
}
}
break;
case BAG_OPTION:
case BAG_STOP_BACKTRACK:
- len = node_min_byte_len(NODE_BODY(node), env);
+ len = node_min_byte_len(ND_BODY(node), env);
break;
case BAG_IF_ELSE:
{
OnigLen elen;
- len = node_min_byte_len(NODE_BODY(node), env);
+ len = node_min_byte_len(ND_BODY(node), env);
if (IS_NOT_NULL(en->te.Then))
len += node_min_byte_len(en->te.Then, env);
if (IS_NOT_NULL(en->te.Else))
@@ -3668,7 +3724,7 @@ node_min_byte_len(Node* node, ParseEnv* env)
}
break;
- case NODE_GIMMICK:
+ case ND_GIMMICK:
{
GimmickNode* g = GIMMICK_(node);
if (g->type == GIMMICK_FAIL) {
@@ -3677,7 +3733,7 @@ node_min_byte_len(Node* node, ParseEnv* env)
}
}
/* fall */
- case NODE_ANCHOR:
+ case ND_ANCHOR:
default:
break;
}
@@ -3690,26 +3746,26 @@ check_backrefs(Node* node, ParseEnv* env)
{
int r;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = check_backrefs(NODE_CAR(node), env);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = check_backrefs(ND_CAR(node), env);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (! ANCHOR_HAS_BODY(ANCHOR_(node))) {
r = 0;
break;
}
/* fall */
- case NODE_QUANT:
- r = check_backrefs(NODE_BODY(node), env);
+ case ND_QUANT:
+ r = check_backrefs(ND_BODY(node), env);
break;
- case NODE_BAG:
- r = check_backrefs(NODE_BODY(node), env);
+ case ND_BAG:
+ r = check_backrefs(ND_BODY(node), env);
{
BagNode* en = BAG_(node);
@@ -3726,7 +3782,7 @@ check_backrefs(Node* node, ParseEnv* env)
}
break;
- case NODE_BACKREF:
+ case ND_BACKREF:
{
int i;
BackRefNode* br = BACKREF_(node);
@@ -3737,7 +3793,7 @@ check_backrefs(Node* node, ParseEnv* env)
if (backs[i] > env->num_mem)
return ONIGERR_INVALID_BACKREF;
- NODE_STATUS_ADD(mem_env[backs[i]].mem_node, BACKREF);
+ ND_STATUS_ADD(mem_env[backs[i]].mem_node, BACKREF);
}
r = 0;
}
@@ -3756,15 +3812,15 @@ set_empty_repeat_node_trav(Node* node, Node* empty, ParseEnv* env)
{
int r;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = set_empty_repeat_node_trav(NODE_CAR(node), empty, env);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = set_empty_repeat_node_trav(ND_CAR(node), empty, env);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
{
AnchorNode* an = ANCHOR_(node);
@@ -3781,22 +3837,22 @@ set_empty_repeat_node_trav(Node* node, Node* empty, ParseEnv* env)
default:
break;
}
- r = set_empty_repeat_node_trav(NODE_BODY(node), empty, env);
+ r = set_empty_repeat_node_trav(ND_BODY(node), empty, env);
}
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
if (qn->emptiness != BODY_IS_NOT_EMPTY) empty = node;
- r = set_empty_repeat_node_trav(NODE_BODY(node), empty, env);
+ r = set_empty_repeat_node_trav(ND_BODY(node), empty, env);
}
break;
- case NODE_BAG:
- if (IS_NOT_NULL(NODE_BODY(node))) {
- r = set_empty_repeat_node_trav(NODE_BODY(node), empty, env);
+ case ND_BAG:
+ if (IS_NOT_NULL(ND_BODY(node))) {
+ r = set_empty_repeat_node_trav(ND_BODY(node), empty, env);
if (r != 0) return r;
}
{
@@ -3804,7 +3860,7 @@ set_empty_repeat_node_trav(Node* node, Node* empty, ParseEnv* env)
r = 0;
if (en->type == BAG_MEMORY) {
- if (NODE_IS_BACKREF(node)) {
+ if (ND_IS_BACKREF(node)) {
if (IS_NOT_NULL(empty))
PARSEENV_MEMENV(env)[en->m.regnum].empty_repeat_node = empty;
}
@@ -3834,7 +3890,7 @@ is_ancestor_node(Node* node, Node* me)
{
Node* parent;
- while ((parent = NODE_PARENT(me)) != NULL_NODE) {
+ while ((parent = ND_PARENT(me)) != NULL_NODE) {
if (parent == node) return 1;
me = parent;
}
@@ -3844,30 +3900,30 @@ is_ancestor_node(Node* node, Node* me)
static void
set_empty_status_check_trav(Node* node, ParseEnv* env)
{
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- set_empty_status_check_trav(NODE_CAR(node), env);
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ set_empty_status_check_trav(ND_CAR(node), env);
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
{
AnchorNode* an = ANCHOR_(node);
if (! ANCHOR_HAS_BODY(an)) break;
- set_empty_status_check_trav(NODE_BODY(node), env);
+ set_empty_status_check_trav(ND_BODY(node), env);
}
break;
- case NODE_QUANT:
- set_empty_status_check_trav(NODE_BODY(node), env);
+ case ND_QUANT:
+ set_empty_status_check_trav(ND_BODY(node), env);
break;
- case NODE_BAG:
- if (IS_NOT_NULL(NODE_BODY(node)))
- set_empty_status_check_trav(NODE_BODY(node), env);
+ case ND_BAG:
+ if (IS_NOT_NULL(ND_BODY(node)))
+ set_empty_status_check_trav(ND_BODY(node), env);
{
BagNode* en = BAG_(node);
@@ -3882,7 +3938,7 @@ set_empty_status_check_trav(Node* node, ParseEnv* env)
}
break;
- case NODE_BACKREF:
+ case ND_BACKREF:
{
int i;
int* backs;
@@ -3894,8 +3950,8 @@ set_empty_status_check_trav(Node* node, ParseEnv* env)
if (IS_NOT_NULL(ernode)) {
if (! is_ancestor_node(ernode, node)) {
MEM_STATUS_LIMIT_ON(QUANT_(ernode)->empty_status_mem, backs[i]);
- NODE_STATUS_ADD(ernode, EMPTY_STATUS_CHECK);
- NODE_STATUS_ADD(mem_env[backs[i]].mem_node, EMPTY_STATUS_CHECK);
+ ND_STATUS_ADD(ernode, EMPTY_STATUS_CHECK);
+ ND_STATUS_ADD(mem_env[backs[i]].mem_node, EMPTY_STATUS_CHECK);
}
}
}
@@ -3910,28 +3966,28 @@ set_empty_status_check_trav(Node* node, ParseEnv* env)
static void
set_parent_node_trav(Node* node, Node* parent)
{
- NODE_PARENT(node) = parent;
+ ND_PARENT(node) = parent;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- set_parent_node_trav(NODE_CAR(node), node);
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ set_parent_node_trav(ND_CAR(node), node);
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (! ANCHOR_HAS_BODY(ANCHOR_(node))) break;
- set_parent_node_trav(NODE_BODY(node), node);
+ set_parent_node_trav(ND_BODY(node), node);
break;
- case NODE_QUANT:
- set_parent_node_trav(NODE_BODY(node), node);
+ case ND_QUANT:
+ set_parent_node_trav(ND_BODY(node), node);
break;
- case NODE_BAG:
- if (IS_NOT_NULL(NODE_BODY(node)))
- set_parent_node_trav(NODE_BODY(node), node);
+ case ND_BAG:
+ if (IS_NOT_NULL(ND_BODY(node)))
+ set_parent_node_trav(ND_BODY(node), node);
{
BagNode* en = BAG_(node);
@@ -3963,45 +4019,45 @@ infinite_recursive_call_check(Node* node, ParseEnv* env, int head)
int ret;
int r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
{
Node *x;
OnigLen min;
x = node;
do {
- ret = infinite_recursive_call_check(NODE_CAR(x), env, head);
+ ret = infinite_recursive_call_check(ND_CAR(x), env, head);
if (ret < 0 || (ret & RECURSION_INFINITE) != 0) return ret;
r |= ret;
if (head != 0) {
- min = node_min_byte_len(NODE_CAR(x), env);
+ min = node_min_byte_len(ND_CAR(x), env);
if (min != 0) head = 0;
}
- } while (IS_NOT_NULL(x = NODE_CDR(x)));
+ } while (IS_NOT_NULL(x = ND_CDR(x)));
}
break;
- case NODE_ALT:
+ case ND_ALT:
{
int must;
must = RECURSION_MUST;
do {
- ret = infinite_recursive_call_check(NODE_CAR(node), env, head);
+ ret = infinite_recursive_call_check(ND_CAR(node), env, head);
if (ret < 0 || (ret & RECURSION_INFINITE) != 0) return ret;
r |= (ret & RECURSION_EXIST);
must &= ret;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
r |= must;
}
break;
- case NODE_QUANT:
+ case ND_QUANT:
if (QUANT_(node)->upper == 0) break;
- r = infinite_recursive_call_check(NODE_BODY(node), env, head);
+ r = infinite_recursive_call_check(ND_BODY(node), env, head);
if (r < 0) return r;
if ((r & RECURSION_MUST) != 0) {
if (QUANT_(node)->lower == 0)
@@ -4009,40 +4065,40 @@ infinite_recursive_call_check(Node* node, ParseEnv* env, int head)
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (! ANCHOR_HAS_BODY(ANCHOR_(node)))
break;
/* fall */
- case NODE_CALL:
- r = infinite_recursive_call_check(NODE_BODY(node), env, head);
+ case ND_CALL:
+ r = infinite_recursive_call_check(ND_BODY(node), env, head);
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_MARK2(node))
+ if (ND_IS_MARK2(node))
return 0;
- else if (NODE_IS_MARK1(node))
+ else if (ND_IS_MARK1(node))
return (head == 0 ? RECURSION_EXIST | RECURSION_MUST
: RECURSION_EXIST | RECURSION_MUST | RECURSION_INFINITE);
else {
- NODE_STATUS_ADD(node, MARK2);
- r = infinite_recursive_call_check(NODE_BODY(node), env, head);
- NODE_STATUS_REMOVE(node, MARK2);
+ ND_STATUS_ADD(node, MARK2);
+ r = infinite_recursive_call_check(ND_BODY(node), env, head);
+ ND_STATUS_REMOVE(node, MARK2);
}
}
else if (en->type == BAG_IF_ELSE) {
int eret;
- ret = infinite_recursive_call_check(NODE_BODY(node), env, head);
+ ret = infinite_recursive_call_check(ND_BODY(node), env, head);
if (ret < 0 || (ret & RECURSION_INFINITE) != 0) return ret;
r |= ret;
if (IS_NOT_NULL(en->te.Then)) {
OnigLen min;
if (head != 0) {
- min = node_min_byte_len(NODE_BODY(node), env);
+ min = node_min_byte_len(ND_BODY(node), env);
}
else min = 0;
@@ -4062,7 +4118,7 @@ infinite_recursive_call_check(Node* node, ParseEnv* env, int head)
}
}
else {
- r = infinite_recursive_call_check(NODE_BODY(node), env, head);
+ r = infinite_recursive_call_check(ND_BODY(node), env, head);
}
}
break;
@@ -4079,40 +4135,40 @@ infinite_recursive_call_check_trav(Node* node, ParseEnv* env)
{
int r;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = infinite_recursive_call_check_trav(NODE_CAR(node), env);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = infinite_recursive_call_check_trav(ND_CAR(node), env);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (! ANCHOR_HAS_BODY(ANCHOR_(node))) {
r = 0;
break;
}
/* fall */
- case NODE_QUANT:
- r = infinite_recursive_call_check_trav(NODE_BODY(node), env);
+ case ND_QUANT:
+ r = infinite_recursive_call_check_trav(ND_BODY(node), env);
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_RECURSION(node) && NODE_IS_CALLED(node)) {
+ if (ND_IS_RECURSION(node) && ND_IS_CALLED(node)) {
int ret;
- NODE_STATUS_ADD(node, MARK1);
+ ND_STATUS_ADD(node, MARK1);
- ret = infinite_recursive_call_check(NODE_BODY(node), env, 1);
+ ret = infinite_recursive_call_check(ND_BODY(node), env, 1);
if (ret < 0) return ret;
else if ((ret & (RECURSION_MUST | RECURSION_INFINITE)) != 0)
return ONIGERR_NEVER_ENDING_RECURSION;
- NODE_STATUS_REMOVE(node, MARK1);
+ ND_STATUS_REMOVE(node, MARK1);
}
}
else if (en->type == BAG_IF_ELSE) {
@@ -4127,7 +4183,7 @@ infinite_recursive_call_check_trav(Node* node, ParseEnv* env)
}
}
- r = infinite_recursive_call_check_trav(NODE_BODY(node), env);
+ r = infinite_recursive_call_check_trav(ND_BODY(node), env);
break;
default:
@@ -4143,46 +4199,46 @@ recursive_call_check(Node* node)
{
int r;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
r = 0;
do {
- r |= recursive_call_check(NODE_CAR(node));
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ r |= recursive_call_check(ND_CAR(node));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (! ANCHOR_HAS_BODY(ANCHOR_(node))) {
r = 0;
break;
}
/* fall */
- case NODE_QUANT:
- r = recursive_call_check(NODE_BODY(node));
+ case ND_QUANT:
+ r = recursive_call_check(ND_BODY(node));
break;
- case NODE_CALL:
- r = recursive_call_check(NODE_BODY(node));
+ case ND_CALL:
+ r = recursive_call_check(ND_BODY(node));
if (r != 0) {
- if (NODE_IS_MARK1(NODE_BODY(node)))
- NODE_STATUS_ADD(node, RECURSION);
+ if (ND_IS_MARK1(ND_BODY(node)))
+ ND_STATUS_ADD(node, RECURSION);
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_MARK2(node))
+ if (ND_IS_MARK2(node))
return 0;
- else if (NODE_IS_MARK1(node))
+ else if (ND_IS_MARK1(node))
return 1; /* recursion */
else {
- NODE_STATUS_ADD(node, MARK2);
- r = recursive_call_check(NODE_BODY(node));
- NODE_STATUS_REMOVE(node, MARK2);
+ ND_STATUS_ADD(node, MARK2);
+ r = recursive_call_check(ND_BODY(node));
+ ND_STATUS_REMOVE(node, MARK2);
}
}
else if (en->type == BAG_IF_ELSE) {
@@ -4193,10 +4249,10 @@ recursive_call_check(Node* node)
if (IS_NOT_NULL(en->te.Else)) {
r |= recursive_call_check(en->te.Else);
}
- r |= recursive_call_check(NODE_BODY(node));
+ r |= recursive_call_check(ND_BODY(node));
}
else {
- r = recursive_call_check(NODE_BODY(node));
+ r = recursive_call_check(ND_BODY(node));
}
}
break;
@@ -4217,65 +4273,65 @@ recursive_call_check_trav(Node* node, ParseEnv* env, int state)
{
int r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
{
int ret;
do {
- ret = recursive_call_check_trav(NODE_CAR(node), env, state);
+ ret = recursive_call_check_trav(ND_CAR(node), env, state);
if (ret == FOUND_CALLED_NODE) r = FOUND_CALLED_NODE;
else if (ret < 0) return ret;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
}
break;
- case NODE_QUANT:
- r = recursive_call_check_trav(NODE_BODY(node), env, state);
+ case ND_QUANT:
+ r = recursive_call_check_trav(ND_BODY(node), env, state);
if (QUANT_(node)->upper == 0) {
if (r == FOUND_CALLED_NODE)
QUANT_(node)->include_referred = 1;
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
{
AnchorNode* an = ANCHOR_(node);
if (ANCHOR_HAS_BODY(an))
- r = recursive_call_check_trav(NODE_ANCHOR_BODY(an), env, state);
+ r = recursive_call_check_trav(ND_ANCHOR_BODY(an), env, state);
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
int ret;
int state1;
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_CALLED(node)) {
+ if (ND_IS_CALLED(node)) {
r = FOUND_CALLED_NODE;
goto check_recursion;
}
else if ((state & IN_RECURSION) != 0) {
check_recursion:
- if (! NODE_IS_RECURSION(node)) {
- NODE_STATUS_ADD(node, MARK1);
- ret = recursive_call_check(NODE_BODY(node));
+ if (! ND_IS_RECURSION(node)) {
+ ND_STATUS_ADD(node, MARK1);
+ ret = recursive_call_check(ND_BODY(node));
if (ret != 0) {
- NODE_STATUS_ADD(node, RECURSION);
+ ND_STATUS_ADD(node, RECURSION);
MEM_STATUS_ON(env->backtrack_mem, en->m.regnum);
}
- NODE_STATUS_REMOVE(node, MARK1);
+ ND_STATUS_REMOVE(node, MARK1);
}
}
}
state1 = state;
- if (NODE_IS_RECURSION(node))
+ if (ND_IS_RECURSION(node))
state1 |= IN_RECURSION;
- ret = recursive_call_check_trav(NODE_BODY(node), env, state1);
+ ret = recursive_call_check_trav(ND_BODY(node), env, state1);
if (ret == FOUND_CALLED_NODE)
r = FOUND_CALLED_NODE;
@@ -4306,10 +4362,10 @@ recursive_call_check_trav(Node* node, ParseEnv* env, int state)
static void
remove_from_list(Node* prev, Node* a)
{
- if (NODE_CDR(prev) != a) return ;
+ if (ND_CDR(prev) != a) return ;
- NODE_CDR(prev) = NODE_CDR(a);
- NODE_CDR(a) = NULL_NODE;
+ ND_CDR(prev) = ND_CDR(a);
+ ND_CDR(a) = NULL_NODE;
}
static int
@@ -4317,8 +4373,8 @@ reduce_string_list(Node* node, OnigEncoding enc)
{
int r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
{
Node* prev;
Node* curr;
@@ -4327,12 +4383,12 @@ reduce_string_list(Node* node, OnigEncoding enc)
prev = NULL_NODE;
do {
- next_node = NODE_CDR(node);
- curr = NODE_CAR(node);
- if (NODE_TYPE(curr) == NODE_STRING) {
+ next_node = ND_CDR(node);
+ curr = ND_CAR(node);
+ if (ND_TYPE(curr) == ND_STRING) {
if (IS_NULL(prev)
|| STR_(curr)->flag != STR_(prev)->flag
- || NODE_STATUS(curr) != NODE_STATUS(prev)) {
+ || ND_STATUS(curr) != ND_STATUS(prev)) {
prev = curr;
prev_node = node;
}
@@ -4370,14 +4426,14 @@ reduce_string_list(Node* node, OnigEncoding enc)
}
break;
- case NODE_ALT:
+ case ND_ALT:
do {
- r = reduce_string_list(NODE_CAR(node), enc);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = reduce_string_list(ND_CAR(node), enc);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
#ifdef USE_CHECK_VALIDITY_OF_STRING_IN_TREE
- case NODE_STRING:
+ case ND_STRING:
{
StrNode* sn = STR_(node);
if (! ONIGENC_IS_VALID_MBC_STRING(enc, sn->s, sn->end))
@@ -4386,19 +4442,19 @@ reduce_string_list(Node* node, OnigEncoding enc)
break;
#endif
- case NODE_ANCHOR:
- if (IS_NULL(NODE_BODY(node)))
+ case ND_ANCHOR:
+ if (IS_NULL(ND_BODY(node)))
break;
/* fall */
- case NODE_QUANT:
- r = reduce_string_list(NODE_BODY(node), enc);
+ case ND_QUANT:
+ r = reduce_string_list(ND_BODY(node), enc);
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
- r = reduce_string_list(NODE_BODY(node), enc);
+ r = reduce_string_list(ND_BODY(node), enc);
if (r != 0) return r;
if (en->type == BAG_IF_ELSE) {
@@ -4447,26 +4503,26 @@ divide_look_behind_alternatives(Node* node)
an = ANCHOR_(node);
anc_type = an->type;
- head = NODE_ANCHOR_BODY(an);
- np = NODE_CAR(head);
+ head = ND_ANCHOR_BODY(an);
+ np = ND_CAR(head);
node_swap(node, head);
- NODE_CAR(node) = head;
- NODE_BODY(head) = np;
+ ND_CAR(node) = head;
+ ND_BODY(head) = np;
np = node;
- while (IS_NOT_NULL(np = NODE_CDR(np))) {
+ while (IS_NOT_NULL(np = ND_CDR(np))) {
r = onig_node_copy(&insert_node, head);
if (r != 0) return r;
CHECK_NULL_RETURN_MEMERR(insert_node);
- NODE_BODY(insert_node) = NODE_CAR(np);
- NODE_CAR(np) = insert_node;
+ ND_BODY(insert_node) = ND_CAR(np);
+ ND_CAR(np) = insert_node;
}
if (anc_type == ANCR_LOOK_BEHIND_NOT) {
np = node;
do {
- NODE_SET_TYPE(np, NODE_LIST); /* alt -> list */
- } while (IS_NOT_NULL(np = NODE_CDR(np)));
+ ND_SET_TYPE(np, ND_LIST); /* alt -> list */
+ } while (IS_NOT_NULL(np = ND_CDR(np)));
}
return 0;
}
@@ -4477,12 +4533,12 @@ node_reduce_in_look_behind(Node* node)
NodeType type;
Node* body;
- if (NODE_TYPE(node) != NODE_QUANT) return 0;
+ if (ND_TYPE(node) != ND_QUANT) return 0;
- body = NODE_BODY(node);
- type = NODE_TYPE(body);
- if (type == NODE_STRING || type == NODE_CTYPE ||
- type == NODE_CCLASS || type == NODE_BACKREF) {
+ body = ND_BODY(node);
+ type = ND_TYPE(body);
+ if (type == ND_STRING || type == ND_CTYPE ||
+ type == ND_CCLASS || type == ND_BACKREF) {
QuantNode* qn = QUANT_(node);
qn->upper = qn->lower;
if (qn->upper == 0)
@@ -4497,17 +4553,17 @@ list_reduce_in_look_behind(Node* node)
{
int r;
- switch (NODE_TYPE(node)) {
- case NODE_QUANT:
+ switch (ND_TYPE(node)) {
+ case ND_QUANT:
r = node_reduce_in_look_behind(node);
if (r > 0) r = 0;
break;
- case NODE_LIST:
+ case ND_LIST:
do {
- r = node_reduce_in_look_behind(NODE_CAR(node));
+ r = node_reduce_in_look_behind(ND_CAR(node));
if (r <= 0) break;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
default:
@@ -4523,11 +4579,11 @@ alt_reduce_in_look_behind(Node* node, regex_t* reg, ParseEnv* env)
{
int r;
- switch (NODE_TYPE(node)) {
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_ALT:
do {
- r = list_reduce_in_look_behind(NODE_CAR(node));
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = list_reduce_in_look_behind(ND_CAR(node));
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
default:
@@ -4551,7 +4607,7 @@ tune_look_behind(Node* node, regex_t* reg, int state, ParseEnv* env)
AnchorNode* an = ANCHOR_(node);
used = FALSE;
- r = check_node_in_look_behind(NODE_ANCHOR_BODY(an),
+ r = check_node_in_look_behind(ND_ANCHOR_BODY(an),
an->type == ANCR_LOOK_BEHIND_NOT ? 1 : 0,
&used);
if (r < 0) return r;
@@ -4562,7 +4618,7 @@ tune_look_behind(Node* node, regex_t* reg, int state, ParseEnv* env)
else
state1 = state | IN_LOOK_BEHIND;
- body = NODE_ANCHOR_BODY(an);
+ body = ND_ANCHOR_BODY(an);
/* Execute tune_tree(body) before call node_char_len().
Because case-fold expansion must be done before node_char_len().
*/
@@ -4642,8 +4698,8 @@ tune_next(Node* node, Node* next_node, regex_t* reg)
called = FALSE;
retry:
- type = NODE_TYPE(node);
- if (type == NODE_QUANT) {
+ type = ND_TYPE(node);
+ if (type == ND_QUANT) {
QuantNode* qn = QUANT_(node);
if (qn->greedy && IS_INFINITE_REPEAT(qn->upper)) {
#ifdef USE_QUANT_PEEK_NEXT
@@ -4657,29 +4713,29 @@ tune_next(Node* node, Node* next_node, regex_t* reg)
#endif
/* automatic posseivation a*b ==> (?>a*)b */
if (qn->lower <= 1) {
- if (is_strict_real_node(NODE_BODY(node))) {
+ if (is_strict_real_node(ND_BODY(node))) {
Node *x, *y;
- x = get_tree_head_literal(NODE_BODY(node), 0, reg);
+ x = get_tree_head_literal(ND_BODY(node), 0, reg);
if (IS_NOT_NULL(x)) {
y = get_tree_head_literal(next_node, 0, reg);
if (IS_NOT_NULL(y) && is_exclusive(x, y, reg)) {
Node* en = onig_node_new_bag(BAG_STOP_BACKTRACK);
CHECK_NULL_RETURN_MEMERR(en);
- NODE_STATUS_ADD(en, STRICT_REAL_REPEAT);
+ ND_STATUS_ADD(en, STRICT_REAL_REPEAT);
node_swap(node, en);
- NODE_BODY(node) = en;
+ ND_BODY(node) = en;
}
}
}
}
}
}
- else if (type == NODE_BAG) {
+ else if (type == ND_BAG) {
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_CALLED(node))
+ if (ND_IS_CALLED(node))
called = TRUE;
- node = NODE_BODY(node);
+ node = ND_BODY(node);
goto retry;
}
}
@@ -4846,7 +4902,7 @@ unravel_cf_string_alt_or_cc_add(Node** rlist, int n,
return ONIGERR_MEMORY;
}
- NODE_CDR(curr) = alt;
+ ND_CDR(curr) = alt;
curr = alt;
}
}
@@ -4914,9 +4970,9 @@ unravel_case_fold_string(Node* node, regex_t* reg, int state)
OnigEncoding enc;
OnigCaseFoldCodeItem items[ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM];
- if (NODE_STRING_IS_CASE_EXPANDED(node)) return 0;
+ if (ND_STRING_IS_CASE_EXPANDED(node)) return 0;
- NODE_STATUS_REMOVE(node, IGNORECASE);
+ ND_STATUS_REMOVE(node, IGNORECASE);
snode = STR_(node);
start = snode->s;
end = snode->end;
@@ -4974,7 +5030,7 @@ unravel_case_fold_string(Node* node, regex_t* reg, int state)
if (IS_NOT_NULL(list)) {
if (node_list_len(list) == 1) {
- node_swap(node, NODE_CAR(list));
+ node_swap(node, ND_CAR(list));
}
else {
node_swap(node, list);
@@ -5002,43 +5058,43 @@ quantifiers_memory_node_info(Node* node)
{
int r = BODY_MAY_BE_EMPTY;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
{
int v;
do {
- v = quantifiers_memory_node_info(NODE_CAR(node));
+ v = quantifiers_memory_node_info(ND_CAR(node));
if (v > r) r = v;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
}
break;
#ifdef USE_CALL
- case NODE_CALL:
- if (NODE_IS_RECURSION(node)) {
+ case ND_CALL:
+ if (ND_IS_RECURSION(node)) {
return BODY_MAY_BE_EMPTY_REC; /* tiny version */
}
else
- r = quantifiers_memory_node_info(NODE_BODY(node));
+ r = quantifiers_memory_node_info(ND_BODY(node));
break;
#endif
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
if (qn->upper != 0) {
- r = quantifiers_memory_node_info(NODE_BODY(node));
+ r = quantifiers_memory_node_info(ND_BODY(node));
}
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
switch (en->type) {
case BAG_MEMORY:
- if (NODE_IS_RECURSION(node)) {
+ if (ND_IS_RECURSION(node)) {
return BODY_MAY_BE_EMPTY_REC;
}
return BODY_MAY_BE_EMPTY_MEM;
@@ -5046,12 +5102,12 @@ quantifiers_memory_node_info(Node* node)
case BAG_OPTION:
case BAG_STOP_BACKTRACK:
- r = quantifiers_memory_node_info(NODE_BODY(node));
+ r = quantifiers_memory_node_info(ND_BODY(node));
break;
case BAG_IF_ELSE:
{
int v;
- r = quantifiers_memory_node_info(NODE_BODY(node));
+ r = quantifiers_memory_node_info(ND_BODY(node));
if (IS_NOT_NULL(en->te.Then)) {
v = quantifiers_memory_node_info(en->te.Then);
if (v > r) r = v;
@@ -5066,12 +5122,12 @@ quantifiers_memory_node_info(Node* node)
}
break;
- case NODE_BACKREF:
- case NODE_STRING:
- case NODE_CTYPE:
- case NODE_CCLASS:
- case NODE_ANCHOR:
- case NODE_GIMMICK:
+ case ND_BACKREF:
+ case ND_STRING:
+ case ND_CTYPE:
+ case ND_CCLASS:
+ case ND_ANCHOR:
+ case ND_GIMMICK:
default:
break;
}
@@ -5107,14 +5163,14 @@ check_call_reference(CallNode* cn, ParseEnv* env, int state)
}
set_call_attr:
- NODE_CALL_BODY(cn) = mem_env[cn->called_gnum].mem_node;
- if (IS_NULL(NODE_CALL_BODY(cn))) {
+ ND_CALL_BODY(cn) = mem_env[cn->called_gnum].mem_node;
+ if (IS_NULL(ND_CALL_BODY(cn))) {
onig_scan_env_set_error_string(env, ONIGERR_UNDEFINED_NAME_REFERENCE,
cn->name, cn->name_end);
return ONIGERR_UNDEFINED_NAME_REFERENCE;
}
- NODE_STATUS_ADD(NODE_CALL_BODY(cn), REFERENCED);
+ ND_STATUS_ADD(ND_CALL_BODY(cn), REFERENCED);
}
else {
int *refs;
@@ -5148,22 +5204,22 @@ check_whole_options_position(Node* node /* root */)
is_list = FALSE;
start:
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- if (IS_NOT_NULL(NODE_CDR(node)))
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ if (IS_NOT_NULL(ND_CDR(node)))
is_list = TRUE;
- node = NODE_CAR(node);
+ node = ND_CAR(node);
goto start;
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_OPTION) {
- if (NODE_IS_WHOLE_OPTIONS(node)) {
- if (is_list == TRUE && IS_NOT_NULL(NODE_BODY(node)))
+ if (ND_IS_WHOLE_OPTIONS(node)) {
+ if (is_list == TRUE && IS_NOT_NULL(ND_BODY(node)))
break;
return 0;
@@ -5183,61 +5239,61 @@ check_whole_options_position(Node* node /* root */)
static void
tune_call2_call(Node* node)
{
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- tune_call2_call(NODE_CAR(node));
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ tune_call2_call(ND_CAR(node));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
- tune_call2_call(NODE_BODY(node));
+ case ND_QUANT:
+ tune_call2_call(ND_BODY(node));
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (ANCHOR_HAS_BODY(ANCHOR_(node)))
- tune_call2_call(NODE_BODY(node));
+ tune_call2_call(ND_BODY(node));
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (! NODE_IS_MARK1(node)) {
- NODE_STATUS_ADD(node, MARK1);
- tune_call2_call(NODE_BODY(node));
- NODE_STATUS_REMOVE(node, MARK1);
+ if (! ND_IS_MARK1(node)) {
+ ND_STATUS_ADD(node, MARK1);
+ tune_call2_call(ND_BODY(node));
+ ND_STATUS_REMOVE(node, MARK1);
}
}
else if (en->type == BAG_IF_ELSE) {
- tune_call2_call(NODE_BODY(node));
+ tune_call2_call(ND_BODY(node));
if (IS_NOT_NULL(en->te.Then))
tune_call2_call(en->te.Then);
if (IS_NOT_NULL(en->te.Else))
tune_call2_call(en->te.Else);
}
else {
- tune_call2_call(NODE_BODY(node));
+ tune_call2_call(ND_BODY(node));
}
}
break;
- case NODE_CALL:
- if (! NODE_IS_MARK1(node)) {
- NODE_STATUS_ADD(node, MARK1);
+ case ND_CALL:
+ if (! ND_IS_MARK1(node)) {
+ ND_STATUS_ADD(node, MARK1);
{
CallNode* cn = CALL_(node);
- Node* called = NODE_CALL_BODY(cn);
+ Node* called = ND_CALL_BODY(cn);
cn->entry_count++;
- NODE_STATUS_ADD(called, CALLED);
+ ND_STATUS_ADD(called, CALLED);
BAG_(called)->m.entry_count++;
tune_call2_call(called);
}
- NODE_STATUS_REMOVE(node, MARK1);
+ ND_STATUS_REMOVE(node, MARK1);
}
break;
@@ -5251,41 +5307,41 @@ tune_call(Node* node, ParseEnv* env, int state)
{
int r;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = tune_call(NODE_CAR(node), env, state);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = tune_call(ND_CAR(node), env, state);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
+ case ND_QUANT:
if (QUANT_(node)->upper == 0)
state |= IN_ZERO_REPEAT;
- r = tune_call(NODE_BODY(node), env, state);
+ r = tune_call(ND_BODY(node), env, state);
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (ANCHOR_HAS_BODY(ANCHOR_(node)))
- r = tune_call(NODE_BODY(node), env, state);
+ r = tune_call(ND_BODY(node), env, state);
else
r = 0;
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
if ((state & IN_ZERO_REPEAT) != 0) {
- NODE_STATUS_ADD(node, IN_ZERO_REPEAT);
+ ND_STATUS_ADD(node, IN_ZERO_REPEAT);
BAG_(node)->m.entry_count--;
}
- r = tune_call(NODE_BODY(node), env, state);
+ r = tune_call(ND_BODY(node), env, state);
}
else if (en->type == BAG_IF_ELSE) {
- r = tune_call(NODE_BODY(node), env, state);
+ r = tune_call(ND_BODY(node), env, state);
if (r != 0) return r;
if (IS_NOT_NULL(en->te.Then)) {
r = tune_call(en->te.Then, env, state);
@@ -5295,13 +5351,13 @@ tune_call(Node* node, ParseEnv* env, int state)
r = tune_call(en->te.Else, env, state);
}
else
- r = tune_call(NODE_BODY(node), env, state);
+ r = tune_call(ND_BODY(node), env, state);
}
break;
- case NODE_CALL:
+ case ND_CALL:
if ((state & IN_ZERO_REPEAT) != 0) {
- NODE_STATUS_ADD(node, IN_ZERO_REPEAT);
+ ND_STATUS_ADD(node, IN_ZERO_REPEAT);
CALL_(node)->entry_count--;
}
@@ -5321,27 +5377,27 @@ tune_call2(Node* node)
{
int r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = tune_call2(NODE_CAR(node));
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = tune_call2(ND_CAR(node));
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
+ case ND_QUANT:
if (QUANT_(node)->upper != 0)
- r = tune_call2(NODE_BODY(node));
+ r = tune_call2(ND_BODY(node));
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
if (ANCHOR_HAS_BODY(ANCHOR_(node)))
- r = tune_call2(NODE_BODY(node));
+ r = tune_call2(ND_BODY(node));
break;
- case NODE_BAG:
- if (! NODE_IS_IN_ZERO_REPEAT(node))
- r = tune_call2(NODE_BODY(node));
+ case ND_BAG:
+ if (! ND_IS_IN_ZERO_REPEAT(node))
+ r = tune_call2(ND_BODY(node));
{
BagNode* en = BAG_(node);
@@ -5358,8 +5414,8 @@ tune_call2(Node* node)
}
break;
- case NODE_CALL:
- if (! NODE_IS_IN_ZERO_REPEAT(node)) {
+ case ND_CALL:
+ if (! ND_IS_IN_ZERO_REPEAT(node)) {
tune_call2_call(node);
}
break;
@@ -5375,17 +5431,17 @@ tune_call2(Node* node)
static void
tune_called_state_call(Node* node, int state)
{
- switch (NODE_TYPE(node)) {
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_ALT:
state |= IN_ALT;
/* fall */
- case NODE_LIST:
+ case ND_LIST:
do {
- tune_called_state_call(NODE_CAR(node), state);
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ tune_called_state_call(ND_CAR(node), state);
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
@@ -5394,13 +5450,13 @@ tune_called_state_call(Node* node, int state)
if (qn->lower != qn->upper)
state |= IN_VAR_REPEAT;
if ((state & IN_PEEK) != 0)
- NODE_STATUS_ADD(node, INPEEK);
+ ND_STATUS_ADD(node, INPEEK);
- tune_called_state_call(NODE_QUANT_BODY(qn), state);
+ tune_called_state_call(ND_QUANT_BODY(qn), state);
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
{
AnchorNode* an = ANCHOR_(node);
@@ -5408,12 +5464,12 @@ tune_called_state_call(Node* node, int state)
case ANCR_PREC_READ_NOT:
case ANCR_LOOK_BEHIND_NOT:
state |= (IN_NOT | IN_PEEK);
- tune_called_state_call(NODE_ANCHOR_BODY(an), state);
+ tune_called_state_call(ND_ANCHOR_BODY(an), state);
break;
case ANCR_PREC_READ:
case ANCR_LOOK_BEHIND:
state |= IN_PEEK;
- tune_called_state_call(NODE_ANCHOR_BODY(an), state);
+ tune_called_state_call(ND_ANCHOR_BODY(an), state);
break;
default:
break;
@@ -5421,27 +5477,27 @@ tune_called_state_call(Node* node, int state)
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
if (en->type == BAG_MEMORY) {
- if (NODE_IS_MARK1(node)) {
+ if (ND_IS_MARK1(node)) {
if ((~en->m.called_state & state) != 0) {
en->m.called_state |= state;
- tune_called_state_call(NODE_BODY(node), state);
+ tune_called_state_call(ND_BODY(node), state);
}
}
else {
- NODE_STATUS_ADD(node, MARK1);
+ ND_STATUS_ADD(node, MARK1);
en->m.called_state |= state;
- tune_called_state_call(NODE_BODY(node), state);
- NODE_STATUS_REMOVE(node, MARK1);
+ tune_called_state_call(ND_BODY(node), state);
+ ND_STATUS_REMOVE(node, MARK1);
}
}
else if (en->type == BAG_IF_ELSE) {
state |= IN_ALT;
- tune_called_state_call(NODE_BODY(node), state);
+ tune_called_state_call(ND_BODY(node), state);
if (IS_NOT_NULL(en->te.Then)) {
tune_called_state_call(en->te.Then, state);
}
@@ -5449,18 +5505,18 @@ tune_called_state_call(Node* node, int state)
tune_called_state_call(en->te.Else, state);
}
else {
- tune_called_state_call(NODE_BODY(node), state);
+ tune_called_state_call(ND_BODY(node), state);
}
}
break;
- case NODE_CALL:
+ case ND_CALL:
if ((state & IN_PEEK) != 0)
- NODE_STATUS_ADD(node, INPEEK);
+ ND_STATUS_ADD(node, INPEEK);
if ((state & IN_REAL_REPEAT) != 0)
- NODE_STATUS_ADD(node, IN_REAL_REPEAT);
+ ND_STATUS_ADD(node, IN_REAL_REPEAT);
- tune_called_state_call(NODE_BODY(node), state);
+ tune_called_state_call(ND_BODY(node), state);
break;
default:
@@ -5471,28 +5527,28 @@ tune_called_state_call(Node* node, int state)
static void
tune_called_state(Node* node, int state)
{
- switch (NODE_TYPE(node)) {
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_ALT:
state |= IN_ALT;
/* fall */
- case NODE_LIST:
+ case ND_LIST:
do {
- tune_called_state(NODE_CAR(node), state);
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ tune_called_state(ND_CAR(node), state);
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
if ((state & IN_PEEK) != 0)
- NODE_STATUS_ADD(node, INPEEK);
+ ND_STATUS_ADD(node, INPEEK);
if ((state & IN_REAL_REPEAT) != 0)
- NODE_STATUS_ADD(node, IN_REAL_REPEAT);
+ ND_STATUS_ADD(node, IN_REAL_REPEAT);
tune_called_state_call(node, state);
break;
#endif
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
@@ -5505,11 +5561,11 @@ tune_called_state(Node* node, int state)
/* fall */
case BAG_OPTION:
case BAG_STOP_BACKTRACK:
- tune_called_state(NODE_BODY(node), state);
+ tune_called_state(ND_BODY(node), state);
break;
case BAG_IF_ELSE:
state |= IN_ALT;
- tune_called_state(NODE_BODY(node), state);
+ tune_called_state(ND_BODY(node), state);
if (IS_NOT_NULL(en->te.Then))
tune_called_state(en->te.Then, state);
if (IS_NOT_NULL(en->te.Else))
@@ -5519,7 +5575,7 @@ tune_called_state(Node* node, int state)
}
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
@@ -5528,13 +5584,13 @@ tune_called_state(Node* node, int state)
if (qn->lower != qn->upper)
state |= IN_VAR_REPEAT;
if ((state & IN_PEEK) != 0)
- NODE_STATUS_ADD(node, INPEEK);
+ ND_STATUS_ADD(node, INPEEK);
- tune_called_state(NODE_QUANT_BODY(qn), state);
+ tune_called_state(ND_QUANT_BODY(qn), state);
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
{
AnchorNode* an = ANCHOR_(node);
@@ -5542,12 +5598,12 @@ tune_called_state(Node* node, int state)
case ANCR_PREC_READ_NOT:
case ANCR_LOOK_BEHIND_NOT:
state |= (IN_NOT | IN_PEEK);
- tune_called_state(NODE_ANCHOR_BODY(an), state);
+ tune_called_state(ND_ANCHOR_BODY(an), state);
break;
case ANCR_PREC_READ:
case ANCR_LOOK_BEHIND:
state |= IN_PEEK;
- tune_called_state(NODE_ANCHOR_BODY(an), state);
+ tune_called_state(ND_ANCHOR_BODY(an), state);
break;
default:
break;
@@ -5555,11 +5611,11 @@ tune_called_state(Node* node, int state)
}
break;
- case NODE_BACKREF:
- case NODE_STRING:
- case NODE_CTYPE:
- case NODE_CCLASS:
- case NODE_GIMMICK:
+ case ND_BACKREF:
+ case ND_STRING:
+ case ND_CTYPE:
+ case ND_CCLASS:
+ case ND_GIMMICK:
default:
break;
}
@@ -5579,10 +5635,10 @@ tune_anchor(Node* node, regex_t* reg, int state, ParseEnv* env)
switch (an->type) {
case ANCR_PREC_READ:
- r = tune_tree(NODE_ANCHOR_BODY(an), reg, (state | IN_PREC_READ), env);
+ r = tune_tree(ND_ANCHOR_BODY(an), reg, (state | IN_PREC_READ), env);
break;
case ANCR_PREC_READ_NOT:
- r = tune_tree(NODE_ANCHOR_BODY(an), reg, (state | IN_PREC_READ | IN_NOT),
+ r = tune_tree(ND_ANCHOR_BODY(an), reg, (state | IN_PREC_READ | IN_NOT),
env);
break;
@@ -5607,13 +5663,13 @@ tune_quant(Node* node, regex_t* reg, int state, ParseEnv* env)
{
int r;
QuantNode* qn = QUANT_(node);
- Node* body = NODE_BODY(node);
+ Node* body = ND_BODY(node);
if ((state & IN_REAL_REPEAT) != 0) {
- NODE_STATUS_ADD(node, IN_REAL_REPEAT);
+ ND_STATUS_ADD(node, IN_REAL_REPEAT);
}
if ((state & IN_MULTI_ENTRY) != 0) {
- NODE_STATUS_ADD(node, IN_MULTI_ENTRY);
+ ND_STATUS_ADD(node, IN_MULTI_ENTRY);
}
if (IS_INFINITE_REPEAT(qn->upper) || qn->upper >= 1) {
@@ -5637,10 +5693,10 @@ tune_quant(Node* node, regex_t* reg, int state, ParseEnv* env)
/* expand string */
#define EXPAND_STRING_MAX_LENGTH 100
- if (NODE_TYPE(body) == NODE_STRING) {
+ if (ND_TYPE(body) == ND_STRING) {
if (!IS_INFINITE_REPEAT(qn->lower) && qn->lower == qn->upper &&
qn->lower > 1 && qn->lower <= EXPAND_STRING_MAX_LENGTH) {
- int len = NODE_STRING_LEN(body);
+ int len = ND_STRING_LEN(body);
if (len * qn->lower <= EXPAND_STRING_MAX_LENGTH) {
int i, n = qn->lower;
@@ -5656,7 +5712,7 @@ tune_quant(Node* node, regex_t* reg, int state, ParseEnv* env)
}
if (qn->greedy && (qn->emptiness == BODY_IS_NOT_EMPTY)) {
- if (NODE_TYPE(body) == NODE_QUANT) {
+ if (ND_TYPE(body) == ND_QUANT) {
QuantNode* tqn = QUANT_(body);
if (IS_NOT_NULL(tqn->head_exact)) {
qn->head_exact = tqn->head_exact;
@@ -5664,7 +5720,7 @@ tune_quant(Node* node, regex_t* reg, int state, ParseEnv* env)
}
}
else {
- qn->head_exact = get_tree_head_literal(NODE_BODY(node), 1, reg);
+ qn->head_exact = get_tree_head_literal(ND_BODY(node), 1, reg);
}
}
@@ -5684,33 +5740,33 @@ tune_tree(Node* node, regex_t* reg, int state, ParseEnv* env)
{
int r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
{
Node* prev = NULL_NODE;
do {
- r = tune_tree(NODE_CAR(node), reg, state, env);
+ r = tune_tree(ND_CAR(node), reg, state, env);
if (IS_NOT_NULL(prev) && r == 0) {
- r = tune_next(prev, NODE_CAR(node), reg);
+ r = tune_next(prev, ND_CAR(node), reg);
}
- prev = NODE_CAR(node);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ prev = ND_CAR(node);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
}
break;
- case NODE_ALT:
+ case ND_ALT:
do {
- r = tune_tree(NODE_CAR(node), reg, (state | IN_ALT), env);
- } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node)));
+ r = tune_tree(ND_CAR(node), reg, (state | IN_ALT), env);
+ } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_STRING:
- if (NODE_IS_REAL_IGNORECASE(node)) {
+ case ND_STRING:
+ if (ND_IS_REAL_IGNORECASE(node)) {
r = unravel_case_fold_string(node, reg, state);
}
break;
- case NODE_BACKREF:
+ case ND_BACKREF:
{
int i;
int* p;
@@ -5721,7 +5777,7 @@ tune_tree(Node* node, regex_t* reg, int state, ParseEnv* env)
MEM_STATUS_ON(env->backrefed_mem, p[i]);
#if 0
#ifdef USE_BACKREF_WITH_LEVEL
- if (NODE_IS_NEST_LEVEL(node)) {
+ if (ND_IS_NEST_LEVEL(node)) {
MEM_STATUS_ON(env->backtrack_mem, p[i]);
}
#endif
@@ -5735,7 +5791,7 @@ tune_tree(Node* node, regex_t* reg, int state, ParseEnv* env)
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
@@ -5744,7 +5800,7 @@ tune_tree(Node* node, regex_t* reg, int state, ParseEnv* env)
{
OnigOptionType options = reg->options;
reg->options = BAG_(node)->o.options;
- r = tune_tree(NODE_BODY(node), reg, state, env);
+ r = tune_tree(ND_BODY(node), reg, state, env);
reg->options = options;
}
break;
@@ -5755,29 +5811,29 @@ tune_tree(Node* node, regex_t* reg, int state, ParseEnv* env)
#endif
if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_MULTI_ENTRY)) != 0
- || NODE_IS_RECURSION(node)) {
+ || ND_IS_RECURSION(node)) {
MEM_STATUS_ON(env->backtrack_mem, en->m.regnum);
}
- r = tune_tree(NODE_BODY(node), reg, state, env);
+ r = tune_tree(ND_BODY(node), reg, state, env);
break;
case BAG_STOP_BACKTRACK:
{
- Node* target = NODE_BODY(node);
+ Node* target = ND_BODY(node);
r = tune_tree(target, reg, state, env);
- if (NODE_TYPE(target) == NODE_QUANT) {
+ if (ND_TYPE(target) == ND_QUANT) {
QuantNode* tqn = QUANT_(target);
if (IS_INFINITE_REPEAT(tqn->upper) && tqn->lower <= 1 &&
tqn->greedy != 0) { /* (?>a*), a*+ etc... */
- if (is_strict_real_node(NODE_BODY(target)))
- NODE_STATUS_ADD(node, STRICT_REAL_REPEAT);
+ if (is_strict_real_node(ND_BODY(target)))
+ ND_STATUS_ADD(node, STRICT_REAL_REPEAT);
}
}
}
break;
case BAG_IF_ELSE:
- r = tune_tree(NODE_BODY(node), reg, (state | IN_ALT), env);
+ r = tune_tree(ND_BODY(node), reg, (state | IN_ALT), env);
if (r != 0) return r;
if (IS_NOT_NULL(en->te.Then)) {
r = tune_tree(en->te.Then, reg, (state | IN_ALT), env);
@@ -5790,23 +5846,23 @@ tune_tree(Node* node, regex_t* reg, int state, ParseEnv* env)
}
break;
- case NODE_QUANT:
+ case ND_QUANT:
if ((state & (IN_PREC_READ | IN_LOOK_BEHIND)) != 0)
- NODE_STATUS_ADD(node, INPEEK);
+ ND_STATUS_ADD(node, INPEEK);
r = tune_quant(node, reg, state, env);
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
r = tune_anchor(node, reg, state, env);
break;
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
#endif
- case NODE_CTYPE:
- case NODE_CCLASS:
- case NODE_GIMMICK:
+ case ND_CTYPE:
+ case ND_CCLASS:
+ case ND_GIMMICK:
default:
break;
}
@@ -6427,42 +6483,42 @@ node_max_byte_len(Node* node, ParseEnv* env)
OnigLen tmax;
len = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
do {
- tmax = node_max_byte_len(NODE_CAR(node), env);
+ tmax = node_max_byte_len(ND_CAR(node), env);
len = distance_add(len, tmax);
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_ALT:
+ case ND_ALT:
do {
- tmax = node_max_byte_len(NODE_CAR(node), env);
+ tmax = node_max_byte_len(ND_CAR(node), env);
if (len < tmax) len = tmax;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_STRING:
+ case ND_STRING:
{
StrNode* sn = STR_(node);
len = (OnigLen )(sn->end - sn->s);
}
break;
- case NODE_CTYPE:
- case NODE_CCLASS:
+ case ND_CTYPE:
+ case ND_CCLASS:
len = ONIGENC_MBC_MAXLEN_DIST(env->enc);
break;
- case NODE_BACKREF:
- if (! NODE_IS_CHECKER(node)) {
+ case ND_BACKREF:
+ if (! ND_IS_CHECKER(node)) {
int i;
int* backs;
MemEnv* mem_env = PARSEENV_MEMENV(env);
BackRefNode* br = BACKREF_(node);
- if (NODE_IS_RECURSION(node)) {
+ if (ND_IS_RECURSION(node)) {
#ifdef USE_BACKREF_WITH_LEVEL
- if (NODE_IS_NEST_LEVEL(node)) {
+ if (ND_IS_NEST_LEVEL(node)) {
len = INFINITE_LEN;
}
#endif
@@ -6477,20 +6533,20 @@ node_max_byte_len(Node* node, ParseEnv* env)
break;
#ifdef USE_CALL
- case NODE_CALL:
- if (! NODE_IS_RECURSION(node))
- len = node_max_byte_len(NODE_BODY(node), env);
+ case ND_CALL:
+ if (! ND_IS_RECURSION(node))
+ len = node_max_byte_len(ND_BODY(node), env);
else
len = INFINITE_LEN;
break;
#endif
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
if (qn->upper != 0) {
- len = node_max_byte_len(NODE_BODY(node), env);
+ len = node_max_byte_len(ND_BODY(node), env);
if (len != 0) {
if (! IS_INFINITE_REPEAT(qn->upper))
len = distance_multiply(len, qn->upper);
@@ -6501,36 +6557,36 @@ node_max_byte_len(Node* node, ParseEnv* env)
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
switch (en->type) {
case BAG_MEMORY:
- if (NODE_IS_FIXED_MAX(node))
+ if (ND_IS_FIXED_MAX(node))
len = en->max_len;
else {
- if (NODE_IS_MARK1(node))
+ if (ND_IS_MARK1(node))
len = INFINITE_LEN;
else {
- NODE_STATUS_ADD(node, MARK1);
- len = node_max_byte_len(NODE_BODY(node), env);
- NODE_STATUS_REMOVE(node, MARK1);
+ ND_STATUS_ADD(node, MARK1);
+ len = node_max_byte_len(ND_BODY(node), env);
+ ND_STATUS_REMOVE(node, MARK1);
en->max_len = len;
- NODE_STATUS_ADD(node, FIXED_MAX);
+ ND_STATUS_ADD(node, FIXED_MAX);
}
}
break;
case BAG_OPTION:
case BAG_STOP_BACKTRACK:
- len = node_max_byte_len(NODE_BODY(node), env);
+ len = node_max_byte_len(ND_BODY(node), env);
break;
case BAG_IF_ELSE:
{
OnigLen tlen, elen;
- len = node_max_byte_len(NODE_BODY(node), env);
+ len = node_max_byte_len(ND_BODY(node), env);
if (IS_NOT_NULL(en->te.Then)) {
tlen = node_max_byte_len(en->te.Then, env);
len = distance_add(len, tlen);
@@ -6546,8 +6602,8 @@ node_max_byte_len(Node* node, ParseEnv* env)
}
break;
- case NODE_ANCHOR:
- case NODE_GIMMICK:
+ case ND_ANCHOR:
+ case ND_GIMMICK:
default:
break;
}
@@ -6555,7 +6611,7 @@ node_max_byte_len(Node* node, ParseEnv* env)
return len;
}
-#define MAX_NODE_OPT_INFO_REF_COUNT 5
+#define MAX_ND_OPT_INFO_REF_COUNT 5
static int
optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
@@ -6570,38 +6626,38 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
clear_node_opt_info(opt);
set_bound_node_opt_info(opt, &env->mm);
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
{
OptEnv nenv;
Node* nd = node;
copy_opt_env(&nenv, env);
do {
- r = optimize_nodes(NODE_CAR(nd), &xo, &nenv);
+ r = optimize_nodes(ND_CAR(nd), &xo, &nenv);
if (r == 0) {
mml_add(&nenv.mm, &xo.len);
concat_left_node_opt_info(enc, opt, &xo);
}
- } while (r == 0 && IS_NOT_NULL(nd = NODE_CDR(nd)));
+ } while (r == 0 && IS_NOT_NULL(nd = ND_CDR(nd)));
}
break;
- case NODE_ALT:
+ case ND_ALT:
{
Node* nd = node;
do {
- r = optimize_nodes(NODE_CAR(nd), &xo, env);
+ r = optimize_nodes(ND_CAR(nd), &xo, env);
if (r == 0) {
if (nd == node) copy_node_opt_info(opt, &xo);
else alt_merge_node_opt_info(opt, &xo, env);
}
- } while ((r == 0) && IS_NOT_NULL(nd = NODE_CDR(nd)));
+ } while ((r == 0) && IS_NOT_NULL(nd = ND_CDR(nd)));
}
break;
- case NODE_STRING:
+ case ND_STRING:
{
StrNode* sn = STR_(node);
int slen = (int )(sn->end - sn->s);
@@ -6614,7 +6670,7 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
}
break;
- case NODE_CCLASS:
+ case ND_CCLASS:
{
int z;
CClassNode* cc = CCLASS_(node);
@@ -6639,7 +6695,7 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
}
break;
- case NODE_CTYPE:
+ case ND_CTYPE:
{
int min, max;
int range;
@@ -6682,7 +6738,7 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
switch (ANCHOR_(node)->type) {
case ANCR_BEGIN_BUF:
case ANCR_BEGIN_POSITION:
@@ -6697,7 +6753,7 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
case ANCR_PREC_READ:
{
- r = optimize_nodes(NODE_BODY(node), &xo, env);
+ r = optimize_nodes(ND_BODY(node), &xo, env);
if (r == 0) {
if (xo.sb.len > 0)
copy_opt_exact(&opt->spr, &xo.sb);
@@ -6717,8 +6773,8 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
}
break;
- case NODE_BACKREF:
- if (! NODE_IS_CHECKER(node)) {
+ case ND_BACKREF:
+ if (! ND_IS_CHECKER(node)) {
OnigLen min, max;
min = node_min_byte_len(node, env->scan_env);
@@ -6728,16 +6784,16 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
break;
#ifdef USE_CALL
- case NODE_CALL:
- if (NODE_IS_RECURSION(node))
+ case ND_CALL:
+ if (ND_IS_RECURSION(node))
mml_set_min_max(&opt->len, 0, INFINITE_LEN);
else {
- r = optimize_nodes(NODE_BODY(node), opt, env);
+ r = optimize_nodes(ND_BODY(node), opt, env);
}
break;
#endif
- case NODE_QUANT:
+ case ND_QUANT:
{
OnigLen min, max;
QuantNode* qn = QUANT_(node);
@@ -6756,7 +6812,7 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
break;
}
- r = optimize_nodes(NODE_BODY(node), &xo, env);
+ r = optimize_nodes(ND_BODY(node), &xo, env);
if (r != 0) break;
if (qn->lower > 0) {
@@ -6781,8 +6837,8 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
if (IS_INFINITE_REPEAT(qn->upper)) {
if (env->mm.max == 0 &&
- NODE_IS_ANYCHAR(NODE_BODY(node)) && qn->greedy != 0) {
- if (NODE_IS_MULTILINE(NODE_QUANT_BODY(qn)))
+ ND_IS_ANYCHAR(ND_BODY(node)) && qn->greedy != 0) {
+ if (ND_IS_MULTILINE(ND_QUANT_BODY(qn)))
add_opt_anc_info(&opt->anc, ANCR_ANYCHAR_INF_ML);
else
add_opt_anc_info(&opt->anc, ANCR_ANYCHAR_INF);
@@ -6799,32 +6855,32 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
switch (en->type) {
case BAG_STOP_BACKTRACK:
case BAG_OPTION:
- r = optimize_nodes(NODE_BODY(node), opt, env);
+ r = optimize_nodes(ND_BODY(node), opt, env);
break;
case BAG_MEMORY:
#ifdef USE_CALL
en->opt_count++;
- if (en->opt_count > MAX_NODE_OPT_INFO_REF_COUNT) {
+ if (en->opt_count > MAX_ND_OPT_INFO_REF_COUNT) {
OnigLen min, max;
min = 0;
max = INFINITE_LEN;
- if (NODE_IS_FIXED_MIN(node)) min = en->min_len;
- if (NODE_IS_FIXED_MAX(node)) max = en->max_len;
+ if (ND_IS_FIXED_MIN(node)) min = en->min_len;
+ if (ND_IS_FIXED_MAX(node)) max = en->max_len;
mml_set_min_max(&opt->len, min, max);
}
else
#endif
{
- r = optimize_nodes(NODE_BODY(node), opt, env);
+ r = optimize_nodes(ND_BODY(node), opt, env);
if (is_set_opt_anc_info(&opt->anc, ANCR_ANYCHAR_INF_MASK)) {
if (MEM_STATUS_AT0(env->scan_env->backrefed_mem, en->m.regnum))
remove_opt_anc_info(&opt->anc, ANCR_ANYCHAR_INF_MASK);
@@ -6838,7 +6894,7 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
if (IS_NOT_NULL(en->te.Else)) {
copy_opt_env(&nenv, env);
- r = optimize_nodes(NODE_BAG_BODY(en), &xo, &nenv);
+ r = optimize_nodes(ND_BAG_BODY(en), &xo, &nenv);
if (r == 0) {
mml_add(&nenv.mm, &xo.len);
concat_left_node_opt_info(enc, opt, &xo);
@@ -6860,12 +6916,12 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env)
}
break;
- case NODE_GIMMICK:
+ case ND_GIMMICK:
break;
default:
#ifdef ONIG_DEBUG
- fprintf(DBGFP, "optimize_nodes: undefined node type %d\n", NODE_TYPE(node));
+ fprintf(DBGFP, "optimize_nodes: undefined node type %d\n", ND_TYPE(node));
#endif
r = ONIGERR_TYPE_BUG;
break;
@@ -7018,10 +7074,12 @@ clear_optimize_info(regex_t* reg)
}
}
-#ifdef ONIG_DEBUG
+#if defined(ONIG_DEBUG_PARSE) || defined(ONIG_DEBUG_MATCH) || \
+ defined(ONIG_DEBUG_SEARCH) || defined(ONIG_DEBUG_COMPILE)
-static void print_enc_string(FILE* fp, OnigEncoding enc,
- const UChar *s, const UChar *end)
+static void
+print_enc_string(FILE* fp, OnigEncoding enc,
+ const UChar *s, const UChar *end)
{
if (ONIGENC_MBC_MINLEN(enc) > 1) {
const UChar *p;
@@ -7042,7 +7100,17 @@ static void print_enc_string(FILE* fp, OnigEncoding enc,
}
else {
while (s < end) {
- fputc((int )*s, fp);
+ if (ONIGENC_MBC_MAXLEN(enc) == 1) {
+ if (*s >= 0x80) {
+ fprintf(fp, "\\x%02x", (unsigned int )*s);
+ }
+ else {
+ fputc((int )*s, fp);
+ }
+ }
+ else { /* for UTF-8 */
+ fputc((int )*s, fp);
+ }
s++;
}
}
@@ -7077,7 +7145,7 @@ print_options(FILE* fp, OnigOptionType o)
if ((o & ONIG_OPTION_CALLBACK_EACH_MATCH) != 0) fprintf(fp, " CALLBACK_EACH_MATCH");
}
-#endif /* ONIG_DEBUG */
+#endif
#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH)
@@ -7426,7 +7494,8 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
UnsetAddrList uslist = {0};
#endif
-#ifdef ONIG_DEBUG
+#if defined(ONIG_DEBUG_PARSE) || defined(ONIG_DEBUG_MATCH) || \
+ defined(ONIG_DEBUG_SEARCH) || defined(ONIG_DEBUG_COMPILE)
fprintf(DBGFP, "\nPATTERN: /");
print_enc_string(DBGFP, reg->enc, pattern, pattern_end);
fprintf(DBGFP, "/\n");
@@ -7836,30 +7905,30 @@ mostly_just_anychar(Node* node, int in_reluctant)
MJ_RESULT r;
r = MJ_NO;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
{
int found = FALSE;
do {
- r = mostly_just_anychar(NODE_CAR(node), in_reluctant);
+ r = mostly_just_anychar(ND_CAR(node), in_reluctant);
if (r == MJ_NO) break;
if (r == MJ_YES) found = TRUE;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
if (r == MJ_IGNORE) {
if (found == TRUE) r = MJ_YES;
}
}
break;
- case NODE_ALT:
+ case ND_ALT:
r = MJ_IGNORE;
do {
- r = mostly_just_anychar(NODE_CAR(node), in_reluctant);
+ r = mostly_just_anychar(ND_CAR(node), in_reluctant);
if (r == MJ_YES) break;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
QuantNode* qn = QUANT_(node);
@@ -7873,12 +7942,12 @@ mostly_just_anychar(Node* node, int in_reluctant)
in_reluctant = TRUE;
}
}
- r = mostly_just_anychar(NODE_BODY(node), in_reluctant);
+ r = mostly_just_anychar(ND_BODY(node), in_reluctant);
}
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
switch (ANCHOR_(node)->type) {
case ANCR_PREC_READ:
case ANCR_PREC_READ_NOT:
@@ -7892,7 +7961,7 @@ mostly_just_anychar(Node* node, int in_reluctant)
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
@@ -7906,34 +7975,34 @@ mostly_just_anychar(Node* node, int in_reluctant)
}
}
else {
- r = mostly_just_anychar(NODE_BODY(node), in_reluctant);
+ r = mostly_just_anychar(ND_BODY(node), in_reluctant);
}
}
break;
- case NODE_CTYPE:
+ case ND_CTYPE:
if (CTYPE_(node)->ctype == CTYPE_ANYCHAR)
r = MJ_YES;
else
r = MJ_NO;
break;
- case NODE_STRING:
- if (NODE_STRING_LEN(node) == 0) {
+ case ND_STRING:
+ if (ND_STRING_LEN(node) == 0) {
r = MJ_IGNORE;
break;
}
/* fall */
- case NODE_CCLASS:
+ case ND_CCLASS:
r = MJ_NO;
break;
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
/* ignore call */
#endif
- case NODE_BACKREF:
- case NODE_GIMMICK:
+ case ND_BACKREF:
+ case ND_GIMMICK:
r = MJ_IGNORE;
break;
@@ -7965,23 +8034,23 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
int r;
r = 0;
- switch (NODE_TYPE(node)) {
- case NODE_LIST:
- case NODE_ALT:
+ switch (ND_TYPE(node)) {
+ case ND_LIST:
+ case ND_ALT:
do {
- r = detect_can_be_slow(NODE_CAR(node), ct, ncall, calls);
+ r = detect_can_be_slow(ND_CAR(node), ct, ncall, calls);
if (r != 0) return r;
- } while (IS_NOT_NULL(node = NODE_CDR(node)));
+ } while (IS_NOT_NULL(node = ND_CDR(node)));
break;
- case NODE_QUANT:
+ case ND_QUANT:
{
- int prev_heavy_element;
QuantNode* qn;
Node* body;
+ int prev_heavy_element = 0;
qn = QUANT_(node);
- body = NODE_BODY(node);
+ body = ND_BODY(node);
if (qn->emptiness != BODY_IS_NOT_EMPTY) {
prev_heavy_element = ct->heavy_element;
@@ -7989,8 +8058,7 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
if (ct->empty_check_nest_level > ct->max_empty_check_nest_level)
ct->max_empty_check_nest_level = ct->empty_check_nest_level;
}
- else if (IS_INFINITE_REPEAT(qn->upper) ||
- qn->upper > MANY_REPEAT_OF_ANYCHAR) {
+ else if (IS_INFINITE_REPEAT(qn->upper) || qn->upper > 0) {
MJ_RESULT mr = mostly_just_anychar(body, (qn->greedy == 0));
if (mr == MJ_YES)
ct->anychar_reluctant_many++;
@@ -7999,7 +8067,7 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
r = detect_can_be_slow(body, ct, ncall, calls);
if (qn->emptiness != BODY_IS_NOT_EMPTY) {
- if (NODE_IS_INPEEK(node)) {
+ if (ND_IS_INPEEK(node)) {
if (ct->empty_check_nest_level > 2) {
if (prev_heavy_element == ct->heavy_element)
ct->heavy_element++;
@@ -8010,7 +8078,7 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
switch (ANCHOR_(node)->type) {
case ANCR_PREC_READ:
case ANCR_PREC_READ_NOT:
@@ -8025,14 +8093,14 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
}
if (ANCHOR_HAS_BODY(ANCHOR_(node)))
- r = detect_can_be_slow(NODE_BODY(node), ct, ncall, calls);
+ r = detect_can_be_slow(ND_BODY(node), ct, ncall, calls);
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* en = BAG_(node);
- r = detect_can_be_slow(NODE_BODY(node), ct, ncall, calls);
+ r = detect_can_be_slow(ND_BODY(node), ct, ncall, calls);
if (r != 0) return r;
if (en->type == BAG_IF_ELSE) {
@@ -8049,8 +8117,8 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
break;
#ifdef USE_BACKREF_WITH_LEVEL
- case NODE_BACKREF:
- if (NODE_IS_NEST_LEVEL(node))
+ case ND_BACKREF:
+ if (ND_IS_NEST_LEVEL(node))
ct->heavy_element++;
else
ct->backref++;
@@ -8058,7 +8126,7 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
#endif
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
{
int i;
int found;
@@ -8067,8 +8135,8 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
gnum = CALL_(node)->called_gnum;
ct->call++;
- if (NODE_IS_RECURSION(node) && NODE_IS_INPEEK(node) &&
- NODE_IS_IN_REAL_REPEAT(node)) {
+ if (ND_IS_RECURSION(node) && ND_IS_INPEEK(node) &&
+ ND_IS_IN_REAL_REPEAT(node)) {
ct->heavy_element += 10;
}
@@ -8083,7 +8151,7 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
if (! found) {
if (ncall + 1 < MAX_CALLS_IN_DETECT) {
calls[ncall] = gnum;
- r = detect_can_be_slow(NODE_BODY(node), ct, ncall + 1, calls);
+ r = detect_can_be_slow(ND_BODY(node), ct, ncall + 1, calls);
}
else {
ct->heavy_element++;
@@ -8092,7 +8160,7 @@ detect_can_be_slow(Node* node, SlowElementCount* ct, int ncall, int calls[])
}
break;
#endif
- case NODE_GIMMICK:
+ case ND_GIMMICK:
{
GimmickNode* g = GIMMICK_(node);
if (g->type == GIMMICK_SAVE && g->detail_type == SAVE_KEEP)
@@ -8236,33 +8304,33 @@ print_indent_tree(FILE* f, Node* node, int indent)
exit(0);
}
- type = NODE_TYPE(node);
+ type = ND_TYPE(node);
switch (type) {
- case NODE_LIST:
- case NODE_ALT:
- if (type == NODE_LIST)
+ case ND_LIST:
+ case ND_ALT:
+ if (type == ND_LIST)
fprintf(f, "<list:%p>\n", node);
else
fprintf(f, "<alt:%p>\n", node);
- print_indent_tree(f, NODE_CAR(node), indent + add);
- while (IS_NOT_NULL(node = NODE_CDR(node))) {
- if (NODE_TYPE(node) != type) {
- fprintf(f, "ERROR: list/alt right is not a cons. %d\n", NODE_TYPE(node));
+ print_indent_tree(f, ND_CAR(node), indent + add);
+ while (IS_NOT_NULL(node = ND_CDR(node))) {
+ if (ND_TYPE(node) != type) {
+ fprintf(f, "ERROR: list/alt right is not a cons. %d\n", ND_TYPE(node));
exit(0);
}
- print_indent_tree(f, NODE_CAR(node), indent + add);
+ print_indent_tree(f, ND_CAR(node), indent + add);
}
break;
- case NODE_STRING:
+ case ND_STRING:
{
char* str;
char* mode;
- if (NODE_STRING_IS_CRUDE(node))
+ if (ND_STRING_IS_CRUDE(node))
mode = "-crude";
- else if (NODE_IS_IGNORECASE(node))
+ else if (ND_IS_IGNORECASE(node))
mode = "-ignorecase";
else
mode = "";
@@ -8283,7 +8351,7 @@ print_indent_tree(FILE* f, Node* node, int indent)
}
break;
- case NODE_CCLASS:
+ case ND_CCLASS:
#define CCLASS_MBUF_MAX_OUTPUT_NUM 10
fprintf(f, "<cclass:%p>", node);
@@ -8299,7 +8367,7 @@ print_indent_tree(FILE* f, Node* node, int indent)
}
break;
- case NODE_CTYPE:
+ case ND_CTYPE:
fprintf(f, "<ctype:%p> ", node);
switch (CTYPE_(node)->ctype) {
case CTYPE_ANYCHAR:
@@ -8323,7 +8391,7 @@ print_indent_tree(FILE* f, Node* node, int indent)
}
break;
- case NODE_ANCHOR:
+ case ND_ANCHOR:
fprintf(f, "<anchor:%p> ", node);
switch (ANCHOR_(node)->type) {
case ANCR_BEGIN_BUF: fputs("begin buf", f); break;
@@ -8345,19 +8413,19 @@ print_indent_tree(FILE* f, Node* node, int indent)
fputs("no text-segment boundary", f); break;
case ANCR_PREC_READ:
fprintf(f, "prec read\n");
- print_indent_tree(f, NODE_BODY(node), indent + add);
+ print_indent_tree(f, ND_BODY(node), indent + add);
break;
case ANCR_PREC_READ_NOT:
fprintf(f, "prec read not\n");
- print_indent_tree(f, NODE_BODY(node), indent + add);
+ print_indent_tree(f, ND_BODY(node), indent + add);
break;
case ANCR_LOOK_BEHIND:
fprintf(f, "look behind\n");
- print_indent_tree(f, NODE_BODY(node), indent + add);
+ print_indent_tree(f, ND_BODY(node), indent + add);
break;
case ANCR_LOOK_BEHIND_NOT:
fprintf(f, "look behind not\n");
- print_indent_tree(f, NODE_BODY(node), indent + add);
+ print_indent_tree(f, ND_BODY(node), indent + add);
break;
default:
@@ -8366,18 +8434,18 @@ print_indent_tree(FILE* f, Node* node, int indent)
}
break;
- case NODE_BACKREF:
+ case ND_BACKREF:
{
int* p;
BackRefNode* br = BACKREF_(node);
p = BACKREFS_P(br);
- fprintf(f, "<backref%s:%p>", NODE_IS_CHECKER(node) ? "-checker" : "", node);
+ fprintf(f, "<backref%s:%p>", ND_IS_CHECKER(node) ? "-checker" : "", node);
for (i = 0; i < br->back_num; i++) {
if (i > 0) fputs(", ", f);
fprintf(f, "%d", p[i]);
}
#ifdef USE_BACKREF_WITH_LEVEL
- if (NODE_IS_NEST_LEVEL(node)) {
+ if (ND_IS_NEST_LEVEL(node)) {
fprintf(f, ", level: %d", br->nest_level);
}
#endif
@@ -8385,33 +8453,33 @@ print_indent_tree(FILE* f, Node* node, int indent)
break;
#ifdef USE_CALL
- case NODE_CALL:
+ case ND_CALL:
{
CallNode* cn = CALL_(node);
fprintf(f, "<call:%p>", node);
fprintf(f, " num: %d, name", cn->called_gnum);
p_string(f, cn->name_end - cn->name, cn->name);
- if (NODE_IS_RECURSION(node)) fprintf(f, ", recursion");
- if (NODE_IS_INPEEK(node)) fprintf(f, ", in-peek");
- if (NODE_IS_IN_REAL_REPEAT(node)) fprintf(f, ", in-real-repeat");
+ if (ND_IS_RECURSION(node)) fprintf(f, ", recursion");
+ if (ND_IS_INPEEK(node)) fprintf(f, ", in-peek");
+ if (ND_IS_IN_REAL_REPEAT(node)) fprintf(f, ", in-real-repeat");
}
break;
#endif
- case NODE_QUANT:
+ case ND_QUANT:
{
fprintf(f, "<quantifier:%p>{%d,%d}%s%s%s", node,
QUANT_(node)->lower, QUANT_(node)->upper,
(QUANT_(node)->greedy ? "" : "?"),
QUANT_(node)->include_referred == 0 ? "" : " referred",
emptiness_name[QUANT_(node)->emptiness]);
- if (NODE_IS_INPEEK(node)) fprintf(f, ", in-peek");
+ if (ND_IS_INPEEK(node)) fprintf(f, ", in-peek");
fprintf(f, "\n");
- print_indent_tree(f, NODE_BODY(node), indent + add);
+ print_indent_tree(f, ND_BODY(node), indent + add);
}
break;
- case NODE_BAG:
+ case ND_BAG:
{
BagNode* bn = BAG_(node);
fprintf(f, "<bag:%p> ", node);
@@ -8420,7 +8488,7 @@ print_indent_tree(FILE* f, Node* node, int indent)
Node* Else;
fprintf(f, "if-else\n");
- print_indent_tree(f, NODE_BODY(node), indent + add);
+ print_indent_tree(f, ND_BODY(node), indent + add);
Then = bn->te.Then;
Else = bn->te.Else;
@@ -8445,15 +8513,15 @@ print_indent_tree(FILE* f, Node* node, int indent)
break;
case BAG_MEMORY:
fprintf(f, "memory:%d", bn->m.regnum);
- if (NODE_IS_CALLED(node)) {
+ if (ND_IS_CALLED(node)) {
fprintf(f, ", called");
- if (NODE_IS_RECURSION(node))
+ if (ND_IS_RECURSION(node))
fprintf(f, ", recursion");
}
- else if (NODE_IS_REFERENCED(node))
+ else if (ND_IS_REFERENCED(node))
fprintf(f, ", referenced");
- if (NODE_IS_FIXED_ADDR(node))
+ if (ND_IS_FIXED_ADDR(node))
fprintf(f, ", fixed-addr");
if ((bn->m.called_state & IN_PEEK) != 0)
fprintf(f, ", in-peek");
@@ -8465,12 +8533,12 @@ print_indent_tree(FILE* f, Node* node, int indent)
break;
}
fprintf(f, "\n");
- print_indent_tree(f, NODE_BODY(node), indent + add);
+ print_indent_tree(f, ND_BODY(node), indent + add);
}
}
break;
- case NODE_GIMMICK:
+ case ND_GIMMICK:
fprintf(f, "<gimmick:%p> ", node);
switch (GIMMICK_(node)->type) {
case GIMMICK_FAIL:
@@ -8497,12 +8565,12 @@ print_indent_tree(FILE* f, Node* node, int indent)
break;
default:
- fprintf(f, "print_indent_tree: undefined node type %d\n", NODE_TYPE(node));
+ fprintf(f, "print_indent_tree: undefined node type %d\n", ND_TYPE(node));
break;
}
- if (type != NODE_LIST && type != NODE_ALT && type != NODE_QUANT &&
- type != NODE_BAG)
+ if (type != ND_LIST && type != ND_ALT && type != ND_QUANT &&
+ type != ND_BAG)
fprintf(f, "\n");
fflush(f);
}