34 files changed, 284 insertions, 197 deletions

diff --git a/.gitignore b/.gitignore
index 7e6e49b76..4bb5041e7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,6 +22,7 @@ cscope.out
 /test/mrbtest
 /test/mrbtest.c
 /test/*.*tmp
+/test/mrubytest.*
 CMakeFiles
 CMakeCache.txt
 /mrbgems/generator
diff --git a/include/mruby.h b/include/mruby.h
index 94fa393ea..4a5b5ce88 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -46,8 +46,6 @@ typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
 #ifndef MRB_ARENA_SIZE
 #define MRB_ARENA_SIZE 1024
 #endif
-#define ruby_debug   (mrb_nil_value())
-#define ruby_verbose (mrb_nil_value())
 
 typedef struct {
   mrb_sym mid;
@@ -304,23 +302,6 @@ void mrb_bug(const char *fmt, ...);
 
 #define E_KEY_ERROR                 (mrb_class_obj_get(mrb, "KeyError"))
 
-#define SYM2ID(x) ((x).value.sym)
-
-#define NUM2CHR_internal(x) (((mrb_type(x) == MRB_TT_STRING)&&(RSTRING_LEN(x)>=1))?\
-                     RSTRING_PTR(x)[0]:(char)(mrb_fixnum_number(x)&0xff))
-#ifdef __GNUC__
-# define NUM2CHR(x) __extension__ ({mrb_value num2chr_x = (x); NUM2CHR_internal(num2chr_x);})
-#else
-/* TODO: there is no definitions of RSTRING_* here, so cannot compile.
-static inline char
-NUM2CHR(mrb_value x)
-{
-    return NUM2CHR_internal(x);
-}
-*/
-#define NUM2CHR(x) NUM2CHR_internal(x)
-#endif
-
 mrb_value mrb_yield(mrb_state *mrb, mrb_value v, mrb_value blk);
 mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv);
 mrb_value mrb_class_new_instance(mrb_state *mrb, int, mrb_value*, struct RClass *);
diff --git a/include/mruby/class.h b/include/mruby/class.h
index 3eae31f4e..eda54dff9 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -64,6 +64,7 @@ struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
 void mrb_define_method_vm(mrb_state*, struct RClass*, mrb_sym, mrb_value);
 void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, struct RProc *);
 void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, int aspec);
+void mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b);
 
 struct RClass *mrb_class_outer_module(mrb_state*, struct RClass *);
 struct RProc *mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
diff --git a/include/mruby/object.h b/include/mruby/object.h
deleted file mode 100644
index afdce5546..000000000
--- a/include/mruby/object.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-** mruby/object.h - Object, NilClass, TrueClass, FalseClass class
-**
-** See Copyright Notice in mruby.h
-*/
-
-#ifndef MRUBY_OBJECT_H
-#define MRUBY_OBJECT_H
-
-#define MRB_OBJECT_HEADER \
-  enum mrb_vtype tt:8;\
-  unsigned int color:3;\
-  unsigned int flags:21;\
-  struct RClass *c;\
-  struct RBasic *gcnext
-
-/* white: 011, black: 100, gray: 000 */
-#define MRB_GC_GRAY 0
-#define MRB_GC_WHITE_A 1
-#define MRB_GC_WHITE_B (1 << 1)
-#define MRB_GC_BLACK (1 << 2)
-#define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B)
-#define MRB_GC_COLOR_MASK 7
-
-#define paint_gray(o) ((o)->color = MRB_GC_GRAY)
-#define paint_black(o) ((o)->color = MRB_GC_BLACK)
-#define paint_white(o) ((o)->color = MRB_GC_WHITES)
-#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
-#define is_gray(o) ((o)->color == MRB_GC_GRAY)
-#define is_white(o) ((o)->color & MRB_GC_WHITES)
-#define is_black(o) ((o)->color & MRB_GC_BLACK)
-#define is_dead(s, o) (((o)->color & other_white_part(s) & MRB_GC_WHITES) || (o)->tt == MRB_TT_FREE)
-#define flip_white_part(s) ((s)->current_white_part = other_white_part(s))
-#define other_white_part(s) ((s)->current_white_part ^ MRB_GC_WHITES)
-
-struct RBasic {
-  MRB_OBJECT_HEADER;
-};
-
-struct RObject {
-  MRB_OBJECT_HEADER;
-  struct iv_tbl *iv;
-};
-
-#define mrb_obj_ptr(v)    ((struct RObject*)((v).value.p))
-#define RBASIC(obj)  ((struct RBasic*)((obj).value.p))
-#define RBASIC_KLASS(v) ((struct RClass *)(((struct RBasic*)((v).value.p))->c))
-#define ROBJECT(v) ((struct RObject*)((v).value.p))
-#define ROBJECT_IVPTR(v) (((struct RObject*)((v).value.p))->iv)
-#define ROBJECT_NUMIV(v) (ROBJECT_IVPTR(v) ? ROBJECT_IVPTR(v)->size : 0)
-
-#endif  /* MRUBY_OBJECT_H */
diff --git a/include/mruby/value.h b/include/mruby/value.h
index 70e0e9b3f..90c011a7e 100644
--- a/include/mruby/value.h
+++ b/include/mruby/value.h
@@ -149,31 +149,56 @@ mrb_float_value(mrb_float f)
 #define mrb_fixnum(o) (o).value.i
 #define mrb_symbol(o) (o).value.sym
 #define mrb_object(o) ((struct RBasic *) (o).value.p)
-#define FIXNUM_P(o)   (mrb_type(o) == MRB_TT_FIXNUM)
+#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM)
+#define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
 #define mrb_undef_p(o) (mrb_type(o) == MRB_TT_UNDEF)
 #define mrb_nil_p(o)  (mrb_type(o) == MRB_TT_FALSE && !(o).value.i)
+#define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
+#define mrb_array_p(o) (mrb_type(o) == MRB_TT_ARRAY)
+#define mrb_string_p(o) (mrb_type(o) == MRB_TT_STRING)
+#define mrb_hash_p(o) (mrb_type(o) == MRB_TT_HASH)
 #define mrb_test(o)   (mrb_type(o) != MRB_TT_FALSE)
 
-#include "mruby/object.h"
+#define MRB_OBJECT_HEADER \
+  enum mrb_vtype tt:8;\
+  unsigned int color:3;\
+  unsigned int flags:21;\
+  struct RClass *c;\
+  struct RBasic *gcnext
+
+/* white: 011, black: 100, gray: 000 */
+#define MRB_GC_GRAY 0
+#define MRB_GC_WHITE_A 1
+#define MRB_GC_WHITE_B (1 << 1)
+#define MRB_GC_BLACK (1 << 2)
+#define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B)
+#define MRB_GC_COLOR_MASK 7
+
+#define paint_gray(o) ((o)->color = MRB_GC_GRAY)
+#define paint_black(o) ((o)->color = MRB_GC_BLACK)
+#define paint_white(o) ((o)->color = MRB_GC_WHITES)
+#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
+#define is_gray(o) ((o)->color == MRB_GC_GRAY)
+#define is_white(o) ((o)->color & MRB_GC_WHITES)
+#define is_black(o) ((o)->color & MRB_GC_BLACK)
+#define is_dead(s, o) (((o)->color & other_white_part(s) & MRB_GC_WHITES) || (o)->tt == MRB_TT_FREE)
+#define flip_white_part(s) ((s)->current_white_part = other_white_part(s))
+#define other_white_part(s) ((s)->current_white_part ^ MRB_GC_WHITES)
+
+struct RBasic {
+  MRB_OBJECT_HEADER;
+};
 
