Merge Onigmo 6.0.0

* https://github.com/k-takata/Onigmo/blob/Onigmo-6.0.0/HISTORY
* fix for ruby 2.4: https://github.com/k-takata/Onigmo/pull/78
* suppress warning: https://github.com/k-takata/Onigmo/pull/79
* include/ruby/oniguruma.h: include onigmo.h.
* template/encdb.h.tmpl: ignore duplicated definition of EUC-CN in
  enc/euc_kr.c. It is defined in enc/gb2313.c with CRuby macro.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@57045 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 276 insertions, 307 deletions

diff --git a/regcomp.c b/regcomp.c
index 222d1d6c9e..49103afea1 100644
--- a/regcomp.c
+++ b/regcomp.c
@@ -3,7 +3,7 @@
 **********************************************************************/
 /*-
  * Copyright (c) 2002-2013  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>
- * Copyright (c) 2011-2014  K.Takata  <kentkt AT csc DOT jp>
+ * Copyright (c) 2011-2016  K.Takata  <kentkt AT csc DOT jp>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,15 +30,6 @@
 
 #include "regparse.h"
 
-#if defined(USE_MULTI_THREAD_SYSTEM) \
-  && defined(USE_DEFAULT_MULTI_THREAD_SYSTEM)
-#ifdef _WIN32
-CRITICAL_SECTION gOnigMutex;
-#else
-pthread_mutex_t gOnigMutex;
-#endif
-#endif
-
 OnigCaseFoldType OnigDefaultCaseFoldFlag = ONIGENC_CASE_FOLD_MIN;
 
 extern OnigCaseFoldType
@@ -263,6 +254,7 @@ add_mem_num(regex_t* reg, int num)
   return 0;
 }
 
+#if 0
 static int
 add_pointer(regex_t* reg, void* addr)
 {
@@ -271,6 +263,7 @@ add_pointer(regex_t* reg, void* addr)
   BBUF_ADD(reg, &ptr, SIZE_POINTER);
   return 0;
 }
+#endif
 
 static int
 add_option(regex_t* reg, OnigOptionType option)
@@ -591,11 +584,6 @@ compile_length_cclass_node(CClassNode* cc, regex_t* reg)
 {
   int len;
 
-  if (IS_NCCLASS_SHARE(cc)) {
-    len = SIZE_OPCODE + SIZE_POINTER;
-    return len;
-  }
-
   if (IS_NULL(cc->mbuf)) {
     len = SIZE_OPCODE + SIZE_BITSET;
   }
@@ -621,12 +609,6 @@ compile_cclass_node(CClassNode* cc, regex_t* reg)
 {
   int r;
 
-  if (IS_NCCLASS_SHARE(cc)) {
-    add_opcode(reg, OP_CCLASS_NODE);
-    r = add_pointer(reg, cc);
-    return r;
-  }
-
   if (IS_NULL(cc->mbuf)) {
     if (IS_NCCLASS_NOT(cc))
       add_opcode(reg, OP_CCLASS_NOT);
@@ -638,17 +620,17 @@ compile_cclass_node(CClassNode* cc, regex_t* reg)
   else {
     if (ONIGENC_MBC_MINLEN(reg->enc) > 1 || bitset_is_empty(cc->bs)) {
       if (IS_NCCLASS_NOT(cc))
-        add_opcode(reg, OP_CCLASS_MB_NOT);
+	add_opcode(reg, OP_CCLASS_MB_NOT);
       else
-        add_opcode(reg, OP_CCLASS_MB);
+	add_opcode(reg, OP_CCLASS_MB);
 
       r = add_multi_byte_cclass(cc->mbuf, reg);
     }
     else {
       if (IS_NCCLASS_NOT(cc))
-        add_opcode(reg, OP_CCLASS_MIX_NOT);
+	add_opcode(reg, OP_CCLASS_MIX_NOT);
       else
-        add_opcode(reg, OP_CCLASS_MIX);
+	add_opcode(reg, OP_CCLASS_MIX);
 
       r = add_bitset(reg, cc->bs);
       if (r) return r;
@@ -760,9 +742,9 @@ compile_length_quantifier_node(QtfrNode* qn, regex_t* reg)
   if (NTYPE(qn->target) == NT_CANY) {
     if (qn->greedy && infinite) {
       if (IS_NOT_NULL(qn->next_head_exact) && !CKN_ON)
-        return SIZE_OP_ANYCHAR_STAR_PEEK_NEXT + tlen * qn->lower + cklen;
+	return SIZE_OP_ANYCHAR_STAR_PEEK_NEXT + tlen * qn->lower + cklen;
       else
-        return SIZE_OP_ANYCHAR_STAR + tlen * qn->lower + cklen;
+	return SIZE_OP_ANYCHAR_STAR + tlen * qn->lower + cklen;
     }
   }
 
@@ -989,9 +971,9 @@ compile_length_quantifier_node(QtfrNode* qn, regex_t* reg)
   if (NTYPE(qn->target) == NT_CANY) {
     if (qn->greedy && infinite) {
       if (IS_NOT_NULL(qn->next_head_exact))
-        return SIZE_OP_ANYCHAR_STAR_PEEK_NEXT + tlen * qn->lower;
+	return SIZE_OP_ANYCHAR_STAR_PEEK_NEXT + tlen * qn->lower;
       else
-        return SIZE_OP_ANYCHAR_STAR + tlen * qn->lower;
+	return SIZE_OP_ANYCHAR_STAR + tlen * qn->lower;
     }
   }
 
@@ -1010,9 +992,12 @@ compile_length_quantifier_node(QtfrNode* qn, regex_t* reg)
     }
 
     if (qn->greedy) {
+#ifdef USE_OP_PUSH_OR_JUMP_EXACT
       if (IS_NOT_NULL(qn->head_exact))
 	len += SIZE_OP_PUSH_OR_JUMP_EXACT1 + mod_tlen + SIZE_OP_JUMP;
-      else if (IS_NOT_NULL(qn->next_head_exact))
+      else
+#endif
+      if (IS_NOT_NULL(qn->next_head_exact))
 	len += SIZE_OP_PUSH_IF_PEEK_NEXT + mod_tlen + SIZE_OP_JUMP;
       else
 	len += SIZE_OP_PUSH + mod_tlen + SIZE_OP_JUMP;
@@ -1078,9 +1063,12 @@ 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) {
+#ifdef USE_OP_PUSH_OR_JUMP_EXACT
 	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))
+	else
+#endif
+	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);
@@ -1096,6 +1084,7 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
     }
 
     if (qn->greedy) {
+#ifdef USE_OP_PUSH_OR_JUMP_EXACT
       if (IS_NOT_NULL(qn->head_exact)) {
 	r = add_opcode_rel_addr(reg, OP_PUSH_OR_JUMP_EXACT1,
 			     mod_tlen + SIZE_OP_JUMP);
@@ -1106,7 +1095,9 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
 	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)) {
+      else
+#endif
+      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;
@@ -1243,6 +1234,11 @@ compile_length_enclose_node(EncloseNode* node, regex_t* reg)
 	len += (IS_ENCLOSE_RECURSION(node)
 		? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
     }
+    else if (IS_ENCLOSE_RECURSION(node)) {
+      len = SIZE_OP_MEMORY_START_PUSH;
+      len += tlen + (BIT_STATUS_AT(reg->bt_mem_end, node->regnum)
+		     ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_REC);
+    }
     else
 #endif
     {
@@ -1354,6 +1350,14 @@ compile_enclose_node(EncloseNode* node, regex_t* reg)
       if (r) return r;
       r = add_opcode(reg, OP_RETURN);
     }
+    else if (IS_ENCLOSE_RECURSION(node)) {
+      if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
+	r = add_opcode(reg, OP_MEMORY_END_PUSH_REC);
+      else
+	r = add_opcode(reg, OP_MEMORY_END_REC);
+      if (r) return r;
+      r = add_mem_num(reg, node->regnum);
+    }
     else
 #endif
     {
@@ -1589,10 +1593,10 @@ compile_length_tree(Node* node, regex_t* reg)
       int n = 0;
       len = 0;
       do {
-        r = compile_length_tree(NCAR(node), reg);
-        if (r < 0) return r;
-        len += r;
-        n++;
+	r = compile_length_tree(NCAR(node), reg);
+	if (r < 0) return r;
+	len += r;
+	n++;
       } while (IS_NOT_NULL(node = NCDR(node)));
       r = len;
       r += (SIZE_OP_PUSH + SIZE_OP_JUMP) * (n - 1);
@@ -1621,7 +1625,7 @@ compile_length_tree(Node* node, regex_t* reg)
 
 #ifdef USE_BACKREF_WITH_LEVEL
       if (IS_BACKREF_NEST_LEVEL(br)) {
-        r = SIZE_OPCODE + SIZE_OPTION + SIZE_LENGTH +
+	r = SIZE_OPCODE + SIZE_OPTION + SIZE_LENGTH +
             SIZE_LENGTH + (SIZE_MEMNUM * br->back_num);
       }
       else
@@ -1785,12 +1789,12 @@ compile_tree(Node* node, regex_t* reg)
 	int i;
 	int* p;
 
-        if (IS_IGNORECASE(reg->options)) {
-          r = add_opcode(reg, OP_BACKREF_MULTI_IC);
-        }
-        else {
-          r = add_opcode(reg, OP_BACKREF_MULTI);
-        }
+	if (IS_IGNORECASE(reg->options)) {
+	  r = add_opcode(reg, OP_BACKREF_MULTI_IC);
+	}
+	else {
+	  r = add_opcode(reg, OP_BACKREF_MULTI);
+	}
 	if (r) return r;
 
 #ifdef USE_BACKREF_WITH_LEVEL
@@ -1884,17 +1888,8 @@ noname_disable_map(Node** plink, GroupNumRemap* map, int* counter)
     break;
 
   case NT_ANCHOR:
-    {
-      AnchorNode* an = NANCHOR(node);
-      switch (an->type) {
-      case ANCHOR_PREC_READ:
-      case ANCHOR_PREC_READ_NOT:
-      case ANCHOR_LOOK_BEHIND:
-      case ANCHOR_LOOK_BEHIND_NOT:
-	r = noname_disable_map(&(an->target), map, counter);
-	break;
-      }
-    }
+    if (NANCHOR(node)->target)
+      r = noname_disable_map(&(NANCHOR(node)->target), map, counter);
     break;
 
   default:
@@ -1951,7 +1946,7 @@ renumber_by_map(Node* node, GroupNumRemap* map)
     {
       EncloseNode* en = NENCLOSE(node);
       if (en->type == ENCLOSE_CONDITION)
-        en->regnum = map[en->regnum].new_val;
+	en->regnum = map[en->regnum].new_val;
       r = renumber_by_map(en->target, map);
     }
     break;
@@ -1961,17 +1956,8 @@ renumber_by_map(Node* node, GroupNumRemap* map)
     break;
 
   case NT_ANCHOR:
-    {
-      AnchorNode* an = NANCHOR(node);
-      switch (an->type) {
-      case ANCHOR_PREC_READ:
-      case ANCHOR_PREC_READ_NOT:
-      case ANCHOR_LOOK_BEHIND:
-      case ANCHOR_LOOK_BEHIND_NOT:
-	r = renumber_by_map(an->target, map);
-	break;
-      }
-    }
+    if (NANCHOR(node)->target)
+      r = renumber_by_map(NANCHOR(node)->target, map);
     break;
 
   default:
@@ -2005,6 +1991,11 @@ numbered_ref_check(Node* node)
       return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
     break;
 
+  case NT_ANCHOR:
+    if (NANCHOR(node)->target)
+      r = numbered_ref_check(NANCHOR(node)->target);
+    break;
+
   default:
     break;
   }
@@ -2091,7 +2082,7 @@ quantifiers_memory_node_info(Node* node)
     }
     break;
 
-#ifdef USE_SUBEXP_CALL
+# ifdef USE_SUBEXP_CALL
   case NT_CALL:
     if (IS_CALL_RECURSION(NCALL(node))) {
       return NQ_TARGET_IS_EMPTY_REC; /* tiny version */
