diff --git a/include/cfunc.h b/include/cfunc.h
index 39587bc..162f079 100644
--- a/include/cfunc.h
+++ b/include/cfunc.h
@@ -58,17 +58,17 @@ static inline struct cfunc_state *
 cfunc_state(mrb_state *mrb, struct RClass* obj)
 {
     if(obj == NULL) {
-        obj = (struct RClass*) mrb_object(mrb_vm_const_get(mrb, mrb_intern_cstr(mrb, "CFunc")));
+        obj = (struct RClass*) mrb_obj_ptr(mrb_vm_const_get(mrb, mrb_intern_cstr(mrb, "CFunc")));
     }
     mrb_value state = mrb_mod_cv_get(mrb, obj, mrb_intern_cstr(mrb, "cfunc_state"));
-    return (struct cfunc_state *)mrb_voidp(state);
+    return (struct cfunc_state *)mrb_cptr(state);
 }
 
 
 static inline void
 set_cfunc_state(mrb_state *mrb, struct RClass* klass, struct cfunc_state *state)
 {
-    mrb_value mstate = mrb_voidp_value(mrb, state);
+    mrb_value mstate = mrb_cptr_value(mrb, state);
     mrb_mod_cv_set(mrb, klass, mrb_intern_cstr(mrb, "cfunc_state"), mstate);
 }
 
diff --git a/src/cfunc.c b/src/cfunc.c
index 4b8fec9..945dbdf 100644
--- a/src/cfunc.c
+++ b/src/cfunc.c
@@ -58,9 +58,9 @@ mrb_mruby_cfunc_gem_init(mrb_state* mrb)
     init_cfunc_rubyvm(mrb, ns); mrb_gc_arena_restore(mrb, ai);
 	init_cfunc_platform(mrb, ns); mrb_gc_arena_restore(mrb, ai);
 
-    mrb_define_class_method(mrb, ns, "mrb_state", cfunc_mrb_state, ARGS_NONE());
-    mrb_define_class_method(mrb, ns, "errno", cfunc_errno, ARGS_NONE());
-    mrb_define_class_method(mrb, ns, "strerror", cfunc_strerror, ARGS_NONE());
+    mrb_define_class_method(mrb, ns, "mrb_state", cfunc_mrb_state, MRB_ARGS_NONE());
+    mrb_define_class_method(mrb, ns, "errno", cfunc_errno, MRB_ARGS_NONE());
+    mrb_define_class_method(mrb, ns, "strerror", cfunc_strerror, MRB_ARGS_NONE());
 }
 
 void
diff --git a/src/cfunc_call.c b/src/cfunc_call.c
index 458679f..e4b42a1 100644
--- a/src/cfunc_call.c
+++ b/src/cfunc_call.c
@@ -222,6 +222,6 @@ cfunc_libcall(mrb_state *mrb, mrb_value self)
 
 void init_cfunc_call(mrb_state *mrb, struct RClass* module)
 {
-    mrb_define_class_method(mrb, module, "call", cfunc_call, ARGS_ANY());
-    mrb_define_module_function(mrb, module, "libcall", cfunc_libcall, ARGS_ANY());
+    mrb_define_class_method(mrb, module, "call", cfunc_call, MRB_ARGS_ANY());
+    mrb_define_module_function(mrb, module, "libcall", cfunc_libcall, MRB_ARGS_ANY());
 }
diff --git a/src/cfunc_closure.c b/src/cfunc_closure.c
index afa336d..cdee2e1 100644
--- a/src/cfunc_closure.c
+++ b/src/cfunc_closure.c
@@ -91,7 +91,7 @@ cfunc_closure_initialize(mrb_state *mrb, mrb_value self)
     
     if (data->closure) {
         if (ffi_prep_cif(data->cif, FFI_DEFAULT_ABI, data->argc, return_ffi_type, data->arg_ffi_types) == FFI_OK) {
-            if (ffi_prep_closure_loc(data->closure, data->cif, cfunc_closure_call_binding, mrb_object(self), closure_pointer) == FFI_OK) {
+            if (ffi_prep_closure_loc(data->closure, data->cif, cfunc_closure_call_binding, mrb_obj_ptr(self), closure_pointer) == FFI_OK) {
                 set_cfunc_pointer_data((struct cfunc_type_data *)data, closure_pointer);
                 return self;
             }
@@ -187,5 +187,5 @@ init_cfunc_closure(mrb_state *mrb, struct RClass* module)
     mrb_value ffi_type = mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &cfunc_closure_ffi_type_data_type, &closure_mrb_ffi_type));
     mrb_obj_iv_set(mrb, (struct RObject*)closure_class, mrb_intern_cstr(mrb, "@ffi_type"), ffi_type);
 
-    mrb_define_method(mrb, closure_class, "initialize", cfunc_closure_initialize, ARGS_ANY());
+    mrb_define_method(mrb, closure_class, "initialize", cfunc_closure_initialize, MRB_ARGS_ANY());
 }