-#define IMMEDIATE_P(x) (mrb_type(x) <= MRB_TT_MAIN)
-#define SPECIAL_CONST_P(x) IMMEDIATE_P(x)
-#define SYMBOL_P(o) (mrb_type(o) == MRB_TT_SYMBOL)
-#define RTEST(o) mrb_test(o)
+#define mrb_basic(v)     ((struct RBasic*)((v).value.p))
 
-#define FL_ABLE(x) (!SPECIAL_CONST_P(x))
-#define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0)
-#define FL_ANY(x,f) FL_TEST(x,f)
-#define FL_ALL(x,f) (FL_TEST(x,f) == (f))
-#define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0)
-#define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0)
+struct RObject {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+};
 
-static inline mrb_int
-mrb_special_const_p(mrb_value obj)
-{
-  if (SPECIAL_CONST_P(obj)) return 1;
-  return 0;
-}
+#define mrb_obj_ptr(v)   ((struct RObject*)((v).value.p))
+#define mrb_immediate_p(x) (mrb_type(x) <= MRB_TT_MAIN)
+#define mrb_special_const_p(x) mrb_immediate_p(x)
 
 static inline mrb_value
 mrb_fixnum_value(mrb_int i)
@@ -197,7 +222,7 @@ static inline mrb_value
 mrb_obj_value(void *p)
 {
   mrb_value v;
-  struct RBasic *b = (struct RBasic*) p;
+  struct RBasic *b = (struct RBasic*)p;
 
   MRB_SET_VALUE(v, b->tt, value.p, p);
   return v;
diff --git a/mrblib/string.rb b/mrblib/string.rb
index 0b995f9ca..43dda16e5 100644
--- a/mrblib/string.rb
+++ b/mrblib/string.rb
@@ -133,7 +133,6 @@ class String
   def []=(pos, value)
     b = self[0, pos]
     a = self[pos+1..-1]
-    p [b, value, a].join('')
     self.replace([b, value, a].join(''))
   end
 end
diff --git a/src/array.c b/src/array.c
index 2e2536368..a200de3aa 100644
--- a/src/array.c
+++ b/src/array.c
@@ -294,7 +294,7 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1)
   int i, len;
 
   mrb_get_args(mrb, "o", &ary2);