@@ -2099,7 +2090,7 @@ quantifiers_memory_node_info(Node* node)
     else
       r = quantifiers_memory_node_info(NCALL(node)->target);
     break;
-#endif
+# endif
 
   case NT_QTFR:
     {
@@ -2238,18 +2229,23 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       EncloseNode* en = NENCLOSE(node);
       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);
+        if (IS_ENCLOSE_MIN_FIXED(en))
+          *min = en->min_len;
+        else {
+	  if (IS_ENCLOSE_MARK1(NENCLOSE(node)))
+	    *min = 0;  // recursive
+	  else {
+	    SET_ENCLOSE_STATUS(node, NST_MARK1);
+	    r = get_min_match_length(en->target, min, env);
+	    CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
+	    if (r == 0) {
+	      en->min_len = *min;
+	      SET_ENCLOSE_STATUS(node, NST_MIN_FIXED);
+	    }
 	  }
-	}
-	break;
-#endif
+        }
+        break;
+
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
       case ENCLOSE_CONDITION:
@@ -2356,18 +2352,23 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
       EncloseNode* en = NENCLOSE(node);
       switch (en->type) {
       case ENCLOSE_MEMORY:
-#ifdef USE_SUBEXP_CALL
 	if (IS_ENCLOSE_MAX_FIXED(en))
 	  *max = en->max_len;
 	else {
-	  r = get_max_match_length(en->target, max, env);
-	  if (r == 0) {
-	    en->max_len = *max;
-	    SET_ENCLOSE_STATUS(node, NST_MAX_FIXED);
+	  if (IS_ENCLOSE_MARK1(NENCLOSE(node)))
+	    *max = ONIG_INFINITE_DISTANCE;
+	  else {
+	    SET_ENCLOSE_STATUS(node, NST_MARK1);
+	    r = get_max_match_length(en->target, max, env);
+	    CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
+	    if (r == 0) {
+	      en->max_len = *max;
+	      SET_ENCLOSE_STATUS(node, NST_MAX_FIXED);
+	    }
 	  }
 	}
 	break;
-#endif
+
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
       case ENCLOSE_CONDITION:
@@ -2622,10 +2623,10 @@ is_not_included(Node* x, Node* y, regex_t* reg)
 	  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 == 0 && IS_NCCLASS_NOT(xc))) {
 	      v = BITSET_AT(yc->bs, i);
 	      if ((v != 0 && !IS_NCCLASS_NOT(yc)) ||
-                  (v == 0 && IS_NCCLASS_NOT(yc)))
+		  (v == 0 && IS_NCCLASS_NOT(yc)))
 		return 0;
 	    }
 	  }