diff --git a/src/cfunc_platform.c b/src/cfunc_platform.c
index 0cd52a7..964e416 100644
--- a/src/cfunc_platform.c
+++ b/src/cfunc_platform.c
@@ -45,7 +45,7 @@ void init_cfunc_platform(mrb_state *mrb, struct RClass* module)
 {
     struct RClass *struct_class = mrb_define_class_under(mrb, module, "Platform", mrb->object_class);
     
-    mrb_define_class_method(mrb, struct_class, "is_posix?", cfunc_platform_is_posix, ARGS_NONE());
-    mrb_define_class_method(mrb, struct_class, "is_win32?", cfunc_platform_is_win32, ARGS_NONE());
-    mrb_define_class_method(mrb, struct_class, "is_darwin?", cfunc_platform_is_darwin, ARGS_NONE());
+    mrb_define_class_method(mrb, struct_class, "is_posix?", cfunc_platform_is_posix, MRB_ARGS_NONE());
+    mrb_define_class_method(mrb, struct_class, "is_win32?", cfunc_platform_is_win32, MRB_ARGS_NONE());
+    mrb_define_class_method(mrb, struct_class, "is_darwin?", cfunc_platform_is_darwin, MRB_ARGS_NONE());
 }
diff --git a/src/cfunc_pointer.c b/src/cfunc_pointer.c
index 12ca494..5046203 100644
--- a/src/cfunc_pointer.c
+++ b/src/cfunc_pointer.c
@@ -166,7 +166,7 @@ cfunc_pointer_inspect(mrb_state *mrb, mrb_value self)
     struct cfunc_type_data *data = DATA_PTR(self);
     
     mrb_value type = mrb_funcall(mrb, mrb_obj_value(mrb_class(mrb, self)), "type", 0);
-    const char* classname = mrb_class_name(mrb, (struct RClass*)mrb_object(type));
+    const char* classname = mrb_class_name(mrb, (struct RClass*)mrb_obj_ptr(type));
     if(!classname) {
         classname = "Unknown pointer";
     }
@@ -207,8 +207,8 @@ cfunc_pointer_to_s(mrb_state *mrb, mrb_value self)
     len = strlen(p);
     str = mrb_str_new(mrb, 0, len);
     s = mrb_str_ptr(str);
-    strcpy(s->ptr, p);
-    s->len = strlen(s->ptr);
+    strcpy(s->as.heap.ptr, p);
+    s->as.heap.len = strlen(s->as.heap.ptr);
     return str;
 }
 
@@ -252,7 +252,7 @@ cfunc_pointer_addr(mrb_state *mrb, mrb_value self)
 static mrb_value
 cfunc_string_addr(mrb_state *mrb, mrb_value self)
 {
-    mrb_value ptr = cfunc_pointer_new_with_pointer(mrb, &RSTRING_PTR(self), false);
+    mrb_value ptr = cfunc_pointer_new_with_pointer(mrb, RSTRING_PTR(self), false);
     mrb_obj_iv_set(mrb, mrb_obj_ptr(ptr), mrb_intern_cstr(mrb, "parent_pointer"), self); // keep for GC
     return ptr;
 }
@@ -323,20 +323,20 @@ init_cfunc_pointer(mrb_state *mrb, struct RClass* module)
     mrb_obj_iv_set(mrb, (struct RObject*)pointer_class, mrb_intern_cstr(mrb, "@ffi_type"), ffi_type);
     state->pointer_class = pointer_class;
 
