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)); }