From: kosako <kosako@sofnec.co.jp>
Date: Mon, 11 Apr 2016 08:19:18 +0000 (+0900)
Subject: fix indent
X-Git-Tag: v6.0.0^2~57
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=db72375549bf3906ea305a1e1022a2e150ba9cbb;p=onig

fix indent
---

diff --git a/src/regcomp.c b/src/regcomp.c
index ed31eea..7310569 100644
--- a/src/regcomp.c
+++ b/src/regcomp.c
@@ -826,31 +826,31 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
     if (r) return r;
     if (IS_NOT_NULL(qn->next_head_exact) && !CKN_ON) {
       if (IS_MULTILINE(reg->options))
-	r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT);
+        r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT);
       else
-	r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT);
+        r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT);
       if (r) return r;
       if (CKN_ON) {
-	r = add_state_check_num(reg, ckn);
-	if (r) return r;
+        r = add_state_check_num(reg, ckn);
+        if (r) return r;
       }
 
       return add_bytes(reg, NSTR(qn->next_head_exact)->s, 1);
     }
     else {
       if (IS_MULTILINE(reg->options)) {
-	r = add_opcode(reg, (CKN_ON ?
-			       OP_STATE_CHECK_ANYCHAR_ML_STAR
-			     : OP_ANYCHAR_ML_STAR));
+        r = add_opcode(reg, (CKN_ON ?
+                             OP_STATE_CHECK_ANYCHAR_ML_STAR
+                             : OP_ANYCHAR_ML_STAR));
       }
       else {
-	r = add_opcode(reg, (CKN_ON ?
-			       OP_STATE_CHECK_ANYCHAR_STAR
-			     : OP_ANYCHAR_STAR));
+        r = add_opcode(reg, (CKN_ON ?
+                             OP_STATE_CHECK_ANYCHAR_STAR
+                             : OP_ANYCHAR_STAR));
       }
       if (r) return r;
       if (CKN_ON)
-	r = add_state_check_num(reg, ckn);
+        r = add_state_check_num(reg, ckn);
 
       return r;
     }
@@ -864,45 +864,45 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
   if (infinite && qn->lower <= 1) {
     if (qn->greedy) {
       if (qn->lower == 1) {
-	r = add_opcode_rel_addr(reg, OP_JUMP,
-			(CKN_ON ? SIZE_OP_STATE_CHECK_PUSH : SIZE_OP_PUSH));
-	if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP,
+                       (CKN_ON ? SIZE_OP_STATE_CHECK_PUSH : SIZE_OP_PUSH));
+        if (r) return r;
       }
 
       if (CKN_ON) {
-	r = add_opcode(reg, OP_STATE_CHECK_PUSH);
-	if (r) return r;
-	r = add_state_check_num(reg, ckn);
-	if (r) return r;
-	r = add_rel_addr(reg, mod_tlen + SIZE_OP_JUMP);
+        r = add_opcode(reg, OP_STATE_CHECK_PUSH);
+        if (r) return r;
+        r = add_state_check_num(reg, ckn);
+        if (r) return r;
+        r = add_rel_addr(reg, mod_tlen + SIZE_OP_JUMP);
       }
       else {
-	r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP);
+        r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP);
       }
       if (r) return r;
       r = compile_tree_empty_check(qn->target, reg, empty_info);
       if (r) return r;
       r = add_opcode_rel_addr(reg, OP_JUMP,
-	      -(mod_tlen + (int )SIZE_OP_JUMP
-		+ (int )(CKN_ON ? SIZE_OP_STATE_CHECK_PUSH : SIZE_OP_PUSH)));
+                -(mod_tlen + (int )SIZE_OP_JUMP
+                + (int )(CKN_ON ? SIZE_OP_STATE_CHECK_PUSH : SIZE_OP_PUSH)));
     }
     else {
       if (qn->lower == 0) {
-	r = add_opcode_rel_addr(reg, OP_JUMP, mod_tlen);
-	if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP, mod_tlen);
+        if (r) return r;
       }
       r = compile_tree_empty_check(qn->target, reg, empty_info);
       if (r) return r;
       if (CKN_ON) {
-	r = add_opcode(reg, OP_STATE_CHECK_PUSH_OR_JUMP);
-	if (r) return r;
-	r = add_state_check_num(reg, ckn);
-	if (r) return r;
-	r = add_rel_addr(reg,
-		 -(mod_tlen + (int )SIZE_OP_STATE_CHECK_PUSH_OR_JUMP));
+        r = add_opcode(reg, OP_STATE_CHECK_PUSH_OR_JUMP);
+        if (r) return r;
+        r = add_state_check_num(reg, ckn);
+        if (r) return r;
+        r = add_rel_addr(reg,
+                         -(mod_tlen + (int )SIZE_OP_STATE_CHECK_PUSH_OR_JUMP));
       }
       else
-	r = add_opcode_rel_addr(reg, OP_PUSH, -(mod_tlen + (int )SIZE_OP_PUSH));
+        r = add_opcode_rel_addr(reg, OP_PUSH, -(mod_tlen + (int )SIZE_OP_PUSH));
     }
   }
   else if (qn->upper == 0) {
@@ -917,14 +917,14 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
   else if (qn->upper == 1 && qn->greedy) {
     if (qn->lower == 0) {
       if (CKN_ON) {
-	r = add_opcode(reg, OP_STATE_CHECK_PUSH);
-	if (r) return r;
-	r = add_state_check_num(reg, ckn);
-	if (r) return r;
-	r = add_rel_addr(reg, tlen);
+        r = add_opcode(reg, OP_STATE_CHECK_PUSH);
+        if (r) return r;
+        r = add_state_check_num(reg, ckn);
+        if (r) return r;
+        r = add_rel_addr(reg, tlen);
       }
       else {
-	r = add_opcode_rel_addr(reg, OP_PUSH, tlen);
+        r = add_opcode_rel_addr(reg, OP_PUSH, tlen);
       }
       if (r) return r;
     }
@@ -998,11 +998,11 @@ compile_length_quantifier_node(QtfrNode* qn, regex_t* reg)
 
     if (qn->greedy) {
       if (IS_NOT_NULL(qn->head_exact))
-	len += SIZE_OP_PUSH_OR_JUMP_EXACT1 + mod_tlen + SIZE_OP_JUMP;
+        len += SIZE_OP_PUSH_OR_JUMP_EXACT1 + mod_tlen + SIZE_OP_JUMP;
       else if (IS_NOT_NULL(qn->next_head_exact))
-	len += SIZE_OP_PUSH_IF_PEEK_NEXT + mod_tlen + SIZE_OP_JUMP;
+        len += SIZE_OP_PUSH_IF_PEEK_NEXT + mod_tlen + SIZE_OP_JUMP;
       else
-	len += SIZE_OP_PUSH + mod_tlen + SIZE_OP_JUMP;
+        len += SIZE_OP_PUSH + mod_tlen + SIZE_OP_JUMP;
     }
     else
       len += SIZE_OP_JUMP + mod_tlen + SIZE_OP_PUSH;
@@ -1042,17 +1042,17 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
     if (r) return r;
     if (IS_NOT_NULL(qn->next_head_exact)) {
       if (IS_MULTILINE(reg->options))
-	r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT);
+        r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT);
       else
-	r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT);
+        r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT);
       if (r) return r;
       return add_bytes(reg, NSTR(qn->next_head_exact)->s, 1);
     }
     else {
       if (IS_MULTILINE(reg->options))
-	return add_opcode(reg, OP_ANYCHAR_ML_STAR);
+        return add_opcode(reg, OP_ANYCHAR_ML_STAR);
       else
-	return add_opcode(reg, OP_ANYCHAR_STAR);
+        return add_opcode(reg, OP_ANYCHAR_STAR);
     }
   }
 
@@ -1065,15 +1065,15 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
       (qn->lower <= 1 || tlen * qn->lower <= QUANTIFIER_EXPAND_LIMIT_SIZE)) {
     if (qn->lower == 1 && tlen > QUANTIFIER_EXPAND_LIMIT_SIZE) {
       if (qn->greedy) {
-	if (IS_NOT_NULL(qn->head_exact))
-	  r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_OR_JUMP_EXACT1);
-	else if (IS_NOT_NULL(qn->next_head_exact))
-	  r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_IF_PEEK_NEXT);
-	else
-	  r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH);
+        if (IS_NOT_NULL(qn->head_exact))
+          r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_OR_JUMP_EXACT1);
+        else if (IS_NOT_NULL(qn->next_head_exact))
+          r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_IF_PEEK_NEXT);
+        else
+          r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH);
       }
       else {
-	r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_JUMP);
+        r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_JUMP);
       }
       if (r) return r;
     }
@@ -1084,32 +1084,32 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
 
     if (qn->greedy) {
       if (IS_NOT_NULL(qn->head_exact)) {
-	r = add_opcode_rel_addr(reg, OP_PUSH_OR_JUMP_EXACT1,
-			     mod_tlen + SIZE_OP_JUMP);
-	if (r) return r;
-	add_bytes(reg, NSTR(qn->head_exact)->s, 1);
-	r = compile_tree_empty_check(qn->target, reg, empty_info);
-	if (r) return r;
-	r = add_opcode_rel_addr(reg, OP_JUMP,
-	-(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_OR_JUMP_EXACT1));
+        r = add_opcode_rel_addr(reg, OP_PUSH_OR_JUMP_EXACT1,
+                                mod_tlen + SIZE_OP_JUMP);
+        if (r) return r;
+        add_bytes(reg, NSTR(qn->head_exact)->s, 1);
+        r = compile_tree_empty_check(qn->target, reg, empty_info);
+        if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP,
+         -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_OR_JUMP_EXACT1));
       }
       else if (IS_NOT_NULL(qn->next_head_exact)) {
-	r = add_opcode_rel_addr(reg, OP_PUSH_IF_PEEK_NEXT,
-				mod_tlen + SIZE_OP_JUMP);
-	if (r) return r;
-	add_bytes(reg, NSTR(qn->next_head_exact)->s, 1);
-	r = compile_tree_empty_check(qn->target, reg, empty_info);
-	if (r) return r;
-	r = add_opcode_rel_addr(reg, OP_JUMP,
+        r = add_opcode_rel_addr(reg, OP_PUSH_IF_PEEK_NEXT,
+                                mod_tlen + SIZE_OP_JUMP);
+        if (r) return r;
+        add_bytes(reg, NSTR(qn->next_head_exact)->s, 1);
+        r = compile_tree_empty_check(qn->target, reg, empty_info);
+        if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP,
           -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_IF_PEEK_NEXT));
       }
       else {
-	r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP);
-	if (r) return r;
-	r = compile_tree_empty_check(qn->target, reg, empty_info);
-	if (r) return r;
-	r = add_opcode_rel_addr(reg, OP_JUMP,
-		     -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH));
+        r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP);
+        if (r) return r;
+        r = compile_tree_empty_check(qn->target, reg, empty_info);
+        if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP,
+                   -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH));
       }
     }
     else {
@@ -1222,21 +1222,21 @@ compile_length_enclose_node(EncloseNode* node, regex_t* reg)
 #ifdef USE_SUBEXP_CALL
     if (IS_ENCLOSE_CALLED(node)) {
       len = SIZE_OP_MEMORY_START_PUSH + tlen
-	  + SIZE_OP_CALL + SIZE_OP_JUMP + SIZE_OP_RETURN;
+        + SIZE_OP_CALL + SIZE_OP_JUMP + SIZE_OP_RETURN;
       if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
-	len += (IS_ENCLOSE_RECURSION(node)
-		? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
+        len += (IS_ENCLOSE_RECURSION(node)
+                ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
       else
-	len += (IS_ENCLOSE_RECURSION(node)
-		? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
+        len += (IS_ENCLOSE_RECURSION(node)
+                ? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
     }
     else
 #endif
     {
       if (BIT_STATUS_AT(reg->bt_mem_start, node->regnum))
-	len = SIZE_OP_MEMORY_START_PUSH;
+        len = SIZE_OP_MEMORY_START_PUSH;
       else
-	len = SIZE_OP_MEMORY_START;
+        len = SIZE_OP_MEMORY_START;
 
       len += tlen + (BIT_STATUS_AT(reg->bt_mem_end, node->regnum)
 		     ? SIZE_OP_MEMORY_END_PUSH : SIZE_OP_MEMORY_END);
@@ -1288,11 +1288,11 @@ compile_enclose_node(EncloseNode* node, regex_t* reg)
       len = compile_length_tree(node->target, reg);
       len += (SIZE_OP_MEMORY_START_PUSH + SIZE_OP_RETURN);
       if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
-	len += (IS_ENCLOSE_RECURSION(node)
-		? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
+        len += (IS_ENCLOSE_RECURSION(node)
+                ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
       else
-	len += (IS_ENCLOSE_RECURSION(node)
-		? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
+        len += (IS_ENCLOSE_RECURSION(node)
+                ? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
 
       r = add_opcode_rel_addr(reg, OP_JUMP, len);
       if (r) return r;
@@ -1310,11 +1310,11 @@ compile_enclose_node(EncloseNode* node, regex_t* reg)
 #ifdef USE_SUBEXP_CALL
     if (IS_ENCLOSE_CALLED(node)) {
       if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
-	r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node)
-			     ? OP_MEMORY_END_PUSH_REC : OP_MEMORY_END_PUSH));
+        r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node)
+                             ? OP_MEMORY_END_PUSH_REC : OP_MEMORY_END_PUSH));
       else
-	r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node)
-			     ? OP_MEMORY_END_REC : OP_MEMORY_END));
+        r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node)
+                             ? OP_MEMORY_END_REC : OP_MEMORY_END));
 
       if (r) return r;
       r = add_mem_num(reg, node->regnum);