-  if (mrb_type(ary2) != MRB_TT_ARRAY) return mrb_nil_value();
+  if (!mrb_array_p(ary2)) return mrb_nil_value();
   a1 = RARRAY(ary1); a2 = RARRAY(ary2);
   if (a1->len == a2->len && a1->ptr == a2->ptr) return mrb_fixnum_value(0);
   else {
@@ -616,7 +616,7 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
   tail = head + len;
 
   /* size check */
-  if (mrb_type(rpl) == MRB_TT_ARRAY) {
+  if (mrb_array_p(rpl)) {
     argc = RARRAY_LEN(rpl);
     argv = RARRAY_PTR(rpl);
   }
@@ -719,7 +719,7 @@ mrb_ary_aset(mrb_state *mrb, mrb_value self)
   mrb_get_args(mrb, "*", &argv, &argc);
   switch(argc) {
   case 2:
-    if (FIXNUM_P(argv[0])) {
+    if (mrb_fixnum_p(argv[0])) {
       mrb_ary_set(mrb, self, mrb_fixnum(argv[0]), argv[1]);
     }
     else {
@@ -848,7 +848,7 @@ mrb_ary_rindex_m(mrb_state *mrb, mrb_value self)
 mrb_value
 mrb_ary_splat(mrb_state *mrb, mrb_value v)
 {
-  if (mrb_type(v) == MRB_TT_ARRAY) {
+  if (mrb_array_p(v)) {
     return v;
   }
   else {
@@ -928,7 +928,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
     if (i > 0) {
       mrb_str_buf_cat(mrb, arystr, sep, sizeof(sep));
     }
-    if (mrb_type(RARRAY_PTR(ary)[i]) == MRB_TT_ARRAY) {
+    if (mrb_array_p(RARRAY_PTR(ary)[i])) {
       s = inspect_ary(mrb, RARRAY_PTR(ary)[i], list);
     } else {
       s = mrb_inspect(mrb, RARRAY_PTR(ary)[i]);
@@ -1067,8 +1067,8 @@ mrb_ary_equal(mrb_state *mrb, mrb_value ary1)
 
   mrb_get_args(mrb, "o", &ary2);
   if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value();
-  if (SPECIAL_CONST_P(ary2)) return mrb_false_value();
-  if (mrb_type(ary2) != MRB_TT_ARRAY) {
+  if (mrb_special_const_p(ary2)) return mrb_false_value();
+  if (!mrb_array_p(ary2)) {
     if (!mrb_respond_to(mrb, ary2, mrb_intern(mrb, "to_ary"))) {
         return mrb_false_value();
     }
@@ -1107,7 +1107,7 @@ mrb_ary_eql(mrb_state *mrb, mrb_value ary1)
 
   mrb_get_args(mrb, "o", &ary2);
   if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value();
-  if (mrb_type(ary2) != MRB_TT_ARRAY) return mrb_false_value();
+  if (!mrb_array_p(ary2)) return mrb_false_value();
   if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value();
   else {
     int i;
diff --git a/src/class.c b/src/class.c
index 3e54afede..cf2f6df50 100644
--- a/src/class.c
+++ b/src/class.c
@@ -503,8 +503,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 	  case MRB_TT_FIXNUM:
 	    *p = (mrb_float)mrb_fixnum(*sp);
 	    break;
-	  case MRB_TT_FALSE:
-	    *p = 0.0;
+	  case MRB_TT_STRING:
+	    mrb_raise(mrb, E_TYPE_ERROR, "String can't be coerced into Float");
 	    break;
 	  default:
 	    {
@@ -852,9 +852,12 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
 
   m = mrb_method_search_vm(mrb, &c, mid);
   if (!m) {
+    mrb_value inspect = mrb_funcall(mrb, mrb_obj_value(c), "inspect", 0);
+    if (RSTRING_LEN(inspect) > 64) {
+      inspect = mrb_any_to_s(mrb, mrb_obj_value(c));
+    }
     mrb_raisef(mrb, E_NAME_ERROR, "undefined method '%s' for class %s",
-        mrb_sym2name(mrb, mid),
-        RSTRING_PTR(mrb_funcall(mrb, mrb_obj_value(c), "inspect", 0)));
+        mrb_sym2name(mrb, mid), RSTRING_PTR(inspect));
   }
   return m;
 }
@@ -1005,14 +1008,20 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
 {
   mrb_value name, *a;
   int alen;
+  mrb_value inspect;
 
   mrb_get_args(mrb, "o*", &name, &a, &alen);
-  if (!SYMBOL_P(name)) {
+  if (!mrb_symbol_p(name)) {
     mrb_raise(mrb, E_TYPE_ERROR, "name should be a symbol");
   }
+
+  inspect = mrb_funcall(mrb, mod, "inspect", 0);
+  if (RSTRING_LEN(inspect) > 64) {
+    inspect = mrb_any_to_s(mrb, mod);
+  }
+
   mrb_raisef(mrb, E_NOMETHOD_ERROR, "undefined method '%s' for %s",
-      mrb_sym2name(mrb, mrb_symbol(name)),
-      RSTRING_PTR(mrb_funcall(mrb, mod, "inspect", 0)));
+      mrb_sym2name(mrb, mrb_symbol(name)), RSTRING_PTR(inspect));
   /* not reached */
   return mrb_nil_value();
 }
@@ -1322,10 +1331,10 @@ mod_define_method(mrb_state *mrb, mrb_value self)
 static mrb_sym
 mrb_sym_value(mrb_state *mrb, mrb_value val)
 {
-  if(mrb_type(val) == MRB_TT_STRING) {
+  if (mrb_string_p(val)) {
     return mrb_intern_str(mrb, val);
   }
-  else if(mrb_type(val) != MRB_TT_SYMBOL) {
+  else if(!mrb_symbol_p(val)) {
     mrb_value obj = mrb_funcall(mrb, val, "inspect", 0);
     mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a symbol",
          mrb_string_value_ptr(mrb, obj));
diff --git a/src/codegen.c b/src/codegen.c
index ca2269d85..82e80ee41 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -635,7 +635,6 @@ scope_body(codegen_scope *s, node *tree)
     genop(scope, MKOP_A(OP_STOP, 0));
   }
   else {
-    pop_(scope);
     if (scope->nregs == 0) {
       genop(scope, MKOP_A(OP_LOADNIL, 0));
       genop(scope, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
diff --git a/src/encoding.h b/src/encoding.h
index 00cb92bd8..7bc0d9ef0 100644
--- a/src/encoding.h
+++ b/src/encoding.h
@@ -35,8 +35,8 @@ extern "C" {
 #define ENCODING_MASK (((unsigned int)ENCODING_INLINE_MAX)<<ENCODING_SHIFT)
 
 #define ENCODING_SET_INLINED(obj,i) do {\
-    RBASIC(obj)->flags &= ~ENCODING_MASK;\
-    RBASIC(obj)->flags |= (unsigned int)(i) << ENCODING_SHIFT;\
+    mrb_obj_ptr(obj)->flags &= ~ENCODING_MASK;\
+    mrb_obj_ptr(obj)->flags |= (unsigned int)(i) << ENCODING_SHIFT;\
 } while (0)
 #define ENCODING_SET(mrb, obj,i) do {\
     mrb_value mrb_encoding_set_obj = (obj); \
diff --git a/src/error.c b/src/error.c
index 858c70820..430728db0 100644
--- a/src/error.c
+++ b/src/error.c
@@ -189,6 +189,7 @@ exc_debug_info(mrb_state *mrb, struct RObject *exc)
   mrb_callinfo *ci = mrb->ci;
   mrb_code *pc = ci->pc;
 
+  mrb_obj_iv_set(mrb, exc, mrb_intern(mrb, "ciidx"), mrb_fixnum_value(ci - mrb->cibase));
   ci--;
   while (ci >= mrb->cibase) {
     if (ci->proc && !MRB_PROC_CFUNC_P(ci->proc)) {
diff --git a/src/etc.c b/src/etc.c
index c38f2a0bc..4542c4abd 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -25,7 +25,7 @@ mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const str
 void *
 mrb_get_datatype(mrb_state *mrb, mrb_value obj, const struct mrb_data_type *type)
 {
-  if (SPECIAL_CONST_P(obj) || (mrb_type(obj) != MRB_TT_DATA)) {
+  if (mrb_special_const_p(obj) || (mrb_type(obj) != MRB_TT_DATA)) {
     return NULL;
   }
   if (DATA_TYPE(obj) != type) {
@@ -39,7 +39,7 @@ mrb_check_datatype(mrb_state *mrb, mrb_value obj, const struct mrb_data_type *ty
 {
   static const char mesg[] = "wrong argument type %s (expected %s)";
 
-  if (SPECIAL_CONST_P(obj) || (mrb_type(obj) != MRB_TT_DATA)) {
+  if (mrb_special_const_p(obj) || (mrb_type(obj) != MRB_TT_DATA)) {
     mrb_check_type(mrb, obj, MRB_TT_DATA);
   }
   if (DATA_TYPE(obj) != type) {
@@ -103,7 +103,7 @@ mrb_to_id(mrb_state *mrb, mrb_value name)
       name = mrb_str_intern(mrb, name);
       /* fall through */
     case MRB_TT_SYMBOL:
-      return SYM2ID(name);
+      return mrb_symbol(name);
   }
   return id;
 }
@@ -156,7 +156,7 @@ mrb_obj_id(mrb_value obj)
   case  MRB_TT_TRUE:
     return MakeID(1);
   case  MRB_TT_SYMBOL:
-    return MakeID(SYM2ID(obj));
+    return MakeID(mrb_symbol(obj));
   case  MRB_TT_FIXNUM:
     return MakeID2(float_id((mrb_float)mrb_fixnum(obj)), MRB_TT_FLOAT);
   case  MRB_TT_FLOAT:
diff --git a/src/gc.c b/src/gc.c
index 37e4a363b..374072ce5 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -5,7 +5,6 @@
 */
 
 #include "mruby.h"
-#include "mruby/object.h"
 #include "mruby/class.h"
 #include "mruby/array.h"
 #include "mruby/string.h"
@@ -318,8 +317,8 @@ gc_protect(mrb_state *mrb, struct RBasic *p)
 void
 mrb_gc_protect(mrb_state *mrb, mrb_value obj)
 {
-  if (SPECIAL_CONST_P(obj)) return;
-  gc_protect(mrb, RBASIC(obj));
+  if (mrb_special_const_p(obj)) return;
+  gc_protect(mrb, mrb_basic(obj));
 }
 
 struct RBasic*
@@ -1076,8 +1075,8 @@ test_mrb_field_write_barrier(void)
   struct RBasic *obj, *value;
 
   puts("test_mrb_field_write_barrier");
-  obj = RBASIC(mrb_ary_new(mrb));
-  value = RBASIC(mrb_str_new_cstr(mrb, "value"));
+  obj = mrb_basic(mrb_ary_new(mrb));
+  value = mrb_basic(mrb_str_new_cstr(mrb, "value"));
   paint_black(obj);
   paint_partial_white(mrb,value);
 
@@ -1118,15 +1117,15 @@ test_mrb_field_write_barrier(void)
 
   {
     puts("test_mrb_field_write_barrier_value");
-    obj = RBASIC(mrb_ary_new(mrb));
+    obj = mrb_basic(mrb_ary_new(mrb));
     mrb_value value = mrb_str_new_cstr(mrb, "value");
     paint_black(obj);
-    paint_partial_white(mrb, RBASIC(value));
+    paint_partial_white(mrb, mrb_basic(value));
 
     mrb->gc_state = GC_STATE_MARK;
     mrb_field_write_barrier_value(mrb, obj, value);
 
-    gc_assert(is_gray(RBASIC(value)));
+    gc_assert(is_gray(mrb_basic(value)));
   }
 
   mrb_close(mrb);
@@ -1139,7 +1138,7 @@ test_mrb_write_barrier(void)
   struct RBasic *obj;
 
   puts("test_mrb_write_barrier");
-  obj = RBASIC(mrb_ary_new(mrb));
+  obj = mrb_basic(mrb_ary_new(mrb));
   paint_black(obj);
 
   puts("  in GC_STATE_MARK");
@@ -1167,12 +1166,12 @@ test_add_gray_list(void)
 
   puts("test_add_gray_list");
   gc_assert(mrb->gray_list == NULL);
-  obj1 = RBASIC(mrb_str_new_cstr(mrb, "test"));
+  obj1 = mrb_basic(mrb_str_new_cstr(mrb, "test"));
   add_gray_list(mrb, obj1);
   gc_assert(mrb->gray_list == obj1);
   gc_assert(is_gray(obj1));
 
-  obj2 = RBASIC(mrb_str_new_cstr(mrb, "test"));
+  obj2 = mrb_basic(mrb_str_new_cstr(mrb, "test"));
   add_gray_list(mrb, obj2);
   gc_assert(mrb->gray_list == obj2);
   gc_assert(mrb->gray_list->gcnext == obj1);
@@ -1201,12 +1200,12 @@ test_gc_gray_mark(void)
   puts("  in MRB_TT_ARRAY");
   obj_v = mrb_ary_new(mrb);
   value_v = mrb_str_new_cstr(mrb, "test");
-  paint_gray(RBASIC(obj_v));
-  paint_partial_white(mrb, RBASIC(value_v));
+  paint_gray(mrb_basic(obj_v));
+  paint_partial_white(mrb, mrb_basic(value_v));
   mrb_ary_push(mrb, obj_v, value_v);
-  gray_num = gc_gray_mark(mrb, RBASIC(obj_v));
-  gc_assert(is_black(RBASIC(obj_v)));
-  gc_assert(is_gray(RBASIC(value_v)));
+  gray_num = gc_gray_mark(mrb, mrb_basic(obj_v));
+  gc_assert(is_black(mrb_basic(obj_v)));
+  gc_assert(is_gray(mrb_basic(value_v)));
   gc_assert(gray_num == 1);
 
   mrb_close(mrb);
diff --git a/src/hash.c b/src/hash.c
index 51f85f4e8..229e61db7 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -37,7 +37,7 @@ static void mrb_hash_modify(mrb_state *mrb, mrb_value hash);
 static inline mrb_value
 mrb_hash_ht_key(mrb_state *mrb, mrb_value key)
 {
-  if (mrb_type(key) == MRB_TT_STRING)
+  if (mrb_string_p(key))
     return mrb_str_dup(mrb, key);
   else
     return key;
@@ -1106,7 +1106,7 @@ hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql)
   khash_t(ht) *h1, *h2;
 
   if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value();
-  if (mrb_type(hash2) != MRB_TT_HASH) {
+  if (!mrb_hash_p(hash2)) {
       if (!mrb_respond_to(mrb, hash2, mrb_intern(mrb, "to_hash"))) {
           return mrb_false_value();
       }
diff --git a/src/kernel.c b/src/kernel.c
index 050dd73bc..ac3c10f46 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -269,7 +269,7 @@ mrb_obj_class_m(mrb_state *mrb, mrb_value self)
 struct RClass*
 mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
 {
-  struct RClass *klass = RBASIC(obj)->c;
+  struct RClass *klass = mrb_basic(obj)->c;
 
   if (klass->tt != MRB_TT_SCLASS)
     return klass;
@@ -345,16 +345,18 @@ init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
 mrb_value
 mrb_obj_clone(mrb_state *mrb, mrb_value self)
 {
-  struct RObject *clone;
+  struct RObject *p;
+  mrb_value clone;
 
   if (mrb_special_const_p(self)) {
       mrb_raisef(mrb, E_TYPE_ERROR, "can't clone %s", mrb_obj_classname(mrb, self));
   }
-  clone = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
-  clone->c = mrb_singleton_class_clone(mrb, self);
-  init_copy(mrb, mrb_obj_value(clone), self);
+  p = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
+  p->c = mrb_singleton_class_clone(mrb, self);
+  clone = mrb_obj_value(p);
+  init_copy(mrb, clone, self);
 
-  return mrb_obj_value(clone);
+  return clone;
 }
 
 /* 15.3.1.3.9  */
@@ -762,7 +764,7 @@ mrb_obj_singleton_methods(mrb_state *mrb, int argc, mrb_value *argv, mrb_value o
       method_entry_loop(mrb, klass, ary);
       klass = klass->super;
   }
-  if (RTEST(recur)) {
+  if (mrb_test(recur)) {
       while (klass && ((klass->tt == MRB_TT_SCLASS) || (klass->tt == MRB_TT_ICLASS))) {
         method_entry_loop(mrb, klass, ary);
         klass = klass->super;
@@ -1006,7 +1008,7 @@ obj_respond_to(mrb_state *mrb, mrb_value self)
   if (argc > 1) priv = argv[1];
   else priv = mrb_nil_value();
   id = mrb_to_id(mrb, mid);
-  if (basic_obj_respond_to(mrb, self, id, !RTEST(priv)))
+  if (basic_obj_respond_to(mrb, self, id, !mrb_test(priv)))
     return mrb_true_value();
   return mrb_false_value();
 }
@@ -1115,4 +1117,5 @@ mrb_init_kernel(mrb_state *mrb)
 #endif
 
   mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
+  mrb_alias_method(mrb, mrb->module_class, mrb_intern(mrb, "dup"), mrb_intern(mrb, "clone"));
 }
diff --git a/src/load.c b/src/load.c
index 65b6004d3..142c6fdf7 100644
--- a/src/load.c
+++ b/src/load.c
@@ -613,6 +613,7 @@ hex_to_str(char *hex, char *str, uint16_t *str_len)
 {
   char *src, *dst, buf[4];
   int escape = 0, base = 0;
+  char *err_ptr;
 
   *str_len = 0;
   for (src = hex, dst = str; *src != '\0'; src++) {
@@ -639,7 +640,6 @@ hex_to_str(char *hex, char *str, uint16_t *str_len)
           strncpy(buf, src, 2);
         }
 
-        char *err_ptr;
         *dst++ = (unsigned char) strtol(buf, &err_ptr, base) & 0xff;
         src += (err_ptr - buf - 1);
         break;
diff --git a/src/numeric.c b/src/numeric.c
index c1491ac51..562562340 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -97,7 +97,7 @@ num_pow(mrb_state *mrb, mrb_value x)
   mrb_float d;
 
   mrb_get_args(mrb, "o", &y);
-  if (FIXNUM_P(x) && FIXNUM_P(y)) both_int = TRUE;
+  if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) both_int = TRUE;
   d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
   if (both_int && FIXABLE(d))
     return mrb_fixnum_value((mrb_int)d);
@@ -682,7 +682,7 @@ fix_succ(mrb_state *mrb, mrb_value num)
 static mrb_value
 int_succ(mrb_state *mrb, mrb_value num)
 {
-  if (FIXNUM_P(num)) return fix_succ(mrb, num);
+  if (mrb_fixnum_p(num)) return fix_succ(mrb, num);
   return mrb_funcall(mrb, num, "+", 1, mrb_fixnum_value(1));
 }
 
@@ -697,7 +697,7 @@ mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
   
   a = mrb_fixnum(x);
   if (a == 0) return x;
-  if (FIXNUM_P(y)) {
+  if (mrb_fixnum_p(y)) {
     mrb_int b, c;
 
     b = mrb_fixnum(y);
@@ -774,7 +774,7 @@ fix_mod(mrb_state *mrb, mrb_value x)
 
   mrb_get_args(mrb, "o", &y);
   a = mrb_fixnum(x);
-  if (FIXNUM_P(y) && (b=mrb_fixnum(y)) != 0) {
+  if (mrb_fixnum_p(y) && (b=mrb_fixnum(y)) != 0) {
     mrb_int mod;
 
     if (mrb_fixnum(y) == 0) {
@@ -803,7 +803,7 @@ fix_divmod(mrb_state *mrb, mrb_value x)
   mrb_value y;
   mrb_get_args(mrb, "o", &y);
 
-  if (FIXNUM_P(y)) {
+  if (mrb_fixnum_p(y)) {
     mrb_int div, mod;
 
     if (mrb_fixnum(y) == 0) {
@@ -877,8 +877,8 @@ fix_rev(mrb_state *mrb, mrb_value num)
 static mrb_value
 bit_coerce(mrb_state *mrb, mrb_value x)
 {
-    while (!FIXNUM_P(x)) {
-        if (mrb_type(x) == MRB_TT_FLOAT) {
+    while (!mrb_fixnum_p(x)) {
+        if (mrb_float_p(x)) {
             mrb_raise(mrb, E_TYPE_ERROR, "can't convert Float into Integer");
         }
         x = mrb_to_int(mrb, x);
@@ -1076,7 +1076,7 @@ mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y)
   
   a = mrb_fixnum(x);
   if (a == 0) return y;
-  if (FIXNUM_P(y)) {
+  if (mrb_fixnum_p(y)) {
     mrb_int b, c;
 
     b = mrb_fixnum(y);
@@ -1114,7 +1114,7 @@ mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y)
   mrb_int a;
   
   a = mrb_fixnum(x);
-  if (FIXNUM_P(y)) {
+  if (mrb_fixnum_p(y)) {
     mrb_int b, c;
 
     b = mrb_fixnum(y);
diff --git a/src/object.c b/src/object.c
index a23e397f6..51b5c12d9 100644
--- a/src/object.c
+++ b/src/object.c
@@ -509,7 +509,7 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method)
 {
     mrb_value v;
 
-    if (FIXNUM_P(val)) return val;
+    if (mrb_fixnum_p(val)) return val;
     v = convert_type(mrb, val, "Integer", method, TRUE);
     if (!mrb_obj_is_kind_of(mrb, v, mrb->fixnum_class)) {
       const char *cname = mrb_obj_classname(mrb, val);
@@ -603,5 +603,5 @@ int
 mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 {
   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
-  return RTEST(mrb_funcall(mrb, obj1, "eql?", 1, obj2));
+  return mrb_test(mrb_funcall(mrb, obj1, "eql?", 1, obj2));
 }
diff --git a/src/parse.y b/src/parse.y
index cffb6ba09..abec59e3f 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -3162,10 +3162,13 @@ skips(parser_state *p, const char *s)
       int len = strlen(s);
 
       while (len--) {
-	nextc(p);
+        nextc(p);
       }
       return TRUE;
     }
+	else{
+      s--;
+    }
   }
   return FALSE;
 }
diff --git a/src/print.c b/src/print.c
index e6805edbf..3b762e05f 100644
--- a/src/print.c
+++ b/src/print.c
@@ -16,7 +16,7 @@ printstr(mrb_state *mrb, mrb_value obj)
   char *s;
   int len;
 
-  if (mrb_type(obj) == MRB_TT_STRING) {
+  if (mrb_string_p(obj)) {
     str = mrb_str_ptr(obj);
     s = str->ptr;
     len = str->len;
diff --git a/src/re.c b/src/re.c
index ff637aecb..091c35f61 100644
--- a/src/re.c
+++ b/src/re.c
@@ -260,7 +260,7 @@ match_backref_number(mrb_state *mrb, mrb_value match, mrb_value backref)
       return mrb_fixnum(backref);
 
     case MRB_TT_SYMBOL:
-      name = mrb_sym2name(mrb, SYM2ID(backref));
+      name = mrb_sym2name(mrb, mrb_symbol(backref));
       break;
 
     case MRB_TT_STRING:
@@ -344,8 +344,8 @@ mrb_reg_options(mrb_state *mrb, mrb_value re)
 
     mrb_reg_check(mrb, re);
     options = RREGEXP(re)->ptr->options & ARG_REG_OPTION_MASK;
-    if (RBASIC(re)->flags & KCODE_FIXED) options |= ARG_ENCODING_FIXED;
-    if (RBASIC(re)->flags & REG_ENCODING_NONE) options |= ARG_ENCODING_NONE;
+    if (mrb_basic(re)->flags & KCODE_FIXED) options |= ARG_ENCODING_FIXED;
+    if (mrb_basic(re)->flags & REG_ENCODING_NONE) options |= ARG_ENCODING_NONE;
     return options;
 }
 
@@ -361,7 +361,7 @@ mrb_reg_desc(mrb_state *mrb, const char *s, long len, mrb_value re)
     mrb_reg_check(mrb, re);
     if (*option_to_str(opts, RREGEXP(re)->ptr->options))
         mrb_str_buf_cat(mrb, str, opts, strlen(opts));//mrb_str_buf_cat2(str, opts);
-    if (RBASIC(re)->flags & REG_ENCODING_NONE)
+    if (mrb_basic(re)->flags & REG_ENCODING_NONE)
         mrb_str_buf_cat(mrb, str, "n", 1);
   }
 
@@ -1192,8 +1192,7 @@ mrb_match_aref(mrb_state *mrb, /*int argc, mrb_value *argv,*/ mrb_value match)
 
       switch (mrb_type(idx)) {
         case MRB_TT_SYMBOL:
-          //p = mrb_id2name(SYM2ID(idx));
-          p = mrb_sym2name(mrb, SYM2ID(idx));
+          p = mrb_sym2name(mrb, mrb_symbol(idx));
           goto name_to_backref;
           break;
         case MRB_TT_STRING:
diff --git a/src/regparse.c b/src/regparse.c
index f7bb23306..0ecb01018 100644
--- a/src/regparse.c
+++ b/src/regparse.c
@@ -2831,7 +2831,7 @@ CLOSE_BRACKET_WITHOUT_ESC_WARN(ScanEnv* env, UChar* c)
 static void
 CC_DUP_WARN(ScanEnv *env)
 {
-  if (onig_warn == onig_null_warn /*|| !RTEST(ruby_verbose)*/) return ;
+  if (onig_warn == onig_null_warn /*|| !mrb_test(ruby_verbose)*/) return ;
 
   if (IS_SYNTAX_BV((env)->syntax, ONIG_SYN_WARN_CC_DUP) &&
     !((env)->warnings_flag & ONIG_SYN_WARN_CC_DUP)) {
@@ -2843,7 +2843,7 @@ CC_DUP_WARN(ScanEnv *env)
 static void
 UNKNOWN_ESC_WARN(ScanEnv *env, int c)
 {
-  if (onig_warn == onig_null_warn /*|| !RTEST(ruby_verbose)*/) return ;
+  if (onig_warn == onig_null_warn /*|| !mrb_test(ruby_verbose)*/) return ;
   onig_syntax_warn(env, "Unknown escape \\%c is ignored", c);
 }
 
diff --git a/src/sprintf.c b/src/sprintf.c
index 2bd72ffc6..630875a88 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -800,7 +800,7 @@ retry:
               goto bin_retry;
             }
             val = mrb_flt2big(mrb, mrb_float(val));
-            if (FIXNUM_P(val)) goto bin_retry;
+            if (mrb_fixnum_p(val)) goto bin_retry;
             break;
           case MRB_TT_STRING:
             val = mrb_str_to_inum(mrb, val, 0, TRUE);
@@ -1048,13 +1048,15 @@ retry:
   }
 
   sprint_exit:
+#if 0
   /* XXX - We cannot validate the number of arguments if (digit)$ style used.
    */
   if (posarg >= 0 && nextarg < argc) {
     const char *mesg = "too many arguments for format string";
-    if (RTEST(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, mesg);
-    if (RTEST(ruby_verbose)) mrb_warn("%s", mesg);
+    if (mrb_test(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, mesg);
+    if (mrb_test(ruby_verbose)) mrb_warn("%s", mesg);
   }
+#endif
   mrb_str_resize(mrb, result, blen);
 
   return result;
diff --git a/src/string.c b/src/string.c
index 8eb08562d..760b02883 100644
--- a/src/string.c
+++ b/src/string.c
@@ -333,7 +333,7 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
   int len;
 
   str_modify(mrb, s1);
-  if (mrb_type(other) != MRB_TT_STRING) {
+  if (!mrb_string_p(other)) {
     other = mrb_str_to_str(mrb, other);
   }
   s2 = mrb_str_ptr(other);
@@ -519,7 +519,7 @@ mrb_str_cmp_m(mrb_state *mrb, mrb_value str1)
   mrb_int result;
 
   mrb_get_args(mrb, "o", &str2);
-  if (mrb_type(str2) != MRB_TT_STRING) {
+  if (!mrb_string_p(str2)) {
     if (!mrb_respond_to(mrb, str2, mrb_intern(mrb, "to_s"))) {
       return mrb_nil_value();
     }
@@ -557,7 +557,7 @@ int
 mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2)
 {
   if (mrb_obj_equal(mrb, str1, str2)) return TRUE;
-  if (mrb_type(str2) != MRB_TT_STRING) {
+  if (!mrb_string_p(str2)) {
     if (mrb_nil_p(str2)) return FALSE;
     if (!mrb_respond_to(mrb, str2, mrb_intern(mrb, "to_str"))) {
       return FALSE;
@@ -595,7 +595,7 @@ mrb_str_to_str(mrb_state *mrb, mrb_value str)
 {
   mrb_value s;
 
-  if (mrb_type(str) != MRB_TT_STRING) {
+  if (!mrb_string_p(str)) {
     s = mrb_check_convert_type(mrb, str, MRB_TT_STRING, "String", "to_str");
     if (mrb_nil_p(s)) {
       s = mrb_convert_type(mrb, str, MRB_TT_STRING, "String", "to_s");
@@ -609,7 +609,7 @@ mrb_value
 mrb_string_value(mrb_state *mrb, mrb_value *ptr)
 {
   mrb_value s = *ptr;
-  if (mrb_type(s) != MRB_TT_STRING) {
+  if (!mrb_string_p(s)) {
     s = mrb_str_to_str(mrb, s);
     *ptr = s;
   }
@@ -1317,7 +1317,7 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang)
     mrb_str_buf_cat(mrb, dest, cp, RSTRING_LEN(str) - offset);
   }
   mrb_reg_search(mrb, pat, str, last, 0);
-  RBASIC(dest)->c = mrb_obj_class(mrb, str);
+  mrb_basic(dest)->c = mrb_obj_class(mrb, str);
   return str;
 }
 
@@ -1653,11 +1653,11 @@ mrb_obj_as_string(mrb_state *mrb, mrb_value obj)
 {
   mrb_value str;
 
-  if (mrb_type(obj) == MRB_TT_STRING) {
+  if (mrb_string_p(obj)) {
     return obj;
   }
   str = mrb_funcall(mrb, obj, "to_s", 0);
-  if (mrb_type(str) != MRB_TT_STRING)
+  if (!mrb_string_p(str))
     return mrb_any_to_s(mrb, obj);
   return str;
 }
@@ -2141,7 +2141,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
     split_type = awk;
   }
   else {
-    if (mrb_type(spat) == MRB_TT_STRING) {
+    if (mrb_string_p(spat)) {
       split_type = string;
 #ifdef ENABLE_REGEXP
       if (RSTRING_LEN(spat) == 0) {
diff --git a/src/struct.c b/src/struct.c
index 2a391d0b1..85d0fa094 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -58,7 +58,7 @@ mrb_struct_s_members(mrb_state *mrb, mrb_value klass)
     if (mrb_nil_p(members)) {
       mrb_raise(mrb, E_TYPE_ERROR, "uninitialized struct");
     }
-    if (mrb_type(members) != MRB_TT_ARRAY) {
+    if (!mrb_array_p(members)) {
       mrb_raise(mrb, E_TYPE_ERROR, "corrupted struct");
     }
     return members;
@@ -220,7 +220,7 @@ mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val)
   ptr = RSTRUCT_PTR(obj);
   for (i=0; i<len; i++) {
     slot = ptr_members[i];
-    if (SYM2ID(slot) == mid) {
+    if (mrb_symbol(slot) == mid) {
       return ptr[i] = val;
     }
   }
@@ -290,7 +290,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k
     ptr_members = RARRAY_PTR(members);
     len = RARRAY_LEN(members);
     for (i=0; i< len; i++) {
-      mrb_sym id = SYM2ID(ptr_members[i]);
+      mrb_sym id = mrb_symbol(ptr_members[i]);
       if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
           if (i < N_REF_FUNC) {
             mrb_define_method_id(mrb, c, id, ref_func[i], ARGS_NONE());
@@ -381,8 +381,8 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
   else {   
     if (argc > 0) name = argv[0];
     if (argc > 1) rest = argv[1];
-    if (mrb_type(rest) == MRB_TT_ARRAY) {
-      if (!mrb_nil_p(name) && SYMBOL_P(name)) {
+    if (mrb_array_p(rest)) {
+      if (!mrb_nil_p(name) && mrb_symbol_p(name)) {
         /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
         mrb_ary_unshift(mrb, rest, name);
         name = mrb_nil_value();
@@ -391,7 +391,7 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
     else {
       pargv = &argv[1];
       argcnt = argc-1;
-      if (!mrb_nil_p(name) && SYMBOL_P(name)) {
+      if (!mrb_nil_p(name) && mrb_symbol_p(name)) {
         /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
         name = mrb_nil_value();
         pargv = &argv[0];
@@ -417,7 +417,7 @@ num_members(mrb_state *mrb, struct RClass *klass)
 {
     mrb_value members;
     members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern(mrb, "__members__"));
-    if (mrb_type(members) != MRB_TT_ARRAY) {
+    if (!mrb_array_p(members)) {
       mrb_raise(mrb, E_TYPE_ERROR, "broken members");
     }
     return RARRAY_LEN(members);
@@ -492,7 +492,7 @@ inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur)
           mrb_str_cat2(mrb, str, " ");
       }
       slot = ptr_members[i];
-      id = SYM2ID(slot);
+      id = mrb_symbol(slot);
       if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
 	const char *name;
 	int len;
@@ -556,7 +556,7 @@ mrb_struct_aref_id(mrb_state *mrb, mrb_value s, mrb_sym id)
     ptr_members = RARRAY_PTR(members);
     len = RARRAY_LEN(members);
     for (i=0; i<len; i++) {
-      if (SYM2ID(ptr_members[i]) == id) {
+      if (mrb_symbol(ptr_members[i]) == id) {
           return ptr[i];
       }
     }
@@ -588,7 +588,7 @@ mrb_struct_aref_n(mrb_state *mrb, mrb_value s, mrb_value idx)
 {
   long i;
 
-  if (mrb_type(idx) == MRB_TT_STRING || mrb_type(idx) == MRB_TT_SYMBOL) {
+  if (mrb_string_p(idx) || mrb_symbol_p(idx)) {
     return mrb_struct_aref_id(mrb, s, mrb_to_id(mrb, idx));
   }
 
@@ -628,7 +628,7 @@ mrb_struct_aset_id(mrb_state *mrb, mrb_value s, mrb_sym id, mrb_value val)
     ptr = RSTRUCT_PTR(s);
     ptr_members = RARRAY_PTR(members);
     for (i=0; i<len; i++) {
-      if (SYM2ID(ptr_members[i]) == id) {
+      if (mrb_symbol(ptr_members[i]) == id) {
           ptr[i] = val;
           return val;
       }
@@ -668,7 +668,7 @@ mrb_struct_aset(mrb_state *mrb, mrb_value s)
 
   mrb_get_args(mrb, "oo", &idx, &val);
 
-  if (mrb_type(idx) == MRB_TT_STRING || mrb_type(idx) == MRB_TT_SYMBOL) {
+  if (mrb_string_p(idx) || mrb_symbol_p(idx)) {
     return mrb_struct_aset_id(mrb, s, mrb_to_id(mrb, idx), val);
   }
 
diff --git a/src/symbol.c b/src/symbol.c
index 353245bb1..81c28d265 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -177,7 +177,7 @@ sym_equal(mrb_state *mrb, mrb_value sym1)
 mrb_value
 mrb_sym_to_s(mrb_state *mrb, mrb_value sym)
 {
-  mrb_sym id = SYM2ID(sym);
+  mrb_sym id = mrb_symbol(sym);
   const char *p;
   int len;
 
@@ -331,7 +331,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
   mrb_value str;
   const char *name;
   int len;
-  mrb_sym id = SYM2ID(sym);
+  mrb_sym id = mrb_symbol(sym);
 
   name = mrb_sym2name_len(mrb, id, &len);
   str = mrb_str_new(mrb, 0, len+1);
diff --git a/src/variable.c b/src/variable.c
index eebe81575..b3b3b3d87 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -580,7 +580,7 @@ iv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 
   ary = *(mrb_value*)p;
   s = mrb_sym2name_len(mrb, sym, &len);
-  if (len > 1 && s[0] == '@') {
+  if (len > 1 && s[0] == '@' && s[1] != '@') {
     mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
   }
   return 0;
@@ -927,5 +927,5 @@ mrb_class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer)
       return arg.sym;
     }
   }
-  return SYM2ID(name);
+  return mrb_symbol(name);
 }
diff --git a/src/vm.c b/src/vm.c
index 953863a0b..b5bde896b 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -992,7 +992,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         struct RArray *rest;
         int len = 0;
 
-        if (mrb_type(stack[m1]) == MRB_TT_ARRAY) {
+        if (mrb_array_p(stack[m1])) {
           struct RArray *ary = mrb_ary_ptr(stack[m1]);
 
           pp = ary->ptr;
@@ -1047,7 +1047,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
           }
         }
       }
-      else if (len > 1 && argc == 1 && mrb_type(argv[0]) == MRB_TT_ARRAY) {
+      else if (len > 1 && argc == 1 && mrb_array_p(argv[0])) {
         argc = mrb_ary_ptr(argv[0])->len;
         argv = mrb_ary_ptr(argv[0])->ptr;
       }
@@ -1592,7 +1592,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       int c = GETARG_C(i);
       mrb_value v = regs[GETARG_B(i)];
 
-      if (mrb_type(v) != MRB_TT_ARRAY) {
+      if (!mrb_array_p(v)) {
         if (c == 0) {
           regs[GETARG_A(i)] = v;
         }
@@ -1619,7 +1619,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       int pre  = GETARG_B(i);
       int post = GETARG_C(i);
 
-      if (mrb_type(v) != MRB_TT_ARRAY) {
+      if (!mrb_array_p(v)) {
         regs[a++] = mrb_ary_new_capa(mrb, 0);
         while (post--) {
           SET_NIL_VALUE(regs[a]);
diff --git a/test/Makefile b/test/Makefile
index 183e03438..b06343084 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -18,6 +18,13 @@ ASSLIB := $(BASEDIR)/assert.rb
 MRBS := $(BASEDIR)/t/*.rb
 OBJS := driver.o $(MLIB)
 
+# for mruby/mrbc test
+REPLIB  := $(BASEDIR)/report.rb
+TESTRB  := mrubytest.rb
+TESTMRB := mrubytest.mrb
+TESTRB_REP  := mrubytest.rb.report
+TESTMRB_REP := mrubytest.mrb.report
+
 # libraries, includes
 LIBS = -lm
 INCLUDES = -I$(BASEDIR)/../src -I$(BASEDIR)/../include
@@ -44,19 +51,37 @@ endif
 
 # mruby compiler and test driver
 ifeq ($(OS),Windows_NT)
+<<<<<<< HEAD
   MRBC = ../bin/mrbc.exe
   EXE := $(TARGET).exe
 else
   MRBC = ../bin/mrbc
   EXE := $(TARGET)
+=======
+MRBC = ../bin/mrbc.exe
+MRUBY= ../bin/mruby.exe
+EXE := $(TARGET).exe
+else
+MRBC = ../bin/mrbc
+MRUBY= ../bin/mruby
+EXE := $(TARGET)
+>>>>>>> upstream/master
 endif
 
 ##############################
 # generic build targets, rules
 
 .PHONY : test
-all : $(EXE)
+all : $(EXE) $(MRUBY) $(TESTRB) $(TESTMRB)
+	@echo "# exec mrbtest"
 	./$(EXE)
+	@echo
+	@echo "# exec mruby test with ruby script"
+	@($(MRUBY) $(TESTRB) > $(TESTRB_REP) && echo "mrubytest.rb success.") || $(CAT) $(TESTRB_REP)
+	@echo
+	@echo "# exec mruby test with mrb file"
+	@($(MRUBY) -b $(TESTMRB) > $(TESTMRB_REP) && echo "mrubytest.mrb success.") || $(CAT) $(TESTMRB_REP)
+	@echo
 
 # executable constructed using linker from object files
 $(EXE) : $(OBJS) $(LIBR)
@@ -80,8 +105,16 @@ $(DLIB) : $(RLIB) $(MRBC)
 $(RLIB) : $(ASSLIB) $(MRBS)
 	$(CAT) $(ASSLIB) $(MRBS) > $@
 
+# Compile mrb file from mruby source
+$(TESTMRB) : $(MRBC) $(TESTRB)
+	$(MRBC) $(TESTRB)
+
+$(TESTRB) : $(ASSLIB) $(MRBS) $(REPLIB)
+	$(CAT) $(ASSLIB) $(MRBS) $(REPLIB) > $@
+
 # clean up
 .PHONY : clean
 clean :
 	@echo "make: removing targets, objects and depend files of `pwd`"
 	-$(RM_F) $(MLIB) $(CLIB) $(RLIB) $(DLIB) $(DEPLIB) $(OBJS) $(EXE)
+	-$(RM_F) $(TESTRB) $(TESTMRB) $(TESTRB_REP) $(TESTMRB_REP)
diff --git a/test/driver.c b/test/driver.c
index d2ad31b26..788a77b2d 100644
--- a/test/driver.c
+++ b/test/driver.c
@@ -32,7 +32,7 @@ check_error(mrb_state *mrb)
   mrb_value ko_test = mrb_gv_get(mrb, mrb_intern(mrb, "$ko_test"));
   mrb_value kill_test = mrb_gv_get(mrb, mrb_intern(mrb, "$kill_test"));
 
-  return FIXNUM_P(ko_test) && mrb_fixnum(ko_test) == 0 && FIXNUM_P(kill_test) && mrb_fixnum(kill_test) == 0;
+  return mrb_fixnum_p(ko_test) && mrb_fixnum(ko_test) == 0 && mrb_fixnum_p(kill_test) && mrb_fixnum(kill_test) == 0;
 }
 
 int
diff --git a/test/report.rb b/test/report.rb
new file mode 100644
index 000000000..fb77fd0aa
--- /dev/null
+++ b/test/report.rb
@@ -0,0 +1,4 @@
+report
+if $ko_test > 0 or $kill_test > 0
+  raise "mrbtest failed (KO:#{$ko_test}, Crash:#{$kill_test})"
+end
diff --git a/test/t/string.rb b/test/t/string.rb
index 27af38a4c..26b7df584 100644
--- a/test/t/string.rb
+++ b/test/t/string.rb
@@ -339,3 +339,20 @@ assert('Check the usage of a NUL character') do
   "qqq\0ppp"
 end
 
+assert('String#bytes') do
+  str1 = "hello"
+  bytes1 = [104, 101, 108, 108, 111]
+
+  str1.bytes == bytes1
+end
+
+assert('String#each_byte') do
+  str1 = "hello"
+  bytes1 = [104, 101, 108, 108, 111]
+  bytes2 = []
+
+  str1.each_byte {|b| bytes2 << b }
+
+  bytes1 == bytes2
+end
+
diff --git a/test/t/syntax.rb b/test/t/syntax.rb
index 7898a0b7d..47221d425 100644
--- a/test/t/syntax.rb
+++ b/test/t/syntax.rb
@@ -45,3 +45,16 @@ assert('Abbreviated variable assignment', '11.4.2.3.2') do
   c += 2
   a == 1 and b == nil and c == 3
 end
+
+assert('Nested const reference') do
+  module Syntax4Const
+    CONST1 = "hello world"
+    class Const2
+      def const1
+        CONST1
+      end
+    end
+  end
+  Syntax4Const::CONST1 == "hello world" and
+  Syntax4Const::Const2.new.const1 == "hello world"
+end
diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c
index db26d23a1..d9386f6e2 100644
--- a/tools/mruby/mruby.c
+++ b/tools/mruby/mruby.c
@@ -4,6 +4,7 @@
 #include "mruby/string.h"
 #include "mruby/compile.h"
 #include "mruby/dump.h"
+#include "mruby/variable.h"
 #include <stdio.h>
 #include <string.h>
 
@@ -162,6 +163,53 @@ cleanup(mrb_state *mrb, struct _args *args)
   mrb_close(mrb);
 }
 
+static void
+showcallinfo(mrb_state *mrb)
+{
+  mrb_callinfo *ci;
+  mrb_int ciidx;
+  const char *filename, *method, *sep;
+  int i, line;
+
+  printf("trace:\n");
+  ciidx = mrb_fixnum(mrb_obj_iv_get(mrb, mrb->exc, mrb_intern(mrb, "ciidx")));
+  if (ciidx >= mrb->ciend - mrb->cibase)
+    ciidx = 10; /* ciidx is broken... */
+
+  for (i = ciidx; i >= 0; i--) {
+    ci = &mrb->cibase[i];
+    filename = "(unknown)";
+    line = -1;
+
+    if (MRB_PROC_CFUNC_P(ci->proc)) {
+      continue;
+    }
+    else {
+      mrb_irep *irep = ci->proc->body.irep;
+      if (irep->filename != NULL)
+        filename = irep->filename;
+      if (irep->lines != NULL && i+1 <= ciidx) {
+        mrb_code *pc = mrb->cibase[i+1].pc;
+        if (irep->iseq <= pc && pc < irep->iseq + irep->ilen) {
+          line = irep->lines[pc - irep->iseq - 1];
+        }
+      }
+    }
+    if (ci->target_class == ci->proc->target_class)
+      sep = ".";
+    else
+      sep = "#";
+
+    method = mrb_sym2name(mrb, ci->mid);
+    printf("\t[%d] %s:%d%s%s%s%s\n",
+    	   i, filename, line,
+	   method ? ":in " : "",
+	   method ? mrb_class_name(mrb, ci->proc->target_class) : "",
+	   method ? sep : "",
+	   method ? method : "");
+  }
+}
+
 int
 main(int argc, char **argv)
 {
@@ -198,6 +246,7 @@ main(int argc, char **argv)
       mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
       n = 0;
       if (mrb->exc) {
+        showcallinfo(mrb);
         p(mrb, mrb_obj_value(mrb->exc));
         n = -1;
       }
@@ -223,6 +272,7 @@ main(int argc, char **argv)
     mrbc_context_free(mrb, c);
     if (mrb->exc) {
       if (!mrb_undef_p(v)) {
+        showcallinfo(mrb);
         p(mrb, mrb_obj_value(mrb->exc));
       }
       n = -1;