summaryrefslogtreecommitdiffhomepage
path: root/mrbgems/mruby-io/src
diff options
context:
space:
mode:
Diffstat (limited to 'mrbgems/mruby-io/src')
-rw-r--r--mrbgems/mruby-io/src/file.c504
-rw-r--r--mrbgems/mruby-io/src/file_test.c381
-rw-r--r--mrbgems/mruby-io/src/io.c1328
-rw-r--r--mrbgems/mruby-io/src/mruby_io_gem.c20
4 files changed, 2233 insertions, 0 deletions
diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c
new file mode 100644
index 000000000..3dcfe3a0b
--- /dev/null
+++ b/mrbgems/mruby-io/src/file.c
@@ -0,0 +1,504 @@
+/*
+** file.c - File class
+*/
+
+#include "mruby.h"
+#include "mruby/class.h"
+#include "mruby/data.h"
+#include "mruby/string.h"
+#include "mruby/ext/io.h"
+
+#if MRUBY_RELEASE_NO < 10000
+#include "error.h"
+#else
+#include "mruby/error.h"
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <fcntl.h>
+#include <limits.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(_WIN32) || defined(_WIN64)
+ #include <windows.h>
+ #include <io.h>
+ #define NULL_FILE "NUL"
+ #define UNLINK _unlink
+ #define GETCWD _getcwd
+ #define CHMOD(a, b) 0
+ #define MAXPATHLEN 1024
+ #if !defined(PATH_MAX)
+ #define PATH_MAX _MAX_PATH
+ #endif
+ #define realpath(N,R) _fullpath((R),(N),_MAX_PATH)
+ #include <direct.h>
+#else
+ #define NULL_FILE "/dev/null"
+ #include <unistd.h>
+ #define UNLINK unlink
+ #define GETCWD getcwd
+ #define CHMOD(a, b) chmod(a,b)
+ #include <sys/file.h>
+ #include <libgen.h>
+ #include <sys/param.h>
+ #include <pwd.h>
+#endif
+
+#define FILE_SEPARATOR "/"
+
+#if defined(_WIN32) || defined(_WIN64)
+ #define PATH_SEPARATOR ";"
+ #define FILE_ALT_SEPARATOR "\\"
+#else
+ #define PATH_SEPARATOR ":"
+#endif
+
+#ifndef LOCK_SH
+#define LOCK_SH 1
+#endif
+#ifndef LOCK_EX
+#define LOCK_EX 2
+#endif
+#ifndef LOCK_NB
+#define LOCK_NB 4
+#endif
+#ifndef LOCK_UN
+#define LOCK_UN 8
+#endif
+
+#define STAT(p, s) stat(p, s)
+
+#ifdef _WIN32
+static int
+flock(int fd, int operation) {
+ OVERLAPPED ov;
+ HANDLE h = (HANDLE)_get_osfhandle(fd);
+ DWORD flags;
+ flags = ((operation & LOCK_NB) ? LOCKFILE_FAIL_IMMEDIATELY : 0)
+ | ((operation & LOCK_SH) ? LOCKFILE_EXCLUSIVE_LOCK : 0);
+ memset(&ov, 0, sizeof(ov));
+ return LockFileEx(h, flags, 0, 0xffffffff, 0xffffffff, &ov) ? 0 : -1;
+}
+#endif
+
+mrb_value
+mrb_file_s_umask(mrb_state *mrb, mrb_value klass)
+{
+#if defined(_WIN32) || defined(_WIN64)
+ /* nothing to do on windows */
+ return mrb_fixnum_value(0);
+
+#else
+ mrb_int mask, omask;
+ if (mrb_get_args(mrb, "|i", &mask) == 0) {
+ omask = umask(0);
+ umask(omask);
+ } else {
+ omask = umask(mask);
+ }
+ return mrb_fixnum_value(omask);
+#endif
+}
+
+static mrb_value
+mrb_file_s_unlink(mrb_state *mrb, mrb_value obj)
+{
+ mrb_value *argv;
+ mrb_value pathv;
+ mrb_int argc, i;
+ char *path;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ for (i = 0; i < argc; i++) {
+ pathv = mrb_convert_type(mrb, argv[i], MRB_TT_STRING, "String", "to_str");
+ path = mrb_locale_from_utf8(mrb_string_value_cstr(mrb, &pathv), -1);
+ if (UNLINK(path) < 0) {
+ mrb_locale_free(path);
+ mrb_sys_fail(mrb, path);
+ }
+ mrb_locale_free(path);
+ }
+ return mrb_fixnum_value(argc);
+}
+
+static mrb_value
+mrb_file_s_rename(mrb_state *mrb, mrb_value obj)
+{
+ mrb_value from, to;
+ char *src, *dst;
+
+ mrb_get_args(mrb, "SS", &from, &to);
+ src = mrb_locale_from_utf8(mrb_string_value_cstr(mrb, &from), -1);
+ dst = mrb_locale_from_utf8(mrb_string_value_cstr(mrb, &to), -1);
+ if (rename(src, dst) < 0) {
+#if defined(_WIN32) || defined(_WIN64)
+ if (CHMOD(dst, 0666) == 0 && UNLINK(dst) == 0 && rename(src, dst) == 0) {
+ mrb_locale_free(src);
+ mrb_locale_free(dst);
+ return mrb_fixnum_value(0);
+ }
+#endif
+ mrb_locale_free(src);
+ mrb_locale_free(dst);
+ mrb_sys_fail(mrb, mrb_str_to_cstr(mrb, mrb_format(mrb, "(%S, %S)", from, to)));
+ }
+ mrb_locale_free(src);
+ mrb_locale_free(dst);
+ return mrb_fixnum_value(0);
+}
+
+static mrb_value
+mrb_file_dirname(mrb_state *mrb, mrb_value klass)
+{
+#if defined(_WIN32) || defined(_WIN64)
+ char dname[_MAX_DIR], vname[_MAX_DRIVE];
+ char buffer[_MAX_DRIVE + _MAX_DIR];
+ char *path;
+ size_t ridx;
+ mrb_value s;
+ mrb_get_args(mrb, "S", &s);
+ path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, s), -1);
+ _splitpath((const char*)path, vname, dname, NULL, NULL);
+ snprintf(buffer, _MAX_DRIVE + _MAX_DIR, "%s%s", vname, dname);
+ mrb_locale_free(path);
+ ridx = strlen(buffer);
+ if (ridx == 0) {
+ strncpy(buffer, ".", 2); /* null terminated */
+ } else if (ridx > 1) {
+ ridx--;
+ while (ridx > 0 && (buffer[ridx] == '/' || buffer[ridx] == '\\')) {
+ buffer[ridx] = '\0'; /* remove last char */
+ ridx--;
+ }
+ }
+ return mrb_str_new_cstr(mrb, buffer);
+#else
+ char *dname, *path;
+ mrb_value s;
+ mrb_get_args(mrb, "S", &s);
+ path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, s), -1);
+
+ if ((dname = dirname(path)) == NULL) {
+ mrb_locale_free(path);
+ mrb_sys_fail(mrb, "dirname");
+ }
+ mrb_locale_free(path);
+ return mrb_str_new_cstr(mrb, dname);
+#endif
+}
+
+static mrb_value
+mrb_file_basename(mrb_state *mrb, mrb_value klass)
+{
+ // NOTE: Do not use mrb_locale_from_utf8 here
+#if defined(_WIN32) || defined(_WIN64)
+ char bname[_MAX_DIR];
+ char extname[_MAX_EXT];
+ char *path;
+ size_t ridx;
+ char buffer[_MAX_DIR + _MAX_EXT];
+ mrb_value s;
+
+ mrb_get_args(mrb, "S", &s);
+ path = mrb_str_to_cstr(mrb, s);
+ ridx = strlen(path);
+ if (ridx > 0) {
+ ridx--;
+ while (ridx > 0 && (path[ridx] == '/' || path[ridx] == '\\')) {
+ path[ridx] = '\0';
+ ridx--;
+ }
+ if (strncmp(path, "/", 2) == 0) {
+ return mrb_str_new_cstr(mrb, path);
+ }
+ }
+ _splitpath((const char*)path, NULL, NULL, bname, extname);
+ snprintf(buffer, _MAX_DIR + _MAX_EXT, "%s%s", bname, extname);
+ return mrb_str_new_cstr(mrb, buffer);
+#else
+ char *bname, *path;
+ mrb_value s;
+ mrb_get_args(mrb, "S", &s);
+ path = mrb_str_to_cstr(mrb, s);
+ if ((bname = basename(path)) == NULL) {
+ mrb_sys_fail(mrb, "basename");
+ }
+ if (strncmp(bname, "//", 3) == 0) bname[1] = '\0'; /* patch for Cygwin */
+ return mrb_str_new_cstr(mrb, bname);
+#endif
+}
+
+static mrb_value
+mrb_file_realpath(mrb_state *mrb, mrb_value klass)
+{
+ mrb_value pathname, dir_string, s, result;
+ mrb_int argc;
+ char *cpath;
+
+ argc = mrb_get_args(mrb, "S|S", &pathname, &dir_string);
+ if (argc == 2) {
+ s = mrb_str_dup(mrb, dir_string);
+ s = mrb_str_append(mrb, s, mrb_str_new_cstr(mrb, FILE_SEPARATOR));
+ s = mrb_str_append(mrb, s, pathname);
+ pathname = s;
+ }
+ cpath = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, pathname), -1);
+ result = mrb_str_buf_new(mrb, PATH_MAX);
+ if (realpath(cpath, RSTRING_PTR(result)) == NULL) {
+ mrb_locale_free(cpath);
+ mrb_sys_fail(mrb, cpath);
+ }
+ mrb_locale_free(cpath);
+ mrb_str_resize(mrb, result, strlen(RSTRING_PTR(result)));
+ return result;
+}
+
+mrb_value
+mrb_file__getwd(mrb_state *mrb, mrb_value klass)
+{
+ mrb_value path;
+ char buf[MAXPATHLEN], *utf8;
+
+ if (GETCWD(buf, MAXPATHLEN) == NULL) {
+ mrb_sys_fail(mrb, "getcwd(2)");
+ }
+ utf8 = mrb_utf8_from_locale(buf, -1);
+ path = mrb_str_new_cstr(mrb, utf8);
+ mrb_utf8_free(utf8);
+ return path;
+}
+
+static int
+mrb_file_is_absolute_path(const char *path)
+{
+ return (path[0] == '/');
+}
+
+static mrb_value
+mrb_file__gethome(mrb_state *mrb, mrb_value klass)
+{
+ mrb_int argc;
+ char *home;
+ mrb_value path;
+
+#ifndef _WIN32
+ mrb_value username;
+
+ argc = mrb_get_args(mrb, "|S", &username);
+ if (argc == 0) {
+ home = getenv("HOME");
+ if (home == NULL) {
+ return mrb_nil_value();
+ }
+ if (!mrb_file_is_absolute_path(home)) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "non-absolute home");
+ }
+ } else {
+ const char *cuser = mrb_str_to_cstr(mrb, username);
+ struct passwd *pwd = getpwnam(cuser);
+ if (pwd == NULL) {
+ return mrb_nil_value();
+ }
+ home = pwd->pw_dir;
+ if (!mrb_file_is_absolute_path(home)) {
+ mrb_raisef(mrb, E_ARGUMENT_ERROR, "non-absolute home of ~%S", username);
+ }
+ }
+ home = mrb_locale_from_utf8(home, -1);
+ path = mrb_str_new_cstr(mrb, home);
+ mrb_utf8_free(home);
+ return path;
+#else
+ argc = mrb_get_argc(mrb);
+ if (argc == 0) {
+ home = getenv("USERPROFILE");
+ if (home == NULL) {
+ return mrb_nil_value();
+ }
+ if (!mrb_file_is_absolute_path(home)) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "non-absolute home");
+ }
+ } else {
+ return mrb_nil_value();
+ }
+ home = mrb_locale_from_utf8(home, -1);
+ path = mrb_str_new_cstr(mrb, home);
+ mrb_utf8_free(home);
+ return path;
+#endif
+}
+
+static mrb_value
+mrb_file_mtime(mrb_state *mrb, mrb_value self)
+{
+ mrb_value obj;
+ struct stat st;
+ int fd;
+
+ obj = mrb_obj_value(mrb_class_get(mrb, "Time"));
+ fd = (int)mrb_fixnum(mrb_io_fileno(mrb, self));
+ if (fstat(fd, &st) == -1)
+ return mrb_false_value();
+ return mrb_funcall(mrb, obj, "at", 1, mrb_float_value(mrb, st.st_mtime));
+}
+
+mrb_value
+mrb_file_flock(mrb_state *mrb, mrb_value self)
+{
+#if defined(sun)
+ mrb_raise(mrb, E_NOTIMP_ERROR, "flock is not supported on Illumos/Solaris/Windows");
+#else
+ mrb_int operation;
+ int fd;
+
+ mrb_get_args(mrb, "i", &operation);
+ fd = (int)mrb_fixnum(mrb_io_fileno(mrb, self));
+
+ while (flock(fd, (int)operation) == -1) {
+ switch (errno) {
+ case EINTR:
+ /* retry */
+ break;
+ case EAGAIN: /* NetBSD */
+#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
+ case EWOULDBLOCK: /* FreeBSD OpenBSD Linux */
+#endif
+ if (operation & LOCK_NB) {
+ return mrb_false_value();
+ }
+ /* FALLTHRU - should not happen */
+ default:
+ mrb_sys_fail(mrb, "flock failed");
+ break;
+ }
+ }
+#endif
+ return mrb_fixnum_value(0);
+}
+
+static mrb_value
+mrb_file_s_symlink(mrb_state *mrb, mrb_value klass)
+{
+#if defined(_WIN32) || defined(_WIN64)
+ mrb_raise(mrb, E_NOTIMP_ERROR, "symlink is not supported on this platform");
+#else
+ mrb_value from, to;
+ const char *src, *dst;
+ int ai = mrb_gc_arena_save(mrb);
+
+ mrb_get_args(mrb, "SS", &from, &to);
+ src = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, from), -1);
+ dst = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, to), -1);
+
+ if (symlink(src, dst) == -1) {
+ mrb_locale_free(src);
+ mrb_locale_free(dst);
+ mrb_sys_fail(mrb, mrb_str_to_cstr(mrb, mrb_format(mrb, "(%S, %S)", from, to)));
+ }
+ mrb_locale_free(src);
+ mrb_locale_free(dst);
+ mrb_gc_arena_restore(mrb, ai);
+#endif
+ return mrb_fixnum_value(0);
+}
+
+static mrb_value
+mrb_file_s_chmod(mrb_state *mrb, mrb_value klass) {
+ mrb_int mode;
+ mrb_int argc, i;
+ mrb_value *filenames;
+ int ai = mrb_gc_arena_save(mrb);
+
+ mrb_get_args(mrb, "i*", &mode, &filenames, &argc);
+ for (i = 0; i < argc; i++) {
+ char *path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, filenames[i]), -1);
+ if (CHMOD(path, mode) == -1) {
+ mrb_locale_free(path);
+ mrb_sys_fail(mrb, path);
+ }
+ mrb_locale_free(path);
+ }
+
+ mrb_gc_arena_restore(mrb, ai);
+ return mrb_fixnum_value(argc);
+}
+
+static mrb_value
+mrb_file_s_readlink(mrb_state *mrb, mrb_value klass) {
+#if defined(_WIN32) || defined(_WIN64)
+ mrb_raise(mrb, E_NOTIMP_ERROR, "readlink is not supported on this platform");
+ return mrb_nil_value(); // unreachable
+#else
+ char *path, *buf, *tmp;
+ size_t bufsize = 100;
+ ssize_t rc;
+ mrb_value ret;
+ int ai = mrb_gc_arena_save(mrb);
+
+ mrb_get_args(mrb, "z", &path);
+ tmp = mrb_locale_from_utf8(path, -1);
+
+ buf = (char *)mrb_malloc(mrb, bufsize);
+ while ((rc = readlink(tmp, buf, bufsize)) == (ssize_t)bufsize && rc != -1) {
+ bufsize *= 2;
+ buf = (char *)mrb_realloc(mrb, buf, bufsize);
+ }
+ mrb_locale_free(tmp);
+ if (rc == -1) {
+ mrb_free(mrb, buf);
+ mrb_sys_fail(mrb, path);
+ }
+ tmp = mrb_utf8_from_locale(buf, -1);
+ ret = mrb_str_new(mrb, tmp, rc);
+ mrb_locale_free(tmp);
+ mrb_free(mrb, buf);
+
+ mrb_gc_arena_restore(mrb, ai);
+ return ret;
+#endif
+}
+
+void
+mrb_init_file(mrb_state *mrb)
+{
+ struct RClass *io, *file, *cnst;
+
+ io = mrb_class_get(mrb, "IO");
+ file = mrb_define_class(mrb, "File", io);
+ MRB_SET_INSTANCE_TT(file, MRB_TT_DATA);
+ mrb_define_class_method(mrb, file, "umask", mrb_file_s_umask, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
+ mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY());
+ mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2));
+ mrb_define_class_method(mrb, file, "symlink", mrb_file_s_symlink, MRB_ARGS_REQ(2));
+ mrb_define_class_method(mrb, file, "chmod", mrb_file_s_chmod, MRB_ARGS_REQ(1) | MRB_ARGS_REST());
+ mrb_define_class_method(mrb, file, "readlink", mrb_file_s_readlink, MRB_ARGS_REQ(1));
+
+ mrb_define_class_method(mrb, file, "dirname", mrb_file_dirname, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, file, "basename", mrb_file_basename, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, file, "realpath", mrb_file_realpath, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
+ mrb_define_class_method(mrb, file, "_getwd", mrb_file__getwd, MRB_ARGS_NONE());
+ mrb_define_class_method(mrb, file, "_gethome", mrb_file__gethome, MRB_ARGS_OPT(1));
+
+ mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, file, "mtime", mrb_file_mtime, MRB_ARGS_NONE());
+
+ cnst = mrb_define_module_under(mrb, file, "Constants");
+ mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));
+ mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX));
+ mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN));
+ mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB));
+ mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR));
+ mrb_define_const(mrb, cnst, "PATH_SEPARATOR", mrb_str_new_cstr(mrb, PATH_SEPARATOR));
+#if defined(_WIN32) || defined(_WIN64)
+ mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
+#else
+ mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value());
+#endif
+ mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE));
+
+}
diff --git a/mrbgems/mruby-io/src/file_test.c b/mrbgems/mruby-io/src/file_test.c
new file mode 100644
index 000000000..e429b06b3
--- /dev/null
+++ b/mrbgems/mruby-io/src/file_test.c
@@ -0,0 +1,381 @@
+/*
+** file.c - File class
+*/
+
+#include "mruby.h"
+#include "mruby/class.h"
+#include "mruby/data.h"
+#include "mruby/string.h"
+#include "mruby/ext/io.h"
+
+#if MRUBY_RELEASE_NO < 10000
+#include "error.h"
+#else
+#include "mruby/error.h"
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#if defined(_WIN32) || defined(_WIN64)
+ #define LSTAT stat
+ #include <winsock.h>
+#else
+ #define LSTAT lstat
+ #include <sys/file.h>
+ #include <sys/param.h>
+ #include <sys/wait.h>
+ #include <libgen.h>
+ #include <pwd.h>
+ #include <unistd.h>
+#endif
+
+#include <fcntl.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern struct mrb_data_type mrb_io_type;
+
+static int
+mrb_stat0(mrb_state *mrb, mrb_value obj, struct stat *st, int do_lstat)
+{
+ mrb_value tmp;
+ mrb_value io_klass, str_klass;
+
+ io_klass = mrb_obj_value(mrb_class_get(mrb, "IO"));
+ str_klass = mrb_obj_value(mrb_class_get(mrb, "String"));
+
+ tmp = mrb_funcall(mrb, obj, "is_a?", 1, io_klass);
+ if (mrb_test(tmp)) {
+ struct mrb_io *fptr;
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, obj, &mrb_io_type);
+
+ if (fptr && fptr->fd >= 0) {
+ return fstat(fptr->fd, st);
+ }
+
+ mrb_raise(mrb, E_IO_ERROR, "closed stream");
+ return -1;
+ }
+
+ tmp = mrb_funcall(mrb, obj, "is_a?", 1, str_klass);
+ if (mrb_test(tmp)) {
+ char *path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, obj), -1);
+ int ret;
+ if (do_lstat) {
+ ret = LSTAT(path, st);
+ } else {
+ ret = stat(path, st);
+ }
+ mrb_locale_free(path);
+ return ret;
+ }
+
+ return -1;
+}
+
+static int
+mrb_stat(mrb_state *mrb, mrb_value obj, struct stat *st)
+{
+ return mrb_stat0(mrb, obj, st, 0);
+}
+
+static int
+mrb_lstat(mrb_state *mrb, mrb_value obj, struct stat *st)
+{
+ return mrb_stat0(mrb, obj, st, 1);
+}
+
+/*
+ * Document-method: directory?
+ *
+ * call-seq:
+ * File.directory?(file_name) -> true or false
+ *
+ * Returns <code>true</code> if the named file is a directory,
+ * or a symlink that points at a directory, and <code>false</code>
+ * otherwise.
+ *
+ * File.directory?(".")
+ */
+
+mrb_value
+mrb_filetest_s_directory_p(mrb_state *mrb, mrb_value klass)
+{
+#ifndef S_ISDIR
+# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#endif
+
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+
+ if (mrb_stat(mrb, obj, &st) < 0)
+ return mrb_false_value();
+ if (S_ISDIR(st.st_mode))
+ return mrb_true_value();
+
+ return mrb_false_value();
+}
+
+/*
+ * call-seq:
+ * File.pipe?(file_name) -> true or false
+ *
+ * Returns <code>true</code> if the named file is a pipe.
+ */
+
+mrb_value
+mrb_filetest_s_pipe_p(mrb_state *mrb, mrb_value klass)
+{
+#if defined(_WIN32) || defined(_WIN64)
+ mrb_raise(mrb, E_NOTIMP_ERROR, "pipe is not supported on this platform");
+#else
+#ifdef S_IFIFO
+# ifndef S_ISFIFO
+# define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
+# endif
+
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+
+ if (mrb_stat(mrb, obj, &st) < 0)
+ return mrb_false_value();
+ if (S_ISFIFO(st.st_mode))
+ return mrb_true_value();
+
+#endif
+ return mrb_false_value();
+#endif
+}
+
+/*
+ * call-seq:
+ * File.symlink?(file_name) -> true or false
+ *
+ * Returns <code>true</code> if the named file is a symbolic link.
+ */
+
+mrb_value
+mrb_filetest_s_symlink_p(mrb_state *mrb, mrb_value klass)
+{
+#if defined(_WIN32) || defined(_WIN64)
+ mrb_raise(mrb, E_NOTIMP_ERROR, "symlink is not supported on this platform");
+#else
+#ifndef S_ISLNK
+# ifdef _S_ISLNK
+# define S_ISLNK(m) _S_ISLNK(m)
+# else
+# ifdef _S_IFLNK
+# define S_ISLNK(m) (((m) & S_IFMT) == _S_IFLNK)
+# else
+# ifdef S_IFLNK
+# define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
+# endif
+# endif
+# endif
+#endif
+
+#ifdef S_ISLNK
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+
+ if (mrb_lstat(mrb, obj, &st) == -1)
+ return mrb_false_value();
+ if (S_ISLNK(st.st_mode))
+ return mrb_true_value();
+#endif
+
+ return mrb_false_value();
+#endif
+}
+
+/*
+ * call-seq:
+ * File.socket?(file_name) -> true or false
+ *
+ * Returns <code>true</code> if the named file is a socket.
+ */
+
+mrb_value
+mrb_filetest_s_socket_p(mrb_state *mrb, mrb_value klass)
+{
+#if defined(_WIN32) || defined(_WIN64)
+ mrb_raise(mrb, E_NOTIMP_ERROR, "socket is not supported on this platform");
+#else
+#ifndef S_ISSOCK
+# ifdef _S_ISSOCK
+# define S_ISSOCK(m) _S_ISSOCK(m)
+# else
+# ifdef _S_IFSOCK
+# define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)
+# else
+# ifdef S_IFSOCK
+# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
+# endif
+# endif
+# endif
+#endif
+
+#ifdef S_ISSOCK
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+
+ if (mrb_stat(mrb, obj, &st) < 0)
+ return mrb_false_value();
+ if (S_ISSOCK(st.st_mode))
+ return mrb_true_value();
+#endif
+
+ return mrb_false_value();
+#endif
+}
+
+/*
+ * call-seq:
+ * File.exist?(file_name) -> true or false
+ * File.exists?(file_name) -> true or false
+ *
+ * Return <code>true</code> if the named file exists.
+ */
+
+mrb_value
+mrb_filetest_s_exist_p(mrb_state *mrb, mrb_value klass)
+{
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+ if (mrb_stat(mrb, obj, &st) < 0)
+ return mrb_false_value();
+
+ return mrb_true_value();
+}
+
+/*
+ * call-seq:
+ * File.file?(file_name) -> true or false
+ *
+ * Returns <code>true</code> if the named file exists and is a
+ * regular file.
+ */
+
+mrb_value
+mrb_filetest_s_file_p(mrb_state *mrb, mrb_value klass)
+{
+#ifndef S_ISREG
+# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#endif
+
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+
+ if (mrb_stat(mrb, obj, &st) < 0)
+ return mrb_false_value();
+ if (S_ISREG(st.st_mode))
+ return mrb_true_value();
+
+ return mrb_false_value();
+}
+
+/*
+ * call-seq:
+ * File.zero?(file_name) -> true or false
+ *
+ * Returns <code>true</code> if the named file exists and has
+ * a zero size.
+ */
+
+mrb_value
+mrb_filetest_s_zero_p(mrb_state *mrb, mrb_value klass)
+{
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+
+ if (mrb_stat(mrb, obj, &st) < 0)
+ return mrb_false_value();
+ if (st.st_size == 0)
+ return mrb_true_value();
+
+ return mrb_false_value();
+}
+
+/*
+ * call-seq:
+ * File.size(file_name) -> integer
+ *
+ * Returns the size of <code>file_name</code>.
+ *
+ * _file_name_ can be an IO object.
+ */
+
+mrb_value
+mrb_filetest_s_size(mrb_state *mrb, mrb_value klass)
+{
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+
+ if (mrb_stat(mrb, obj, &st) < 0)
+ mrb_sys_fail(mrb, "mrb_stat");
+
+ return mrb_fixnum_value(st.st_size);
+}
+
+/*
+ * call-seq:
+ * File.size?(file_name) -> Integer or nil
+ *
+ * Returns +nil+ if +file_name+ doesn't exist or has zero size, the size of the
+ * file otherwise.
+ */
+
+mrb_value
+mrb_filetest_s_size_p(mrb_state *mrb, mrb_value klass)
+{
+ struct stat st;
+ mrb_value obj;
+
+ mrb_get_args(mrb, "o", &obj);
+
+ if (mrb_stat(mrb, obj, &st) < 0)
+ return mrb_nil_value();
+ if (st.st_size == 0)
+ return mrb_nil_value();
+
+ return mrb_fixnum_value(st.st_size);
+}
+
+void
+mrb_init_file_test(mrb_state *mrb)
+{
+ struct RClass *f;
+
+ f = mrb_define_class(mrb, "FileTest", mrb->object_class);
+
+ mrb_define_class_method(mrb, f, "directory?", mrb_filetest_s_directory_p, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "exist?", mrb_filetest_s_exist_p, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "exists?", mrb_filetest_s_exist_p, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "file?", mrb_filetest_s_file_p, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "pipe?", mrb_filetest_s_pipe_p, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "size", mrb_filetest_s_size, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "size?", mrb_filetest_s_size_p, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "socket?", mrb_filetest_s_socket_p, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "symlink?", mrb_filetest_s_symlink_p, MRB_ARGS_REQ(1));
+ mrb_define_class_method(mrb, f, "zero?", mrb_filetest_s_zero_p, MRB_ARGS_REQ(1));
+}
diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c
new file mode 100644
index 000000000..58bcdd1ee
--- /dev/null
+++ b/mrbgems/mruby-io/src/io.c
@@ -0,0 +1,1328 @@
+/*
+** io.c - IO class
+*/
+
+#include "mruby.h"
+#include "mruby/array.h"
+#include "mruby/class.h"
+#include "mruby/data.h"
+#include "mruby/hash.h"
+#include "mruby/string.h"
+#include "mruby/variable.h"
+#include "mruby/ext/io.h"
+
+#if MRUBY_RELEASE_NO < 10000
+#include "error.h"
+#else
+#include "mruby/error.h"
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#if defined(_WIN32) || defined(_WIN64)
+ #include <winsock.h>
+ #include <io.h>
+ #define open _open
+ #define close _close
+ #define dup _dup
+ #define dup2 _dup2
+ #define read _read
+ #define write _write
+ #define lseek _lseek
+ #define isatty _isatty
+ #define WEXITSTATUS(x) (x)
+ typedef int fsize_t;
+ typedef long ftime_t;
+ typedef long fsuseconds_t;
+ typedef int fmode_t;
+
+#else
+ #include <sys/wait.h>
+ #include <unistd.h>
+ typedef size_t fsize_t;
+ typedef time_t ftime_t;
+ typedef suseconds_t fsuseconds_t;
+ typedef mode_t fmode_t;
+#endif
+
+#ifdef _MSC_VER
+typedef mrb_int pid_t;
+#endif
+
+#include <fcntl.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+
+static void mrb_io_free(mrb_state *mrb, void *ptr);
+struct mrb_data_type mrb_io_type = { "IO", mrb_io_free };
+
+
+static struct mrb_io *io_get_open_fptr(mrb_state *mrb, mrb_value self);
+static int mrb_io_modestr_to_flags(mrb_state *mrb, const char *modestr);
+static int mrb_io_flags_to_modenum(mrb_state *mrb, int flags);
+static void fptr_finalize(mrb_state *mrb, struct mrb_io *fptr, int quiet);
+
+#if MRUBY_RELEASE_NO < 10000
+static struct RClass *
+mrb_module_get(mrb_state *mrb, const char *name)
+{
+ return mrb_class_get(mrb, name);
+}
+#endif
+
+static struct mrb_io *
+io_get_open_fptr(mrb_state *mrb, mrb_value self)
+{
+ struct mrb_io *fptr;
+
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, self, &mrb_io_type);
+ if (fptr->fd < 0) {
+ mrb_raise(mrb, E_IO_ERROR, "closed stream.");
+ }
+ return fptr;
+}
+
+static void
+io_set_process_status(mrb_state *mrb, pid_t pid, int status)
+{
+ struct RClass *c_process, *c_status;
+ mrb_value v;
+
+ c_status = NULL;
+ if (mrb_class_defined(mrb, "Process")) {
+ c_process = mrb_module_get(mrb, "Process");
+ if (mrb_const_defined(mrb, mrb_obj_value(c_process), mrb_intern_cstr(mrb, "Status"))) {
+ c_status = mrb_class_get_under(mrb, c_process, "Status");
+ }
+ }
+ if (c_status != NULL) {
+ v = mrb_funcall(mrb, mrb_obj_value(c_status), "new", 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
+ } else {
+ v = mrb_fixnum_value(WEXITSTATUS(status));
+ }
+ mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$?"), v);
+}
+
+static int
+mrb_io_modestr_to_flags(mrb_state *mrb, const char *mode)
+{
+ int flags = 0;
+ const char *m = mode;
+
+ switch (*m++) {
+ case 'r':
+ flags |= FMODE_READABLE;
+ break;
+ case 'w':
+ flags |= FMODE_WRITABLE | FMODE_CREATE | FMODE_TRUNC;
+ break;
+ case 'a':
+ flags |= FMODE_WRITABLE | FMODE_APPEND | FMODE_CREATE;
+ break;
+ default:
+ mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %S", mrb_str_new_cstr(mrb, mode));
+ }
+
+ while (*m) {
+ switch (*m++) {
+ case 'b':
+ flags |= FMODE_BINMODE;
+ break;
+ case '+':
+ flags |= FMODE_READWRITE;
+ break;
+ case ':':
+ /* XXX: PASSTHROUGH*/
+ default:
+ mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %S", mrb_str_new_cstr(mrb, mode));
+ }
+ }
+
+ return flags;
+}
+
+static int
+mrb_io_flags_to_modenum(mrb_state *mrb, int flags)
+{
+ int modenum = 0;
+
+ switch(flags & (FMODE_READABLE|FMODE_WRITABLE|FMODE_READWRITE)) {
+ case FMODE_READABLE:
+ modenum = O_RDONLY;
+ break;
+ case FMODE_WRITABLE:
+ modenum = O_WRONLY;
+ break;
+ case FMODE_READWRITE:
+ modenum = O_RDWR;
+ break;
+ }
+
+ if (flags & FMODE_APPEND) {
+ modenum |= O_APPEND;
+ }
+ if (flags & FMODE_TRUNC) {
+ modenum |= O_TRUNC;
+ }
+ if (flags & FMODE_CREATE) {
+ modenum |= O_CREAT;
+ }
+#ifdef O_BINARY
+ if (flags & FMODE_BINMODE) {
+ modenum |= O_BINARY;
+ }
+#endif
+
+ return modenum;
+}
+
+static void
+mrb_fd_cloexec(mrb_state *mrb, int fd)
+{
+#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
+ int flags, flags2;
+
+ flags = fcntl(fd, F_GETFD);
+ if (flags == -1) {
+ mrb_bug(mrb, "mrb_fd_cloexec: fcntl(%S, F_GETFD) failed: %S",
+ mrb_fixnum_value(fd), mrb_fixnum_value(errno));
+ }
+ if (fd <= 2) {
+ flags2 = flags & ~FD_CLOEXEC; /* Clear CLOEXEC for standard file descriptors: 0, 1, 2. */
+ }
+ else {
+ flags2 = flags | FD_CLOEXEC; /* Set CLOEXEC for non-standard file descriptors: 3, 4, 5, ... */
+ }
+ if (flags != flags2) {
+ if (fcntl(fd, F_SETFD, flags2) == -1) {
+ mrb_bug(mrb, "mrb_fd_cloexec: fcntl(%S, F_SETFD, %S) failed: %S",
+ mrb_fixnum_value(fd), mrb_fixnum_value(flags2), mrb_fixnum_value(errno));
+ }
+ }
+#endif
+}
+
+#ifndef _WIN32
+static int
+mrb_cloexec_pipe(mrb_state *mrb, int fildes[2])
+{
+ int ret;
+ ret = pipe(fildes);
+ if (ret == -1)
+ return -1;
+ mrb_fd_cloexec(mrb, fildes[0]);
+ mrb_fd_cloexec(mrb, fildes[1]);
+ return ret;
+}
+
+static int
+mrb_pipe(mrb_state *mrb, int pipes[2])
+{
+ int ret;
+ ret = mrb_cloexec_pipe(mrb, pipes);
+ if (ret == -1) {
+ if (errno == EMFILE || errno == ENFILE) {
+ mrb_garbage_collect(mrb);
+ ret = mrb_cloexec_pipe(mrb, pipes);
+ }
+ }
+ return ret;
+}
+
+static int
+mrb_proc_exec(const char *pname)
+{
+ const char *s;
+ s = pname;
+
+ while (*s == ' ' || *s == '\t' || *s == '\n')
+ s++;
+
+ if (!*s) {
+ errno = ENOENT;
+ return -1;
+ }
+
+ execl("/bin/sh", "sh", "-c", pname, (char *)NULL);
+ return -1;
+}
+#endif
+
+static void
+mrb_io_free(mrb_state *mrb, void *ptr)
+{
+ struct mrb_io *io = (struct mrb_io *)ptr;
+ if (io != NULL) {
+ fptr_finalize(mrb, io, TRUE);
+ mrb_free(mrb, io);
+ }
+}
+
+static struct mrb_io *
+mrb_io_alloc(mrb_state *mrb)
+{
+ struct mrb_io *fptr;
+
+ fptr = (struct mrb_io *)mrb_malloc(mrb, sizeof(struct mrb_io));
+ fptr->fd = -1;
+ fptr->fd2 = -1;
+ fptr->pid = 0;
+ fptr->readable = 0;
+ fptr->writable = 0;
+ fptr->sync = 0;
+ fptr->is_socket = 0;
+ return fptr;
+}
+
+#ifndef NOFILE
+#define NOFILE 64
+#endif
+
+static int
+option_to_fd(mrb_state *mrb, mrb_value obj, const char *key)
+{
+ mrb_value opt = mrb_funcall(mrb, obj, "[]", 1, mrb_symbol_value(mrb_intern_static(mrb, key, strlen(key))));
+ if (mrb_nil_p(opt)) {
+ return -1;
+ }
+
+ switch (mrb_type(opt)) {
+ case MRB_TT_DATA: /* IO */
+ return (int)mrb_fixnum(mrb_io_fileno(mrb, opt));
+ case MRB_TT_FIXNUM:
+ return (int)mrb_fixnum(opt);
+ default:
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
+ break;
+ }
+ return -1; /* never reached */
+}
+
+#ifndef _WIN32
+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;
+ int opt_in, opt_out, opt_err;
+
+ 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");
+
+ if (flags & FMODE_READABLE) {
+ if (pipe(pr) == -1) {
+ mrb_sys_fail(mrb, "pipe");
+ }
+ mrb_fd_cloexec(mrb, pr[0]);
+ mrb_fd_cloexec(mrb, pr[1]);
+ }
+
+ if (flags & FMODE_WRITABLE) {
+ if (pipe(pw) == -1) {
+ if (pr[0] != -1) close(pr[0]);
+ if (pr[1] != -1) close(pr[1]);
+ mrb_sys_fail(mrb, "pipe");
+ }
+ mrb_fd_cloexec(mrb, pw[0]);
+ mrb_fd_cloexec(mrb, pw[1]);
+ }
+
+ if (!doexec) {
+ // XXX
+ fflush(stdin);
+ fflush(stdout);
+ fflush(stderr);
+ }
+
+ result = mrb_nil_value();
+ switch (pid = fork()) {
+ case 0: /* child */
+ if (opt_in != -1) {
+ dup2(opt_in, 0);
+ }
+ if (opt_out != -1) {
+ dup2(opt_out, 1);
+ }
+ if (opt_err != -1) {
+ dup2(opt_err, 2);
+ }
+ 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, ""));
+
+ fptr = mrb_io_alloc(mrb);
+ fptr->fd = fd;
+ fptr->fd2 = write_fd;
+ 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;
+ 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;
+}
+#else
+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;
+}
+#endif
+
+static int
+mrb_dup(mrb_state *mrb, int fd, mrb_bool *failed)
+{
+ int new_fd;
+
+ *failed = FALSE;
+ if (fd < 0)
+ return fd;
+
+ new_fd = dup(fd);
+ if (new_fd == -1) *failed = TRUE;
+ return new_fd;
+}
+
+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_copy = (struct mrb_io *)DATA_PTR(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);
+ fptr_orig = io_get_open_fptr(mrb, orig);
+
+ 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;
+}
+
+mrb_value
+mrb_io_initialize(mrb_state *mrb, mrb_value io)
+{
+ struct mrb_io *fptr;
+ mrb_int fd;
+ mrb_value mode, opt;
+ int flags;
+
+ mode = opt = mrb_nil_value();
+
+ mrb_get_args(mrb, "i|So", &fd, &mode, &opt);
+ if (mrb_nil_p(mode)) {
+ mode = mrb_str_new_cstr(mrb, "r");
+ }
+ if (mrb_nil_p(opt)) {
+ opt = mrb_hash_new(mrb);
+ }
+
+ flags = mrb_io_modestr_to_flags(mrb, mrb_string_value_cstr(mrb, &mode));
+
+ mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
+
+ fptr = (struct mrb_io *)DATA_PTR(io);
+ if (fptr != NULL) {
+ fptr_finalize(mrb, fptr, TRUE);
+ mrb_free(mrb, fptr);
+ }
+ fptr = mrb_io_alloc(mrb);
+
+ DATA_TYPE(io) = &mrb_io_type;
+ DATA_PTR(io) = fptr;
+
+ fptr->fd = (int)fd;
+ fptr->readable = ((flags & FMODE_READABLE) != 0);
+ fptr->writable = ((flags & FMODE_WRITABLE) != 0);
+ fptr->sync = 0;
+ return io;
+}
+
+static void
+fptr_finalize(mrb_state *mrb, struct mrb_io *fptr, int quiet)
+{
+ int saved_errno = 0;
+
+ if (fptr == NULL) {
+ return;
+ }
+
+ if (fptr->fd > 2) {
+#ifdef _WIN32
+ if (fptr->is_socket) {
+ if (closesocket(fptr->fd) != 0) {
+ saved_errno = WSAGetLastError();
+ }
+ fptr->fd = -1;
+ }
+#endif
+ if (fptr->fd != -1) {
+ if (close(fptr->fd) == -1) {
+ saved_errno = errno;
+ }
+ }
+ fptr->fd = -1;
+ }
+
+ if (fptr->fd2 > 2) {
+ if (close(fptr->fd2) == -1) {
+ if (saved_errno == 0) {
+ saved_errno = errno;
+ }
+ }
+ fptr->fd2 = -1;
+ }
+
+ if (fptr->pid != 0) {
+#if !defined(_WIN32) && !defined(_WIN64)
+ pid_t pid;
+ int status;
+ do {
+ pid = waitpid(fptr->pid, &status, 0);
+ } while (pid == -1 && errno == EINTR);
+ if (!quiet && pid == fptr->pid) {
+ io_set_process_status(mrb, pid, status);
+ }
+#else
+ HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, fptr->pid);
+ DWORD status;
+ if (WaitForSingleObject(h, INFINITE) && GetExitCodeProcess(h, &status))
+ if (!quiet)
+ io_set_process_status(mrb, fptr->pid, (int)status);
+ CloseHandle(h);
+#endif
+ fptr->pid = 0;
+ /* Note: we don't raise an exception when waitpid(3) fails */
+ }
+
+ if (!quiet && saved_errno != 0) {
+ errno = saved_errno;
+ mrb_sys_fail(mrb, "fptr_finalize failed.");
+ }
+}
+
+mrb_value
+mrb_io_check_readable(mrb_state *mrb, mrb_value self)
+{
+ struct mrb_io *fptr = io_get_open_fptr(mrb, self);
+ if (! fptr->readable) {
+ mrb_raise(mrb, E_IO_ERROR, "not opened for reading");
+ }
+ return mrb_nil_value();
+}
+
+mrb_value
+mrb_io_isatty(mrb_state *mrb, mrb_value self)
+{
+ struct mrb_io *fptr;
+
+ fptr = io_get_open_fptr(mrb, self);
+ if (isatty(fptr->fd) == 0)
+ return mrb_false_value();
+ return mrb_true_value();
+}
+
+mrb_value
+mrb_io_s_for_fd(mrb_state *mrb, mrb_value klass)
+{
+ struct RClass *c = mrb_class_ptr(klass);
+ enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
+ mrb_value obj;
+
+ /* copied from mrb_instance_alloc() */
+ if (ttype == 0) ttype = MRB_TT_OBJECT;
+ obj = mrb_obj_value((struct RObject*)mrb_obj_alloc(mrb, ttype, c));
+ return mrb_io_initialize(mrb, obj);
+}
+
+mrb_value
+mrb_io_s_sysclose(mrb_state *mrb, mrb_value klass)
+{
+ mrb_int fd;
+ mrb_get_args(mrb, "i", &fd);
+ if (close((int)fd) == -1) {
+ mrb_sys_fail(mrb, "close");
+ }
+ return mrb_fixnum_value(0);
+}
+
+int
+mrb_cloexec_open(mrb_state *mrb, const char *pathname, mrb_int flags, mrb_int mode)
+{
+ mrb_value emsg;
+ int fd, retry = FALSE;
+ char* fname = mrb_locale_from_utf8(pathname, -1);
+
+#ifdef O_CLOEXEC
+ /* O_CLOEXEC is available since Linux 2.6.23. Linux 2.6.18 silently ignore it. */
+ flags |= O_CLOEXEC;
+#elif defined O_NOINHERIT
+ flags |= O_NOINHERIT;
+#endif
+reopen:
+ fd = open(fname, (int)flags, (fmode_t)mode);
+ if (fd == -1) {
+ if (!retry) {
+ switch (errno) {
+ case ENFILE:
+ case EMFILE:
+ mrb_garbage_collect(mrb);
+ retry = TRUE;
+ goto reopen;
+ }
+ }
+
+ emsg = mrb_format(mrb, "open %S", mrb_str_new_cstr(mrb, pathname));
+ mrb_str_modify(mrb, mrb_str_ptr(emsg));
+ mrb_sys_fail(mrb, RSTRING_PTR(emsg));
+ }
+ mrb_utf8_free(fname);
+
+ if (fd <= 2) {
+ mrb_fd_cloexec(mrb, fd);
+ }
+ return fd;
+}
+
+mrb_value
+mrb_io_s_sysopen(mrb_state *mrb, mrb_value klass)
+{
+ mrb_value path = mrb_nil_value();
+ mrb_value mode = mrb_nil_value();
+ mrb_int fd, perm = -1;
+ const char *pat;
+ int flags, modenum;
+
+ mrb_get_args(mrb, "S|Si", &path, &mode, &perm);
+ if (mrb_nil_p(mode)) {
+ mode = mrb_str_new_cstr(mrb, "r");
+ }
+ if (perm < 0) {
+ perm = 0666;
+ }
+
+ pat = mrb_string_value_cstr(mrb, &path);
+ flags = mrb_io_modestr_to_flags(mrb, mrb_string_value_cstr(mrb, &mode));
+ modenum = mrb_io_flags_to_modenum(mrb, flags);
+ fd = mrb_cloexec_open(mrb, pat, modenum, perm);
+ return mrb_fixnum_value(fd);
+}
+
+mrb_value
+mrb_io_sysread(mrb_state *mrb, mrb_value io)
+{
+ struct mrb_io *fptr;
+ mrb_value buf = mrb_nil_value();
+ mrb_int maxlen;
+ int ret;
+
+ mrb_get_args(mrb, "i|S", &maxlen, &buf);
+ if (maxlen < 0) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "negative expanding string size");
+ }
+ else if (maxlen == 0) {
+ return mrb_str_new(mrb, NULL, maxlen);
+ }
+
+ if (mrb_nil_p(buf)) {
+ buf = mrb_str_new(mrb, NULL, maxlen);
+ }
+
+ if (RSTRING_LEN(buf) != maxlen) {
+ buf = mrb_str_resize(mrb, buf, maxlen);
+ } else {
+ mrb_str_modify(mrb, RSTRING(buf));
+ }
+
+ fptr = (struct mrb_io *)io_get_open_fptr(mrb, io);
+ if (!fptr->readable) {
+ mrb_raise(mrb, E_IO_ERROR, "not opened for reading");
+ }
+ ret = read(fptr->fd, RSTRING_PTR(buf), (fsize_t)maxlen);
+ switch (ret) {
+ case 0: /* EOF */
+ if (maxlen == 0) {
+ buf = mrb_str_new_cstr(mrb, "");
+ } else {
+ mrb_raise(mrb, E_EOF_ERROR, "sysread failed: End of File");
+ }
+ break;
+ case -1: /* Error */
+ mrb_sys_fail(mrb, "sysread failed");
+ break;
+ default:
+ if (RSTRING_LEN(buf) != ret) {
+ buf = mrb_str_resize(mrb, buf, ret);
+ }
+ break;
+ }
+
+ return buf;
+}
+
+mrb_value
+mrb_io_sysseek(mrb_state *mrb, mrb_value io)
+{
+ struct mrb_io *fptr;
+ off_t pos;
+ mrb_int offset, whence = -1;
+
+ mrb_get_args(mrb, "i|i", &offset, &whence);
+ if (whence < 0) {
+ whence = 0;
+ }
+
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
+ pos = lseek(fptr->fd, (off_t)offset, (int)whence);
+ if (pos == -1) {
+ mrb_sys_fail(mrb, "sysseek");
+ }
+ if (pos > MRB_INT_MAX) {
+#ifndef MRB_WITHOUT_FLOAT
+ return mrb_float_value(mrb, (mrb_float)pos);
+#else
+ mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_WITHOUT_FLOAT");
+#endif
+ } else {
+ return mrb_fixnum_value(pos);
+ }
+}
+
+mrb_value
+mrb_io_syswrite(mrb_state *mrb, mrb_value io)
+{
+ struct mrb_io *fptr;
+ mrb_value str, buf;
+ int fd, length;
+
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
+ if (! fptr->writable) {
+ mrb_raise(mrb, E_IO_ERROR, "not opened for writing");
+ }
+
+ mrb_get_args(mrb, "S", &str);
+ if (mrb_type(str) != MRB_TT_STRING) {
+ buf = mrb_funcall(mrb, str, "to_s", 0);
+ } else {
+ buf = str;
+ }
+
+ if (fptr->fd2 == -1) {
+ fd = fptr->fd;
+ } else {
+ fd = fptr->fd2;
+ }
+ length = write(fd, RSTRING_PTR(buf), (fsize_t)RSTRING_LEN(buf));
+ if (length == -1) {
+ mrb_sys_fail(mrb, 0);
+ }
+
+ return mrb_fixnum_value(length);
+}
+
+mrb_value
+mrb_io_close(mrb_state *mrb, mrb_value self)
+{
+ struct mrb_io *fptr;
+ fptr = io_get_open_fptr(mrb, self);
+ fptr_finalize(mrb, fptr, FALSE);
+ return mrb_nil_value();
+}
+
+mrb_value
+mrb_io_close_write(mrb_state *mrb, mrb_value self)
+{
+ struct mrb_io *fptr;
+ fptr = io_get_open_fptr(mrb, self);
+ if (close((int)fptr->fd2) == -1) {
+ mrb_sys_fail(mrb, "close");
+ }
+ return mrb_nil_value();
+}
+
+mrb_value
+mrb_io_closed(mrb_state *mrb, mrb_value io)
+{
+ struct mrb_io *fptr;
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
+ if (fptr->fd >= 0) {
+ return mrb_false_value();
+ }
+
+ return mrb_true_value();
+}
+
+mrb_value
+mrb_io_pid(mrb_state *mrb, mrb_value io)
+{
+ struct mrb_io *fptr;
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
+
+ if (fptr->pid > 0) {
+ return mrb_fixnum_value(fptr->pid);
+ }
+
+ return mrb_nil_value();
+}
+
+static struct timeval
+time2timeval(mrb_state *mrb, mrb_value time)
+{
+ struct timeval t = { 0, 0 };
+
+ switch (mrb_type(time)) {
+ case MRB_TT_FIXNUM:
+ t.tv_sec = (ftime_t)mrb_fixnum(time);
+ t.tv_usec = 0;
+ break;
+
+#ifndef MRB_WITHOUT_FLOAT
+ case MRB_TT_FLOAT:
+ t.tv_sec = (ftime_t)mrb_float(time);
+ t.tv_usec = (fsuseconds_t)((mrb_float(time) - t.tv_sec) * 1000000.0);
+ break;
+#endif
+
+ default:
+ mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
+ }
+
+ return t;
+}
+
+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;
+}
+
+#ifndef _WIN32
+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);
+}
+#endif
+
+static mrb_value
+mrb_io_s_select(mrb_state *mrb, mrb_value klass)
+{
+ mrb_value *argv;
+ mrb_int argc;
+ mrb_value read, read_io, write, except, timeout, list;
+ struct timeval *tp, timerec;
+ fd_set pset, rset, wset, eset;
+ fd_set *rp, *wp, *ep;
+ struct mrb_io *fptr;
+ int pending = 0;
+ mrb_value result;
+ int max = 0;
+ int interrupt_flag = 0;
+ int i, n;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+
+ if (argc < 1 || argc > 4) {
+ mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 1..4)", mrb_fixnum_value(argc));
+ }
+
+ timeout = mrb_nil_value();
+ except = mrb_nil_value();
+ write = mrb_nil_value();
+ if (argc > 3)
+ timeout = argv[3];
+ if (argc > 2)
+ except = argv[2];
+ if (argc > 1)
+ write = argv[1];
+ read = argv[0];
+
+ if (mrb_nil_p(timeout)) {
+ tp = NULL;
+ } else {
+ timerec = time2timeval(mrb, timeout);
+ tp = &timerec;
+ }
+
+ FD_ZERO(&pset);
+ if (!mrb_nil_p(read)) {
+ mrb_check_type(mrb, read, MRB_TT_ARRAY);
+ rp = &rset;
+ FD_ZERO(rp);
+ for (i = 0; i < RARRAY_LEN(read); i++) {
+ read_io = RARRAY_PTR(read)[i];
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, read_io, &mrb_io_type);
+ FD_SET(fptr->fd, rp);
+ if (mrb_io_read_data_pending(mrb, read_io)) {
+ pending++;
+ FD_SET(fptr->fd, &pset);
+ }
+ if (max < fptr->fd)
+ max = fptr->fd;
+ }
+ if (pending) {
+ timerec.tv_sec = timerec.tv_usec = 0;
+ tp = &timerec;
+ }
+ } else {
+ rp = NULL;
+ }
+
+ if (!mrb_nil_p(write)) {
+ mrb_check_type(mrb, write, MRB_TT_ARRAY);
+ wp = &wset;
+ FD_ZERO(wp);
+ for (i = 0; i < RARRAY_LEN(write); i++) {
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(write)[i], &mrb_io_type);
+ FD_SET(fptr->fd, wp);
+ if (max < fptr->fd)
+ max = fptr->fd;
+ if (fptr->fd2 >= 0) {
+ FD_SET(fptr->fd2, wp);
+ if (max < fptr->fd2)
+ max = fptr->fd2;
+ }
+ }
+ } else {
+ wp = NULL;
+ }
+
+ if (!mrb_nil_p(except)) {
+ mrb_check_type(mrb, except, MRB_TT_ARRAY);
+ ep = &eset;
+ FD_ZERO(ep);
+ for (i = 0; i < RARRAY_LEN(except); i++) {
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(except)[i], &mrb_io_type);
+ FD_SET(fptr->fd, ep);
+ if (max < fptr->fd)
+ max = fptr->fd;
+ if (fptr->fd2 >= 0) {
+ FD_SET(fptr->fd2, ep);
+ if (max < fptr->fd2)
+ max = fptr->fd2;
+ }
+ }
+ } else {
+ ep = NULL;
+ }
+
+ max++;
+
+retry:
+ n = select(max, rp, wp, ep, tp);
+ if (n < 0) {
+ if (errno != EINTR)
+ mrb_sys_fail(mrb, "select failed");
+ if (tp == NULL)
+ goto retry;
+ interrupt_flag = 1;
+ }
+
+ if (!pending && n == 0)
+ return mrb_nil_value();
+
+ result = mrb_ary_new_capa(mrb, 3);
+ mrb_ary_push(mrb, result, rp? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
+ mrb_ary_push(mrb, result, wp? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
+ mrb_ary_push(mrb, result, ep? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
+
+ if (interrupt_flag == 0) {
+ if (rp) {
+ list = RARRAY_PTR(result)[0];
+ for (i = 0; i < RARRAY_LEN(read); i++) {
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(read)[i], &mrb_io_type);
+ if (FD_ISSET(fptr->fd, rp) ||
+ FD_ISSET(fptr->fd, &pset)) {
+ mrb_ary_push(mrb, list, RARRAY_PTR(read)[i]);
+ }
+ }
+ }
+
+ if (wp) {
+ list = RARRAY_PTR(result)[1];
+ for (i = 0; i < RARRAY_LEN(write); i++) {
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(write)[i], &mrb_io_type);
+ if (FD_ISSET(fptr->fd, wp)) {
+ mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
+ } else if (fptr->fd2 >= 0 && FD_ISSET(fptr->fd2, wp)) {
+ mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
+ }
+ }
+ }
+
+ if (ep) {
+ list = RARRAY_PTR(result)[2];
+ for (i = 0; i < RARRAY_LEN(except); i++) {
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(except)[i], &mrb_io_type);
+ if (FD_ISSET(fptr->fd, ep)) {
+ mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
+ } else if (fptr->fd2 >= 0 && FD_ISSET(fptr->fd2, ep)) {
+ mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
+ }
+ }
+ }
+ }
+
+ return result;
+}
+
+mrb_value
+mrb_io_fileno(mrb_state *mrb, mrb_value io)
+{
+ struct mrb_io *fptr;
+ fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
+ return mrb_fixnum_value(fptr->fd);
+}
+
+mrb_value
+mrb_io_close_on_exec_p(mrb_state *mrb, mrb_value self)
+{
+#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
+ struct mrb_io *fptr;
+ int ret;
+
+ fptr = io_get_open_fptr(mrb, self);
+
+ if (fptr->fd2 >= 0) {
+ if ((ret = fcntl(fptr->fd2, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
+ if (!(ret & FD_CLOEXEC)) return mrb_false_value();
+ }
+
+ if ((ret = fcntl(fptr->fd, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
+ if (!(ret & FD_CLOEXEC)) return mrb_false_value();
+ return mrb_true_value();
+
+#else
+ mrb_raise(mrb, E_NOTIMP_ERROR, "IO#close_on_exec? is not supported on the platform");
+ return mrb_false_value();
+#endif
+}
+
+mrb_value
+mrb_io_set_close_on_exec(mrb_state *mrb, mrb_value self)
+{
+#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
+ struct mrb_io *fptr;
+ int flag, ret;
+ mrb_bool b;
+
+ fptr = io_get_open_fptr(mrb, self);
+ mrb_get_args(mrb, "b", &b);
+ flag = b ? FD_CLOEXEC : 0;
+
+ if (fptr->fd2 >= 0) {
+ if ((ret = fcntl(fptr->fd2, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
+ if ((ret & FD_CLOEXEC) != flag) {
+ ret = (ret & ~FD_CLOEXEC) | flag;
+ ret = fcntl(fptr->fd2, F_SETFD, ret);
+
+ if (ret == -1) mrb_sys_fail(mrb, "F_SETFD failed");
+ }
+ }
+
+ if ((ret = fcntl(fptr->fd, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
+ if ((ret & FD_CLOEXEC) != flag) {
+ ret = (ret & ~FD_CLOEXEC) | flag;
+ ret = fcntl(fptr->fd, F_SETFD, ret);
+ if (ret == -1) mrb_sys_fail(mrb, "F_SETFD failed");
+ }
+
+ return mrb_bool_value(b);
+#else
+ mrb_raise(mrb, E_NOTIMP_ERROR, "IO#close_on_exec= is not supported on the platform");
+ return mrb_nil_value();
+#endif
+}
+
+mrb_value
+mrb_io_set_sync(mrb_state *mrb, mrb_value self)
+{
+ struct mrb_io *fptr;
+ mrb_bool b;
+
+ fptr = io_get_open_fptr(mrb, self);
+ mrb_get_args(mrb, "b", &b);
+ fptr->sync = b;
+ return mrb_bool_value(b);
+}
+
+mrb_value
+mrb_io_sync(mrb_state *mrb, mrb_value self)
+{
+ struct mrb_io *fptr;
+ fptr = io_get_open_fptr(mrb, self);
+ return mrb_bool_value(fptr->sync);
+}
+
+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 */
+ 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));
+ mrb_define_class_method(mrb, io, "for_fd", mrb_io_s_for_fd, MRB_ARGS_ANY());
+ 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());
+#ifndef _WIN32
+ mrb_define_class_method(mrb, io, "_pipe", mrb_io_s_pipe, MRB_ARGS_NONE());
+#endif
+
+ mrb_define_method(mrb, io, "initialize", mrb_io_initialize, MRB_ARGS_ANY()); /* 15.2.20.5.21 (x)*/
+ mrb_define_method(mrb, io, "initialize_copy", mrb_io_initialize_copy, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, io, "_check_readable", mrb_io_check_readable, MRB_ARGS_NONE());
+ mrb_define_method(mrb, io, "isatty", mrb_io_isatty, MRB_ARGS_NONE());
+ 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_write", mrb_io_close_write, MRB_ARGS_NONE());
+ 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"));
+}
diff --git a/mrbgems/mruby-io/src/mruby_io_gem.c b/mrbgems/mruby-io/src/mruby_io_gem.c
new file mode 100644
index 000000000..6880e6678
--- /dev/null
+++ b/mrbgems/mruby-io/src/mruby_io_gem.c
@@ -0,0 +1,20 @@
+#include "mruby.h"
+
+void mrb_init_io(mrb_state *mrb);
+void mrb_init_file(mrb_state *mrb);
+void mrb_init_file_test(mrb_state *mrb);
+
+#define DONE mrb_gc_arena_restore(mrb, 0)
+
+void
+mrb_mruby_io_gem_init(mrb_state* mrb)
+{
+ mrb_init_io(mrb); DONE;
+ mrb_init_file(mrb); DONE;
+ mrb_init_file_test(mrb); DONE;
+}
+
+void
+mrb_mruby_io_gem_final(mrb_state* mrb)
+{
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-28 21:14:25 +0000