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); }
mrb_value mrb_io_s_for_fd(mrb_state *mrb, mrb_value klass) { mrb_value io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type)); return mrb_io_initialize(mrb, io); }
struct RData* mrb_mruby_opencv_mat_object_alloc(mrb_state* mrb, cv::Mat* mat) { struct RClass* cv_class = mrb_class_get(mrb, "CV"); struct RClass* mat_class = mrb_class_ptr(mrb_iv_get(mrb, mrb_obj_value(cv_class), mrb_intern_lit(mrb, "Mat"))); struct RData* data = mrb_data_object_alloc(mrb, mat_class, mat, &mrb_mruby_opencv_data_type); return data; }
static mrb_value context_alloc (mrb_state *mrb, mrb_value self) { struct zmq_context * ctx; ctx = mrb_malloc(mrb, sizeof(*ctx)); ctx->context = NULL; ctx->refs = 1; return mrb_data_object_alloc(mrb, 0, ctx, &mrb_zmq_context_type); }
static mrb_value sha256_clone(mrb_state *mrb, mrb_value self) { SHA256_CTX *ctx = (SHA256_CTX*)DATA_PTR(self); SHA256_CTX *ctx_copy = (SHA256_CTX*)mrb_malloc(mrb, sizeof(SHA256_CTX)); struct RData *c; memcpy(ctx_copy, ctx, sizeof(SHA256_CTX)); c = mrb_data_object_alloc(mrb, sha256_class, ctx_copy, &sha256_type); return mrb_obj_value(c); }
void Init_oci8_handle(void) { VALUE obj; /* * OCIHandle is the abstract base class of OCI handles and * OCI descriptors; opaque data types of Oracle Call Interface. * Don't use constants and methods defined in the class. * * @since 2.0.0 */ oci8_cOCIHandle = rb_define_class("OCIHandle", rb_cObject); rb_define_alloc_func(oci8_cOCIHandle, oci8_s_allocate); rb_define_method_nodoc(oci8_cOCIHandle, "initialize", oci8_handle_initialize, 0); #ifndef MRUBY_H rb_define_private_method(oci8_cOCIHandle, "free", oci8_handle_free, 0); #endif #ifdef MRUBY_H obj = mrb_obj_value(mrb_data_object_alloc(mrb, mrb->object_class, &oci8_base_vtable, &mrb_data_type_static)); #else obj = Data_Wrap_Struct(rb_cObject, 0, 0, &oci8_base_vtable); #endif rb_ivar_set(oci8_cOCIHandle, oci8_id_oci8_vtable, obj); /* methods to get attributes */ rb_define_private_method(oci8_cOCIHandle, "attr_get_ub1", attr_get_ub1, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_ub2", attr_get_ub2, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_ub4", attr_get_ub4, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_ub8", attr_get_ub8, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_sb1", attr_get_sb1, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_sb2", attr_get_sb2, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_sb4", attr_get_sb4, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_sb8", attr_get_sb8, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_boolean", attr_get_boolean, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_string", attr_get_string, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_binary", attr_get_binary, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_integer", attr_get_integer, 1); rb_define_private_method(oci8_cOCIHandle, "attr_get_oradate", attr_get_oradate, 1); /* methods to set attributes */ rb_define_private_method(oci8_cOCIHandle, "attr_set_ub1", attr_set_ub1, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_ub2", attr_set_ub2, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_ub4", attr_set_ub4, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_ub8", attr_set_ub8, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_sb1", attr_set_sb1, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_sb2", attr_set_sb2, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_sb4", attr_set_sb4, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_sb8", attr_set_sb8, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_boolean", attr_set_boolean, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_string", attr_set_string, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_binary", attr_set_binary, 2); rb_define_private_method(oci8_cOCIHandle, "attr_set_integer", attr_set_integer, 2); }
static mrb_value config_create(mrb_state *mrb, mrb_value self) { ALLEGRO_CONFIG *cfg; struct RData *data; cfg = al_create_config(); if (!cfg) { mrb_raise(mrb, E_ALLEGRO_ERROR, "could not create config"); } data = mrb_data_object_alloc(mrb, mrb_class_ptr(self), cfg, &mrbal_config_data_type); return mrb_obj_value(data); }
static mrb_value config_load_file(mrb_state *mrb, mrb_value self) { char *filename; ALLEGRO_CONFIG *cfg; struct RData *data; mrb_get_args(mrb, "z", &filename); cfg = al_load_config_file(filename); if (!cfg) { mrb_raise(mrb, E_ALLEGRO_ERROR, "could not load config"); } data = mrb_data_object_alloc(mrb, mrb_class_ptr(self), cfg, &mrbal_config_data_type); return mrb_obj_value(data); }
static mrb_value config_merge(mrb_state *mrb, mrb_value self) { ALLEGRO_CONFIG *cfg1; mrb_value o; ALLEGRO_CONFIG *cfg2; ALLEGRO_CONFIG *cfg_new; struct RData *data; Check_Destroyed(mrb, self, config, cfg1); mrb_get_args(mrb, "o", &o); Check_Destroyed(mrb, o, config, cfg2); cfg_new = al_merge_config(cfg1, cfg2); data = mrb_data_object_alloc(mrb, mrb_obj_class(mrb, self), cfg_new, &mrbal_config_data_type); return mrb_obj_value(data); }
mrb_value mrb_io_s_popen(mrb_state *mrb, mrb_value klass) { mrb_value cmd, io, result; mrb_value mode = mrb_str_new_cstr(mrb, "r"); mrb_value opt = mrb_hash_new(mrb); struct mrb_io *fptr; const char *pname; int pid, flags, fd, write_fd = -1; int pr[2] = { -1, -1 }; int pw[2] = { -1, -1 }; int doexec; int saved_errno; mrb_get_args(mrb, "S|SH", &cmd, &mode, &opt); io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type)); pname = mrb_string_value_cstr(mrb, &cmd); flags = mrb_io_modestr_to_flags(mrb, mrb_string_value_cstr(mrb, &mode)); doexec = (strcmp("-", pname) != 0); if ((flags & FMODE_READABLE) && pipe(pr) == -1) { mrb_sys_fail(mrb, "pipe"); } if ((flags & FMODE_WRITABLE) && pipe(pw) == -1) { if (pr[0] != -1) close(pr[0]); if (pr[1] != -1) close(pr[1]); mrb_sys_fail(mrb, "pipe"); } if (!doexec) { // XXX fflush(stdin); fflush(stdout); fflush(stderr); } result = mrb_nil_value(); switch (pid = fork()) { case 0: /* child */ if (flags & FMODE_READABLE) { close(pr[0]); if (pr[1] != 1) { dup2(pr[1], 1); close(pr[1]); } } if (flags & FMODE_WRITABLE) { close(pw[1]); if (pw[0] != 0) { dup2(pw[0], 0); close(pw[0]); } } if (doexec) { for (fd = 3; fd < NOFILE; fd++) { close(fd); } mrb_proc_exec(pname); mrb_raisef(mrb, E_IO_ERROR, "command not found: %S", cmd); _exit(127); } result = mrb_nil_value(); break; default: /* parent */ if ((flags & FMODE_READABLE) && (flags & FMODE_WRITABLE)) { close(pr[1]); fd = pr[0]; close(pw[0]); write_fd = pw[1]; } else if (flags & FMODE_READABLE) { close(pr[1]); fd = pr[0]; } else { close(pw[0]); fd = pw[1]; } mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, "")); mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0)); fptr = mrb_io_alloc(mrb); fptr->fd = fd; fptr->fd2 = write_fd; fptr->pid = pid; fptr->writable = ((flags & FMODE_WRITABLE) != 0); fptr->sync = 0; DATA_TYPE(io) = &mrb_io_type; DATA_PTR(io) = fptr; result = io; break; case -1: /* error */ saved_errno = errno; if (flags & FMODE_READABLE) { close(pr[0]); close(pr[1]); } if (flags & FMODE_WRITABLE) { close(pw[0]); close(pw[1]); } errno = saved_errno; mrb_sys_fail(mrb, "pipe_open failed."); break; } return result; }
//---------------------------------------------------------- mrb_value BindImage::ToMrb(mrb_state* mrb, struct RClass* aClass, ofImage* aPtr) { struct RData *data = mrb_data_object_alloc(mrb, aClass, aPtr, &data_type); return mrb_obj_value(data); }
mrb_value mrb_io_s_popen(mrb_state *mrb, mrb_value klass) { mrb_value cmd, io; mrb_value mode = mrb_str_new_cstr(mrb, "r"); mrb_value opt = mrb_hash_new(mrb); struct mrb_io *fptr; const char *pname; int pid = 0, flags; STARTUPINFO si; PROCESS_INFORMATION pi; SECURITY_ATTRIBUTES saAttr; HANDLE ifd[2]; HANDLE ofd[2]; int doexec; int opt_in, opt_out, opt_err; ifd[0] = INVALID_HANDLE_VALUE; ifd[1] = INVALID_HANDLE_VALUE; ofd[0] = INVALID_HANDLE_VALUE; ofd[1] = INVALID_HANDLE_VALUE; mrb_get_args(mrb, "S|SH", &cmd, &mode, &opt); io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type)); pname = mrb_string_value_cstr(mrb, &cmd); flags = mrb_io_modestr_to_flags(mrb, mrb_string_value_cstr(mrb, &mode)); doexec = (strcmp("-", pname) != 0); opt_in = option_to_fd(mrb, opt, "in"); opt_out = option_to_fd(mrb, opt, "out"); opt_err = option_to_fd(mrb, opt, "err"); saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; if (flags & FMODE_READABLE) { if (!CreatePipe(&ofd[0], &ofd[1], &saAttr, 0) || !SetHandleInformation(ofd[0], HANDLE_FLAG_INHERIT, 0)) { mrb_sys_fail(mrb, "pipe"); } } if (flags & FMODE_WRITABLE) { if (!CreatePipe(&ifd[0], &ifd[1], &saAttr, 0) || !SetHandleInformation(ifd[1], HANDLE_FLAG_INHERIT, 0)) { mrb_sys_fail(mrb, "pipe"); } } if (doexec) { ZeroMemory(&pi, sizeof(pi)); ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); si.dwFlags |= STARTF_USESHOWWINDOW; si.wShowWindow = SW_HIDE; si.dwFlags |= STARTF_USESTDHANDLES; if (flags & FMODE_READABLE) { si.hStdOutput = ofd[1]; si.hStdError = ofd[1]; } if (flags & FMODE_WRITABLE) { si.hStdInput = ifd[0]; } if (!CreateProcess( NULL, (char*)pname, NULL, NULL, TRUE, CREATE_NEW_PROCESS_GROUP, NULL, NULL, &si, &pi)) { CloseHandle(ifd[0]); CloseHandle(ifd[1]); CloseHandle(ofd[0]); CloseHandle(ofd[1]); mrb_raisef(mrb, E_IO_ERROR, "command not found: %S", cmd); } CloseHandle(pi.hThread); CloseHandle(ifd[0]); CloseHandle(ofd[1]); pid = pi.dwProcessId; } mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, "")); fptr = mrb_io_alloc(mrb); fptr->fd = _open_osfhandle((intptr_t)ofd[0], 0); fptr->fd2 = _open_osfhandle((intptr_t)ifd[1], 0); fptr->pid = pid; fptr->readable = ((flags & FMODE_READABLE) != 0); fptr->writable = ((flags & FMODE_WRITABLE) != 0); fptr->sync = 0; DATA_TYPE(io) = &mrb_io_type; DATA_PTR(io) = fptr; return io; }