Removed shared mrb_state->ud, Use CFunc module's instance var instead…

… what's TT=VOIDP;

Makefile

@@ -18,7 +18,7 @@ else ifeq ($(COMPILE_MODE),release)
 else ifeq ($(COMPILE_MODE),small)
   CFLAGS = -Os
 endif
-CFLAGS += -pthread
+CFLAGS += -pthread -D DISABLE_GEMS
 
 BASEDIR = $(shell pwd)
 INCLUDES = -I$(BASEDIR)/include -I$(BASEDIR)/vendors/include
@@ -84,7 +84,7 @@ tmp/mruby:
 	sed -i -e 's/\/\/\#define MRB_INT64/\#define MRB_INT64/' tmp/mruby/include/mrbconf.h
 
 vendors/lib/libmruby.a: tmp/mruby
-	cd tmp/mruby && make clean && make all CFLAGS="$(CFLAGS)"
+	cd tmp/mruby && ./minirake clean && ./minirake all CFLAGS="$(CFLAGS)"
 	cp -r tmp/mruby/include vendors/
 	cp -r tmp/mruby/lib vendors/
 	cp -r tmp/mruby/bin vendors/

include/cfunc.h

@@ -29,6 +29,8 @@
 #define cfunc_h
 
 #include "mruby.h"
