From: K.Kosako Date: Sun, 4 Nov 2018 04:30:26 +0000 (+0900) Subject: refactoring X-Git-Tag: v6.9.1~14 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=fad016dff18716b40d49f086f681302d19f48d74;p=onig refactoring --- diff --git a/src/regcomp.c b/src/regcomp.c index 9b7918f..31406c2 100644 --- a/src/regcomp.c +++ b/src/regcomp.c @@ -1003,49 +1003,49 @@ compile_quantifier_node(QuantNode* qn, regex_t* reg, ScanEnv* env) } static int -compile_length_option_node(EnclosureNode* node, regex_t* reg) +compile_length_option_node(BagNode* node, regex_t* reg) { int tlen; OnigOptionType prev = reg->options; reg->options = node->o.options; - tlen = compile_length_tree(NODE_ENCLOSURE_BODY(node), reg); + tlen = compile_length_tree(NODE_BAG_BODY(node), reg); reg->options = prev; return tlen; } static int -compile_option_node(EnclosureNode* node, regex_t* reg, ScanEnv* env) +compile_option_node(BagNode* node, regex_t* reg, ScanEnv* env) { int r; OnigOptionType prev = reg->options; reg->options = node->o.options; - r = compile_tree(NODE_ENCLOSURE_BODY(node), reg, env); + r = compile_tree(NODE_BAG_BODY(node), reg, env); reg->options = prev; return r; } static int -compile_length_enclosure_node(EnclosureNode* node, regex_t* reg) +compile_length_bag_node(BagNode* node, regex_t* reg) { int len; int tlen; - if (node->type == ENCLOSURE_OPTION) + if (node->type == BAG_OPTION) return compile_length_option_node(node, reg); - if (NODE_ENCLOSURE_BODY(node)) { - tlen = compile_length_tree(NODE_ENCLOSURE_BODY(node), reg); + if (NODE_BAG_BODY(node)) { + tlen = compile_length_tree(NODE_BAG_BODY(node), reg); if (tlen < 0) return tlen; } else tlen = 0; switch (node->type) { - case ENCLOSURE_MEMORY: + case BAG_MEMORY: #ifdef USE_CALL if (node->m.regnum == 0 && NODE_IS_CALLED(node)) { @@ -1081,12 +1081,12 @@ compile_length_enclosure_node(EnclosureNode* node, regex_t* reg) } break; - case ENCLOSURE_STOP_BACKTRACK: + case BAG_STOP_BACKTRACK: if (NODE_IS_STOP_BT_SIMPLE_REPEAT(node)) { int v; QuantNode* qn; - qn = QUANT_(NODE_ENCLOSURE_BODY(node)); + qn = QUANT_(NODE_BAG_BODY(node)); tlen = compile_length_tree(NODE_QUANT_BODY(qn), reg); if (tlen < 0) return tlen; @@ -1099,9 +1099,9 @@ compile_length_enclosure_node(EnclosureNode* node, regex_t* reg) } break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: { - Node* cond = NODE_ENCLOSURE_BODY(node); + Node* cond = NODE_BAG_BODY(node); Node* Then = node->te.Then; Node* Else = node->te.Else; @@ -1125,7 +1125,7 @@ compile_length_enclosure_node(EnclosureNode* node, regex_t* reg) } break; - case ENCLOSURE_OPTION: + case BAG_OPTION: len = tlen; break; } @@ -1136,7 +1136,7 @@ compile_length_enclosure_node(EnclosureNode* node, regex_t* reg) static int get_char_len_node(Node* node, regex_t* reg, int* len); static int -compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env) +compile_bag_memory_node(BagNode* node, regex_t* reg, ScanEnv* env) { int r; int len; @@ -1149,12 +1149,12 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env) NODE_STATUS_ADD(node, ADDR_FIXED); r = add_abs_addr(reg, (int )node->m.called_addr); if (r != 0) return r; - len = compile_length_tree(NODE_ENCLOSURE_BODY(node), reg); + len = compile_length_tree(NODE_BAG_BODY(node), reg); len += SIZE_OP_RETURN; r = add_opcode_rel_addr(reg, OP_JUMP, len); if (r != 0) return r; - r = compile_tree(NODE_ENCLOSURE_BODY(node), reg, env); + r = compile_tree(NODE_BAG_BODY(node), reg, env); if (r != 0) return r; r = add_opcode(reg, OP_RETURN); return r; @@ -1167,7 +1167,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env) NODE_STATUS_ADD(node, ADDR_FIXED); r = add_abs_addr(reg, (int )node->m.called_addr); if (r != 0) return r; - len = compile_length_tree(NODE_ENCLOSURE_BODY(node), reg); + len = compile_length_tree(NODE_BAG_BODY(node), reg); len += (SIZE_OP_MEMORY_START_PUSH + SIZE_OP_RETURN); if (MEM_STATUS_AT0(reg->bt_mem_end, node->m.regnum)) len += (NODE_IS_RECURSION(node) @@ -1188,7 +1188,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env) if (r != 0) return r; r = add_mem_num(reg, node->m.regnum); if (r != 0) return r; - r = compile_tree(NODE_ENCLOSURE_BODY(node), reg, env); + r = compile_tree(NODE_BAG_BODY(node), reg, env); if (r != 0) return r; #ifdef USE_CALL @@ -1217,22 +1217,22 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env) } static int -compile_enclosure_node(EnclosureNode* node, regex_t* reg, ScanEnv* env) +compile_bag_node(BagNode* node, regex_t* reg, ScanEnv* env) { int r, len; switch (node->type) { - case ENCLOSURE_MEMORY: - r = compile_enclosure_memory_node(node, reg, env); + case BAG_MEMORY: + r = compile_bag_memory_node(node, reg, env); break; - case ENCLOSURE_OPTION: + case BAG_OPTION: r = compile_option_node(node, reg, env); break; - case ENCLOSURE_STOP_BACKTRACK: + case BAG_STOP_BACKTRACK: if (NODE_IS_STOP_BT_SIMPLE_REPEAT(node)) { - QuantNode* qn = QUANT_(NODE_ENCLOSURE_BODY(node)); + QuantNode* qn = QUANT_(NODE_BAG_BODY(node)); r = compile_tree_n_times(NODE_QUANT_BODY(qn), qn->lower, reg, env); if (r != 0) return r; @@ -1251,16 +1251,16 @@ compile_enclosure_node(EnclosureNode* node, regex_t* reg, ScanEnv* env) else { r = add_opcode(reg, OP_ATOMIC_START); if (r != 0) return r; - r = compile_tree(NODE_ENCLOSURE_BODY(node), reg, env); + r = compile_tree(NODE_BAG_BODY(node), reg, env); if (r != 0) return r; r = add_opcode(reg, OP_ATOMIC_END); } break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: { int cond_len, then_len, jump_len; - Node* cond = NODE_ENCLOSURE_BODY(node); + Node* cond = NODE_BAG_BODY(node); Node* Then = node->te.Then; Node* Else = node->te.Else; @@ -1647,8 +1647,8 @@ compile_length_tree(Node* node, regex_t* reg) r = compile_length_quantifier_node(QUANT_(node), reg); break; - case NODE_ENCLOSURE: - r = compile_length_enclosure_node(ENCLOSURE_(node), reg); + case NODE_BAG: + r = compile_length_bag_node(BAG_(node), reg); break; case NODE_ANCHOR: @@ -1838,8 +1838,8 @@ compile_tree(Node* node, regex_t* reg, ScanEnv* env) r = compile_quantifier_node(QUANT_(node), reg, env); break; - case NODE_ENCLOSURE: - r = compile_enclosure_node(ENCLOSURE_(node), reg, env); + case NODE_BAG: + r = compile_bag_node(BAG_(node), reg, env); break; case NODE_ANCHOR: @@ -1885,10 +1885,10 @@ noname_disable_map(Node** plink, GroupNumRemap* map, int* counter) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); - if (en->type == ENCLOSURE_MEMORY) { + BagNode* en = BAG_(node); + if (en->type == BAG_MEMORY) { if (NODE_IS_NAMED_GROUP(node)) { (*counter)++; map[en->m.regnum].new_val = *counter; @@ -1902,8 +1902,8 @@ noname_disable_map(Node** plink, GroupNumRemap* map, int* counter) r = noname_disable_map(plink, map, counter); } } - else if (en->type == ENCLOSURE_IF_ELSE) { - r = noname_disable_map(&(NODE_ENCLOSURE_BODY(en)), map, counter); + else if (en->type == BAG_IF_ELSE) { + r = noname_disable_map(&(NODE_BAG_BODY(en)), map, counter); if (r != 0) return r; if (IS_NOT_NULL(en->te.Then)) { r = noname_disable_map(&(en->te.Then), map, counter); @@ -1976,14 +1976,14 @@ renumber_by_map(Node* node, GroupNumRemap* map) r = renumber_by_map(NODE_BODY(node), map); break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); r = renumber_by_map(NODE_BODY(node), map); if (r != 0) return r; - if (en->type == ENCLOSURE_IF_ELSE) { + if (en->type == BAG_IF_ELSE) { if (IS_NOT_NULL(en->te.Then)) { r = renumber_by_map(en->te.Then, map); if (r != 0) return r; @@ -2033,14 +2033,14 @@ numbered_ref_check(Node* node) r = numbered_ref_check(NODE_BODY(node)); break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); r = numbered_ref_check(NODE_BODY(node)); if (r != 0) return r; - if (en->type == ENCLOSURE_IF_ELSE) { + if (en->type == BAG_IF_ELSE) { if (IS_NOT_NULL(en->te.Then)) { r = numbered_ref_check(en->te.Then); if (r != 0) return r; @@ -2111,14 +2111,14 @@ static int fix_unset_addr_list(UnsetAddrList* uslist, regex_t* reg) { int i, offset; - EnclosureNode* en; + BagNode* en; AbsAddrType addr; for (i = 0; i < uslist->num; i++) { if (! NODE_IS_ADDR_FIXED(uslist->us[i].target)) return ONIGERR_PARSER_BUG; - en = ENCLOSURE_(uslist->us[i].target); + en = BAG_(uslist->us[i].target); addr = en->m.called_addr; offset = uslist->us[i].offset; @@ -2221,12 +2221,12 @@ get_char_len_node1(Node* node, regex_t* reg, int* len, int level) *len = 1; break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); switch (en->type) { - case ENCLOSURE_MEMORY: + case BAG_MEMORY: #ifdef USE_CALL if (NODE_IS_CLEN_FIXED(node)) *len = en->char_len; @@ -2239,11 +2239,11 @@ get_char_len_node1(Node* node, regex_t* reg, int* len, int level) } break; #endif - case ENCLOSURE_OPTION: - case ENCLOSURE_STOP_BACKTRACK: + case BAG_OPTION: + case BAG_STOP_BACKTRACK: r = get_char_len_node1(NODE_BODY(node), reg, len, level); break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: { int clen, elen; @@ -2548,23 +2548,23 @@ get_head_value_node(Node* node, int exact, regex_t* reg) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); switch (en->type) { - case ENCLOSURE_OPTION: + case BAG_OPTION: { OnigOptionType options = reg->options; - reg->options = ENCLOSURE_(node)->o.options; + reg->options = BAG_(node)->o.options; n = get_head_value_node(NODE_BODY(node), exact, reg); reg->options = options; } break; - case ENCLOSURE_MEMORY: - case ENCLOSURE_STOP_BACKTRACK: - case ENCLOSURE_IF_ELSE: + case BAG_MEMORY: + case BAG_STOP_BACKTRACK: + case BAG_IF_ELSE: n = get_head_value_node(NODE_BODY(node), exact, reg); break; } @@ -2585,7 +2585,7 @@ get_head_value_node(Node* node, int exact, regex_t* reg) } static int -check_type_tree(Node* node, int type_mask, int enclosure_mask, int anchor_mask) +check_type_tree(Node* node, int type_mask, int bag_mask, int anchor_mask) { NodeType type; int r = 0; @@ -2598,29 +2598,29 @@ check_type_tree(Node* node, int type_mask, int enclosure_mask, int anchor_mask) case NODE_LIST: case NODE_ALT: do { - r = check_type_tree(NODE_CAR(node), type_mask, enclosure_mask, + r = check_type_tree(NODE_CAR(node), type_mask, bag_mask, anchor_mask); } while (r == 0 && IS_NOT_NULL(node = NODE_CDR(node))); break; case NODE_QUANT: - r = check_type_tree(NODE_BODY(node), type_mask, enclosure_mask, anchor_mask); + r = check_type_tree(NODE_BODY(node), type_mask, bag_mask, anchor_mask); break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); - if (((1<type) & enclosure_mask) == 0) + BagNode* en = BAG_(node); + if (((1<type) & bag_mask) == 0) return 1; - r = check_type_tree(NODE_BODY(node), type_mask, enclosure_mask, anchor_mask); - if (r == 0 && en->type == ENCLOSURE_IF_ELSE) { + r = check_type_tree(NODE_BODY(node), type_mask, bag_mask, anchor_mask); + if (r == 0 && en->type == BAG_IF_ELSE) { if (IS_NOT_NULL(en->te.Then)) { - r = check_type_tree(en->te.Then, type_mask, enclosure_mask, anchor_mask); + r = check_type_tree(en->te.Then, type_mask, bag_mask, anchor_mask); if (r != 0) break; } if (IS_NOT_NULL(en->te.Else)) { - r = check_type_tree(en->te.Else, type_mask, enclosure_mask, anchor_mask); + r = check_type_tree(en->te.Else, type_mask, bag_mask, anchor_mask); } } } @@ -2632,7 +2632,7 @@ check_type_tree(Node* node, int type_mask, int enclosure_mask, int anchor_mask) return 1; if (IS_NOT_NULL(NODE_BODY(node))) - r = check_type_tree(NODE_BODY(node), type_mask, enclosure_mask, anchor_mask); + r = check_type_tree(NODE_BODY(node), type_mask, bag_mask, anchor_mask); break; case NODE_GIMMICK: @@ -2673,7 +2673,7 @@ tree_min_len(Node* node, ScanEnv* env) Node* t = NODE_BODY(node); if (NODE_IS_RECURSION(node)) { if (NODE_IS_MIN_FIXED(t)) - len = ENCLOSURE_(t)->min_len; + len = BAG_(t)->min_len; } else len = tree_min_len(t, env); @@ -2724,11 +2724,11 @@ tree_min_len(Node* node, ScanEnv* env) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); switch (en->type) { - case ENCLOSURE_MEMORY: + case BAG_MEMORY: if (NODE_IS_MIN_FIXED(node)) len = en->min_len; else { @@ -2745,11 +2745,11 @@ tree_min_len(Node* node, ScanEnv* env) } break; - case ENCLOSURE_OPTION: - case ENCLOSURE_STOP_BACKTRACK: + case BAG_OPTION: + case BAG_STOP_BACKTRACK: len = tree_min_len(NODE_BODY(node), env); break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: { OnigLen elen; @@ -2861,11 +2861,11 @@ tree_max_len(Node* node, ScanEnv* env) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); switch (en->type) { - case ENCLOSURE_MEMORY: + case BAG_MEMORY: if (NODE_IS_MAX_FIXED(node)) len = en->max_len; else { @@ -2882,11 +2882,11 @@ tree_max_len(Node* node, ScanEnv* env) } break; - case ENCLOSURE_OPTION: - case ENCLOSURE_STOP_BACKTRACK: + case BAG_OPTION: + case BAG_STOP_BACKTRACK: len = tree_max_len(NODE_BODY(node), env); break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: { OnigLen tlen, elen; @@ -2938,12 +2938,12 @@ check_backrefs(Node* node, ScanEnv* env) r = check_backrefs(NODE_BODY(node), env); break; - case NODE_ENCLOSURE: + case NODE_BAG: r = check_backrefs(NODE_BODY(node), env); { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); - if (en->type == ENCLOSURE_IF_ELSE) { + if (en->type == BAG_IF_ELSE) { if (r != 0) return r; if (IS_NOT_NULL(en->te.Then)) { r = check_backrefs(en->te.Then, env); @@ -3046,11 +3046,11 @@ infinite_recursive_call_check(Node* node, ScanEnv* env, int head) r = infinite_recursive_call_check(NODE_BODY(node), env, head); break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); - if (en->type == ENCLOSURE_MEMORY) { + if (en->type == BAG_MEMORY) { if (NODE_IS_MARK2(node)) return 0; else if (NODE_IS_MARK1(node)) @@ -3062,7 +3062,7 @@ infinite_recursive_call_check(Node* node, ScanEnv* env, int head) NODE_STATUS_REMOVE(node, MARK2); } } - else if (en->type == ENCLOSURE_IF_ELSE) { + else if (en->type == BAG_IF_ELSE) { int eret; ret = infinite_recursive_call_check(NODE_BODY(node), env, head); @@ -3123,11 +3123,11 @@ infinite_recursive_call_check_trav(Node* node, ScanEnv* env) r = infinite_recursive_call_check_trav(NODE_BODY(node), env); break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); - if (en->type == ENCLOSURE_MEMORY) { + if (en->type == BAG_MEMORY) { if (NODE_IS_RECURSION(node) && NODE_IS_CALLED(node)) { int ret; @@ -3141,7 +3141,7 @@ infinite_recursive_call_check_trav(Node* node, ScanEnv* env) NODE_STATUS_REMOVE(node, MARK1); } } - else if (en->type == ENCLOSURE_IF_ELSE) { + else if (en->type == BAG_IF_ELSE) { if (IS_NOT_NULL(en->te.Then)) { r = infinite_recursive_call_check_trav(en->te.Then, env); if (r != 0) return r; @@ -3196,11 +3196,11 @@ recursive_call_check(Node* node) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); - if (en->type == ENCLOSURE_MEMORY) { + if (en->type == BAG_MEMORY) { if (NODE_IS_MARK2(node)) return 0; else if (NODE_IS_MARK1(node)) @@ -3211,7 +3211,7 @@ recursive_call_check(Node* node) NODE_STATUS_REMOVE(node, MARK2); } } - else if (en->type == ENCLOSURE_IF_ELSE) { + else if (en->type == BAG_IF_ELSE) { r = 0; if (IS_NOT_NULL(en->te.Then)) { r |= recursive_call_check(en->te.Then); @@ -3272,13 +3272,13 @@ recursive_call_check_trav(Node* node, ScanEnv* env, int state) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { int ret; int state1; - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); - if (en->type == ENCLOSURE_MEMORY) { + if (en->type == BAG_MEMORY) { if (NODE_IS_CALLED(node) || (state & IN_RECURSION) != 0) { if (! NODE_IS_RECURSION(node)) { NODE_STATUS_ADD(node, MARK1); @@ -3301,7 +3301,7 @@ recursive_call_check_trav(Node* node, ScanEnv* env, int state) if (ret == FOUND_CALLED_NODE) r = FOUND_CALLED_NODE; - if (en->type == ENCLOSURE_IF_ELSE) { + if (en->type == BAG_IF_ELSE) { if (IS_NOT_NULL(en->te.Then)) { ret = recursive_call_check_trav(en->te.Then, env, state1); if (ret == FOUND_CALLED_NODE) @@ -3414,7 +3414,7 @@ next_setup(Node* node, Node* next_node, regex_t* reg) if (IS_NOT_NULL(x)) { y = get_head_value_node(next_node, 0, reg); if (IS_NOT_NULL(y) && is_exclusive(x, y, reg)) { - Node* en = onig_node_new_enclosure(ENCLOSURE_STOP_BACKTRACK); + Node* en = onig_node_new_bag(BAG_STOP_BACKTRACK); CHECK_NULL_RETURN_MEMERR(en); NODE_STATUS_ADD(en, STOP_BT_SIMPLE_REPEAT); swap_node(node, en); @@ -3425,9 +3425,9 @@ next_setup(Node* node, Node* next_node, regex_t* reg) } } } - else if (type == NODE_ENCLOSURE) { - EnclosureNode* en = ENCLOSURE_(node); - if (en->type == ENCLOSURE_MEMORY) { + else if (type == NODE_BAG) { + BagNode* en = BAG_(node); + if (en->type == BAG_MEMORY) { node = NODE_BODY(node); goto retry; } @@ -3855,22 +3855,22 @@ quantifiers_memory_node_info(Node* node) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); switch (en->type) { - case ENCLOSURE_MEMORY: + case BAG_MEMORY: if (NODE_IS_RECURSION(node)) { return QUANT_BODY_IS_EMPTY_REC; } return QUANT_BODY_IS_EMPTY_MEM; break; - case ENCLOSURE_OPTION: - case ENCLOSURE_STOP_BACKTRACK: + case BAG_OPTION: + case BAG_STOP_BACKTRACK: r = quantifiers_memory_node_info(NODE_BODY(node)); break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: { int v; r = quantifiers_memory_node_info(NODE_BODY(node)); @@ -3979,18 +3979,18 @@ setup_call2_call(Node* node) setup_call2_call(NODE_BODY(node)); break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); - if (en->type == ENCLOSURE_MEMORY) { + if (en->type == BAG_MEMORY) { if (! NODE_IS_MARK1(node)) { NODE_STATUS_ADD(node, MARK1); setup_call2_call(NODE_BODY(node)); NODE_STATUS_REMOVE(node, MARK1); } } - else if (en->type == ENCLOSURE_IF_ELSE) { + else if (en->type == BAG_IF_ELSE) { setup_call2_call(NODE_BODY(node)); if (IS_NOT_NULL(en->te.Then)) setup_call2_call(en->te.Then); @@ -4013,7 +4013,7 @@ setup_call2_call(Node* node) cn->entry_count++; NODE_STATUS_ADD(called, CALLED); - ENCLOSURE_(called)->m.entry_count++; + BAG_(called)->m.entry_count++; setup_call2_call(called); } NODE_STATUS_REMOVE(node, MARK1); @@ -4052,18 +4052,18 @@ setup_call(Node* node, ScanEnv* env, int state) r = 0; break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); - if (en->type == ENCLOSURE_MEMORY) { + if (en->type == BAG_MEMORY) { if ((state & IN_ZERO_REPEAT) != 0) { NODE_STATUS_ADD(node, IN_ZERO_REPEAT); - ENCLOSURE_(node)->m.entry_count--; + BAG_(node)->m.entry_count--; } r = setup_call(NODE_BODY(node), env, state); } - else if (en->type == ENCLOSURE_IF_ELSE) { + else if (en->type == BAG_IF_ELSE) { r = setup_call(NODE_BODY(node), env, state); if (r != 0) return r; if (IS_NOT_NULL(en->te.Then)) { @@ -4118,15 +4118,15 @@ setup_call2(Node* node) r = setup_call2(NODE_BODY(node)); break; - case NODE_ENCLOSURE: + case NODE_BAG: if (! NODE_IS_IN_ZERO_REPEAT(node)) r = setup_call2(NODE_BODY(node)); { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); if (r != 0) return r; - if (en->type == ENCLOSURE_IF_ELSE) { + if (en->type == BAG_IF_ELSE) { if (IS_NOT_NULL(en->te.Then)) { r = setup_call2(en->te.Then); if (r != 0) return r; @@ -4196,11 +4196,11 @@ setup_called_state_call(Node* node, int state) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); - if (en->type == ENCLOSURE_MEMORY) { + if (en->type == BAG_MEMORY) { if (NODE_IS_MARK1(node)) { if ((~en->m.called_state & state) != 0) { en->m.called_state |= state; @@ -4214,7 +4214,7 @@ setup_called_state_call(Node* node, int state) NODE_STATUS_REMOVE(node, MARK1); } } - else if (en->type == ENCLOSURE_IF_ELSE) { + else if (en->type == BAG_IF_ELSE) { if (IS_NOT_NULL(en->te.Then)) { setup_called_state_call(en->te.Then, state); } @@ -4255,22 +4255,22 @@ setup_called_state(Node* node, int state) break; #endif - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); switch (en->type) { - case ENCLOSURE_MEMORY: + case BAG_MEMORY: if (en->m.entry_count > 1) state |= IN_MULTI_ENTRY; en->m.called_state |= state; /* fall */ - case ENCLOSURE_OPTION: - case ENCLOSURE_STOP_BACKTRACK: + case BAG_OPTION: + case BAG_STOP_BACKTRACK: setup_called_state(NODE_BODY(node), state); break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: setup_called_state(NODE_BODY(node), state); if (IS_NOT_NULL(en->te.Then)) setup_called_state(en->te.Then, state); @@ -4337,11 +4337,11 @@ setup_anchor(Node* node, regex_t* reg, int state, ScanEnv* env) /* 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_ENCLOSURE | NODE_BIT_QUANT \ + | NODE_BIT_CTYPE | NODE_BIT_ANCHOR | NODE_BIT_BAG | NODE_BIT_QUANT \ | NODE_BIT_CALL | NODE_BIT_GIMMICK) -#define ALLOWED_ENCLOSURE_IN_LB ( 1< 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN; r = setup_tree(NODE_ANCHOR_BODY(an), reg, (state|IN_LOOK_BEHIND), env); @@ -4383,7 +4383,7 @@ setup_anchor(Node* node, regex_t* reg, int state, ScanEnv* env) case ANCHOR_LOOK_BEHIND_NOT: { r = check_type_tree(NODE_ANCHOR_BODY(an), ALLOWED_TYPE_IN_LB, - ALLOWED_ENCLOSURE_IN_LB_NOT, ALLOWED_ANCHOR_IN_LB_NOT); + ALLOWED_BAG_IN_LB_NOT, ALLOWED_ANCHOR_IN_LB_NOT); if (r < 0) return r; if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN; r = setup_tree(NODE_ANCHOR_BODY(an), reg, (state|IN_NOT|IN_LOOK_BEHIND), @@ -4425,9 +4425,9 @@ setup_quant(Node* node, regex_t* reg, int state, ScanEnv* env) #ifdef USE_INSISTENT_CHECK_CAPTURES_IN_EMPTY_REPEAT qn->body_empty_info = quantifiers_memory_node_info(body); if (qn->body_empty_info == QUANT_BODY_IS_EMPTY_REC) { - if (NODE_TYPE(body) == NODE_ENCLOSURE && - ENCLOSURE_(body)->type == ENCLOSURE_MEMORY) { - MEM_STATUS_ON(env->bt_mem_end, ENCLOSURE_(body)->m.regnum); + if (NODE_TYPE(body) == NODE_BAG && + BAG_(body)->type == BAG_MEMORY) { + MEM_STATUS_ON(env->bt_mem_end, BAG_(body)->m.regnum); } } #else @@ -4541,21 +4541,21 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); switch (en->type) { - case ENCLOSURE_OPTION: + case BAG_OPTION: { OnigOptionType options = reg->options; - reg->options = ENCLOSURE_(node)->o.options; + reg->options = BAG_(node)->o.options; r = setup_tree(NODE_BODY(node), reg, state, env); reg->options = options; } break; - case ENCLOSURE_MEMORY: + case BAG_MEMORY: #ifdef USE_CALL state |= en->m.called_state; #endif @@ -4567,7 +4567,7 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env) r = setup_tree(NODE_BODY(node), reg, state, env); break; - case ENCLOSURE_STOP_BACKTRACK: + case BAG_STOP_BACKTRACK: { Node* target = NODE_BODY(node); r = setup_tree(target, reg, state, env); @@ -4582,7 +4582,7 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env) } break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: r = setup_tree(NODE_BODY(node), reg, (state | IN_ALT), env); if (r != 0) return r; if (IS_NOT_NULL(en->te.Then)) { @@ -5538,7 +5538,7 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env) set_mml(&opt->len, 0, INFINITE_LEN); else { OnigOptionType save = env->options; - env->options = ENCLOSURE_(NODE_BODY(node))->o.options; + env->options = BAG_(NODE_BODY(node))->o.options; r = optimize_nodes(NODE_BODY(node), opt, env); env->options = save; } @@ -5593,12 +5593,12 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env) } break; - case NODE_ENCLOSURE: + case NODE_BAG: { - EnclosureNode* en = ENCLOSURE_(node); + BagNode* en = BAG_(node); switch (en->type) { - case ENCLOSURE_OPTION: + case BAG_OPTION: { OnigOptionType save = env->options; @@ -5608,7 +5608,7 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env) } break; - case ENCLOSURE_MEMORY: + case BAG_MEMORY: #ifdef USE_CALL en->opt_count++; if (en->opt_count > MAX_NODE_OPT_INFO_REF_COUNT) { @@ -5631,16 +5631,16 @@ optimize_nodes(Node* node, OptNode* opt, OptEnv* env) } break; - case ENCLOSURE_STOP_BACKTRACK: + case BAG_STOP_BACKTRACK: r = optimize_nodes(NODE_BODY(node), opt, env); break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: { OptEnv nenv; copy_opt_env(&nenv, env); - r = optimize_nodes(NODE_ENCLOSURE_BODY(en), &xo, &nenv); + r = optimize_nodes(NODE_BAG_BODY(en), &xo, &nenv); if (r == 0) { add_mml(&nenv.mmd, &xo.len); concat_left_node_opt_info(enc, opt, &xo); @@ -6689,19 +6689,19 @@ print_indent_tree(FILE* f, Node* node, int indent) print_indent_tree(f, NODE_BODY(node), indent + add); break; - case NODE_ENCLOSURE: - fprintf(f, " ", node); - switch (ENCLOSURE_(node)->type) { - case ENCLOSURE_OPTION: - fprintf(f, "option:%d", ENCLOSURE_(node)->o.options); + case NODE_BAG: + fprintf(f, " ", node); + switch (BAG_(node)->type) { + case BAG_OPTION: + fprintf(f, "option:%d", BAG_(node)->o.options); break; - case ENCLOSURE_MEMORY: - fprintf(f, "memory:%d", ENCLOSURE_(node)->m.regnum); + case BAG_MEMORY: + fprintf(f, "memory:%d", BAG_(node)->m.regnum); break; - case ENCLOSURE_STOP_BACKTRACK: + case BAG_STOP_BACKTRACK: fprintf(f, "stop-bt"); break; - case ENCLOSURE_IF_ELSE: + case BAG_IF_ELSE: fprintf(f, "if-else"); break; } @@ -6744,7 +6744,7 @@ print_indent_tree(FILE* f, Node* node, int indent) } if (type != NODE_LIST && type != NODE_ALT && type != NODE_QUANT && - type != NODE_ENCLOSURE) + type != NODE_BAG) fprintf(f, "\n"); fflush(f); } diff --git a/src/regparse.c b/src/regparse.c index 09cb83a..21a8b7c 100644 --- a/src/regparse.c +++ b/src/regparse.c @@ -2037,13 +2037,13 @@ onig_node_free(Node* node) xfree(BACKREF_(node)->back_dynamic); break; - case NODE_ENCLOSURE: + case NODE_BAG: if (NODE_BODY(node)) onig_node_free(NODE_BODY(node)); { - EnclosureNode* en = ENCLOSURE_(node); - if (en->type == ENCLOSURE_IF_ELSE) { + BagNode* en = BAG_(node); + if (en->type == BAG_IF_ELSE) { onig_node_free(en->te.Then); onig_node_free(en->te.Else); } @@ -2381,62 +2381,62 @@ node_new_quantifier(int lower, int upper, int by_number) } static Node* -node_new_enclosure(enum EnclosureType type) +node_new_bag(enum BagType type) { Node* node = node_new(); CHECK_NULL_RETURN(node); - NODE_SET_TYPE(node, NODE_ENCLOSURE); - ENCLOSURE_(node)->type = type; + NODE_SET_TYPE(node, NODE_BAG); + BAG_(node)->type = type; switch (type) { - case ENCLOSURE_MEMORY: - ENCLOSURE_(node)->m.regnum = 0; - ENCLOSURE_(node)->m.called_addr = -1; - ENCLOSURE_(node)->m.entry_count = 1; - ENCLOSURE_(node)->m.called_state = 0; + case BAG_MEMORY: + BAG_(node)->m.regnum = 0; + BAG_(node)->m.called_addr = -1; + BAG_(node)->m.entry_count = 1; + BAG_(node)->m.called_state = 0; break; - case ENCLOSURE_OPTION: - ENCLOSURE_(node)->o.options = 0; + case BAG_OPTION: + BAG_(node)->o.options = 0; break; - case ENCLOSURE_STOP_BACKTRACK: + case BAG_STOP_BACKTRACK: break; - case ENCLOSURE_IF_ELSE: - ENCLOSURE_(node)->te.Then = 0; - ENCLOSURE_(node)->te.Else = 0; + case BAG_IF_ELSE: + BAG_(node)->te.Then = 0; + BAG_(node)->te.Else = 0; break; } - ENCLOSURE_(node)->opt_count = 0; + BAG_(node)->opt_count = 0; return node; } extern Node* -onig_node_new_enclosure(enum EnclosureType type) +onig_node_new_bag(enum BagType type) { - return node_new_enclosure(type); + return node_new_bag(type); } static Node* -node_new_enclosure_if_else(Node* cond, Node* Then, Node* Else) +node_new_bag_if_else(Node* cond, Node* Then, Node* Else) { Node* n; - n = node_new_enclosure(ENCLOSURE_IF_ELSE); + n = node_new_bag(BAG_IF_ELSE); CHECK_NULL_RETURN(n); NODE_BODY(n) = cond; - ENCLOSURE_(n)->te.Then = Then; - ENCLOSURE_(n)->te.Else = Else; + BAG_(n)->te.Then = Then; + BAG_(n)->te.Else = Else; return n; } static Node* node_new_memory(int is_named) { - Node* node = node_new_enclosure(ENCLOSURE_MEMORY); + Node* node = node_new_bag(BAG_MEMORY); CHECK_NULL_RETURN(node); if (is_named != 0) NODE_STATUS_ADD(node, NAMED_GROUP); @@ -2447,20 +2447,20 @@ node_new_memory(int is_named) static Node* node_new_option(OnigOptionType option) { - Node* node = node_new_enclosure(ENCLOSURE_OPTION); + Node* node = node_new_bag(BAG_OPTION); CHECK_NULL_RETURN(node); - ENCLOSURE_(node)->o.options = option; - ENCLOSURE_(node)->o.is_no_effect = 0; + BAG_(node)->o.options = option; + BAG_(node)->o.is_no_effect = 0; return node; } static Node* node_new_no_effect(OnigOptionType option) { - Node* node = node_new_enclosure(ENCLOSURE_OPTION); + Node* node = node_new_bag(BAG_OPTION); CHECK_NULL_RETURN(node); - ENCLOSURE_(node)->o.options = option; - ENCLOSURE_(node)->o.is_no_effect = 1; + BAG_(node)->o.options = option; + BAG_(node)->o.is_no_effect = 1; return node; } @@ -2672,7 +2672,7 @@ make_extended_grapheme_cluster(Node** node, ScanEnv* env) ns[0] = x; ns[1] = NULL_NODE; - x = node_new_enclosure(ENCLOSURE_STOP_BACKTRACK); + x = node_new_bag(BAG_STOP_BACKTRACK); if (IS_NULL(x)) goto err; NODE_BODY(x) = ns[0]; @@ -2732,7 +2732,7 @@ make_absent_engine(Node** node, int pre_save_right_id, Node* absent, ns[0] = x; if (possessive != 0) { - x = node_new_enclosure(ENCLOSURE_STOP_BACKTRACK); + x = node_new_bag(BAG_STOP_BACKTRACK); if (IS_NULL(x)) goto err0; NODE_BODY(x) = ns[0]; @@ -2884,11 +2884,11 @@ is_simple_one_char_repeat(Node* node, Node** rquant, Node** rbody, quant = node; } else { - if (NODE_TYPE(node) == NODE_ENCLOSURE) { - EnclosureNode* en = ENCLOSURE_(node); - if (en->type == ENCLOSURE_STOP_BACKTRACK) { + if (NODE_TYPE(node) == NODE_BAG) { + BagNode* en = BAG_(node); + if (en->type == BAG_STOP_BACKTRACK) { *is_possessive = 1; - quant = NODE_ENCLOSURE_BODY(en); + quant = NODE_BAG_BODY(en); if (NODE_TYPE(quant) != NODE_QUANT) return 0; } @@ -3808,7 +3808,7 @@ is_invalid_quantifier_target(Node* node) return 1; break; - case NODE_ENCLOSURE: + case NODE_BAG: /* allow enclosed elements */ /* return is_invalid_quantifier_target(NODE_BODY(node)); */ break; @@ -3985,7 +3985,7 @@ node_new_general_newline(Node** node, ScanEnv* env) if (r != 0) goto err1; } - x = node_new_enclosure_if_else(crnl, 0, ncc); + x = node_new_bag_if_else(crnl, 0, ncc); if (IS_NULL(x)) goto err1; *node = x; @@ -6979,8 +6979,8 @@ parse_callout_of_name(Node** np, int cterm, UChar** src, UChar* end, ScanEnv* en #endif static int -parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, - ScanEnv* env) +parse_bag(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, + ScanEnv* env) { int r, num; Node *target; @@ -7020,7 +7020,7 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, *np = onig_node_new_anchor(ANCHOR_PREC_READ_NOT, 0); break; case '>': /* (?>...) stop backtrack */ - *np = node_new_enclosure(ENCLOSURE_STOP_BACKTRACK); + *np = node_new_bag(BAG_STOP_BACKTRACK); break; case '\'': @@ -7065,7 +7065,7 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, if (r != 0) return r; *np = node_new_memory(1); CHECK_NULL_RETURN_MEMERR(*np); - ENCLOSURE_(*np)->m.regnum = num; + BAG_(*np)->m.regnum = num; if (list_capture != 0) MEM_STATUS_ON_SIMPLE(env->capture_history, num); env->num_named++; @@ -7349,7 +7349,7 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, } } - *np = node_new_enclosure_if_else(condition, Then, Else); + *np = node_new_bag_if_else(condition, Then, Else); if (IS_NULL(*np)) { onig_node_free(condition); onig_node_free(Then); @@ -7384,7 +7384,7 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, else if (num >= (int )MEM_STATUS_BITS_NUM) { return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY; } - ENCLOSURE_(*np)->m.regnum = num; + BAG_(*np)->m.regnum = num; MEM_STATUS_ON_SIMPLE(env->capture_history, num); } else { @@ -7494,7 +7494,7 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, CHECK_NULL_RETURN_MEMERR(*np); num = scan_env_add_mem_entry(env); if (num < 0) return num; - ENCLOSURE_(*np)->m.regnum = num; + BAG_(*np)->m.regnum = num; } CHECK_NULL_RETURN_MEMERR(*np); @@ -7508,10 +7508,10 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, NODE_BODY(*np) = target; - if (NODE_TYPE(*np) == NODE_ENCLOSURE) { - if (ENCLOSURE_(*np)->type == ENCLOSURE_MEMORY) { + if (NODE_TYPE(*np) == NODE_BAG) { + if (BAG_(*np)->type == BAG_MEMORY) { /* Don't move this to previous of parse_subexp() */ - r = scan_env_set_mem_node(env, ENCLOSURE_(*np)->m.regnum, *np); + r = scan_env_set_mem_node(env, BAG_(*np)->m.regnum, *np); if (r != 0) return r; } } @@ -7752,7 +7752,7 @@ parse_exp(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, break; case TK_SUBEXP_OPEN: - r = parse_enclosure(np, tok, TK_SUBEXP_CLOSE, src, end, env); + r = parse_bag(np, tok, TK_SUBEXP_CLOSE, src, end, env); if (r < 0) return r; if (r == 1) { /* group */ if (group_head == 0) @@ -7773,7 +7773,7 @@ parse_exp(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, Node* target; OnigOptionType prev = env->options; - env->options = ENCLOSURE_(*np)->o.options; + env->options = BAG_(*np)->o.options; r = fetch_token(tok, src, end, env); if (r < 0) return r; r = parse_subexp(&target, tok, term, src, end, env, 0); @@ -8078,7 +8078,7 @@ parse_exp(Node** np, OnigToken* tok, int term, UChar** src, UChar* end, if (tok->u.repeat.possessive != 0) { Node* en; - en = node_new_enclosure(ENCLOSURE_STOP_BACKTRACK); + en = node_new_bag(BAG_STOP_BACKTRACK); if (IS_NULL(en)) { onig_node_free(qn); return ONIGERR_MEMORY; @@ -8250,7 +8250,7 @@ make_call_zero_body(Node* node, ScanEnv* env, Node** rnode) CHECK_NULL_RETURN_MEMERR(x); NODE_BODY(x) = node; - ENCLOSURE_(x)->m.regnum = 0; + BAG_(x)->m.regnum = 0; r = scan_env_set_mem_node(env, 0, x); if (r != 0) { onig_node_free(x); diff --git a/src/regparse.h b/src/regparse.h index 0558339..d321113 100644 --- a/src/regparse.h +++ b/src/regparse.h @@ -38,7 +38,7 @@ typedef enum { NODE_CTYPE = 2, NODE_BACKREF = 3, NODE_QUANT = 4, - NODE_ENCLOSURE = 5, + NODE_BAG = 5, NODE_ANCHOR = 6, NODE_LIST = 7, NODE_ALT = 8, @@ -65,7 +65,7 @@ enum GimmickType { #define NODE_BIT_CTYPE NODE_TYPE2BIT(NODE_CTYPE) #define NODE_BIT_BACKREF NODE_TYPE2BIT(NODE_BACKREF) #define NODE_BIT_QUANT NODE_TYPE2BIT(NODE_QUANT) -#define NODE_BIT_ENCLOSURE NODE_TYPE2BIT(NODE_ENCLOSURE) +#define NODE_BIT_BAG NODE_TYPE2BIT(NODE_BAG) #define NODE_BIT_ANCHOR NODE_TYPE2BIT(NODE_ANCHOR) #define NODE_BIT_LIST NODE_TYPE2BIT(NODE_LIST) #define NODE_BIT_ALT NODE_TYPE2BIT(NODE_ALT) @@ -84,7 +84,7 @@ enum GimmickType { #define CTYPE_(node) (&((node)->u.ctype)) #define BACKREF_(node) (&((node)->u.backref)) #define QUANT_(node) (&((node)->u.quant)) -#define ENCLOSURE_(node) (&((node)->u.enclosure)) +#define BAG_(node) (&((node)->u.bag)) #define ANCHOR_(node) (&((node)->u.anchor)) #define CONS_(node) (&((node)->u.cons)) #define CALL_(node) (&((node)->u.call)) @@ -104,11 +104,11 @@ enum GimmickType { #define ANCHOR_ANYCHAR_INF_MASK (ANCHOR_ANYCHAR_INF | ANCHOR_ANYCHAR_INF_ML) #define ANCHOR_END_BUF_MASK (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF) -enum EnclosureType { - ENCLOSURE_MEMORY = 0, - ENCLOSURE_OPTION = 1, - ENCLOSURE_STOP_BACKTRACK = 2, - ENCLOSURE_IF_ELSE = 3, +enum BagType { + BAG_MEMORY = 0, + BAG_OPTION = 1, + BAG_STOP_BACKTRACK = 2, + BAG_IF_ELSE = 3, }; #define NODE_STRING_MARGIN 16 @@ -199,8 +199,8 @@ enum QuantBodyEmpty { ((NODE_STATUS(node) & NODE_ST_STOP_BT_SIMPLE_REPEAT) != 0) #define NODE_BODY(node) ((node)->u.base.body) -#define NODE_QUANT_BODY(node) ((node)->body) -#define NODE_ENCLOSURE_BODY(node) ((node)->body) +#define NODE_QUANT_BODY(node) ((node)->body) +#define NODE_BAG_BODY(node) ((node)->body) #define NODE_CALL_BODY(node) ((node)->body) #define NODE_ANCHOR_BODY(node) ((node)->body) @@ -244,7 +244,7 @@ typedef struct { int status; struct _Node* body; - enum EnclosureType type; + enum BagType type; union { struct { int regnum; @@ -267,7 +267,7 @@ typedef struct { OnigLen max_len; /* max length (byte) */ int char_len; /* character length */ int opt_count; /* referenced count in optimize_nodes() */ -} EnclosureNode; +} BagNode; #ifdef USE_CALL @@ -285,7 +285,7 @@ typedef struct { typedef struct { NodeType node_type; int status; - struct _Node* body; /* to EnclosureNode : ENCLOSURE_MEMORY */ + struct _Node* body; /* to BagNode : BAG_MEMORY */ int by_number; int group_num; @@ -355,7 +355,7 @@ typedef struct _Node { StrNode str; CClassNode cclass; QuantNode quant; - EnclosureNode enclosure; + BagNode bag; BackRefNode backref; AnchorNode anchor; ConsAltNode cons; @@ -439,7 +439,7 @@ extern void onig_node_conv_to_str_node P_((Node* node, int raw)); extern int onig_node_str_cat P_((Node* node, const UChar* s, const UChar* end)); extern int onig_node_str_set P_((Node* node, const UChar* s, const UChar* end)); extern void onig_node_free P_((Node* node)); -extern Node* onig_node_new_enclosure P_((enum EnclosureType type)); +extern Node* onig_node_new_bag P_((enum BagType type)); extern Node* onig_node_new_anchor P_((int type, int ascii_mode)); extern Node* onig_node_new_str P_((const UChar* s, const UChar* end)); extern Node* onig_node_new_list P_((Node* left, Node* right));