-    mrb_define_class_method(mrb, pointer_class, "refer", cfunc_pointer_refer, ARGS_REQ(1));
-    mrb_define_class_method(mrb, pointer_class, "malloc", cfunc_pointer_class_malloc, ARGS_REQ(1));
+    mrb_define_class_method(mrb, pointer_class, "refer", cfunc_pointer_refer, MRB_ARGS_REQ(1));
+    mrb_define_class_method(mrb, pointer_class, "malloc", cfunc_pointer_class_malloc, MRB_ARGS_REQ(1));
 
-    mrb_define_method(mrb, pointer_class, "initialize", cfunc_pointer_initialize, ARGS_ANY());
-    mrb_define_method(mrb, pointer_class, "realloc", cfunc_pointer_realloc, ARGS_REQ(1));
-    mrb_define_method(mrb, pointer_class, "free", cfunc_pointer_free, ARGS_NONE());
-    mrb_define_method(mrb, pointer_class, "inspect", cfunc_pointer_inspect, ARGS_NONE());
-    mrb_define_method(mrb, pointer_class, "is_null?", cfunc_pointer_is_null, ARGS_NONE());
-    mrb_define_method(mrb, pointer_class, "autofree", cfunc_pointer_autofree, ARGS_NONE());
+    mrb_define_method(mrb, pointer_class, "initialize", cfunc_pointer_initialize, MRB_ARGS_ANY());
+    mrb_define_method(mrb, pointer_class, "realloc", cfunc_pointer_realloc, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, pointer_class, "free", cfunc_pointer_free, MRB_ARGS_NONE());
+    mrb_define_method(mrb, pointer_class, "inspect", cfunc_pointer_inspect, MRB_ARGS_NONE());
+    mrb_define_method(mrb, pointer_class, "is_null?", cfunc_pointer_is_null, MRB_ARGS_NONE());
+    mrb_define_method(mrb, pointer_class, "autofree", cfunc_pointer_autofree, MRB_ARGS_NONE());
 
-    mrb_define_method(mrb, pointer_class, "offset", cfunc_pointer_offset, ARGS_REQ(1));
-    mrb_define_method(mrb, pointer_class, "to_s", cfunc_pointer_to_s, ARGS_NONE());
+    mrb_define_method(mrb, pointer_class, "offset", cfunc_pointer_offset, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, pointer_class, "to_s", cfunc_pointer_to_s, MRB_ARGS_NONE());
     
     // add method to system classes
-    mrb_define_method(mrb, mrb->string_class, "addr", cfunc_string_addr, ARGS_NONE());
+    mrb_define_method(mrb, mrb->string_class, "addr", cfunc_string_addr, MRB_ARGS_NONE());
     mrb_obj_iv_set(mrb, (struct RObject *)mrb->string_class, mrb_intern_cstr(mrb, "@ffi_type"), ffi_type);
 }