+#include "mruby/variable.h"
+#include "mruby/value.h"
 
 struct cfunc_state {
     struct RClass *namespace;
@@ -50,38 +52,23 @@ struct cfunc_state {
     struct RClass *closure_class;
     struct RClass *rubyvm_class;
     struct RClass *rubyvm_task_class;
-
-    void (*mrb_state_init)(mrb_state*);
 };
 
-void init_cfunc_module(mrb_state *mrb, void (*mrb_state_init)(mrb_state*));
-
-/* offset of cfunc_state in mrb->ud */
-extern size_t cfunc_state_offset;
-
-/* service function for setting cfunc_state_offset */
-#define cfunc_offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+void init_cfunc_module(mrb_state *mrb);
 
 /*
 example:
 
-struct mrb_state_ud {
-    struct cfunc_state cfunc_state;
-};
-
-cfunc_state_offset = cfunc_offsetof(struct mrb_state_ud, cfunc_state);
-
 mrb_state *mrb = mrb_open();
-mrb->ud = malloc(sizeof(struct mrb_state_ud));
-
 init_cfunc_module(mrb);
 */
 
 
 static inline struct cfunc_state *
-cfunc_state(mrb_state* mrb)
+cfunc_state(mrb_state *mrb, struct RClass* klass)
 {
-  return (struct cfunc_state *)(mrb->ud + cfunc_state_offset);
+    mrb_value state = mrb_obj_iv_get(mrb, (struct RObject *)klass, mrb_intern(mrb, "cfunc_state"));
+    return (struct cfunc_state *)mrb_voidp(state);
 }
 
 #endif

include/cfunc_rubyvm.h

@@ -14,8 +14,7 @@
 
 struct cfunc_rubyvm_data {
     mrb_state *state;
-    void (*mrb_state_init)(mrb_state*);
-
+
     const char* mrb_data;
 
     pthread_t thread;
@@ -25,6 +24,6 @@ struct cfunc_rubyvm_data {
     vector_p queue;
 };
 
-void init_cfunc_rubyvm(mrb_state *mrb, struct RClass* module, void (*mrb_state_init)(mrb_state*));
+void init_cfunc_rubyvm(mrb_state *mrb, struct RClass* module);
 
 #endif

src/cfunc.c

@@ -20,8 +20,6 @@
 
 extern const char mruby_cfunc_data_cfunc_rb[];
 
-size_t cfunc_state_offset = 0;
-
 // generate from mrb/cfunc_rb.rb
 void
 init_cfunc_rb(mrb_state *mrb);
@@ -33,21 +31,23 @@ cfunc_mrb_state(mrb_state *mrb, mrb_value klass)
 }
 
 
-void init_cfunc_module(mrb_state *mrb, void (*mrb_state_init)(mrb_state*))
+void init_cfunc_module(mrb_state *mrb)
 {
     if(sizeof(mrb_int) < 8) {
         fprintf(stderr, "mruby-cfunc require 64bit for mrb_int.");
     }
 
     struct RClass *ns = mrb_define_module(mrb, "CFunc");
-    cfunc_state(mrb)->namespace = ns;
+    struct cfunc_state *state = mrb_malloc(mrb, sizeof(struct cfunc_state));
+    mrb_value mstate = mrb_voidp_value(state);
+    mrb_obj_iv_set(mrb, ns, mrb_intern(mrb, "cfunc_state"), mstate);
 
     init_cfunc_type(mrb, ns);
     init_cfunc_pointer(mrb, ns);
     init_cfunc_struct(mrb, ns);
     init_cfunc_closure(mrb, ns);
     init_cfunc_call(mrb, ns);
-    init_cfunc_rubyvm(mrb, ns, mrb_state_init);
+    init_cfunc_rubyvm(mrb, ns);
 
     mrb_define_class_method(mrb, ns, "mrb_state", cfunc_mrb_state, ARGS_NONE());
 

src/cfunc_closure.c

@@ -168,8 +168,9 @@ static struct mrb_ffi_type closure_mrb_ffi_type = {
 void
 init_cfunc_closure(mrb_state *mrb, struct RClass* module)
 {
-    struct RClass *closure_class = mrb_define_class_under(mrb, module, "Closure", cfunc_state(mrb)->pointer_class);
-    cfunc_state(mrb)->closure_class = closure_class;
+    struct cfunc_state *state = cfunc_state(mrb, module);
+    struct RClass *closure_class = mrb_define_class_under(mrb, module, "Closure", state->pointer_class);
+    state->closure_class = closure_class;
 
     mrb_value ffi_type = mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &cfunc_closure_data_type, &closure_mrb_ffi_type));
     mrb_obj_iv_set(mrb, (struct RObject*)closure_class, mrb_intern(mrb, "@ffi_type"), ffi_type);

src/cfunc_pointer.c

@@ -84,7 +84,9 @@ cfunc_pointer_new_with_pointer(mrb_state *mrb, void *p, bool autofree)
 
     set_cfunc_pointer_data(data, p);
 
-    return mrb_obj_value(Data_Wrap_Struct(mrb, cfunc_state(mrb)->pointer_class, &cfunc_pointer_data_type, data));
+    struct RClass *mod = (struct RClass *)mrb_object(mrb_vm_const_get(mrb, mrb_intern(mrb, "CFunc")));
+    struct cfunc_state *state = cfunc_state(mrb, mod);
+    return mrb_obj_value(Data_Wrap_Struct(mrb, state->pointer_class, &cfunc_pointer_data_type, data));
 }
 
 
@@ -165,7 +167,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, mrb_object(type));
+    const char* classname = mrb_class_name(mrb, (struct RClass*)mrb_object(type));
     if(!classname) {
         classname = "Unknown pointer";
     }
@@ -315,10 +317,12 @@ static struct mrb_ffi_type pointer_mrb_ffi_type = {
 void
 init_cfunc_pointer(mrb_state *mrb, struct RClass* module)
 {
-    struct RClass *pointer_class = mrb_define_class_under(mrb, module, "Pointer", cfunc_state(mrb)->type_class);
+    struct cfunc_state *state = cfunc_state(mrb, module);
+
+    struct RClass *pointer_class = mrb_define_class_under(mrb, module, "Pointer", state->type_class);
     mrb_value ffi_type = mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &cfunc_pointer_ffi_data_type, &pointer_mrb_ffi_type));
     mrb_obj_iv_set(mrb, (struct RObject*)pointer_class, mrb_intern(mrb, "@ffi_type"), ffi_type);
-    cfunc_state(mrb)->pointer_class = pointer_class;
+    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));