@@ -1325,9 +1325,9 @@ compile_enclose_node(EncloseNode* node, regex_t* reg)
 #endif
     {
       if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
-	r = add_opcode(reg, OP_MEMORY_END_PUSH);
+        r = add_opcode(reg, OP_MEMORY_END_PUSH);
       else
-	r = add_opcode(reg, OP_MEMORY_END);
+        r = add_opcode(reg, OP_MEMORY_END);
       if (r) return r;
       r = add_mem_num(reg, node->regnum);
     }
@@ -1445,11 +1445,12 @@ compile_anchor_node(AnchorNode* node, regex_t* reg)
       r = add_opcode(reg, OP_LOOK_BEHIND);
       if (r) return r;
       if (node->char_len < 0) {
-	r = get_char_length_tree(node->target, reg, &n);
-	if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
+        r = get_char_length_tree(node->target, reg, &n);
+        if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
       }
       else
-	n = node->char_len;
+        n = node->char_len;
+
       r = add_length(reg, n);
       if (r) return r;
       r = compile_tree(node->target, reg);
@@ -1464,11 +1465,11 @@ compile_anchor_node(AnchorNode* node, regex_t* reg)
 			   len + SIZE_OP_FAIL_LOOK_BEHIND_NOT);
       if (r) return r;
       if (node->char_len < 0) {
-	r = get_char_length_tree(node->target, reg, &n);
-	if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
+        r = get_char_length_tree(node->target, reg, &n);
+        if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
       }
       else
-	n = node->char_len;
+        n = node->char_len;
       r = add_length(reg, n);
       if (r) return r;
       r = compile_tree(node->target, reg);
@@ -1508,8 +1509,8 @@ compile_length_tree(Node* node, regex_t* reg)
 
       n = r = 0;
       do {
-	r += compile_length_tree(NCAR(node), reg);
-	n++;
+        r += compile_length_tree(NCAR(node), reg);
+        n++;
       } while (IS_NOT_NULL(node = NCDR(node)));
       r += (SIZE_OP_PUSH + SIZE_OP_JUMP) * (n - 1);
     }
@@ -1543,11 +1544,11 @@ compile_length_tree(Node* node, regex_t* reg)
       else
 #endif
       if (br->back_num == 1) {
-	r = ((!IS_IGNORECASE(reg->options) && br->back_static[0] <= 2)
-	     ? SIZE_OPCODE : (SIZE_OPCODE + SIZE_MEMNUM));
+        r = ((!IS_IGNORECASE(reg->options) && br->back_static[0] <= 2)
+             ? SIZE_OPCODE : (SIZE_OPCODE + SIZE_MEMNUM));
       }
       else {
-	r = SIZE_OPCODE + SIZE_LENGTH + (SIZE_MEMNUM * br->back_num);
+        r = SIZE_OPCODE + SIZE_LENGTH + (SIZE_MEMNUM * br->back_num);
       }
     }
     break;
@@ -1596,26 +1597,26 @@ compile_tree(Node* node, regex_t* reg)
       Node* x = node;
       len = 0;
       do {
-	len += compile_length_tree(NCAR(x), reg);
-	if (NCDR(x) != NULL) {
-	  len += SIZE_OP_PUSH + SIZE_OP_JUMP;
-	}
+        len += compile_length_tree(NCAR(x), reg);
+        if (NCDR(x) != NULL) {
+          len += SIZE_OP_PUSH + SIZE_OP_JUMP;
+        }
       } while (IS_NOT_NULL(x = NCDR(x)));
       pos = reg->used + len;  /* goal position */
 
       do {
-	len = compile_length_tree(NCAR(node), reg);
-	if (IS_NOT_NULL(NCDR(node))) {
-	  r = add_opcode_rel_addr(reg, OP_PUSH, len + SIZE_OP_JUMP);
-	  if (r) break;
-	}
-	r = compile_tree(NCAR(node), reg);
-	if (r) break;
-	if (IS_NOT_NULL(NCDR(node))) {
-	  len = pos - (reg->used + SIZE_OP_JUMP);
-	  r = add_opcode_rel_addr(reg, OP_JUMP, len);
-	  if (r) break;
-	}
+        len = compile_length_tree(NCAR(node), reg);
+        if (IS_NOT_NULL(NCDR(node))) {
+          r = add_opcode_rel_addr(reg, OP_PUSH, len + SIZE_OP_JUMP);
+          if (r) break;
+        }
+        r = compile_tree(NCAR(node), reg);
+        if (r) break;
+        if (IS_NOT_NULL(NCDR(node))) {
+          len = pos - (reg->used + SIZE_OP_JUMP);
+          r = add_opcode_rel_addr(reg, OP_JUMP, len);
+          if (r) break;
+        }
       } while (IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -1637,12 +1638,12 @@ compile_tree(Node* node, regex_t* reg)
 
       switch (NCTYPE(node)->ctype) {
       case ONIGENC_CTYPE_WORD:
-	if (NCTYPE(node)->not != 0)  op = OP_NOT_WORD;
-	else                         op = OP_WORD;
-	break;
+        if (NCTYPE(node)->not != 0)  op = OP_NOT_WORD;
+        else                         op = OP_WORD;
+        break;
       default:
-	return ONIGERR_TYPE_BUG;
-	break;
+        return ONIGERR_TYPE_BUG;
+        break;
       }
       r = add_opcode(reg, op);
     }
@@ -1661,39 +1662,39 @@ compile_tree(Node* node, regex_t* reg)
 
 #ifdef USE_BACKREF_WITH_LEVEL
       if (IS_BACKREF_NEST_LEVEL(br)) {
-	r = add_opcode(reg, OP_BACKREF_WITH_LEVEL);
-	if (r) return r;
-	r = add_option(reg, (reg->options & ONIG_OPTION_IGNORECASE));
-	if (r) return r;
-	r = add_length(reg, br->nest_level);
-	if (r) return r;
-
-	goto add_bacref_mems;
+        r = add_opcode(reg, OP_BACKREF_WITH_LEVEL);
+        if (r) return r;
+        r = add_option(reg, (reg->options & ONIG_OPTION_IGNORECASE));
+        if (r) return r;
+        r = add_length(reg, br->nest_level);
+        if (r) return r;
+
+        goto add_bacref_mems;
       }
       else
 #endif
       if (br->back_num == 1) {
-	n = br->back_static[0];
-	if (IS_IGNORECASE(reg->options)) {
-	  r = add_opcode(reg, OP_BACKREFN_IC);
-	  if (r) return r;
-	  r = add_mem_num(reg, n);
-	}
-	else {
-	  switch (n) {
-	  case 1:  r = add_opcode(reg, OP_BACKREF1); break;
-	  case 2:  r = add_opcode(reg, OP_BACKREF2); break;
-	  default:
-	    r = add_opcode(reg, OP_BACKREFN);
-	    if (r) return r;
-	    r = add_mem_num(reg, n);
-	    break;
-	  }
-	}
+        n = br->back_static[0];
+        if (IS_IGNORECASE(reg->options)) {
+          r = add_opcode(reg, OP_BACKREFN_IC);
+          if (r) return r;
+          r = add_mem_num(reg, n);
+        }
+        else {
+          switch (n) {
+          case 1:  r = add_opcode(reg, OP_BACKREF1); break;
+          case 2:  r = add_opcode(reg, OP_BACKREF2); break;
+          default:
+            r = add_opcode(reg, OP_BACKREFN);
+            if (r) return r;
+            r = add_mem_num(reg, n);
+            break;
+          }
+        }
       }
       else {
-	int i;
-	int* p;
+        int i;
+        int* p;
 
         if (IS_IGNORECASE(reg->options)) {
           r = add_opcode(reg, OP_BACKREF_MULTI_IC);
@@ -1701,18 +1702,18 @@ compile_tree(Node* node, regex_t* reg)
         else {
           r = add_opcode(reg, OP_BACKREF_MULTI);
         }
-	if (r) return r;
+        if (r) return r;
 
 #ifdef USE_BACKREF_WITH_LEVEL
       add_bacref_mems:
 #endif
-	r = add_length(reg, br->back_num);
-	if (r) return r;
-	p = BACKREFS_P(br);
-	for (i = br->back_num - 1; i >= 0; i--) {
-	  r = add_mem_num(reg, p[i]);
-	  if (r) return r;
-	}
+        r = add_length(reg, br->back_num);
+        if (r) return r;
+        p = BACKREFS_P(br);
+        for (i = br->back_num - 1; i >= 0; i--) {
+          r = add_mem_num(reg, p[i]);
+          if (r) return r;
+        }
       }
     }
     break;
@@ -1767,7 +1768,7 @@ noname_disable_map(Node** plink, GroupNumRemap* map, int* counter)
       Node*  old = *ptarget;
       r = noname_disable_map(ptarget, map, counter);
       if (*ptarget != old && NTYPE(*ptarget) == NT_QTFR) {
-	onig_reduce_nested_quantifier(node, *ptarget);
+        onig_reduce_nested_quantifier(node, *ptarget);
       }
     }
     break;
@@ -1776,21 +1777,21 @@ noname_disable_map(Node** plink, GroupNumRemap* map, int* counter)
     {
       EncloseNode* en = NENCLOSE(node);
       if (en->type == ENCLOSE_MEMORY) {
-	if (IS_ENCLOSE_NAMED_GROUP(en)) {
-	  (*counter)++;
-	  map[en->regnum].new_val = *counter;
-	  en->regnum = *counter;
-	  r = noname_disable_map(&(en->target), map, counter);
-	}
-	else {
-	  *plink = en->target;
-	  en->target = NULL_NODE;
-	  onig_node_free(node);
-	  r = noname_disable_map(plink, map, counter);
-	}
+        if (IS_ENCLOSE_NAMED_GROUP(en)) {
+          (*counter)++;
+          map[en->regnum].new_val = *counter;
+          en->regnum = *counter;
+          r = noname_disable_map(&(en->target), map, counter);
+        }
+        else {
+          *plink = en->target;
+          en->target = NULL_NODE;
+          onig_node_free(node);
+          r = noname_disable_map(plink, map, counter);
+        }
       }
       else
-	r = noname_disable_map(&(en->target), map, counter);
+        r = noname_disable_map(&(en->target), map, counter);
     }
     break;
 
