refactoring

diff --git a/src/regcomp.c b/src/regcomp.c
index 72cc2a949031c0f259ecda7046375c3621665e6a..7c04a4d9a180e068f4f43fb200466094778162d0 100644 (file)
--- a/src/regcomp.c
+++ b/src/regcomp.c
@@ -277,7 +277,7 @@ unset_addr_list_add(UnsetAddrList* list, int offset, struct _Node* node)
 static int
 add_opcode(regex_t* reg, int opcode)
 {
-  BBUF_ADD1(reg, opcode);
+  BB_ADD1(reg, opcode);
   return 0;
 }
 
@@ -287,7 +287,7 @@ add_state_check_num(regex_t* reg, int num)
 {
   StateCheckNumType n = (StateCheckNumType )num;
 
-  BBUF_ADD(reg, &n, SIZE_STATE_CHECK_NUM);
+  BB_ADD(reg, &n, SIZE_STATE_CHECK_NUM);
   return 0;
 }
 #endif
@@ -297,7 +297,7 @@ add_rel_addr(regex_t* reg, int addr)
 {
   RelAddrType ra = (RelAddrType )addr;
 
-  BBUF_ADD(reg, &ra, SIZE_RELADDR);
+  BB_ADD(reg, &ra, SIZE_RELADDR);
   return 0;
 }
 
@@ -306,7 +306,7 @@ add_abs_addr(regex_t* reg, int addr)
 {
   AbsAddrType ra = (AbsAddrType )addr;
 
-  BBUF_ADD(reg, &ra, SIZE_ABSADDR);
+  BB_ADD(reg, &ra, SIZE_ABSADDR);
   return 0;
 }
 
@@ -315,7 +315,7 @@ add_length(regex_t* reg, int len)
 {
   LengthType l = (LengthType )len;
 
-  BBUF_ADD(reg, &l, SIZE_LENGTH);
+  BB_ADD(reg, &l, SIZE_LENGTH);
   return 0;
 }
 
@@ -324,7 +324,7 @@ add_mem_num(regex_t* reg, int num)
 {
   MemNumType n = (MemNumType )num;
 
-  BBUF_ADD(reg, &n, SIZE_MEMNUM);
+  BB_ADD(reg, &n, SIZE_MEMNUM);
   return 0;
 }
 
@@ -334,7 +334,7 @@ add_pointer(regex_t* reg, void* addr)
 {
   PointerType ptr = (PointerType )addr;
 
-  BBUF_ADD(reg, &ptr, SIZE_POINTER);
+  BB_ADD(reg, &ptr, SIZE_POINTER);
   return 0;
 }
 #endif
@@ -342,7 +342,7 @@ add_pointer(regex_t* reg, void* addr)
 static int
 add_option(regex_t* reg, OnigOptionType option)
 {
-  BBUF_ADD(reg, &option, SIZE_OPTION);
+  BB_ADD(reg, &option, SIZE_OPTION);
   return 0;
 }
 
@@ -351,7 +351,7 @@ add_save_type(regex_t* reg, enum SaveType type)
 {
   SaveType t = (SaveType )type;
 
-  BBUF_ADD(reg, &t, SIZE_SAVE_TYPE);
+  BB_ADD(reg, &t, SIZE_SAVE_TYPE);
   return 0;
 }
 
@@ -360,7 +360,7 @@ add_update_var_type(regex_t* reg, enum UpdateVarType type)
 {
   UpdateVarType t = (UpdateVarType )type;
 
-  BBUF_ADD(reg, &t, SIZE_UPDATE_VAR_TYPE);
+  BB_ADD(reg, &t, SIZE_UPDATE_VAR_TYPE);
   return 0;
 }
 
@@ -378,14 +378,14 @@ add_opcode_rel_addr(regex_t* reg, int opcode, int addr)
 static int
 add_bytes(regex_t* reg, UChar* bytes, int len)
 {
-  BBUF_ADD(reg, bytes, len);
+  BB_ADD(reg, bytes, len);
   return 0;
 }
 
 static int
 add_bitset(regex_t* reg, BitSetRef bs)
 {
-  BBUF_ADD(reg, bs, SIZE_BITSET);
+  BB_ADD(reg, bs, SIZE_BITSET);
   return 0;
 }
 
@@ -492,7 +492,7 @@ compile_call(CallNode* node, regex_t* reg, ScanEnv* env)
 
   r = add_opcode(reg, OP_CALL);
   if (r != 0) return r;
