void MessagePack_Packer_module_init(mrb_state* mrb, struct RClass *mMessagePack)
{
sym_pack_data = mrb_intern_cstr(mrb, "pack_data");
//s_to_msgpack = mrb_intern_cstr(mrb, "to_msgpack");
s_write = mrb_intern_cstr(mrb, "write");
cMessagePack_Packer = mrb_define_class_under(mrb, mMessagePack, "Packer", mrb->object_class);
mrb_define_method(mrb, cMessagePack_Packer, "initialize", Packer_initialize, MRB_ARGS_ANY()/* -1 */);
mrb_define_method(mrb, cMessagePack_Packer, "buffer", Packer_buffer, MRB_ARGS_NONE()/*0*/);
mrb_define_method(mrb, cMessagePack_Packer, "write", Packer_write, MRB_ARGS_REQ(1) /*1*/);
mrb_define_alias(mrb, cMessagePack_Packer, "pack", "write");
mrb_define_method(mrb, cMessagePack_Packer, "write_nil", Packer_write_nil, MRB_ARGS_NONE()/*0*/);
mrb_define_method(mrb, cMessagePack_Packer, "write_array_header", Packer_write_array_header, MRB_ARGS_REQ(1) /*1*/);
mrb_define_method(mrb, cMessagePack_Packer, "write_map_header", Packer_write_map_header, MRB_ARGS_REQ(1) /*1*/);
mrb_define_method(mrb, cMessagePack_Packer, "flush", Packer_flush, MRB_ARGS_NONE()/*0*/);
/* delegation methods */
mrb_define_method(mrb, cMessagePack_Packer, "clear", Packer_clear, MRB_ARGS_NONE());
mrb_define_method(mrb, cMessagePack_Packer, "size", Packer_size, MRB_ARGS_NONE());
mrb_define_method(mrb, cMessagePack_Packer, "empty?", Packer_empty_p, MRB_ARGS_NONE());
//mrb_define_method(mrb, cMessagePack_Packer, "write_to", Packer_write_to, MRB_ARGS_REQ(1) );
mrb_define_method(mrb, cMessagePack_Packer, "to_str", Packer_to_str, MRB_ARGS_NONE());
mrb_define_alias(mrb, cMessagePack_Packer, "to_s", "to_str");
mrb_define_method(mrb, cMessagePack_Packer, "to_a", Packer_to_a, MRB_ARGS_NONE());
/* MessagePack.pack(x) */
mrb_define_module_function(mrb, mMessagePack, "pack", MessagePack_pack_module_method, MRB_ARGS_ANY()/* -1 */);
mrb_define_module_function(mrb, mMessagePack, "dump", MessagePack_dump_module_method, MRB_ARGS_ANY()/* -1 */);
}
void
mrb_mruby_require_gem_init(mrb_state* mrb)
{
char *env;
struct RClass *krn;
krn = mrb->kernel_module;
struct RClass *load_error;
mrb_define_method(mrb, krn, "load", mrb_f_load, MRB_ARGS_REQ(1));
mrb_define_method(mrb, krn, "require", mrb_f_require, MRB_ARGS_REQ(1));
load_error = mrb_define_class(mrb, "LoadError", E_SCRIPT_ERROR);
mrb_define_method(mrb, load_error, "path", mrb_load_error_path, MRB_ARGS_NONE());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$:"), mrb_init_load_path(mrb));
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$\""), mrb_ary_new(mrb));
env = getenv("MRUBY_REQUIRE");
if (env != NULL) {
int i, envlen;
envlen = strlen(env);
for (i = 0; i < envlen; i++) {
char *ptr = env + i;
char *end = strchr(ptr, ',');
int len;
if (end == NULL) {
end = env + envlen;
}
len = end - ptr;
mrb_require(mrb, mrb_str_new(mrb, ptr, len));
i += len;
}
}
}
static mrb_value
mrb_magnetic_s__read(mrb_state *mrb, mrb_value self)
{
mrb_int ret;
mrb_value hash;
BYTE abTk1[256], abTk2[256], abTk3[256];
UINT uiLen1 = 0,uiLen2 = 0,uiLen3 = 0 ;
uiLen1 = sizeof(abTk1);
uiLen2 = sizeof(abTk2);
uiLen3 = sizeof(abTk3);
ret = GEDI_MSR_Read(abTk1, &uiLen1, abTk2, &uiLen2, abTk3, &uiLen3);
hash = mrb_hash_new(mrb);
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "ret")), mrb_fixnum_value(ret));
if (ret == GEDI_MSR_STATUS_SUCCESS) {
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "track1")), mrb_str_new(mrb, abTk1, uiLen1));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "track2")), mrb_str_new(mrb, abTk2, uiLen2));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "track3")), mrb_str_new(mrb, abTk3, uiLen3));
}
return hash;
}
void
cfunc_closure_call_binding(ffi_cif *cif, void *ret, void **args, void *self_)
{
mrb_value self = mrb_obj_value(self_);
struct cfunc_closure_data *data = DATA_PTR(self);
int ai = mrb_gc_arena_save(data->mrb);
mrb_value *ary = mrb_malloc(data->mrb, sizeof(mrb_value) * data->argc);
int i;
for (i = 0; i < data->argc; ++i) {
// TODO: I felt too much consume memory
void *p = mrb_malloc(data->mrb, data->arg_ffi_types[i]->size);
memcpy(p, args[i], data->arg_ffi_types[i]->size);
mrb_value pointer = cfunc_pointer_new_with_pointer(data->mrb, p, true);
ary[i] = mrb_funcall(data->mrb, data->arg_types[i], "refer", 1, pointer);
}
mrb_value block = mrb_iv_get(data->mrb, self, mrb_intern_cstr(data->mrb, "@block"));
mrb_value result = mrb_funcall_argv(data->mrb, block, mrb_intern_cstr(data->mrb, "call"), data->argc, ary);
mrb_free(data->mrb, ary);
mrb_value ret_pointer = cfunc_pointer_new_with_pointer(data->mrb, ret, false);
mrb_funcall(data->mrb, data->return_type, "set", 2, ret_pointer, result);
mrb_gc_arena_restore(data->mrb, ai);
}
static mrb_value
mrb_queue_concurrent(mrb_state *mrb, mrb_value self)
{
mrb_value instance;
mrb_sym priority;
long priority_value;
dispatch_queue_t q;
mrb_get_args(mrb, "|n", &priority);
if (priority == mrb_intern_cstr(mrb, "high")) {
priority_value = DISPATCH_QUEUE_PRIORITY_HIGH;
}
else if (priority == mrb_intern_cstr(mrb, "low")) {
priority_value = DISPATCH_QUEUE_PRIORITY_LOW;
}
#ifdef DISPATCH_QUEUE_PRIORITY_BACKGROUND
else if (priority == mrb_intern_cstr(mrb, "background")) {
priority_value = DISPATCH_QUEUE_PRIORITY_BACKGROUND;
}
#endif
else {
priority_value = DISPATCH_QUEUE_PRIORITY_DEFAULT;
}
instance = mrb_queue_create_instance(mrb);
q = dispatch_get_global_queue(priority_value, 0);
return mrb_queue_set_queue(instance, q);
}
static mrb_value
mrb_io_s_pipe(mrb_state *mrb, mrb_value klass)
{
mrb_value r = mrb_nil_value();
mrb_value w = mrb_nil_value();
struct mrb_io *fptr_r;
struct mrb_io *fptr_w;
int pipes[2];
if (mrb_pipe(mrb, pipes) == -1) {
mrb_sys_fail(mrb, "pipe");
}
r = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
mrb_iv_set(mrb, r, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
fptr_r = mrb_io_alloc(mrb);
fptr_r->fd = pipes[0];
fptr_r->readable = 1;
fptr_r->writable = 0;
fptr_r->sync = 0;
DATA_TYPE(r) = &mrb_io_type;
DATA_PTR(r) = fptr_r;
w = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
mrb_iv_set(mrb, w, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
fptr_w = mrb_io_alloc(mrb);
fptr_w->fd = pipes[1];
fptr_w->readable = 0;
fptr_w->writable = 1;
fptr_w->sync = 1;
DATA_TYPE(w) = &mrb_io_type;
DATA_PTR(w) = fptr_w;
return mrb_assoc_new(mrb, r, w);
}
void
init_cfunc_pointer(mrb_state *mrb, struct RClass* module)
{
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_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_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, "offset", cfunc_pointer_offset, ARGS_REQ(1));
mrb_define_method(mrb, pointer_class, "to_s", cfunc_pointer_to_s, ARGS_NONE());
// add method to system classes
mrb_define_method(mrb, mrb->string_class, "addr", cfunc_string_addr, ARGS_NONE());
mrb_obj_iv_set(mrb, (struct RObject *)mrb->string_class, mrb_intern_cstr(mrb, "@ffi_type"), ffi_type);
}
mrb_value ruby_global_require(mrb_state* mrb, mrb_value self)
{
const char* filename_cstr = nullptr;
mrb_get_args(mrb, "z", &filename_cstr);
std::string filename(filename_cstr);
auto engine = cocos2d::RubyEngine::getInstance();
std::string realfile = engine->findFile(filename);
mrb_value loaded_path_arr = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$LOADED_FEATURES"));
if (mrb_array_p(loaded_path_arr)) {
mrb_int len = mrb_ary_len(mrb, loaded_path_arr);
for (mrb_int i = 0; i < len; i++) {
mrb_value path = mrb_ary_ref(mrb, loaded_path_arr, i);
const char* path_cstr = mrb_str_to_cstr(mrb, path);
if (realfile.compare(path_cstr) == 0) {
return mrb_nil_value();
}
}
}
if (! mrb_array_p(loaded_path_arr)) {
loaded_path_arr = mrb_ary_new(mrb);
mrb_value path = mrb_str_new_cstr(mrb, realfile.c_str());
mrb_ary_push(mrb, loaded_path_arr, path);
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$LOADED_FEATURES"), loaded_path_arr);
} else {
mrb_value path = mrb_str_new_cstr(mrb, realfile.c_str());
mrb_ary_push(mrb, loaded_path_arr, path);
}
engine->executeScriptFile(realfile.c_str());
return mrb_nil_value();
}
static int
loaded_files_check(mrb_state *mrb, mrb_value filepath)
{
mrb_value loading_files;
mrb_value loaded_files = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$\""));
int i;
for (i = 0; i < RARRAY_LEN(loaded_files); i++) {
if (mrb_str_cmp(
mrb,
mrb_ary_entry(loaded_files, i),
filepath) == 0) {
return 0;
}
}
loading_files = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$\"_"));
if (mrb_nil_p(loading_files)) {
return 1;
}
for (i = 0; i < RARRAY_LEN(loading_files); i++) {
if (mrb_str_cmp(
mrb,
mrb_ary_entry(loading_files, i),
filepath) == 0) {
return 0;
}
}
return 1;
}
// For FLTK::Widget#callback
void mrb_fltk_widget_callback_function( Fl_Widget *fl_widget, void *data ) {
mrb_fltk_widget_callback_context *context = (mrb_fltk_widget_callback_context *)data;
mrb_state *mrb = context->mrb;
mrb_value self = context->self;
mrb_value block = mrb_iv_get( mrb, self, mrb_intern_cstr( mrb, "callback" ) );
mrb_funcall_with_block( mrb, self, mrb_intern_cstr( mrb, "instance_eval" ), 0, NULL, block );
}
GLenum
shader_type_sym_to_enum(mrb_state* mrb, mrb_sym shader_type) {
if (shader_type == mrb_intern_cstr(mrb, "vertex"))
return GL_VERTEX_SHADER;
if (shader_type == mrb_intern_cstr(mrb, "fragment"))
return GL_FRAGMENT_SHADER;
return 0;
}
static mrb_value
mrb_future_value(mrb_state *mrb, mrb_value self)
{
mrb_future_context *context = (mrb_future_context *)mrb_cptr(mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "_context")));
if (mrb_fixnum(mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "_state"))) == FUTURE_RUNNING) {
pthread_join(context->thread, NULL);
}
return mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "value"));
}
static mrb_value
mrb_io_test_io_cleanup(mrb_state *mrb, mrb_value self)
{
mrb_value rfname = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_rfname"));
mrb_value wfname = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_wfname"));
mrb_value symlinkname = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_symlinkname"));
mrb_value socketname = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_socketname"));
if (mrb_type(rfname) == MRB_TT_STRING) {
remove(RSTRING_PTR(rfname));
}
if (mrb_type(wfname) == MRB_TT_STRING) {
remove(RSTRING_PTR(wfname));
}
if (mrb_type(symlinkname) == MRB_TT_STRING) {
remove(RSTRING_PTR(symlinkname));
}
if (mrb_type(socketname) == MRB_TT_STRING) {
remove(RSTRING_PTR(socketname));
}
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_rfname"), mrb_nil_value());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_wfname"), mrb_nil_value());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_symlinkname"), mrb_nil_value());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_socketname"), mrb_nil_value());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_msg"), mrb_nil_value());
return mrb_nil_value();
}
static void
loading_files_add(mrb_state *mrb, mrb_value filepath)
{
mrb_value loading_files = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$\"_"));
if (mrb_nil_p(loading_files)) {
loading_files = mrb_ary_new(mrb);
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$\"_"), loading_files);
}
mrb_ary_push(mrb, loading_files, filepath);
return;
}
// FLTK.measure(text)
// Get the width and height of a string, according to the last call to FLTK.font.
mrb_value mrb_fltk_measure_module_method( mrb_state *mrb, mrb_value self ) {
int width = 0;
int height = 0;
char *text;
mrb_get_args( mrb, "z", &text );
fl_measure( text, width, height );
mrb_value result = mrb_hash_new( mrb );
mrb_hash_set( mrb, result, mrb_symbol_value( mrb_intern_cstr( mrb, "width" ) ), mrb_fixnum_value( width ) );
mrb_hash_set( mrb, result, mrb_symbol_value( mrb_intern_cstr( mrb, "height" ) ), mrb_fixnum_value( height ) );
return result;
}
unsigned int
gl_clear_flag_symbol_to_flag(mrb_state* mrb, mrb_value sym)
{
mrb_sym flag = mrb_obj_to_sym(mrb, sym);
if (flag == mrb_intern_cstr(mrb, "color"))
return GL_COLOR_BUFFER_BIT;
if (flag == mrb_intern_cstr(mrb, "depth"))
return GL_DEPTH_BUFFER_BIT;
if (flag == mrb_intern_cstr(mrb, "stencil"))
return GL_STENCIL_BUFFER_BIT;
return 0;
}
static mrb_value h2o_mrb_get_class_obj(mrb_state *mrb, mrb_value self, char *obj_id, char *class_name)
{
mrb_value obj;
struct RClass *obj_class, *h2o_class;
obj = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, obj_id));
if (mrb_nil_p(obj)) {
h2o_class = mrb_class_get(mrb, "H2O");
obj_class = (struct RClass *)mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(h2o_class), mrb_intern_cstr(mrb, class_name)));
obj = mrb_obj_new(mrb, obj_class, 0, NULL);
mrb_iv_set(mrb, self, mrb_intern_cstr(mrb, obj_id), obj);
}
return obj;
}
static mrb_value mrb_cgroup_get_cpuacct_obj(mrb_state *mrb, mrb_value self)
{
mrb_value cpuacct_value;
struct RClass *cpuacct_class, *cgroup_class;
mrb_cgroup_context *mrb_cg_cxt = mrb_cgroup_get_context(mrb, self, "mrb_cgroup_context");
cpuacct_value = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "cpuacct_obj"));
if (mrb_nil_p(cpuacct_value)) {
cgroup_class = mrb_class_get(mrb, "Cgroup");
cpuacct_class = (struct RClass*)mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(cgroup_class), mrb_intern_cstr(mrb, "CPUACCT")));
cpuacct_value = mrb_obj_new(mrb, cpuacct_class, 1, &mrb_cg_cxt->group_name);
mrb_iv_set(mrb, self, mrb_intern_cstr(mrb, "cpuacct_obj"), cpuacct_value);
}
return cpuacct_value;
}
mrb_value
mrb_io_initialize_copy(mrb_state *mrb, mrb_value copy)
{
mrb_value orig;
mrb_value buf;
struct mrb_io *fptr_copy;
struct mrb_io *fptr_orig;
mrb_bool failed = TRUE;
mrb_get_args(mrb, "o", &orig);
fptr_orig = io_get_open_fptr(mrb, orig);
fptr_copy = (struct mrb_io *)DATA_PTR(copy);
if (fptr_orig == fptr_copy) return copy;
if (fptr_copy != NULL) {
fptr_finalize(mrb, fptr_copy, FALSE);
mrb_free(mrb, fptr_copy);
}
fptr_copy = (struct mrb_io *)mrb_io_alloc(mrb);
DATA_TYPE(copy) = &mrb_io_type;
DATA_PTR(copy) = fptr_copy;
buf = mrb_iv_get(mrb, orig, mrb_intern_cstr(mrb, "@buf"));
mrb_iv_set(mrb, copy, mrb_intern_cstr(mrb, "@buf"), buf);
fptr_copy->fd = mrb_dup(mrb, fptr_orig->fd, &failed);
if (failed) {
mrb_sys_fail(mrb, 0);
}
mrb_fd_cloexec(mrb, fptr_copy->fd);
if (fptr_orig->fd2 != -1) {
fptr_copy->fd2 = mrb_dup(mrb, fptr_orig->fd2, &failed);
if (failed) {
close(fptr_copy->fd);
mrb_sys_fail(mrb, 0);
}
mrb_fd_cloexec(mrb, fptr_copy->fd2);
}
fptr_copy->pid = fptr_orig->pid;
fptr_copy->readable = fptr_orig->readable;
fptr_copy->writable = fptr_orig->writable;
fptr_copy->sync = fptr_orig->sync;
fptr_copy->is_socket = fptr_orig->is_socket;
return copy;
}
bool jamruby_context::register_method_signature(bool is_class_method, struct RClass *target,
char const * const name, char const * const sig)
{
class_map_t::iterator it = classes.find(target);
if (it == classes.end()) {
class_map_entry_t *entry = new class_map_entry_t();
if (NULL == entry) {
return false;
}
std::pair<class_map_t::iterator, bool> ret = classes.insert(class_map_t::value_type(target, entry));
it = ret.first;
}
signature_map_t *&sig_map = is_class_method ? it->second->class_methods : it->second->instance_methods;
if (NULL == sig_map) {
sig_map = new signature_map_t();
if (NULL == sig_map) {
return false;
}
}
mrb_sym const sym = mrb_intern_cstr(mrb_, name);
signature_map_t::iterator sig_it = sig_map->find(sym);
if (sig_it == sig_map->end()) {
signatures_t signatures;
signatures.insert(sig);
sig_map->insert(signature_map_t::value_type(sym, signatures));
} else {
sig_it->second.insert(sig);
}
return true;
}
static void
loaded_files_add(mrb_state *mrb, mrb_value filepath)
{
mrb_value loaded_files = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$\""));
mrb_ary_push(mrb, loaded_files, filepath);
return;
}
static void*
mrb_future_func(void* data) {
mrb_value result;
mrb_future_context *context = (mrb_future_context *) data;
struct mrb_state *mrb = context->mrb;
struct mrb_state *oldmrb = context->oldmrb;
mrb_value self = context->self;
result = mrb_yield_with_class(mrb, mrb_obj_value(context->proc), context->argc, context->argv, context->self, mrb_class(mrb, context->self));
mrb_iv_set(oldmrb, self, mrb_intern_cstr(oldmrb, "value"), result);
mrb_iv_set(oldmrb, self, mrb_intern_cstr(oldmrb, "_state"), mrb_fixnum_value(FUTURE_FINISH));
return NULL;
}
mrb_value
mrb_exec_command(mrb_state *mrb, mrb_value obj)
{
mrb_value command_str;
mrb_get_args(mrb, "o", &command_str);
char *command_p = mrb_str_to_cstr(mrb, command_str);
char result_buff[BUF_SIZE];
FILE *fp;
mrb_value buff_str;
if ( (fp = popen(command_p, "r")) == NULL) {
return mrb_nil_value();
}
mrb_value str = mrb_obj_new(mrb, mrb_class_get(mrb, "String"), 0, NULL);
while(fgets(result_buff, BUF_SIZE, fp) != NULL) {
buff_str = mrb_str_new_cstr(mrb, result_buff);
mrb_str_concat(mrb, str, buff_str);
}
int rc = pclose(fp);
// Set the return code variable
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$?"), mrb_fixnum_value(WEXITSTATUS(rc)));
return str;
}
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_obj_iv_set(mrb, mrb_obj_ptr(ptr), mrb_intern_cstr(mrb, "parent_pointer"), self); // keep for GC
return ptr;
}
void
mrb_init_io(mrb_state *mrb)
{
struct RClass *io;
io = mrb_define_class(mrb, "IO", mrb->object_class);
MRB_SET_INSTANCE_TT(io, MRB_TT_DATA);
mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */
#ifndef _WIN32
mrb_define_class_method(mrb, io, "_popen", mrb_io_s_popen, MRB_ARGS_ANY());
mrb_define_class_method(mrb, io, "_sysclose", mrb_io_s_sysclose, MRB_ARGS_REQ(1));
#endif
mrb_define_class_method(mrb, io, "select", mrb_io_s_select, MRB_ARGS_ANY());
mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, MRB_ARGS_ANY());
mrb_define_method(mrb, io, "initialize", mrb_io_initialize, MRB_ARGS_ANY()); /* 15.2.20.5.21 (x)*/
mrb_define_method(mrb, io, "sync", mrb_io_sync, MRB_ARGS_NONE());
mrb_define_method(mrb, io, "sync=", mrb_io_set_sync, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "sysread", mrb_io_sysread, MRB_ARGS_ANY());
mrb_define_method(mrb, io, "sysseek", mrb_io_sysseek, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "syswrite", mrb_io_syswrite, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "close", mrb_io_close, MRB_ARGS_NONE()); /* 15.2.20.5.1 */
mrb_define_method(mrb, io, "close_on_exec=", mrb_io_set_close_on_exec, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "close_on_exec?", mrb_io_close_on_exec_p, MRB_ARGS_NONE());
mrb_define_method(mrb, io, "closed?", mrb_io_closed, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
mrb_define_method(mrb, io, "pid", mrb_io_pid, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
mrb_define_method(mrb, io, "fileno", mrb_io_fileno, MRB_ARGS_NONE());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$/"), mrb_str_new_cstr(mrb, "\n"));
}
mrb_value
cfunc_struct_define_struct(mrb_state *mrb, mrb_value klass)
{
mrb_value elements_mrb;
mrb_get_args(mrb, "A", &elements_mrb);
struct RArray *elements = mrb_ary_ptr(elements_mrb);
ffi_type *tm_type = mrb_malloc(mrb, sizeof(ffi_type));
tm_type->type = FFI_TYPE_STRUCT;
tm_type->size = tm_type->alignment = 0;
ffi_type **tm_type_elements = mrb_malloc(mrb, sizeof(ffi_type*) * (elements->len + 1));
int i;
for(i = 0; i < elements->len; ++i) {
tm_type_elements[i] = rclass_to_mrb_ffi_type(mrb, mrb_class_ptr(elements->ptr[i]))->ffi_type_value;
}
tm_type_elements[i] = NULL;
tm_type->elements = tm_type_elements;
struct mrb_ffi_type *mft = mrb_malloc(mrb, sizeof(struct mrb_ffi_type));
mft->name = mrb_class_name(mrb, mrb_class_ptr(klass));
mft->ffi_type_value = tm_type;
mft->mrb_to_c = &cfunc_type_ffi_struct_mrb_to_c;
mft->c_to_mrb = &cfunc_type_ffi_struct_c_to_mrb;
mrb_value __ffi_type = mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &cfunc_struct_data_type, mft));
mrb_obj_iv_set(mrb, (struct RObject*)(mrb_class_ptr(klass)), mrb_intern_cstr(mrb, "@ffi_type"), __ffi_type);
return mrb_nil_value();
}
static mrb_value
mrb_thread_init(mrb_state* mrb, mrb_value self) {
mrb_value proc = mrb_nil_value();
int argc;
mrb_value* argv;
mrb_get_args(mrb, "&*", &proc, &argv, &argc);
if (!mrb_nil_p(proc)) {
int i;
mrb_thread_context* context = (mrb_thread_context*) malloc(sizeof(mrb_thread_context));
context->mrb_caller = mrb;
context->mrb = mrb_open();
context->proc = mrb_proc_ptr(proc);
context->argc = argc;
context->argv = argv;
context->argv = calloc(sizeof (mrb_value), context->argc);
context->result = mrb_nil_value();
for (i = 0; i < context->argc; i++) {
context->argv[i] = migrate_simple_value(mrb, argv[i], context->mrb);
}
mrb_iv_set(mrb, self, mrb_intern_cstr(mrb, "context"), mrb_obj_value(
Data_Wrap_Struct(mrb, mrb->object_class,
&mrb_thread_context_type, (void*) context)));
pthread_create(&context->thread, NULL, &mrb_thread_func, (void*) context);
}
return self;
}
static mrb_value
mrb_proc_parameters(mrb_state *mrb, mrb_value self)
{
struct parameters_type {
int size;
const char *name;
} *p, parameters_list [] = {
{0, "req"},
{0, "opt"},
{0, "rest"},
{0, "req"},
{0, "block"},
{0, NULL}
};
const struct RProc *proc = mrb_proc_ptr(self);
const struct mrb_irep *irep = proc->body.irep;
mrb_aspec aspec;
mrb_value parameters;
int i, j;
if (MRB_PROC_CFUNC_P(proc)) {
// TODO cfunc aspec is not implemented yet
return mrb_ary_new(mrb);
}
if (!irep) {
return mrb_ary_new(mrb);
}
if (!irep->lv) {
return mrb_ary_new(mrb);
}
if (GET_OPCODE(*irep->iseq) != OP_ENTER) {
return mrb_ary_new(mrb);
}
if (!MRB_PROC_STRICT_P(proc)) {
parameters_list[0].name = "opt";
parameters_list[3].name = "opt";
}
aspec = GETARG_Ax(*irep->iseq);
parameters_list[0].size = MRB_ASPEC_REQ(aspec);
parameters_list[1].size = MRB_ASPEC_OPT(aspec);
parameters_list[2].size = MRB_ASPEC_REST(aspec);
parameters_list[3].size = MRB_ASPEC_POST(aspec);
parameters_list[4].size = MRB_ASPEC_BLOCK(aspec);
parameters = mrb_ary_new_capa(mrb, irep->nlocals-1);
for (i = 0, p = parameters_list; p->name; p++) {
mrb_value sname = mrb_symbol_value(mrb_intern_cstr(mrb, p->name));
for (j = 0; j < p->size; i++, j++) {
mrb_assert(i < (irep->nlocals-1));
mrb_ary_push(mrb, parameters, mrb_assoc_new(mrb,
sname,
mrb_symbol_value(irep->lv[i].name)
));
}
}
return parameters;
}
/* :nodoc: */
static void __rb_lmc_raise_exception(mrb_state *mrb, const char *error_type, const char *m)
{
mrb_sym eid;
mrb_value k;
eid = mrb_intern_cstr(mrb, error_type);
k = mrb_mod_cv_get(mrb, mrb_class_get(mrb, "Cache"), eid);
mrb_raise(mrb, mrb_class_ptr(k), m);
}
static int
mrb_io_read_data_pending(mrb_state *mrb, mrb_value io)
{
mrb_value buf = mrb_iv_get(mrb, io, mrb_intern_cstr(mrb, "@buf"));
if (mrb_type(buf) == MRB_TT_STRING && RSTRING_LEN(buf) > 0) {
return 1;
}
return 0;
}