@@ -2675,24 +2676,24 @@ is_not_included(Node* x, Node* y, regex_t* reg)
 	break;
 
       case NT_CCLASS:
-        {
-          CClassNode* cc = NCCLASS(y);
+	{
+	  CClassNode* cc = NCCLASS(y);
 
-          code = ONIGENC_MBC_TO_CODE(reg->enc, xs->s,
-                                     xs->s + ONIGENC_MBC_MAXLEN(reg->enc));
-          return (onig_is_code_in_cc(reg->enc, code, cc) != 0 ? 0 : 1);
-        }
-        break;
+	  code = ONIGENC_MBC_TO_CODE(reg->enc, xs->s,
+				     xs->s + ONIGENC_MBC_MAXLEN(reg->enc));
+	  return (onig_is_code_in_cc(reg->enc, code, cc) != 0 ? 0 : 1);
+	}
+	break;
 
       case NT_STR:
-        {
-          UChar *q;
-          StrNode* ys = NSTR(y);
-          len = NSTRING_LEN(x);
-          if (len > NSTRING_LEN(y)) len = NSTRING_LEN(y);
-          if (NSTRING_IS_AMBIG(x) || NSTRING_IS_AMBIG(y)) {
-            /* tiny version */
-            return 0;
+	{
+	  UChar *q;
+	  StrNode* ys = NSTR(y);
+	  len = NSTRING_LEN(x);
+	  if (len > NSTRING_LEN(y)) len = NSTRING_LEN(y);
+	  if (NSTRING_IS_AMBIG(x) || NSTRING_IS_AMBIG(y)) {
+	    /* tiny version */
+	    return 0;
 	  }
 	  else {
 	    for (i = 0, p = ys->s, q = xs->s; (OnigDistance )i < len; i++, p++, q++) {
@@ -2703,7 +2704,7 @@ is_not_included(Node* x, Node* y, regex_t* reg)
 	break;
 
       default:
-        break;
+	break;
       }
     }
     break;
@@ -2760,9 +2761,11 @@ get_head_value_node(Node* node, int exact, regex_t* reg)
     {
       QtfrNode* qn = NQTFR(node);
       if (qn->lower > 0) {
+#ifdef USE_OP_PUSH_OR_JUMP_EXACT
 	if (IS_NOT_NULL(qn->head_exact))
 	  n = qn->head_exact;
 	else
+#endif
 	  n = get_head_value_node(qn->target, exact, reg);
       }
     }
@@ -2854,8 +2857,8 @@ check_type_tree(Node* node, int type_mask, int enclose_mask, int anchor_mask)
 
 #ifdef USE_SUBEXP_CALL
 
-#define RECURSION_EXIST       1
-#define RECURSION_INFINITE    2
+# define RECURSION_EXIST       1
+# define RECURSION_INFINITE    2
 
 static int
 subexp_inf_recursive_check(Node* node, ScanEnv* env, int head)
@@ -3055,7 +3058,7 @@ subexp_recursive_check(Node* node)
 static int
 subexp_recursive_check_trav(Node* node, ScanEnv* env)
 {
-#define FOUND_CALLED_NODE    1
+# define FOUND_CALLED_NODE    1
 
   int type;
   int r = 0;
@@ -3156,22 +3159,22 @@ setup_subexp_call(Node* node, ScanEnv* env)
       if (cn->group_num != 0) {
 	int gnum = cn->group_num;
 
-#ifdef USE_NAMED_GROUP
+# 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;
 	}
-#endif
+# 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;
 	}
 
-#ifdef USE_NAMED_GROUP
+# ifdef USE_NAMED_GROUP
       set_call_attr:
-#endif
+# endif
 	cn->target = nodes[cn->group_num];
 	if (IS_NULL(cn->target)) {
 	  onig_scan_env_set_error_string(env,
@@ -3182,12 +3185,12 @@ setup_subexp_call(Node* node, ScanEnv* env)
 	BIT_STATUS_ON_AT(env->bt_mem_start, cn->group_num);
 	cn->unset_addr_list = env->unset_addr_list;
       }
-#ifdef USE_NAMED_GROUP
-#ifdef USE_PERL_SUBEXP_CALL
+# ifdef USE_NAMED_GROUP
+#  ifdef USE_PERL_SUBEXP_CALL
       else if (cn->name == cn->name_end) {
 	goto set_call_attr;
       }
-#endif
+#  endif
       else {
 	int *refs;
 
@@ -3209,7 +3212,7 @@ setup_subexp_call(Node* node, ScanEnv* env)
 	  goto set_call_attr;
 	}
       }
-#endif
+# endif
     }
     break;
 
@@ -3398,13 +3401,9 @@ update_string_node_case_fold(regex_t* reg, Node *node)
   }
 
   r = onig_node_str_set(node, sbuf, sp);
-  if (r != 0) {
-    xfree(sbuf);
-    return r;
-  }
 
   xfree(sbuf);
-  return 0;
+  return r;
 }
 
 static int