@@ -1963,8 +1964,8 @@ quantifiers_memory_node_info(Node* node)
     {
       int v;
       do {
-	v = quantifiers_memory_node_info(NCAR(node));
-	if (v > r) r = v;
+        v = quantifiers_memory_node_info(NCAR(node));
+        if (v > r) r = v;
       } while (v >= 0 && IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -1983,7 +1984,7 @@ quantifiers_memory_node_info(Node* node)
     {
       QtfrNode* qn = NQTFR(node);
       if (qn->upper != 0) {
-	r = quantifiers_memory_node_info(qn->target);
+        r = quantifiers_memory_node_info(qn->target);
       }
     }
     break;
@@ -1993,15 +1994,15 @@ quantifiers_memory_node_info(Node* node)
       EncloseNode* en = NENCLOSE(node);
       switch (en->type) {
       case ENCLOSE_MEMORY:
-	return NQ_TARGET_IS_EMPTY_MEM;
-	break;
+        return NQ_TARGET_IS_EMPTY_MEM;
+        break;
 
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
-	r = quantifiers_memory_node_info(en->target);
-	break;
+        r = quantifiers_memory_node_info(en->target);
+        break;
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2041,10 +2042,10 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       r = get_min_match_length(nodes[backs[0]], min, env);
       if (r != 0) break;
       for (i = 1; i < br->back_num; i++) {
-	if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
-	r = get_min_match_length(nodes[backs[i]], &tmin, env);
-	if (r != 0) break;
-	if (*min > tmin) *min = tmin;
+        if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
+        r = get_min_match_length(nodes[backs[i]], &tmin, env);
+        if (r != 0) break;
+        if (*min > tmin) *min = tmin;
       }
     }
     break;
@@ -2054,7 +2055,7 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
     if (IS_CALL_RECURSION(NCALL(node))) {
       EncloseNode* en = NENCLOSE(NCALL(node)->target);
       if (IS_ENCLOSE_MIN_FIXED(en))
-	*min = en->min_len;
+        *min = en->min_len;
     }
     else
       r = get_min_match_length(NCALL(node)->target, min, env);
@@ -2073,11 +2074,11 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       Node *x, *y;
       y = node;
       do {
-	x = NCAR(y);
-	r = get_min_match_length(x, &tmin, env);
-	if (r != 0) break;
-	if (y == node) *min = tmin;
-	else if (*min > tmin) *min = tmin;
+        x = NCAR(y);
+        r = get_min_match_length(x, &tmin, env);
+        if (r != 0) break;
+        if (y == node) *min = tmin;
+        else if (*min > tmin) *min = tmin;
       } while (r == 0 && IS_NOT_NULL(y = NCDR(y)));
     }
     break;
@@ -2103,9 +2104,9 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       QtfrNode* qn = NQTFR(node);
 
       if (qn->lower > 0) {
-	r = get_min_match_length(qn->target, min, env);
-	if (r == 0)
-	  *min = distance_multiply(*min, qn->lower);
+        r = get_min_match_length(qn->target, min, env);
+        if (r == 0)
+          *min = distance_multiply(*min, qn->lower);
       }
     }
     break;
@@ -2116,21 +2117,21 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       switch (en->type) {
       case ENCLOSE_MEMORY:
 #ifdef USE_SUBEXP_CALL
-	if (IS_ENCLOSE_MIN_FIXED(en))
-	  *min = en->min_len;
-	else {
-	  r = get_min_match_length(en->target, min, env);
-	  if (r == 0) {
-	    en->min_len = *min;
-	    SET_ENCLOSE_STATUS(node, NST_MIN_FIXED);
-	  }
-	}
-	break;
+        if (IS_ENCLOSE_MIN_FIXED(en))
+          *min = en->min_len;
+        else {
+          r = get_min_match_length(en->target, min, env);
+          if (r == 0) {
+            en->min_len = *min;
+            SET_ENCLOSE_STATUS(node, NST_MIN_FIXED);
+          }
+        }
+        break;
 #endif
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
-	r = get_min_match_length(en->target, min, env);
-	break;
+        r = get_min_match_length(en->target, min, env);
+        break;
       }
     }
     break;
@@ -2155,7 +2156,7 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
     do {
       r = get_max_match_length(NCAR(node), &tmax, env);
       if (r == 0)
-	*max = distance_add(*max, tmax);
+        *max = distance_add(*max, tmax);
     } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
     break;
 
@@ -2189,15 +2190,15 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
       Node** nodes = SCANENV_MEM_NODES(env);
       BRefNode* br = NBREF(node);
       if (br->state & NST_RECURSION) {
-	*max = ONIG_INFINITE_DISTANCE;
-	break;
+        *max = ONIG_INFINITE_DISTANCE;
+        break;
       }
       backs = BACKREFS_P(br);
       for (i = 0; i < br->back_num; i++) {
-	if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
-	r = get_max_match_length(nodes[backs[i]], &tmax, env);
-	if (r != 0) break;
-	if (*max < tmax) *max = tmax;
+        if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
+        r = get_max_match_length(nodes[backs[i]], &tmax, env);
+        if (r != 0) break;
+        if (*max < tmax) *max = tmax;
       }
     }
     break;
@@ -2216,13 +2217,13 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
       QtfrNode* qn = NQTFR(node);
 
       if (qn->upper != 0) {
-	r = get_max_match_length(qn->target, max, env);
-	if (r == 0 && *max != 0) {
-	  if (! IS_REPEAT_INFINITE(qn->upper))
-	    *max = distance_multiply(*max, qn->upper);
-	  else
-	    *max = ONIG_INFINITE_DISTANCE;
-	}
+        r = get_max_match_length(qn->target, max, env);
+        if (r == 0 && *max != 0) {
+          if (! IS_REPEAT_INFINITE(qn->upper))
+            *max = distance_multiply(*max, qn->upper);
+          else
+            *max = ONIG_INFINITE_DISTANCE;
+        }
       }
     }
     break;
@@ -2246,8 +2247,8 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
 #endif
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
-	r = get_max_match_length(en->target, max, env);
-	break;
+        r = get_max_match_length(en->target, max, env);
+        break;
       }
     }
     break;
@@ -2277,7 +2278,7 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
     do {
       r = get_char_length_tree1(NCAR(node), reg, &tlen, level);
       if (r == 0)
-	*len = distance_add(*len, tlen);
+        *len = distance_add(*len, tlen);
     } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
     break;
 
@@ -2288,21 +2289,21 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
 
       r = get_char_length_tree1(NCAR(node), reg, &tlen, level);
       while (r == 0 && IS_NOT_NULL(node = NCDR(node))) {
-	r = get_char_length_tree1(NCAR(node), reg, &tlen2, level);
-	if (r == 0) {
-	  if (tlen != tlen2)
-	    varlen = 1;
-	}
+        r = get_char_length_tree1(NCAR(node), reg, &tlen2, level);
+        if (r == 0) {
+          if (tlen != tlen2)
+            varlen = 1;
+        }
       }
       if (r == 0) {
-	if (varlen != 0) {
-	  if (level == 1)
-	    r = GET_CHAR_LEN_TOP_ALT_VARLEN;
-	  else
-	    r = GET_CHAR_LEN_VARLEN;
-	}
-	else
-	  *len = tlen;
+        if (varlen != 0) {
+          if (level == 1)
+            r = GET_CHAR_LEN_TOP_ALT_VARLEN;
+          else
+            r = GET_CHAR_LEN_VARLEN;
+        }
+        else
+          *len = tlen;
       }
     }
     break;
@@ -2312,8 +2313,8 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
       StrNode* sn = NSTR(node);
       UChar *s = sn->s;
       while (s < sn->end) {
-	s += enclen(reg->enc, s);
-	(*len)++;
+        s += enclen(reg->enc, s);
+        (*len)++;
       }
     }
     break;
@@ -2322,12 +2323,12 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
     {
       QtfrNode* qn = NQTFR(node);
       if (qn->lower == qn->upper) {
-	r = get_char_length_tree1(qn->target, reg, &tlen, level);
-	if (r == 0)
-	  *len = distance_multiply(tlen, qn->lower);
+        r = get_char_length_tree1(qn->target, reg, &tlen, level);
+        if (r == 0)
+          *len = distance_multiply(tlen, qn->lower);
       }
       else
-	r = GET_CHAR_LEN_VARLEN;
+        r = GET_CHAR_LEN_VARLEN;
     }
     break;
 
@@ -2368,10 +2369,10 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
 #endif
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
-	r = get_char_length_tree1(en->target, reg, len, level);
-	break;
+        r = get_char_length_tree1(en->target, reg, len, level);
+        break;
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2409,28 +2410,28 @@ is_not_included(Node* x, Node* y, regex_t* reg)
     {
       switch (ytype) {
       case NT_CTYPE:
-	if (NCTYPE(y)->ctype == NCTYPE(x)->ctype &&
-	    NCTYPE(y)->not   != NCTYPE(x)->not)
-	  return 1;
-	else
-	  return 0;
-	break;
+        if (NCTYPE(y)->ctype == NCTYPE(x)->ctype &&
+            NCTYPE(y)->not   != NCTYPE(x)->not)
+          return 1;
+        else
+          return 0;
+        break;
 
       case NT_CCLASS:
       swap:
-	{
-	  Node* tmp;
-	  tmp = x; x = y; y = tmp;
-	  goto retry;
-	}
-	break;
+        {
+          Node* tmp;
+          tmp = x; x = y; y = tmp;
+          goto retry;
+        }
+        break;
 
       case NT_STR:
-	goto swap;
-	break;
+        goto swap;
+        break;
 
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2440,69 +2441,69 @@ is_not_included(Node* x, Node* y, regex_t* reg)
       CClassNode* xc = NCCLASS(x);
       switch (ytype) {
       case NT_CTYPE:
-	switch (NCTYPE(y)->ctype) {
-	case ONIGENC_CTYPE_WORD:
-	  if (NCTYPE(y)->not == 0) {
-	    if (IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) {
-	      for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-		if (BITSET_AT(xc->bs, i)) {
-		  if (IS_CODE_SB_WORD(reg->enc, i)) return 0;
-		}
-	      }
-	      return 1;
-	    }
-	    return 0;
-	  }
-	  else {
-	    for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-	      if (! IS_CODE_SB_WORD(reg->enc, i)) {
-		if (!IS_NCCLASS_NOT(xc)) {
-		  if (BITSET_AT(xc->bs, i))
-		    return 0;
-		}
-		else {
-		  if (! BITSET_AT(xc->bs, i))
-		    return 0;
-		}
-	      }
-	    }
-	    return 1;
-	  }
-	  break;
+        switch (NCTYPE(y)->ctype) {
+        case ONIGENC_CTYPE_WORD:
+          if (NCTYPE(y)->not == 0) {
+            if (IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) {
+              for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+                if (BITSET_AT(xc->bs, i)) {
+                  if (IS_CODE_SB_WORD(reg->enc, i)) return 0;
+                }
+              }
+              return 1;
+            }
+            return 0;
+          }
+          else {
+            for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+              if (! IS_CODE_SB_WORD(reg->enc, i)) {
+                if (!IS_NCCLASS_NOT(xc)) {
+                  if (BITSET_AT(xc->bs, i))
+                    return 0;
+                }
+                else {
+                  if (! BITSET_AT(xc->bs, i))
+                    return 0;
+                }
+              }
+            }
+            return 1;
+          }
+          break;
 
-	default:
-	  break;
-	}
-	break;
+        default:
+          break;
+        }
+        break;
 
       case NT_CCLASS:
-	{
-	  int v;
-	  CClassNode* yc = NCCLASS(y);
+        {
+          int v;
+          CClassNode* yc = NCCLASS(y);
 
-	  for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-	    v = BITSET_AT(xc->bs, i);
-	    if ((v != 0 && !IS_NCCLASS_NOT(xc)) ||
+          for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+            v = BITSET_AT(xc->bs, i);
+            if ((v != 0 && !IS_NCCLASS_NOT(xc)) ||
                 (v == 0 && IS_NCCLASS_NOT(xc))) {
-	      v = BITSET_AT(yc->bs, i);
-	      if ((v != 0 && !IS_NCCLASS_NOT(yc)) ||
+              v = BITSET_AT(yc->bs, i);
+              if ((v != 0 && !IS_NCCLASS_NOT(yc)) ||
                   (v == 0 && IS_NCCLASS_NOT(yc)))
-		return 0;
-	    }
-	  }
-	  if ((IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) ||
-	      (IS_NULL(yc->mbuf) && !IS_NCCLASS_NOT(yc)))
-	    return 1;
-	  return 0;
-	}
-	break;
+                return 0;
+            }
+          }
+          if ((IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) ||
+              (IS_NULL(yc->mbuf) && !IS_NCCLASS_NOT(yc)))
+            return 1;
+          return 0;
+        }
+        break;
 
       case NT_STR:
-	goto swap;
-	break;
+        goto swap;
+        break;
 
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2511,7 +2512,7 @@ is_not_included(Node* x, Node* y, regex_t* reg)
     {
       StrNode* xs = NSTR(x);
       if (NSTRING_LEN(x) == 0)
-	break;
+        break;
 
       //c = *(xs->s);
       switch (ytype) {
@@ -2599,13 +2600,13 @@ get_head_value_node(Node* node, int exact, regex_t* reg)
       StrNode* sn = NSTR(node);
 
       if (sn->end <= sn->s)
-	break;
+        break;
 
       if (exact != 0 &&
-	  !NSTRING_IS_RAW(node) && IS_IGNORECASE(reg->options)) {
+          !NSTRING_IS_RAW(node) && IS_IGNORECASE(reg->options)) {
       }
       else {
-	n = node;
+        n = node;
       }
     }
     break;
@@ -2614,10 +2615,10 @@ get_head_value_node(Node* node, int exact, regex_t* reg)
     {
       QtfrNode* qn = NQTFR(node);
       if (qn->lower > 0) {
-	if (IS_NOT_NULL(qn->head_exact))
-	  n = qn->head_exact;
-	else
-	  n = get_head_value_node(qn->target, exact, reg);
+        if (IS_NOT_NULL(qn->head_exact))
+          n = qn->head_exact;
+        else
+          n = get_head_value_node(qn->target, exact, reg);
       }
     }
     break;
@@ -2627,19 +2628,19 @@ get_head_value_node(Node* node, int exact, regex_t* reg)
       EncloseNode* en = NENCLOSE(node);
       switch (en->type) {
       case ENCLOSE_OPTION:
-	{
-	  OnigOptionType options = reg->options;
+        {
+          OnigOptionType options = reg->options;
 
-	  reg->options = NENCLOSE(node)->option;
-	  n = get_head_value_node(NENCLOSE(node)->target, exact, reg);
-	  reg->options = options;
-	}
-	break;
+          reg->options = NENCLOSE(node)->option;
+          n = get_head_value_node(NENCLOSE(node)->target, exact, reg);
+          reg->options = options;
+        }
+        break;
 
       case ENCLOSE_MEMORY:
       case ENCLOSE_STOP_BACKTRACK:
-	n = get_head_value_node(en->target, exact, reg);
-	break;
+        n = get_head_value_node(en->target, exact, reg);
+        break;
       }
     }
     break;
@@ -2670,20 +2671,20 @@ check_type_tree(Node* node, int type_mask, int enclose_mask, int anchor_mask)
   case NT_ALT:
     do {
       r = check_type_tree(NCAR(node), type_mask, enclose_mask,
-			  anchor_mask);
+                          anchor_mask);
     } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
     break;
 
   case NT_QTFR:
     r = check_type_tree(NQTFR(node)->target, type_mask, enclose_mask,
-			anchor_mask);
+                        anchor_mask);
     break;
 
   case NT_ENCLOSE:
     {
       EncloseNode* en = NENCLOSE(node);
       if ((en->type & enclose_mask) == 0)
-	return 1;
+        return 1;
 
       r = check_type_tree(en->target, type_mask, enclose_mask, anchor_mask);
     }
@@ -2726,14 +2727,14 @@ subexp_inf_recursive_check(Node* node, ScanEnv* env, int head)
 
       x = node;
       do {
-	ret = subexp_inf_recursive_check(NCAR(x), env, head);
-	if (ret < 0 || ret == RECURSION_INFINITE) return ret;
-	r |= ret;
-	if (head) {
-	  ret = get_min_match_length(NCAR(x), &min, env);
-	  if (ret != 0) return ret;
-	  if (min != 0) head = 0;
-	}
+        ret = subexp_inf_recursive_check(NCAR(x), env, head);
+        if (ret < 0 || ret == RECURSION_INFINITE) return ret;
+        r |= ret;
+        if (head) {
+          ret = get_min_match_length(NCAR(x), &min, env);
+          if (ret != 0) return ret;
+          if (min != 0) head = 0;
+        }
       } while (IS_NOT_NULL(x = NCDR(x)));
     }
     break;
@@ -2743,9 +2744,9 @@ subexp_inf_recursive_check(Node* node, ScanEnv* env, int head)
       int ret;
       r = RECURSION_EXIST;
       do {
-	ret = subexp_inf_recursive_check(NCAR(node), env, head);
-	if (ret < 0 || ret == RECURSION_INFINITE) return ret;
-	r &= ret;
+        ret = subexp_inf_recursive_check(NCAR(node), env, head);
+        if (ret < 0 || ret == RECURSION_INFINITE) return ret;
+        r &= ret;
       } while (IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -2765,8 +2766,8 @@ subexp_inf_recursive_check(Node* node, ScanEnv* env, int head)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = subexp_inf_recursive_check(an->target, env, head);
-	break;
+        r = subexp_inf_recursive_check(an->target, env, head);
+        break;
       }
     }
     break;
@@ -2821,8 +2822,8 @@ subexp_inf_recursive_check_trav(Node* node, ScanEnv* env)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = subexp_inf_recursive_check_trav(an->target, env);
-	break;
+        r = subexp_inf_recursive_check_trav(an->target, env);
+        break;
       }
     }
     break;
@@ -2832,14 +2833,13 @@ subexp_inf_recursive_check_trav(Node* node, ScanEnv* env)
       EncloseNode* en = NENCLOSE(node);
 
       if (IS_ENCLOSE_RECURSION(en)) {
-	SET_ENCLOSE_STATUS(node, NST_MARK1);
-	r = subexp_inf_recursive_check(en->target, env, 1);
-	if (r > 0) return ONIGERR_NEVER_ENDING_RECURSION;
-	CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
+        SET_ENCLOSE_STATUS(node, NST_MARK1);
+        r = subexp_inf_recursive_check(en->target, env, 1);
+        if (r > 0) return ONIGERR_NEVER_ENDING_RECURSION;
+        CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
       }
       r = subexp_inf_recursive_check_trav(en->target, env);
     }
-
     break;
 
   default:
@@ -2874,8 +2874,8 @@ subexp_recursive_check(Node* node)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = subexp_recursive_check(an->target);
-	break;
+        r = subexp_recursive_check(an->target);
+        break;
       }
     }
     break;
@@ -2920,9 +2920,9 @@ subexp_recursive_check_trav(Node* node, ScanEnv* env)
     {
       int ret;
       do {
-	ret = subexp_recursive_check_trav(NCAR(node), env);
-	if (ret == FOUND_CALLED_NODE) r = FOUND_CALLED_NODE;
-	else if (ret < 0) return ret;
+        ret = subexp_recursive_check_trav(NCAR(node), env);
+        if (ret == FOUND_CALLED_NODE) r = FOUND_CALLED_NODE;
+        else if (ret < 0) return ret;
       } while (IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -2931,7 +2931,7 @@ subexp_recursive_check_trav(Node* node, ScanEnv* env)
     r = subexp_recursive_check_trav(NQTFR(node)->target, env);
     if (NQTFR(node)->upper == 0) {
       if (r == FOUND_CALLED_NODE)
-	NQTFR(node)->is_refered = 1;
+        NQTFR(node)->is_refered = 1;
     }
     break;
 
@@ -2943,8 +2943,8 @@ subexp_recursive_check_trav(Node* node, ScanEnv* env)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = subexp_recursive_check_trav(an->target, env);
-	break;
+        r = subexp_recursive_check_trav(an->target, env);
+        break;
       }
     }
     break;
@@ -2954,16 +2954,16 @@ subexp_recursive_check_trav(Node* node, ScanEnv* env)
       EncloseNode* en = NENCLOSE(node);
 
       if (! IS_ENCLOSE_RECURSION(en)) {
-	if (IS_ENCLOSE_CALLED(en)) {
-	  SET_ENCLOSE_STATUS(node, NST_MARK1);
-	  r = subexp_recursive_check(en->target);
-	  if (r != 0) SET_ENCLOSE_STATUS(node, NST_RECURSION);
-	  CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
-	}
+        if (IS_ENCLOSE_CALLED(en)) {
+          SET_ENCLOSE_STATUS(node, NST_MARK1);
+          r = subexp_recursive_check(en->target);
+          if (r != 0) SET_ENCLOSE_STATUS(node, NST_RECURSION);
+          CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
+        }
       }
       r = subexp_recursive_check_trav(en->target, env);
       if (IS_ENCLOSE_CALLED(en))
-	r |= FOUND_CALLED_NODE;
+        r |= FOUND_CALLED_NODE;
     }
     break;
 
@@ -3007,54 +3007,54 @@ setup_subexp_call(Node* node, ScanEnv* env)
       Node** nodes = SCANENV_MEM_NODES(env);
 
       if (cn->group_num != 0) {
-	int gnum = cn->group_num;
+        int gnum = cn->group_num;
 
 #ifdef USE_NAMED_GROUP
-	if (env->num_named > 0 &&
-	    IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&
-	    !ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_CAPTURE_GROUP)) {
-	  return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
-	}
+        if (env->num_named > 0 &&
+            IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&
+            !ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_CAPTURE_GROUP)) {
+          return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
+        }
 #endif
-	if (gnum > env->num_mem) {
-	  onig_scan_env_set_error_string(env,
-		 ONIGERR_UNDEFINED_GROUP_REFERENCE, cn->name, cn->name_end);
-	  return ONIGERR_UNDEFINED_GROUP_REFERENCE;
-	}
+        if (gnum > env->num_mem) {
+          onig_scan_env_set_error_string(env,
+                   ONIGERR_UNDEFINED_GROUP_REFERENCE, cn->name, cn->name_end);
+          return ONIGERR_UNDEFINED_GROUP_REFERENCE;
+        }
 
 #ifdef USE_NAMED_GROUP
       set_call_attr:
 #endif