diff --git a/src/cfunc_rubyvm.c b/src/cfunc_rubyvm.c
index eedd6a6..eb73151 100644
--- a/src/cfunc_rubyvm.c
+++ b/src/cfunc_rubyvm.c
@@ -79,7 +79,7 @@ struct task_arg* mrb_value_to_task_arg(mrb_state *mrb, mrb_value v)
 
     case MRB_TT_SYMBOL:
         {
-            size_t len;
+            mrb_int len;
             const char* name = mrb_sym2name_len(mrb, v.value.sym, &len);
             arg->value.string.len = len;
             arg->value.string.ptr = mrb_malloc(mrb, len + 1);
@@ -90,9 +90,9 @@ struct task_arg* mrb_value_to_task_arg(mrb_state *mrb, mrb_value v)
     case MRB_TT_STRING:
         {
             struct RString *str = mrb_str_ptr(v);
-            arg->value.string.len = str->len;
+            arg->value.string.len = str->as.heap.len;
             arg->value.string.ptr = mrb_malloc(mrb, arg->value.string.len+1);
-            memcpy(arg->value.string.ptr, str->ptr, arg->value.string.len+1);
+            memcpy(arg->value.string.ptr, str->as.heap.ptr, arg->value.string.len+1);
         }
         break;
 
@@ -398,15 +398,15 @@ init_cfunc_rubyvm(mrb_state *mrb, struct RClass* module)
     state->rubyvm_class = rubyvm_class;
     set_cfunc_state(mrb, rubyvm_class, state);
 
-    mrb_define_class_method(mrb, rubyvm_class, "thread", cfunc_rubyvm_class_thread, ARGS_REQ(1));
-    mrb_define_method(mrb, rubyvm_class, "dispatch", cfunc_rubyvm_dispatch, ARGS_ANY());
+    mrb_define_class_method(mrb, rubyvm_class, "thread", cfunc_rubyvm_class_thread, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, rubyvm_class, "dispatch", cfunc_rubyvm_dispatch, MRB_ARGS_ANY());
 
     struct RClass *rubyvm_task_class = mrb_define_class_under(mrb, rubyvm_class, "Task", mrb->object_class);
     state->rubyvm_task_class = rubyvm_task_class;
 
-    mrb_define_method(mrb, rubyvm_task_class, "wait", cfunc_rubyvm_task_wait, ARGS_NONE());
-    mrb_define_method(mrb, rubyvm_task_class, "result", cfunc_rubyvm_task_result, ARGS_NONE());
-    mrb_define_method(mrb, rubyvm_task_class, "status", cfunc_rubyvm_task_status, ARGS_NONE());
+    mrb_define_method(mrb, rubyvm_task_class, "wait", cfunc_rubyvm_task_wait, MRB_ARGS_NONE());
+    mrb_define_method(mrb, rubyvm_task_class, "result", cfunc_rubyvm_task_result, MRB_ARGS_NONE());
+    mrb_define_method(mrb, rubyvm_task_class, "status", cfunc_rubyvm_task_status, MRB_ARGS_NONE());
 
     mrb_define_const(mrb, rubyvm_task_class, "QUEUED", mrb_fixnum_value(queue_task_queued));
     mrb_define_const(mrb, rubyvm_task_class, "RUNNING", mrb_fixnum_value(queue_task_running));
diff --git a/src/cfunc_struct.c b/src/cfunc_struct.c
index 913d452..725571f 100644
--- a/src/cfunc_struct.c
+++ b/src/cfunc_struct.c
@@ -86,5 +86,5 @@ init_cfunc_struct(mrb_state *mrb, struct RClass* module)
     set_cfunc_state(mrb, struct_class, state);
     state->struct_class = struct_class;
     
-    mrb_define_class_method(mrb, struct_class, "define_struct", cfunc_struct_define_struct, ARGS_REQ(1));
+    mrb_define_class_method(mrb, struct_class, "define_struct", cfunc_struct_define_struct, MRB_ARGS_REQ(1));
 }
diff --git a/src/cfunc_type.c b/src/cfunc_type.c
index d4f0768..e1b70c1 100644
--- a/src/cfunc_type.c
+++ b/src/cfunc_type.c
@@ -66,7 +66,7 @@ mrb_value_to_mrb_ffi_type(mrb_state *mrb, mrb_value val)
         case MRB_TT_FALSE:
             return rclass_to_mrb_ffi_type(mrb, cfunc_state(mrb, NULL)->sint32_class);
         default:
-            return rclass_to_mrb_ffi_type(mrb, mrb_object(val)->c);
+            return rclass_to_mrb_ffi_type(mrb, mrb_obj_ptr(val)->c);
     }
 }
 