@@ -3512,29 +3511,29 @@ expand_case_fold_string_alt(int item_num, OnigCaseFoldCodeItem items[],
       UChar *q = p + items[i].byte_len;
 
       if (q < end) {
-        r = expand_case_fold_make_rem_string(&rem, q, end, reg);
-        if (r != 0) {
-          onig_node_free(an);
-          goto mem_err2;
-        }
+	r = expand_case_fold_make_rem_string(&rem, q, end, reg);
+	if (r != 0) {
+	  onig_node_free(an);
+	  goto mem_err2;
+	}
 
-        xnode = onig_node_list_add(NULL_NODE, snode);
-        if (IS_NULL(xnode)) {
-          onig_node_free(an);
-          onig_node_free(rem);
-          goto mem_err2;
-        }
-        if (IS_NULL(onig_node_list_add(xnode, rem))) {
-          onig_node_free(an);
-          onig_node_free(xnode);
-          onig_node_free(rem);
-          goto mem_err;
-        }
+	xnode = onig_node_list_add(NULL_NODE, snode);
+	if (IS_NULL(xnode)) {
+	  onig_node_free(an);
+	  onig_node_free(rem);
+	  goto mem_err2;
+	}
+	if (IS_NULL(onig_node_list_add(xnode, rem))) {
+	  onig_node_free(an);
+	  onig_node_free(xnode);
+	  onig_node_free(rem);
+	  goto mem_err;
+	}
 
-        NCAR(an) = xnode;
+	NCAR(an) = xnode;
       }
       else {
-        NCAR(an) = snode;
+	NCAR(an) = snode;
       }
 
       NCDR(var_anode) = an;
@@ -3711,12 +3710,12 @@ expand_case_fold_string(Node* node, regex_t* reg)
 
 #ifdef USE_COMBINATION_EXPLOSION_CHECK
 
-#define CEC_THRES_NUM_BIG_REPEAT         512
-#define CEC_INFINITE_NUM          0x7fffffff
+# define CEC_THRES_NUM_BIG_REPEAT         512
+# define CEC_INFINITE_NUM          0x7fffffff
 
-#define CEC_IN_INFINITE_REPEAT    (1<<0)
-#define CEC_IN_FINITE_REPEAT      (1<<1)
-#define CEC_CONT_BIG_REPEAT       (1<<2)
+# define CEC_IN_INFINITE_REPEAT    (1<<0)
+# define CEC_IN_FINITE_REPEAT      (1<<1)
+# define CEC_CONT_BIG_REPEAT       (1<<2)
 
 static int
 setup_comb_exp_check(Node* node, int state, ScanEnv* env)
@@ -3832,14 +3831,14 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
     }
     break;
 
-#ifdef USE_SUBEXP_CALL
+# ifdef USE_SUBEXP_CALL
   case NT_CALL:
     if (IS_CALL_RECURSION(NCALL(node)))
       env->has_recursion = 1;
     else
       r = setup_comb_exp_check(NCALL(node)->target, state, env);
     break;
-#endif
+# endif
 
   default:
     break;
@@ -3854,6 +3853,8 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
 #define IN_REPEAT     (1<<2)
 #define IN_VAR_REPEAT (1<<3)
 #define IN_ROOT       (1<<4)
+#define IN_CALL       (1<<5)
+#define IN_RECCALL    (1<<6)
 
 /* setup_tree does the following work.
  1. check empty loop. (set qn->target_empty_info)
@@ -3943,7 +3944,7 @@ restart:
       Node* target = qn->target;
 
       if ((state & IN_REPEAT) != 0) {
-        qn->state |= NST_IN_REPEAT;
+	qn->state |= NST_IN_REPEAT;
       }
 
       if (IS_REPEAT_INFINITE(qn->upper) || qn->upper >= 1) {
@@ -4058,12 +4059,18 @@ restart:
 	break;
 
       case ENCLOSE_MEMORY:
-	if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT)) != 0) {
+	if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_CALL)) != 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;
+	if (IS_ENCLOSE_CALLED(en))
+	  state |= IN_CALL;
+	if (IS_ENCLOSE_RECURSION(en))
+	  state |= IN_RECCALL;
+	else if ((state & IN_RECCALL) != 0)
+	  SET_CALL_RECURSION(node);
+	r = setup_tree(en->target, reg, state, env);
+	break;
 
       case ENCLOSE_STOP_BACKTRACK:
 	{
@@ -4090,6 +4097,8 @@ restart:
 	  return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
 	}
 #endif
+	if (NENCLOSE(node)->regnum > env->num_mem)
+	  return ONIGERR_INVALID_BACKREF;
 	r = setup_tree(NENCLOSE(node)->target, reg, state, env);
 	break;
       }
@@ -4133,10 +4142,10 @@ restart:
 			      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;
 	  if (NTYPE(node) != NT_ANCHOR) goto restart;
 	  r = setup_tree(an->target, reg, state, env);
+	  if (r != 0) return r;
+	  r = setup_look_behind(node, reg, env);
 	}
 	break;
 
@@ -4146,10 +4155,10 @@ restart:
 		      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;
 	  if (NTYPE(node) != NT_ANCHOR) goto restart;
 	  r = setup_tree(an->target, reg, (state | IN_NOT), env);
+	  if (r != 0) return r;
+	  r = setup_look_behind(node, reg, env);
 	}
 	break;
       }
@@ -4203,6 +4212,10 @@ set_bm_skip(UChar* s, UChar* end, regex_t* reg,
     }
   }
   else {
+# if OPT_EXACT_MAXLEN < ONIG_CHAR_TABLE_SIZE
+    /* This should not happen. */
+    return ONIGERR_TYPE_BUG;
+# else
     if (IS_NULL(*int_skip)) {
       *int_skip = (int* )xmalloc(sizeof(int) * ONIG_CHAR_TABLE_SIZE);
       if (IS_NULL(*int_skip)) return ONIGERR_MEMORY;
@@ -4231,6 +4244,7 @@ set_bm_skip(UChar* s, UChar* end, regex_t* reg,
 	}
       }
     }
