refactoring

diff --git a/src/oniguruma.h b/src/oniguruma.h
index dc797ef671c75422aa3c22ca6fb1e86eaf85eeb5..4fa719c18b44d0b47a7ec98e4dadbcb07ca2b743 100644 (file)
--- a/src/oniguruma.h
+++ b/src/oniguruma.h
@@ -609,7 +609,7 @@ ONIG_EXTERN OnigSyntaxType*   OnigDefaultSyntax;
 /* #define ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT                -1001 */
 
 
-/* must be smaller than BIT_STATUS_BITS_NUM (unsigned int * 8) */
+/* must be smaller than MEM_STATUS_BITS_NUM (unsigned int * 8) */
 #define ONIG_MAX_CAPTURE_HISTORY_GROUP   31
 #define ONIG_IS_CAPTURE_HISTORY_GROUP(r, i) \
   ((i) <= ONIG_MAX_CAPTURE_HISTORY_GROUP && (r)->list && (r)->list[i])

diff --git a/src/regcomp.c b/src/regcomp.c
index b2f8af1809506f702af2bca9d4a74d392f2f3dff..a8d4e2bf5052f2d658201fc488255a0c34ead807 100644 (file)
--- a/src/regcomp.c
+++ b/src/regcomp.c
@@ -1306,7 +1306,7 @@ compile_length_enclosure_node(EnclosureNode* node, regex_t* reg)
     if (NODE_IS_CALLED(node)) {
       len = SIZE_OP_MEMORY_START_PUSH + tlen
         + SIZE_OP_CALL + SIZE_OP_JUMP + SIZE_OP_RETURN;
-      if (BIT_STATUS_AT(reg->bt_mem_end, node->m.regnum))
+      if (MEM_STATUS_AT(reg->bt_mem_end, node->m.regnum))
         len += (NODE_IS_RECURSION(node)
                 ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
       else
@@ -1315,18 +1315,18 @@ compile_length_enclosure_node(EnclosureNode* node, regex_t* reg)
     }
     else if (NODE_IS_RECURSION(node)) {
       len = SIZE_OP_MEMORY_START_PUSH;
-      len += tlen + (BIT_STATUS_AT(reg->bt_mem_end, node->m.regnum)
+      len += tlen + (MEM_STATUS_AT(reg->bt_mem_end, node->m.regnum)
                      ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_REC);
     }
     else
 #endif
     {
-      if (BIT_STATUS_AT(reg->bt_mem_start, node->m.regnum))
+      if (MEM_STATUS_AT(reg->bt_mem_start, node->m.regnum))
         len = SIZE_OP_MEMORY_START_PUSH;
       else
         len = SIZE_OP_MEMORY_START;
 
-      len += tlen + (BIT_STATUS_AT(reg->bt_mem_end, node->m.regnum)
+      len += tlen + (MEM_STATUS_AT(reg->bt_mem_end, node->m.regnum)
                     ? SIZE_OP_MEMORY_END_PUSH : SIZE_OP_MEMORY_END);
     }
     break;
@@ -1391,7 +1391,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env)
     if (r != 0) return r;
     len = compile_length_tree(NODE_ENCLOSURE_BODY(node), reg);
     len += (SIZE_OP_MEMORY_START_PUSH + SIZE_OP_RETURN);
-    if (BIT_STATUS_AT(reg->bt_mem_end, node->m.regnum))
+    if (MEM_STATUS_AT(reg->bt_mem_end, node->m.regnum))
       len += (NODE_IS_RECURSION(node)
               ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
     else
@@ -1403,7 +1403,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env)
   }
 #endif
 
-  if (BIT_STATUS_AT(reg->bt_mem_start, node->m.regnum))
+  if (MEM_STATUS_AT(reg->bt_mem_start, node->m.regnum))
     r = add_opcode(reg, OP_MEMORY_START_PUSH);
   else
     r = add_opcode(reg, OP_MEMORY_START);
@@ -1414,7 +1414,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env)
   if (r != 0) return r;
 
 #ifdef USE_SUBEXP_CALL