-	cn->target = nodes[cn->group_num];
-	if (IS_NULL(cn->target)) {
-	  onig_scan_env_set_error_string(env,
-		 ONIGERR_UNDEFINED_NAME_REFERENCE, cn->name, cn->name_end);
-	  return ONIGERR_UNDEFINED_NAME_REFERENCE;
-	}
-	SET_ENCLOSE_STATUS(cn->target, NST_CALLED);
-	BIT_STATUS_ON_AT(env->bt_mem_start, cn->group_num);
-	cn->unset_addr_list = env->unset_addr_list;
+        cn->target = nodes[cn->group_num];
+        if (IS_NULL(cn->target)) {
+          onig_scan_env_set_error_string(env,
+                   ONIGERR_UNDEFINED_NAME_REFERENCE, cn->name, cn->name_end);
+          return ONIGERR_UNDEFINED_NAME_REFERENCE;
+        }
+        SET_ENCLOSE_STATUS(cn->target, NST_CALLED);
+        BIT_STATUS_ON_AT(env->bt_mem_start, cn->group_num);
+        cn->unset_addr_list = env->unset_addr_list;
       }
 #ifdef USE_NAMED_GROUP
       else {
-	int *refs;
-
-	int n = onig_name_to_group_numbers(env->reg, cn->name, cn->name_end,
-					   &refs);
-	if (n <= 0) {
-	  onig_scan_env_set_error_string(env,
-		 ONIGERR_UNDEFINED_NAME_REFERENCE, cn->name, cn->name_end);
-	  return ONIGERR_UNDEFINED_NAME_REFERENCE;
-	}
-	else if (n > 1) {
-	  onig_scan_env_set_error_string(env,
-	    ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL, cn->name, cn->name_end);
-	  return ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL;
-	}
-	else {
-	  cn->group_num = refs[0];
-	  goto set_call_attr;
-	}
+        int *refs;
+
+        int n = onig_name_to_group_numbers(env->reg, cn->name, cn->name_end,
+                                           &refs);
+        if (n <= 0) {
+          onig_scan_env_set_error_string(env,
+                   ONIGERR_UNDEFINED_NAME_REFERENCE, cn->name, cn->name_end);
+          return ONIGERR_UNDEFINED_NAME_REFERENCE;
+        }
+        else if (n > 1) {
+          onig_scan_env_set_error_string(env,
+               ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL, cn->name, cn->name_end);
+          return ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL;
+        }
+        else {
+          cn->group_num = refs[0];
+          goto set_call_attr;
+        }
       }
 #endif
     }
@@ -3069,8 +3069,8 @@ setup_subexp_call(Node* node, ScanEnv* env)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = setup_subexp_call(an->target, env);
-	break;
+        r = setup_subexp_call(an->target, env);
+        break;
       }
     }
     break;
@@ -3152,26 +3152,26 @@ next_setup(Node* node, Node* next_node, regex_t* reg)
       Node* n = get_head_value_node(next_node, 1, reg);
       /* '\0': for UTF-16BE etc... */
       if (IS_NOT_NULL(n) && NSTR(n)->s[0] != '\0') {
-	qn->next_head_exact = n;
+        qn->next_head_exact = n;
       }
 #endif
       /* automatic posseivation a*b ==> (?>a*)b */
       if (qn->lower <= 1) {
-	int ttype = NTYPE(qn->target);
-	if (IS_NODE_TYPE_SIMPLE(ttype)) {
-	  Node *x, *y;
-	  x = get_head_value_node(qn->target, 0, reg);
-	  if (IS_NOT_NULL(x)) {
-	    y = get_head_value_node(next_node,  0, reg);
-	    if (IS_NOT_NULL(y) && is_not_included(x, y, reg)) {
-	      Node* en = onig_node_new_enclose(ENCLOSE_STOP_BACKTRACK);
-	      CHECK_NULL_RETURN_MEMERR(en);
-	      SET_ENCLOSE_STATUS(en, NST_STOP_BT_SIMPLE_REPEAT);
-	      swap_node(node, en);
-	      NENCLOSE(node)->target = en;
-	    }
-	  }
-	}
+        int ttype = NTYPE(qn->target);
+        if (IS_NODE_TYPE_SIMPLE(ttype)) {
+          Node *x, *y;
+          x = get_head_value_node(qn->target, 0, reg);
+          if (IS_NOT_NULL(x)) {
+            y = get_head_value_node(next_node,  0, reg);
+            if (IS_NOT_NULL(y) && is_not_included(x, y, reg)) {
+              Node* en = onig_node_new_enclose(ENCLOSE_STOP_BACKTRACK);
+              CHECK_NULL_RETURN_MEMERR(en);
+              SET_ENCLOSE_STATUS(en, NST_STOP_BT_SIMPLE_REPEAT);
+              swap_node(node, en);
+              NENCLOSE(node)->target = en;
+            }
+          }
+        }
       }
     }
   }
@@ -3297,8 +3297,8 @@ expand_case_fold_string_alt(int item_num, OnigCaseFoldCodeItem items[],
     for (j = 0; j < items[i].code_len; j++) {
       len = ONIGENC_CODE_TO_MBC(reg->enc, items[i].code[j], buf);
       if (len < 0) {
-	r = len;
-	goto mem_err2;
+        r = len;
+        goto mem_err2;
       }
 
       r = onig_node_str_cat(snode, buf, buf + len);
@@ -3394,22 +3394,22 @@ expand_case_fold_string(Node* node, regex_t* reg)
 
     if (n == 0) {
       if (IS_NULL(snode)) {
-	if (IS_NULL(root) && IS_NOT_NULL(prev_node)) {
-	  top_root = root = onig_node_list_add(NULL_NODE, prev_node);
-	  if (IS_NULL(root)) {
-	    onig_node_free(prev_node);
-	    goto mem_err;
-	  }
-	}
+        if (IS_NULL(root) && IS_NOT_NULL(prev_node)) {
+          top_root = root = onig_node_list_add(NULL_NODE, prev_node);
+          if (IS_NULL(root)) {
+            onig_node_free(prev_node);
+            goto mem_err;
+          }
+        }
 
-	prev_node = snode = onig_node_new_str(NULL, NULL);
-	if (IS_NULL(snode)) goto mem_err;
-	if (IS_NOT_NULL(root)) {
-	  if (IS_NULL(onig_node_list_add(root, snode))) {
-	    onig_node_free(snode);
-	    goto mem_err;
-	  }
-	}
+        prev_node = snode = onig_node_new_str(NULL, NULL);
+        if (IS_NULL(snode)) goto mem_err;
+        if (IS_NOT_NULL(root)) {
+          if (IS_NULL(onig_node_list_add(root, snode))) {
+            onig_node_free(snode);
+            goto mem_err;
+          }
+        }
       }
 
       r = onig_node_str_cat(snode, p, p + len);
@@ -3420,35 +3420,35 @@ expand_case_fold_string(Node* node, regex_t* reg)
       if (alt_num > THRESHOLD_CASE_FOLD_ALT_FOR_EXPANSION) break;
 
       if (IS_NULL(root) && IS_NOT_NULL(prev_node)) {
-	top_root = root = onig_node_list_add(NULL_NODE, prev_node);
-	if (IS_NULL(root)) {
-	  onig_node_free(prev_node);
-	  goto mem_err;
-	}
+        top_root = root = onig_node_list_add(NULL_NODE, prev_node);
+        if (IS_NULL(root)) {
+          onig_node_free(prev_node);
+          goto mem_err;
+        }
       }
 
       r = expand_case_fold_string_alt(n, items, p, len, end, reg, &prev_node);
       if (r < 0) goto mem_err;
       if (r == 1) {
-	if (IS_NULL(root)) {
-	  top_root = prev_node;
-	}
-	else {
-	  if (IS_NULL(onig_node_list_add(root, prev_node))) {
-	    onig_node_free(prev_node);
-	    goto mem_err;
-	  }
-	}
+        if (IS_NULL(root)) {
+          top_root = prev_node;
+        }
+        else {
+          if (IS_NULL(onig_node_list_add(root, prev_node))) {
+            onig_node_free(prev_node);
+            goto mem_err;
+          }
+        }
 
-	root = NCAR(prev_node);
+        root = NCAR(prev_node);
       }
       else { /* r == 0 */
-	if (IS_NOT_NULL(root)) {
-	  if (IS_NULL(onig_node_list_add(root, prev_node))) {
-	    onig_node_free(prev_node);
-	    goto mem_err;
-	  }
-	}
+        if (IS_NOT_NULL(root)) {
+          if (IS_NULL(onig_node_list_add(root, prev_node))) {
+            onig_node_free(prev_node);
+            goto mem_err;
+          }
+        }
       }
 
       snode = NULL_NODE;
@@ -3466,9 +3466,9 @@ expand_case_fold_string(Node* node, regex_t* reg)
     if (IS_NOT_NULL(prev_node) && IS_NULL(root)) {
       top_root = root = onig_node_list_add(NULL_NODE, prev_node);
       if (IS_NULL(root)) {
-	onig_node_free(srem);
-	onig_node_free(prev_node);
-	goto mem_err;
+        onig_node_free(srem);
+        onig_node_free(prev_node);
+        goto mem_err;
       }
     }
 
@@ -3477,8 +3477,8 @@ expand_case_fold_string(Node* node, regex_t* reg)
     }
     else {
       if (IS_NULL(onig_node_list_add(root, srem))) {
-	onig_node_free(srem);
-	goto mem_err;
+        onig_node_free(srem);
+        goto mem_err;
       }
     }
   }
@@ -3519,8 +3519,8 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
     {
       Node* prev = NULL_NODE;
       do {
-	r = setup_comb_exp_check(NCAR(node), r, env);
-	prev = NCAR(node);
+        r = setup_comb_exp_check(NCAR(node), r, env);
+        prev = NCAR(node);
       } while (r >= 0 && IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -3529,8 +3529,8 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
     {
       int ret;
       do {
-	ret = setup_comb_exp_check(NCAR(node), state, env);
-	r |= ret;
+        ret = setup_comb_exp_check(NCAR(node), state, env);
+        r |= ret;
       } while (ret >= 0 && IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -3544,55 +3544,55 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
       int var_num;
 
       if (! IS_REPEAT_INFINITE(qn->upper)) {
-	if (qn->upper > 1) {
-	  /* {0,1}, {1,1} are allowed */
-	  child_state |= CEC_IN_FINITE_REPEAT;
-
-	  /* check (a*){n,m}, (a+){n,m} => (a*){n,n}, (a+){n,n} */
-	  if (env->backrefed_mem == 0) {
-	    if (NTYPE(qn->target) == NT_ENCLOSE) {
-	      EncloseNode* en = NENCLOSE(qn->target);
-	      if (en->type == ENCLOSE_MEMORY) {
-		if (NTYPE(en->target) == NT_QTFR) {
-		  QtfrNode* q = NQTFR(en->target);
-		  if (IS_REPEAT_INFINITE(q->upper)
-		      && q->greedy == qn->greedy) {
-		    qn->upper = (qn->lower == 0 ? 1 : qn->lower);
-		    if (qn->upper == 1)
-		      child_state = state;
-		  }
-		}
-	      }
-	    }
-	  }
-	}
+        if (qn->upper > 1) {
+          /* {0,1}, {1,1} are allowed */
+          child_state |= CEC_IN_FINITE_REPEAT;
+
+          /* check (a*){n,m}, (a+){n,m} => (a*){n,n}, (a+){n,n} */
+          if (env->backrefed_mem == 0) {
+            if (NTYPE(qn->target) == NT_ENCLOSE) {
+              EncloseNode* en = NENCLOSE(qn->target);
+              if (en->type == ENCLOSE_MEMORY) {
+                if (NTYPE(en->target) == NT_QTFR) {
+                  QtfrNode* q = NQTFR(en->target);
+                  if (IS_REPEAT_INFINITE(q->upper)
+                      && q->greedy == qn->greedy) {
+                    qn->upper = (qn->lower == 0 ? 1 : qn->lower);
+                    if (qn->upper == 1)
+                      child_state = state;
+                  }
+                }
+              }
+            }
+          }
+        }
       }
 
       if (state & CEC_IN_FINITE_REPEAT) {
-	qn->comb_exp_check_num = -1;
+        qn->comb_exp_check_num = -1;
       }
       else {
-	if (IS_REPEAT_INFINITE(qn->upper)) {
-	  var_num = CEC_INFINITE_NUM;
-	  child_state |= CEC_IN_INFINITE_REPEAT;
-	}
-	else {
-	  var_num = qn->upper - qn->lower;
-	}
+        if (IS_REPEAT_INFINITE(qn->upper)) {
+          var_num = CEC_INFINITE_NUM;
+          child_state |= CEC_IN_INFINITE_REPEAT;
+        }
+        else {
+          var_num = qn->upper - qn->lower;
+        }
 
-	if (var_num >= CEC_THRES_NUM_BIG_REPEAT)
-	  add_state |= CEC_CONT_BIG_REPEAT;
-
-	if (((state & CEC_IN_INFINITE_REPEAT) != 0 && var_num != 0) ||
-	    ((state & CEC_CONT_BIG_REPEAT) != 0 &&
-	     var_num >= CEC_THRES_NUM_BIG_REPEAT)) {
-	  if (qn->comb_exp_check_num == 0) {
-	    env->num_comb_exp_check++;
-	    qn->comb_exp_check_num = env->num_comb_exp_check;
-	    if (env->curr_max_regnum > env->comb_exp_max_regnum)
-	      env->comb_exp_max_regnum = env->curr_max_regnum;
-	  }
-	}
+        if (var_num >= CEC_THRES_NUM_BIG_REPEAT)
+          add_state |= CEC_CONT_BIG_REPEAT;
+
+        if (((state & CEC_IN_INFINITE_REPEAT) != 0 && var_num != 0) ||
+            ((state & CEC_CONT_BIG_REPEAT) != 0 &&
+             var_num >= CEC_THRES_NUM_BIG_REPEAT)) {
+          if (qn->comb_exp_check_num == 0) {
+            env->num_comb_exp_check++;
+            qn->comb_exp_check_num = env->num_comb_exp_check;
+            if (env->curr_max_regnum > env->comb_exp_max_regnum)
+              env->comb_exp_max_regnum = env->curr_max_regnum;
+          }
+        }
       }
 
       r = setup_comb_exp_check(target, child_state, env);
@@ -3606,17 +3606,17 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
 
       switch (en->type) {
       case ENCLOSE_MEMORY:
-	{
-	  if (env->curr_max_regnum < en->regnum)
-	    env->curr_max_regnum = en->regnum;
+        {
+          if (env->curr_max_regnum < en->regnum)
+            env->curr_max_regnum = en->regnum;
 
-	  r = setup_comb_exp_check(en->target, state, env);
-	}
-	break;
+          r = setup_comb_exp_check(en->target, state, env);
+        }
+        break;
 
       default:
-	r = setup_comb_exp_check(en->target, state, env);
-	break;
+        r = setup_comb_exp_check(en->target, state, env);
+        break;
       }
     }
     break;
@@ -3663,11 +3663,11 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
     {
       Node* prev = NULL_NODE;
       do {
-	r = setup_tree(NCAR(node), reg, state, env);
-	if (IS_NOT_NULL(prev) && r == 0) {
-	  r = next_setup(prev, NCAR(node), reg);
-	}
-	prev = NCAR(node);
+        r = setup_tree(NCAR(node), reg, state, env);
+        if (IS_NOT_NULL(prev) && r == 0) {
+          r = next_setup(prev, NCAR(node), reg);
+        }
+        prev = NCAR(node);
       } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -3704,15 +3704,15 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
       BRefNode* br = NBREF(node);
       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]);
+        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]);
 #ifdef USE_BACKREF_WITH_LEVEL
-	if (IS_BACKREF_NEST_LEVEL(br)) {
-	  BIT_STATUS_ON_AT(env->bt_mem_end, p[i]);
-	}
+        if (IS_BACKREF_NEST_LEVEL(br)) {
+          BIT_STATUS_ON_AT(env->bt_mem_end, p[i]);
+        }
 #endif
-	SET_ENCLOSE_STATUS(nodes[p[i]], NST_MEM_BACKREFED);
+        SET_ENCLOSE_STATUS(nodes[p[i]], NST_MEM_BACKREFED);
       }
     }
     break;
