omit NST_ from NODE_STATUS_ADD() and NODE_STATUS_REMOVE() argument

diff --git a/src/regcomp.c b/src/regcomp.c
index b83df97992506b716caac210939d0d38f23c4349..83b92525d90670c3568fc22617c6081da970426f 100644 (file)
--- a/src/regcomp.c
+++ b/src/regcomp.c
@@ -1130,7 +1130,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env)
     r = add_opcode(reg, OP_CALL);
     if (r != 0) return r;
     node->m.called_addr = BB_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP;
-    NODE_STATUS_ADD(node, NST_ADDR_FIXED);
+    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);
@@ -1148,7 +1148,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env)
     r = add_opcode(reg, OP_CALL);
     if (r != 0) return r;
     node->m.called_addr = BB_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP;
-    NODE_STATUS_ADD(node, NST_ADDR_FIXED);
+    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);
@@ -2222,7 +2222,7 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
           r = get_char_length_tree1(NODE_BODY(node), reg, len, level);
           if (r == 0) {
             en->char_len = *len;
-            NODE_STATUS_ADD(node, NST_CLEN_FIXED);
+            NODE_STATUS_ADD(node, CLEN_FIXED);
           }
         }
         break;
@@ -2728,12 +2728,12 @@ tree_min_len(Node* node, ScanEnv* env)
           if (NODE_IS_MARK1(node))
             len = 0;  /* recursive */
           else {
-            NODE_STATUS_ADD(node, NST_MARK1);
+            NODE_STATUS_ADD(node, MARK1);
             len = tree_min_len(NODE_BODY(node), env);
-            NODE_STATUS_REMOVE(node, NST_MARK1);
+            NODE_STATUS_REMOVE(node, MARK1);
 
             en->min_len = len;
-            NODE_STATUS_ADD(node, NST_MIN_FIXED);
+            NODE_STATUS_ADD(node, MIN_FIXED);
           }
         }
         break;
@@ -2865,12 +2865,12 @@ tree_max_len(Node* node, ScanEnv* env)
           if (NODE_IS_MARK1(node))
             len = INFINITE_LEN;
           else {
-            NODE_STATUS_ADD(node, NST_MARK1);
+            NODE_STATUS_ADD(node, MARK1);
             len = tree_max_len(NODE_BODY(node), env);
-            NODE_STATUS_REMOVE(node, NST_MARK1);
+            NODE_STATUS_REMOVE(node, MARK1);
 
             en->max_len = len;
-            NODE_STATUS_ADD(node, NST_MAX_FIXED);
+            NODE_STATUS_ADD(node, MAX_FIXED);
           }
         }
         break;
@@ -2960,7 +2960,7 @@ check_backrefs(Node* node, ScanEnv* env)
         if (backs[i] > env->num_mem)
           return ONIGERR_INVALID_BACKREF;
 
-        NODE_STATUS_ADD(mem_env[backs[i]].node, NST_BACKREF);
+        NODE_STATUS_ADD(mem_env[backs[i]].node, BACKREF);
       }
       r = 0;
     }
