diff --git a/ChangeLog b/ChangeLog
index d66f246e70..5396f12c4c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,26 @@
+Wed Feb  7 03:39:32 2007  Koichi Sasada  <ko1@atdot.net>
+
+	* blockinlining.c, compile.c, compile.h, error.c, eval.c,
+	  eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
+	  eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
+	  process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
+	  vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
+	  yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
+	  * yarv_*_t -> rb_*_t
+	  * yarv_*_struct -> rb_*_struct
+	  * yarv_tag -> rb_vm_tag
+	  * YARV_* -> RUBY_VM_*
+
+	* proc.c, vm.c: move functions about env object creation
+	  from proc.c to vm.c.
+
+	* proc.c, yarvcore.c: fix rb_cVM initialization place.
+
+	* inits.c: change Init_ISeq() order (after Init_VM).
+
+	* ruby.h, proc.c: change declaration place of rb_cEnv
+	  from proc.c to ruby.c.
+
 Tue Feb 06 22:06:45 2007  NARUSE, Yui  <naruse@ruby-lang.org>
 
         * ext/nkf/nkf-utf8/{nkf.c,utf8tbl.c}:
diff --git a/blockinlining.c b/blockinlining.c
index 7a74f3492e..c599d57a49 100644
--- a/blockinlining.c
+++ b/blockinlining.c
@@ -17,7 +17,7 @@ VALUE yarv_new_iseqval(VALUE node, VALUE name, VALUE file,
 		       VALUE parent, VALUE type, VALUE block_opt, VALUE opt);
 
 static VALUE
-yarv_iseq_special_block(yarv_iseq_t *iseq, void *builder)
+yarv_iseq_special_block(rb_iseq_t *iseq, void *builder)
 {
 #if OPT_BLOCKINLINING
     VALUE parent = Qfalse;
@@ -110,7 +110,7 @@ new_assign(NODE * lnode, NODE * rhs)
 }
 
 static NODE *