-  if (BIT_STATUS_AT(reg->bt_mem_end, node->m.regnum))
+  if (MEM_STATUS_AT(reg->bt_mem_end, node->m.regnum))
     r = add_opcode(reg, (NODE_IS_RECURSION(node)
                          ? OP_MEMORY_END_PUSH_REC : OP_MEMORY_END_PUSH));
   else
@@ -1427,7 +1427,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env)
     r = add_opcode(reg, OP_RETURN);
   }
 #else
-  if (BIT_STATUS_AT(reg->bt_mem_end, node->m.regnum))
+  if (MEM_STATUS_AT(reg->bt_mem_end, node->m.regnum))
     r = add_opcode(reg, OP_MEMORY_END_PUSH);
   else
     r = add_opcode(reg, OP_MEMORY_END);
@@ -2025,7 +2025,7 @@ static int
 disable_noname_group_capture(Node** root, regex_t* reg, ScanEnv* env)
 {
   int r, i, pos, counter;
-  BitStatusType loc;
+  MemStatusType loc;
   GroupNumRemap* map;
 
   map = (GroupNumRemap* )xalloca(sizeof(GroupNumRemap) * (env->num_mem + 1));
@@ -2048,10 +2048,10 @@ disable_noname_group_capture(Node** root, regex_t* reg, ScanEnv* env)
   }
 
   loc = env->capture_history;
-  BIT_STATUS_CLEAR(env->capture_history);
+  MEM_STATUS_CLEAR(env->capture_history);
   for (i = 1; i <= ONIG_MAX_CAPTURE_HISTORY_GROUP; i++) {
-    if (BIT_STATUS_AT(loc, i)) {
-      BIT_STATUS_ON_AT_SIMPLE(env->capture_history, map[i].new_val);
+    if (MEM_STATUS_AT(loc, i)) {
+      MEM_STATUS_ON_AT_SIMPLE(env->capture_history, map[i].new_val);
     }
   }
 
@@ -4196,7 +4196,7 @@ setup_qtfr(Node* node, regex_t* reg, int state, ScanEnv* env)
       if (qn->body_empty_info == QTFR_BODY_IS_EMPTY_REC) {
         if (NODE_TYPE(body) == NODE_ENCLOSURE &&
             ENCLOSURE_(body)->type == ENCLOSURE_MEMORY) {
-          BIT_STATUS_ON_AT(env->bt_mem_end, ENCLOSURE_(body)->m.regnum);
+          MEM_STATUS_ON_AT(env->bt_mem_end, ENCLOSURE_(body)->m.regnum);
         }
       }
 #else
@@ -4299,11 +4299,11 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
       p = BACKREFS_P(br);
       for (i = 0; i < br->back_num; i++) {
         if (p[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
-        BIT_STATUS_ON_AT(env->backrefed_mem, p[i]);
-        BIT_STATUS_ON_AT(env->bt_mem_start, p[i]);
+        MEM_STATUS_ON_AT(env->backrefed_mem, p[i]);
+        MEM_STATUS_ON_AT(env->bt_mem_start, p[i]);
 #ifdef USE_BACKREF_WITH_LEVEL
         if (NODE_IS_NEST_LEVEL(node)) {
-          BIT_STATUS_ON_AT(env->bt_mem_end, p[i]);
+          MEM_STATUS_ON_AT(env->bt_mem_end, p[i]);
         }
 #endif
       }
@@ -4331,7 +4331,7 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
 
         if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_MULTI_ENTRY)) != 0
             || NODE_IS_RECURSION(node)) {
-          BIT_STATUS_ON_AT(env->bt_mem_start, en->m.regnum);
+          MEM_STATUS_ON_AT(env->bt_mem_start, en->m.regnum);
         }
         r = setup_tree(NODE_BODY(node), reg, state, env);
         break;
@@ -5322,7 +5322,7 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
             r = optimize_node_left(NODE_BODY(node), opt, env);
 
             if (is_set_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK)) {
-              if (BIT_STATUS_AT(env->scan_env->backrefed_mem, en->m.regnum))
+              if (MEM_STATUS_AT(env->scan_env->backrefed_mem, en->m.regnum))
                 remove_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK);
             }
           }
@@ -5789,7 +5789,7 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
   reg->bt_mem_start     = scan_env.bt_mem_start;
   reg->bt_mem_start    |= reg->capture_history;
   if (IS_FIND_CONDITION(reg->options))