@@ -3050,9 +3050,9 @@ infinite_recursive_call_check(Node* node, ScanEnv* env, int head)
           return (head == 0 ? RECURSION_EXIST | RECURSION_MUST
                   : RECURSION_EXIST | RECURSION_MUST | RECURSION_INFINITE);
         else {
-          NODE_STATUS_ADD(node, NST_MARK2);
+          NODE_STATUS_ADD(node, MARK2);
           r = infinite_recursive_call_check(NODE_BODY(node), env, head);
-          NODE_STATUS_REMOVE(node, NST_MARK2);
+          NODE_STATUS_REMOVE(node, MARK2);
         }
       }
       else if (en->type == ENCLOSURE_IF_ELSE) {
@@ -3124,14 +3124,14 @@ infinite_recursive_call_check_trav(Node* node, ScanEnv* env)
         if (NODE_IS_RECURSION(node) && NODE_IS_CALLED(node)) {
           int ret;
 
-          NODE_STATUS_ADD(node, NST_MARK1);
+          NODE_STATUS_ADD(node, MARK1);
 
           ret = infinite_recursive_call_check(NODE_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, NST_MARK1);
+          NODE_STATUS_REMOVE(node, MARK1);
         }
       }
       else if (en->type == ENCLOSURE_IF_ELSE) {
@@ -3185,7 +3185,7 @@ recursive_call_check(Node* node)
     r = recursive_call_check(NODE_BODY(node));
     if (r != 0) {
       if (NODE_IS_MARK1(NODE_BODY(node)))
-        NODE_STATUS_ADD(node, NST_RECURSION);
+        NODE_STATUS_ADD(node, RECURSION);
     }
     break;
 
@@ -3199,9 +3199,9 @@ recursive_call_check(Node* node)
         else if (NODE_IS_MARK1(node))
           return 1; /* recursion */
         else {
-          NODE_STATUS_ADD(node, NST_MARK2);
+          NODE_STATUS_ADD(node, MARK2);
           r = recursive_call_check(NODE_BODY(node));
-          NODE_STATUS_REMOVE(node, NST_MARK2);
+          NODE_STATUS_REMOVE(node, MARK2);
         }
       }
       else if (en->type == ENCLOSURE_IF_ELSE) {
@@ -3274,11 +3274,11 @@ recursive_call_check_trav(Node* node, ScanEnv* env, int state)
       if (en->type == ENCLOSURE_MEMORY) {
         if (NODE_IS_CALLED(node) || (state & IN_RECURSION) != 0) {
           if (! NODE_IS_RECURSION(node)) {
-            NODE_STATUS_ADD(node, NST_MARK1);
+            NODE_STATUS_ADD(node, MARK1);
             r = recursive_call_check(NODE_BODY(node));
             if (r != 0)
-              NODE_STATUS_ADD(node, NST_RECURSION);
-            NODE_STATUS_REMOVE(node, NST_MARK1);
+              NODE_STATUS_ADD(node, RECURSION);
+            NODE_STATUS_REMOVE(node, MARK1);
           }
 
           if (NODE_IS_CALLED(node))
@@ -3400,7 +3400,7 @@ next_setup(Node* node, Node* next_node, regex_t* reg)
             if (IS_NOT_NULL(y) && is_exclusive(x, y, reg)) {
               Node* en = onig_node_new_enclosure(ENCLOSURE_STOP_BACKTRACK);
               CHECK_NULL_RETURN_MEMERR(en);
-              NODE_STATUS_ADD(en, NST_STOP_BT_SIMPLE_REPEAT);
+              NODE_STATUS_ADD(en, STOP_BT_SIMPLE_REPEAT);
               swap_node(node, en);
               NODE_BODY(node) = en;
             }
@@ -3907,9 +3907,9 @@ setup_call2_call(Node* node)
 
       if (en->type == ENCLOSURE_MEMORY) {
         if (! NODE_IS_MARK1(node)) {
-          NODE_STATUS_ADD(node, NST_MARK1);
+          NODE_STATUS_ADD(node, MARK1);
           setup_call2_call(NODE_BODY(node));
-          NODE_STATUS_REMOVE(node, NST_MARK1);
+          NODE_STATUS_REMOVE(node, MARK1);
         }
       }
       else if (en->type == ENCLOSURE_IF_ELSE) {
@@ -3927,18 +3927,18 @@ setup_call2_call(Node* node)
 
   case NODE_CALL:
     if (! NODE_IS_MARK1(node)) {
-      NODE_STATUS_ADD(node, NST_MARK1);
+      NODE_STATUS_ADD(node, MARK1);
       {
         CallNode* cn = CALL_(node);
         Node* called = NODE_CALL_BODY(cn);
 
         cn->entry_count++;
 
-        NODE_STATUS_ADD(called, NST_CALLED);
+        NODE_STATUS_ADD(called, CALLED);
         ENCLOSURE_(called)->m.entry_count++;
         setup_call2_call(called);
       }
-      NODE_STATUS_REMOVE(node, NST_MARK1);
+      NODE_STATUS_REMOVE(node, MARK1);
     }
     break;
 
@@ -3980,7 +3980,7 @@ setup_call(Node* node, ScanEnv* env, int state)
 
       if (en->type == ENCLOSURE_MEMORY) {
         if ((state & IN_ZERO_REPEAT) != 0) {
-          NODE_STATUS_ADD(node, NST_IN_ZERO_REPEAT);
+          NODE_STATUS_ADD(node, IN_ZERO_REPEAT);
           ENCLOSURE_(node)->m.entry_count--;
         }
         r = setup_call(NODE_BODY(node), env, state);
@@ -4002,7 +4002,7 @@ setup_call(Node* node, ScanEnv* env, int state)
 
   case NODE_CALL:
     if ((state & IN_ZERO_REPEAT) != 0) {
-      NODE_STATUS_ADD(node, NST_IN_ZERO_REPEAT);
+      NODE_STATUS_ADD(node, IN_ZERO_REPEAT);
       CALL_(node)->entry_count--;
     }
 
@@ -4130,10 +4130,10 @@ setup_called_state_call(Node* node, int state)
           }
         }
         else {
-          NODE_STATUS_ADD(node, NST_MARK1);
+          NODE_STATUS_ADD(node, MARK1);
           en->m.called_state |= state;
           setup_called_state_call(NODE_BODY(node), state);
-          NODE_STATUS_REMOVE(node, NST_MARK1);
+          NODE_STATUS_REMOVE(node, MARK1);
         }
       }
       else if (en->type == ENCLOSURE_IF_ELSE) {
@@ -4334,10 +4334,10 @@ setup_quant(Node* node, regex_t* reg, int state, ScanEnv* env)
   Node* body = NODE_BODY(node);
 
   if ((state & IN_REAL_REPEAT) != 0) {
-    NODE_STATUS_ADD(node, NST_IN_REAL_REPEAT);
+    NODE_STATUS_ADD(node, IN_REAL_REPEAT);
   }
   if ((state & IN_MULTI_ENTRY) != 0) {
-    NODE_STATUS_ADD(node, NST_IN_MULTI_ENTRY);
+    NODE_STATUS_ADD(node, IN_MULTI_ENTRY);
   }
 
   if (IS_REPEAT_INFINITE(qn->upper) || qn->upper >= 1) {
@@ -4497,7 +4497,7 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
             if (IS_REPEAT_INFINITE(tqn->upper) && tqn->lower <= 1 &&
                 tqn->greedy != 0) {  /* (?>a*), a*+ etc... */
               if (NODE_IS_SIMPLE_TYPE(NODE_BODY(target)))
-                NODE_STATUS_ADD(node, NST_STOP_BT_SIMPLE_REPEAT);
+                NODE_STATUS_ADD(node, STOP_BT_SIMPLE_REPEAT);
             }
           }
         }

diff --git a/src/regparse.c b/src/regparse.c
index 64923ad82f9d0655194530a265a7a789bc7495d2..d9acf78dea4a5d28def12c6e9d2eed1bd4682344 100644 (file)
--- a/src/regparse.c
+++ b/src/regparse.c
@@ -2154,7 +2154,7 @@ node_new_anychar_with_fixed_option(OnigOptionType option)
   node = node_new_anychar();
   ct = CTYPE_(node);
   ct->options = option;
-  NODE_STATUS_ADD(node, NST_FIXED_OPTION);
+  NODE_STATUS_ADD(node, FIXED_OPTION);
   return node;
 }
 
@@ -2303,11 +2303,11 @@ node_new_backref(int back_num, int* backrefs, int by_name,
   BACKREF_(node)->back_num = back_num;
   BACKREF_(node)->back_dynamic = (int* )NULL;
   if (by_name != 0)
-    NODE_STATUS_ADD(node, NST_BY_NAME);
+    NODE_STATUS_ADD(node, BY_NAME);
 
 #ifdef USE_BACKREF_WITH_LEVEL
   if (exist_level != 0) {
-    NODE_STATUS_ADD(node, NST_NEST_LEVEL);
+    NODE_STATUS_ADD(node, NEST_LEVEL);
     BACKREF_(node)->nest_level  = nest_level;
   }
 #endif
@@ -2315,7 +2315,7 @@ node_new_backref(int back_num, int* backrefs, int by_name,
   for (i = 0; i < back_num; i++) {
     if (backrefs[i] <= env->num_mem &&
         IS_NULL(SCANENV_MEMENV(env)[backrefs[i]].node)) {
-      NODE_STATUS_ADD(node, NST_RECURSION);   /* /...(\1).../ */
+      NODE_STATUS_ADD(node, RECURSION);   /* /...(\1).../ */
       break;
     }
   }
@@ -2353,7 +2353,7 @@ node_new_backref_checker(int back_num, int* backrefs, int by_name,
                           env);
   CHECK_NULL_RETURN(node);
 
-  NODE_STATUS_ADD(node, NST_CHECKER);
+  NODE_STATUS_ADD(node, CHECKER);
   return node;
 }
 
@@ -2389,7 +2389,7 @@ node_new_quantifier(int lower, int upper, int by_number)
   QUANT_(node)->next_head_exact = NULL_NODE;
   QUANT_(node)->is_refered      = 0;
   if (by_number != 0)
-    NODE_STATUS_ADD(node, NST_BY_NUMBER);
+    NODE_STATUS_ADD(node, BY_NUMBER);
 
   return node;
 }
@@ -2453,7 +2453,7 @@ node_new_memory(int is_named)
   Node* node = node_new_enclosure(ENCLOSURE_MEMORY);
   CHECK_NULL_RETURN(node);
   if (is_named != 0)
-    NODE_STATUS_ADD(node, NST_NAMED_GROUP);
+    NODE_STATUS_ADD(node, NAMED_GROUP);
 
   return node;
 }