+# endif
   }
   return 0;
 }
@@ -4276,6 +4290,10 @@ set_bm_skip(UChar* s, UChar* end, regex_t* reg,
     }
   }
   else {
+# if OPT_EXACT_MAXLEN < ONIG_CHAR_TABLE_SIZE
+    /* This should not happen. */
+    return ONIGERR_TYPE_BUG;
+# else
     if (IS_NULL(*int_skip)) {
       *int_skip = (int* )xmalloc(sizeof(int) * ONIG_CHAR_TABLE_SIZE);
       if (IS_NULL(*int_skip)) return ONIGERR_MEMORY;
@@ -4304,13 +4322,12 @@ set_bm_skip(UChar* s, UChar* end, regex_t* reg,
 	}
       }
     }
+# endif
   }
   return 0;
 }
 #endif /* USE_SUNDAY_QUICK_SEARCH */
 
-#define OPT_EXACT_MAXLEN   24
-
 typedef struct {
   OnigDistance min;  /* min byte length */
   OnigDistance max;  /* max byte length */
@@ -4980,14 +4997,14 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 	if (slen > 0) {
 	  add_char_opt_map_info(&opt->map, *(sn->s), env->enc);
 	}
-        set_mml(&opt->len, slen, slen);
+	set_mml(&opt->len, slen, slen);
       }
       else {
-        OnigDistance max;
+	OnigDistance max;
 
 	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;
+	  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,
@@ -5003,7 +5020,7 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 	  max = slen;
 	}
 
-        set_mml(&opt->len, slen, max);
+	set_mml(&opt->len, slen, max);
       }
 
       if ((OnigDistance )opt->exb.len == slen)
@@ -5019,18 +5036,18 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       /* no need to check ignore case. (set in setup_tree()) */
 
       if (IS_NOT_NULL(cc->mbuf) || IS_NCCLASS_NOT(cc)) {
-        OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);
+	OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);
 	OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
 
 	set_mml(&opt->len, min, max);
       }
       else {
-        for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-          z = BITSET_AT(cc->bs, i);
-          if ((z && !IS_NCCLASS_NOT(cc)) || (!z && IS_NCCLASS_NOT(cc))) {
-            add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
-          }
-        }
+	for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+	  z = BITSET_AT(cc->bs, i);
+	  if ((z && !IS_NCCLASS_NOT(cc)) || (!z && IS_NCCLASS_NOT(cc))) {
+	    add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
+	  }
+	}
 	set_mml(&opt->len, 1, 1);
       }
     }
@@ -5044,7 +5061,7 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
 
       if (max == 1) {
-        min = 1;
+	min = 1;
 
 	maxcode = NCTYPE(node)->ascii_range ? 0x80 : SINGLE_BYTE_SIZE;
 	switch (NCTYPE(node)->ctype) {
@@ -5067,7 +5084,7 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 	}
       }
       else {
-        min = ONIGENC_MBC_MINLEN(env->enc);
+	min = ONIGENC_MBC_MINLEN(env->enc);
       }
       set_mml(&opt->len, min, max);
     }
@@ -5186,7 +5203,7 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 	  if (nopt.exb.len > 0) {
 	    if (nopt.exb.reach_end) {
 	      for (i = 2; i <= qn->lower &&
-		          ! is_full_opt_exact_info(&opt->exb); i++) {
+			  ! is_full_opt_exact_info(&opt->exb); i++) {
 		concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc);
 	      }
 	      if (i < qn->lower) {
@@ -5308,11 +5325,14 @@ set_optimize_exact_info(regex_t* reg, OptExactInfo* e)
   else {
     if (e->len >= 3 || (e->len >= 2 && allow_reverse)) {
       r = set_bm_skip(reg->exact, reg->exact_end, reg,
-	              reg->map, &(reg->int_map), 0);
-      if (r) return r;
-
-      reg->optimize = (allow_reverse != 0
+		      reg->map, &(reg->int_map), 0);
+      if (r == 0) {
+	reg->optimize = (allow_reverse != 0
 		       ? ONIG_OPTIMIZE_EXACT_BM : ONIG_OPTIMIZE_EXACT_BM_NOT_REV);
+      }
+      else {
+	reg->optimize = ONIG_OPTIMIZE_EXACT;
+      }
     }
     else {
       reg->optimize = ONIG_OPTIMIZE_EXACT;
@@ -5378,6 +5398,9 @@ set_optimize_info_from_tree(Node* node, regex_t* reg, ScanEnv* scan_env)
         ANCHOR_BEGIN_POSITION | ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML |
         ANCHOR_LOOK_BEHIND);
 
+  if ((opt.anc.left_anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) != 0)
+    reg->anchor &= ~ANCHOR_ANYCHAR_STAR_ML;
+
   reg->anchor |= opt.anc.right_anchor & (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF |
 	ANCHOR_PREC_READ_NOT);
 
@@ -5570,14 +5593,14 @@ print_optimize_info(FILE* f, regex_t* reg)
       fputc('[', f);
       for (i = 0; i < ONIG_CHAR_TABLE_SIZE; i++) {
 	if (reg->map[i] != 0) {
-          if (c > 0)  fputs(", ", f);
-          c++;
-          if (ONIGENC_MBC_MAXLEN(reg->enc) == 1 &&
-              ONIGENC_IS_CODE_PRINT(reg->enc, (OnigCodePoint )i))
-            fputc(i, f);
-          else
-            fprintf(f, "%d", i);
-        }
+	  if (c > 0)  fputs(", ", f);
+	  c++;
+	  if (ONIGENC_MBC_MAXLEN(reg->enc) == 1 &&
+	      ONIGENC_IS_CODE_PRINT(reg->enc, (OnigCodePoint )i))
+	    fputc(i, f);
+	  else
+	    fprintf(f, "%d", i);
+	}
       }
       fprintf(f, "]\n");
     }
@@ -5612,6 +5635,7 @@ onig_free(regex_t* reg)
   }
 }
 
