script_core 0.2.7 → 0.3.0

data/ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/test/hash.rb

@@ -288,3 +288,10 @@
   assert_equal({:a=>100}, h.slice(:a))
   assert_equal({:b=>200, :c=>300}, h.slice(:b, :c, :d))
 end
+
+assert("Hash#except") do
+  h = { a: 100, b: 200, c: 300 }
+  assert_equal({:b=>200, :c=>300}, h.except(:a))
+  assert_equal({:a=>100}, h.except(:b, :c, :d))
+  assert_equal(h, h.except)
+end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-inline-struct/test/inline.c

@@ -10,10 +10,10 @@ istruct_test_initialize(mrb_state *mrb, mrb_value self)
   mrb_int size = mrb_istruct_size();
   mrb_value object = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(object)) {
+  if (mrb_integer_p(object)) {
     strncpy(string, "fixnum", size-1);
   }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   else if (mrb_float_p(object)) {
     strncpy(string, "float", size-1);
   }

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/README.md

@@ -4,7 +4,8 @@ mruby-io
 `IO` and `File` classes for mruby
 
 ## Installation
-Add the line below to your `build_config.rb`:
+
+Add the line below to your build configuration.
 
 ```
   conf.gem core: 'mruby-io'
@@ -13,7 +14,8 @@ Add the line below to your `build_config.rb`:
 ## Implemented methods
 
 ### IO
- - http://doc.ruby-lang.org/ja/1.9.3/class/IO.html
+
+ - https://doc.ruby-lang.org/ja/1.9.3/class/IO.html
 
 | method                     | mruby-io | memo |
 | -------------------------  | -------- | ---- |
@@ -97,7 +99,8 @@ Add the line below to your `build_config.rb`:
 | IO#write_nonblock          |          |      |
 
 ### File
- - http://doc.ruby-lang.org/ja/1.9.3/class/File.html
+
+ - https://doc.ruby-lang.org/ja/1.9.3/class/File.html
 
 | method                      | mruby-io | memo |
 | --------------------------- | -------- | ---- |
@@ -167,26 +170,25 @@ Add the line below to your `build_config.rb`:
 | File#size                   |          |      |
 | File#truncate               |          |      |
 
-
 ## License
 
 Copyright (c) 2013 Internet Initiative Japan Inc.
 Copyright (c) 2017 mruby developers
 
-Permission is hereby granted, free of charge, to any person obtaining a 
-copy of this software and associated documentation files (the "Software"), 
-to deal in the Software without restriction, including without limitation 
-the rights to use, copy, modify, merge, publish, distribute, sublicense, 
-and/or sell copies of the Software, and to permit persons to whom the 
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in 
+The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/include/mruby/ext/io.h

@@ -7,8 +7,8 @@
 
 #include <mruby.h>
 
-#ifdef MRB_DISABLE_STDIO
-# error IO and File conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#ifdef MRB_NO_STDIO
+# error IO and File conflicts 'MRB_NO_STDIO' in your build configuration
 #endif
 
 #if defined(__cplusplus)

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/mrblib/file.rb

@@ -2,7 +2,7 @@ class File < IO
   attr_accessor :path
 
   def initialize(fd_or_path, mode = "r", perm = 0666)
-    if fd_or_path.kind_of? Fixnum
+    if fd_or_path.kind_of? Integer
       super(fd_or_path, mode)
     else
       @path = fd_or_path
@@ -11,6 +11,11 @@ def initialize(fd_or_path, mode = "r", perm = 0666)
     end
   end
 
+  def mtime
+    t = self._mtime
+    t && Time.at(t)
+  end
+
   def self.join(*names)
     return "" if names.empty?
 
@@ -186,9 +191,9 @@ def self.zero?(file)
 
   def self.extname(filename)
     fname = self.basename(filename)
-    return '' if fname[0] == '.' || fname.index('.').nil?
-    ext = fname.split('.').last
-    ext.empty? ? '' : ".#{ext}"
+    epos = fname.rindex('.')
+    return '' if epos == 0 || epos.nil?
+    return fname[epos..-1]
   end
 
   def self.path(filename)

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/mrblib/io.rb

@@ -186,7 +186,7 @@ def ungetc(substr)
 
   def read(length = nil, outbuf = "")
     unless length.nil?
-      unless length.is_a? Fixnum
+      unless length.is_a? Integer
         raise TypeError.new "can't convert #{length.class} into Integer"
       end
       if length < 0
@@ -229,7 +229,7 @@ def readline(arg = "\n", limit = nil)
     case arg
     when String
       rs = arg
-    when Fixnum
+    when Integer
       rs = "\n"
       limit = arg
     else

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/src/file.c

@@ -8,6 +8,7 @@
 #include "mruby/string.h"
 #include "mruby/ext/io.h"
 #include "mruby/error.h"
+#include "mruby/presym.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -66,12 +67,16 @@
 #define LOCK_UN 8
 #endif
 
-#ifndef _WIN32
+#if !defined(_WIN32) || defined(MRB_MINGW32_LEGACY)
 typedef struct stat         mrb_stat;
 # define mrb_stat(path, sb) stat(path, sb)
 # define mrb_fstat(fd, sb)  fstat(fd, sb)
+#elif defined MRB_INT32
+typedef struct _stat32      mrb_stat;
+# define mrb_stat(path, sb) _stat32(path, sb)
+# define mrb_fstat(fd, sb)  _fstat32(fd, sb)
 #else
-typedef struct __stat64     mrb_stat;
+typedef struct _stat64      mrb_stat;
 # define mrb_stat(path, sb) _stat64(path, sb)
 # define mrb_fstat(fd, sb)  _fstat64(fd, sb)
 #endif
@@ -111,7 +116,7 @@ mrb_file_s_umask(mrb_state *mrb, mrb_value klass)
 static mrb_value
 mrb_file_s_unlink(mrb_state *mrb, mrb_value obj)
 {
-  mrb_value *argv;
+  const mrb_value *argv;
   mrb_value pathv;
   mrb_int argc, i;
   char *path;
@@ -254,7 +259,7 @@ mrb_file_realpath(mrb_state *mrb, mrb_value klass)
     pathname = s;
   }
   cpath = mrb_locale_from_utf8(RSTRING_CSTR(mrb, pathname), -1);
-  result = mrb_str_buf_new(mrb, PATH_MAX);
+  result = mrb_str_new_capa(mrb, PATH_MAX);
   if (realpath(cpath, RSTRING_PTR(result)) == NULL) {
     mrb_locale_free(cpath);
     mrb_sys_fail(mrb, cpath);
@@ -286,20 +291,20 @@ mrb_file__getwd(mrb_state *mrb, mrb_value klass)
 #define IS_DEVICEID(x) (x == '.' || x == '?')
 #define CHECK_UNCDEV_PATH (IS_FILESEP(path[0]) && IS_FILESEP(path[1]))
 
-static int 
+static int
 is_absolute_traditional_path(const char *path, size_t len)
 {
   if (len < 3) return 0;
   return (ISALPHA(path[0]) && IS_VOLSEP(path[1]) && IS_FILESEP(path[2]));
 }
 
-static int 
-is_aboslute_unc_path(const char *path, size_t len) {
+static int
+is_absolute_unc_path(const char *path, size_t len) {
   if (len < 2) return 0;
   return (CHECK_UNCDEV_PATH && !IS_DEVICEID(path[2]));
 }
 
-static int 
+static int
 is_absolute_device_path(const char *path, size_t len) {
   if (len < 4) return 0;
   return (CHECK_UNCDEV_PATH && IS_DEVICEID(path[2]) && IS_FILESEP(path[3]));
@@ -312,8 +317,8 @@ mrb_file_is_absolute_path(const char *path)
   if (IS_FILESEP(path[0])) return 1;
   if (len > 0)
     return (
-      is_absolute_traditional_path(path, len) || 
-      is_aboslute_unc_path(path, len) || 
+      is_absolute_traditional_path(path, len) ||
+      is_absolute_unc_path(path, len) ||
       is_absolute_device_path(path, len)
       );
   else
@@ -390,15 +395,12 @@ mrb_file__gethome(mrb_state *mrb, mrb_value klass)
 static mrb_value
 mrb_file_mtime(mrb_state *mrb, mrb_value self)
 {
-  mrb_value obj;
-  struct stat st;
-  int fd;
+  int fd = mrb_io_fileno(mrb, self);
+  mrb_stat st;
 
-  obj = mrb_obj_value(mrb_class_get(mrb, "Time"));
-  fd = mrb_io_fileno(mrb, self);
-  if (fstat(fd, &st) == -1)
+  if (mrb_fstat(fd, &st) == -1)
     return mrb_false_value();
-  return mrb_funcall(mrb, obj, "at", 1, mrb_fixnum_value(st.st_mtime));
+  return mrb_int_value(mrb, (mrb_int)st.st_mtime);
 }
 
 static mrb_value
@@ -447,14 +449,14 @@ mrb_file_size(mrb_state *mrb, mrb_value self)
   }
 
   if (st.st_size > MRB_INT_MAX) {
-#ifdef MRB_WITHOUT_FLOAT
-    mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_WITHOUT_FLOAT");
+#ifdef MRB_NO_FLOAT
+    mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_NO_FLOAT");
 #else
     return mrb_float_value(mrb, (mrb_float)st.st_size);
 #endif
   }
 
-  return mrb_fixnum_value((mrb_int)st.st_size);
+  return mrb_int_value(mrb, (mrb_int)st.st_size);
 }
 
 static int
@@ -532,7 +534,7 @@ static mrb_value
 mrb_file_s_chmod(mrb_state *mrb, mrb_value klass) {
   mrb_int mode;
   mrb_int argc, i;
-  mrb_value *filenames;
+  const mrb_value *filenames;
   int ai = mrb_gc_arena_save(mrb);
 
   mrb_get_args(mrb, "i*", &mode, &filenames, &argc);
@@ -556,7 +558,8 @@ mrb_file_s_readlink(mrb_state *mrb, mrb_value klass) {
   mrb_raise(mrb, E_NOTIMP_ERROR, "readlink is not supported on this platform");
   return mrb_nil_value(); // unreachable
 #else
-  char *path, *buf, *tmp;
+  const char *path;
+  char *buf, *tmp;
   size_t bufsize = 100;
   ssize_t rc;
   mrb_value ret;
@@ -608,40 +611,40 @@ mrb_init_file(mrb_state *mrb)
   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());
+  mrb_define_method(mrb, file, "_mtime", mrb_file_mtime, MRB_ARGS_NONE());
   mrb_define_method(mrb, file, "size", mrb_file_size, MRB_ARGS_NONE());
   mrb_define_method(mrb, file, "truncate", mrb_file_truncate, MRB_ARGS_REQ(1));
 
-  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));
+  cnst = mrb_define_module_under_id(mrb, file, MRB_SYM(Constants));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_SH), mrb_fixnum_value(LOCK_SH));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_EX), mrb_fixnum_value(LOCK_EX));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_UN), mrb_fixnum_value(LOCK_UN));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_NB), mrb_fixnum_value(LOCK_NB));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(SEPARATOR), mrb_str_new_cstr(mrb, FILE_SEPARATOR));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(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));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
 #else
-  mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value());
+  mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_nil_value());
 #endif
-  mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE));
-
-  mrb_define_const(mrb, cnst, "RDONLY", mrb_fixnum_value(MRB_O_RDONLY));
-  mrb_define_const(mrb, cnst, "WRONLY", mrb_fixnum_value(MRB_O_WRONLY));
-  mrb_define_const(mrb, cnst, "RDWR", mrb_fixnum_value(MRB_O_RDWR));
-  mrb_define_const(mrb, cnst, "APPEND", mrb_fixnum_value(MRB_O_APPEND));
-  mrb_define_const(mrb, cnst, "CREAT", mrb_fixnum_value(MRB_O_CREAT));
-  mrb_define_const(mrb, cnst, "EXCL", mrb_fixnum_value(MRB_O_EXCL));
-  mrb_define_const(mrb, cnst, "TRUNC", mrb_fixnum_value(MRB_O_TRUNC));
-  mrb_define_const(mrb, cnst, "NONBLOCK", mrb_fixnum_value(MRB_O_NONBLOCK));
-  mrb_define_const(mrb, cnst, "NOCTTY", mrb_fixnum_value(MRB_O_NOCTTY));
-  mrb_define_const(mrb, cnst, "BINARY", mrb_fixnum_value(MRB_O_BINARY));
-  mrb_define_const(mrb, cnst, "SHARE_DELETE", mrb_fixnum_value(MRB_O_SHARE_DELETE));
-  mrb_define_const(mrb, cnst, "SYNC", mrb_fixnum_value(MRB_O_SYNC));
-  mrb_define_const(mrb, cnst, "DSYNC", mrb_fixnum_value(MRB_O_DSYNC));
-  mrb_define_const(mrb, cnst, "RSYNC", mrb_fixnum_value(MRB_O_RSYNC));
-  mrb_define_const(mrb, cnst, "NOFOLLOW", mrb_fixnum_value(MRB_O_NOFOLLOW));
-  mrb_define_const(mrb, cnst, "NOATIME", mrb_fixnum_value(MRB_O_NOATIME));
-  mrb_define_const(mrb, cnst, "DIRECT", mrb_fixnum_value(MRB_O_DIRECT));
-  mrb_define_const(mrb, cnst, "TMPFILE", mrb_fixnum_value(MRB_O_TMPFILE));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NULL), mrb_str_new_cstr(mrb, NULL_FILE));
+
+  mrb_define_const_id(mrb, cnst, MRB_SYM(RDONLY), mrb_fixnum_value(MRB_O_RDONLY));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(WRONLY), mrb_fixnum_value(MRB_O_WRONLY));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(RDWR), mrb_fixnum_value(MRB_O_RDWR));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(APPEND), mrb_fixnum_value(MRB_O_APPEND));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(CREAT), mrb_fixnum_value(MRB_O_CREAT));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(EXCL), mrb_fixnum_value(MRB_O_EXCL));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(TRUNC), mrb_fixnum_value(MRB_O_TRUNC));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NONBLOCK), mrb_fixnum_value(MRB_O_NONBLOCK));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NOCTTY), mrb_fixnum_value(MRB_O_NOCTTY));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(BINARY), mrb_fixnum_value(MRB_O_BINARY));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(SHARE_DELETE), mrb_fixnum_value(MRB_O_SHARE_DELETE));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(SYNC), mrb_fixnum_value(MRB_O_SYNC));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(DSYNC), mrb_fixnum_value(MRB_O_DSYNC));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(RSYNC), mrb_fixnum_value(MRB_O_RSYNC));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NOFOLLOW), mrb_fixnum_value(MRB_O_NOFOLLOW));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NOATIME), mrb_fixnum_value(MRB_O_NOATIME));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(DIRECT), mrb_fixnum_value(MRB_O_DIRECT));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(TMPFILE), mrb_fixnum_value(MRB_O_TMPFILE));
 }

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/src/file_test.c

@@ -66,11 +66,13 @@ mrb_stat(mrb_state *mrb, mrb_value obj, struct stat *st)
   return mrb_stat0(mrb, obj, st, 0);
 }
 
+#ifdef S_ISLNK
 static int
 mrb_lstat(mrb_state *mrb, mrb_value obj, struct stat *st)
 {
   return mrb_stat0(mrb, obj, st, 1);
 }
+#endif
 
 /*
  * Document-method: directory?
@@ -302,7 +304,7 @@ mrb_filetest_s_size(mrb_state *mrb, mrb_value klass)
   if (mrb_stat(mrb, obj, &st) < 0)
     mrb_sys_fail(mrb, "mrb_stat");
 
-  return mrb_fixnum_value(st.st_size);
+  return mrb_int_value(mrb, st.st_size);
 }
 
 /*
@@ -324,7 +326,7 @@ mrb_filetest_s_size_p(mrb_state *mrb, mrb_value klass)
   if (st.st_size == 0)
     return mrb_nil_value();
 
-  return mrb_fixnum_value(st.st_size);
+  return mrb_int_value(mrb, st.st_size);
 }
 
 void

data/ext/enterprise_script_service/mruby/mrbgems/mruby-io/src/io.c

@@ -11,6 +11,7 @@
 #include "mruby/variable.h"
 #include "mruby/ext/io.h"
 #include "mruby/error.h"
+#include "mruby/presym.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -18,6 +19,7 @@
 #if defined(_WIN32) || defined(_WIN64)
   #include <winsock.h>
   #include <io.h>
+  #include <basetsd.h>
   #define open  _open
   #define close _close
   #define dup _dup
@@ -32,6 +34,12 @@
   typedef long fsuseconds_t;
   typedef int fmode_t;
   typedef int mrb_io_read_write_size;
+  #ifndef MRB_MINGW32_LEGACY
+    #if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED) && \
+        !defined(__have_typedef_ssize_t)
+    typedef SSIZE_T ssize_t;
+    #endif
+  #endif
 
   #ifndef O_TMPFILE
     #define O_TMPFILE O_TEMPORARY
@@ -95,18 +103,18 @@ io_set_process_status(mrb_state *mrb, pid_t pid, int 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 (mrb_class_defined_id(mrb, MRB_SYM(Process))) {
+    c_process = mrb_module_get_id(mrb, MRB_SYM(Process));
+    if (mrb_const_defined(mrb, mrb_obj_value(c_process), MRB_SYM(Status))) {
+      c_status = mrb_class_get_under_id(mrb, c_process, MRB_SYM(Status));
     }
   }
   if (c_status != NULL) {
-    v = mrb_funcall(mrb, mrb_obj_value(c_status), "new", 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
+    v = mrb_funcall_id(mrb, mrb_obj_value(c_status), MRB_SYM(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);
+  mrb_gv_set(mrb, mrb_intern_lit(mrb, "$?"), v);
 }
 
 static int
@@ -319,20 +327,20 @@ mrb_io_alloc(mrb_state *mrb)
 #define NOFILE 64
 #endif
 
+#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+# define mrb_io_s_popen mrb_notimplement_m
+#else
 static int
-option_to_fd(mrb_state *mrb, mrb_value hash, const char *key)
+option_to_fd(mrb_state *mrb, mrb_value v)
 {
-  mrb_value opt;
-
-  if (!mrb_hash_p(hash)) return -1;
-  opt = mrb_hash_fetch(mrb, hash, mrb_symbol_value(mrb_intern_static(mrb, key, strlen(key))), mrb_nil_value());
-  if (mrb_nil_p(opt)) return -1;
+  if (mrb_undef_p(v)) return -1;
+  if (mrb_nil_p(v)) return -1;
 
-  switch (mrb_type(opt)) {
+  switch (mrb_type(v)) {
     case MRB_TT_DATA: /* IO */
-      return mrb_io_fileno(mrb, opt);
-    case MRB_TT_FIXNUM:
-      return (int)mrb_fixnum(opt);
+      return mrb_io_fileno(mrb, v);
+    case MRB_TT_INTEGER:
+      return (int)mrb_integer(v);
     default:
       mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
       break;
@@ -340,16 +348,42 @@ option_to_fd(mrb_state *mrb, mrb_value hash, const char *key)
   return -1; /* never reached */
 }
 
+static mrb_value
+mrb_io_s_popen_args(mrb_state *mrb, mrb_value klass,
+                    const char **cmd, int *flags, int *doexec,
+                    int *opt_in, int *opt_out, int *opt_err)
+{
+  mrb_value mode = mrb_nil_value();
+  struct { mrb_value opt_in, opt_out, opt_err; } kv;
+  mrb_sym knames[3] = {MRB_SYM(in), MRB_SYM(out), MRB_SYM(err)};
+  const mrb_kwargs kw = {
+    3, 0,
+    knames,
+    &kv.opt_in,
+    NULL,
+  };
+
+  mrb_get_args(mrb, "z|o:", cmd, &mode, &kw);
+
+  *flags = mrb_io_mode_to_flags(mrb, mode);
+  *doexec = (strcmp("-", *cmd) != 0);
+  *opt_in = option_to_fd(mrb, kv.opt_in);
+  *opt_out = option_to_fd(mrb, kv.opt_out);
+  *opt_err = option_to_fd(mrb, kv.opt_err);
+
+  return mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
+}
+
 #ifdef _WIN32
 static 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);
+  mrb_value io;
+  int doexec;
+  int opt_in, opt_out, opt_err;
+  const char *cmd;
 
   struct mrb_io *fptr;
-  const char *pname;
   int pid = 0, flags;
   STARTUPINFO si;
   PROCESS_INFORMATION pi;
@@ -358,24 +392,13 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
   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|oH", &cmd, &mode, &opt);
-  io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
-
-  pname = RSTRING_CSTR(mrb, cmd);
-  flags = mrb_io_mode_to_flags(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");
+  io = mrb_io_s_popen_args(mrb, klass, &cmd, &flags, &doexec,
+                           &opt_in, &opt_out, &opt_err);
 
   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
   saAttr.bInheritHandle = TRUE;
@@ -410,13 +433,13 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
       si.hStdInput = ifd[0];
     }
     if (!CreateProcess(
-        NULL, (char*)pname, NULL, NULL,
+        NULL, (char*)cmd, 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: %v", cmd);
+      mrb_raisef(mrb, E_IO_ERROR, "command not found: %s", cmd);
     }
     CloseHandle(pi.hThread);
     CloseHandle(ifd[0]);
@@ -424,7 +447,7 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
     pid = pi.dwProcessId;
   }
 
-  mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
+  mrb_iv_set(mrb, io, mrb_intern_lit(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
 
   fptr = mrb_io_alloc(mrb);
   fptr->fd = _open_osfhandle((intptr_t)ofd[0], 0);
@@ -438,40 +461,23 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
   DATA_PTR(io)  = fptr;
   return io;
 }
-#elif defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
-static mrb_value
-mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
-{
-  mrb_raise(mrb, E_NOTIMP_ERROR, "IO#popen is not supported on the platform");
-  return mrb_false_value();
-}
 #else
 static 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);
+  mrb_value io, result;
+  int doexec;
+  int opt_in, opt_out, opt_err;
+  const char *cmd;
 
   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|oH", &cmd, &mode, &opt);
-  io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
 
-  pname = RSTRING_CSTR(mrb, cmd);
-  flags = mrb_io_mode_to_flags(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");
+  io = mrb_io_s_popen_args(mrb, klass, &cmd, &flags, &doexec,
+                           &opt_in, &opt_out, &opt_err);
 
   if (OPEN_READABLE_P(flags)) {
     if (pipe(pr) == -1) {
@@ -528,8 +534,8 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
         for (fd = 3; fd < NOFILE; fd++) {
           close(fd);
         }
-        mrb_proc_exec(pname);
-        mrb_raisef(mrb, E_IO_ERROR, "command not found: %v", cmd);
+        mrb_proc_exec(cmd);
+        mrb_raisef(mrb, E_IO_ERROR, "command not found: %s", cmd);
         _exit(127);
       }
       result = mrb_nil_value();
@@ -549,7 +555,7 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
         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_lit(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
 
       fptr = mrb_io_alloc(mrb);
       fptr->fd = fd;
@@ -580,7 +586,8 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
   }
   return result;
 }
-#endif
+#endif /* _WIN32 */
+#endif /* TARGET_OS_IPHONE */
 
 static int
 mrb_dup(mrb_state *mrb, int fd, mrb_bool *failed)
@@ -617,8 +624,8 @@ mrb_io_initialize_copy(mrb_state *mrb, mrb_value copy)
   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);
+  buf = mrb_iv_get(mrb, orig, mrb_intern_lit(mrb, "@buf"));
+  mrb_iv_set(mrb, copy, mrb_intern_lit(mrb, "@buf"), buf);
 
   fptr_copy->fd = mrb_dup(mrb, fptr_orig->fd, &failed);
   if (failed) {
@@ -692,7 +699,15 @@ mrb_io_initialize(mrb_state *mrb, mrb_value io)
   mode = opt = mrb_nil_value();
 
   mrb_get_args(mrb, "i|oo", &fd, &mode, &opt);
-  check_file_descriptor(mrb, fd);
+  switch (fd) {
+    case 0: /* STDIN_FILENO */
+    case 1: /* STDOUT_FILENO */
+    case 2: /* STDERR_FILENO */
+      break;
+    default:
+      check_file_descriptor(mrb, fd);
+      break;
+  }
   if (mrb_nil_p(mode)) {
     mode = mrb_str_new_cstr(mrb, "r");
   }
@@ -702,7 +717,7 @@ mrb_io_initialize(mrb_state *mrb, mrb_value io)
 
   flags = mrb_io_mode_to_flags(mrb, mode);
 
-  mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
+  mrb_iv_set(mrb, io, mrb_intern_lit(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
 
   fptr = (struct mrb_io *)DATA_PTR(io);
   if (fptr != NULL) {
@@ -966,13 +981,13 @@ mrb_io_sysseek(mrb_state *mrb, mrb_value io)
     mrb_sys_fail(mrb, "sysseek");
   }
   if (pos > MRB_INT_MAX) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     return mrb_float_value(mrb, (mrb_float)pos);
 #else
-    mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_WITHOUT_FLOAT");
+    mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_NO_FLOAT");
 #endif
   } else {
-    return mrb_fixnum_value(pos);
+    return mrb_int_value(mrb, pos);
   }
 }
 
@@ -999,7 +1014,7 @@ mrb_io_syswrite_common(mrb_state *mrb,
     mrb_sys_fail(mrb, 0);
   }
 
-  return mrb_fixnum_value(length);
+  return mrb_int_value(mrb, (mrb_int)length);
 }
 
 static mrb_io_read_write_size
@@ -1069,12 +1084,12 @@ 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);
+    case MRB_TT_INTEGER:
+      t.tv_sec = (ftime_t)mrb_integer(time);
       t.tv_usec = 0;
       break;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_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);
@@ -1091,7 +1106,7 @@ time2timeval(mrb_state *mrb, mrb_value time)
 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"));
+  mrb_value buf = mrb_iv_get(mrb, io, mrb_intern_lit(mrb, "@buf"));
   if (mrb_string_p(buf) && RSTRING_LEN(buf) > 0) {
     return 1;
   }
@@ -1113,7 +1128,7 @@ mrb_io_s_pipe(mrb_state *mrb, mrb_value klass)
   }
 
   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, ""));
+  mrb_iv_set(mrb, r, mrb_intern_lit(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
   fptr_r = mrb_io_alloc(mrb);
   fptr_r->fd = pipes[0];
   fptr_r->readable = 1;
@@ -1123,7 +1138,7 @@ mrb_io_s_pipe(mrb_state *mrb, mrb_value klass)
   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, ""));
+  mrb_iv_set(mrb, w, mrb_intern_lit(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
   fptr_w = mrb_io_alloc(mrb);
   fptr_w->fd = pipes[1];
   fptr_w->readable = 0;
@@ -1139,7 +1154,7 @@ mrb_io_s_pipe(mrb_state *mrb, mrb_value klass)
 static mrb_value
 mrb_io_s_select(mrb_state *mrb, mrb_value klass)
 {
-  mrb_value *argv;
+  const mrb_value *argv;
   mrb_int argc;
   mrb_value read, read_io, write, except, timeout, list;
   struct timeval *tp, timerec;
@@ -1316,10 +1331,10 @@ mrb_io_fileno_m(mrb_state *mrb, mrb_value io)
   return mrb_fixnum_value(fd);
 }
 
+#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
 static 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;
 
@@ -1333,17 +1348,15 @@ mrb_io_close_on_exec_p(mrb_state *mrb, mrb_value self)
   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();
+# define mrb_io_close_on_exec_p mrb_notimplement_m
 #endif
-}
 
+#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
 static 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;
@@ -1370,11 +1383,10 @@ mrb_io_set_close_on_exec(mrb_state *mrb, mrb_value self)
   }
 
   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();
+# define mrb_io_set_close_on_exec mrb_notimplement_m
 #endif
-}
 
 static mrb_value
 mrb_io_set_sync(mrb_state *mrb, mrb_value self)