@@ -2758,7 +2758,7 @@ make_absent_engine(Node** node, int pre_save_right_id, Node* absent,
   if (IS_NULL(x)) goto err0;
 
   if (is_range_cutter != 0)
-    NODE_STATUS_ADD(x, NST_SUPER);
+    NODE_STATUS_ADD(x, SUPER);
 
   *node = x;
   return ONIG_NORMAL;
@@ -2853,7 +2853,7 @@ make_range_clear(Node** node, ScanEnv* env)
   x = make_alt(2, ns);
   if (IS_NULL(x)) goto err0;
 
-  NODE_STATUS_ADD(x, NST_SUPER);
+  NODE_STATUS_ADD(x, SUPER);
 
   ns[0] = save;
   ns[1] = x;

diff --git a/src/regparse.h b/src/regparse.h
index 2144feca8c27dfda01fbfde03d3abf4defe27838..d96cfa6b7f9959f3e452449deb41f3157b1e0469 100644 (file)
--- a/src/regparse.h
+++ b/src/regparse.h
@@ -165,8 +165,8 @@ enum QuantBodyEmpty {
 
 
 #define NODE_STATUS(node)           (((Node* )node)->u.base.status)
-#define NODE_STATUS_ADD(node,f)     (NODE_STATUS(node) |= (f))
-#define NODE_STATUS_REMOVE(node,f)  (NODE_STATUS(node) &= ~(f))
+#define NODE_STATUS_ADD(node,f)     (NODE_STATUS(node) |= (NST_ ## f))
+#define NODE_STATUS_REMOVE(node,f)  (NODE_STATUS(node) &= ~(NST_ ## f))
 
 #define NODE_IS_BY_NUMBER(node)       ((NODE_STATUS(node) & NST_BY_NUMBER)      != 0)
 #define NODE_IS_IN_REAL_REPEAT(node)  ((NODE_STATUS(node) & NST_IN_REAL_REPEAT) != 0)