+#ifdef RUBY
 size_t
 onig_memsize(const regex_t *reg)
 {
@@ -5635,65 +5659,47 @@ onig_region_memsize(const OnigRegion *regs)
     size += regs->allocated * (sizeof(*regs->beg) + sizeof(*regs->end));
     return size;
 }
+#endif
 
 #define REGEX_TRANSFER(to,from) do {\
-  (to)->state = ONIG_STATE_MODIFY;\
   onig_free_body(to);\
   xmemcpy(to, from, sizeof(regex_t));\
   xfree(from);\
 } while (0)
 
+#if 0
 extern void
 onig_transfer(regex_t* to, regex_t* from)
 {
-  THREAD_ATOMIC_START;
   REGEX_TRANSFER(to, from);
-  THREAD_ATOMIC_END;
-}
-
-#define REGEX_CHAIN_HEAD(reg) do {\
-  while (IS_NOT_NULL((reg)->chain)) {\
-    (reg) = (reg)->chain;\
-  }\
-} while (0)
-
-extern void
-onig_chain_link_add(regex_t* to, regex_t* add)
-{
-  THREAD_ATOMIC_START;
-  REGEX_CHAIN_HEAD(to);
-  to->chain = add;
-  THREAD_ATOMIC_END;
-}
-
-extern void
-onig_chain_reduce(regex_t* reg)
-{
-  regex_t *head, *prev;
-
-  prev = reg;
-  head = prev->chain;
-  if (IS_NOT_NULL(head)) {
-    reg->state = ONIG_STATE_MODIFY;
-    while (IS_NOT_NULL(head->chain)) {
-      prev = head;
-      head = head->chain;
-    }
-    prev->chain = (regex_t* )NULL;
-    REGEX_TRANSFER(reg, head);
-  }
 }
+#endif
 
 #ifdef ONIG_DEBUG_COMPILE
-static void print_compiled_byte_code_list P_((FILE* f, regex_t* reg));
+static void print_compiled_byte_code_list(FILE* f, regex_t* reg);
 #endif
 #ifdef ONIG_DEBUG_PARSE_TREE
-static void print_tree P_((FILE* f, Node* node));
+static void print_tree(FILE* f, Node* node);
 #endif
 
+#ifdef RUBY
 extern int
 onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
+	     OnigErrorInfo* einfo)
+{
+  return onig_compile_ruby(reg, pattern, pattern_end, einfo, NULL, 0);
+}
+#endif
+
+#ifdef RUBY
+extern int
+onig_compile_ruby(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
 	      OnigErrorInfo* einfo, const char *sourcefile, int sourceline)