@@ -3728,70 +3728,70 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
       }
 
       if (IS_REPEAT_INFINITE(qn->upper) || qn->upper >= 1) {
-	r = get_min_match_length(target, &d, env);
-	if (r) break;
-	if (d == 0) {
-	  qn->target_empty_info = NQ_TARGET_IS_EMPTY;
+        r = get_min_match_length(target, &d, env);
+        if (r) break;
+        if (d == 0) {
+          qn->target_empty_info = NQ_TARGET_IS_EMPTY;
 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
-	  r = quantifiers_memory_node_info(target);
-	  if (r < 0) break;
-	  if (r > 0) {
-	    qn->target_empty_info = r;
-	  }
+          r = quantifiers_memory_node_info(target);
+          if (r < 0) break;
+          if (r > 0) {
+            qn->target_empty_info = r;
+          }
 #endif
 #if 0
-	  r = get_max_match_length(target, &d, env);
-	  if (r == 0 && d == 0) {
-	    /*  ()* ==> ()?, ()+ ==> ()  */
-	    qn->upper = 1;
-	    if (qn->lower > 1) qn->lower = 1;
-	    if (NTYPE(target) == NT_STR) {
-	      qn->upper = qn->lower = 0;  /* /(?:)+/ ==> // */
-	    }
-	  }
+          r = get_max_match_length(target, &d, env);
+          if (r == 0 && d == 0) {
+            /*  ()* ==> ()?, ()+ ==> ()  */
+            qn->upper = 1;
+            if (qn->lower > 1) qn->lower = 1;
+            if (NTYPE(target) == NT_STR) {
+              qn->upper = qn->lower = 0;  /* /(?:)+/ ==> // */
+            }
+          }
 #endif
-	}
+        }
       }
 
       state |= IN_REPEAT;
       if (qn->lower != qn->upper)
-	state |= IN_VAR_REPEAT;
+        state |= IN_VAR_REPEAT;
       r = setup_tree(target, reg, state, env);
       if (r) break;
 
       /* expand string */
 #define EXPAND_STRING_MAX_LENGTH  100
       if (NTYPE(target) == NT_STR) {
-	if (!IS_REPEAT_INFINITE(qn->lower) && qn->lower == qn->upper &&
-	    qn->lower > 1 && qn->lower <= EXPAND_STRING_MAX_LENGTH) {
-	  int len = NSTRING_LEN(target);
-	  StrNode* sn = NSTR(target);
-
-	  if (len * qn->lower <= EXPAND_STRING_MAX_LENGTH) {
-	    int i, n = qn->lower;
-	    onig_node_conv_to_str_node(node, NSTR(target)->flag);
-	    for (i = 0; i < n; i++) {
-	      r = onig_node_str_cat(node, sn->s, sn->end);
-	      if (r) break;
-	    }
-	    onig_node_free(target);
-	    break; /* break case NT_QTFR: */
-	  }
-	}
+        if (!IS_REPEAT_INFINITE(qn->lower) && qn->lower == qn->upper &&
+            qn->lower > 1 && qn->lower <= EXPAND_STRING_MAX_LENGTH) {
+          int len = NSTRING_LEN(target);
+          StrNode* sn = NSTR(target);
+
+          if (len * qn->lower <= EXPAND_STRING_MAX_LENGTH) {
+            int i, n = qn->lower;
+            onig_node_conv_to_str_node(node, NSTR(target)->flag);
+            for (i = 0; i < n; i++) {
+              r = onig_node_str_cat(node, sn->s, sn->end);
+              if (r) break;
+            }
+            onig_node_free(target);
+            break; /* break case NT_QTFR: */
+          }
+        }
       }
 
 #ifdef USE_OP_PUSH_OR_JUMP_EXACT
       if (qn->greedy && (qn->target_empty_info != 0)) {
-	if (NTYPE(target) == NT_QTFR) {
-	  QtfrNode* tqn = NQTFR(target);
-	  if (IS_NOT_NULL(tqn->head_exact)) {
-	    qn->head_exact  = tqn->head_exact;
-	    tqn->head_exact = NULL;
-	  }
-	}
-	else {
-	  qn->head_exact = get_head_value_node(qn->target, 1, reg);
-	}
+        if (NTYPE(target) == NT_QTFR) {
+          QtfrNode* tqn = NQTFR(target);
+          if (IS_NOT_NULL(tqn->head_exact)) {
+            qn->head_exact  = tqn->head_exact;
+            tqn->head_exact = NULL;
+          }
+        }
+        else {
+          qn->head_exact = get_head_value_node(qn->target, 1, reg);
+        }
       }
 #endif
     }
@@ -3803,37 +3803,37 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
 
       switch (en->type) {
       case ENCLOSE_OPTION:
-	{
-	  OnigOptionType options = reg->options;
-	  reg->options = NENCLOSE(node)->option;
-	  r = setup_tree(NENCLOSE(node)->target, reg, state, env);
-	  reg->options = options;
-	}
-	break;
+        {
+          OnigOptionType options = reg->options;
+          reg->options = NENCLOSE(node)->option;
+          r = setup_tree(NENCLOSE(node)->target, reg, state, env);
+          reg->options = options;
+        }
+        break;
 
       case ENCLOSE_MEMORY:
-	if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT)) != 0) {
-	  BIT_STATUS_ON_AT(env->bt_mem_start, en->regnum);
-	  /* SET_ENCLOSE_STATUS(node, NST_MEM_IN_ALT_NOT); */
-	}
+        if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT)) != 0) {
+          BIT_STATUS_ON_AT(env->bt_mem_start, en->regnum);
+          /* SET_ENCLOSE_STATUS(node, NST_MEM_IN_ALT_NOT); */
+        }
         r = setup_tree(en->target, reg, state, env);
         break;
 
       case ENCLOSE_STOP_BACKTRACK:
-	{
-	  Node* target = en->target;
-	  r = setup_tree(target, reg, state, env);
-	  if (NTYPE(target) == NT_QTFR) {
-	    QtfrNode* tqn = NQTFR(target);
-	    if (IS_REPEAT_INFINITE(tqn->upper) && tqn->lower <= 1 &&
-		tqn->greedy != 0) {  /* (?>a*), a*+ etc... */
-	      int qtype = NTYPE(tqn->target);
-	      if (IS_NODE_TYPE_SIMPLE(qtype))
-		SET_ENCLOSE_STATUS(node, NST_STOP_BT_SIMPLE_REPEAT);
-	    }
-	  }
-	}
-	break;
+        {
+          Node* target = en->target;
+          r = setup_tree(target, reg, state, env);
+          if (NTYPE(target) == NT_QTFR) {
+            QtfrNode* tqn = NQTFR(target);
+            if (IS_REPEAT_INFINITE(tqn->upper) && tqn->lower <= 1 &&
+                tqn->greedy != 0) {  /* (?>a*), a*+ etc... */
+              int qtype = NTYPE(tqn->target);
+              if (IS_NODE_TYPE_SIMPLE(qtype))
+                SET_ENCLOSE_STATUS(node, NST_STOP_BT_SIMPLE_REPEAT);
+            }
+          }
+        }
+        break;
       }
     }
     break;