-  r = unset_addr_list_add(env->unset_addr_list, BBUF_GET_OFFSET_POS(reg),
+  r = unset_addr_list_add(env->unset_addr_list, BB_GET_OFFSET_POS(reg),
                           NODE_CALL_BODY(node));
   if (r != 0) return r;
   r = add_abs_addr(reg, 0 /*dummy addr.*/);
@@ -655,7 +655,7 @@ add_multi_byte_cclass(BBuf* mbuf, regex_t* reg)
   return add_bytes(reg, mbuf->p, mbuf->used);
 #else
   int r, pad_size;
-  UChar* p = BBUF_GET_ADD_ADDRESS(reg) + SIZE_LENGTH;
+  UChar* p = BB_GET_ADD_ADDRESS(reg) + SIZE_LENGTH;
 
   GET_ALIGNMENT_PAD_SIZE(p, pad_size);
   add_length(reg, mbuf->used + (WORD_ALIGNMENT_SIZE - 1));
@@ -1400,7 +1400,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env)
   if (node->m.regnum == 0 && NODE_IS_CALLED(node)) {
     r = add_opcode(reg, OP_CALL);
     if (r != 0) return r;
-    node->m.called_addr = BBUF_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP;
+    node->m.called_addr = BB_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP;
     NODE_STATUS_ADD(node, NST_ADDR_FIXED);
     r = add_abs_addr(reg, (int )node->m.called_addr);
     if (r != 0) return r;
@@ -1418,7 +1418,7 @@ compile_enclosure_memory_node(EnclosureNode* node, regex_t* reg, ScanEnv* env)
   if (NODE_IS_CALLED(node)) {
     r = add_opcode(reg, OP_CALL);
     if (r != 0) return r;
-    node->m.called_addr = BBUF_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP;
+    node->m.called_addr = BB_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP;
     NODE_STATUS_ADD(node, NST_ADDR_FIXED);
     r = add_abs_addr(reg, (int )node->m.called_addr);
     if (r != 0) return r;
@@ -2298,7 +2298,7 @@ unset_addr_list_fix(UnsetAddrList* uslist, regex_t* reg)
     addr   = en->m.called_addr;
     offset = uslist->us[i].offset;
 
-    BBUF_WRITE(reg, offset, &addr, SIZE_ABSADDR);
+    BB_WRITE(reg, offset, &addr, SIZE_ABSADDR);
   }
   return 0;
 }
@@ -6219,7 +6219,7 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
   if (reg->alloc == 0) {
     init_size = (pattern_end - pattern) * 2;
     if (init_size <= 0) init_size = COMPILE_INIT_SIZE;
-    r = BBUF_INIT(reg, init_size);
+    r = BB_INIT(reg, init_size);
     if (r != 0) goto end;
   }
   else

diff --git a/src/regint.h b/src/regint.h
index 9e3eb4f7b0d852486350521fa31e481260e91df1..10a70b3f69597685601a424e9ac62f92b37db09a 100644 (file)
--- a/src/regint.h
+++ b/src/regint.h
@@ -349,21 +349,21 @@ typedef struct _BBuf {
   unsigned int alloc;
 } BBuf;
 
-#define BBUF_INIT(buf,size)    onig_bbuf_init((BBuf* )(buf), (size))
+#define BB_INIT(buf,size)    onig_bbuf_init((BBuf* )(buf), (size))
 
-#define BBUF_SIZE_INC(buf,inc) do{\
+#define BB_SIZE_INC(buf,inc) do{\
   (buf)->alloc += (inc);\
   (buf)->p = (UChar* )xrealloc((buf)->p, (buf)->alloc);\
   if (IS_NULL((buf)->p)) return(ONIGERR_MEMORY);\
 } while (0)
 
-#define BBUF_EXPAND(buf,low) do{\
+#define BB_EXPAND(buf,low) do{\
   do { (buf)->alloc *= 2; } while ((buf)->alloc < (unsigned int )low);\
   (buf)->p = (UChar* )xrealloc((buf)->p, (buf)->alloc);\
   if (IS_NULL((buf)->p)) return(ONIGERR_MEMORY);\
 } while (0)
 
-#define BBUF_ENSURE_SIZE(buf,size) do{\
+#define BB_ENSURE_SIZE(buf,size) do{\
   unsigned int new_alloc = (buf)->alloc;\
   while (new_alloc < (unsigned int )(size)) { new_alloc *= 2; }\
   if ((buf)->alloc != new_alloc) {\
@@ -373,54 +373,54 @@ typedef struct _BBuf {
   }\
 } while (0)
 
-#define BBUF_WRITE(buf,pos,bytes,n) do{\
+#define BB_WRITE(buf,pos,bytes,n) do{\
   int used = (pos) + (n);\