-    BIT_STATUS_ON_ALL(reg->bt_mem_end);
+    MEM_STATUS_ON_ALL(reg->bt_mem_end);
   else {
     reg->bt_mem_end  = scan_env.bt_mem_end;
     reg->bt_mem_end |= reg->capture_history;
@@ -5812,7 +5812,7 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
     if (scan_env.comb_exp_max_regnum > 0) {
       int i;
       for (i = 1; i <= scan_env.comb_exp_max_regnum; i++) {
-        if (BIT_STATUS_AT(scan_env.backrefed_mem, i) != 0) {
+        if (MEM_STATUS_AT(scan_env.backrefed_mem, i) != 0) {
           scan_env.num_comb_exp_check = 0;
           break;
         }

diff --git a/src/regexec.c b/src/regexec.c
index b41a6cea48cb01faa1e0ef033c167955235be226..f66da1f89fc59c9dc055703b9ea905b3e04d20cd 100644 (file)
--- a/src/regexec.c
+++ b/src/regexec.c
@@ -889,7 +889,7 @@ stack_double(int is_alloca, char** arg_alloc_base,
               if (k->u.mem.end == INVALID_STACK_INDEX) {\
                 (isnull) = 0; break;\
               }\
-              if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
+              if (MEM_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
                 endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\
               else\
                 endp = (UChar* )k->u.mem.end;\
@@ -931,7 +931,7 @@ stack_double(int is_alloca, char** arg_alloc_base,
                 if (k->u.mem.end == INVALID_STACK_INDEX) {\
                   (isnull) = 0; break;\
                 }\
-                if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
+                if (MEM_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
                   endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\
                 else\
                   endp = (UChar* )k->u.mem.end;\
@@ -1100,7 +1100,7 @@ make_capture_history_tree(OnigCaptureTreeNode* node, OnigStackType** kp,
     if (k->type == STK_MEM_START) {
       n = k->u.mem.num;
       if (n <= ONIG_MAX_CAPTURE_HISTORY_GROUP &&
-          BIT_STATUS_AT(reg->capture_history, n) != 0) {
+          MEM_STATUS_AT(reg->capture_history, n) != 0) {
         child = history_node_new();
         CHECK_NULL_RETURN_MEMERR(child);
         child->group = n;
@@ -1402,12 +1402,12 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
             rmt[0].rm_eo = s      - str;
             for (i = 1; i <= num_mem; i++) {
               if (mem_end_stk[i] != INVALID_STACK_INDEX) {
-                if (BIT_STATUS_AT(reg->bt_mem_start, i))
+                if (MEM_STATUS_AT(reg->bt_mem_start, i))
                   rmt[i].rm_so = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
                 else
                   rmt[i].rm_so = (UChar* )((void* )(mem_start_stk[i])) - str;
 
-                rmt[i].rm_eo = (BIT_STATUS_AT(reg->bt_mem_end, i)
+                rmt[i].rm_eo = (MEM_STATUS_AT(reg->bt_mem_end, i)
                                 ? STACK_AT(mem_end_stk[i])->u.mem.pstr
                                 : (UChar* )((void* )mem_end_stk[i])) - str;
               }
@@ -1422,12 +1422,12 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
             region->end[0] = s      - str;
             for (i = 1; i <= num_mem; i++) {
               if (mem_end_stk[i] != INVALID_STACK_INDEX) {
-                if (BIT_STATUS_AT(reg->bt_mem_start, i))
+                if (MEM_STATUS_AT(reg->bt_mem_start, i))
                   region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
                 else
                   region->beg[i] = (UChar* )((void* )mem_start_stk[i]) - str;
 
-                region->end[i] = (BIT_STATUS_AT(reg->bt_mem_end, i)
+                region->end[i] = (MEM_STATUS_AT(reg->bt_mem_end, i)
                                   ? STACK_AT(mem_end_stk[i])->u.mem.pstr
                                   : (UChar* )((void* )mem_end_stk[i])) - str;
               }
@@ -2172,7 +2172,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       mem_end_stk[mem] = (OnigStackIndex )((void* )s);
       STACK_GET_MEM_START(mem, stkp);
 
-      if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+      if (MEM_STATUS_AT(reg->bt_mem_start, mem))
         mem_start_stk[mem] = GET_STACK_INDEX(stkp);
       else
         mem_start_stk[mem] = (OnigStackIndex )((void* )stkp->u.mem.pstr);
@@ -2206,12 +2206,12 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
         if (mem_end_stk[mem]   == INVALID_STACK_INDEX) goto fail;
         if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail;
 
-        if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+        if (MEM_STATUS_AT(reg->bt_mem_start, mem))
           pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
         else
           pstart = (UChar* )((void* )mem_start_stk[mem]);
 
-        pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
+        pend = (MEM_STATUS_AT(reg->bt_mem_end, mem)
                 ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
                 : (UChar* )((void* )mem_end_stk[mem]));
         n = pend - pstart;
@@ -2238,12 +2238,12 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
         if (mem_end_stk[mem]   == INVALID_STACK_INDEX) goto fail;
         if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail;
 
-        if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+        if (MEM_STATUS_AT(reg->bt_mem_start, mem))
           pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
         else
           pstart = (UChar* )((void* )mem_start_stk[mem]);
 
-        pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
+        pend = (MEM_STATUS_AT(reg->bt_mem_end, mem)
                 ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
                 : (UChar* )((void* )mem_end_stk[mem]));
         n = pend - pstart;
@@ -2270,12 +2270,12 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
           if (mem_end_stk[mem]   == INVALID_STACK_INDEX) continue;
           if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;
 
-          if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+          if (MEM_STATUS_AT(reg->bt_mem_start, mem))
             pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
           else
             pstart = (UChar* )((void* )mem_start_stk[mem]);
 
-          pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
+          pend = (MEM_STATUS_AT(reg->bt_mem_end, mem)
                   ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
                   : (UChar* )((void* )mem_end_stk[mem]));
           n = pend - pstart;
@@ -2309,12 +2309,12 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
           if (mem_end_stk[mem]   == INVALID_STACK_INDEX) continue;
           if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;
 
-          if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+          if (MEM_STATUS_AT(reg->bt_mem_start, mem))
             pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
           else
             pstart = (UChar* )((void* )mem_start_stk[mem]);
 
-          pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
+          pend = (MEM_STATUS_AT(reg->bt_mem_end, mem)
                   ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
                   : (UChar* )((void* )mem_end_stk[mem]));
           n = pend - pstart;
@@ -3867,7 +3867,7 @@ onig_number_of_capture_histories(regex_t* reg)
 
   n = 0;
   for (i = 0; i <= ONIG_MAX_CAPTURE_HISTORY_GROUP; i++) {
-    if (BIT_STATUS_AT(reg->capture_history, i) != 0)
+    if (MEM_STATUS_AT(reg->capture_history, i) != 0)
       n++;
   }
   return n;

diff --git a/src/regint.h b/src/regint.h
index e2fa1ad7feb76ae72d817d501f8de20e0859c6f8..688f893797ddda96855fe2e028b96805123d7cd8 100644 (file)
--- a/src/regint.h
+++ b/src/regint.h
@@ -240,23 +240,23 @@ typedef int intptr_t;
 #define ONIG_OPTIMIZE_MAP               5   /* char map */
 
 /* bit status */
-typedef unsigned int  BitStatusType;
+typedef unsigned int  MemStatusType;
 
-#define BIT_STATUS_BITS_NUM          (sizeof(BitStatusType) * 8)
-#define BIT_STATUS_CLEAR(stats)      (stats) = 0
-#define BIT_STATUS_ON_ALL(stats)     (stats) = ~((BitStatusType )0)
-#define BIT_STATUS_AT(stats,n) \
-  ((n) < (int )BIT_STATUS_BITS_NUM  ?  ((stats) & (1 << n)) : ((stats) & 1))
+#define MEM_STATUS_BITS_NUM          (sizeof(MemStatusType) * 8)
+#define MEM_STATUS_CLEAR(stats)      (stats) = 0
+#define MEM_STATUS_ON_ALL(stats)     (stats) = ~((MemStatusType )0)
+#define MEM_STATUS_AT(stats,n) \
+  ((n) < (int )MEM_STATUS_BITS_NUM  ?  ((stats) & (1 << n)) : ((stats) & 1))
 
-#define BIT_STATUS_ON_AT(stats,n) do {\
-    if ((n) < (int )BIT_STATUS_BITS_NUM)       \
+#define MEM_STATUS_ON_AT(stats,n) do {\
+    if ((n) < (int )MEM_STATUS_BITS_NUM)       \
     (stats) |= (1 << (n));\
   else\
     (stats) |= 1;\
 } while (0)
 
-#define BIT_STATUS_ON_AT_SIMPLE(stats,n) do {\
-    if ((n) < (int )BIT_STATUS_BITS_NUM)\
+#define MEM_STATUS_ON_AT_SIMPLE(stats,n) do {\
+    if ((n) < (int )MEM_STATUS_BITS_NUM)\
     (stats) |= (1 << (n));\
 } while (0)
 

diff --git a/src/regparse.c b/src/regparse.c
index 9eecb0328288378b8852247cd3d10d6d69344dec..92efb9ae08780bf5e16cc4d199055da20858bb51 100644 (file)
--- a/src/regparse.c
+++ b/src/regparse.c
@@ -978,10 +978,10 @@ onig_noname_group_capture_is_active(regex_t* reg)
 static void
 scan_env_clear(ScanEnv* env)
 {
-  BIT_STATUS_CLEAR(env->capture_history);
-  BIT_STATUS_CLEAR(env->bt_mem_start);
-  BIT_STATUS_CLEAR(env->bt_mem_end);
-  BIT_STATUS_CLEAR(env->backrefed_mem);
+  MEM_STATUS_CLEAR(env->capture_history);
+  MEM_STATUS_CLEAR(env->bt_mem_start);
+  MEM_STATUS_CLEAR(env->bt_mem_end);
+  MEM_STATUS_CLEAR(env->backrefed_mem);
   env->error      = (UChar* )NULL;
   env->error_end  = (UChar* )NULL;
   env->num_call   = 0;
@@ -4696,7 +4696,7 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end,
 
           num = scan_env_add_mem_entry(env);
           if (num < 0) return num;
-          if (list_capture != 0 && num >= (int )BIT_STATUS_BITS_NUM)
+          if (list_capture != 0 && num >= (int )MEM_STATUS_BITS_NUM)
             return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY;
 
           r = name_add(env->reg, name, name_end, num, env);
@@ -4705,7 +4705,7 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end,
           CHECK_NULL_RETURN_MEMERR(*np);
           ENCLOSURE_(*np)->m.regnum = num;
           if (list_capture != 0)
-            BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
+            MEM_STATUS_ON_AT_SIMPLE(env->capture_history, num);
           env->num_named++;
         }
         else {
@@ -4737,11 +4737,11 @@ parse_enclosure(Node** np, OnigToken* tok, int term, UChar** src, UChar* end,
         if (num < 0) {
           return num;
         }
-        else if (num >= (int )BIT_STATUS_BITS_NUM) {
+        else if (num >= (int )MEM_STATUS_BITS_NUM) {
           return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY;
         }
         ENCLOSURE_(*np)->m.regnum = num;
-        BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
+        MEM_STATUS_ON_AT_SIMPLE(env->capture_history, num);
       }
       else {
         return ONIGERR_UNDEFINED_GROUP_OPTION;

diff --git a/src/regparse.h b/src/regparse.h
index 5776efc0251f81d4792511d67f08a2a774e5c5fd..b2ae1974f9c67077583114eeeb5197d6f7f789d3 100644 (file)
--- a/src/regparse.h
+++ b/src/regparse.h
@@ -333,10 +333,10 @@ typedef struct {
   OnigCaseFoldType case_fold_flag;
   OnigEncoding     enc;
   OnigSyntaxType*  syntax;
-  BitStatusType    capture_history;
-  BitStatusType    bt_mem_start;
-  BitStatusType    bt_mem_end;
-  BitStatusType    backrefed_mem;
+  MemStatusType    capture_history;
+  MemStatusType    bt_mem_start;
+  MemStatusType    bt_mem_end;
+  MemStatusType    backrefed_mem;
   UChar*           pattern;
   UChar*           pattern_end;
   UChar*           error;