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