-  if ((buf)->alloc < (unsigned int )used) BBUF_EXPAND((buf),used);\
+  if ((buf)->alloc < (unsigned int )used) BB_EXPAND((buf),used);\
   xmemcpy((buf)->p + (pos), (bytes), (n));\
   if ((buf)->used < (unsigned int )used) (buf)->used = used;\
 } while (0)
 
-#define BBUF_WRITE1(buf,pos,byte) do{\
+#define BB_WRITE1(buf,pos,byte) do{\
   int used = (pos) + 1;\
-  if ((buf)->alloc < (unsigned int )used) BBUF_EXPAND((buf),used);\
+  if ((buf)->alloc < (unsigned int )used) BB_EXPAND((buf),used);\
   (buf)->p[(pos)] = (byte);\
   if ((buf)->used < (unsigned int )used) (buf)->used = used;\
 } while (0)
 
-#define BBUF_ADD(buf,bytes,n)       BBUF_WRITE((buf),(buf)->used,(bytes),(n))
-#define BBUF_ADD1(buf,byte)         BBUF_WRITE1((buf),(buf)->used,(byte))
-#define BBUF_GET_ADD_ADDRESS(buf)   ((buf)->p + (buf)->used)
-#define BBUF_GET_OFFSET_POS(buf)    ((buf)->used)
+#define BB_ADD(buf,bytes,n)       BB_WRITE((buf),(buf)->used,(bytes),(n))
+#define BB_ADD1(buf,byte)         BB_WRITE1((buf),(buf)->used,(byte))
+#define BB_GET_ADD_ADDRESS(buf)   ((buf)->p + (buf)->used)
+#define BB_GET_OFFSET_POS(buf)    ((buf)->used)
 
 /* from < to */
-#define BBUF_MOVE_RIGHT(buf,from,to,n) do {\
-  if ((unsigned int )((to)+(n)) > (buf)->alloc) BBUF_EXPAND((buf),(to) + (n));\
+#define BB_MOVE_RIGHT(buf,from,to,n) do {\
+  if ((unsigned int )((to)+(n)) > (buf)->alloc) BB_EXPAND((buf),(to) + (n));\
   xmemmove((buf)->p + (to), (buf)->p + (from), (n));\
   if ((unsigned int )((to)+(n)) > (buf)->used) (buf)->used = (to) + (n);\
 } while (0)
 
 /* from > to */
-#define BBUF_MOVE_LEFT(buf,from,to,n) do {\
+#define BB_MOVE_LEFT(buf,from,to,n) do {\
   xmemmove((buf)->p + (to), (buf)->p + (from), (n));\
 } while (0)
 
 /* from > to */
-#define BBUF_MOVE_LEFT_REDUCE(buf,from,to) do {\
+#define BB_MOVE_LEFT_REDUCE(buf,from,to) do {\
   xmemmove((buf)->p + (to), (buf)->p + (from), (buf)->used - (from));\
   (buf)->used -= (from - to);\
 } while (0)
 
-#define BBUF_INSERT(buf,pos,bytes,n) do {\
+#define BB_INSERT(buf,pos,bytes,n) do {\
   if (pos >= (buf)->used) {\
-    BBUF_WRITE(buf,pos,bytes,n);\
+    BB_WRITE(buf,pos,bytes,n);\
   }\
   else {\
-    BBUF_MOVE_RIGHT((buf),(pos),(pos) + (n),((buf)->used - (pos)));\
+    BB_MOVE_RIGHT((buf),(pos),(pos) + (n),((buf)->used - (pos)));\
     xmemcpy((buf)->p + (pos), (bytes), (n));\
   }\
 } while (0)
 
-#define BBUF_GET_BYTE(buf, pos) (buf)->p[(pos)]
+#define BB_GET_BYTE(buf, pos) (buf)->p[(pos)]
 
 
 /* has body */

diff --git a/src/regparse.c b/src/regparse.c
index e3438e6551dc738bf268df84e278a7aff60b67d1..3a5d7ad7f9c844a900db585fa5219312dbd72fea 100644 (file)
--- a/src/regparse.c
+++ b/src/regparse.c
@@ -163,7 +163,7 @@ bbuf_clone(BBuf** rto, BBuf* from)
 
   *rto = to = (BBuf* )xmalloc(sizeof(BBuf));
   CHECK_NULL_RETURN_MEMERR(to);