@@ -3844,11 +3844,11 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
 
       switch (an->type) {
       case ANCHOR_PREC_READ:
-	r = setup_tree(an->target, reg, state, env);
-	break;
+        r = setup_tree(an->target, reg, state, env);
+        break;
       case ANCHOR_PREC_READ_NOT:
-	r = setup_tree(an->target, reg, (state | IN_NOT), env);
-	break;
+        r = setup_tree(an->target, reg, (state | IN_NOT), env);
+        break;
 
 /* allowed node types in look-behind */
 #define ALLOWED_TYPE_IN_LB  \
@@ -3864,28 +3864,28 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
 ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION )
 
       case ANCHOR_LOOK_BEHIND:
-	{
-	  r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB,
-			      ALLOWED_ENCLOSE_IN_LB, ALLOWED_ANCHOR_IN_LB);
-	  if (r < 0) return r;
-	  if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
-	  r = setup_look_behind(node, reg, env);
-	  if (r != 0) return r;
-	  r = setup_tree(an->target, reg, state, env);
-	}
-	break;
+        {
+          r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB,
+                              ALLOWED_ENCLOSE_IN_LB, ALLOWED_ANCHOR_IN_LB);
+          if (r < 0) return r;
+          if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
+          r = setup_look_behind(node, reg, env);
+          if (r != 0) return r;
+          r = setup_tree(an->target, reg, state, env);
+        }
+        break;
 
       case ANCHOR_LOOK_BEHIND_NOT:
-	{
-	  r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB,
-		      ALLOWED_ENCLOSE_IN_LB_NOT, ALLOWED_ANCHOR_IN_LB_NOT);
-	  if (r < 0) return r;
-	  if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
-	  r = setup_look_behind(node, reg, env);
-	  if (r != 0) return r;
-	  r = setup_tree(an->target, reg, (state | IN_NOT), env);
-	}
-	break;
+        {
+          r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB,
+                   ALLOWED_ENCLOSE_IN_LB_NOT, ALLOWED_ANCHOR_IN_LB_NOT);
+          if (r < 0) return r;
+          if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
+          r = setup_look_behind(node, reg, env);
+          if (r != 0) return r;
+          r = setup_tree(an->target, reg, (state | IN_NOT), env);
+        }
+        break;
       }
     }
     break;
@@ -4505,9 +4505,9 @@ concat_left_node_opt_info(OnigEncoding enc, NodeOptInfo* to, NodeOptInfo* add)
 	to->expr.len = add->len.max;
 
       if (to->expr.mmd.max == 0)
-	select_opt_exact_info(enc, &to->exb, &to->expr);
+        select_opt_exact_info(enc, &to->exb, &to->expr);
       else
-	select_opt_exact_info(enc, &to->exm, &to->expr);
+        select_opt_exact_info(enc, &to->exm, &to->expr);
     }
   }
   else if (add->expr.len > 0) {
@@ -4553,11 +4553,11 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 
       copy_opt_env(&nenv, env);
       do {
-	r = optimize_node_left(NCAR(nd), &nopt, &nenv);
-	if (r == 0) {
-	  add_mml(&nenv.mmd, &nopt.len);
-	  concat_left_node_opt_info(env->enc, opt, &nopt);
-	}
+        r = optimize_node_left(NCAR(nd), &nopt, &nenv);
+        if (r == 0) {
+          add_mml(&nenv.mmd, &nopt.len);
+          concat_left_node_opt_info(env->enc, opt, &nopt);
+        }
       } while (r == 0 && IS_NOT_NULL(nd = NCDR(nd)));
     }
     break;
@@ -4568,11 +4568,11 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       Node* nd = node;
 
       do {
-	r = optimize_node_left(NCAR(nd), &nopt, env);
-	if (r == 0) {
-	  if (nd == node) copy_node_opt_info(opt, &nopt);
-	  else            alt_merge_node_opt_info(opt, &nopt, env);
-	}
+        r = optimize_node_left(NCAR(nd), &nopt, env);
+        if (r == 0) {
+          if (nd == node) copy_node_opt_info(opt, &nopt);
+          else            alt_merge_node_opt_info(opt, &nopt, env);
+        }
       } while ((r == 0) && IS_NOT_NULL(nd = NCDR(nd)));
     }
     break;
@@ -4584,39 +4584,39 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       int is_raw = NSTRING_IS_RAW(node);
 
       if (! NSTRING_IS_AMBIG(node)) {
-	concat_opt_exact_info_str(&opt->exb, sn->s, sn->end,
-				  NSTRING_IS_RAW(node), env->enc);
-	if (slen > 0) {
-	  add_char_opt_map_info(&opt->map, *(sn->s), env->enc);
-	}
+        concat_opt_exact_info_str(&opt->exb, sn->s, sn->end,
+                                  NSTRING_IS_RAW(node), env->enc);
+        if (slen > 0) {
+          add_char_opt_map_info(&opt->map, *(sn->s), env->enc);
+        }
         set_mml(&opt->len, slen, slen);
       }
       else {
         int max;
 
-	if (NSTRING_IS_DONT_GET_OPT_INFO(node)) {
+        if (NSTRING_IS_DONT_GET_OPT_INFO(node)) {
           int n = onigenc_strlen(env->enc, sn->s, sn->end);
           max = ONIGENC_MBC_MAXLEN_DIST(env->enc) * n;
-	}
-	else {
-	  concat_opt_exact_info_str(&opt->exb, sn->s, sn->end,
-				    is_raw, env->enc);
-	  opt->exb.ignore_case = 1;
-
-	  if (slen > 0) {
-	    r = add_char_amb_opt_map_info(&opt->map, sn->s, sn->end,
-					  env->enc, env->case_fold_flag);
-	    if (r != 0) break;
-	  }
+        }
+        else {
+          concat_opt_exact_info_str(&opt->exb, sn->s, sn->end,
+                                    is_raw, env->enc);
+          opt->exb.ignore_case = 1;
+
+          if (slen > 0) {
+            r = add_char_amb_opt_map_info(&opt->map, sn->s, sn->end,
+                                          env->enc, env->case_fold_flag);
+            if (r != 0) break;
+          }
 
-	  max = slen;
-	}
+          max = slen;
+        }
 
         set_mml(&opt->len, slen, max);
       }
 
       if (opt->exb.len == slen)
-	opt->exb.reach_end = 1;
+        opt->exb.reach_end = 1;
     }
     break;
 
@@ -4629,9 +4629,9 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 
       if (IS_NOT_NULL(cc->mbuf) || IS_NCCLASS_NOT(cc)) {
         OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);
-	OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
+        OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
 
-	set_mml(&opt->len, min, max);
+        set_mml(&opt->len, min, max);
       }
       else {
         for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
@@ -4640,7 +4640,7 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
             add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
           }
         }
-	set_mml(&opt->len, 1, 1);
+        set_mml(&opt->len, 1, 1);
       }
     }
     break;
@@ -4654,24 +4654,24 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       if (max == 1) {
         min = 1;
 
-	switch (NCTYPE(node)->ctype) {
-	case ONIGENC_CTYPE_WORD:
-	  if (NCTYPE(node)->not != 0) {
-	    for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-	      if (! ONIGENC_IS_CODE_WORD(env->enc, i)) {
-		add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
-	      }
-	    }
-	  }
-	  else {
-	    for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-	      if (ONIGENC_IS_CODE_WORD(env->enc, i)) {
-		add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
-	      }
-	    }
-	  }
-	  break;
-	}
+        switch (NCTYPE(node)->ctype) {
+        case ONIGENC_CTYPE_WORD:
+          if (NCTYPE(node)->not != 0) {
+            for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+              if (! ONIGENC_IS_CODE_WORD(env->enc, i)) {
+                add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
+              }
+            }
+          }
+          else {
+            for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+              if (ONIGENC_IS_CODE_WORD(env->enc, i)) {
+                add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
+              }
+            }
+          }
+          break;
+        }
       }
       else {
         min = ONIGENC_MBC_MINLEN(env->enc);
@@ -4701,20 +4701,20 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 
     case ANCHOR_PREC_READ:
       {
-	NodeOptInfo nopt;
+        NodeOptInfo nopt;
 
-	r = optimize_node_left(NANCHOR(node)->target, &nopt, env);
-	if (r == 0) {
-	  if (nopt.exb.len > 0)
-	    copy_opt_exact_info(&opt->expr, &nopt.exb);
-	  else if (nopt.exm.len > 0)
-	    copy_opt_exact_info(&opt->expr, &nopt.exm);
+        r = optimize_node_left(NANCHOR(node)->target, &nopt, env);
+        if (r == 0) {
+          if (nopt.exb.len > 0)
+            copy_opt_exact_info(&opt->expr, &nopt.exb);
+          else if (nopt.exm.len > 0)
+            copy_opt_exact_info(&opt->expr, &nopt.exm);
 
-	  opt->expr.reach_end = 0;
+          opt->expr.reach_end = 0;
 
-	  if (nopt.map.value > 0)
-	    copy_opt_map_info(&opt->map, &nopt.map);
-	}
+          if (nopt.map.value > 0)
+            copy_opt_map_info(&opt->map, &nopt.map);
+        }
       }
       break;
 
@@ -4734,8 +4734,8 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       BRefNode* br = NBREF(node);
 
       if (br->state & NST_RECURSION) {
-	set_mml(&opt->len, 0, ONIG_INFINITE_DISTANCE);
-	break;
+        set_mml(&opt->len, 0, ONIG_INFINITE_DISTANCE);
+        break;
       }
       backs = BACKREFS_P(br);
       r = get_min_match_length(nodes[backs[0]], &min, env->scan_env);
@@ -4743,12 +4743,12 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       r = get_max_match_length(nodes[backs[0]], &max, env->scan_env);
       if (r != 0) break;
       for (i = 1; i < br->back_num; i++) {
-	r = get_min_match_length(nodes[backs[i]], &tmin, env->scan_env);
-	if (r != 0) break;
-	r = get_max_match_length(nodes[backs[i]], &tmax, env->scan_env);
-	if (r != 0) break;
-	if (min > tmin) min = tmin;
-	if (max < tmax) max = tmax;
+        r = get_min_match_length(nodes[backs[i]], &tmin, env->scan_env);
+        if (r != 0) break;
+        r = get_max_match_length(nodes[backs[i]], &tmax, env->scan_env);
+        if (r != 0) break;
+        if (min > tmin) min = tmin;
+        if (max < tmax) max = tmax;
       }
       if (r == 0) set_mml(&opt->len, min, max);
     }
@@ -4778,43 +4778,43 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       if (r) break;
 
       if (qn->lower == 0 && IS_REPEAT_INFINITE(qn->upper)) {
-	if (env->mmd.max == 0 &&
-	    NTYPE(qn->target) == NT_CANY && qn->greedy) {
-	  if (IS_MULTILINE(env->options))
-	    add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_ML);
-	  else
-	    add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR);
-	}
+        if (env->mmd.max == 0 &&
+            NTYPE(qn->target) == NT_CANY && qn->greedy) {
+          if (IS_MULTILINE(env->options))
+            add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_ML);
+          else
+            add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR);
+        }
       }
       else {
-	if (qn->lower > 0) {
-	  copy_node_opt_info(opt, &nopt);
-	  if (nopt.exb.len > 0) {
-	    if (nopt.exb.reach_end) {
-	      for (i = 2; i <= qn->lower &&
-		          ! is_full_opt_exact_info(&opt->exb); i++) {
-		concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc);
-	      }
-	      if (i < qn->lower) {
-		opt->exb.reach_end = 0;
-	      }
-	    }
-	  }
+        if (qn->lower > 0) {
+          copy_node_opt_info(opt, &nopt);
+          if (nopt.exb.len > 0) {
+            if (nopt.exb.reach_end) {
+              for (i = 2; i <= qn->lower &&
+                     ! is_full_opt_exact_info(&opt->exb); i++) {
+                concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc);
+              }
+              if (i < qn->lower) {
+                opt->exb.reach_end = 0;
+              }
+            }
+          }
 
-	  if (qn->lower != qn->upper) {
-	    opt->exb.reach_end = 0;
-	    opt->exm.reach_end = 0;
-	  }
-	  if (qn->lower > 1)
-	    opt->exm.reach_end = 0;
-	}
+          if (qn->lower != qn->upper) {
+            opt->exb.reach_end = 0;
+            opt->exm.reach_end = 0;
+          }
+          if (qn->lower > 1)
+            opt->exm.reach_end = 0;
+        }
       }
 
       min = distance_multiply(nopt.len.min, qn->lower);
       if (IS_REPEAT_INFINITE(qn->upper))
