Skip to content

fix build fails with upstream master branch of mruby(latest) #32

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

fix build fails with upstream master branch of mruby(latest) #32

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 3 additions & 3 deletions include/cfunc.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}

Expand Down
6 changes: 3 additions & 3 deletions src/cfunc.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
4 changes: 2 additions & 2 deletions src/cfunc_call.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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());
}
4 changes: 2 additions & 2 deletions src/cfunc_closure.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}
Expand Down Expand Up @@ -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());
}
6 changes: 3 additions & 3 deletions src/cfunc_platform.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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());
}
30 changes: 15 additions & 15 deletions src/cfunc_pointer.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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";
}
Expand Down Expand Up @@ -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;
}

Expand Down Expand Up @@ -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;
}
Expand Down Expand Up @@ -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);
}
16 changes: 8 additions & 8 deletions src/cfunc_rubyvm.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand All @@ -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;

Expand Down Expand Up @@ -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));
Expand Down
2 changes: 1 addition & 1 deletion src/cfunc_struct.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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));
}
64 changes: 32 additions & 32 deletions src/cfunc_type.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}
}

Expand Down Expand Up @@ -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);
}
Expand Down Expand Up @@ -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);
}

Expand All @@ -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;
Expand Down Expand Up @@ -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);
Expand All @@ -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;
}
2 changes: 1 addition & 1 deletion src/cfunc_utils.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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));
}