@@ -107,7 +107,7 @@ cfunc_type_initialize(mrb_state *mrb, mrb_value self)
     mrb_value val;
     int argc = mrb_get_args(mrb, "|o", &val);
     if(argc > 0) {
-        struct mrb_ffi_type *mft = rclass_to_mrb_ffi_type(mrb, mrb_object(self)->c);
+        struct mrb_ffi_type *mft = rclass_to_mrb_ffi_type(mrb, mrb_obj_ptr(self)->c);
         if(mft && mft->mrb_to_data) {
             mft->mrb_to_data(mrb, val, data);
         }
@@ -164,7 +164,7 @@ mrb_value
 cfunc_type_get_value(mrb_state *mrb, mrb_value self)
 {
     struct cfunc_type_data *data = (struct cfunc_type_data*)DATA_PTR(self);
-    struct mrb_ffi_type *mft = rclass_to_mrb_ffi_type(mrb, mrb_object(self)->c);
+    struct mrb_ffi_type *mft = rclass_to_mrb_ffi_type(mrb, mrb_obj_ptr(self)->c);
     return mft->data_to_mrb(mrb, data);
 }
 
@@ -176,7 +176,7 @@ cfunc_type_set_value(mrb_state *mrb, mrb_value self)
     mrb_get_args(mrb, "o", &val);
     
     struct cfunc_type_data *data = (struct cfunc_type_data*)DATA_PTR(self);
-    struct mrb_ffi_type *mft = rclass_to_mrb_ffi_type(mrb, mrb_object(self)->c);
+    struct mrb_ffi_type *mft = rclass_to_mrb_ffi_type(mrb, mrb_obj_ptr(self)->c);
     mft->mrb_to_data(mrb, val, data);
 
     return val;
@@ -643,17 +643,17 @@ void init_cfunc_type(mrb_state *mrb, struct RClass* module)
     set_cfunc_state(mrb, type_class, state);
 
     int ai = mrb_gc_arena_save(mrb);
-    mrb_define_class_method(mrb, type_class, "refer", cfunc_type_class_refer, ARGS_REQ(1));
-    mrb_define_class_method(mrb, type_class, "size", cfunc_type_size, ARGS_NONE());
-    mrb_define_class_method(mrb, type_class, "align", cfunc_type_align, ARGS_NONE());
-    mrb_define_class_method(mrb, type_class, "get", cfunc_type_class_get, ARGS_REQ(1));
-    mrb_define_class_method(mrb, type_class, "set", cfunc_type_class_set, ARGS_REQ(2));
-
-    mrb_define_method(mrb, type_class, "initialize", cfunc_type_initialize, ARGS_ANY());
-    mrb_define_method(mrb, type_class, "value", cfunc_type_get_value, ARGS_NONE());
-    mrb_define_method(mrb, type_class, "value=", cfunc_type_set_value, ARGS_REQ(1));
-    mrb_define_method(mrb, type_class, "addr", cfunc_type_addr, ARGS_NONE());
-    mrb_define_method(mrb, type_class, "to_ffi_value", cfunc_type_addr, ARGS_NONE());
+    mrb_define_class_method(mrb, type_class, "refer", cfunc_type_class_refer, MRB_ARGS_REQ(1));
+    mrb_define_class_method(mrb, type_class, "size", cfunc_type_size, MRB_ARGS_NONE());
+    mrb_define_class_method(mrb, type_class, "align", cfunc_type_align, MRB_ARGS_NONE());
+    mrb_define_class_method(mrb, type_class, "get", cfunc_type_class_get, MRB_ARGS_REQ(1));
+    mrb_define_class_method(mrb, type_class, "set", cfunc_type_class_set, MRB_ARGS_REQ(2));
+
+    mrb_define_method(mrb, type_class, "initialize", cfunc_type_initialize, MRB_ARGS_ANY());
+    mrb_define_method(mrb, type_class, "value", cfunc_type_get_value, MRB_ARGS_NONE());
+    mrb_define_method(mrb, type_class, "value=", cfunc_type_set_value, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, type_class, "addr", cfunc_type_addr, MRB_ARGS_NONE());
+    mrb_define_method(mrb, type_class, "to_ffi_value", cfunc_type_addr, MRB_ARGS_NONE());
     DONE;
 
     int map_size = sizeof(types) / sizeof(struct mrb_ffi_type);
@@ -679,30 +679,30 @@ void init_cfunc_type(mrb_state *mrb, struct RClass* module)
     state->double_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "Double")));
     DONE;
 
-    mrb_define_class_method(mrb, mrb->nil_class, "size", cfunc_nil_size, ARGS_NONE());
-    mrb_define_class_method(mrb, mrb->nil_class, "align", cfunc_nil_align, ARGS_NONE());
+    mrb_define_class_method(mrb, mrb->nil_class, "size", cfunc_nil_size, MRB_ARGS_NONE());
+    mrb_define_class_method(mrb, mrb->nil_class, "align", cfunc_nil_align, MRB_ARGS_NONE());
     DONE;
 
     // uint64 specific
     struct RClass *uint64_class = state->uint64_class;