-	max = (nopt.len.max > 0 ? ONIG_INFINITE_DISTANCE : 0);
+        max = (nopt.len.max > 0 ? ONIG_INFINITE_DISTANCE : 0);
       else
-	max = distance_multiply(nopt.len.max, qn->upper);
+        max = distance_multiply(nopt.len.max, qn->upper);
 
       set_mml(&opt->len, min, max);
     }
@@ -4826,42 +4826,42 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 
       switch (en->type) {
       case ENCLOSE_OPTION:
-	{
-	  OnigOptionType save = env->options;
+        {
+          OnigOptionType save = env->options;
 
-	  env->options = en->option;
-	  r = optimize_node_left(en->target, opt, env);
-	  env->options = save;
-	}
-	break;
+          env->options = en->option;
+          r = optimize_node_left(en->target, opt, env);
+          env->options = save;
+        }
+        break;
 
       case ENCLOSE_MEMORY:
 #ifdef USE_SUBEXP_CALL
-	en->opt_count++;
-	if (en->opt_count > MAX_NODE_OPT_INFO_REF_COUNT) {
-	  OnigDistance min, max;
-
-	  min = 0;
-	  max = ONIG_INFINITE_DISTANCE;
-	  if (IS_ENCLOSE_MIN_FIXED(en)) min = en->min_len;
-	  if (IS_ENCLOSE_MAX_FIXED(en)) max = en->max_len;
-	  set_mml(&opt->len, min, max);
-	}
-	else
+        en->opt_count++;
+        if (en->opt_count > MAX_NODE_OPT_INFO_REF_COUNT) {
+          OnigDistance min, max;
+
+          min = 0;
+          max = ONIG_INFINITE_DISTANCE;
+          if (IS_ENCLOSE_MIN_FIXED(en)) min = en->min_len;
+          if (IS_ENCLOSE_MAX_FIXED(en)) max = en->max_len;
+          set_mml(&opt->len, min, max);
+        }
+        else
 #endif
-	{
-	  r = optimize_node_left(en->target, opt, env);
+          {
+            r = optimize_node_left(en->target, opt, env);
 
-	  if (is_set_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK)) {
-	    if (BIT_STATUS_AT(env->scan_env->backrefed_mem, en->regnum))
-	      remove_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK);
-	  }
-	}
-	break;
+            if (is_set_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK)) {
+              if (BIT_STATUS_AT(env->scan_env->backrefed_mem, en->regnum))
+                remove_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK);
+            }
+          }
+        break;
 
       case ENCLOSE_STOP_BACKTRACK:
-	r = optimize_node_left(en->target, opt, env);
-	break;
+        r = optimize_node_left(en->target, opt, env);
+        break;
       }
     }
     break;
@@ -5039,10 +5039,10 @@ static void print_enc_string(FILE* fp, OnigEncoding enc,
     while (p < end) {
       code = ONIGENC_MBC_TO_CODE(enc, p, end);
       if (code >= 0x80) {
-	fprintf(fp, " 0x%04x ", (int )code);
+        fprintf(fp, " 0x%04x ", (int )code);
       }
       else {
-	fputc((int )code, fp);
+        fputc((int )code, fp);
       }
 
       p += enclen(enc, p);
@@ -5160,7 +5160,7 @@ print_optimize_info(FILE* f, regex_t* reg)
       c = 0;
       fputc('[', f);
       for (i = 0; i < ONIG_CHAR_TABLE_SIZE; i++) {
-	if (reg->map[i] != 0) {
+        if (reg->map[i] != 0) {
           if (c > 0)  fputs(", ", f);
           c++;
           if (ONIGENC_MBC_MAXLEN(reg->enc) == 1 &&
@@ -5328,10 +5328,10 @@ 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) {
-	  scan_env.num_comb_exp_check = 0;
-	  break;
-	}
+        if (BIT_STATUS_AT(scan_env.backrefed_mem, i) != 0) {
+          scan_env.num_comb_exp_check = 0;
+          break;
+        }
       }
     }
   }
@@ -5365,9 +5365,9 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
       reg->stack_pop_level = STACK_POP_LEVEL_ALL;
     else {
       if (reg->bt_mem_start != 0)
-	reg->stack_pop_level = STACK_POP_LEVEL_MEM_START;
+        reg->stack_pop_level = STACK_POP_LEVEL_MEM_START;
       else
-	reg->stack_pop_level = STACK_POP_LEVEL_FREE;
+        reg->stack_pop_level = STACK_POP_LEVEL_FREE;
     }
   }
 #ifdef USE_SUBEXP_CALL
@@ -5805,9 +5805,9 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar** nextp,
       break;
     case ARG_OPTION:
       {
-	OnigOptionType option = *((OnigOptionType* )bp);
-	bp += SIZE_OPTION;
-	fprintf(f, ":%d", option);
+        OnigOptionType option = *((OnigOptionType* )bp);
+        bp += SIZE_OPTION;
+        fprintf(f, ":%d", option);
       }
       break;
 
@@ -5856,13 +5856,13 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar** nextp,
       break;
     case OP_EXACTMBN:
       {
-	int mb_len;
+        int mb_len;
       
-	GET_LENGTH_INC(mb_len, bp);
-	GET_LENGTH_INC(len, bp);
-	fprintf(f, ":%d:%d:", mb_len, len);
-	n = len * mb_len;
-	while (n-- > 0) { fputc(*bp++, f); }
+        GET_LENGTH_INC(mb_len, bp);
+        GET_LENGTH_INC(len, bp);
+        fprintf(f, ":%d:%d:", mb_len, len);
+        n = len * mb_len;
+        while (n-- > 0) { fputc(*bp++, f); }
       }
       break;
 
@@ -5936,40 +5936,40 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar** nextp,
       fputs(" ", f);
       GET_LENGTH_INC(len, bp);
       for (i = 0; i < len; i++) {
-	GET_MEMNUM_INC(mem, bp);
-	if (i > 0) fputs(", ", f);
-	fprintf(f, "%d", mem);
+        GET_MEMNUM_INC(mem, bp);
+        if (i > 0) fputs(", ", f);
+        fprintf(f, "%d", mem);
       }
       break;
 
     case OP_BACKREF_WITH_LEVEL:
       {
-	OnigOptionType option;
-	LengthType level;
-
-	GET_OPTION_INC(option, bp);
-	fprintf(f, ":%d", option);
-	GET_LENGTH_INC(level, bp);
-	fprintf(f, ":%d", level);
-
-	fputs(" ", f);
-	GET_LENGTH_INC(len, bp);
-	for (i = 0; i < len; i++) {
-	  GET_MEMNUM_INC(mem, bp);
-	  if (i > 0) fputs(", ", f);
-	  fprintf(f, "%d", mem);
-	}
+        OnigOptionType option;
+        LengthType level;
+
+        GET_OPTION_INC(option, bp);
+        fprintf(f, ":%d", option);
+        GET_LENGTH_INC(level, bp);
+        fprintf(f, ":%d", level);
+
+        fputs(" ", f);
+        GET_LENGTH_INC(len, bp);
+        for (i = 0; i < len; i++) {
+          GET_MEMNUM_INC(mem, bp);
+          if (i > 0) fputs(", ", f);
+          fprintf(f, "%d", mem);
+        }
       }
       break;
 
     case OP_REPEAT:
     case OP_REPEAT_NG:
       {
-	mem = *((MemNumType* )bp);
-	bp += SIZE_MEMNUM;
-	addr = *((RelAddrType* )bp);
-	bp += SIZE_RELADDR;
-	fprintf(f, ":%d:%d", mem, addr);
+        mem = *((MemNumType* )bp);
+        bp += SIZE_MEMNUM;
+        addr = *((RelAddrType* )bp);
+        bp += SIZE_RELADDR;
+        fprintf(f, ":%d:%d", mem, addr);
       }
       break;
 
@@ -6025,9 +6025,9 @@ print_compiled_byte_code_list(FILE* f, regex_t* reg)
     ncode++;
     if (bp > reg->p) {
       if (ncode % 5 == 0)
-	fprintf(f, "\n");
+        fprintf(f, "\n");
       else
-	fputs(" ", f);
+        fputs(" ", f);
     }
     onig_print_compiled_byte_code(f, bp, &bp, reg->enc);
   }
@@ -6060,8 +6060,8 @@ print_indent_tree(FILE* f, Node* node, int indent)
     print_indent_tree(f, NCAR(node), indent + add);
     while (IS_NOT_NULL(node = NCDR(node))) {
       if (NTYPE(node) != type) {
-	fprintf(f, "ERROR: list/alt right is not a cons. %d\n", NTYPE(node));
-	exit(0);
+        fprintf(f, "ERROR: list/alt right is not a cons. %d\n", NTYPE(node));
+        exit(0);
       }
       print_indent_tree(f, NCAR(node), indent + add);
     }
@@ -6072,9 +6072,9 @@ print_indent_tree(FILE* f, Node* node, int indent)
 	    (NSTRING_IS_RAW(node) ? "-raw" : ""), (int )node);
     for (p = NSTR(node)->s; p < NSTR(node)->end; p++) {
       if (*p >= 0x20 && *p < 0x7f)
-	fputc(*p, f);
+        fputc(*p, f);
       else {
-	fprintf(f, " 0x%02x", *p);
+        fprintf(f, " 0x%02x", *p);
       }
     }
     break;
@@ -6085,8 +6085,8 @@ print_indent_tree(FILE* f, Node* node, int indent)
     if (NCCLASS(node)->mbuf) {
       BBuf* bbuf = NCCLASS(node)->mbuf;
       for (i = 0; i < bbuf->used; i++) {
-	if (i > 0) fprintf(f, ",");
-	fprintf(f, "%0x", bbuf->p[i]);
+        if (i > 0) fprintf(f, ",");
+        fprintf(f, "%0x", bbuf->p[i]);
       }
     }
     break;
@@ -6096,9 +6096,9 @@ print_indent_tree(FILE* f, Node* node, int indent)
     switch (NCTYPE(node)->ctype) {
     case ONIGENC_CTYPE_WORD:
       if (NCTYPE(node)->not != 0)
-	fputs("not word",       f);
+        fputs("not word",       f);
       else
-	fputs("word",           f);
+        fputs("word",           f);
       break;
 
     default:
@@ -6145,8 +6145,8 @@ print_indent_tree(FILE* f, Node* node, int indent)
       p = BACKREFS_P(br);
       fprintf(f, "<backref:%x>", (int )node);
       for (i = 0; i < br->back_num; i++) {
-	if (i > 0) fputs(", ", f);
-	fprintf(f, "%d", p[i]);
+        if (i > 0) fputs(", ", f);
+        fprintf(f, "%d", p[i]);
       }
     }
     break;