-  r = BBUF_INIT(to, from->alloc);
+  r = BB_INIT(to, from->alloc);
   if (r != 0) {
     xfree(to->p);
     *rto = 0;
@@ -2182,8 +2182,8 @@ scan_unsigned_octal_number(UChar** src, UChar* end, int maxlen,
 }
 
 
-#define BBUF_WRITE_CODE_POINT(bbuf,pos,code) \
-    BBUF_WRITE(bbuf, pos, &(code), SIZE_CODE_POINT)
+#define BB_WRITE_CODE_POINT(bbuf,pos,code) \
+    BB_WRITE(bbuf, pos, &(code), SIZE_CODE_POINT)
 
 /* data format:
      [n][from-1][to-1][from-2][to-2] ... [from-n][to-n]
@@ -2199,7 +2199,7 @@ new_code_range(BBuf** pbuf)
 
   bbuf = *pbuf = (BBuf* )xmalloc(sizeof(BBuf));
   CHECK_NULL_RETURN_MEMERR(bbuf);
-  r = BBUF_INIT(bbuf, INIT_MULTI_BYTE_RANGE_SIZE);
+  r = BB_INIT(bbuf, INIT_MULTI_BYTE_RANGE_SIZE);
   if (r != 0) {
     xfree(bbuf);
     *pbuf = 0;
@@ -2207,7 +2207,7 @@ new_code_range(BBuf** pbuf)
   }
 
   n = 0;
-  BBUF_WRITE_CODE_POINT(bbuf, 0, n);
+  BB_WRITE_CODE_POINT(bbuf, 0, n);
   return 0;
 }
 
@@ -2270,19 +2270,19 @@ add_code_range_to_buf(BBuf** pbuf, OnigCodePoint from, OnigCodePoint to)
     int size = (n - high) * 2 * SIZE_CODE_POINT;
 
     if (inc_n > 0) {
-      BBUF_MOVE_RIGHT(bbuf, from_pos, to_pos, size);
+      BB_MOVE_RIGHT(bbuf, from_pos, to_pos, size);
     }
     else {
-      BBUF_MOVE_LEFT_REDUCE(bbuf, from_pos, to_pos);
+      BB_MOVE_LEFT_REDUCE(bbuf, from_pos, to_pos);
     }
   }
 
   pos = SIZE_CODE_POINT * (1 + low * 2);
-  BBUF_ENSURE_SIZE(bbuf, pos + SIZE_CODE_POINT * 2);
-  BBUF_WRITE_CODE_POINT(bbuf, pos, from);
-  BBUF_WRITE_CODE_POINT(bbuf, pos + SIZE_CODE_POINT, to);
+  BB_ENSURE_SIZE(bbuf, pos + SIZE_CODE_POINT * 2);
+  BB_WRITE_CODE_POINT(bbuf, pos, from);
+  BB_WRITE_CODE_POINT(bbuf, pos + SIZE_CODE_POINT, to);
   n += inc_n;
-  BBUF_WRITE_CODE_POINT(bbuf, 0, n);
+  BB_WRITE_CODE_POINT(bbuf, 0, n);
 
   return 0;
 }
@@ -2335,7 +2335,7 @@ not_code_range_buf(OnigEncoding enc, BBuf* bbuf, BBuf** pbuf)
   return r;
 }
 
-#define SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2) do {\
+#define SWAP_BB_NOT(bbuf1, not1, bbuf2, not2) do {\
   BBuf *tbuf; \
   int  tnot; \
   tnot = not1;  not1  = not2;  not2  = tnot; \
@@ -2359,7 +2359,7 @@ or_code_range_buf(OnigEncoding enc, BBuf* bbuf1, int not1,
 
   r = 0;
   if (IS_NULL(bbuf2))
-    SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2);
+    SWAP_BB_NOT(bbuf1, not1, bbuf2, not2);
 
   if (IS_NULL(bbuf1)) {
     if (not1 != 0) {
@@ -2376,7 +2376,7 @@ or_code_range_buf(OnigEncoding enc, BBuf* bbuf1, int not1,
   }
 
   if (not1 != 0)
-    SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2);
+    SWAP_BB_NOT(bbuf1, not1, bbuf2, not2);
 
   data1 = (OnigCodePoint* )(bbuf1->p);
   GET_CODE_POINT(n1, data1);
@@ -2459,7 +2459,7 @@ and_code_range_buf(BBuf* bbuf1, int not1, BBuf* bbuf2, int not2, BBuf** pbuf)
   }
 
   if (not1 != 0)
-    SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2);
+    SWAP_BB_NOT(bbuf1, not1, bbuf2, not2);
 
   data1 = (OnigCodePoint* )(bbuf1->p);
   data2 = (OnigCodePoint* )(bbuf2->p);