-build_Integer_times_node(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
+build_Integer_times_node(rb_iseq_t *iseq, NODE * node, NODE * lnode,
 			 VALUE param_vars, VALUE local_vars)
 {
     /* Special Block for Integer#times
@@ -183,17 +183,17 @@ build_Integer_times_node(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
 VALUE
 yarv_invoke_Integer_times_special_block(VALUE num)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_block_t *orig_block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
+    rb_thead_t *th = GET_THREAD();
+    rb_block_t *orig_block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
 
     if (orig_block && BUILTIN_TYPE(orig_block->iseq) != T_NODE) {
 	VALUE tsiseqval = yarv_iseq_special_block(orig_block->iseq,
 						  build_Integer_times_node);
-	yarv_iseq_t *tsiseq;
+	rb_iseq_t *tsiseq;
 	VALUE argv[2], val;
 
 	if (tsiseqval) {
-	    yarv_block_t block = *orig_block;
+	    rb_block_t block = *orig_block;
 	    GetISeqPtr(tsiseqval, tsiseq);
 	    block.iseq = tsiseq;
 	    th->cfp->lfp[0] = GC_GUARDED_PTR(&block);
@@ -212,7 +212,7 @@ yarv_invoke_Integer_times_special_block(VALUE num)
 }
 
 static NODE *
-build_Range_each_node(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
+build_Range_each_node(rb_iseq_t *iseq, NODE * node, NODE * lnode,
 		      VALUE param_vars, VALUE local_vars, ID mid)
 {
     /* Special Block for Range#each
@@ -281,7 +281,7 @@ build_Range_each_node(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
 }
 
 static NODE *
-build_Range_each_node_LE(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
+build_Range_each_node_LE(rb_iseq_t *iseq, NODE * node, NODE * lnode,
 			 VALUE param_vars, VALUE local_vars)
 {
     return build_Range_each_node(iseq, node, lnode,
@@ -289,7 +289,7 @@ build_Range_each_node_LE(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
 }
 
 static NODE *
-build_Range_each_node_LT(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
+build_Range_each_node_LT(rb_iseq_t *iseq, NODE * node, NODE * lnode,
 			 VALUE param_vars, VALUE local_vars)
 {
     return build_Range_each_node(iseq, node, lnode,
@@ -300,19 +300,19 @@ VALUE
 yarv_invoke_Range_each_special_block(VALUE range,
 				     VALUE beg, VALUE end, int excl)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_block_t *orig_block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
+    rb_thead_t *th = GET_THREAD();
+    rb_block_t *orig_block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
 
     if (BUILTIN_TYPE(orig_block->iseq) != T_NODE) {
 	void *builder =
 	    excl ? build_Range_each_node_LT : build_Range_each_node_LE;
 	VALUE tsiseqval = yarv_iseq_special_block(orig_block->iseq, builder);
-	yarv_iseq_t *tsiseq;
+	rb_iseq_t *tsiseq;
 	VALUE argv[2];
 
 	if (tsiseqval) {
 	    VALUE val;
-	    yarv_block_t block = *orig_block;
+	    rb_block_t block = *orig_block;
 	    GetISeqPtr(tsiseqval, tsiseq);
 	    block.iseq = tsiseq;
 	    th->cfp->lfp[0] = GC_GUARDED_PTR(&block);
@@ -332,7 +332,7 @@ yarv_invoke_Range_each_special_block(VALUE range,
 
 
 static NODE *
-build_Array_each_node(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
+build_Array_each_node(rb_iseq_t *iseq, NODE * node, NODE * lnode,
 		      VALUE param_vars, VALUE local_vars)
 {
     /* Special block for Array#each
@@ -431,18 +431,18 @@ build_Array_each_node(yarv_iseq_t *iseq, NODE * node, NODE * lnode,
 VALUE
 yarv_invoke_Array_each_special_block(VALUE ary)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_block_t *orig_block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
+    rb_thead_t *th = GET_THREAD();
+    rb_block_t *orig_block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
 
     if (BUILTIN_TYPE(orig_block->iseq) != T_NODE) {
 	VALUE tsiseqval = yarv_iseq_special_block(orig_block->iseq,
 						  build_Array_each_node);
-	yarv_iseq_t *tsiseq;
+	rb_iseq_t *tsiseq;
 	VALUE argv[2];
 
 	if (tsiseqval) {
 	    VALUE val;
-	    yarv_block_t block = *orig_block;
+	    rb_block_t block = *orig_block;
 	    GetISeqPtr(tsiseqval, tsiseq);
 	    block.iseq = tsiseq;
 	    th->cfp->lfp[0] = GC_GUARDED_PTR(&block);
diff --git a/compile.c b/compile.c
index fb584c4811..eb4101447e 100644
--- a/compile.c
+++ b/compile.c
@@ -93,37 +93,37 @@ static int insn_ret_num(int insn);
 
 static void ADD_ELEM(LINK_ANCHOR *anchor, LINK_ELEMENT *elem);
 
-static INSN *new_insn_body(yarv_iseq_t *iseq, int line_no,
+static INSN *new_insn_body(rb_iseq_t *iseq, int line_no,
 			   int insn_id, int argc, ...);
-static LABEL *new_label_body(yarv_iseq_t *iseq, int line);
+static LABEL *new_label_body(rb_iseq_t *iseq, int line);
 
-static int iseq_compile_each(yarv_iseq_t *iseq, LINK_ANCHOR *anchor,
+static int iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *anchor,
 			     NODE * n, int);
-static int iseq_setup(yarv_iseq_t *iseq, LINK_ANCHOR *anchor);
+static int iseq_setup(rb_iseq_t *iseq, LINK_ANCHOR *anchor);
 
-static int iseq_optimize(yarv_iseq_t *iseq, LINK_ANCHOR *anchor);
-static int iseq_insns_unification(yarv_iseq_t *iseq, LINK_ANCHOR *anchor);
-static int set_sequence_stackcaching(yarv_iseq_t *iseq, LINK_ANCHOR *anchor);
-static int set_sequence(yarv_iseq_t *iseq, LINK_ANCHOR *anchor);
+static int iseq_optimize(rb_iseq_t *iseq, LINK_ANCHOR *anchor);
+static int iseq_insns_unification(rb_iseq_t *iseq, LINK_ANCHOR *anchor);
+static int set_sequence_stackcaching(rb_iseq_t *iseq, LINK_ANCHOR *anchor);
+static int set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor);
 
-static int set_exception_table(yarv_iseq_t *iseq);
-static int set_localtbl(yarv_iseq_t *iseq, ID *tbl);
-static int set_localtbl_eval(yarv_iseq_t *iseq, ID *tbl);
-static int set_arguments(yarv_iseq_t *iseq, LINK_ANCHOR *anchor, NODE * node);
-static NODE *set_block_local_tbl(yarv_iseq_t *iseq, NODE * node,
+static int set_exception_table(rb_iseq_t *iseq);
+static int set_localtbl(rb_iseq_t *iseq, ID *tbl);
+static int set_localtbl_eval(rb_iseq_t *iseq, ID *tbl);
+static int set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *anchor, NODE * node);
+static NODE *set_block_local_tbl(rb_iseq_t *iseq, NODE * node,
 				 LINK_ANCHOR *anchor);
-static int set_exception_tbl(yarv_iseq_t *iseq);
-static int set_optargs_table(yarv_iseq_t *iseq);
+static int set_exception_tbl(rb_iseq_t *iseq);
+static int set_optargs_table(rb_iseq_t *iseq);
 
 static int
-iseq_add_mark_object(yarv_iseq_t *iseq, VALUE v)
+iseq_add_mark_object(rb_iseq_t *iseq, VALUE v)
 {
     rb_ary_push(iseq->iseq_mark_ary, v);
     return COMPILE_OK;
 }
 
 static int
-iseq_add_mark_object_compile_time(yarv_iseq_t *iseq, VALUE v)
+iseq_add_mark_object_compile_time(rb_iseq_t *iseq, VALUE v)
 {
     rb_ary_push(iseq->compile_data->mark_ary, v);
     return COMPILE_OK;
@@ -140,7 +140,7 @@ VALUE
 iseq_compile(VALUE self, NODE *narg)
 {
     DECL_ANCHOR(list_anchor);
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
     NODE *node = (NODE *) narg;
     GetISeqPtr(self, iseq);
 
@@ -272,7 +272,7 @@ iseq_compile(VALUE self, NODE *narg)
 VALUE th_eval(void *);
 
 static int
-iseq_translate_direct_threaded_code(yarv_iseq_t *iseq)
+iseq_translate_direct_threaded_code(rb_iseq_t *iseq)
 {
 #if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE
 
@@ -305,7 +305,7 @@ iseq_translate_direct_threaded_code(yarv_iseq_t *iseq)
 
 
 static void *
-compile_data_alloc(yarv_iseq_t *iseq, size_t size)
+compile_data_alloc(rb_iseq_t *iseq, size_t size)
 {
     void *ptr = 0;
     struct iseq_compile_data_storage *storage =
@@ -336,13 +336,13 @@ compile_data_alloc(yarv_iseq_t *iseq, size_t size)
 }
 
 static INSN *
-compile_data_alloc_insn(yarv_iseq_t *iseq)
+compile_data_alloc_insn(rb_iseq_t *iseq)
 {
     return (INSN *)compile_data_alloc(iseq, sizeof(INSN));
 }
 
 static LABEL *
-compile_data_alloc_label(yarv_iseq_t *iseq)
+compile_data_alloc_label(rb_iseq_t *iseq)
 {
     return (LABEL *)compile_data_alloc(iseq, sizeof(LABEL));
 }
@@ -620,7 +620,7 @@ debug_list(LINK_ANCHOR *anchor)
 #endif
 
 static LABEL *
-new_label_body(yarv_iseq_t *iseq, int line)
+new_label_body(rb_iseq_t *iseq, int line)
 {
     LABEL *labelobj = compile_data_alloc_label(iseq);
     static int label_no = 0;
@@ -635,7 +635,7 @@ new_label_body(yarv_iseq_t *iseq, int line)
 }
 
 static INSN *
-new_insn_core(yarv_iseq_t *iseq, int line_no,
+new_insn_core(rb_iseq_t *iseq, int line_no,
 	      int insn_id, int argc, VALUE *argv)
 {
     INSN *iobj = compile_data_alloc_insn(iseq);
@@ -651,7 +651,7 @@ new_insn_core(yarv_iseq_t *iseq, int line_no,
 }
 
 static INSN *
-new_insn_body(yarv_iseq_t *iseq, int line_no, int insn_id, int argc, ...)
+new_insn_body(rb_iseq_t *iseq, int line_no, int insn_id, int argc, ...)
 {
     VALUE *operands = 0;
     va_list argv;
@@ -669,7 +669,7 @@ new_insn_body(yarv_iseq_t *iseq, int line_no, int insn_id, int argc, ...)
 }
 
 static INSN *
-new_insn_send(yarv_iseq_t *iseq, int line_no,
+new_insn_send(rb_iseq_t *iseq, int line_no,
 	      VALUE id, VALUE argc, VALUE block, VALUE flag)
 {
     INSN *iobj = 0;
@@ -685,22 +685,22 @@ new_insn_send(yarv_iseq_t *iseq, int line_no,
 }
 
 static VALUE
-new_child_iseq(yarv_iseq_t *iseq, NODE *node,
+new_child_iseq(rb_iseq_t *iseq, NODE *node,
 	       VALUE name, VALUE parent, VALUE type)
 {
     VALUE args[6];
     VALUE ret;
 
     debugs("[new_child_iseq]> ---------------------------------------\n");
-    ret = yarv_iseq_new_with_opt(node, name, iseq_filename(iseq->self),
-				 parent, type, iseq->compile_data->option);
+    ret = rb_iseq_new_with_opt(node, name, iseq_filename(iseq->self),
+			       parent, type, iseq->compile_data->option);
     debugs("[new_child_iseq]< ---------------------------------------\n");
     iseq_add_mark_object(iseq, ret);
     return ret;
 }
 
 static int
-iseq_setup(yarv_iseq_t *iseq, LINK_ANCHOR *anchor)
+iseq_setup(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
 {
     /* debugs("[compile step 2] (iseq_array_to_linkedlist)\n"); */
 
@@ -767,7 +767,7 @@ iseq_assemble_setup(VALUE self, VALUE args, VALUE locals, VALUE insn_ary)
 }
 
 int
-set_exception_tbl(yarv_iseq_t *iseq)
+set_exception_tbl(rb_iseq_t *iseq)
 {
     static ID id_dollar_bang;
 
@@ -806,7 +806,7 @@ search_block_local_variables(NODE * node, VALUE local_vars)
 }
 
 static NODE *
-search_block_local_parameters(yarv_iseq_t *iseq, NODE * lnode)
+search_block_local_parameters(rb_iseq_t *iseq, NODE * lnode)
 {
     NODE *node = lnode;
     NODE *nelem;
@@ -893,7 +893,7 @@ search_block_local_parameters(yarv_iseq_t *iseq, NODE * lnode)
 
     /* translate to block inlining code */
     if (iseq->special_block_builder != 0) {
-	node = ((NODE * (*)(yarv_iseq_t *, NODE *, NODE *, VALUE, VALUE))
+	node = ((NODE * (*)(rb_iseq_t *, NODE *, NODE *, VALUE, VALUE))
 		iseq->special_block_builder) (iseq, node, lnode->nd_var,
 					      param_vars, local_vars);
     }
@@ -917,7 +917,7 @@ search_block_local_parameters(yarv_iseq_t *iseq, NODE * lnode)
 }
 
 static int
-set_block_initializer(yarv_iseq_t *iseq, NODE * node, LINK_ANCHOR *anchor, int didx)
+set_block_initializer(rb_iseq_t *iseq, NODE * node, LINK_ANCHOR *anchor, int didx)
 {
     DECL_ANCHOR(anc);
     LINK_ELEMENT *elem;
@@ -947,7 +947,7 @@ set_block_initializer(yarv_iseq_t *iseq, NODE * node, LINK_ANCHOR *anchor, int d
 }
 
 static NODE *
-set_block_local_tbl(yarv_iseq_t *iseq, NODE * node, LINK_ANCHOR *anchor)
+set_block_local_tbl(rb_iseq_t *iseq, NODE * node, LINK_ANCHOR *anchor)
 {
     NODE *rnode;
 
@@ -1049,7 +1049,7 @@ set_block_local_tbl(yarv_iseq_t *iseq, NODE * node, LINK_ANCHOR *anchor)
 }
 
 static int
-get_dyna_var_idx_at_raw(yarv_iseq_t *iseq, ID id)
+get_dyna_var_idx_at_raw(rb_iseq_t *iseq, ID id)
 {
     int i;
     for (i = 0; i < iseq->local_size; i++) {
@@ -1061,7 +1061,7 @@ get_dyna_var_idx_at_raw(yarv_iseq_t *iseq, ID id)
 }
 
 static int
-get_dyna_var_idx(yarv_iseq_t *iseq, ID id, int *level, int *ls)
+get_dyna_var_idx(rb_iseq_t *iseq, ID id, int *level, int *ls)
 {
     int lv = 0, idx;
 
@@ -1081,7 +1081,7 @@ get_dyna_var_idx(yarv_iseq_t *iseq, ID id, int *level, int *ls)
 
  */
 static int
-set_arguments(yarv_iseq_t *iseq, LINK_ANCHOR *optargs, NODE * node)
+set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE * node)
 {
     int i, j;
 
@@ -1146,7 +1146,7 @@ set_arguments(yarv_iseq_t *iseq, LINK_ANCHOR *optargs, NODE * node)
 }
 
 static int
-set_localtbl(yarv_iseq_t *iseq, ID *tbl)
+set_localtbl(rb_iseq_t *iseq, ID *tbl)
 {
     int size;
     if (tbl) {
@@ -1164,7 +1164,7 @@ set_localtbl(yarv_iseq_t *iseq, ID *tbl)
 }
 
 static int
-set_localtbl_eval(yarv_iseq_t *iseq, ID *tbl)
+set_localtbl_eval(rb_iseq_t *iseq, ID *tbl)
 {
     int size;
     if (tbl) {
@@ -1185,7 +1185,7 @@ set_localtbl_eval(yarv_iseq_t *iseq, ID *tbl)
   ruby insn object array -> raw instruction sequence
  */
 static int
-set_sequence(yarv_iseq_t *iseq, LINK_ANCHOR *anchor)
+set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
 {
     LABEL *lobj;
     INSN *iobj;
@@ -1320,7 +1320,7 @@ set_sequence(yarv_iseq_t *iseq, LINK_ANCHOR *anchor)
 		    case TS_ISEQ:	/* iseq */
 			{
 			    VALUE v = operands[j];
-			    yarv_iseq_t *block = 0;
+			    rb_iseq_t *block = 0;
 			    if (v) {
 				GetISeqPtr(v, block);
 			    }
@@ -1405,7 +1405,7 @@ label_get_sp(LABEL *lobj)
 }
 
 static int
-set_exception_table(yarv_iseq_t *iseq)
+set_exception_table(rb_iseq_t *iseq)
 {
     VALUE *tptr, *ptr;
     int tlen, i;
@@ -1463,7 +1463,7 @@ set_exception_table(yarv_iseq_t *iseq)
  *      expr2
  */
 static int
-set_optargs_table(yarv_iseq_t *iseq)
+set_optargs_table(rb_iseq_t *iseq)
 {
     int i;
 
@@ -1521,7 +1521,7 @@ get_prev_insn(INSN *iobj)
 }
 
 static int
-iseq_peephole_optimize(yarv_iseq_t *iseq, LINK_ELEMENT *list)
+iseq_peephole_optimize(rb_iseq_t *iseq, LINK_ELEMENT *list)
 {
     INSN *iobj = (INSN *)list;
   again:
@@ -1618,7 +1618,7 @@ insn_set_specialized_instruction(INSN *iobj, int insn_id)
 
 
 static int
-iseq_specialized_instruction(yarv_iseq_t *iseq, INSN *iobj)
+iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
 {
     if (iobj->insn_id == BIN(send)) {
 	ID mid = SYM2ID(OPERAND_AT(iobj, 0));
@@ -1681,7 +1681,7 @@ iseq_specialized_instruction(yarv_iseq_t *iseq, INSN *iobj)
 }
 
 static int
-iseq_optimize(yarv_iseq_t *iseq, LINK_ANCHOR *anchor)
+iseq_optimize(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
 {
     LINK_ELEMENT *list;
     const int do_peephole = iseq->compile_data->option->peephole_optimization;
@@ -1708,7 +1708,7 @@ iseq_optimize(yarv_iseq_t *iseq, LINK_ANCHOR *anchor)
 
 #if OPT_INSTRUCTIONS_UNIFICATION
 static INSN *
-new_unified_insn(yarv_iseq_t *iseq,
+new_unified_insn(rb_iseq_t *iseq,
 		 int insn_id, int size, LINK_ELEMENT *seq_list)
 {
     INSN *iobj = 0;
@@ -1748,7 +1748,7 @@ new_unified_insn(yarv_iseq_t *iseq,
  * It's future work (if compile time was bottle neck).
  */
 static int
-iseq_insns_unification(yarv_iseq_t *iseq, LINK_ANCHOR *anchor)
+iseq_insns_unification(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
 {
 #if OPT_INSTRUCTIONS_UNIFICATION
     LINK_ELEMENT *list;
@@ -1860,7 +1860,7 @@ label_set_sc_state(LABEL *lobj, int state)
 #endif
 
 static int
-set_sequence_stackcaching(yarv_iseq_t *iseq, LINK_ANCHOR *anchor)
+set_sequence_stackcaching(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
 {
 #if OPT_STACK_CACHING
     LINK_ELEMENT *list;
@@ -1952,7 +1952,7 @@ set_sequence_stackcaching(yarv_iseq_t *iseq, LINK_ANCHOR *anchor)
 
 
 static int
-compile_dstr(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node)
+compile_dstr(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node)
 {
     NODE *list = node->nd_next;
     VALUE lit = node->nd_lit;
@@ -1972,7 +1972,7 @@ compile_dstr(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node)
 }
 
 static int
-compile_branch_condition(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * cond,
+compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * cond,
 			 LABEL *then_label, LABEL *else_label)
 {
     switch (nd_type(cond)) {
@@ -2020,7 +2020,7 @@ compile_branch_condition(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * cond,
 }
 
 static int
-compile_array(yarv_iseq_t *iseq,
+compile_array(rb_iseq_t *iseq,
 	      LINK_ANCHOR *ret, NODE * node_root, VALUE opt_p)
 {
     NODE *node = node_root;
@@ -2076,7 +2076,7 @@ case_when_optimizable_literal(NODE * node)
 }
 
 static VALUE
-when_vals(yarv_iseq_t *iseq, LINK_ANCHOR *cond_seq, NODE *vals, LABEL *l1, VALUE special_literals)
+when_vals(rb_iseq_t *iseq, LINK_ANCHOR *cond_seq, NODE *vals, LABEL *l1, VALUE special_literals)
 {
     while (vals) {
 	VALUE lit;
@@ -2103,7 +2103,7 @@ when_vals(yarv_iseq_t *iseq, LINK_ANCHOR *cond_seq, NODE *vals, LABEL *l1, VALUE
 }
 
 static int
-make_masgn_lhs(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node)
+make_masgn_lhs(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node)
 {
 
     switch (nd_type(node)) {
@@ -2145,7 +2145,7 @@ make_masgn_lhs(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node)
 }
 
 static int
-compile_massign(yarv_iseq_t *iseq, LINK_ANCHOR *ret,
+compile_massign(rb_iseq_t *iseq, LINK_ANCHOR *ret,
 		NODE * rhsn, NODE * splatn, NODE * lhsn, int llen)
 {
     if (lhsn != 0) {
@@ -2265,7 +2265,7 @@ compile_massign(yarv_iseq_t *iseq, LINK_ANCHOR *ret,
 }
 
 static int
-compile_colon2(yarv_iseq_t *iseq, NODE * node,
+compile_colon2(rb_iseq_t *iseq, NODE * node,
 	       LINK_ANCHOR *pref, LINK_ANCHOR *body)
 {
     switch (nd_type(node)) {
@@ -2292,7 +2292,7 @@ compile_colon2(yarv_iseq_t *iseq, NODE * node,
 }
 
 static int
-compile_cpath(LINK_ANCHOR *ret, yarv_iseq_t *iseq, NODE *cpath)
+compile_cpath(LINK_ANCHOR *ret, rb_iseq_t *iseq, NODE *cpath)
 {
     if(cpath->nd_head) {
 	COMPILE(ret, "nd_else->nd_head", cpath->nd_head);
@@ -2307,7 +2307,7 @@ compile_cpath(LINK_ANCHOR *ret, yarv_iseq_t *iseq, NODE *cpath)
 }
 
 static int
-defined_expr(yarv_iseq_t *iseq, LINK_ANCHOR *ret,
+defined_expr(rb_iseq_t *iseq, LINK_ANCHOR *ret,
 	     NODE * node, LABEL *lfinish, VALUE needstr)
 {
     char *estr = 0;
@@ -2490,7 +2490,7 @@ defined_expr(yarv_iseq_t *iseq, LINK_ANCHOR *ret,
 #define BUFSIZE 0x100
 
 static VALUE
-make_name_for_block(yarv_iseq_t *iseq)
+make_name_for_block(rb_iseq_t *iseq)
 {
     char buf[BUFSIZE];
     if (iseq->parent_iseq == 0) {
@@ -2498,7 +2498,7 @@ make_name_for_block(yarv_iseq_t *iseq)
     }
     else {
 	int level = 1;
-	yarv_iseq_t *ip = iseq;
+	rb_iseq_t *ip = iseq;
 	while (1) {
 	    if (ip->local_iseq != ip) {
 		ip = ip->parent_iseq;
@@ -2523,7 +2523,7 @@ make_name_with_str(const char *fmt, const char *str)
 }
 
 static void
-add_ensure_range(yarv_iseq_t *iseq, struct ensure_range *erange,
+add_ensure_range(rb_iseq_t *iseq, struct ensure_range *erange,
 		 LABEL *lstart, LABEL *lend)
 {
     struct ensure_range *ne =
@@ -2541,7 +2541,7 @@ add_ensure_range(yarv_iseq_t *iseq, struct ensure_range *erange,
 }
 
 static void
-add_ensure_iseq(LINK_ANCHOR *ret, yarv_iseq_t *iseq)
+add_ensure_iseq(LINK_ANCHOR *ret, rb_iseq_t *iseq)
 {
     struct iseq_compile_data_ensure_node_stack *enlp =
 	iseq->compile_data->ensure_node_stack;
@@ -2567,7 +2567,7 @@ add_ensure_iseq(LINK_ANCHOR *ret, yarv_iseq_t *iseq)
 }
 
 static VALUE
-setup_arg(yarv_iseq_t *iseq, LINK_ANCHOR *args, NODE *node, VALUE *flag)
+setup_arg(rb_iseq_t *iseq, LINK_ANCHOR *args, NODE *node, VALUE *flag)
 {
     VALUE argc = INT2FIX(0);
     NODE *argn = node->nd_args;
@@ -2632,7 +2632,7 @@ setup_arg(yarv_iseq_t *iseq, LINK_ANCHOR *args, NODE *node, VALUE *flag)
   poped: This node will be poped
  */
 static int
-iseq_compile_each(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
+iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
 {
     VALUE tmp;			/* reserved for macro */
     int type;
@@ -3002,7 +3002,7 @@ iseq_compile_each(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
 	      COMPILE_ERROR(("Can't escape from eval with break"));
 	  }
 	  else {
-	      yarv_iseq_t *ip = iseq->parent_iseq;
+	      rb_iseq_t *ip = iseq->parent_iseq;
 	      while (ip) {
 		  level++;
 		  if (ip->compile_data->redo_label != 0) {
@@ -3041,7 +3041,7 @@ iseq_compile_each(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
 	      COMPILE_ERROR(("Can't escape from eval with next"));
 	  }
 	  else {
-	      yarv_iseq_t *ip = iseq->parent_iseq;
+	      rb_iseq_t *ip = iseq->parent_iseq;
 	      while (ip) {
 		  level = 0x8000;
 		  if (ip->type == ISEQ_TYPE_BLOCK) {
@@ -3085,7 +3085,7 @@ iseq_compile_each(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
 	      }
 	  }
 	  else {
-	      yarv_iseq_t *ip = iseq->parent_iseq;
+	      rb_iseq_t *ip = iseq->parent_iseq;
 	      unsigned long level = 0x8000 | 0x4000;
 	      while (ip) {
 		  if (ip->type == ISEQ_TYPE_BLOCK) {
@@ -3682,7 +3682,7 @@ iseq_compile_each(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
 	  else {
 	      /* NODE_ZSUPER */
 	      int i;
-	      yarv_iseq_t *liseq = iseq->local_iseq;
+	      rb_iseq_t *liseq = iseq->local_iseq;
 
 	      argc = INT2FIX(liseq->argc);
 
@@ -3779,7 +3779,7 @@ iseq_compile_each(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
 	  break;
       }
       case NODE_RETURN:{
-	  yarv_iseq_t *is = iseq;
+	  rb_iseq_t *is = iseq;
 
 	  while (is) {
 	      if (is->type == ISEQ_TYPE_TOP || is->type == ISEQ_TYPE_CLASS) {
@@ -4398,7 +4398,7 @@ iseq_compile_each(yarv_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
 			    INT2FIX(0));
 	      }
 	      else {
-		  yarv_iseq_t *ip = iseq;
+		  rb_iseq_t *ip = iseq;
 		  int level = 0;
 		  while (ip) {
 		      if (ip->type == ISEQ_TYPE_RESCUE) {
@@ -4588,7 +4588,7 @@ insn_data_to_s_detail(INSN *iobj)
 		break;
 	      case TS_ISEQ:	/* iseq */
 		{
-		    yarv_iseq_t *iseq = (yarv_iseq_t *)OPERAND_AT(iobj, j);
+		    rb_iseq_t *iseq = (rb_iseq_t *)OPERAND_AT(iobj, j);
 		    VALUE val = Qnil;
 		    if (iseq) {
 			val = iseq->self;
@@ -4692,7 +4692,7 @@ insns_name_array(void)
 }
 
 static LABEL *
-register_label(yarv_iseq_t *iseq, struct st_table *labels_table, VALUE obj)
+register_label(rb_iseq_t *iseq, struct st_table *labels_table, VALUE obj)
 {
     LABEL *label = 0;
     obj = rb_convert_type(obj, T_SYMBOL, "Symbol", "to_sym");
@@ -4732,7 +4732,7 @@ get_exception_sym2type(VALUE sym)
 VALUE iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt);
 
 static int
-iseq_build_exception(yarv_iseq_t *iseq, struct st_table *labels_table,
+iseq_build_exception(rb_iseq_t *iseq, struct st_table *labels_table,
 		     VALUE exception)
 {
     int i;
@@ -4767,7 +4767,7 @@ iseq_build_exception(yarv_iseq_t *iseq, struct st_table *labels_table,
 struct st_table *insn_make_insn_table(void);
 
 static int
-iseq_build_body(yarv_iseq_t *iseq, LINK_ANCHOR *anchor,
+iseq_build_body(rb_iseq_t *iseq, LINK_ANCHOR *anchor,
 		VALUE body, VALUE line, struct st_table *labels_table)
 {
     /* TODO: body should be freezed */
@@ -4894,7 +4894,7 @@ iseq_build_body(yarv_iseq_t *iseq, LINK_ANCHOR *anchor,
 }
 
 VALUE
-iseq_build_from_ary(yarv_iseq_t *iseq, VALUE line,
+iseq_build_from_ary(rb_iseq_t *iseq, VALUE line,
 		    VALUE locals, VALUE args, VALUE exception, VALUE body)
 {
     int i;
diff --git a/compile.h b/compile.h
index d670484539..345116a9cb 100644
--- a/compile.h
+++ b/compile.h
@@ -103,7 +103,7 @@ r_value(VALUE value)
 #define NEW_LABEL(l) new_label_body(iseq, l)
 
 #define iseq_filename(iseq) \
-  (((yarv_iseq_t*)DATA_PTR(iseq))->file_name)
+  (((rb_iseq_t*)DATA_PTR(iseq))->file_name)
 
 #define NEW_ISEQVAL(node, name, type)       \
   new_child_iseq(iseq, node, name, 0, type)
diff --git a/error.c b/error.c
index aeb7e3505c..ee5ccda359 100644
--- a/error.c
+++ b/error.c
@@ -1473,7 +1473,7 @@ Init_syserr(void)
 static void
 err_append(const char *s)
 {
-  yarv_thread_t *th = GET_THREAD();
+  rb_thead_t *th = GET_THREAD();
   if (th->parse_in_eval) {
     if (NIL_P(th->errinfo)) {
       th->errinfo = rb_exc_new2(rb_eSyntaxError, s);
diff --git a/eval.c b/eval.c
index e8e2e70612..1dfacc0dac 100644
--- a/eval.c
+++ b/eval.c
@@ -182,7 +182,7 @@ ruby_cleanup(int ex)
 {
     int state;
     volatile VALUE err = GET_THREAD()->errinfo;
-    yarv_vm_t *vm = GET_THREAD()->vm;
+    rb_vm_t *vm = GET_THREAD()->vm;
 
     /* th->errinfo contains a NODE while break'ing */
     if (RTEST(err) && (TYPE(err) != T_NODE) &&
@@ -466,13 +466,6 @@ rb_frozen_class_p(VALUE klass)
 
 #define MATCH_DATA *rb_svar(node->nd_cnt)
 
-static VALUE
-rb_obj_is_proc(proc)
-    VALUE proc;
-{
-    return yarv_obj_is_proc(proc);
-}
-
 void
 rb_add_event_hook(func, events)
     rb_event_hook_func_t func;
@@ -886,7 +879,7 @@ rb_mod_protected_method_defined(VALUE mod, VALUE mid)
     return Qfalse;
 }
 
-NORETURN(void th_iter_break _((yarv_thread_t *)));
+NORETURN(void th_iter_break _((rb_thead_t *)));
 
 void
 rb_iter_break()
@@ -903,7 +896,7 @@ rb_longjmp(tag, mesg)
     VALUE mesg;
 {
     VALUE at;
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
 
     /*
     //while (th->cfp->pc == 0 || th->cfp->iseq == 0) {
@@ -1088,7 +1081,7 @@ rb_jump_tag(tag)
 int
 rb_block_given_p()
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     if (GC_GUARDED_PTR_REF(th->cfp->lfp[0])) {
 	return Qtrue;
     }
@@ -1128,9 +1121,9 @@ rb_iterator_p()
 VALUE
 rb_f_block_given_p()
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = th->cfp;
-    cfp = th_get_ruby_level_cfp(th, YARV_PREVIOUS_CONTROL_FRAME(cfp));
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th->cfp;
+    cfp = th_get_ruby_level_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
     if (GC_GUARDED_PTR_REF(cfp->lfp[0])) {
 	return Qtrue;
     }
@@ -1245,15 +1238,15 @@ rb_iterate(VALUE (*it_proc) (VALUE), VALUE data1,
     int state;
     volatile VALUE retval = Qnil;
     NODE *node = NEW_IFUNC(bl_proc, data2);
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = th->cfp;
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th->cfp;
 
     TH_PUSH_TAG(th);
     state = TH_EXEC_TAG();
     if (state == 0) {
       iter_retry:
 	{
-	    yarv_block_t *blockptr = GET_BLOCK_PTR_IN_CFP(th->cfp);
+	    rb_block_t *blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(th->cfp);
 	    blockptr->iseq = (void *)node;
 	    blockptr->proc = 0;
 	    th->passed_block = blockptr;
@@ -1524,7 +1517,7 @@ rb_method_missing(int argc, const VALUE *argv, VALUE obj)
     VALUE exc = rb_eNoMethodError;
     char *format = 0;
     NODE *cnode = ruby_current_node;
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     int last_call_status = th->method_missing_reason;
     if (argc == 0 || !SYMBOL_P(argv[0])) {
 	rb_raise(rb_eArgError, "no id given");
@@ -1716,8 +1709,8 @@ VALUE
 rb_f_send(int argc, VALUE *argv, VALUE recv)
 {
     int scope = NOEX_PUBLIC;
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = YARV_PREVIOUS_CONTROL_FRAME(th->cfp);
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
 
     if (SPECIAL_CONST_P(cfp->sp[0])) {
 	scope = NOEX_NOSUPER | NOEX_PRIVATE;
@@ -1856,13 +1849,13 @@ make_backtrace(void)
 }
 
 static ID
-frame_func_id(yarv_control_frame_t *cfp)
+frame_func_id(rb_control_frame_t *cfp)
 {
-    yarv_iseq_t *iseq = cfp->iseq;
+    rb_iseq_t *iseq = cfp->iseq;
     if (!iseq) {
 	return cfp->method_id;
     }
-    else if (YARV_IFUNC_P(iseq)) {
+    else if (RUBY_VM_IFUNC_P(iseq)) {
 	return rb_intern("<ifunc>");
     }
     else {
@@ -1879,8 +1872,8 @@ rb_frame_this_func(void)
 ID
 rb_frame_callee(void)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *prev_cfp = YARV_PREVIOUS_CONTROL_FRAME(th->cfp);
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
     /* check if prev_cfp can be accessible */
     if ((void *)(th->stack + th->stack_size) == (void *)(prev_cfp)) {
         return 0;
@@ -1891,8 +1884,8 @@ rb_frame_callee(void)
 void
 rb_frame_pop(void)
 {
-    yarv_thread_t *th = GET_THREAD();
-    th->cfp = YARV_PREVIOUS_CONTROL_FRAME(th->cfp);
+    rb_thead_t *th = GET_THREAD();
+    th->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
 }
 
 static VALUE
@@ -1904,8 +1897,8 @@ rb_frame_self(void)
 const char *
 rb_sourcefile(void)
 {
-    yarv_iseq_t *iseq = GET_THREAD()->cfp->iseq;
-    if (YARV_NORMAL_ISEQ_P(iseq)) {
+    rb_iseq_t *iseq = GET_THREAD()->cfp->iseq;
+    if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
 	return RSTRING_PTR(iseq->file_name);
     }
     return 0;
@@ -1914,12 +1907,12 @@ rb_sourcefile(void)
 int
 rb_sourceline(void)
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     return th_get_sourceline(th->cfp);
 }
 
-VALUE th_set_eval_stack(yarv_thread_t *, VALUE iseq);
-VALUE th_eval_body(yarv_thread_t *);
+VALUE th_set_eval_stack(rb_thead_t *, VALUE iseq);
+VALUE th_eval_body(rb_thead_t *);
 
 static VALUE
 eval(VALUE self, VALUE src, VALUE scope, char *file, int line)
@@ -1927,9 +1920,9 @@ eval(VALUE self, VALUE src, VALUE scope, char *file, int line)
     int state;
     VALUE result = Qundef;
     VALUE envval;
-    yarv_binding_t *bind = 0;
-    yarv_thread_t *th = GET_THREAD();
-    yarv_env_t *env = NULL;
+    rb_binding_t *bind = 0;
+    rb_thead_t *th = GET_THREAD();
+    rb_env_t *env = NULL;
     NODE *stored_cref_stack = 0;
 
     if (file == 0) {
@@ -1939,7 +1932,7 @@ eval(VALUE self, VALUE src, VALUE scope, char *file, int line)
     }
     PUSH_TAG(PROT_NONE);
     if ((state = EXEC_TAG()) == 0) {
-	yarv_iseq_t *iseq;
+	rb_iseq_t *iseq;
 	VALUE iseqval;
 
 	if (scope != Qnil) {
@@ -1958,8 +1951,8 @@ eval(VALUE self, VALUE src, VALUE scope, char *file, int line)
 	    th->base_block = &env->block;
 	}
 	else {
-	    yarv_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
-	    th->base_block = GET_BLOCK_PTR_IN_CFP(cfp);
+	    rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
+	    th->base_block = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
 	    th->base_block->iseq = cfp->iseq;	/* TODO */
 	}
 
@@ -2065,22 +2058,22 @@ rb_f_eval(int argc, VALUE *argv, VALUE self)
     return eval(self, src, scope, file, line);
 }
 
-VALUE *th_cfp_svar(yarv_control_frame_t *cfp, int idx);
+VALUE *th_cfp_svar(rb_control_frame_t *cfp, int idx);
 
 /* function to call func under the specified class/module context */
 static VALUE
 exec_under(VALUE (*func) (VALUE), VALUE under, VALUE self, VALUE args)
 {
     VALUE val = Qnil;		/* OK */
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = th->cfp;
-    yarv_control_frame_t *pcfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th->cfp;
+    rb_control_frame_t *pcfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     VALUE stored_self = pcfp->self;
     NODE *stored_cref = 0;
     NODE **pcref = 0;
 
-    yarv_block_t block;
-    yarv_block_t *blockptr;
+    rb_block_t block;
+    rb_block_t *blockptr;
     int state;
 
     /* replace environment */
@@ -2093,8 +2086,8 @@ exec_under(VALUE (*func) (VALUE), VALUE under, VALUE self, VALUE args)
 	*th->cfp->lfp = GC_GUARDED_PTR(&block);
     }
 
-    while (!YARV_NORMAL_ISEQ_P(cfp->iseq)) {
-	cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+    while (!RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
+	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
     
     pcref = (NODE **) th_cfp_svar(cfp, -1);
@@ -2727,12 +2720,12 @@ VALUE rb_f_untrace_var();
 static VALUE
 get_errinfo(void)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = th->cfp;
-    yarv_control_frame_t *end_cfp = YARV_END_CONTROL_FRAME(th);
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th->cfp;
+    rb_control_frame_t *end_cfp = RUBY_VM_END_CONTROL_FRAME(th);
 
-    while (YARV_VALID_CONTROL_FRAME_P(cfp, end_cfp)) {
-	if (YARV_NORMAL_ISEQ_P(cfp->iseq)) {
+    while (RUBY_VM_VALID_CONTROL_FRAME_P(cfp, end_cfp)) {
+	if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
 	    if (cfp->iseq->type == ISEQ_TYPE_RESCUE) {
 		return cfp->dfp[-1];
 	    }
@@ -2741,7 +2734,7 @@ get_errinfo(void)
 		return cfp->dfp[-1];
 	    }
 	}
-	cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
     return Qnil;
 }
@@ -2810,15 +2803,15 @@ errat_setter(VALUE val, ID id, VALUE *var)
  *     local_variables   #=> ["fred", "i"]
  */
 
-int th_collect_local_variables_in_heap(yarv_thread_t *th, VALUE *dfp, VALUE ary);
+int th_collect_local_variables_in_heap(rb_thead_t *th, VALUE *dfp, VALUE ary);
 
 static VALUE
 rb_f_local_variables(void)
 {
     VALUE ary = rb_ary_new();
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp =
-	th_get_ruby_level_cfp(th, YARV_PREVIOUS_CONTROL_FRAME(th->cfp));
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp =
+	th_get_ruby_level_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp));
     int i;
 
     while (1) {
@@ -2843,7 +2836,7 @@ rb_f_local_variables(void)
 	    }
 	    else {
 		while (cfp->dfp != dfp) {
-		    cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+		    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
 		}
 	    }
 	}
@@ -2960,8 +2953,8 @@ Init_eval()
 VALUE
 rb_dvar_defined(ID id)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_iseq_t *iseq;
+    rb_thead_t *th = GET_THREAD();
+    rb_iseq_t *iseq;
     if (th->base_block && (iseq = th->base_block->iseq)) {
 	while (iseq->type == ISEQ_TYPE_BLOCK ||
 	       iseq->type == ISEQ_TYPE_RESCUE ||
@@ -2984,7 +2977,7 @@ rb_dvar_defined(ID id)
 void
 rb_scope_setup_top_local_tbl(ID *tbl)
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     if (tbl) {
 	if (th->top_local_tbl) {
 	    xfree(th->top_local_tbl);
@@ -3000,7 +2993,7 @@ rb_scope_setup_top_local_tbl(ID *tbl)
 int
 rb_scope_base_local_tbl_size(void)
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     if (th->base_block) {
 	return th->base_block->iseq->local_iseq->local_size +
 	    2 /* $_, $~ */  - 1 /* svar */ ;
@@ -3013,7 +3006,7 @@ rb_scope_base_local_tbl_size(void)
 ID
 rb_scope_base_local_tbl_id(int i)
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     switch (i) {
     case 0:
 	return rb_intern("$_");
@@ -3028,7 +3021,7 @@ rb_scope_base_local_tbl_id(int i)
 int
 rb_dvar_current(void)
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     if (th->base_block) {
 	return 1;
     }
diff --git a/eval_error.h b/eval_error.h
index 757204b15f..91edcb8521 100644
--- a/eval_error.h
+++ b/eval_error.h
@@ -198,7 +198,7 @@ static int
 error_handle(int ex)
 {
     int status = EXIT_FAILURE;
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
 
     if (thread_set_raised(th))
 	return EXIT_FAILURE;
diff --git a/eval_intern.h b/eval_intern.h
index be0b2c88a7..da51b0ba99 100644
--- a/eval_intern.h
+++ b/eval_intern.h
@@ -4,7 +4,7 @@
 
 #define PASS_PASSED_BLOCK() \
   (GET_THREAD()->passed_block = \
-   GC_GUARDED_PTR_REF((yarv_block_t *)GET_THREAD()->cfp->lfp[0]))
+   GC_GUARDED_PTR_REF((rb_block_t *)GET_THREAD()->cfp->lfp[0]))
 
 
 #define UNSUPPORTED(func) \
@@ -189,8 +189,8 @@ extern int function_call_may_return_twice_false;
 #include <sys/stat.h>
 
 #define TH_PUSH_TAG(th) do { \
-  yarv_thread_t * const _th = th; \
-  struct yarv_tag _tag; \
+  rb_thead_t * const _th = th; \
+  struct rb_vm_tag _tag; \
   _tag.tag = 0; \
   _tag.prev = _th->tag; \
   _th->tag = &_tag;
@@ -278,8 +278,8 @@ extern VALUE sysstack_error;
 void rb_thread_cleanup _((void));
 void rb_thread_wait_other_threads _((void));
 
-int thread_set_raised(yarv_thread_t *th);
-int thread_reset_raised(yarv_thread_t *th);
+int thread_set_raised(rb_thead_t *th);
+int thread_reset_raised(rb_thead_t *th);
 
 VALUE rb_f_eval(int argc, VALUE *argv, VALUE self);
 VALUE rb_make_exception _((int argc, VALUE *argv));
@@ -289,23 +289,22 @@ NORETURN(void print_undef _((VALUE, ID)));
 NORETURN(void th_localjump_error(const char *, VALUE, int));
 NORETURN(void th_jump_tag_but_local_jump(int, VALUE));
 
-rb_thread_t rb_vm_curr_thread();
-VALUE th_compile(yarv_thread_t *th, VALUE str, VALUE file, VALUE line);
+VALUE th_compile(rb_thead_t *th, VALUE str, VALUE file, VALUE line);
 
-NODE *th_get_cref(yarv_thread_t *th, yarv_iseq_t *iseq, yarv_control_frame_t *cfp);
-NODE *th_cref_push(yarv_thread_t *th, VALUE, int);
-NODE *th_set_special_cref(yarv_thread_t *th, VALUE *lfp, NODE * cref_stack);
+NODE *th_get_cref(rb_thead_t *th, rb_iseq_t *iseq, rb_control_frame_t *cfp);
+NODE *th_cref_push(rb_thead_t *th, VALUE, int);
+NODE *th_set_special_cref(rb_thead_t *th, VALUE *lfp, NODE * cref_stack);
 
-static yarv_control_frame_t *
-th_get_ruby_level_cfp(yarv_thread_t *th, yarv_control_frame_t *cfp)
+static rb_control_frame_t *
+th_get_ruby_level_cfp(rb_thead_t *th, rb_control_frame_t *cfp)
 {
-    yarv_iseq_t *iseq = 0;
-    while (!YARV_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) {
-	if (YARV_NORMAL_ISEQ_P(cfp->iseq)) {
+    rb_iseq_t *iseq = 0;
+    while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) {
+	if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
 	    iseq = cfp->iseq;
 	    break;
 	}
-	cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
     if (!iseq) {
 	return 0;
@@ -316,12 +315,13 @@ th_get_ruby_level_cfp(yarv_thread_t *th, yarv_control_frame_t *cfp)
 static NODE *
 ruby_cref()
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
     return th_get_cref(th, cfp->iseq, cfp);
 }
 
-VALUE th_get_cbase(yarv_thread_t *th);
+VALUE th_get_cbase(rb_thead_t *th);
+VALUE rb_obj_is_proc(VALUE);
 
 #define ruby_cbase() th_get_cbase(GET_THREAD())
 
diff --git a/eval_jump.h b/eval_jump.h
index d4fab68705..653172d16c 100644
--- a/eval_jump.h
+++ b/eval_jump.h
@@ -22,8 +22,8 @@ static VALUE
 rb_f_throw(int argc, VALUE *argv)
 {
     VALUE tag, value;
-    yarv_thread_t *th = GET_THREAD();
-    struct yarv_tag *tt = th->tag;
+    rb_thead_t *th = GET_THREAD();
+    struct rb_vm_tag *tt = th->tag;
 
     rb_scan_args(argc, argv, "11", &tag, &value);
     tag = ID2SYM(rb_to_id(tag));
@@ -94,7 +94,7 @@ rb_f_catch(VALUE dmy, VALUE tag)
 {
     int state;
     VALUE val = Qnil;		/* OK */
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
 
     tag = ID2SYM(rb_to_id(tag));
     PUSH_TAG(tag);
@@ -138,7 +138,7 @@ static VALUE
 terminate_process(int status, const char *mesg, long mlen)
 {
     VALUE args[2];
-    yarv_vm_t *vm = GET_THREAD()->vm;
+    rb_vm_t *vm = GET_THREAD()->vm;
 
     args[0] = INT2NUM(status);
     args[1] = rb_str_new(mesg, mlen);
diff --git a/eval_load.c b/eval_load.c
index bbe992171e..809f9654a1 100644
--- a/eval_load.c
+++ b/eval_load.c
@@ -111,7 +111,7 @@ rb_provide(const char *feature)
 VALUE rb_load_path;
 
 NORETURN(static void load_failed _((VALUE)));
-void th_klass_init(yarv_thread_t *);
+void th_klass_init(rb_thead_t *);
 
 void
 rb_load(VALUE fname, int wrap)
@@ -339,7 +339,7 @@ rb_require_safe(VALUE fname, int safe)
 {
     VALUE result = Qnil;
     volatile VALUE errinfo = GET_THREAD()->errinfo;
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     int state;
     char *volatile ftptr = 0;
 
diff --git a/eval_method.h b/eval_method.h
index a99e6bea9a..5abf06d67b 100644
--- a/eval_method.h
+++ b/eval_method.h
@@ -156,7 +156,7 @@ rb_add_method(VALUE klass, ID mid, NODE * node, int noex)
 	}
 
 	if (mid == object_id || mid == __send || mid == __send_bang) {
-	    if (node && nd_type(node) == YARV_METHOD_NODE) {
+	    if (node && nd_type(node) == RUBY_VM_METHOD_NODE) {
 		rb_warn("redefining `%s' may cause serious problem",
 			rb_id2name(mid));
 	    }
diff --git a/eval_safe.h b/eval_safe.h
index 6748ca87fe..76cb059ee5 100644
--- a/eval_safe.h
+++ b/eval_safe.h
@@ -36,7 +36,7 @@ static void safe_setter _((VALUE val));
 void
 rb_set_safe_level(int level)
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
 
     if (level > th->safe_level) {
 	if (level > SAFE_LEVEL_MAX) {
@@ -56,7 +56,7 @@ static void
 safe_setter(VALUE val)
 {
     int level = NUM2INT(val);
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
 
     if (level < th->safe_level) {
 	rb_raise(rb_eSecurityError,
diff --git a/gc.c b/gc.c
index 8b6aab0fcb..c9dde3d557 100644
--- a/gc.c
+++ b/gc.c
@@ -482,13 +482,13 @@ rb_newobj_from_heap(void)
 
 #if USE_VALUE_CACHE
 static VALUE
-rb_fill_value_cache(yarv_thread_t *th)
+rb_fill_value_cache(rb_thead_t *th)
 {
     int i;
     VALUE rv;
 
     /* LOCK */
-    for (i=0; i<YARV_VALUE_CACHE_SIZE; i++) {
+    for (i=0; i<RUBY_VM_VALUE_CACHE_SIZE; i++) {
 	VALUE v = rb_newobj_from_heap();
 	
 	th->value_cache[i] = v;
@@ -505,7 +505,7 @@ VALUE
 rb_newobj(void)
 {
 #if USE_VALUE_CACHE && 1
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     VALUE v = *th->value_cache_ptr;
 
     if (v) {
@@ -562,7 +562,7 @@ static int grow_direction;
 static int
 stack_grow_direction(VALUE *addr)
 {
-  yarv_thread_t *th = GET_THREAD();
+  rb_thead_t *th = GET_THREAD();
   SET_STACK_END;
 
   if (STACK_END > addr) return grow_direction = 1;
@@ -582,7 +582,7 @@ stack_grow_direction(VALUE *addr)
 int
 ruby_stack_length(VALUE **p)
 {
-  yarv_thread_t *th = GET_THREAD();
+  rb_thead_t *th = GET_THREAD();
   SET_STACK_END;
   if (p) *p = STACK_UPPER(STACK_END, STACK_START, STACK_END);
   return STACK_LENGTH;
@@ -592,7 +592,7 @@ int
 ruby_stack_check(void)
 {
   int ret;
-  yarv_thread_t *th = GET_THREAD();
+  rb_thead_t *th = GET_THREAD();
   CHECK_STACK(ret);
   return ret;
 }
@@ -1337,7 +1337,7 @@ garbage_collect(void)
 {
     struct gc_list *list;
     jmp_buf save_regs_gc_mark;
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
 
     if (GC_NOTIFY) printf("start garbage_collect()\n");
 
@@ -1442,7 +1442,7 @@ garbage_collect(void)
 }
 
 void
-yarv_machine_stack_mark(yarv_thread_t *th)
+yarv_machine_stack_mark(rb_thead_t *th)
 {
 #if STACK_GROW_DIRECTION < 0
     rb_gc_mark_locations(th->machine_stack_end, th->machine_stack_start);
diff --git a/inits.c b/inits.c
index 568d450dbb..74115b1d92 100644
--- a/inits.c
+++ b/inits.c
@@ -84,8 +84,8 @@ rb_call_inits()
     Init_GC();
     Init_marshal();
     Init_Enumerator();
-    Init_ISeq();
     Init_VM();
+    Init_ISeq();
     Init_Thread();
     Init_version();
 }
diff --git a/insnhelper.h b/insnhelper.h
index a2cb2e106c..b4ced7a50a 100644
--- a/insnhelper.h
+++ b/insnhelper.h
@@ -124,7 +124,7 @@
 
 /* block */
 #define GET_BLOCK_PTR() \
-  ((yarv_block_t *)(GC_GUARDED_PTR_REF(GET_LFP()[0])))
+  ((rb_block_t *)(GC_GUARDED_PTR_REF(GET_LFP()[0])))
 
 #define CHECK_STACK_OVERFLOW(th, cfp, margin) \
   (((VALUE *)(cfp)->sp) + (margin) >= ((VALUE *)cfp))
diff --git a/insns.def b/insns.def
index dab579d4fc..6acd86505b 100644
--- a/insns.def
+++ b/insns.def
@@ -961,7 +961,7 @@ defined
 	}
 	break;
       case DEFINED_ZSUPER:{
-	  yarv_iseq_t *ip = GET_ISEQ();
+	  rb_iseq_t *ip = GET_ISEQ();
 	  while (ip) {
 	      if (ip->defined_method_id) {
 		  break;
@@ -1011,10 +1011,10 @@ postexe
 ()
 ()
 {
-    yarv_block_t *blockptr;
+    rb_block_t *blockptr;
     VALUE proc;
 
-    blockptr = GET_BLOCK_PTR_IN_CFP(GET_CFP());
+    blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(GET_CFP());
     blockptr->iseq = blockiseq;
     blockptr->proc = 0;
 
@@ -1164,7 +1164,7 @@ send
     NODE *mn;
     VALUE recv;
     VALUE klass;
-    yarv_block_t *blockptr = 0;
+    rb_block_t *blockptr = 0;
     num_t num = op_argc;
     num_t flag = op_flag;
     ID id = op_id;
@@ -1232,8 +1232,8 @@ send
     if (0) {
 	LABEL_IS_SC(start_init_in_super):
 	{
-	    yarv_iseq_t *iseq = GET_ISEQ();
-	    yarv_iseq_t *ip = iseq;
+	    rb_iseq_t *iseq = GET_ISEQ();
+	    rb_iseq_t *ip = iseq;
 
 	    num = tmp_num;
 	    flag = VM_CALL_FCALL_BIT;
@@ -1251,12 +1251,12 @@ send
 	    
 	    if (ip != ip->local_iseq) {
 		/* defined by method_defined() */
-		yarv_control_frame_t *lcfp = GET_CFP();
+		rb_control_frame_t *lcfp = GET_CFP();
 
 		while (lcfp->iseq != ip) {
 		    VALUE *tdfp = GET_PREV_DFP(lcfp->dfp);
 		    while (1) {
-			lcfp = YARV_PREVIOUS_CONTROL_FRAME(lcfp);
+			lcfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(lcfp);
 			if (lcfp->dfp == tdfp) {
 			    break;
 			}
@@ -1287,7 +1287,7 @@ send
 #endif
 #endif
     macro_eval_invoke_method(recv, klass, id, num, mn, blockptr);
-    YARV_CHECK_INTS();
+    RUBY_VM_CHECK_INTS();
 }
 
 /**
@@ -1326,8 +1326,8 @@ invokeblock
 (...)
 (VALUE val)  // inc += 1 - num;
 {
-    yarv_block_t *block = GET_BLOCK_PTR();
-    yarv_iseq_t *iseq;
+    rb_block_t *block = GET_BLOCK_PTR();
+    rb_iseq_t *iseq;
     int argc = num;
 
     if (GET_ISEQ()->local_iseq->type != ISEQ_TYPE_METHOD || block == 0) {
@@ -1392,7 +1392,7 @@ leave
 	}
     }
 
-    YARV_CHECK_INTS();
+    RUBY_VM_CHECK_INTS();
     pop_frame(th);
     RESTORE_REGS();
 }
@@ -1451,7 +1451,7 @@ throw
 		}
 	    }
 	    else if (state == TAG_RETURN) {
-		yarv_control_frame_t *cfp = GET_CFP();
+		rb_control_frame_t *cfp = GET_CFP();
 		int is_orphan = 1;
 		VALUE *dfp = GET_DFP();
 		
@@ -1522,7 +1522,7 @@ jump
 ()
 ()
 {
-    YARV_CHECK_INTS();
+    RUBY_VM_CHECK_INTS();
     JUMP(dst);
 }
 
@@ -1538,7 +1538,7 @@ branchif
 ()
 {
     if (RTEST(val)) {
-	YARV_CHECK_INTS();
+	RUBY_VM_CHECK_INTS();
 	JUMP(dst);
     }
 }
@@ -1555,7 +1555,7 @@ branchunless
 ()
 {
     if (!RTEST(val)) {
-	YARV_CHECK_INTS();
+	RUBY_VM_CHECK_INTS();
 	JUMP(dst);
     }
 }
@@ -2394,7 +2394,7 @@ opt_call_native_compiled
 ()
 {
 #if __GNUC__ && OPT_USE_JIT_COMPILE
-    yarv_iseq_t *iseq = GET_ISEQ();
+    rb_iseq_t *iseq = GET_ISEQ();
     void *label = (void *)iseq->jit_compiled;
 
     breakpoint();
diff --git a/iseq.c b/iseq.c
index 9932491d1c..94ffd7865b 100644
--- a/iseq.c
+++ b/iseq.c
@@ -40,7 +40,7 @@ compile_data_free(struct iseq_compile_data *compile_data)
 static void
 iseq_free(void *ptr)
 {
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
     FREE_REPORT_ENTER("iseq");
 
     if (ptr) {
@@ -67,7 +67,7 @@ iseq_free(void *ptr)
 static void
 iseq_mark(void *ptr)
 {
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
     MARK_REPORT_ENTER("iseq");
 
     if (ptr) {
@@ -94,18 +94,18 @@ static VALUE
 iseq_alloc(VALUE klass)
 {
     VALUE volatile obj;
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
 
-    obj = Data_Make_Struct(klass, yarv_iseq_t, iseq_mark, iseq_free, iseq);
-    MEMZERO(iseq, yarv_iseq_t, 1);
+    obj = Data_Make_Struct(klass, rb_iseq_t, iseq_mark, iseq_free, iseq);
+    MEMZERO(iseq, rb_iseq_t, 1);
     return obj;
 }
 
 static VALUE
-prepare_iseq_build(yarv_iseq_t *iseq,
+prepare_iseq_build(rb_iseq_t *iseq,
 		   VALUE name, VALUE file_name,
 		   VALUE parent, VALUE type, VALUE block_opt,
-		   const yarv_compile_option_t *option)
+		   const rb_compile_option_t *option)
 {
     iseq->name = name;
     iseq->defined_method_id = 0;
@@ -133,7 +133,7 @@ prepare_iseq_build(yarv_iseq_t *iseq,
 	iseq->cref_stack->nd_file = 0;
     }
     else if (parent) {
-	yarv_iseq_t *piseq;
+	rb_iseq_t *piseq;
 	GetISeqPtr(parent, piseq);
 	iseq->cref_stack = piseq->cref_stack;
     }
@@ -162,13 +162,13 @@ prepare_iseq_build(yarv_iseq_t *iseq,
 	iseq->local_iseq = iseq;
     }
     else {
-	yarv_iseq_t *piseq;
+	rb_iseq_t *piseq;
 	GetISeqPtr(parent, piseq);
 	iseq->local_iseq = piseq->local_iseq;
     }
 
     if (RTEST(parent)) {
-	yarv_iseq_t *piseq;
+	rb_iseq_t *piseq;
 	GetISeqPtr(parent, piseq);
 	iseq->parent_iseq = piseq;
     }
@@ -177,7 +177,7 @@ prepare_iseq_build(yarv_iseq_t *iseq,
 }
 
 static VALUE
-cleanup_iseq_build(yarv_iseq_t *iseq)
+cleanup_iseq_build(rb_iseq_t *iseq)
 {
     struct iseq_compile_data *data = iseq->compile_data;
     iseq->compile_data = 0;
@@ -191,7 +191,7 @@ cleanup_iseq_build(yarv_iseq_t *iseq)
     return Qtrue;
 }
 
-static yarv_compile_option_t COMPILE_OPTION_DEFAULT = {
+static rb_compile_option_t COMPILE_OPTION_DEFAULT = {
     OPT_INLINE_CONST_CACHE, /* int inline_const_cache; */
     OPT_PEEPHOLE_OPTIMIZATION, /* int peephole_optimization; */
     OPT_SPECIALISED_INSTRUCTION, /* int specialized_instruction; */
@@ -199,10 +199,10 @@ static yarv_compile_option_t COMPILE_OPTION_DEFAULT = {
     OPT_INSTRUCTIONS_UNIFICATION, /* int instructions_unification; */
     OPT_STACK_CACHING, /* int stack_caching; */
 };
-static const yarv_compile_option_t COMPILE_OPTION_FALSE;
+static const rb_compile_option_t COMPILE_OPTION_FALSE;
 
 static void
-make_compile_option(yarv_compile_option_t *option, VALUE opt)
+make_compile_option(rb_compile_option_t *option, VALUE opt)
 {
     if (opt == Qnil) {
 	*option = COMPILE_OPTION_DEFAULT;
@@ -211,7 +211,7 @@ make_compile_option(yarv_compile_option_t *option, VALUE opt)
 	*option = COMPILE_OPTION_FALSE;
     }
     else if (opt == Qtrue) {
-	memset(option, 1, sizeof(yarv_compile_option_t));
+	memset(option, 1, sizeof(rb_compile_option_t));
     }
     else if (CLASS_OF(opt) == rb_cHash) {
 #define SET_COMPILE_OPTION(o, h, mem) \
@@ -233,7 +233,7 @@ make_compile_option(yarv_compile_option_t *option, VALUE opt)
 }
 
 static VALUE
-make_compile_option_value(yarv_compile_option_t *option)
+make_compile_option_value(rb_compile_option_t *option)
 {
     VALUE opt = rb_hash_new();
 #define SET_COMPILE_OPTION(o, h, mem) \
@@ -254,16 +254,16 @@ VALUE
 yarv_iseq_new(NODE *node, VALUE name, VALUE file_name,
 	      VALUE parent, VALUE type)
 {
-    return yarv_iseq_new_with_opt(node, name, file_name, parent, type,
-				  &COMPILE_OPTION_DEFAULT);
+    return rb_iseq_new_with_opt(node, name, file_name, parent, type,
+				&COMPILE_OPTION_DEFAULT);
 }
 
 static VALUE
 yarv_iseq_new_with_bopt_and_opt(NODE *node, VALUE name, VALUE file_name,
 				VALUE parent, VALUE type, VALUE bopt,
-				const yarv_compile_option_t *option)
+				const rb_compile_option_t *option)
 {
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
     VALUE self = iseq_alloc(rb_cISeq);
     
     GetISeqPtr(self, iseq);
@@ -276,9 +276,9 @@ yarv_iseq_new_with_bopt_and_opt(NODE *node, VALUE name, VALUE file_name,
 }
 
 VALUE
-yarv_iseq_new_with_opt(NODE *node, VALUE name, VALUE file_name,
-			VALUE parent, VALUE type,
-			const yarv_compile_option_t *option)
+rb_iseq_new_with_opt(NODE *node, VALUE name, VALUE file_name,
+		     VALUE parent, VALUE type,
+		     const rb_compile_option_t *option)
 {
     return yarv_iseq_new_with_bopt_and_opt(node, name, file_name, parent, type,
 					   Qfalse, option);
@@ -292,7 +292,7 @@ yarv_iseq_new_with_bopt(NODE *node, VALUE name, VALUE file_name,
 					   bopt, &COMPILE_OPTION_DEFAULT);
 }
 
-VALUE iseq_build_from_ary(yarv_iseq_t *iseq, VALUE line,
+VALUE iseq_build_from_ary(rb_iseq_t *iseq, VALUE line,
 			  VALUE locals, VALUE args, VALUE exception, VALUE body);
 
 #define CHECK_ARRAY(v)   rb_convert_type(v, T_ARRAY, "Array", "to_ary")
@@ -310,8 +310,8 @@ iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt)
 
     VALUE iseq_type;
     struct st_table *type_map = 0;
-    yarv_iseq_t *iseq;
-    yarv_compile_option_t option;
+    rb_iseq_t *iseq;
+    rb_compile_option_t option;
 
     /* [magic, major_version, minor_version, format_type, misc,
      *  name, filename, line,
@@ -398,7 +398,7 @@ iseq_s_compile(int argc, VALUE *argv, VALUE self)
 {
     VALUE str, file = Qnil, line = INT2FIX(1), opt = Qnil;
     NODE *node;
-    yarv_compile_option_t option;
+    rb_compile_option_t option;
     
     rb_scan_args(argc, argv, "13", &str, &file, &line, &opt);
 
@@ -407,8 +407,8 @@ iseq_s_compile(int argc, VALUE *argv, VALUE self)
 
     node = compile_string(str, file, line);
     make_compile_option(&option, opt);
-    return yarv_iseq_new_with_opt(node, rb_str_new2("<main>"), file, Qfalse,
-				  ISEQ_TYPE_TOP, &option);
+    return rb_iseq_new_with_opt(node, rb_str_new2("<main>"), file, Qfalse,
+				ISEQ_TYPE_TOP, &option);
 }
 
 static VALUE
@@ -419,7 +419,7 @@ iseq_s_compile_file(int argc, VALUE *argv, VALUE self)
     VALUE f;
     NODE *node;
     const char *fname;
-    yarv_compile_option_t option;
+    rb_compile_option_t option;
 
     rb_scan_args(argc, argv, "11", &file, &opt);
     fname = StringValueCStr(file);
@@ -429,23 +429,23 @@ iseq_s_compile_file(int argc, VALUE *argv, VALUE self)
     parser = rb_parser_new();
     node = rb_parser_compile_file(parser, fname, f, NUM2INT(line));
     make_compile_option(&option, opt);
-    return yarv_iseq_new_with_opt(node, rb_str_new2("<main>"), file, Qfalse,
-				  ISEQ_TYPE_TOP, &option);
+    return rb_iseq_new_with_opt(node, rb_str_new2("<main>"), file, Qfalse,
+				ISEQ_TYPE_TOP, &option);
 }
 
 static VALUE
 iseq_s_compile_option_set(VALUE self, VALUE opt)
 {
-    yarv_compile_option_t option;
+    rb_compile_option_t option;
     make_compile_option(&option, opt);
     COMPILE_OPTION_DEFAULT = option;
     return make_compile_option_value(&option);
 }
 
-static yarv_iseq_t *
+static rb_iseq_t *
 iseq_check(VALUE val)
 {
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
     GetISeqPtr(val, iseq);
     if (!iseq->name) {
 	rb_raise(rb_eTypeError, "uninitialized InstructionSequence");
@@ -453,19 +453,19 @@ iseq_check(VALUE val)
     return iseq;
 }
 
-VALUE yarv_th_eval(yarv_thread_t *th, VALUE iseqval);
+VALUE rb_thread_eval(rb_thead_t *th, VALUE iseqval);
 
 static VALUE
 iseq_eval(VALUE self)
 {
-    return yarv_th_eval(GET_THREAD(), self);
+    return rb_thread_eval(GET_THREAD(), self);
 }
 
 static VALUE
 iseq_inspect(VALUE self)
 {
     char buff[0x100];
-    yarv_iseq_t *iseq = iseq_check(self);
+    rb_iseq_t *iseq = iseq_check(self);
 
     snprintf(buff, sizeof(buff), "<ISeq:%s@%s>",
 	     RSTRING_PTR(iseq->name), RSTRING_PTR(iseq->file_name));
@@ -473,12 +473,12 @@ iseq_inspect(VALUE self)
     return rb_str_new2(buff);
 }
 
-VALUE iseq_data_to_ary(yarv_iseq_t *iseq);
+VALUE iseq_data_to_ary(rb_iseq_t *iseq);
 
 static VALUE
 iseq_to_a(VALUE self)
 {
-    yarv_iseq_t *iseq = iseq_check(self);
+    rb_iseq_t *iseq = iseq_check(self);
     return iseq_data_to_ary(iseq);
 }
 
@@ -486,7 +486,7 @@ iseq_to_a(VALUE self)
   now, search algorithm is brute force. but this should be binary search.
  */
 static unsigned short
-find_line_no(yarv_iseq_t *iseqdat, unsigned long pos)
+find_line_no(rb_iseq_t *iseqdat, unsigned long pos)
 {
     unsigned long i, size = iseqdat->insn_info_size;
     struct insn_info_struct *iiary = iseqdat->insn_info_tbl;
@@ -501,7 +501,7 @@ find_line_no(yarv_iseq_t *iseqdat, unsigned long pos)
 }
 
 static unsigned short
-find_prev_line_no(yarv_iseq_t *iseqdat, unsigned long pos)
+find_prev_line_no(rb_iseq_t *iseqdat, unsigned long pos)
 {
     unsigned long i, size = iseqdat->insn_info_size;
     struct insn_info_struct *iiary = iseqdat->insn_info_tbl;
@@ -521,7 +521,7 @@ find_prev_line_no(yarv_iseq_t *iseqdat, unsigned long pos)
 }
 
 static VALUE
-insn_operand_intern(yarv_iseq_t *iseq,
+insn_operand_intern(rb_iseq_t *iseq,
 		    int insn, int op_no, VALUE op,
 		    int len, int pos, VALUE *pnop, VALUE child)
 {
@@ -543,7 +543,7 @@ insn_operand_intern(yarv_iseq_t *iseq,
 
     case TS_LINDEX:
 	{
-	    yarv_iseq_t *ip = iseq->local_iseq;
+	    rb_iseq_t *ip = iseq->local_iseq;
 
 	    ret =
 	      rb_str_new2(
@@ -552,7 +552,7 @@ insn_operand_intern(yarv_iseq_t *iseq,
 	}
     case TS_DINDEX:{
 	    if (insn == BIN(getdynamic) || insn == BIN(setdynamic)) {
-		yarv_iseq_t *ip = iseq;
+		rb_iseq_t *ip = iseq;
 		int level = *pnop;
 		int i;
 		for (i = 0; i < level; i++) {
@@ -578,7 +578,7 @@ insn_operand_intern(yarv_iseq_t *iseq,
 
     case TS_ISEQ:		/* iseq */
 	{
-	    yarv_iseq_t *iseq = (yarv_iseq_t *)op;
+	    rb_iseq_t *iseq = (rb_iseq_t *)op;
 	    if (iseq) {
 		ret = iseq->name;
 		if (child) {
@@ -617,7 +617,7 @@ insn_operand_intern(yarv_iseq_t *iseq,
  */
 VALUE
 iseq_disasm_insn(VALUE ret, VALUE *iseq, int pos,
-		 yarv_iseq_t *iseqdat, VALUE child)
+		 rb_iseq_t *iseqdat, VALUE child)
 {
     int insn = iseq[pos];
     int len = insn_len(insn);
@@ -696,7 +696,7 @@ catch_type(int type)
 VALUE
 iseq_disasm(VALUE self)
 {
-    yarv_iseq_t *iseqdat = iseq_check(self);
+    rb_iseq_t *iseqdat = iseq_check(self);
     VALUE *iseq;
     VALUE str = rb_str_new(0, 0);
     VALUE child = rb_ary_new();
@@ -1080,7 +1080,7 @@ cdhash_each(VALUE key, VALUE value, VALUE ary)
 }
 
 VALUE
-iseq_data_to_ary(yarv_iseq_t *iseq)
+iseq_data_to_ary(rb_iseq_t *iseq)
 {
     int i, pos, opt = 0;
     VALUE *seq;
@@ -1205,7 +1205,7 @@ iseq_data_to_ary(yarv_iseq_t *iseq)
 		break;
 	      case TS_ISEQ:
 		{
-		    yarv_iseq_t *iseq = (yarv_iseq_t *)*seq;
+		    rb_iseq_t *iseq = (rb_iseq_t *)*seq;
 		    if (iseq) {
 			VALUE val = iseq_data_to_ary(iseq);
 			rb_ary_push(ary, val);
@@ -1260,7 +1260,7 @@ iseq_data_to_ary(yarv_iseq_t *iseq)
 	struct catch_table_entry *entry = &iseq->catch_table[i];
 	rb_ary_push(ary, exception_type2symbol(entry->type));
 	if (entry->iseq) {
-	    yarv_iseq_t *eiseq;
+	    rb_iseq_t *eiseq;
 	    GetISeqPtr(entry->iseq, eiseq);
 	    rb_ary_push(ary, iseq_data_to_ary(eiseq));
 	}
diff --git a/proc.c b/proc.c
index 0e37b90e48..e9fbfb72fc 100644
--- a/proc.c
+++ b/proc.c
@@ -24,66 +24,11 @@ VALUE rb_cUnboundMethod;
 VALUE rb_cMethod;
 VALUE rb_cBinding;
 VALUE rb_cProc;
-VALUE rb_cEnv;
 
 static VALUE bmcall(VALUE, VALUE);
 static int method_arity(VALUE);
 static VALUE rb_obj_is_method(VALUE m);
 
-/* Env */
-
-static void
-env_free(void *ptr)
-{
-    yarv_env_t *env;
-    FREE_REPORT_ENTER("env");
-    if (ptr) {
-	env = ptr;
-	FREE_UNLESS_NULL(env->env);
-	ruby_xfree(ptr);
-    }
-    FREE_REPORT_LEAVE("env");
-}
-
-static void
-env_mark(void *ptr)
-{
-    yarv_env_t *env;
-    MARK_REPORT_ENTER("env");
-    if (ptr) {
-	env = ptr;
-	if (env->env) {
-	    /* TODO: should mark more restricted range */
-	    GC_INFO("env->env\n");
-	    rb_gc_mark_locations(env->env, env->env + env->env_size);
-	}
-	GC_INFO("env->prev_envval\n");
-	MARK_UNLESS_NULL(env->prev_envval);
-
-	if (env->block.iseq) {
-	    if (BUILTIN_TYPE(env->block.iseq) == T_NODE) {
-		MARK_UNLESS_NULL((VALUE)env->block.iseq);
-	    }
-	    else {
-		MARK_UNLESS_NULL(env->block.iseq->self);
-	    }
-	}
-    }
-    MARK_REPORT_LEAVE("env");
-}
-
-VALUE
-yarv_env_alloc(void)
-{
-    VALUE obj;
-    yarv_env_t *env;
-    obj = Data_Make_Struct(rb_cEnv, yarv_env_t, env_mark, env_free, env);
-    env->env = 0;
-    env->prev_envval = 0;
-    env->block.iseq = 0;
-    return obj;
-}
-
 /* Proc */
 
 static void
@@ -99,14 +44,14 @@ proc_free(void *ptr)
 static void
 proc_mark(void *ptr)
 {
-    yarv_proc_t *proc;
+    rb_proc_t *proc;
     MARK_REPORT_ENTER("proc");
     if (ptr) {
 	proc = ptr;
 	MARK_UNLESS_NULL(proc->envval);
 	MARK_UNLESS_NULL(proc->blockprocval);
 	MARK_UNLESS_NULL((VALUE)proc->special_cref_stack);
-	if (proc->block.iseq && YARV_IFUNC_P(proc->block.iseq)) {
+	if (proc->block.iseq && RUBY_VM_IFUNC_P(proc->block.iseq)) {
 	    MARK_UNLESS_NULL((VALUE)(proc->block.iseq));
 	}
     }
@@ -117,20 +62,20 @@ static VALUE
 proc_alloc(VALUE klass)
 {
     VALUE obj;
-    yarv_proc_t *proc;
-    obj = Data_Make_Struct(klass, yarv_proc_t, proc_mark, proc_free, proc);
-    MEMZERO(proc, yarv_proc_t, 1);
+    rb_proc_t *proc;
+    obj = Data_Make_Struct(klass, rb_proc_t, proc_mark, proc_free, proc);
+    MEMZERO(proc, rb_proc_t, 1);
     return obj;
 }
 
 VALUE
-yarv_proc_alloc(void)
+rb_proc_alloc(void)
 {
     return proc_alloc(rb_cProc);
 }
 
 VALUE
-yarv_obj_is_proc(VALUE proc)
+rb_obj_is_proc(VALUE proc)
 {
     if (TYPE(proc) == T_DATA &&
 	RDATA(proc)->dfree == (RUBY_DATA_FUNC) proc_free) {
@@ -145,7 +90,7 @@ static VALUE
 proc_dup(VALUE self)
 {
     VALUE procval = proc_alloc(rb_cProc);
-    yarv_proc_t *src, *dst;
+    rb_proc_t *src, *dst;
     GetProcPtr(self, src);
     GetProcPtr(procval, dst);
 
@@ -157,12 +102,6 @@ proc_dup(VALUE self)
     return procval;
 }
 
-static VALUE
-yarv_proc_dup(VALUE self)
-{
-    return proc_dup(self);
-}
-
 static VALUE
 proc_clone(VALUE self)
 {
@@ -176,7 +115,7 @@ proc_clone(VALUE self)
 static void
 binding_free(void *ptr)
 {
-    yarv_binding_t *bind;
+    rb_binding_t *bind;
     FREE_REPORT_ENTER("binding");
     if (ptr) {
 	bind = ptr;
@@ -188,7 +127,7 @@ binding_free(void *ptr)
 static void
 binding_mark(void *ptr)
 {
-    yarv_binding_t *bind;
+    rb_binding_t *bind;
     MARK_REPORT_ENTER("binding");
     if (ptr) {
 	bind = ptr;
@@ -202,10 +141,10 @@ static VALUE
 binding_alloc(VALUE klass)
 {
     VALUE obj;
-    yarv_binding_t *bind;
-    obj = Data_Make_Struct(klass, yarv_binding_t,
+    rb_binding_t *bind;
+    obj = Data_Make_Struct(klass, rb_binding_t,
 			   binding_mark, binding_free, bind);
-    MEMZERO(bind, yarv_binding_t, 1);
+    MEMZERO(bind, rb_binding_t, 1);
     return obj;
 }
 
@@ -213,7 +152,7 @@ static VALUE
 binding_dup(VALUE self)
 {
     VALUE bindval = binding_alloc(rb_cBinding);
-    yarv_binding_t *src, *dst;
+    rb_binding_t *src, *dst;
     GetBindingPtr(self, src);
     GetBindingPtr(bindval, dst);
     dst->env = src->env;
@@ -232,10 +171,10 @@ binding_clone(VALUE self)
 VALUE
 rb_binding_new(void)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
     VALUE bindval = binding_alloc(rb_cBinding);
-    yarv_binding_t *bind;
+    rb_binding_t *bind;
 
     GetBindingPtr(bindval, bind);
     bind->env = th_make_env_object(th, cfp);
@@ -302,18 +241,18 @@ static VALUE
 proc_new(VALUE klass, int is_lambda)
 {
     VALUE procval = Qnil;
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = th->cfp;
-    yarv_block_t *block;
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th->cfp;
+    rb_block_t *block;
 
     if ((GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0 &&
-	!YARV_CLASS_SPECIAL_P(cfp->lfp[0])) {
+	!RUBY_VM_CLASS_SPECIAL_P(cfp->lfp[0])) {
 	block = GC_GUARDED_PTR_REF(cfp->lfp[0]);
     }
     else {
-	cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
 	if ((GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0 &&
-	    !YARV_CLASS_SPECIAL_P(cfp->lfp[0])) {
+	    !RUBY_VM_CLASS_SPECIAL_P(cfp->lfp[0])) {
 	    block = GC_GUARDED_PTR_REF(cfp->lfp[0]);
 
 	    if (is_lambda) {
@@ -326,11 +265,11 @@ proc_new(VALUE klass, int is_lambda)
 	}
     }
 
-    cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     procval = th_make_proc(th, cfp, block);
 
     if (is_lambda) {
-	yarv_proc_t *proc;
+	rb_proc_t *proc;
 	GetProcPtr(procval, proc);
 	proc->is_lambda = Qtrue;
     }
@@ -403,7 +342,7 @@ proc_lambda(void)
 VALUE
 proc_invoke(VALUE self, VALUE args, VALUE alt_self, VALUE alt_klass)
 {
-    yarv_proc_t *proc;
+    rb_proc_t *proc;
     GetProcPtr(self, proc);
 
     /* ignore self and klass */
@@ -448,7 +387,7 @@ proc_invoke(VALUE self, VALUE args, VALUE alt_self, VALUE alt_klass)
 static VALUE
 proc_call(int argc, VALUE *argv, VALUE procval)
 {
-    yarv_proc_t *proc;
+    rb_proc_t *proc;
     GetProcPtr(procval, proc);
     return th_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv);
 }
@@ -456,7 +395,7 @@ proc_call(int argc, VALUE *argv, VALUE procval)
 static VALUE
 proc_yield(int argc, VALUE *argv, VALUE procval)
 {
-    yarv_proc_t *proc;
+    rb_proc_t *proc;
     GetProcPtr(procval, proc);
     return th_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv);
 }
@@ -490,8 +429,8 @@ rb_proc_call(VALUE proc, VALUE args)
 static VALUE
 proc_arity(VALUE self)
 {
-    yarv_proc_t *proc;
-    yarv_iseq_t *iseq;
+    rb_proc_t *proc;
+    rb_iseq_t *iseq;
     GetProcPtr(self, proc);
     iseq = proc->block.iseq;
     if (iseq && BUILTIN_TYPE(iseq) != T_NODE) {
@@ -531,7 +470,7 @@ proc_eq(VALUE self, VALUE other)
 	if (TYPE(other)          == T_DATA &&
 	    RBASIC(other)->klass == rb_cProc &&
 	    CLASS_OF(self)       == CLASS_OF(other)) {
-	    yarv_proc_t *p1, *p2;
+	    rb_proc_t *p1, *p2;
 	    GetProcPtr(self, p1);
 	    GetProcPtr(other, p2);
 	    if (p1->block.iseq == p2->block.iseq && p1->envval == p2->envval) {
@@ -553,7 +492,7 @@ static VALUE
 proc_hash(VALUE self)
 {
     int hash;
-    yarv_proc_t *proc;
+    rb_proc_t *proc;
     GetProcPtr(self, proc);
     hash = (long)proc->block.iseq;
     hash ^= (long)proc->envval;
@@ -573,14 +512,14 @@ static VALUE
 proc_to_s(VALUE self)
 {
     VALUE str = 0;
-    yarv_proc_t *proc;
+    rb_proc_t *proc;
     char *cname = rb_obj_classname(self);
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
     
     GetProcPtr(self, proc);
     iseq = proc->block.iseq;
 
-    if (YARV_NORMAL_ISEQ_P(iseq)) {
+    if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
 	int line_no = 0;
 	
 	if (iseq->insn_info_tbl) {
@@ -963,7 +902,7 @@ rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
     else if (argc == 2) {
 	id = rb_to_id(argv[0]);
 	body = argv[1];
-	if (!rb_obj_is_method(body) && !yarv_obj_is_proc(body)) {
+	if (!rb_obj_is_method(body) && !rb_obj_is_proc(body)) {
 	    rb_raise(rb_eTypeError,
 		     "wrong argument type %s (expected Proc/Method)",
 		     rb_obj_classname(body));
@@ -989,9 +928,9 @@ rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
 	}
 	node = method->body;
     }
-    else if (yarv_obj_is_proc(body)) {
-	yarv_proc_t *proc;
-	body = yarv_proc_dup(body);
+    else if (rb_obj_is_proc(body)) {
+	rb_proc_t *proc;
+	body = proc_dup(body);
 	GetProcPtr(body, proc);
 	if (BUILTIN_TYPE(proc->block.iseq) != T_NODE) {
 	    proc->block.iseq->defined_method_id = id;
@@ -1221,8 +1160,8 @@ rb_node_arity(NODE* body)
 	if (body->nd_opt || body->nd_rest)
 	    n = -n - 1;
 	return n;
-    case YARV_METHOD_NODE:{
-	    yarv_iseq_t *iseq;
+    case RUBY_VM_METHOD_NODE:{
+	    rb_iseq_t *iseq;
 	    GetISeqPtr((VALUE)body->nd_body, iseq);
 	    if (iseq->arg_rest == 0 && iseq->arg_opts == 0) {
 		return iseq->argc;
@@ -1378,7 +1317,7 @@ rb_proc_new(
     VALUE (*func)(ANYARGS), /* VALUE yieldarg[, VALUE procarg] */
     VALUE val)
 {
-    yarv_proc_t *proc;
+    rb_proc_t *proc;
     VALUE procval = rb_iterate((VALUE(*)(VALUE))mproc, 0, func, val);
     GetProcPtr(procval, proc);
     ((NODE*)proc->block.iseq)->u3.state = 1;
@@ -1466,11 +1405,6 @@ localjump_reason(VALUE exc)
 void
 Init_Proc(void)
 {
-    /* Env */
-    rb_cVM = rb_define_class("VM", rb_cObject); /* TODO: should be moved to suitable place */
-    rb_cEnv = rb_define_class_under(rb_cVM, "Env", rb_cObject);
-    rb_undef_alloc_func(rb_cEnv);
-
     /* Proc */
     rb_cProc = rb_define_class("Proc", rb_cObject);
     rb_undef_alloc_func(rb_cProc);
diff --git a/process.c b/process.c
index ea9347072c..bcd41a5f2a 100644
--- a/process.c
+++ b/process.c
@@ -200,7 +200,7 @@ static VALUE rb_cProcStatus;
 void
 rb_last_status_set(int status, rb_pid_t pid)
 {
-    yarv_vm_t *vm = GET_VM();
+    rb_vm_t *vm = GET_VM();
     vm->last_status = rb_obj_alloc(rb_cProcStatus);
     rb_iv_set(vm->last_status, "status", INT2FIX(status));
     rb_iv_set(vm->last_status, "pid", INT2FIX(pid));
diff --git a/ruby.h b/ruby.h
index 179a1ea15c..6cb3143e47 100644
--- a/ruby.h
+++ b/ruby.h
@@ -712,6 +712,7 @@ RUBY_EXTERN VALUE rb_cTrueClass;
 RUBY_EXTERN VALUE rb_cUnboundMethod;
 RUBY_EXTERN VALUE rb_cISeq;
 RUBY_EXTERN VALUE rb_cVM;
+RUBY_EXTERN VALUE rb_cEnv;
 
 RUBY_EXTERN VALUE rb_eException;
 RUBY_EXTERN VALUE rb_eStandardError;
diff --git a/signal.c b/signal.c
index f364c6b691..63dd4f0878 100644
--- a/signal.c
+++ b/signal.c
@@ -392,7 +392,7 @@ ruby_nativethread_signal(int signum, sighandler_t handler)
 static RETSIGTYPE
 sighandler(int sig)
 {
-    yarv_vm_t *vm = GET_VM(); /* fix me for Multi-VM */
+    rb_vm_t *vm = GET_VM(); /* fix me for Multi-VM */
     ATOMIC_INC(vm->signal_buff[sig]);
     ATOMIC_INC(vm->bufferd_signal_size);
 }
@@ -431,7 +431,7 @@ rb_enable_interrupt(void)
 }
 
 int
-rb_get_next_signal(yarv_vm_t *vm)
+rb_get_next_signal(rb_vm_t *vm)
 {
     int i, sig = 0;
 
@@ -496,7 +496,7 @@ rb_trap_exit(void)
 }
 
 void
-rb_signal_exec(yarv_thread_t *th, int sig)
+rb_signal_exec(rb_thead_t *th, int sig)
 {
     VALUE cmd = rb_get_trap_cmd(sig);
 
@@ -528,7 +528,7 @@ rb_signal_exec(yarv_thread_t *th, int sig)
 	rb_thread_signal_exit(th);
     }
     else {
-	yarv_proc_t *proc;
+	rb_proc_t *proc;
 	VALUE signum = INT2FIX(sig);
 	GetProcPtr(cmd, proc);
 	th_invoke_proc(th, proc, proc->block.self, 1, &signum);
diff --git a/thread.c b/thread.c
index f2a0589b91..6ecb79d356 100644
--- a/thread.c
+++ b/thread.c
@@ -28,7 +28,7 @@
     scheduling, running thread release GVL.  If running thread
     try blocking operation, this thread must release GVL and another
     thread can continue this flow.  After blocking operation, thread
-    must check interrupt (YARV_CHECK_INTS).
+    must check interrupt (RUBY_VM_CHECK_INTS).
 
     Every VM can run parallel.
 
@@ -52,14 +52,14 @@
 #define THREAD_DEBUG 0
 
 static void sleep_for_polling();
-static void sleep_timeval(yarv_thread_t *th, struct timeval time);
-static void sleep_wait_for_interrupt(yarv_thread_t *th, double sleepsec);
-static void sleep_forever(yarv_thread_t *th);
+static void sleep_timeval(rb_thead_t *th, struct timeval time);
+static void sleep_wait_for_interrupt(rb_thead_t *th, double sleepsec);
+static void sleep_forever(rb_thead_t *th);
 static double timeofday();
 struct timeval rb_time_interval(VALUE);
-static int rb_thread_dead(yarv_thread_t *th);
+static int rb_thread_dead(rb_thead_t *th);
 
-void rb_signal_exec(yarv_thread_t *th, int sig);
+void rb_signal_exec(rb_thead_t *th, int sig);
 void rb_disable_interrupt();
 
 static VALUE eKillSignal = INT2FIX(0);
@@ -76,12 +76,12 @@ st_delete_wrap(st_table * table, VALUE key)
 
 #define THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION
 
-static void native_thread_interrupt(yarv_thread_t *th);
-static void yarv_set_interrupt_function(yarv_thread_t *th, yarv_interrupt_function_t *func, int is_return);
-static void yarv_clear_interrupt_function(yarv_thread_t *th);
+static void native_thread_interrupt(rb_thead_t *th);
+static void yarv_set_interrupt_function(rb_thead_t *th, rb_interrupt_function_t *func, int is_return);
+static void yarv_clear_interrupt_function(rb_thead_t *th);
 
 #define GVL_UNLOCK_RANGE(exec) do { \
-    yarv_thread_t *__th = GET_THREAD(); \
+    rb_thead_t *__th = GET_THREAD(); \
     int __prev_status = __th->status; \
     yarv_set_interrupt_function(__th, native_thread_interrupt, 0); \
     __th->status = THREAD_STOPPED; \
@@ -94,7 +94,7 @@ static void yarv_clear_interrupt_function(yarv_thread_t *th);
     if (__th->status == THREAD_STOPPED) { \
 	__th->status = __prev_status; \
     } \
-    YARV_CHECK_INTS(); \
+    RUBY_VM_CHECK_INTS(); \
 } while(0)
 
 #if THREAD_DEBUG
@@ -125,7 +125,7 @@ void thread_debug(const char *fmt, ...);
 
 #if THREAD_DEBUG
 static int debug_mutex_initialized = 1;
-static yarv_thread_lock_t debug_mutex;
+static rb_thread_lock_t debug_mutex;
 
 void
 thread_debug(const char *fmt, ...)
@@ -148,10 +148,10 @@ thread_debug(const char *fmt, ...)
 
 
 static void
-yarv_set_interrupt_function(yarv_thread_t *th, yarv_interrupt_function_t *func, int is_return)
+yarv_set_interrupt_function(rb_thead_t *th, rb_interrupt_function_t *func, int is_return)
 {
   check_ints:
-    YARV_CHECK_INTS();
+    RUBY_VM_CHECK_INTS();
     native_mutex_lock(&th->interrupt_lock);
     if (th->interrupt_flag) {
 	native_mutex_unlock(&th->interrupt_lock);
@@ -169,7 +169,7 @@ yarv_set_interrupt_function(yarv_thread_t *th, yarv_interrupt_function_t *func,
 }
 
 static void
-yarv_clear_interrupt_function(yarv_thread_t *th)
+yarv_clear_interrupt_function(rb_thead_t *th)
 {
     native_mutex_lock(&th->interrupt_lock);
     th->interrupt_function = 0;
@@ -177,7 +177,7 @@ yarv_clear_interrupt_function(yarv_thread_t *th)
 }
 
 static void
-rb_thread_interrupt(yarv_thread_t *th)
+rb_thread_interrupt(rb_thead_t *th)
 {
     native_mutex_lock(&th->interrupt_lock);
     th->interrupt_flag = 1;
@@ -193,10 +193,10 @@ rb_thread_interrupt(yarv_thread_t *th)
 
 
 static int
-terminate_i(st_data_t key, st_data_t val, yarv_thread_t *main_thread)
+terminate_i(st_data_t key, st_data_t val, rb_thead_t *main_thread)
 {
     VALUE thval = key;
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thval, th);
 
     if (th != main_thread) {
@@ -214,8 +214,8 @@ terminate_i(st_data_t key, st_data_t val, yarv_thread_t *main_thread)
 void
 rb_thread_terminate_all(void)
 {
-    yarv_thread_t *th = GET_THREAD(); /* main thread */
-    yarv_vm_t *vm = th->vm;
+    rb_thead_t *th = GET_THREAD(); /* main thread */
+    rb_vm_t *vm = th->vm;
     if (vm->main_thread != th) {
 	rb_bug("rb_thread_terminate_all: called by child thread (%p, %p)", vm->main_thread, th);
     }
@@ -230,24 +230,24 @@ rb_thread_terminate_all(void)
 }
 
 
-VALUE th_eval_body(yarv_thread_t *th);
+VALUE th_eval_body(rb_thead_t *th);
 
 static void
 thread_cleanup_func(void *th_ptr)
 {
-    yarv_thread_t *th = th_ptr;
+    rb_thead_t *th = th_ptr;
     th->status = THREAD_KILLED;
     th->machine_stack_start = th->machine_stack_end = 0;
 }
 
 
 static int
-thread_start_func_2(yarv_thread_t *th, VALUE *stack_start)
+thread_start_func_2(rb_thead_t *th, VALUE *stack_start)
 {
     int state;
     VALUE args = th->first_args;
-    yarv_proc_t *proc;
-    yarv_thread_t *join_th;
+    rb_proc_t *proc;
+    rb_thead_t *join_th;
     th->machine_stack_start = stack_start;
     th->thgroup = th->vm->thgroup_default;
 
@@ -256,7 +256,7 @@ thread_start_func_2(yarv_thread_t *th, VALUE *stack_start)
     native_mutex_lock(&th->vm->global_interpreter_lock);
     {
 	thread_debug("thread start (get lock): %p\n", th);
-	yarv_set_current_running_thread(th);
+	rb_thread_set_current(th);
 
 	TH_PUSH_TAG(th);
 	if ((state = EXEC_TAG()) == 0) {
@@ -293,16 +293,14 @@ thread_start_func_2(yarv_thread_t *th, VALUE *stack_start)
     return 0;
 }
 
-VALUE yarv_thread_alloc(VALUE klass);
-
 static VALUE
 thread_create_core(VALUE klass, VALUE args, VALUE (*fn)(ANYARGS), void *arg)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     VALUE thval;
 
     /* create thread object */
-    thval = yarv_thread_alloc(klass);
+    thval = rb_thread_alloc(klass);
     GetThreadPtr(thval, th);
 
     /* setup thread environment */
@@ -348,9 +346,9 @@ rb_thread_create(VALUE (*fn)(ANYARGS), void *arg)
 VALUE th_make_jump_tag_but_local_jump(int state, VALUE val);
 
 static VALUE
-thread_join(yarv_thread_t *target_th, double delay)
+thread_join(rb_thead_t *target_th, double delay)
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     double now, limit = timeofday() + delay;
     
     thread_debug("thread_join (thid: %p)\n", target_th->thread_id);
@@ -440,7 +438,7 @@ thread_join(yarv_thread_t *target_th, double delay)
 static VALUE
 thread_join_m(int argc, VALUE *argv, VALUE self)
 {
-    yarv_thread_t *target_th;
+    rb_thead_t *target_th;
     double delay = DELAY_INFTY;
     VALUE limit;
     
@@ -467,7 +465,7 @@ thread_join_m(int argc, VALUE *argv, VALUE self)
 static VALUE
 thread_value(VALUE self)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(self, th);
     thread_join(th, DELAY_INFTY);
     return th->value;
@@ -492,14 +490,14 @@ double2timeval(double d)
 }
 
 static void
-sleep_forever(yarv_thread_t *th)
+sleep_forever(rb_thead_t *th)
 {
     native_sleep(th, 0);
-    YARV_CHECK_INTS();
+    RUBY_VM_CHECK_INTS();
 }
 
 static void
-sleep_timeval(yarv_thread_t *th, struct timeval tv)
+sleep_timeval(rb_thead_t *th, struct timeval tv)
 {
     native_sleep(th, &tv);
 }
@@ -520,13 +518,13 @@ timeofday(void)
 }
 
 static void
-sleep_wait_for_interrupt(yarv_thread_t *th, double sleepsec)
+sleep_wait_for_interrupt(rb_thead_t *th, double sleepsec)
 {
     sleep_timeval(th, double2timeval(sleepsec));
 }
 
 static void
-sleep_for_polling(yarv_thread_t *th)
+sleep_for_polling(rb_thead_t *th)
 {
     struct timeval time;
     time.tv_sec = 0;
@@ -537,7 +535,7 @@ sleep_for_polling(yarv_thread_t *th)
 void
 rb_thread_wait_for(struct timeval time)
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     sleep_timeval(th, time);
 }
 
@@ -545,7 +543,7 @@ void
 rb_thread_polling(void)
 {
     if (!rb_thread_alone()) {
-	yarv_thread_t *th = GET_THREAD();
+	rb_thead_t *th = GET_THREAD();
 	sleep_for_polling(th);
     }
 }
@@ -563,7 +561,7 @@ rb_thread_schedule()
 {
     thread_debug("rb_thread_schedule\n");
     if (!rb_thread_alone()) {
-	yarv_thread_t *th = GET_THREAD();
+	rb_thead_t *th = GET_THREAD();
 
 	thread_debug("rb_thread_schedule/switch start\n");
 
@@ -574,10 +572,10 @@ rb_thread_schedule()
 	}
 	native_mutex_lock(&th->vm->global_interpreter_lock);
 
-	yarv_set_current_running_thread(th);
+	rb_thread_set_current(th);
 	thread_debug("rb_thread_schedule/switch done\n");
 
-	YARV_CHECK_INTS();
+	RUBY_VM_CHECK_INTS();
     }
 }
 
@@ -592,10 +590,10 @@ rb_thread_s_critical(VALUE self)
 
 
 VALUE
-rb_thread_run_parallel(VALUE(*func)(yarv_thread_t *th, void *), void *data)
+rb_thread_run_parallel(VALUE(*func)(rb_thead_t *th, void *), void *data)
 {
     VALUE val;
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     
     GVL_UNLOCK_RANGE({
 	val = func(th, data);
@@ -637,7 +635,7 @@ thread_s_pass(VALUE klass)
  */
 
 void
-yarv_thread_execute_interrupts(yarv_thread_t *th)
+rb_thread_execute_interrupts(rb_thead_t *th)
 {
     while (th->interrupt_flag) {
 	int status = th->status;
@@ -655,14 +653,14 @@ yarv_thread_execute_interrupts(yarv_thread_t *th)
 	if (th->throwed_errinfo) {
 	    VALUE err = th->throwed_errinfo;
 	    th->throwed_errinfo = 0;
-	    thread_debug("yarv_thread_execute_interrupts: %p\n", err);
+	    thread_debug("rb_thread_execute_interrupts: %p\n", err);
 
 	    if (err == eKillSignal) {
 		th->errinfo = INT2FIX(TAG_FATAL);
 		TH_JUMP_TAG(th, TAG_FATAL);
 	    }
 	    else if (err == eTerminateSignal) {
-		struct yarv_tag *tag = th->tag;
+		struct rb_vm_tag *tag = th->tag;
 
 		/* rewind to toplevel stack */
 		while (th->tag->prev) {
@@ -693,13 +691,13 @@ rb_gc_mark_threads()
 /*****************************************************/
 
 static void
-rb_thread_ready(yarv_thread_t *th)
+rb_thread_ready(rb_thead_t *th)
 {
     rb_thread_interrupt(th);
 }
 
 static VALUE
-yarv_thread_raise(int argc, VALUE *argv, yarv_thread_t *th)
+yarv_thread_raise(int argc, VALUE *argv, rb_thead_t *th)
 {
     VALUE exc;
 
@@ -719,7 +717,7 @@ rb_thread_signal_raise(void *thptr, const char *sig)
 {
     VALUE argv[1];
     char buf[BUFSIZ];
-    yarv_thread_t *th = thptr;
+    rb_thead_t *th = thptr;
     
     if (sig == 0) {
 	return;			/* should not happen */
@@ -734,7 +732,7 @@ rb_thread_signal_exit(void *thptr)
 {
     VALUE argv[1];
     VALUE args[2];
-    yarv_thread_t *th = thptr;
+    rb_thead_t *th = thptr;
     
     args[0] = INT2NUM(EXIT_SUCCESS);
     args[1] = rb_str_new2("exit");
@@ -743,7 +741,7 @@ rb_thread_signal_exit(void *thptr)
 }
 
 int
-thread_set_raised(yarv_thread_t *th)
+thread_set_raised(rb_thead_t *th)
 {
     if (th->raised_flag) {
 	return 1;
@@ -753,7 +751,7 @@ thread_set_raised(yarv_thread_t *th)
 }
 
 int
-thread_reset_raised(yarv_thread_t *th)
+thread_reset_raised(rb_thead_t *th)
 {
     if (th->raised_flag == 0) {
 	return 0;
@@ -790,7 +788,7 @@ rb_thread_fd_close(int fd)
 static VALUE
 thread_raise_m(int argc, VALUE *argv, VALUE self)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(self, th);
     yarv_thread_raise(argc, argv, th);
     return Qnil;
@@ -812,7 +810,7 @@ thread_raise_m(int argc, VALUE *argv, VALUE self)
 VALUE
 rb_thread_kill(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
 
     GetThreadPtr(thread, th);
 
@@ -892,7 +890,7 @@ rb_thread_exit()
 VALUE
 rb_thread_wakeup(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
 
     if (th->status == THREAD_KILLED) {
@@ -967,7 +965,7 @@ static int
 thread_list_i(st_data_t key, st_data_t val, void *data)
 {
     VALUE ary = (VALUE)data;
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr((VALUE)key, th);
 
     switch (th->status) {
@@ -1109,7 +1107,7 @@ rb_thread_s_abort_exc_set(VALUE self, VALUE val)
 static VALUE
 rb_thread_abort_exc(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
     return th->abort_on_exception ? Qtrue : Qfalse;
 }
@@ -1127,7 +1125,7 @@ rb_thread_abort_exc(VALUE thread)
 static VALUE
 rb_thread_abort_exc_set(VALUE thread, VALUE val)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     rb_secure(4);
 
     GetThreadPtr(thread, th);
@@ -1149,7 +1147,7 @@ rb_thread_abort_exc_set(VALUE thread, VALUE val)
 VALUE
 rb_thread_group(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     VALUE group;
     GetThreadPtr(thread, th);
     group = th->thgroup;
@@ -1161,7 +1159,7 @@ rb_thread_group(VALUE thread)
 }
 
 static const char *
-thread_status_name(enum yarv_thread_status status)
+thread_status_name(enum rb_thread_status status)
 {
     switch (status) {
     case THREAD_RUNNABLE:
@@ -1178,7 +1176,7 @@ thread_status_name(enum yarv_thread_status status)
 }
 
 static int
-rb_thread_dead(yarv_thread_t *th)
+rb_thread_dead(rb_thead_t *th)
 {
     return th->status == THREAD_KILLED;
 }
@@ -1210,7 +1208,7 @@ rb_thread_dead(yarv_thread_t *th)
 static VALUE
 rb_thread_status(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
 
     if (rb_thread_dead(th)) {
@@ -1239,7 +1237,7 @@ rb_thread_status(VALUE thread)
 static VALUE
 rb_thread_alive_p(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
 
     if (rb_thread_dead(th))
@@ -1262,7 +1260,7 @@ rb_thread_alive_p(VALUE thread)
 static VALUE
 rb_thread_stop_p(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
 
     if (rb_thread_dead(th))
@@ -1287,7 +1285,7 @@ rb_thread_stop_p(VALUE thread)
 static VALUE
 rb_thread_safe_level(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
 
     return INT2NUM(th->safe_level);
@@ -1304,7 +1302,7 @@ static VALUE
 rb_thread_inspect(VALUE thread)
 {
     char *cname = rb_obj_classname(thread);
-    yarv_thread_t *th;
+    rb_thead_t *th;
     const char *status;
     VALUE str;
 
@@ -1319,7 +1317,7 @@ rb_thread_inspect(VALUE thread)
 VALUE
 rb_thread_local_aref(VALUE thread, ID id)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     VALUE val;
 
     GetThreadPtr(thread, th);
@@ -1365,7 +1363,7 @@ rb_thread_aref(VALUE thread, VALUE id)
 VALUE
 rb_thread_local_aset(VALUE thread, ID id, VALUE val)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
 
     if (rb_safe_level() >= 4 && th != GET_THREAD()) {
@@ -1415,7 +1413,7 @@ rb_thread_aset(VALUE self, ID id, VALUE val)
 static VALUE
 rb_thread_key_p(VALUE self, ID id)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(self, th);
 
     if (!th->local_storage) {
@@ -1462,7 +1460,7 @@ rb_thread_alone()
 static VALUE
 rb_thread_keys(VALUE self)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     VALUE ary = rb_ary_new();
     GetThreadPtr(self, th);
 
@@ -1485,7 +1483,7 @@ rb_thread_keys(VALUE self)
 static VALUE
 rb_thread_priority(VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
     return INT2NUM(th->priority);
 }
@@ -1517,7 +1515,7 @@ rb_thread_priority(VALUE thread)
 static VALUE
 rb_thread_priority_set(VALUE thread, VALUE prio)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
 
     rb_secure(4);
@@ -1734,7 +1732,7 @@ rb_gc_set_stack_end(VALUE **stack_end_p)
 }
 
 void
-rb_gc_save_machine_context(yarv_thread_t *th)
+rb_gc_save_machine_context(rb_thead_t *th)
 {
     rb_gc_set_stack_end(&th->machine_stack_end);
     setjmp(th->machine_regs);
@@ -1744,12 +1742,12 @@ rb_gc_save_machine_context(yarv_thread_t *th)
  *
  */
 
-int rb_get_next_signal(yarv_vm_t *vm);
+int rb_get_next_signal(rb_vm_t *vm);
 
 static void
 timer_thread_function(void)
 {
-    yarv_vm_t *vm = GET_VM(); /* TODO: fix me for Multi-VM */
+    rb_vm_t *vm = GET_VM(); /* TODO: fix me for Multi-VM */
     vm->running_thread->interrupt_flag = 1;
     
     if (vm->bufferd_signal_size && vm->main_thread->exec_signal == 0) {
@@ -1786,8 +1784,8 @@ rb_thread_start_timer_thread(void)
 void
 rb_thread_atfork(void)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_vm_t *vm = th->vm;
+    rb_thead_t *th = GET_THREAD();
+    rb_vm_t *vm = th->vm;
     vm->main_thread = th;
 
     st_free_table(vm->living_threads);
@@ -1854,7 +1852,7 @@ thgroup_list_i(st_data_t key, st_data_t val, st_data_t data)
     VALUE thread = (VALUE)key;
     VALUE ary = ((struct thgroup_list_params *)data)->ary;
     VALUE group = ((struct thgroup_list_params *)data)->group;
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thread, th);
 
     if (th->thgroup == group) {
@@ -1965,7 +1963,7 @@ thgroup_enclosed_p(VALUE group)
 static VALUE
 thgroup_add(VALUE group, VALUE thread)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     struct thgroup *data;
 
     rb_secure(4);
@@ -2001,8 +1999,8 @@ thgroup_add(VALUE group, VALUE thread)
  */
 
 typedef struct mutex_struct {
-    yarv_thread_t *th;
-    yarv_thread_lock_t lock;
+    rb_thead_t *th;
+    rb_thread_lock_t lock;
 } mutex_t;
 
 #define GetMutexVal(obj, tobj) \
@@ -2375,7 +2373,7 @@ Init_Thread(void)
     rb_define_method(cThGroup, "add", thgroup_add, 1);
 
     {
-	yarv_thread_t *th = GET_THREAD();
+	rb_thead_t *th = GET_THREAD();
 	th->thgroup = th->vm->thgroup_default = rb_obj_alloc(cThGroup);
 	rb_define_const(cThGroup, "Default", th->thgroup);
     }
@@ -2402,7 +2400,7 @@ Init_Thread(void)
 	/* main thread setting */
 	{
 	    /* acquire global interpreter lock */
-	    yarv_thread_lock_t *lp = &GET_THREAD()->vm->global_interpreter_lock;
+	    rb_thread_lock_t *lp = &GET_THREAD()->vm->global_interpreter_lock;
 	    native_mutex_initialize(lp);
 	    native_mutex_lock(lp);
 	    native_mutex_initialize(&GET_THREAD()->interrupt_lock);
diff --git a/thread_pthread.ci b/thread_pthread.ci
index fe7086dc61..c5f2ebbac7 100644
--- a/thread_pthread.ci
+++ b/thread_pthread.ci
@@ -21,10 +21,10 @@
 #define native_cleanup_pop  pthread_cleanup_pop
 #define native_thread_yield() sched_yield()
 
-static void yarv_add_signal_thread_list(yarv_thread_t *th);
-static void yarv_remove_signal_thread_list(yarv_thread_t *th);
+static void yarv_add_signal_thread_list(rb_thead_t *th);
+static void yarv_remove_signal_thread_list(rb_thead_t *th);
 
-static yarv_thread_lock_t signal_thread_list_lock;
+static rb_thread_lock_t signal_thread_list_lock;
 
 static void
 null_func()
@@ -40,10 +40,10 @@ Init_native_thread()
 }
 
 NOINLINE(static int
-	 thread_start_func_2(yarv_thread_t *th, VALUE *stack_start));
+	 thread_start_func_2(rb_thead_t *th, VALUE *stack_start));
 void static thread_cleanup_func(void *th_ptr);
 
-static yarv_thread_t *register_cached_thread_and_wait(void);
+static rb_thead_t *register_cached_thread_and_wait(void);
 
 #define USE_THREAD_CACHE 0
 
@@ -54,7 +54,7 @@ thread_start_func_1(void *th_ptr)
   thread_start:
 #endif
     {
-	yarv_thread_t *th = th_ptr;
+	rb_thead_t *th = th_ptr;
 	VALUE stack_start;
 	/* ignore self and klass */
 
@@ -70,7 +70,7 @@ thread_start_func_1(void *th_ptr)
 #if USE_THREAD_CACHE
     if (1) {
 	/* cache thread */
-	yarv_thread_t *th;
+	rb_thead_t *th;
 	if ((th = register_cached_thread_and_wait()) != 0) {
 	    th_ptr = (void *)th;
 	    th->thread_id = pthread_self();
@@ -86,18 +86,18 @@ void rb_thread_create_control_thread(void);
 static pthread_mutex_t thread_cache_lock = PTHREAD_MUTEX_INITIALIZER;
 
 struct cached_thread_entry {
-    volatile yarv_thread_t **th_area;
+    volatile rb_thead_t **th_area;
     pthread_cond_t *cond;
     struct cached_thread_entry *next;
 };
 
 struct cached_thread_entry *cached_thread_root;
 
-static yarv_thread_t *
+static rb_thead_t *
 register_cached_thread_and_wait(void)
 {
     pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
-    volatile yarv_thread_t *th_area = 0;
+    volatile rb_thead_t *th_area = 0;
     struct cached_thread_entry *entry =
       (struct cached_thread_entry *)malloc(sizeof(struct cached_thread_entry));
 
@@ -140,11 +140,11 @@ register_cached_thread_and_wait(void)
     }
     pthread_mutex_unlock(&thread_cache_lock);
 
-    return (yarv_thread_t *)th_area;
+    return (rb_thead_t *)th_area;
 }
 
 static int
-use_cached_thread(yarv_thread_t *th)
+use_cached_thread(rb_thead_t *th)
 {
     int result = 0;
 #if USE_THREAD_CACHE
@@ -170,7 +170,7 @@ use_cached_thread(yarv_thread_t *th)
 }
 
 static int
-native_thread_create(yarv_thread_t *th)
+native_thread_create(rb_thead_t *th)
 {
     int err = 0;
 
@@ -215,7 +215,7 @@ native_thread_join(pthread_t th)
 }
 
 static void
-native_thread_apply_priority(yarv_thread_t *th)
+native_thread_apply_priority(rb_thead_t *th)
 {
     struct sched_param sp;
     int policy;
@@ -237,14 +237,14 @@ native_thread_apply_priority(yarv_thread_t *th)
 }
 
 static void
-interrupt_using_pthread_cond_signal(yarv_thread_t *th)
+interrupt_using_pthread_cond_signal(rb_thead_t *th)
 {
     thread_debug("interrupt_using_pthread_cond_signal (%p)\n", th);
     pthread_cond_signal(&th->native_thread_data.sleep_cond);
 }
 
 static void
-native_thread_send_interrupt_signal(yarv_thread_t *th)
+native_thread_send_interrupt_signal(rb_thead_t *th)
 {
     thread_debug("native_thread_send_interrupt_signal (%p)\n", th->thread_id);
     if (th) {
@@ -253,7 +253,7 @@ native_thread_send_interrupt_signal(yarv_thread_t *th)
 }
 
 static void
-native_sleep(yarv_thread_t *th, struct timeval *tv)
+native_sleep(rb_thead_t *th, struct timeval *tv)
 {
     int prev_status = th->status;
     struct timespec ts;
@@ -308,13 +308,13 @@ native_sleep(yarv_thread_t *th, struct timeval *tv)
 }
 
 static void
-native_thread_interrupt(yarv_thread_t *th)
+native_thread_interrupt(rb_thead_t *th)
 {
     yarv_add_signal_thread_list(th);
 }
 
 struct yarv_signal_thread_list {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     struct yarv_signal_thread_list *prev;
     struct yarv_signal_thread_list *next;
 };
@@ -345,7 +345,7 @@ print_signal_list(char *str)
 }
 
 static void
-yarv_add_signal_thread_list(yarv_thread_t *th)
+yarv_add_signal_thread_list(rb_thead_t *th)
 {
     if (!th->native_thread_data.signal_thread_list) {
 	FGLOCK(&signal_thread_list_lock, {
@@ -371,7 +371,7 @@ yarv_add_signal_thread_list(yarv_thread_t *th)
 }
 
 static void
-yarv_remove_signal_thread_list(yarv_thread_t *th)
+yarv_remove_signal_thread_list(rb_thead_t *th)
 {
     if (th->native_thread_data.signal_thread_list) {
 	FGLOCK(&signal_thread_list_lock, {
diff --git a/thread_pthread.h b/thread_pthread.h
index 9783edea98..29306e0e19 100644
--- a/thread_pthread.h
+++ b/thread_pthread.h
@@ -13,8 +13,8 @@
 #define THREAD_PTHREAD_H_INCLUDED
 
 #include <pthread.h>
-typedef pthread_t yarv_thread_id_t;
-typedef pthread_mutex_t yarv_thread_lock_t;
+typedef pthread_t rb_thread_id_t;
+typedef pthread_mutex_t rb_thread_lock_t;
 
 #define native_mutex_lock   pthread_mutex_lock
 #define native_mutex_unlock pthread_mutex_unlock
diff --git a/thread_win32.ci b/thread_win32.ci
index 3dd66932e1..27ea4f0117 100644
--- a/thread_win32.ci
+++ b/thread_win32.ci
@@ -23,7 +23,7 @@
 static void
 Init_native_thread()
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     DuplicateHandle(GetCurrentProcess(),
 		    GetCurrentThread(),
 		    GetCurrentProcess(),
@@ -53,7 +53,7 @@ w32_show_error_message()
 }
 
 static int
-w32_wait_event(HANDLE event, DWORD timeout, yarv_thread_t *th)
+w32_wait_event(HANDLE event, DWORD timeout, rb_thead_t *th)
 {
     HANDLE events[2];
     int count = 0;
@@ -94,7 +94,7 @@ w32_wait_event(HANDLE event, DWORD timeout, yarv_thread_t *th)
 }
 
 static void
-native_sleep(yarv_thread_t *th, struct timeval *tv)
+native_sleep(rb_thead_t *th, struct timeval *tv)
 {
     DWORD msec;
     if (tv) {
@@ -120,7 +120,7 @@ native_sleep(yarv_thread_t *th, struct timeval *tv)
 }
 
 int
-native_mutex_lock(yarv_thread_lock_t *lock)
+native_mutex_lock(rb_thread_lock_t *lock)
 {
 #if USE_WIN32_MUTEX
     DWORD result;
@@ -156,7 +156,7 @@ native_mutex_lock(yarv_thread_lock_t *lock)
 }
 
 int
-native_mutex_unlock(yarv_thread_lock_t *lock)
+native_mutex_unlock(rb_thread_lock_t *lock)
 {
 #if USE_WIN32_MUTEX
     thread_debug("release mutex: %p\n", *lock);
@@ -168,7 +168,7 @@ native_mutex_unlock(yarv_thread_lock_t *lock)
 }
 
 int
-native_mutex_trylock(yarv_thread_lock_t *lock)
+native_mutex_trylock(rb_thread_lock_t *lock)
 {
 #if USE_WIN32MUTEX
     int result;
@@ -188,7 +188,7 @@ native_mutex_trylock(yarv_thread_lock_t *lock)
 }
 
 void
-native_mutex_initialize(yarv_thread_lock_t *lock)
+native_mutex_initialize(rb_thread_lock_t *lock)
 {
 #if USE_WIN32MUTEX
     *lock = CreateMutex(NULL, FALSE, NULL);
@@ -199,13 +199,13 @@ native_mutex_initialize(yarv_thread_lock_t *lock)
 }
 
 NOINLINE(static int
-	 thread_start_func_2(yarv_thread_t *th, VALUE *stack_start));
+	 thread_start_func_2(rb_thead_t *th, VALUE *stack_start));
 void static thread_cleanup_func(void *th_ptr);
 
 static unsigned int _stdcall
 thread_start_func_1(void *th_ptr)
 {
-    yarv_thread_t *th = th_ptr;
+    rb_thead_t *th = th_ptr;
     VALUE stack_start;
     /* run */
     th->native_thread_data.interrupt_event = CreateEvent(0, TRUE, FALSE, 0);
@@ -241,7 +241,7 @@ w32_create_thread(DWORD stack_size, void *func, void *val)
 }
 
 static int
-native_thread_create(yarv_thread_t *th)
+native_thread_create(rb_thead_t *th)
 {
     size_t stack_size = 4 * 1024 - sizeof(int);	/* 4KB */
 
@@ -266,7 +266,7 @@ native_thread_join(HANDLE th)
 }
 
 static void
-native_thread_apply_priority(yarv_thread_t *th)
+native_thread_apply_priority(rb_thead_t *th)
 {
     int priority = th->priority;
     if (th->priority > 0) {
@@ -283,7 +283,7 @@ native_thread_apply_priority(yarv_thread_t *th)
 }
 
 static void
-native_thread_interrupt(yarv_thread_t *th)
+native_thread_interrupt(rb_thead_t *th)
 {
     thread_debug("native_thread_interrupt: %p\n", th);
     SetEvent(th->native_thread_data.interrupt_event);
diff --git a/thread_win32.h b/thread_win32.h
index 8be59b0c1b..c02e406795 100644
--- a/thread_win32.h
+++ b/thread_win32.h
@@ -18,13 +18,13 @@
 WINBASEAPI BOOL WINAPI
 TryEnterCriticalSection(IN OUT LPCRITICAL_SECTION lpCriticalSection);
 
-typedef HANDLE yarv_thread_id_t;
-typedef CRITICAL_SECTION yarv_thread_lock_t;
+typedef HANDLE rb_thread_id_t;
+typedef CRITICAL_SECTION rb_thread_lock_t;
 
-int native_mutex_lock(yarv_thread_lock_t *);
-int native_mutex_unlock(yarv_thread_lock_t *);
-int native_mutex_trylock(yarv_thread_lock_t *);
-void native_mutex_initialize(yarv_thread_lock_t *);
+int native_mutex_lock(rb_thread_lock_t *);
+int native_mutex_unlock(rb_thread_lock_t *);
+int native_mutex_trylock(rb_thread_lock_t *);
+void native_mutex_initialize(rb_thread_lock_t *);
 
 typedef struct native_thread_data_struct {
     HANDLE interrupt_event;
diff --git a/vm.c b/vm.c
index 45dfedb6db..abea88dd27 100644
--- a/vm.c
+++ b/vm.c
@@ -12,6 +12,7 @@
 #include "ruby.h"
 #include "node.h"
 #include "st.h"
+#include "gc.h"
 
 #include "yarvcore.h"
 #include "vm.h"
@@ -20,6 +21,8 @@
 #include "insns.inc"
 #include "eval_intern.h"
 
+VALUE rb_cEnv;
+
 #define PROCDEBUG 0
 #define VM_DEBUG  0
 
@@ -38,12 +41,12 @@ void vm_analysis_register(int reg, int isset);
 void vm_analysis_insn(int insn);
 
 static inline VALUE
- th_invoke_yield_cfunc(yarv_thread_t *th, yarv_block_t *block,
+ th_invoke_yield_cfunc(rb_thead_t *th, rb_block_t *block,
 		       VALUE self, int argc, VALUE *argv);
-VALUE th_invoke_proc(yarv_thread_t *th, yarv_proc_t *proc,
+VALUE th_invoke_proc(rb_thead_t *th, rb_proc_t *proc,
 		     VALUE self, int argc, VALUE *argv);
 
-VALUE th_eval_body(yarv_thread_t *th);
+VALUE th_eval_body(rb_thead_t *th);
 static NODE *lfp_get_special_cref(VALUE *lfp);
 static NODE *lfp_set_special_cref(VALUE *lfp, NODE * cref);
 
@@ -66,13 +69,13 @@ rb_vm_change_state(void)
 /*
  * prepare stack frame
  */
-static inline yarv_control_frame_t *
-push_frame(yarv_thread_t *th, yarv_iseq_t *iseq, VALUE magic,
+static inline rb_control_frame_t *
+push_frame(rb_thead_t *th, rb_iseq_t *iseq, VALUE magic,
 	   VALUE self, VALUE specval, VALUE *pc,
 	   VALUE *sp, VALUE *lfp, int local_size)
 {
     VALUE *dfp;
-    yarv_control_frame_t *cfp;
+    rb_control_frame_t *cfp;
     int i;
 
     /* nil initialize */
@@ -112,14 +115,14 @@ push_frame(yarv_thread_t *th, yarv_iseq_t *iseq, VALUE magic,
 }
 
 static inline void
-pop_frame(yarv_thread_t *th)
+pop_frame(rb_thead_t *th)
 {
 #if COLLECT_PROFILE
-    yarv_control_frame_t *cfp = th->cfp;
+    rb_control_frame_t *cfp = th->cfp;
     
-    if (YARV_NORMAL_ISEQ_P(cfp->iseq)) {
+    if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
 	VALUE current_time = clock();
-	yarv_control_frame_t *cfp = th->cfp;
+	rb_control_frame_t *cfp = th->cfp;
 	cfp->prof_time_self = current_time - cfp->prof_time_self;
 	(cfp+1)->prof_time_chld += cfp->prof_time_self;
 	
@@ -131,13 +134,13 @@ pop_frame(yarv_thread_t *th)
 	
     }
 #endif
-    th->cfp = YARV_PREVIOUS_CONTROL_FRAME(th->cfp);
+    th->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
 }
 
 EXTERN VALUE ruby_top_self;
 
 VALUE
-th_set_finish_env(yarv_thread_t *th)
+th_set_finish_env(rb_thead_t *th)
 {
     push_frame(th, 0, FRAME_MAGIC_FINISH,
 	       Qnil, th->cfp->lfp[0], 0,
@@ -147,9 +150,9 @@ th_set_finish_env(yarv_thread_t *th)
 }
 
 void
-th_set_top_stack(yarv_thread_t *th, VALUE iseqval)
+th_set_top_stack(rb_thead_t *th, VALUE iseqval)
 {
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
     GetISeqPtr(iseqval, iseq);
 
     if (iseq->type != ISEQ_TYPE_TOP) {
@@ -165,10 +168,10 @@ th_set_top_stack(yarv_thread_t *th, VALUE iseqval)
 }
 
 VALUE
-th_set_eval_stack(yarv_thread_t *th, VALUE iseqval)
+th_set_eval_stack(rb_thead_t *th, VALUE iseqval)
 {
-    yarv_iseq_t *iseq;
-    yarv_block_t *block = th->base_block;
+    rb_iseq_t *iseq;
+    rb_block_t *block = th->base_block;
     GetISeqPtr(iseqval, iseq);
 
     /* for return */
@@ -179,14 +182,69 @@ th_set_eval_stack(yarv_thread_t *th, VALUE iseqval)
     return 0;
 }
 
-static int check_env(yarv_env_t *env);
+
+/* Env */
+
+static void
+env_free(void *ptr)
+{
+    rb_env_t *env;
+    FREE_REPORT_ENTER("env");
+    if (ptr) {
+	env = ptr;
+	FREE_UNLESS_NULL(env->env);
+	ruby_xfree(ptr);
+    }
+    FREE_REPORT_LEAVE("env");
+}
+
+static void
+env_mark(void *ptr)
+{
+    rb_env_t *env;
+    MARK_REPORT_ENTER("env");
+    if (ptr) {
+	env = ptr;
+	if (env->env) {
+	    /* TODO: should mark more restricted range */
+	    GC_INFO("env->env\n");
+	    rb_gc_mark_locations(env->env, env->env + env->env_size);
+	}
+	GC_INFO("env->prev_envval\n");
+	MARK_UNLESS_NULL(env->prev_envval);
+
+	if (env->block.iseq) {
+	    if (BUILTIN_TYPE(env->block.iseq) == T_NODE) {
+		MARK_UNLESS_NULL((VALUE)env->block.iseq);
+	    }
+	    else {
+		MARK_UNLESS_NULL(env->block.iseq->self);
+	    }
+	}
+    }
+    MARK_REPORT_LEAVE("env");
+}
 
 static VALUE
-th_make_env_each(yarv_thread_t *th, yarv_control_frame_t *cfp,
+env_alloc(void)
+{
+    VALUE obj;
+    rb_env_t *env;
+    obj = Data_Make_Struct(rb_cEnv, rb_env_t, env_mark, env_free, env);
+    env->env = 0;
+    env->prev_envval = 0;
+    env->block.iseq = 0;
+    return obj;
+}
+
+static int check_env(rb_env_t *env);
+
+static VALUE
+th_make_env_each(rb_thead_t *th, rb_control_frame_t *cfp,
 		 VALUE *envptr, VALUE *endptr)
 {
     VALUE envval, penvval = 0;
-    yarv_env_t *env;
+    rb_env_t *env;
     VALUE *nenvptr;
     int i, local_size;
 
@@ -196,7 +254,7 @@ th_make_env_each(yarv_thread_t *th, yarv_control_frame_t *cfp,
 
     if (envptr != endptr) {
 	VALUE *penvptr = GC_GUARDED_PTR_REF(*envptr);
-	yarv_control_frame_t *pcfp = cfp;
+	rb_control_frame_t *pcfp = cfp;
 
 	if (ENV_IN_HEAP_P(penvptr)) {
 	    penvval = ENV_VAL(penvptr);
@@ -217,10 +275,10 @@ th_make_env_each(yarv_thread_t *th, yarv_control_frame_t *cfp,
     }
 
     /* allocate env */
-    envval = yarv_env_alloc();
+    envval = env_alloc();
     GetEnvPtr(envval, env);
 
-    if (!YARV_NORMAL_ISEQ_P(cfp->iseq)) {
+    if (!RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
 	local_size = 2;
     }
     else {
@@ -235,7 +293,7 @@ th_make_env_each(yarv_thread_t *th, yarv_control_frame_t *cfp,
     for (i = 0; i <= local_size; i++) {
 	env->env[i] = envptr[-local_size + i];
 	// dp(env->env[i]);
-	if (YARV_NORMAL_ISEQ_P(cfp->iseq)) {
+	if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
 	    /* clear value stack for GC */
 	    // envptr[-local_size + i] = 0;
 	}
@@ -266,7 +324,7 @@ th_make_env_each(yarv_thread_t *th, yarv_control_frame_t *cfp,
 	rb_bug("illegal svar");
     }
     
-    if (!YARV_NORMAL_ISEQ_P(cfp->iseq)) {
+    if (!RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
 	/* TODO */
 	env->block.iseq = 0;
     }
@@ -276,7 +334,7 @@ th_make_env_each(yarv_thread_t *th, yarv_control_frame_t *cfp,
 static VALUE check_env_value(VALUE envval);
 
 static int
-check_env(yarv_env_t *env)
+check_env(rb_env_t *env)
 {
     printf("---\n");
     printf("envptr: %p\n", &env->block.dfp[0]);
@@ -299,7 +357,7 @@ check_env(yarv_env_t *env)
 static VALUE
 check_env_value(VALUE envval)
 {
-    yarv_env_t *env;
+    rb_env_t *env;
     GetEnvPtr(envval, env);
 
     if (check_env(env)) {
@@ -310,7 +368,7 @@ check_env_value(VALUE envval)
 }
 
 static int
-collect_local_variables_in_env(yarv_env_t *env, VALUE ary)
+collect_local_variables_in_env(rb_env_t *env, VALUE ary)
 {
     int i;
     if (env->block.lfp == env->block.dfp) {
@@ -330,10 +388,10 @@ collect_local_variables_in_env(yarv_env_t *env, VALUE ary)
 }
 
 int
-th_collect_local_variables_in_heap(yarv_thread_t *th, VALUE *dfp, VALUE ary)
+th_collect_local_variables_in_heap(rb_thead_t *th, VALUE *dfp, VALUE ary)
 {
     if (ENV_IN_HEAP_P(dfp)) {
-	yarv_env_t *env;
+	rb_env_t *env;
 	GetEnvPtr(ENV_VAL(dfp), env);
 	collect_local_variables_in_env(env, ary);
 	return 1;
@@ -345,7 +403,7 @@ th_collect_local_variables_in_heap(yarv_thread_t *th, VALUE *dfp, VALUE ary)
 
 
 VALUE
-th_make_env_object(yarv_thread_t *th, yarv_control_frame_t *cfp)
+th_make_env_object(rb_thead_t *th, rb_control_frame_t *cfp)
 {
     VALUE envval;
     // SDR2(cfp);
@@ -357,18 +415,18 @@ th_make_env_object(yarv_thread_t *th, yarv_control_frame_t *cfp)
 }
 
 static VALUE
-th_make_proc_from_block(yarv_thread_t *th, yarv_control_frame_t *cfp,
-			yarv_block_t *block)
+th_make_proc_from_block(rb_thead_t *th, rb_control_frame_t *cfp,
+			rb_block_t *block)
 {
     VALUE procval;
-    yarv_control_frame_t *bcfp;
+    rb_control_frame_t *bcfp;
     VALUE *bdfp;		/* to gc mark */
 
     if (block->proc) {
 	return block->proc;
     }
 
-    bcfp = GET_CFP_FROM_BLOCK_PTR(block);
+    bcfp = RUBY_VM_GET_CFP_FROM_BLOCK_PTR(block);
     bdfp = bcfp->dfp;
     procval = th_make_proc(th, bcfp, block);
     return procval;
@@ -377,19 +435,19 @@ th_make_proc_from_block(yarv_thread_t *th, yarv_control_frame_t *cfp,
 struct RObject *rb;
 
 VALUE
-th_make_proc(yarv_thread_t *th, yarv_control_frame_t *cfp,
-	     yarv_block_t *block)
+th_make_proc(rb_thead_t *th, rb_control_frame_t *cfp,
+	     rb_block_t *block)
 {
     VALUE procval, envval, blockprocval = 0;
-    yarv_proc_t *proc;
+    rb_proc_t *proc;
 
     if (GC_GUARDED_PTR_REF(cfp->lfp[0])) {
-	if (!YARV_CLASS_SPECIAL_P(cfp->lfp[0])) {
-	    yarv_proc_t *p;
+	if (!RUBY_VM_CLASS_SPECIAL_P(cfp->lfp[0])) {
+	    rb_proc_t *p;
 
 	    blockprocval =
 	      th_make_proc_from_block(th, cfp,
-				      (yarv_block_t *)GC_GUARDED_PTR_REF(*cfp->
+				      (rb_block_t *)GC_GUARDED_PTR_REF(*cfp->
 									 lfp));
 	    GetProcPtr(blockprocval, p);
 	    *cfp->lfp = GC_GUARDED_PTR(&p->block);
@@ -400,7 +458,7 @@ th_make_proc(yarv_thread_t *th, yarv_control_frame_t *cfp,
     if (PROCDEBUG) {
 	check_env_value(envval);
     }
-    procval = yarv_proc_alloc();
+    procval = rb_proc_alloc();
     GetProcPtr(procval, proc);
     proc->blockprocval = blockprocval;
     proc->block.self = block->self;
@@ -424,11 +482,11 @@ th_make_proc(yarv_thread_t *th, yarv_control_frame_t *cfp,
 }
 
 static inline VALUE
-th_invoke_bmethod(yarv_thread_t *th, ID id, VALUE procval, VALUE recv,
+th_invoke_bmethod(rb_thead_t *th, ID id, VALUE procval, VALUE recv,
 		  VALUE klass, int argc, VALUE *argv)
 {
-    yarv_control_frame_t *cfp = th->cfp;
-    yarv_proc_t *proc;
+    rb_control_frame_t *cfp = th->cfp;
+    rb_proc_t *proc;
     VALUE val;
     VALUE values[2] = {
 	id, RCLASS(klass)->super,
@@ -442,12 +500,12 @@ th_invoke_bmethod(yarv_thread_t *th, ID id, VALUE procval, VALUE recv,
 }
 
 VALUE
-th_call0(yarv_thread_t *th, VALUE klass, VALUE recv,
+th_call0(rb_thead_t *th, VALUE klass, VALUE recv,
 	 VALUE id, ID oid, int argc, const VALUE *argv,
 	 NODE * body, int nosuper)
 {
     VALUE val;
-    yarv_block_t *blockptr = 0;
+    rb_block_t *blockptr = 0;
 
     if (0) printf("id: %s, nd: %s, argc: %d, passed: %p\n",
 		  rb_id2name(id), node_name(nd_type(body)),
@@ -459,8 +517,8 @@ th_call0(yarv_thread_t *th, VALUE klass, VALUE recv,
 	th->passed_block = 0;
     }
     switch (nd_type(body)) {
-      case YARV_METHOD_NODE:{
-	  yarv_control_frame_t *reg_cfp;
+      case RUBY_VM_METHOD_NODE:{
+	  rb_control_frame_t *reg_cfp;
 	  int i;
 	  const int flag = 0;
 
@@ -475,8 +533,8 @@ th_call0(yarv_thread_t *th, VALUE klass, VALUE recv,
 	  break;
       }
       case NODE_CFUNC: {
-	  yarv_control_frame_t *reg_cfp = th->cfp;
-	  yarv_control_frame_t *cfp =
+	  rb_control_frame_t *reg_cfp = th->cfp;
+	  rb_control_frame_t *cfp =
 	    push_frame(th, 0, FRAME_MAGIC_CFUNC,
 		       recv, (VALUE)blockptr, 0, reg_cfp->sp, 0, 1);
 
@@ -520,7 +578,7 @@ th_call0(yarv_thread_t *th, VALUE klass, VALUE recv,
       default:
 	rb_bug("unsupported: th_call0");
     }
-    YARV_CHECK_INTS();
+    RUBY_VM_CHECK_INTS();
     return val;
 }
 
@@ -544,14 +602,14 @@ search_super_klass(VALUE klass, VALUE recv)
 }
 
 VALUE
-th_call_super(yarv_thread_t *th, int argc, const VALUE *argv)
+th_call_super(rb_thead_t *th, int argc, const VALUE *argv)
 {
     VALUE recv = th->cfp->self;
     VALUE klass;
     ID id;
     NODE *body;
     int nosuper = 0;
-    yarv_control_frame_t *cfp = th->cfp;
+    rb_control_frame_t *cfp = th->cfp;
 
     if (!th->cfp->iseq) {
 	klass = cfp->method_klass;
@@ -583,7 +641,7 @@ th_call_super(yarv_thread_t *th, int argc, const VALUE *argv)
 }
 
 static inline VALUE
-th_invoke_yield_cfunc(yarv_thread_t *th, yarv_block_t *block,
+th_invoke_yield_cfunc(rb_thead_t *th, rb_block_t *block,
 		      VALUE self, int argc, VALUE *argv)
 {
     NODE *ifunc = (NODE *) block->iseq;
@@ -611,7 +669,7 @@ th_invoke_yield_cfunc(yarv_thread_t *th, yarv_block_t *block,
 }
 
 static inline int
-th_yield_setup_args(yarv_iseq_t *iseq, int argc, VALUE *argv)
+th_yield_setup_args(rb_iseq_t *iseq, int argc, VALUE *argv)
 {
     int i;
     
@@ -689,11 +747,11 @@ th_yield_setup_args(yarv_iseq_t *iseq, int argc, VALUE *argv)
 }
 
 static VALUE
-invoke_block(yarv_thread_t *th, yarv_block_t *block, VALUE self, int argc, VALUE *argv, int magic)
+invoke_block(rb_thead_t *th, rb_block_t *block, VALUE self, int argc, VALUE *argv, int magic)
 {
     VALUE val;
     if (BUILTIN_TYPE(block->iseq) != T_NODE) {
-	yarv_iseq_t *iseq = block->iseq;
+	rb_iseq_t *iseq = block->iseq;
 	int i;
 	th_set_finish_env(th);
 
@@ -722,9 +780,9 @@ invoke_block(yarv_thread_t *th, yarv_block_t *block, VALUE self, int argc, VALUE
 }
 
 VALUE
-th_invoke_yield(yarv_thread_t *th, int argc, VALUE *argv)
+th_invoke_yield(rb_thead_t *th, int argc, VALUE *argv)
 {
-    yarv_block_t *block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
+    rb_block_t *block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
 
     if (block == 0) {
 	th_localjump_error("no block given", Qnil, 0);
@@ -734,14 +792,14 @@ th_invoke_yield(yarv_thread_t *th, int argc, VALUE *argv)
 }
 
 VALUE
-th_invoke_proc(yarv_thread_t *th, yarv_proc_t *proc,
+th_invoke_proc(rb_thead_t *th, rb_proc_t *proc,
 	       VALUE self, int argc, VALUE *argv)
 {
     VALUE val = Qundef;
     int state;
     volatile int stored_safe = th->safe_level;
     volatile NODE *stored_special_cref_stack;
-    yarv_control_frame_t * volatile cfp = th->cfp;
+    rb_control_frame_t * volatile cfp = th->cfp;
 
     TH_PUSH_TAG(th);
     if ((state = EXEC_TAG()) == 0) {
@@ -791,7 +849,7 @@ static VALUE *
 lfp_svar(VALUE *lfp, int cnt)
 {
     struct RValues *val;
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
 
     if (th->local_lfp != lfp) {
 	val = (struct RValues *)lfp[-1];
@@ -829,7 +887,7 @@ lfp_svar(VALUE *lfp, int cnt)
 
 
 VALUE *
-th_cfp_svar(yarv_control_frame_t *cfp, int cnt)
+th_cfp_svar(rb_control_frame_t *cfp, int cnt)
 {
     while (cfp->pc == 0) {
 	cfp++;
@@ -838,27 +896,27 @@ th_cfp_svar(yarv_control_frame_t *cfp, int cnt)
 }
 
 VALUE *
-th_svar(yarv_thread_t *th, int cnt)
+th_svar(rb_thead_t *th, int cnt)
 {
-    yarv_control_frame_t *cfp = th->cfp;
+    rb_control_frame_t *cfp = th->cfp;
     return th_cfp_svar(cfp, cnt);
 }
 
 VALUE *
 thread_svar(VALUE self, int cnt)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(self, th);
     return th_svar(th, cnt);
 }
 
 int
-th_get_sourceline(yarv_control_frame_t *cfp)
+th_get_sourceline(rb_control_frame_t *cfp)
 {
     int line_no = 0;
-    yarv_iseq_t *iseq = cfp->iseq;
+    rb_iseq_t *iseq = cfp->iseq;
 
-    if (YARV_NORMAL_ISEQ_P(iseq)) {
+    if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
 	int i;
 	int pos = cfp->pc - cfp->iseq->iseq_encoded;
 
@@ -875,9 +933,9 @@ th_get_sourceline(yarv_control_frame_t *cfp)
 }
 
 static VALUE
-th_backtrace_each(yarv_thread_t *th,
-		  yarv_control_frame_t *limit_cfp,
-		  yarv_control_frame_t *cfp,
+th_backtrace_each(rb_thead_t *th,
+		  rb_control_frame_t *limit_cfp,
+		  rb_control_frame_t *cfp,
 		  char *file, int line_no, VALUE ary)
 {
     VALUE str;
@@ -886,7 +944,7 @@ th_backtrace_each(yarv_thread_t *th,
 	str = 0;
 	if (cfp->iseq != 0) {
 	    if (cfp->pc != 0) {
-		yarv_iseq_t *iseq = cfp->iseq;
+		rb_iseq_t *iseq = cfp->iseq;
 
 		line_no = th_get_sourceline(cfp);
 		file = RSTRING_PTR(iseq->file_name);
@@ -902,17 +960,17 @@ th_backtrace_each(yarv_thread_t *th,
 			     rb_id2name(cfp->callee_id));
 	    rb_ary_push(ary, str);
 	}
-	cfp = YARV_NEXT_CONTROL_FRAME(cfp);
+	cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp);
     }
     return rb_ary_reverse(ary);
 }
 
 VALUE
-th_backtrace(yarv_thread_t *th, int lev)
+th_backtrace(rb_thead_t *th, int lev)
 {
     VALUE ary;
-    yarv_control_frame_t *cfp = th->cfp;
-    yarv_control_frame_t *top_of_cfp = (void *)(th->stack + th->stack_size);
+    rb_control_frame_t *cfp = th->cfp;
+    rb_control_frame_t *top_of_cfp = (void *)(th->stack + th->stack_size);
     top_of_cfp -= 2;
 
     if (lev < 0) {
@@ -929,7 +987,7 @@ th_backtrace(yarv_thread_t *th, int lev)
 	ary = rb_ary_new();
     }
 
-    ary = th_backtrace_each(th, YARV_NEXT_CONTROL_FRAME(cfp),
+    ary = th_backtrace_each(th, RUBY_VM_NEXT_CONTROL_FRAME(cfp),
 			    top_of_cfp, "", 0, ary);
     return ary;
 }
@@ -937,7 +995,7 @@ th_backtrace(yarv_thread_t *th, int lev)
 VALUE
 thread_backtrace(VALUE self, int level)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(self, th);
     return th_backtrace(th, level);
 }
@@ -962,8 +1020,8 @@ lfp_get_special_cref(VALUE *lfp)
 static void
 check_svar(void)
 {
-    yarv_thread_t *th = GET_THREAD();
-    yarv_control_frame_t *cfp = th->cfp;
+    rb_thead_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th->cfp;
     while ((void *)(cfp + 1) < (void *)(th->stack + th->stack_size)) {
 	/* printf("cfp: %p\n", cfp->magic); */
 	if (cfp->lfp && cfp->lfp[-1] != Qnil &&
@@ -998,7 +1056,7 @@ lfp_set_special_cref(VALUE *lfp, NODE * cref)
 }
 
 NODE *
-th_set_special_cref(yarv_thread_t *th, VALUE *lfp, NODE * cref_stack)
+th_set_special_cref(rb_thead_t *th, VALUE *lfp, NODE * cref_stack)
 {
     return lfp_set_special_cref(lfp, cref_stack);
 }
@@ -1014,7 +1072,7 @@ debug_cref(NODE *cref)
 }
 
 static NODE *
-get_cref(yarv_iseq_t *iseq, VALUE *lfp)
+get_cref(rb_iseq_t *iseq, VALUE *lfp)
 {
     NODE *cref;
     if ((cref = lfp_get_special_cref(lfp)) != 0) {
@@ -1030,16 +1088,16 @@ get_cref(yarv_iseq_t *iseq, VALUE *lfp)
 }
 
 NODE *
-th_get_cref(yarv_thread_t *th, yarv_iseq_t *iseq, yarv_control_frame_t *cfp)
+th_get_cref(rb_thead_t *th, rb_iseq_t *iseq, rb_control_frame_t *cfp)
 {
     return get_cref(iseq, cfp->lfp);
 }
 
 NODE *
-th_cref_push(yarv_thread_t *th, VALUE klass, int noex)
+th_cref_push(rb_thead_t *th, VALUE klass, int noex)
 {
     NODE *cref = NEW_BLOCK(klass);
-    yarv_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
+    rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
 
     cref->nd_file = 0;
     cref->nd_next = get_cref(cfp->iseq, cfp->lfp);
@@ -1048,9 +1106,9 @@ th_cref_push(yarv_thread_t *th, VALUE klass, int noex)
 }
 
 VALUE
-th_get_cbase(yarv_thread_t *th)
+th_get_cbase(rb_thead_t *th)
 {
-    yarv_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
+    rb_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
     NODE *cref = get_cref(cfp->iseq, cfp->lfp);
     VALUE klass = Qundef;
     
@@ -1064,7 +1122,7 @@ th_get_cbase(yarv_thread_t *th)
 }
 
 EVALBODY_HELPER_FUNCTION VALUE
-eval_get_ev_const(yarv_thread_t *th, yarv_iseq_t *iseq,
+eval_get_ev_const(rb_thead_t *th, rb_iseq_t *iseq,
 		  VALUE klass, ID id, int is_defined)
 {
     VALUE val;
@@ -1135,7 +1193,7 @@ eval_get_ev_const(yarv_thread_t *th, yarv_iseq_t *iseq,
 }
 
 EVALBODY_HELPER_FUNCTION VALUE
-eval_get_cvar_base(yarv_thread_t *th, yarv_iseq_t *iseq)
+eval_get_cvar_base(rb_thead_t *th, rb_iseq_t *iseq)
 {
     NODE *cref = get_cref(iseq, th->cfp->lfp);
     VALUE klass = Qnil;
@@ -1153,8 +1211,8 @@ eval_get_cvar_base(yarv_thread_t *th, yarv_iseq_t *iseq)
 }
 
 EVALBODY_HELPER_FUNCTION void
-eval_define_method(yarv_thread_t *th, VALUE obj,
-		   ID id, yarv_iseq_t *miseq, num_t is_singleton, NODE *cref)
+eval_define_method(rb_thead_t *th, VALUE obj,
+		   ID id, rb_iseq_t *miseq, num_t is_singleton, NODE *cref)
 {
     NODE *newbody;
     int noex = cref->nd_visi;
@@ -1179,7 +1237,7 @@ eval_define_method(yarv_thread_t *th, VALUE obj,
     COPY_CREF(miseq->cref_stack, cref);
     miseq->klass = klass;
     miseq->defined_method_id = id;
-    newbody = NEW_NODE(YARV_METHOD_NODE, 0, miseq->self, 0);
+    newbody = NEW_NODE(RUBY_VM_METHOD_NODE, 0, miseq->self, 0);
     rb_add_method(klass, id, newbody, noex);
 
     if (!is_singleton && noex == NOEX_MODFUNC) {
@@ -1189,10 +1247,10 @@ eval_define_method(yarv_thread_t *th, VALUE obj,
 }
 
 EVALBODY_HELPER_FUNCTION VALUE
-eval_method_missing(yarv_thread_t *th, ID id, VALUE recv, int num,
-		    yarv_block_t *blockptr, int opt)
+eval_method_missing(rb_thead_t *th, ID id, VALUE recv, int num,
+		    rb_block_t *blockptr, int opt)
 {
-    yarv_control_frame_t *reg_cfp = th->cfp;
+    rb_control_frame_t *reg_cfp = th->cfp;
     VALUE *argv = STACK_ADDR_FROM_TOP(num + 1);
     VALUE val;
     argv[0] = ID2SYM(id);
@@ -1318,9 +1376,9 @@ th_jump_tag_but_local_jump(int state, VALUE val)
 }
 
 void
-th_iter_break(yarv_thread_t *th)
+th_iter_break(rb_thead_t *th)
 {
-    yarv_control_frame_t *cfp = th->cfp;
+    rb_control_frame_t *cfp = th->cfp;
     VALUE *dfp = GC_GUARDED_PTR_REF(*cfp->dfp);
 
     th->state = TAG_BREAK;
@@ -1404,12 +1462,12 @@ yarv_init_redefined_flag()
     VALUE *pc;                  // cfp[0]
     VALUE *sp;                  // cfp[1]
     VALUE *bp;                  // cfp[2]
-    yarv_iseq_t *iseq;          // cfp[3]
+    rb_iseq_t *iseq;          // cfp[3]
     VALUE magic;                // cfp[4]
     VALUE self;                 // cfp[5]
     VALUE *lfp;                 // cfp[6]
     VALUE *dfp;                 // cfp[7]
-    yarv_iseq_t * block_iseq;   // cfp[8]
+    rb_iseq_t * block_iseq;   // cfp[8]
     VALUE proc;                 // cfp[9] always 0
   };
 
@@ -1417,7 +1475,7 @@ yarv_init_redefined_flag()
     VALUE self;
     VALUE *lfp;
     VALUE *dfp;
-    yarv_iseq_t *block_iseq;
+    rb_iseq_t *block_iseq;
   };
 
   struct PROC {
@@ -1469,24 +1527,24 @@ yarv_init_redefined_flag()
     VALUE *pc;                       // 0
     VALUE *sp;                       // stack pointer
     VALUE *bp;                       // base pointer (used in exception)
-    yarv_iseq_t *iseq;               // cmi
+    rb_iseq_t *iseq;               // cmi
     VALUE magic;                     // C_METHOD_FRAME
     VALUE self;                      // ?
     VALUE *lfp;                      // lfp
     VALUE *dfp;                      // == lfp
-    yarv_iseq_t * block_iseq;        //
+    rb_iseq_t * block_iseq;        //
     VALUE proc;                      // always 0
   };
 
   struct C_BLOCK_CONTROL_FRAME {
     VALUE *pc;                       // point only "finish" insn
     VALUE *sp;                       // sp
-    yarv_iseq_t *iseq;               // ?
+    rb_iseq_t *iseq;               // ?
     VALUE magic;                     // C_METHOD_FRAME
     VALUE self;                      // needed?
     VALUE *lfp;                      // lfp
     VALUE *dfp;                      // lfp
-    yarv_iseq_t * block_iseq; // 0
+    rb_iseq_t * block_iseq; // 0
   };
 
   struct C_METHDO_FRAME{
@@ -1497,7 +1555,7 @@ yarv_init_redefined_flag()
 
 
 VALUE
-th_eval_body(yarv_thread_t *th)
+th_eval_body(rb_thead_t *th)
 {
     int state;
     VALUE result, err;
@@ -1518,7 +1576,7 @@ th_eval_body(yarv_thread_t *th)
 	struct catch_table_entry *entry;
 	unsigned long epc, cont_pc, cont_sp;
 	VALUE catch_iseqval;
-	yarv_control_frame_t *cfp;
+	rb_control_frame_t *cfp;
 	VALUE *escape_dfp = NULL;
 	VALUE type;
 
@@ -1666,7 +1724,7 @@ th_eval_body(yarv_thread_t *th)
 
 	if (catch_iseqval != 0) {
 	    /* found catch table */
-	    yarv_iseq_t *catch_iseq;
+	    rb_iseq_t *catch_iseq;
 
 	    /* enter catch scope */
 	    GetISeqPtr(catch_iseqval, catch_iseq);
diff --git a/vm.h b/vm.h
index 5c8a3097f1..5d8cbcce07 100644
--- a/vm.h
+++ b/vm.h
@@ -101,12 +101,12 @@ error !
 #define ELABEL(x)
 #define LABEL_PTR(x) &LABEL(x)
 
-typedef yarv_control_frame_t *
-    (*insn_func_type) (yarv_thread_t *, yarv_control_frame_t *)FASTCALL;
+typedef rb_control_frame_t *
+    (*insn_func_type) (rb_thead_t *, rb_control_frame_t *)FASTCALL;
 
 #define INSN_ENTRY(insn) \
-  yarv_control_frame_t * \
-    LABEL(insn)(yarv_thread_t *th, yarv_control_frame_t *reg_cfp) FASTCALL {
+  rb_control_frame_t * \
+    LABEL(insn)(rb_thead_t *th, rb_control_frame_t *reg_cfp) FASTCALL {
 
 #define END_INSN(insn) return reg_cfp;}
 
diff --git a/vm_dump.c b/vm_dump.c
index 692f98b92a..f31b958397 100644
--- a/vm_dump.c
+++ b/vm_dump.c
@@ -19,7 +19,7 @@
 #define MAX_POSBUF 128
 
 static void
-control_frame_dump(yarv_thread_t *th, yarv_control_frame_t *cfp)
+control_frame_dump(rb_thead_t *th, rb_control_frame_t *cfp)
 {
     int pc = -1, bp = -1, line = 0;
     unsigned int lfp = cfp->lfp - th->stack;
@@ -94,7 +94,7 @@ control_frame_dump(yarv_thread_t *th, yarv_control_frame_t *cfp)
     }
 
     if (cfp->iseq != 0) {
-	if (YARV_IFUNC_P(cfp->iseq)) {
+	if (RUBY_VM_IFUNC_P(cfp->iseq)) {
 	    iseq_name = "<ifunc>";
 	}
 	else {
@@ -115,7 +115,7 @@ control_frame_dump(yarv_thread_t *th, yarv_control_frame_t *cfp)
     }
 
     fprintf(stderr, "c:%04ld ",
-	    (yarv_control_frame_t *)(th->stack + th->stack_size) - cfp);
+	    (rb_control_frame_t *)(th->stack + th->stack_size) - cfp);
     if (pc == -1) {
 	fprintf(stderr, "p:---- ");
     }
@@ -139,7 +139,7 @@ control_frame_dump(yarv_thread_t *th, yarv_control_frame_t *cfp)
 }
 
 void
-vm_stack_dump_raw(yarv_thread_t *th, yarv_control_frame_t *cfp)
+vm_stack_dump_raw(rb_thead_t *th, rb_control_frame_t *cfp)
 {
     VALUE *sp = cfp->sp, *bp = cfp->bp;
     VALUE *lfp = cfp->lfp;
@@ -173,7 +173,7 @@ vm_stack_dump_raw(yarv_thread_t *th, yarv_control_frame_t *cfp)
 }
 
 void
-env_dump_raw(yarv_env_t *env, VALUE *lfp, VALUE *dfp)
+env_dump_raw(rb_env_t *env, VALUE *lfp, VALUE *dfp)
 {
     int i;
     fprintf(stderr, "-- env --------------------\n");
@@ -201,9 +201,9 @@ env_dump_raw(yarv_env_t *env, VALUE *lfp, VALUE *dfp)
 }
 
 void
-proc_dump_raw(yarv_proc_t *proc)
+proc_dump_raw(rb_proc_t *proc)
 {
-    yarv_env_t *env;
+    rb_env_t *env;
     char *selfstr;
     VALUE val = rb_inspect(proc->block.self);
     selfstr = StringValueCStr(val);
@@ -217,13 +217,13 @@ proc_dump_raw(yarv_proc_t *proc)
 void
 stack_dump_th(VALUE thval)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thval, th);
     vm_stack_dump_raw(th, th->cfp);
 }
 
 void
-stack_dump_each(yarv_thread_t *th, yarv_control_frame_t *cfp)
+stack_dump_each(rb_thead_t *th, rb_control_frame_t *cfp)
 {
     int i;
 
@@ -234,7 +234,7 @@ stack_dump_each(yarv_thread_t *th, yarv_control_frame_t *cfp)
 
     int argc, local_size;
     const char *name;
-    yarv_iseq_t *iseq = cfp->iseq;
+    rb_iseq_t *iseq = cfp->iseq;
 
     if (iseq == 0) {
 	if (cfp->method_id) {
@@ -247,7 +247,7 @@ stack_dump_each(yarv_thread_t *th, yarv_control_frame_t *cfp)
 	    local_size = 0;
 	}
     }
-    else if (YARV_IFUNC_P(iseq)) {
+    else if (RUBY_VM_IFUNC_P(iseq)) {
 	argc = 0;
 	local_size = 0;
 	name = "<ifunc>";
@@ -316,15 +316,15 @@ stack_dump_each(yarv_thread_t *th, yarv_control_frame_t *cfp)
 
 
 void
-debug_print_register(yarv_thread_t *th)
+debug_print_register(rb_thead_t *th)
 {
-    yarv_control_frame_t *cfp = th->cfp;
+    rb_control_frame_t *cfp = th->cfp;
     int pc = -1;
     int lfp = cfp->lfp - th->stack;
     int dfp = cfp->dfp - th->stack;
     int cfpi;
 
-    if (YARV_NORMAL_ISEQ_P(cfp->iseq)) {
+    if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
 	pc = cfp->pc - cfp->iseq->iseq_encoded;
     }
 
@@ -333,7 +333,7 @@ debug_print_register(yarv_thread_t *th)
     if (dfp < 0 || dfp > th->stack_size)
 	dfp = -1;
 
-    cfpi = ((yarv_control_frame_t *)(th->stack + th->stack_size)) - cfp;
+    cfpi = ((rb_control_frame_t *)(th->stack + th->stack_size)) - cfp;
     fprintf(stderr, "  [PC] %04d, [SP] %04ld, [LFP] %04d, [DFP] %04d, [CFP] %04d\n",
 	   pc, cfp->sp - th->stack, lfp, dfp, cfpi);
 }
@@ -341,15 +341,15 @@ debug_print_register(yarv_thread_t *th)
 void
 thread_dump_regs(VALUE thval)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     GetThreadPtr(thval, th);
     debug_print_register(th);
 }
 
 void
-debug_print_pre(yarv_thread_t *th, yarv_control_frame_t *cfp)
+debug_print_pre(rb_thead_t *th, rb_control_frame_t *cfp)
 {
-    yarv_iseq_t *iseq = cfp->iseq;
+    rb_iseq_t *iseq = cfp->iseq;
 
     if (iseq != 0 && cfp->magic != FRAME_MAGIC_FINISH) {
 	VALUE *seq = iseq->iseq;
@@ -365,7 +365,7 @@ debug_print_pre(yarv_thread_t *th, yarv_control_frame_t *cfp)
 }
 
 void
-debug_print_post(yarv_thread_t *th, yarv_control_frame_t *cfp
+debug_print_post(rb_thead_t *th, rb_control_frame_t *cfp
 #if OPT_STACK_CACHING
 		 , VALUE reg_a, VALUE reg_b
 #endif
@@ -563,8 +563,8 @@ vm_analysis_register(int reg, int isset)
 VALUE
 thread_dump_state(VALUE self)
 {
-    yarv_thread_t *th;
-    yarv_control_frame_t *cfp;
+    rb_thead_t *th;
+    rb_control_frame_t *cfp;
     GetThreadPtr(self, th);
     cfp = th->cfp;
 
@@ -578,7 +578,7 @@ thread_dump_state(VALUE self)
 void
 yarv_bug()
 {
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
     VALUE bt;
 
     if (GET_THREAD()->vm) {
diff --git a/vm_evalbody.ci b/vm_evalbody.ci
index 87cd9ee4e2..85a2a12034 100644
--- a/vm_evalbody.ci
+++ b/vm_evalbody.ci
@@ -26,11 +26,11 @@
 #endif
 /* #define DECL_SC_REG(r, reg) VALUE reg_##r */
 
-typedef yarv_iseq_t *ISEQ;
+typedef rb_iseq_t *ISEQ;
 
 #if !OPT_CALL_THREADED_CODE
 VALUE
-th_eval(yarv_thread_t *th, VALUE initial)
+th_eval(rb_thead_t *th, VALUE initial)
 {
 
 #if OPT_STACK_CACHING
@@ -46,16 +46,16 @@ th_eval(yarv_thread_t *th, VALUE initial)
 
 #if __GNUC__ && __i386__
     DECL_SC_REG(VALUE *, pc, "di");
-    DECL_SC_REG(yarv_control_frame_t *, cfp, "si");
+    DECL_SC_REG(rb_control_frame_t *, cfp, "si");
 #define USE_MACHINE_REGS 1
 
 #elif __GNUC__ && __x86_64__
     DECL_SC_REG(VALUE *, pc, "14");
-    DECL_SC_REG(yarv_control_frame_t *, cfp, "15");
+    DECL_SC_REG(rb_control_frame_t *, cfp, "15");
 #define USE_MACHINE_REGS 1
 
 #else
-    register yarv_control_frame_t *reg_cfp;
+    register rb_control_frame_t *reg_cfp;
     VALUE *reg_pc;
 #endif
 
@@ -77,7 +77,7 @@ th_eval(yarv_thread_t *th, VALUE initial)
 #endif
 
     ID tmp_id;
-    yarv_block_t *tmp_blockptr;
+    rb_block_t *tmp_blockptr;
     num_t tmp_num;
 
 #if OPT_TOKEN_THREADED_CODE || OPT_DIRECT_THREADED_CODE
@@ -123,9 +123,9 @@ get_insns_address_table()
 }
 
 VALUE
-th_eval(yarv_thread_t *th, VALUE initial)
+th_eval(rb_thead_t *th, VALUE initial)
 {
-    register yarv_control_frame_t *reg_cfp = th->cfp;
+    register rb_control_frame_t *reg_cfp = th->cfp;
     SET_PC(reg_cfp->iseq->iseq_encoded);
 
     while (*GET_PC()) {
diff --git a/vm_macro.def b/vm_macro.def
index e08fb14938..8add12e6fa 100644
--- a/vm_macro.def
+++ b/vm_macro.def
@@ -6,14 +6,14 @@
 MACRO macro_eval_setup_send_arguments(num, blockptr, flag, blockiseq)
 {
     if (flag & VM_CALL_ARGS_BLOCKARG_BIT) {
-	yarv_proc_t *po;
+	rb_proc_t *po;
 	VALUE proc;
 
 	proc = TOPN(0);
 	if (proc != Qnil) {
-	    if (!yarv_obj_is_proc(proc)) {
+	    if (!rb_obj_is_proc(proc)) {
 		proc = rb_check_convert_type(proc, T_DATA, "Proc", "to_proc");
-		if (!yarv_obj_is_proc(proc)) {
+		if (!rb_obj_is_proc(proc)) {
 		    rb_raise(rb_eTypeError,
 			     "wrong argument type %s (expected Proc)",
 			     rb_obj_classname(proc));
@@ -21,12 +21,12 @@ MACRO macro_eval_setup_send_arguments(num, blockptr, flag, blockiseq)
 	    }
 	    GetProcPtr(proc, po);
 	    blockptr = &po->block;
-	    GET_BLOCK_PTR_IN_CFP(reg_cfp)->proc = proc;
+	    RUBY_VM_GET_BLOCK_PTR_IN_CFP(reg_cfp)->proc = proc;
 	}
 	INC_SP(-1);
     }
     else if (blockiseq) {
-	blockptr = GET_BLOCK_PTR_IN_CFP(reg_cfp);
+	blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(reg_cfp);
 	blockptr->iseq = blockiseq;
 	blockptr->proc = 0;
     }
@@ -56,7 +56,7 @@ MACRO macro_eval_setup_send_arguments(num, blockptr, flag, blockiseq)
 
 MACRO macro_eval_invoke_cfunc(num, id, recv, klass, mn, blockptr)
 {
-    yarv_control_frame_t *cfp =
+    rb_control_frame_t *cfp =
       push_frame(th, 0, FRAME_MAGIC_CFUNC,
 		 recv, (VALUE) blockptr, 0, GET_SP(), 0, 1);
     cfp->callee_id = id; /* TODO */
@@ -77,7 +77,7 @@ MACRO macro_eval_invoke_cfunc(num, id, recv, klass, mn, blockptr)
 
 MACRO macro_eval_invoke_func(niseqval, recv, klass, blockptr, num)
 {
-    yarv_iseq_t *niseq;
+    rb_iseq_t *niseq;
     VALUE *sp = GET_SP();
     VALUE *rsp = sp - num - 1;
     int opt_pc = 0, clear_local_size, i;
@@ -173,7 +173,7 @@ MACRO macro_eval_invoke_func(niseqval, recv, klass, blockptr, num)
 	    if (blockptr) {
 		/* make Proc object */
 		if (blockptr->proc == 0) {
-		    yarv_proc_t *proc;
+		    rb_proc_t *proc;
 		    reg_cfp->sp = sp;
 		    arg_block_val = th_make_proc(th, GET_CFP(), blockptr);
 		    GetProcPtr(arg_block_val, proc);
@@ -274,7 +274,7 @@ MACRO macro_eval_invoke_method(recv, klass, id, num, mn, blockptr)
 
 	node = mn->nd_body;
 	switch (nd_type(node)) {
-	  case YARV_METHOD_NODE:{
+	  case RUBY_VM_METHOD_NODE:{
 	      macro_eval_invoke_func(node->nd_body, recv, klass,
 				     blockptr, num);
 	      NEXT_INSN();
diff --git a/yarv.h b/yarv.h
index 9d21bfc469..9fb8722666 100644
--- a/yarv.h
+++ b/yarv.h
@@ -34,10 +34,10 @@ RUBY_EXTERN int yarvIsWorking;
 #endif
 
 
-#if YARV_THREAD_MODEL == 2
+#if RUBY_VM_THREAD_MODEL == 2
 
-extern yarv_thread_t *yarvCurrentThread;
-extern yarv_vm_t *theYarvVM;
+extern rb_thead_t *yarvCurrentThread;
+extern rb_vm_t *theYarvVM;
 
 static inline VALUE
 yarv_get_current_running_thread_value(void)
@@ -45,7 +45,7 @@ yarv_get_current_running_thread_value(void)
     return yarvCurrentThread->self;
 }
 
-static inline yarv_thread_t *
+static inline rb_thead_t *
 yarv_get_current_running_thread(void)
 {
     return yarvCurrentThread;
@@ -55,15 +55,15 @@ yarv_get_current_running_thread(void)
 #define GET_THREAD() yarvCurrentThread
 
 static inline void
-yarv_set_current_running_thread_raw(yarv_thread_t *th)
+rb_thread_set_current_raw(rb_thead_t *th)
 {
     yarvCurrentThread = th;
 }
 
 static inline void
-yarv_set_current_running_thread(yarv_thread_t *th)
+rb_thread_set_current(rb_thead_t *th)
 {
-    yarv_set_current_running_thread_raw(th);
+    rb_thread_set_current_raw(th);
     th->vm->running_thread = th;
 }
 
@@ -73,33 +73,32 @@ yarv_set_current_running_thread(yarv_thread_t *th)
 
 void rb_vm_change_state();
 
-VALUE th_invoke_yield(yarv_thread_t *th, int argc, VALUE *argv);
+VALUE th_invoke_yield(rb_thead_t *th, int argc, VALUE *argv);
 
-VALUE th_call0(yarv_thread_t *th, VALUE klass, VALUE recv,
+VALUE th_call0(rb_thead_t *th, VALUE klass, VALUE recv,
 	       VALUE id, ID oid, int argc, const VALUE *argv,
 	       NODE * body, int nosuper);
 
 VALUE *yarv_svar(int);
 
-VALUE th_call_super(yarv_thread_t *th, int argc, const VALUE *argv);
+VALUE th_call_super(rb_thead_t *th, int argc, const VALUE *argv);
 
 VALUE yarv_backtrace(int lev);
 
 VALUE yarvcore_eval_parsed(NODE *node, VALUE file);
 
-VALUE th_invoke_proc(yarv_thread_t *th, yarv_proc_t *proc,
+VALUE th_invoke_proc(rb_thead_t *th, rb_proc_t *proc,
 		     VALUE self, int argc, VALUE *argv);
-VALUE th_make_proc(yarv_thread_t *th, yarv_control_frame_t *cfp,
-		   yarv_block_t *block);
-VALUE th_make_env_object(yarv_thread_t *th, yarv_control_frame_t *cfp);
+VALUE th_make_proc(rb_thead_t *th, rb_control_frame_t *cfp,
+		   rb_block_t *block);
+VALUE th_make_env_object(rb_thead_t *th, rb_control_frame_t *cfp);
 VALUE yarvcore_eval(VALUE self, VALUE str, VALUE file, VALUE line);
 
 int yarv_block_given_p(void);
 
 VALUE yarv_load(char *);
-VALUE yarv_obj_is_proc(VALUE);
-int th_get_sourceline(yarv_control_frame_t *);
-VALUE th_backtrace(yarv_thread_t *, int);
+int th_get_sourceline(rb_control_frame_t *);
+VALUE th_backtrace(rb_thead_t *, int);
 void yarv_bug(void);
 
 #endif
diff --git a/yarvcore.c b/yarvcore.c
index 32b136737c..c3a654c410 100644
--- a/yarvcore.c
+++ b/yarvcore.c
@@ -71,14 +71,14 @@ unsigned long yarvGlobalStateVersion = 1;
 #define va_init_list(a,b) va_start(a)
 #endif
 
-VALUE yarv_th_eval(yarv_thread_t *th, VALUE iseqval);
+VALUE rb_thread_eval(rb_thead_t *th, VALUE iseqval);
 
 /************/
 /* YARVCore */
 /************/
 
-yarv_thread_t *yarvCurrentThread = 0;
-yarv_vm_t *theYarvVM = 0;
+rb_thead_t *yarvCurrentThread = 0;
+rb_vm_t *theYarvVM = 0;
 static VALUE yarvVMArray = Qnil;
 
 RUBY_EXTERN int rb_thread_critical;
@@ -91,7 +91,7 @@ yarv_load(char *file)
     NODE *node;
     VALUE iseq;
     volatile int critical;
-    yarv_thread_t *th = GET_THREAD();
+    rb_thead_t *th = GET_THREAD();
 
     critical = rb_thread_critical;
     rb_thread_critical = Qtrue;
@@ -110,11 +110,11 @@ yarv_load(char *file)
     iseq = yarv_iseq_new(node, rb_str_new2("<top (required)>"),
 			 rb_str_new2(file), Qfalse, ISEQ_TYPE_TOP);
 
-    yarv_th_eval(GET_THREAD(), iseq);
+    rb_thread_eval(GET_THREAD(), iseq);
     return 0;
 }
 
-VALUE *th_svar(yarv_thread_t *self, int cnt);
+VALUE *th_svar(rb_thead_t *self, int cnt);
 
 VALUE *
 rb_svar(int cnt)
@@ -172,11 +172,11 @@ compile_string(VALUE str, VALUE file, VALUE line)
 static VALUE
 yarvcore_eval_iseq(VALUE iseq)
 {
-    return yarv_th_eval(GET_THREAD(), iseq);
+    return rb_thread_eval(GET_THREAD(), iseq);
 }
 
 static VALUE
-th_compile_from_node(yarv_thread_t *th, NODE * node, VALUE file)
+th_compile_from_node(rb_thead_t *th, NODE * node, VALUE file)
 {
     VALUE iseq;
     if (th->base_block) {
@@ -194,7 +194,7 @@ th_compile_from_node(yarv_thread_t *th, NODE * node, VALUE file)
 }
 
 VALUE
-th_compile(yarv_thread_t *th, VALUE str, VALUE file, VALUE line)
+th_compile(rb_thead_t *th, VALUE str, VALUE file, VALUE line)
 {
     NODE *node = (NODE *) compile_string(str, file, line);
     return th_compile_from_node(th, (NODE *) node, file);
@@ -226,7 +226,7 @@ vm_free(void *ptr)
 {
     FREE_REPORT_ENTER("vm");
     if (ptr) {
-	yarv_vm_t *vmobj = ptr;
+	rb_vm_t *vmobj = ptr;
 
 	st_free_table(vmobj->living_threads);
 	/* TODO: MultiVM Instance */
@@ -251,7 +251,7 @@ vm_mark(void *ptr)
     MARK_REPORT_ENTER("vm");
     GC_INFO("-------------------------------------------------\n");
     if (ptr) {
-	yarv_vm_t *vm = ptr;
+	rb_vm_t *vm = ptr;
 	if (vm->living_threads) {
 	    st_foreach(vm->living_threads, vm_mark_each_thread_func, 0);
 	}
@@ -266,8 +266,8 @@ static VALUE
 vm_alloc(VALUE klass)
 {
     VALUE volatile obj;
-    yarv_vm_t *vm;
-    obj = Data_Make_Struct(klass, yarv_vm_t, vm_mark, vm_free, vm);
+    rb_vm_t *vm;
+    obj = Data_Make_Struct(klass, rb_vm_t, vm_mark, vm_free, vm);
 
     vm->self = obj;
     vm->mark_object_ary = rb_ary_new();
@@ -275,9 +275,9 @@ vm_alloc(VALUE klass)
 }
 
 static void
-vm_init2(yarv_vm_t *vm)
+vm_init2(rb_vm_t *vm)
 {
-    MEMZERO(vm, yarv_vm_t, 1);
+    MEMZERO(vm, rb_vm_t, 1);
 }
 
 /**********/
@@ -287,7 +287,7 @@ vm_init2(yarv_vm_t *vm)
 static void
 thread_free(void *ptr)
 {
-    yarv_thread_t *th;
+    rb_thead_t *th;
     FREE_REPORT_ENTER("thread");
 
     if (ptr) {
@@ -321,20 +321,20 @@ thread_free(void *ptr)
     FREE_REPORT_LEAVE("thread");
 }
 
-void yarv_machine_stack_mark(yarv_thread_t *th);
+void yarv_machine_stack_mark(rb_thead_t *th);
 
 static void
 thread_mark(void *ptr)
 {
-    yarv_thread_t *th = NULL;
+    rb_thead_t *th = NULL;
     MARK_REPORT_ENTER("thread");
     if (ptr) {
 	th = ptr;
 	if (th->stack) {
 	    VALUE *p = th->stack;
 	    VALUE *sp = th->cfp->sp;
-	    yarv_control_frame_t *cfp = th->cfp;
-	    yarv_control_frame_t *limit_cfp =
+	    rb_control_frame_t *cfp = th->cfp;
+	    rb_control_frame_t *limit_cfp =
 		(void *)(th->stack + th->stack_size);
 
 	    while (p < sp) {
@@ -342,7 +342,7 @@ thread_mark(void *ptr)
 	    }
 	    while (cfp != limit_cfp) {
 		rb_gc_mark(cfp->proc);
-		cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+		cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
 	    }
 	}
 
@@ -374,21 +374,21 @@ static VALUE
 thread_alloc(VALUE klass)
 {
     VALUE volatile obj;
-    yarv_thread_t *th;
-    obj = Data_Make_Struct(klass, yarv_thread_t,
+    rb_thead_t *th;
+    obj = Data_Make_Struct(klass, rb_thead_t,
 			   thread_mark, thread_free, th);
     return obj;
 }
 
 static void
-th_init2(yarv_thread_t *th)
+th_init2(rb_thead_t *th)
 {
-    MEMZERO(th, yarv_thread_t, 1);
+    MEMZERO(th, rb_thead_t, 1);
 
     /* allocate thread stack */
-    th->stack = ALLOC_N(VALUE, YARV_THREAD_STACK_SIZE);
+    th->stack = ALLOC_N(VALUE, RUBY_VM_THREAD_STACK_SIZE);
 
-    th->stack_size = YARV_THREAD_STACK_SIZE;
+    th->stack_size = RUBY_VM_THREAD_STACK_SIZE;
     th->cfp = (void *)(th->stack + th->stack_size);
     th->cfp--;
 
@@ -412,13 +412,13 @@ th_init2(yarv_thread_t *th)
 }
 
 void
-th_klass_init(yarv_thread_t *th)
+th_klass_init(rb_thead_t *th)
 {
     /* */
 }
 
 static void
-th_init(yarv_thread_t *th)
+th_init(rb_thead_t *th)
 {
     th_init2(th);
     th_klass_init(th);
@@ -427,8 +427,8 @@ th_init(yarv_thread_t *th)
 static VALUE
 thread_init(VALUE self)
 {
-    yarv_thread_t *th;
-    yarv_vm_t *vm = GET_THREAD()->vm;
+    rb_thead_t *th;
+    rb_vm_t *vm = GET_THREAD()->vm;
     GetThreadPtr(self, th);
 
     th_init(th);
@@ -438,18 +438,18 @@ thread_init(VALUE self)
 }
 
 VALUE
-yarv_thread_alloc(VALUE klass)
+rb_thread_alloc(VALUE klass)
 {
     VALUE self = thread_alloc(klass);
     thread_init(self);
     return self;
 }
 
-VALUE th_eval_body(yarv_thread_t *th);
-void th_set_top_stack(yarv_thread_t *, VALUE iseq);
+VALUE th_eval_body(rb_thead_t *th);
+void th_set_top_stack(rb_thead_t *, VALUE iseq);
 
 VALUE
-yarv_th_eval(yarv_thread_t *th, VALUE iseqval)
+rb_thread_eval(rb_thead_t *th, VALUE iseqval)
 {
     VALUE val;
     volatile VALUE tmp;
@@ -536,7 +536,11 @@ Init_VM(void)
     /* ::VM */
     rb_cVM = rb_define_class("VM", rb_cObject);
     rb_undef_alloc_func(rb_cVM);
-    
+
+    /* Env */
+    rb_cEnv = rb_define_class_under(rb_cVM, "Env", rb_cObject);
+    rb_undef_alloc_func(rb_cEnv);
+
     /* ::Thread */
     rb_cThread = rb_define_class("Thread", rb_cObject);
     rb_undef_alloc_func(rb_cThread);
@@ -610,8 +614,8 @@ Init_VM(void)
 	VALUE vmval = vm_alloc(rb_cVM);
 	VALUE thval;
 
-	yarv_vm_t *vm;
-	yarv_thread_t *th;
+	rb_vm_t *vm;
+	rb_thead_t *th;
 	vm = theYarvVM;
 
 	xfree(RDATA(vmval)->data);
@@ -623,7 +627,7 @@ Init_VM(void)
 	rb_ary_push(yarvVMArray, vm->self);
 
 	/* create main thread */
-	thval = yarv_thread_alloc(rb_cThread);
+	thval = rb_thread_alloc(rb_cThread);
 	GetThreadPtr(thval, th);
 
 	vm->main_thread = th;
@@ -631,7 +635,7 @@ Init_VM(void)
 	GET_THREAD()->vm = vm;
 	thread_free(GET_THREAD());
 	th->vm = vm;
-	yarv_set_current_running_thread(th);
+	rb_thread_set_current(th);
 
 	th->machine_stack_start = rb_gc_stack_start;
 	vm->living_threads = st_init_numtable();
@@ -644,8 +648,8 @@ void
 Init_yarv(void)
 {
     /* VM bootstrap: phase 1 */
-    yarv_vm_t *vm = ALLOC(yarv_vm_t);
-    yarv_thread_t *th = ALLOC(yarv_thread_t);
+    rb_vm_t *vm = ALLOC(rb_vm_t);
+    rb_thead_t *th = ALLOC(rb_thead_t);
 
     vm_init2(vm);
     theYarvVM = vm;
@@ -653,6 +657,6 @@ Init_yarv(void)
     th_init2(th);
     th->vm = vm;
     th->machine_stack_start = rb_gc_stack_start;
-    yarv_set_current_running_thread_raw(th);
+    rb_thread_set_current_raw(th);
 }
 
diff --git a/yarvcore.h b/yarvcore.h
index 06b563ba2a..25ea517a83 100644
--- a/yarvcore.h
+++ b/yarvcore.h
@@ -13,7 +13,7 @@
 #ifndef _YARVCORE_H_INCLUDED_
 #define _YARVCORE_H_INCLUDED_
 
-#define YARV_THREAD_MODEL 2
+#define RUBY_VM_THREAD_MODEL 2
 
 #include <setjmp.h>
 
@@ -184,14 +184,14 @@ struct iseq_compile_data_storage {
 
 struct iseq_compile_data_ensure_node_stack;
 
-typedef struct yarv_compile_option_struct {
+typedef struct rb_compile_option_struct {
     int inline_const_cache;
     int peephole_optimization;
     int specialized_instruction;
     int operands_unification;
     int instructions_unification;
     int stack_caching;
-} yarv_compile_option_t;
+} rb_compile_option_t;
 
 struct iseq_compile_data {
     /* GC is needed */
@@ -212,20 +212,20 @@ struct iseq_compile_data {
     struct iseq_compile_data_storage *storage_head;
     struct iseq_compile_data_storage *storage_current;
     int last_line;
-    const yarv_compile_option_t *option;
+    const rb_compile_option_t *option;
 };
 
-#define GetISeqPtr(obj, ptr) Data_Get_Struct(obj, yarv_iseq_t, ptr)
+#define GetISeqPtr(obj, ptr) Data_Get_Struct(obj, rb_iseq_t, ptr)
 
-typedef struct yarv_iseq_profile_struct {
+typedef struct rb_iseq_profile_struct {
     VALUE count;
     VALUE time_self;
     VALUE time_cumu; /* cumulative */
-} yarv_iseq_profile_t;
+} rb_iseq_profile_t;
 
-struct yarv_iseq_struct;
+struct rb_iseq_struct;
 
-struct yarv_iseq_struct {
+struct rb_iseq_struct {
     /* instruction sequence type */
     VALUE type;
 
@@ -288,8 +288,8 @@ struct yarv_iseq_struct {
     int catch_table_size;
 
     /* for child iseq */
-    struct yarv_iseq_struct *parent_iseq;
-    struct yarv_iseq_struct *local_iseq;
+    struct rb_iseq_struct *parent_iseq;
+    struct rb_iseq_struct *local_iseq;
 
     /* block inlining */
     NODE *node;
@@ -299,25 +299,25 @@ struct yarv_iseq_struct {
 
     /* misc */
     ID defined_method_id;	/* for define_method */
-    yarv_iseq_profile_t profile;
-    
+    rb_iseq_profile_t profile;
+
     struct iseq_compile_data *compile_data;
 };
 
-typedef struct yarv_iseq_struct yarv_iseq_t;
+typedef struct rb_iseq_struct rb_iseq_t;
 
 #define GetVMPtr(obj, ptr) \
-  Data_Get_Struct(obj, yarv_vm_t, ptr)
+  Data_Get_Struct(obj, rb_vm_t, ptr)
 
-struct yarv_thread_struct;
+struct rb_thread_struct;
 
-typedef struct yarv_vm_struct {
+typedef struct rb_vm_struct {
     VALUE self;
 
-    yarv_thread_lock_t global_interpreter_lock;
+    rb_thread_lock_t global_interpreter_lock;
 
-    struct yarv_thread_struct *main_thread;
-    struct yarv_thread_struct *running_thread;
+    struct rb_thread_struct *main_thread;
+    struct rb_thread_struct *running_thread;
 
     st_table *living_threads;
     VALUE thgroup_default;
@@ -332,18 +332,18 @@ typedef struct yarv_vm_struct {
 
     int signal_buff[RUBY_NSIG];
     int bufferd_signal_size;
-} yarv_vm_t;
+} rb_vm_t;
 
 typedef struct {
     VALUE *pc;			/* cfp[0] */
     VALUE *sp;			/* cfp[1] */
     VALUE *bp;			/* cfp[2] */
-    yarv_iseq_t *iseq;		/* cfp[3] */
+    rb_iseq_t *iseq;		/* cfp[3] */
     VALUE magic;		/* cfp[4] */
     VALUE self;			/* cfp[5] / block[0] */
     VALUE *lfp;			/* cfp[6] / block[1] */
     VALUE *dfp;			/* cfp[7] / block[2] */
-    yarv_iseq_t *block_iseq;	/* cfp[8] / block[3] */
+    rb_iseq_t *block_iseq;	/* cfp[8] / block[3] */
     VALUE proc;			/* cfp[9] / block[4] */
     ID callee_id;               /* cfp[10] */
     ID method_id;               /* cfp[11] saved in special case */
@@ -351,20 +351,20 @@ typedef struct {
     VALUE prof_time_self;       /* cfp[13] */
     VALUE prof_time_chld;       /* cfp[14] */
     VALUE dummy;                /* cfp[15] */
-} yarv_control_frame_t;
+} rb_control_frame_t;
 
 typedef struct {
     VALUE self;			/* share with method frame if it's only block */
     VALUE *lfp;			/* share with method frame if it's only block */
     VALUE *dfp;			/* share with method frame if it's only block */
-    yarv_iseq_t *iseq;
+    rb_iseq_t *iseq;
     VALUE proc;
-} yarv_block_t;
+} rb_block_t;
 
 #define GetThreadPtr(obj, ptr) \
-  Data_Get_Struct(obj, yarv_thread_t, ptr)
+  Data_Get_Struct(obj, rb_thead_t, ptr)
 
-enum yarv_thread_status {
+enum rb_thread_status {
     THREAD_TO_KILL,
     THREAD_RUNNABLE,
     THREAD_STOPPED,
@@ -380,27 +380,27 @@ typedef struct {
 typedef jmp_buf rb_jmpbuf_t;
 #endif
 
-struct yarv_tag {
+struct rb_vm_tag {
     rb_jmpbuf_t buf;
     VALUE tag;
     VALUE retval;
-    struct yarv_tag *prev;
+    struct rb_vm_tag *prev;
 };
 
-typedef void yarv_interrupt_function_t(struct yarv_thread_struct *);
+typedef void rb_interrupt_function_t(struct rb_thread_struct *);
 
-#define YARV_VALUE_CACHE_SIZE 0x1000
+#define RUBY_VM_VALUE_CACHE_SIZE 0x1000
 #define USE_VALUE_CACHE 1
 
-typedef struct yarv_thread_struct
+typedef struct rb_thread_struct
 {
     VALUE self;
-    yarv_vm_t *vm;
+    rb_vm_t *vm;
 
     /* execution information */
     VALUE *stack;		/* must free, must mark */
     unsigned long stack_size;
-    yarv_control_frame_t *cfp;
+    rb_control_frame_t *cfp;
     int safe_level;
     int raised_flag;
     
@@ -408,20 +408,20 @@ typedef struct yarv_thread_struct
     int state;
 
     /* for rb_iterate */
-    yarv_block_t *passed_block;
+    rb_block_t *passed_block;
 
     /* passed via parse.y, eval.c (rb_scope_setup_local_tbl) */
     ID *top_local_tbl;
 
     /* eval env */
-    yarv_block_t *base_block;
+    rb_block_t *base_block;
 
     VALUE *local_lfp;
     VALUE local_svar;
 
     /* thread control */
-    yarv_thread_id_t thread_id;
-    enum yarv_thread_status status;
+    rb_thread_id_t thread_id;
+    enum rb_thread_status status;
     int priority;
 
     native_thread_data_t native_thread_data;
@@ -434,22 +434,22 @@ typedef struct yarv_thread_struct
     int exec_signal;
 
     int interrupt_flag;
-    yarv_interrupt_function_t *interrupt_function;
-    yarv_thread_lock_t interrupt_lock;
+    rb_interrupt_function_t *interrupt_function;
+    rb_thread_lock_t interrupt_lock;
 
-    struct yarv_tag *tag;
+    struct rb_vm_tag *tag;
 
     int parse_in_eval;
 
     /* storage */
     st_table *local_storage;
 #if USE_VALUE_CACHE
-    VALUE value_cache[YARV_VALUE_CACHE_SIZE + 1];
+    VALUE value_cache[RUBY_VM_VALUE_CACHE_SIZE + 1];
     VALUE *value_cache_ptr;
 #endif
 
-    struct yarv_thread_struct *join_list_next;
-    struct yarv_thread_struct *join_list_head;
+    struct rb_thread_struct *join_list_next;
+    struct rb_thread_struct *join_list_head;
 
     VALUE first_proc;
     VALUE first_args;
@@ -467,30 +467,30 @@ typedef struct yarv_thread_struct
     /* misc */
     int method_missing_reason;
     int abort_on_exception;
-} yarv_thread_t;
+} rb_thead_t;
 
 /** node -> yarv instruction sequence object */
 VALUE iseq_compile(VALUE self, NODE *node);
 
-VALUE yarv_iseq_new(NODE *node, VALUE name, VALUE file,
-		    VALUE parent, VALUE type);
+VALUE rb_iseq_new(NODE *node, VALUE name, VALUE file,
+		  VALUE parent, VALUE type);
 
-VALUE yarv_iseq_new_with_bopt(NODE *node, VALUE name, VALUE file_name,
-			      VALUE parent, VALUE type, VALUE bopt);
+VALUE rb_iseq_new_with_bopt(NODE *node, VALUE name, VALUE file_name,
+			    VALUE parent, VALUE type, VALUE bopt);
 
-VALUE yarv_iseq_new_with_opt(NODE *node, VALUE name, VALUE file,
-			     VALUE parent, VALUE type, 
-			     const yarv_compile_option_t *opt);
+VALUE rb_iseq_new_with_opt(NODE *node, VALUE name, VALUE file,
+			   VALUE parent, VALUE type, 
+			   const rb_compile_option_t *opt);
 
 /** disassemble instruction sequence */
-VALUE iseq_disasm(VALUE self);
-VALUE iseq_disasm_insn(VALUE str, VALUE *iseqval, int pos,
-		       yarv_iseq_t *iseq, VALUE child);
-char *node_name(int node);
+VALUE ruby_iseq_disasm(VALUE self);
+VALUE ruby_iseq_disasm_insn(VALUE str, VALUE *iseqval, int pos,
+			    rb_iseq_t *iseq, VALUE child);
+char *ruby_node_name(int node);
 
 
 /* each thread has this size stack : 2MB */
-#define YARV_THREAD_STACK_SIZE (128 * 1024)
+#define RUBY_VM_THREAD_STACK_SIZE (128 * 1024)
 
 
 /* from ruby 1.9 variable.c */
@@ -500,10 +500,10 @@ struct global_entry {
 };
 
 #define GetProcPtr(obj, ptr) \
-  Data_Get_Struct(obj, yarv_proc_t, ptr)
+  Data_Get_Struct(obj, rb_proc_t, ptr)
 
 typedef struct {
-    yarv_block_t block;
+    rb_block_t block;
 
     VALUE envval;		/* for GC mark */
     VALUE blockprocval;
@@ -511,26 +511,26 @@ typedef struct {
     int is_lambda;
 
     NODE *special_cref_stack;
-} yarv_proc_t;
+} rb_proc_t;
 
 #define GetEnvPtr(obj, ptr) \
-  Data_Get_Struct(obj, yarv_env_t, ptr)
+  Data_Get_Struct(obj, rb_env_t, ptr)
 
 typedef struct {
     VALUE *env;
     int env_size;
     int local_size;
     VALUE prev_envval;		/* for GC mark */
-    yarv_block_t block;
-} yarv_env_t;
+    rb_block_t block;
+} rb_env_t;
 
 #define GetBindingPtr(obj, ptr) \
-  Data_Get_Struct(obj, yarv_binding_t, ptr)
+  Data_Get_Struct(obj, rb_binding_t, ptr)
 
 typedef struct {
     VALUE env;
     NODE *cref_stack;
-} yarv_binding_t;
+} rb_binding_t;
 
 
 /* used by compile time and send insn */
@@ -558,27 +558,26 @@ typedef VALUE CDHASH;
 #define GC_GUARDED_PTR_REF(p) ((void *)(((VALUE)p) & ~0x03))
 #define GC_GUARDED_PTR_P(p)   (((VALUE)p) & 0x01)
 
-#define YARV_METHOD_NODE NODE_METHOD
+#define RUBY_VM_METHOD_NODE NODE_METHOD
 
-#define YARV_PREVIOUS_CONTROL_FRAME(cfp) (cfp+1)
-#define YARV_NEXT_CONTROL_FRAME(cfp) (cfp-1)
-#define YARV_END_CONTROL_FRAME(th) \
-  ((yarv_control_frame_t *)((th)->stack + (th)->stack_size))
-#define YARV_VALID_CONTROL_FRAME_P(cfp, ecfp) \
+#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) (cfp+1)
+#define RUBY_VM_NEXT_CONTROL_FRAME(cfp) (cfp-1)
+#define RUBY_VM_END_CONTROL_FRAME(th) \
+  ((rb_control_frame_t *)((th)->stack + (th)->stack_size))
+#define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp) \
   ((void *)(ecfp) > (void *)(cfp))
-#define YARV_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp) \
-  (!YARV_VALID_CONTROL_FRAME_P((cfp), YARV_END_CONTROL_FRAME(th)))
+#define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp) \
+  (!RUBY_VM_VALID_CONTROL_FRAME_P((cfp), RUBY_VM_END_CONTROL_FRAME(th)))
 
-#define YARV_IFUNC_P(ptr)        (BUILTIN_TYPE(ptr) == T_NODE)
-#define YARV_NORMAL_ISEQ_P(ptr) \
-  (ptr && !YARV_IFUNC_P(ptr))
+#define RUBY_VM_IFUNC_P(ptr)        (BUILTIN_TYPE(ptr) == T_NODE)
+#define RUBY_VM_NORMAL_ISEQ_P(ptr) \
+  (ptr && !RUBY_VM_IFUNC_P(ptr))
 
-#define YARV_CLASS_SPECIAL_P(ptr) (((VALUE)(ptr)) & 0x02)
-#define YARV_BLOCK_PTR_P(ptr) (!YARV_CLASS_SPECIAL_P(ptr) && GC_GUARDED_PTR_REF(ptr))
+#define RUBY_VM_CLASS_SPECIAL_P(ptr) (((VALUE)(ptr)) & 0x02)
 
-#define GET_BLOCK_PTR_IN_CFP(cfp) ((yarv_block_t *)(&(cfp)->self))
-#define GET_CFP_FROM_BLOCK_PTR(b) \
-  ((yarv_control_frame_t *)((VALUE *)(b) - 5))
+#define RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp) ((rb_block_t *)(&(cfp)->self))
+#define RUBY_VM_GET_CFP_FROM_BLOCK_PTR(b) \
+  ((rb_control_frame_t *)((VALUE *)(b) - 5))
 
 
 /* defined? */
@@ -595,12 +594,11 @@ typedef VALUE CDHASH;
 
 /* VM related object allocate functions */
 /* TODO: should be static functions */
-VALUE yarv_thread_alloc(VALUE klass);
-VALUE yarv_env_alloc(void);
-VALUE yarv_proc_alloc(void);
+VALUE rb_thread_alloc(VALUE klass);
+VALUE rb_proc_alloc(void);
 
 /* for debug */
-extern void vm_stack_dump_raw(yarv_thread_t *, yarv_control_frame_t *);
+extern void vm_stack_dump_raw(rb_thead_t *, rb_control_frame_t *);
 #define SDR()     vm_stack_dump_raw(GET_THREAD(), GET_THREAD()->cfp)
 #define SDR2(cfp) vm_stack_dump_raw(GET_THREAD(), (cfp))
 
@@ -609,28 +607,28 @@ extern void vm_stack_dump_raw(yarv_thread_t *, yarv_control_frame_t *);
 #include "yarv.h"
 
 #define GVL_UNLOCK_BEGIN() do { \
-  yarv_thread_t *_th_stored = GET_THREAD(); \
+  rb_thead_t *_th_stored = GET_THREAD(); \
   rb_gc_save_machine_context(_th_stored); \
   native_mutex_unlock(&_th_stored->vm->global_interpreter_lock)
 
 #define GVL_UNLOCK_END() \
   native_mutex_lock(&_th_stored->vm->global_interpreter_lock); \
-  yarv_set_current_running_thread(_th_stored); \
+  rb_thread_set_current(_th_stored); \
 } while(0)
 
 NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
-NOINLINE(void rb_gc_save_machine_context(yarv_thread_t *));
+NOINLINE(void rb_gc_save_machine_context(rb_thead_t *));
 
-void yarv_thread_execute_interrupts(yarv_thread_t *);
+void rb_thread_execute_interrupts(rb_thead_t *);
 
-#define YARV_CHECK_INTS_TH(th) do { \
+#define RUBY_VM_CHECK_INTS_TH(th) do { \
   if(th->interrupt_flag){ \
     /* TODO: trap something event */ \
-    yarv_thread_execute_interrupts(th); \
+    rb_thread_execute_interrupts(th); \
   } \
 } while (0)
 
-#define YARV_CHECK_INTS() \
-  YARV_CHECK_INTS_TH(GET_THREAD())
+#define RUBY_VM_CHECK_INTS() \
+  RUBY_VM_CHECK_INTS_TH(GET_THREAD())
 
 #endif /* _YARVCORE_H_INCLUDED_ */