+#else
+extern int
+onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
+	     OnigErrorInfo* einfo)
+#endif
 {
 #define COMPILE_INIT_SIZE  20
 
@@ -5707,9 +5713,10 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
 
   if (IS_NOT_NULL(einfo)) einfo->par = (UChar* )NULL;
 
+#ifdef RUBY
   scan_env.sourcefile = sourcefile;
   scan_env.sourceline = sourceline;
-  reg->state = ONIG_STATE_COMPILING;
+#endif
 
 #ifdef ONIG_DEBUG
   print_enc_string(stderr, reg->enc, pattern, pattern_end);
@@ -5794,17 +5801,17 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
 
 #ifdef USE_COMBINATION_EXPLOSION_CHECK
   if (scan_env.backrefed_mem == 0
-#ifdef USE_SUBEXP_CALL
+# ifdef USE_SUBEXP_CALL
       || scan_env.num_call == 0
-#endif
+# endif
       ) {
     setup_comb_exp_check(root, 0, &scan_env);
-#ifdef USE_SUBEXP_CALL
+# ifdef USE_SUBEXP_CALL
     if (scan_env.has_recursion != 0) {
       scan_env.num_comb_exp_check = 0;
     }
     else
-#endif
+# endif
     if (scan_env.comb_exp_max_regnum > 0) {
       int i;
       for (i = 1; i <= scan_env.comb_exp_max_regnum; i++) {
@@ -5858,14 +5865,13 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
   onig_node_free(root);
 
 #ifdef ONIG_DEBUG_COMPILE
-#ifdef USE_NAMED_GROUP
+# ifdef USE_NAMED_GROUP
   onig_print_names(stderr, reg);
-#endif
+# endif
   print_compiled_byte_code_list(stderr, reg);
 #endif
 
  end:
-  reg->state = ONIG_STATE_NORMAL;
   return r;
 
  err_unset:
@@ -5889,27 +5895,6 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
   return r;
 }
 
-#ifdef USE_RECOMPILE_API
-extern int
-onig_recompile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
-	    OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax,
-	    OnigErrorInfo* einfo)
-{
-  int r;
-  regex_t *new_reg;
-
-  r = onig_new(&new_reg, pattern, pattern_end, option, enc, syntax, einfo);
-  if (r) return r;
-  if (ONIG_STATE(reg) == ONIG_STATE_NORMAL) {
-    onig_transfer(reg, new_reg);
-  }
-  else {
-    onig_chain_link_add(reg, new_reg);
-  }
-  return 0;
-}
-#endif
-
 static int onig_inited = 0;
 
 extern int
@@ -5931,8 +5916,6 @@ onig_reg_init(regex_t* reg, OnigOptionType option,
     return ONIGERR_INVALID_COMBINATION_OF_OPTIONS;
   }
 
-  (reg)->state = ONIG_STATE_MODIFY;
-
   if ((option & ONIG_OPTION_NEGATE_SINGLELINE) != 0) {
     option |= syntax->options;
     option &= ~ONIG_OPTION_SINGLELINE;
@@ -5968,7 +5951,7 @@ onig_new_without_alloc(regex_t* reg, const UChar* pattern,
   r = onig_reg_init(reg, option, ONIGENC_CASE_FOLD_DEFAULT, enc, syntax);
   if (r) return r;
 
-  r = onig_compile(reg, pattern, pattern_end, einfo, NULL, 0);
+  r = onig_compile(reg, pattern, pattern_end, einfo);
   return r;
 }
 
@@ -5985,7 +5968,7 @@ onig_new(regex_t** reg, const UChar* pattern, const UChar* pattern_end,
   r = onig_reg_init(*reg, option, ONIGENC_CASE_FOLD_DEFAULT, enc, syntax);
   if (r) goto err;
 
-  r = onig_compile(*reg, pattern, pattern_end, einfo, NULL, 0);
+  r = onig_compile(*reg, pattern, pattern_end, einfo);
   if (r) {
   err:
     onig_free(*reg);
@@ -5994,6 +5977,11 @@ onig_new(regex_t** reg, const UChar* pattern, const UChar* pattern_end,
   return r;
 }
 
+extern int
+onig_initialize(OnigEncoding encodings[] ARG_UNUSED, int n ARG_UNUSED)
+{
+  return onig_init();
+}
 
 extern int
 onig_init(void)
@@ -6001,11 +5989,12 @@ onig_init(void)
   if (onig_inited != 0)
     return 0;
 
-  THREAD_SYSTEM_INIT;
-  THREAD_ATOMIC_START;
-
   onig_inited = 1;
 
+#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER)
+  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
+#endif
+
   onigenc_init();
   /* onigenc_set_default_caseconv_table((UChar* )0); */
 
@@ -6013,7 +6002,6 @@ onig_init(void)
   onig_statistics_init();
 #endif
 
-  THREAD_ATOMIC_END;
   return 0;
 }
 
@@ -6052,26 +6040,18 @@ exec_end_call_list(void)
 extern int
 onig_end(void)
 {
-  THREAD_ATOMIC_START;
-
   exec_end_call_list();
 
 #ifdef ONIG_DEBUG_STATISTICS
   onig_print_statistics(stderr);
 #endif
 
-#ifdef USE_SHARED_CCLASS_TABLE
-  onig_free_shared_cclass_table();
-#endif
-
-#ifdef USE_PARSE_TREE_NODE_RECYCLE
-  onig_free_node_list();
+#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER)
+  _CrtDumpMemoryLeaks();
 #endif
 
   onig_inited = 0;
 
-  THREAD_ATOMIC_END;
-  THREAD_SYSTEM_END;
   return 0;
 }
 
@@ -6137,14 +6117,14 @@ onig_is_code_in_cc(OnigEncoding enc, OnigCodePoint code, CClassNode* cc)
 #ifdef ONIG_DEBUG
 
 /* arguments type */
-#define ARG_SPECIAL     -1
-#define ARG_NON          0
-#define ARG_RELADDR      1
-#define ARG_ABSADDR      2
-#define ARG_LENGTH       3
-#define ARG_MEMNUM       4
-#define ARG_OPTION       5
-#define ARG_STATE_CHECK  6
+# define ARG_SPECIAL     -1
+# define ARG_NON          0
+# define ARG_RELADDR      1
+# define ARG_ABSADDR      2
+# define ARG_LENGTH       3
+# define ARG_MEMNUM       4
+# define ARG_OPTION       5
+# define ARG_STATE_CHECK  6
 
 OnigOpInfoType OnigOpInfo[] = {
   { OP_FINISH,            "finish",          ARG_NON },
@@ -6169,7 +6149,6 @@ OnigOpInfoType OnigOpInfo[] = {
   { OP_CCLASS_NOT,        "cclass-not",      ARG_SPECIAL },
   { OP_CCLASS_MB_NOT,     "cclass-mb-not",   ARG_SPECIAL },
   { OP_CCLASS_MIX_NOT,    "cclass-mix-not",  ARG_SPECIAL },
-  { OP_CCLASS_NODE,       "cclass-node",     ARG_SPECIAL },
   { OP_ANYCHAR,           "anychar",         ARG_NON },
   { OP_ANYCHAR_ML,        "anychar-ml",      ARG_NON },
   { OP_ANYCHAR_STAR,      "anychar*",        ARG_NON },
@@ -6272,14 +6251,14 @@ op2arg_type(int opcode)
   return ARG_SPECIAL;
 }
 
-#ifdef ONIG_DEBUG_PARSE_TREE
+# ifdef ONIG_DEBUG_PARSE_TREE
 static void
 Indent(FILE* f, int indent)
 {
   int i;
   for (i = 0; i < indent; i++) putc(' ', f);
 }
-#endif /* ONIG_DEBUG_PARSE_TREE */
+# endif /* ONIG_DEBUG_PARSE_TREE */
 
 static void
 p_string(FILE* f, ptrdiff_t len, UChar* s)
@@ -6318,7 +6297,7 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
       break;
     case ARG_RELADDR:
       GET_RELADDR_INC(addr, bp);
-      fprintf(f, ":(+%d)", addr);
+      fprintf(f, ":(%s%d)", (addr >= 0) ? "+" : "", addr);
       break;
     case ARG_ABSADDR:
       GET_ABSADDR_INC(addr, bp);
@@ -6423,9 +6402,9 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
     case OP_CCLASS_MB_NOT:
       GET_LENGTH_INC(len, bp);
       q = bp;
-#ifndef PLATFORM_UNALIGNED_WORD_ACCESS
+# ifndef PLATFORM_UNALIGNED_WORD_ACCESS
       ALIGNMENT_RIGHT(q);
-#endif
+# endif
       GET_CODE_POINT(code, q);
       bp += len;
       fprintf(f, ":%d:%d", (int )code, len);
@@ -6437,24 +6416,14 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
       bp += SIZE_BITSET;
       GET_LENGTH_INC(len, bp);
       q = bp;
-#ifndef PLATFORM_UNALIGNED_WORD_ACCESS
+# ifndef PLATFORM_UNALIGNED_WORD_ACCESS
       ALIGNMENT_RIGHT(q);
-#endif
+# endif
       GET_CODE_POINT(code, q);
       bp += len;
       fprintf(f, ":%d:%d:%d", n, (int )code, len);
       break;
 
-    case OP_CCLASS_NODE:
-      {
-        CClassNode *cc;
-
-        GET_POINTER_INC(cc, bp);
-        n = bitset_on_num(cc->bs);
-        fprintf(f, ":%"PRIuPTR":%d", (uintptr_t )cc, n);
-      }
-      break;
-
     case OP_BACKREFN_IC:
       mem = *((MemNumType* )bp);
       bp += SIZE_MEMNUM;
@@ -6507,7 +6476,7 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
     case OP_PUSH_IF_PEEK_NEXT:
       addr = *((RelAddrType* )bp);
       bp += SIZE_RELADDR;
-      fprintf(f, ":(%d)", addr);
+      fprintf(f, ":(%s%d)", (addr >= 0) ? "+" : "", addr);
       p_string(f, 1, bp);
       bp += 1;
       break;
@@ -6520,7 +6489,7 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
     case OP_PUSH_LOOK_BEHIND_NOT:
       GET_RELADDR_INC(addr, bp);
       GET_LENGTH_INC(len, bp);
-      fprintf(f, ":%d:(%d)", len, addr);
+      fprintf(f, ":%d:(%s%d)", len, (addr >= 0) ? "+" : "", addr);
       break;
 
     case OP_STATE_CHECK_PUSH:
@@ -6529,13 +6498,13 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
       bp += SIZE_STATE_CHECK_NUM;
       addr = *((RelAddrType* )bp);
       bp += SIZE_RELADDR;
-      fprintf(f, ":%d:(%d)", scn, addr);
+      fprintf(f, ":%d:(%s%d)", scn, (addr >= 0) ? "+" : "", addr);
       break;
 
     case OP_CONDITION:
       GET_MEMNUM_INC(mem, bp);
       GET_RELADDR_INC(addr, bp);
-      fprintf(f, ":%d:(%d)", mem, addr);
+      fprintf(f, ":%d:(%s%d)", mem, (addr >= 0) ? "+" : "", addr);
       break;
 
     default:
@@ -6547,7 +6516,7 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
   if (nextp) *nextp = bp;
 }
 
-#ifdef ONIG_DEBUG_COMPILE
+# ifdef ONIG_DEBUG_COMPILE
 static void
 print_compiled_byte_code_list(FILE* f, regex_t* reg)
 {
@@ -6569,9 +6538,9 @@ print_compiled_byte_code_list(FILE* f, regex_t* reg)
 
   fprintf(f, "\n");
 }
-#endif /* ONIG_DEBUG_COMPILE */
+# endif /* ONIG_DEBUG_COMPILE */
 
-#ifdef ONIG_DEBUG_PARSE_TREE
+# ifdef ONIG_DEBUG_PARSE_TREE
 void
 print_indent_tree(FILE* f, Node* node, int indent)
 {
@@ -6621,8 +6590,8 @@ print_indent_tree(FILE* f, Node* node, int indent)
     if (IS_NCCLASS_NOT(NCCLASS(node))) fputs("not ", f);
     if (NCCLASS(node)->mbuf) {
       BBuf* bbuf = NCCLASS(node)->mbuf;
-      OnigCodePoint* data = (OnigCodePoint*)bbuf->p;
-      OnigCodePoint* end = (OnigCodePoint*)(bbuf->p + bbuf->used);
+      OnigCodePoint* data = (OnigCodePoint* )bbuf->p;
+      OnigCodePoint* end = (OnigCodePoint* )(bbuf->p + bbuf->used);
       fprintf(f, "%d", *data++);
       for (; data < end; data+=2) {
 	fprintf(f, ",");
@@ -6664,10 +6633,10 @@ print_indent_tree(FILE* f, Node* node, int indent)
 
     case ANCHOR_WORD_BOUND:      fputs("word bound",     f); break;
     case ANCHOR_NOT_WORD_BOUND:  fputs("not word bound", f); break;
-#ifdef USE_WORD_BEGIN_END
+#  ifdef USE_WORD_BEGIN_END
     case ANCHOR_WORD_BEGIN:      fputs("word begin", f);     break;
     case ANCHOR_WORD_END:        fputs("word end", f);       break;
-#endif
+#  endif
     case ANCHOR_PREC_READ:       fputs("prec read",      f); container_p = TRUE; break;
     case ANCHOR_PREC_READ_NOT:   fputs("prec read not",  f); container_p = TRUE; break;
     case ANCHOR_LOOK_BEHIND:     fputs("look_behind",    f); container_p = TRUE; break;
@@ -6693,7 +6662,7 @@ print_indent_tree(FILE* f, Node* node, int indent)
     }
     break;
 
-#ifdef USE_SUBEXP_CALL
+#  ifdef USE_SUBEXP_CALL
   case NT_CALL:
     {
       CallNode* cn = NCALL(node);
@@ -6701,7 +6670,7 @@ print_indent_tree(FILE* f, Node* node, int indent)
       p_string(f, cn->name_end - cn->name, cn->name);
     }
     break;
-#endif
+#  endif
 
   case NT_QTFR:
     fprintf(f, "<quantifier:%"PRIxPTR">{%d,%d}%s\n", (intptr_t )node,
@@ -6752,5 +6721,5 @@ print_tree(FILE* f, Node* node)
 {
   print_indent_tree(f, node, 0);
 }
-#endif /* ONIG_DEBUG_PARSE_TREE */
+# endif /* ONIG_DEBUG_PARSE_TREE */
 #endif /* ONIG_DEBUG */