-    mrb_define_class_method(mrb, uint64_class, "get", cfunc_uint64_class_get, ARGS_REQ(1));
-    mrb_define_method(mrb, uint64_class, "value", cfunc_uint64_get_value, ARGS_NONE());
-    mrb_define_method(mrb, uint64_class, "low", cfunc_uint64_get_low, ARGS_NONE());
-    mrb_define_method(mrb, uint64_class, "low=", cfunc_uint64_set_low, ARGS_REQ(1));
-    mrb_define_method(mrb, uint64_class, "high", cfunc_uint64_get_high, ARGS_NONE());
-    mrb_define_method(mrb, uint64_class, "high=", cfunc_uint64_set_high, ARGS_REQ(1));
-    mrb_define_method(mrb, uint64_class, "to_s", cfunc_uint64_to_s, ARGS_REQ(1));
-    mrb_define_method(mrb, uint64_class, "divide", cfunc_uint64_divide, ARGS_REQ(1));
+    mrb_define_class_method(mrb, uint64_class, "get", cfunc_uint64_class_get, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, uint64_class, "value", cfunc_uint64_get_value, MRB_ARGS_NONE());
+    mrb_define_method(mrb, uint64_class, "low", cfunc_uint64_get_low, MRB_ARGS_NONE());
+    mrb_define_method(mrb, uint64_class, "low=", cfunc_uint64_set_low, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, uint64_class, "high", cfunc_uint64_get_high, MRB_ARGS_NONE());
+    mrb_define_method(mrb, uint64_class, "high=", cfunc_uint64_set_high, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, uint64_class, "to_s", cfunc_uint64_to_s, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, uint64_class, "divide", cfunc_uint64_divide, MRB_ARGS_REQ(1));
     DONE;
     
     // sint64 specific
     struct RClass *sint64_class = state->sint64_class;
-    mrb_define_class_method(mrb, sint64_class, "get", cfunc_sint64_class_get, ARGS_REQ(1));
-    mrb_define_method(mrb, sint64_class, "value", cfunc_sint64_get_value, ARGS_NONE());
-    mrb_define_method(mrb, sint64_class, "low", cfunc_uint64_get_low, ARGS_NONE());
-    mrb_define_method(mrb, sint64_class, "low=", cfunc_uint64_set_low, ARGS_REQ(1));
-    mrb_define_method(mrb, sint64_class, "high", cfunc_uint64_get_high, ARGS_NONE());
-    mrb_define_method(mrb, sint64_class, "high=", cfunc_uint64_set_high, ARGS_REQ(1));
-    mrb_define_method(mrb, sint64_class, "to_s", cfunc_int64_to_s, ARGS_REQ(1));
+    mrb_define_class_method(mrb, sint64_class, "get", cfunc_sint64_class_get, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, sint64_class, "value", cfunc_sint64_get_value, MRB_ARGS_NONE());
+    mrb_define_method(mrb, sint64_class, "low", cfunc_uint64_get_low, MRB_ARGS_NONE());
+    mrb_define_method(mrb, sint64_class, "low=", cfunc_uint64_set_low, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, sint64_class, "high", cfunc_uint64_get_high, MRB_ARGS_NONE());
+    mrb_define_method(mrb, sint64_class, "high=", cfunc_uint64_set_high, MRB_ARGS_REQ(1));
+    mrb_define_method(mrb, sint64_class, "to_s", cfunc_int64_to_s, MRB_ARGS_REQ(1));
     DONE;
 }
diff --git a/src/cfunc_utils.c b/src/cfunc_utils.c
index 23ed150..3db88fb 100644
--- a/src/cfunc_utils.c
+++ b/src/cfunc_utils.c
@@ -25,5 +25,5 @@ cfunc_mrb_raise_without_jump(mrb_state *mrb, struct RClass *c, const char *fmt,
     if (n < 0) {
       n = 0;
     }
-    mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, c, buf, n));
+    mrb->exc = (struct RObject*)mrb_obj_ptr(mrb_exc_new(mrb, c, buf, n));
 }