src/cfunc_rubyvm.c

@@ -236,7 +236,9 @@ cfunc_rubyvm_open(void *args)
     mrb_state *mrb = mrb_open();
     data->state = mrb;
 
-    data->mrb_state_init(mrb);
+#ifdef DISABLE_GEMS
+    init_cfunc_module(mrb);
+#endif
 
     int n = mrb_read_irep(mrb, data->mrb_data);
 
@@ -311,7 +313,8 @@ cfunc_rubyvm_dispatch(mrb_state *mrb, mrb_value self)
     pthread_cond_signal(&data->queue_cond);
     pthread_mutex_unlock(&data->queue_mutex);
 
-    return mrb_obj_value((struct RObject *)Data_Wrap_Struct(mrb, cfunc_state(mrb)->rubyvm_task_class, &cfunc_rubyvm_task_data_type, task));
+    struct cfunc_state *state = cfunc_state(mrb, mrb_obj_ptr(self)->c);
+    return mrb_obj_value((struct RObject *)Data_Wrap_Struct(mrb, state->rubyvm_task_class, &cfunc_rubyvm_task_data_type, task));
 }
 
 
@@ -350,8 +353,8 @@ cfunc_rubyvm_class_thread(mrb_state *mrb, mrb_value klass)
 {
     // init bindle data with RubyVM object
     struct RClass *c = mrb_class_ptr(klass);
+    struct cfunc_state *state = cfunc_state(mrb, c);
     struct cfunc_rubyvm_data *data = malloc(sizeof(struct cfunc_rubyvm_data));
-    data->mrb_state_init = cfunc_state(mrb)->mrb_state_init;
     mrb_value self = mrb_obj_value((struct RObject *)Data_Wrap_Struct(mrb, c, &cfunc_rubyvm_data_type, data));
 
     // load script
@@ -379,18 +382,19 @@ cfunc_rubyvm_class_thread(mrb_state *mrb, mrb_value klass)
 
 
 void
-init_cfunc_rubyvm(mrb_state *mrb, struct RClass* module, void (*mrb_state_init)(mrb_state*))
+init_cfunc_rubyvm(mrb_state *mrb, struct RClass* module)
 {
-    cfunc_state(mrb)->mrb_state_init = mrb_state_init;
+    struct cfunc_state *state = cfunc_state(mrb, module);
 
     struct RClass *rubyvm_class = mrb_define_class_under(mrb, module, "RubyVM", mrb->object_class);
-    cfunc_state(mrb)->rubyvm_class = rubyvm_class;
+    state->rubyvm_class = rubyvm_class;
+    mrb_obj_iv_set(mrb, (struct RObject*)rubyvm_class, mrb_intern(mrb, "cfunc_state"), mrb_voidp_value(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());
 
-    struct RClass *rubyvm_task_class = mrb_define_class_under(mrb, cfunc_state(mrb)->rubyvm_class, "Task", mrb->object_class);
-    cfunc_state(mrb)->rubyvm_task_class = rubyvm_task_class;
+    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());

src/cfunc_struct.c

@@ -81,8 +81,10 @@ cfunc_struct_define_struct(mrb_state *mrb, mrb_value klass)
 void
 init_cfunc_struct(mrb_state *mrb, struct RClass* module)
 {
+    struct cfunc_state *state = cfunc_state(mrb, module);
     struct RClass *struct_class = mrb_define_class_under(mrb, module, "Struct", mrb->object_class);
-    cfunc_state(mrb)->struct_class = struct_class;
+    mrb_obj_iv_set(mrb, struct_class, mrb_intern(mrb, "cfunc_state"), mrb_voidp_value(state));
+    state->struct_class = struct_class;
 
     mrb_define_class_method(mrb, struct_class, "define_struct", cfunc_struct_define_struct, ARGS_REQ(1));
 }

src/cfunc_type.c

@@ -58,12 +58,16 @@ struct mrb_ffi_type*
 mrb_value_to_mrb_ffi_type(mrb_state *mrb, mrb_value val)
 {
     if(mrb_nil_p(val)) {
-        return rclass_to_mrb_ffi_type(mrb, cfunc_state(mrb)->pointer_class);
+        struct RClass *mod = (struct RClass *)mrb_object(mrb_vm_const_get(mrb, mrb_intern(mrb, "CFunc")));
+        return rclass_to_mrb_ffi_type(mrb, cfunc_state(mrb, mod)->pointer_class);
     }
     switch(mrb_type(val)) {
         case MRB_TT_TRUE:
         case MRB_TT_FALSE:
-           return rclass_to_mrb_ffi_type(mrb, cfunc_state(mrb)->sint32_class);
+            {
+                struct RClass *mod = (struct RClass *)mrb_object(mrb_vm_const_get(mrb, mrb_intern(mrb, "CFunc")));
+                return rclass_to_mrb_ffi_type(mrb, cfunc_state(mrb, mod)->sint32_class);
+            }
     }
     return rclass_to_mrb_ffi_type(mrb, mrb_object(val)->c);
 }
@@ -515,9 +519,11 @@ const struct mrb_data_type cfunc_class_ffi_data_type = {
 
 void init_cfunc_type(mrb_state *mrb, struct RClass* module)
 {
+    struct cfunc_state *state = cfunc_state(mrb, module);
     struct RClass *type_class = mrb_define_class_under(mrb, module, "Type", mrb->object_class);
     MRB_SET_INSTANCE_TT(type_class, MRB_TT_DATA);
-    cfunc_state(mrb)->type_class = type_class;
+    state->type_class = type_class;
+    mrb_obj_iv_set(mrb, type_class, mrb_intern(mrb, "cfunc_state"), mrb_voidp_value(state));
 
     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());
@@ -539,23 +545,23 @@ void init_cfunc_type(mrb_state *mrb, struct RClass* module)
     }
 
     mrb_value mod = mrb_obj_value(module);
-    cfunc_state(mrb)->void_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "Void")));
-    cfunc_state(mrb)->uint8_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "UInt8")));
-    cfunc_state(mrb)->sint8_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "SInt8")));
-    cfunc_state(mrb)->uint16_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "UInt16")));
-    cfunc_state(mrb)->sint16_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "SInt16")));
-    cfunc_state(mrb)->uint32_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "UInt32")));
-    cfunc_state(mrb)->sint32_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "SInt32")));
-    cfunc_state(mrb)->uint64_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "UInt64")));
-    cfunc_state(mrb)->sint64_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "SInt64")));
-    cfunc_state(mrb)->float_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "Float")));
-    cfunc_state(mrb)->double_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "Double")));
+    state->void_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "Void")));
+    state->uint8_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "UInt8")));
+    state->sint8_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "SInt8")));
+    state->uint16_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "UInt16")));
+    state->sint16_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "SInt16")));
+    state->uint32_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "UInt32")));
+    state->sint32_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "SInt32")));
+    state->uint64_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "UInt64")));
+    state->sint64_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "SInt64")));
+    state->float_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "Float")));
+    state->double_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern(mrb, "Double")));
 
     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());
 
     // sint64 specific
-    struct RClass *uint64_class = cfunc_state(mrb)->uint64_class;
+    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());

test/main.c

@@ -88,17 +88,14 @@ const char* assert_rb =
 static 
 void mrb_state_init(mrb_state *mrb)
 {
-    mrb->ud = malloc(sizeof(struct mrb_state_ud));
-    init_cfunc_module(mrb, mrb_state_init);
+    init_cfunc_module(mrb);
 }
 
 
 int main(int argc, char *argv[])
 {
     printf("%s: ", appname);
 
-    cfunc_state_offset = cfunc_offsetof(struct mrb_state_ud, cfunc_state);
-
     mrb_state *mrb = mrb_open();
     mrb_state_init(mrb);