diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c
index 703de791e..64307517d 100644
--- a/mrbgems/mruby-io/src/file.c
+++ b/mrbgems/mruby-io/src/file.c
@@ -84,13 +84,13 @@ typedef struct _stat64      mrb_stat;
 
 #ifdef _WIN32
 static int
-flock(int fd, int operation) {
-  OVERLAPPED ov;
+flock(int fd, int operation)
+{
   HANDLE h = (HANDLE)_get_osfhandle(fd);
   DWORD flags;
   flags = ((operation & LOCK_NB) ? LOCKFILE_FAIL_IMMEDIATELY : 0)
           | ((operation & LOCK_SH) ? LOCKFILE_EXCLUSIVE_LOCK : 0);
-  ov = (OVERLAPPED){0};
+  OVERLAPPED ov = (OVERLAPPED){0};
   return LockFileEx(h, flags, 0, 0xffffffff, 0xffffffff, &ov) ? 0 : -1;
 }
 #endif
@@ -119,10 +119,10 @@ static mrb_value
 mrb_file_s_unlink(mrb_state *mrb, mrb_value obj)
 {
   const mrb_value *argv;
-  mrb_int argc, i;
+  mrb_int argc;
 
   mrb_get_args(mrb, "*", &argv, &argc);
-  for (i = 0; i < argc; i++) {
+  for (int i = 0; i < argc; i++) {
     mrb_value pathv = argv[i];
     mrb_ensure_string_type(mrb, pathv);
     const char *utf8_path = RSTRING_CSTR(mrb, pathv);
@@ -140,11 +140,10 @@ 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(RSTRING_CSTR(mrb, from), -1);
-  dst = mrb_locale_from_utf8(RSTRING_CSTR(mrb, to), -1);
+  char *src = mrb_locale_from_utf8(RSTRING_CSTR(mrb, from), -1);
+  char *dst = mrb_locale_from_utf8(RSTRING_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) {
@@ -170,14 +169,12 @@ mrb_file_dirname(mrb_state *mrb, mrb_value klass)
   char dname[_MAX_DIR], vname[_MAX_DRIVE];
   char buffer[_MAX_DRIVE + _MAX_DIR];
   const char *utf8_path;
-  char *path;
-  size_t ridx;
   mrb_get_args(mrb, "z", &utf8_path);
-  path = mrb_locale_from_utf8(utf8_path, -1);
+  char *path = mrb_locale_from_utf8(utf8_path, -1);
   _splitpath(path, vname, dname, NULL, NULL);
   snprintf(buffer, _MAX_DRIVE + _MAX_DIR, "%s%s", vname, dname);
   mrb_locale_free(path);
-  ridx = strlen(buffer);
+  size_t ridx = strlen(buffer);
   if (ridx == 0) {
     strncpy(buffer, ".", 2);  /* null terminated */
   }
@@ -190,11 +187,10 @@ mrb_file_dirname(mrb_state *mrb, mrb_value klass)
   }
   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);
-
+  char *path = mrb_locale_from_utf8(mrb_str_to_cstr(mrb, s), -1);
+  char *dname;
   if ((dname = dirname(path)) == NULL) {
     mrb_locale_free(path);
     mrb_sys_fail(mrb, "dirname");
@@ -211,14 +207,12 @@ mrb_file_basename(mrb_state *mrb, mrb_value klass)
 #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);
+  char *path = mrb_str_to_cstr(mrb, s);
+  size_t ridx = strlen(path);
   if (ridx > 0) {
     ridx--;
     while (ridx > 0 && (path[ridx] == '/' || path[ridx] == '\\')) {
@@ -233,10 +227,10 @@ mrb_file_basename(mrb_state *mrb, mrb_value klass)
   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);
+  char *path = mrb_str_to_cstr(mrb, s);
+  char *bname;
   if ((bname = basename(path)) == NULL) {
     mrb_sys_fail(mrb, "basename");
   }
@@ -248,19 +242,16 @@ mrb_file_basename(mrb_state *mrb, mrb_value klass)
 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);
+  mrb_value pathname, dir_string;
+  mrb_int argc = mrb_get_args(mrb, "S|S", &pathname, &dir_string);
   if (argc == 2) {
-    s = mrb_str_dup(mrb, dir_string);
+    mrb_value 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(RSTRING_CSTR(mrb, pathname), -1);
-  result = mrb_str_new_capa(mrb, PATH_MAX);
+  char *cpath = mrb_locale_from_utf8(RSTRING_CSTR(mrb, pathname), -1);
+  mrb_value result = mrb_str_new_capa(mrb, PATH_MAX);
   if (realpath(cpath, RSTRING_PTR(result)) == NULL) {
     mrb_locale_free(cpath);
     mrb_sys_fail(mrb, RSTRING_CSTR(mrb, pathname));
@@ -274,15 +265,14 @@ mrb_file_realpath(mrb_state *mrb, mrb_value klass)
 static mrb_value
 mrb_file__getwd(mrb_state *mrb, mrb_value klass)
 {
-  mrb_value path;
-  char buf[MAXPATHLEN], *utf8;
+  char buf[MAXPATHLEN];
 
   mrb->c->ci->mid = 0;
   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);
+  char *utf8 = mrb_utf8_from_locale(buf, -1);
+  mrb_value path = mrb_str_new_cstr(mrb, utf8);
   mrb_utf8_free(utf8);
   return path;
 }
@@ -301,13 +291,15 @@ is_absolute_traditional_path(const char *path, size_t len)
 }
 
 static int
-is_absolute_unc_path(const char *path, size_t len) {
+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
-is_absolute_device_path(const char *path, size_t len) {
+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]));
 }
@@ -343,7 +335,6 @@ mrb_file_is_absolute_path(const char *path)
 static mrb_value
 mrb_file__gethome(mrb_state *mrb, mrb_value klass)
 {
-  mrb_int argc;
   char *home;
   mrb_value path;
 
@@ -351,7 +342,7 @@ mrb_file__gethome(mrb_state *mrb, mrb_value klass)
 #ifndef _WIN32
   mrb_value username;
 
-  argc = mrb_get_args(mrb, "|S", &username);
+  mrb_int argc = mrb_get_args(mrb, "|S", &username);
   if (argc == 0) {
     home = getenv("HOME");
     if (home == NULL) {
@@ -461,10 +452,9 @@ mrb_file_flock(mrb_state *mrb, mrb_value self)
   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 = mrb_io_fileno(mrb, self);
+  int fd = mrb_io_fileno(mrb, self);
 
   while (flock(fd, (int)operation) == -1) {
     switch (errno) {
@@ -492,9 +482,7 @@ static mrb_value
 mrb_file_size(mrb_state *mrb, mrb_value self)
 {
   mrb_stat st;
-  int fd;
-
-  fd = mrb_io_fileno(mrb, self);
+  int fd = mrb_io_fileno(mrb, self);
   if (mrb_fstat(fd, &st) == -1) {
     mrb_raise(mrb, E_RUNTIME_ERROR, "fstat failed");
   }
@@ -516,10 +504,8 @@ mrb_ftruncate(int fd, mrb_int length)
 #ifndef _WIN32
   return ftruncate(fd, (off_t)length);
 #else
-  HANDLE file;
   __int64 cur;
-
-  file = (HANDLE)_get_osfhandle(fd);
+  HANDLE file = (HANDLE)_get_osfhandle(fd);
   if (file == INVALID_HANDLE_VALUE) {
     return -1;
   }
@@ -543,12 +529,9 @@ mrb_ftruncate(int fd, mrb_int length)
 static mrb_value
 mrb_file_truncate(mrb_state *mrb, mrb_value self)
 {
-  int fd;
-  mrb_int length;
   mrb_value lenv = mrb_get_arg1(mrb);
-
-  fd = mrb_io_fileno(mrb, self);
-  length = mrb_as_int(mrb, lenv);
+  int fd = mrb_io_fileno(mrb, self);
+  mrb_int length = mrb_as_int(mrb, lenv);
   if (mrb_ftruncate(fd, length) != 0) {
     mrb_raise(mrb, E_IO_ERROR, "ftruncate failed");
   }
@@ -563,12 +546,11 @@ mrb_file_s_symlink(mrb_state *mrb, mrb_value klass)
   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(RSTRING_CSTR(mrb, from), -1);
-  dst = mrb_locale_from_utf8(RSTRING_CSTR(mrb, to), -1);
+  const char *src = mrb_locale_from_utf8(RSTRING_CSTR(mrb, from), -1);
+  const char *dst = mrb_locale_from_utf8(RSTRING_CSTR(mrb, to), -1);
   if (symlink(src, dst) == -1) {
     mrb_locale_free(src);
     mrb_locale_free(dst);
@@ -582,14 +564,15 @@ mrb_file_s_symlink(mrb_state *mrb, mrb_value klass)
 }
 
 static mrb_value
-mrb_file_s_chmod(mrb_state *mrb, mrb_value klass) {
+mrb_file_s_chmod(mrb_state *mrb, mrb_value klass)
+{
   mrb_int mode;
-  mrb_int argc, i;
+  mrb_int argc;
   const mrb_value *filenames;
   int ai = mrb_gc_arena_save(mrb);
 
   mrb_get_args(mrb, "i*", &mode, &filenames, &argc);
-  for (i = 0; i < argc; i++) {
+  for (int i = 0; i < argc; i++) {
     const char *utf8_path = RSTRING_CSTR(mrb, filenames[i]);
     char *path = mrb_locale_from_utf8(utf8_path, -1);
     if (CHMOD(path, mode) == -1) {
@@ -604,7 +587,8 @@ mrb_file_s_chmod(mrb_state *mrb, mrb_value klass) {
 }
 
 static mrb_value
-mrb_file_s_readlink(mrb_state *mrb, mrb_value klass) {
+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
@@ -642,10 +626,8 @@ mrb_file_s_readlink(mrb_state *mrb, mrb_value klass) {
 void
 mrb_init_file(mrb_state *mrb)
 {
-  struct RClass *io, *file, *cnst;
-
-  io   = mrb_class_get_id(mrb, MRB_SYM(IO));
-  file = mrb_define_class(mrb, "File", io);
+  struct RClass *io   = mrb_class_get_id(mrb, MRB_SYM(IO));
+  struct RClass *file = mrb_define_class(mrb, "File", io);
   MRB_SET_INSTANCE_TT(file, MRB_TT_CDATA);
   mrb_define_class_method(mrb, file, "umask",  mrb_file_s_umask, MRB_ARGS_OPT(1));
   mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
@@ -668,7 +650,7 @@ mrb_init_file(mrb_state *mrb)
   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_id(mrb, file, MRB_SYM(Constants));
+  struct RClass *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));
diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c
index 9e30879ea..18c6bef79 100644
--- a/mrbgems/mruby-io/src/io.c
+++ b/mrbgems/mruby-io/src/io.c
@@ -82,9 +82,7 @@ static void fptr_finalize(mrb_state *mrb, struct mrb_io *fptr, int quiet);
 static struct mrb_io*
 io_get_open_fptr(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
-
-  fptr = (struct mrb_io*)mrb_data_get_ptr(mrb, io, &mrb_io_type);
+  struct mrb_io *fptr = (struct mrb_io*)mrb_data_get_ptr(mrb, io, &mrb_io_type);
   if (fptr == NULL) {
     mrb_raise(mrb, E_IO_ERROR, "uninitialized stream");
   }
@@ -242,9 +240,9 @@ static void
 io_fd_cloexec(mrb_state *mrb, int fd)
 {
 #if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
-  int flags, flags2;
+  int flags = fcntl(fd, F_GETFD);
+  int flags2;
 
-  flags = fcntl(fd, F_GETFD);
   if (flags < 0) {
     mrb_sys_fail(mrb, "cloexec GETFD");
   }
@@ -266,8 +264,7 @@ io_fd_cloexec(mrb_state *mrb, int fd)
 static int
 io_cloexec_pipe(mrb_state *mrb, int fildes[2])
 {
-  int ret;
-  ret = pipe(fildes);
+  int ret = pipe(fildes);
   if (ret == -1)
     return -1;
   io_fd_cloexec(mrb, fildes[0]);
@@ -278,8 +275,7 @@ io_cloexec_pipe(mrb_state *mrb, int fildes[2])
 static int
 io_pipe(mrb_state *mrb, int pipes[2])
 {
-  int ret;
-  ret = io_cloexec_pipe(mrb, pipes);
+  int ret = io_cloexec_pipe(mrb, pipes);
   if (ret == -1) {
     if (errno == EMFILE || errno == ENFILE) {
       mrb_garbage_collect(mrb);
@@ -292,8 +288,7 @@ io_pipe(mrb_state *mrb, int pipes[2])
 static int
 io_process_exec(const char *pname)
 {
-  const char *s;
-  s = pname;
+  const char *s = pname;
 
   while (*s == ' ' || *s == '\t' || *s == '\n')
     s++;
@@ -331,9 +326,7 @@ io_init_buf(mrb_state *mrb, struct mrb_io *fptr)
 static struct mrb_io *
 io_alloc(mrb_state *mrb)
 {
-  struct mrb_io *fptr;
-
-  fptr = (struct mrb_io*)mrb_malloc(mrb, sizeof(struct mrb_io));
+  struct mrb_io *fptr = (struct mrb_io*)mrb_malloc(mrb, sizeof(struct mrb_io));
   fptr->fd = -1;
   fptr->fd2 = -1;
   fptr->pid = 0;
@@ -412,7 +405,6 @@ io_s_popen(mrb_state *mrb, mrb_value klass)
   int pid = 0, flags;
   STARTUPINFO si;
   PROCESS_INFORMATION pi;
-  SECURITY_ATTRIBUTES saAttr;
 
   HANDLE ifd[2];
   HANDLE ofd[2];
@@ -423,9 +415,10 @@ io_s_popen(mrb_state *mrb, mrb_value klass)
   ofd[1] = INVALID_HANDLE_VALUE;
 
   mrb->c->ci->mid = 0;
-  io = io_s_popen_args(mrb, klass, &cmd, &flags, &doexec,
-                       &opt_in, &opt_out, &opt_err);
+  mrb_value io = io_s_popen_args(mrb, klass, &cmd, &flags, &doexec,
+                                 &opt_in, &opt_out, &opt_err);
 
+  SECURITY_ATTRIBUTES saAttr;
   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
   saAttr.bInheritHandle = TRUE;
   saAttr.lpSecurityDescriptor = NULL;
@@ -489,20 +482,17 @@ io_s_popen(mrb_state *mrb, mrb_value klass)
 static mrb_value
 io_s_popen(mrb_state *mrb, mrb_value klass)
 {
-  mrb_value io, result;
   int doexec;
   int opt_in, opt_out, opt_err;
   const char *cmd;
 
-  struct mrb_io *fptr;
-  int pid, flags, fd, write_fd = -1;
+  int pid, flags, write_fd = -1;
   int pr[2] = { -1, -1 };
   int pw[2] = { -1, -1 };
-  int saved_errno;
 
   mrb->c->ci->mid = 0;
-  io = io_s_popen_args(mrb, klass, &cmd, &flags, &doexec,
-                       &opt_in, &opt_out, &opt_err);
+  mrb_value io = io_s_popen_args(mrb, klass, &cmd, &flags, &doexec,
+                                 &opt_in, &opt_out, &opt_err);
 
   if (OPEN_READABLE_P(flags)) {
     if (pipe(pr) == -1) {
@@ -527,7 +517,7 @@ io_s_popen(mrb_state *mrb, mrb_value klass)
     fflush(stderr);
   }
 
-  result = mrb_nil_value();
+  mrb_value result = mrb_nil_value();
   switch (pid = fork()) {
     case 0: /* child */
       if (opt_in != -1) {
@@ -554,7 +544,7 @@ io_s_popen(mrb_state *mrb, mrb_value klass)
         }
       }
       if (doexec) {
-        for (fd = 3; fd < NOFILE; fd++) {
+        for (int fd = 3; fd < NOFILE; fd++) {
           close(fd);
         }
         io_process_exec(cmd);
@@ -565,46 +555,52 @@ io_s_popen(mrb_state *mrb, mrb_value klass)
       break;
 
     default: /* parent */
-      if (OPEN_RDWR_P(flags)) {
-        close(pr[1]);
-        fd = pr[0];
-        close(pw[0]);
-        write_fd = pw[1];
-      }
-      else if (OPEN_RDONLY_P(flags)) {
-        close(pr[1]);
-        fd = pr[0];
-      }
-      else {
-        close(pw[0]);
-        fd = pw[1];
-      }
+      {
+        int fd;
 
-      fptr = io_alloc(mrb);
-      fptr->fd = fd;
-      fptr->fd2 = write_fd;
-      fptr->pid = pid;
-      fptr->readable = OPEN_READABLE_P(flags);
-      fptr->writable = OPEN_WRITABLE_P(flags);
-      io_init_buf(mrb, fptr);
+        if (OPEN_RDWR_P(flags)) {
+          close(pr[1]);
+          fd = pr[0];
+          close(pw[0]);
+          write_fd = pw[1];
+        }
+        else if (OPEN_RDONLY_P(flags)) {
+          close(pr[1]);
+          fd = pr[0];
+        }
+        else {
+          close(pw[0]);
+          fd = pw[1];
+        }
 
-      DATA_TYPE(io) = &mrb_io_type;
-      DATA_PTR(io)  = fptr;
-      result = io;
+        struct mrb_io *fptr = io_alloc(mrb);
+        fptr->fd = fd;
+        fptr->fd2 = write_fd;
+        fptr->pid = pid;
+        fptr->readable = OPEN_READABLE_P(flags);
+        fptr->writable = OPEN_WRITABLE_P(flags);
+        io_init_buf(mrb, fptr);
+
+        DATA_TYPE(io) = &mrb_io_type;
+        DATA_PTR(io)  = fptr;
+        result = io;
+      }
       break;
 
     case -1: /* error */
-      saved_errno = errno;
-      if (OPEN_READABLE_P(flags)) {
-        close(pr[0]);
-        close(pr[1]);
-      }
-      if (OPEN_WRITABLE_P(flags)) {
+      {
+        int saved_errno = errno;
+        if (OPEN_READABLE_P(flags)) {
+          close(pr[0]);
+          close(pr[1]);
+        }
+        if (OPEN_WRITABLE_P(flags)) {
         close(pw[0]);
         close(pw[1]);
+        }
+        errno = saved_errno;
+        mrb_sys_fail(mrb, "pipe_open failed");
       }
-      errno = saved_errno;
-      mrb_sys_fail(mrb, "pipe_open failed");
       break;
   }
   return result;
@@ -855,9 +851,7 @@ io_get_write_fd(struct mrb_io *fptr)
 static mrb_value
 io_isatty(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
-
-  fptr = io_get_open_fptr(mrb, io);
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
   if (isatty(fptr->fd) == 0)
     return mrb_false_value();
   return mrb_true_value();
@@ -868,11 +862,11 @@ 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));
+
+  mrb_value obj = mrb_obj_value((struct RObject*)mrb_obj_alloc(mrb, ttype, c));
   return io_init(mrb, obj);
 }
 
@@ -891,8 +885,9 @@ io_s_sysclose(mrb_state *mrb, mrb_value klass)
 static int
 io_cloexec_open(mrb_state *mrb, const char *pathname, int flags, fmode_t mode)
 {
-  int fd, retry = FALSE;
-  char* fname = mrb_locale_from_utf8(pathname, -1);
+  int retry = FALSE;
+  char *fname = mrb_locale_from_utf8(pathname, -1);
+  int fd;
 
 #ifdef O_CLOEXEC
   /* O_CLOEXEC is available since Linux 2.6.23.  Linux 2.6.18 silently ignore it. */
@@ -905,14 +900,13 @@ reopen:
   if (fd == -1) {
     if (!retry) {
       switch (errno) {
-        case ENFILE:
-        case EMFILE:
+      case ENFILE:
+      case EMFILE:
         mrb_garbage_collect(mrb);
         retry = TRUE;
         goto reopen;
       }
     }
-
     mrb_sys_fail(mrb, RSTRING_CSTR(mrb, mrb_format(mrb, "open %s", pathname)));
   }
   mrb_locale_free(fname);
@@ -928,18 +922,16 @@ 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;
+  mrb_int perm = -1;
 
   mrb_get_args(mrb, "S|oi", &path, &mode, &perm);
   if (perm < 0) {
     perm = 0666;
   }
 
-  pat = RSTRING_CSTR(mrb, path);
-  flags = io_mode_to_flags(mrb, mode);
-  fd = io_cloexec_open(mrb, pat, flags, (fmode_t)perm);
+  const char *pat = RSTRING_CSTR(mrb, path);
+  int flags = io_mode_to_flags(mrb, mode);
+  mrb_int fd = io_cloexec_open(mrb, pat, flags, (fmode_t)perm);
   return mrb_fixnum_value(fd);
 }
 
@@ -954,8 +946,6 @@ io_read_common(mrb_state *mrb,
     fssize_t (*readfunc)(int, void*, fsize_t, off_t),
     mrb_value io, mrb_value buf, mrb_int maxlen, off_t offset)
 {
-  int ret;
-
   if (maxlen < 0) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "negative expanding string size");
   }
@@ -975,7 +965,7 @@ io_read_common(mrb_state *mrb,
   }
 
   struct mrb_io *fptr = io_get_read_fptr(mrb, io);
-  ret = readfunc(fptr->fd, RSTRING_PTR(buf), (fsize_t)maxlen, offset);
+  int ret = readfunc(fptr->fd, RSTRING_PTR(buf), (fsize_t)maxlen, offset);
   if (ret < 0) {
     mrb_sys_fail(mrb, "sysread failed");
   }
@@ -1009,8 +999,6 @@ io_sysread(mrb_state *mrb, mrb_value io)
 static mrb_value
 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);
@@ -1018,8 +1006,8 @@ io_sysseek(mrb_state *mrb, mrb_value io)
     whence = 0;
   }
 
-  fptr = io_get_open_fptr(mrb, io);
-  pos = lseek(fptr->fd, (off_t)offset, (int)whence);
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
+  off_t pos = lseek(fptr->fd, (off_t)offset, (int)whence);
   if (pos == -1) {
     mrb_sys_fail(mrb, "sysseek");
   }
@@ -1047,11 +1035,8 @@ io_write_common(mrb_state *mrb,
     fssize_t (*writefunc)(int, const void*, fsize_t, off_t),
     struct mrb_io *fptr, const void *buf, mrb_ssize blen, off_t offset)
 {
-  int fd;
-  fssize_t length;
-
-  fd = io_get_write_fd(fptr);
-  length = writefunc(fd, buf, (fsize_t)blen, offset);
+  int fd = io_get_write_fd(fptr);
+  fssize_t length = writefunc(fd, buf, (fsize_t)blen, offset);
   if (length == -1) {
     mrb_sys_fail(mrb, "syswrite");
   }
@@ -1084,13 +1069,13 @@ io_syswrite(mrb_state *mrb, mrb_value io)
 static mrb_int
 fd_write(mrb_state *mrb, int fd, mrb_value str)
 {
-  fssize_t len, sum, n;
+  fssize_t n;
 
   str = mrb_obj_as_string(mrb, str);
-  len = (fssize_t)RSTRING_LEN(str);
-  if (len == 0)return 0;
+  fssize_t len = (fssize_t)RSTRING_LEN(str);
+  if (len == 0) return 0;
 
-  for (sum=0; sum<len; sum+=n) {
+  for (fssize_t sum=0; sum<len; sum+=n) {
     n = write(fd, RSTRING_PTR(str), (fsize_t)len);
     if (n == -1) {
       mrb_sys_fail(mrb, "syswrite");
@@ -1104,7 +1089,6 @@ io_write(mrb_state *mrb, mrb_value io)
 {
   struct mrb_io *fptr = io_get_write_fptr(mrb, io);
   int fd = io_get_write_fd(fptr);
-  mrb_int len = 0;
 
   if (fptr->buf && fptr->buf->len > 0) {
     off_t n;
@@ -1118,6 +1102,7 @@ io_write(mrb_state *mrb, mrb_value io)
     fptr->buf->start = fptr->buf->len = 0;
   }
 
+  mrb_int len = 0;
   if (mrb_get_argc(mrb) == 1) {
     len = fd_write(mrb, fd, mrb_get_arg1(mrb));
   }
@@ -1145,8 +1130,7 @@ io_close(mrb_state *mrb, mrb_value io)
 static mrb_value
 io_close_write(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
-  fptr = io_get_open_fptr(mrb, io);
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
   if (close((int)fptr->fd2) == -1) {
     mrb_sys_fail(mrb, "close");
   }
@@ -1156,8 +1140,7 @@ io_close_write(mrb_state *mrb, mrb_value io)
 static mrb_value
 io_closed(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
-  fptr = (struct mrb_io*)mrb_data_get_ptr(mrb, io, &mrb_io_type);
+  struct mrb_io *fptr = (struct mrb_io*)mrb_data_get_ptr(mrb, io, &mrb_io_type);
   if (fptr == NULL || fptr->fd >= 0) {
     return mrb_false_value();
   }
@@ -1183,8 +1166,7 @@ io_pos(mrb_state *mrb, mrb_value io)
 static mrb_value
 io_pid(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
-  fptr = io_get_open_fptr(mrb, io);
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
 
   if (fptr->pid > 0) {
     return mrb_fixnum_value(fptr->pid);
@@ -1260,16 +1242,12 @@ io_s_select(mrb_state *mrb, mrb_value klass)
 {
   const 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;
+  mrb_value read_io, list;
   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);
 
@@ -1277,17 +1255,18 @@ io_s_select(mrb_state *mrb, mrb_value klass)
     mrb_argnum_error(mrb, argc, 1, 4);
   }
 
-  timeout = mrb_nil_value();
-  except = mrb_nil_value();
-  write = mrb_nil_value();
+  mrb_value timeout = mrb_nil_value();
+  mrb_value except = mrb_nil_value();
+  mrb_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];
+  mrb_value read = argv[0];
 
+  struct timeval *tp, timerec;
   if (mrb_nil_p(timeout)) {
     tp = NULL;
   }
@@ -1296,12 +1275,13 @@ io_s_select(mrb_state *mrb, mrb_value klass)
     tp = &timerec;
   }
 
+  fd_set pset, rset, *rp;
   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++) {
+    for (int i = 0; i < RARRAY_LEN(read); i++) {
       read_io = RARRAY_PTR(read)[i];
       fptr = io_get_open_fptr(mrb, read_io);
       if (fptr->fd >= FD_SETSIZE) continue;
@@ -1322,11 +1302,12 @@ io_s_select(mrb_state *mrb, mrb_value klass)
     rp = NULL;
   }
 
+  fd_set wset, *wp;
   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++) {
+    for (int i = 0; i < RARRAY_LEN(write); i++) {
       fptr = io_get_open_fptr(mrb, RARRAY_PTR(write)[i]);
       if (fptr->fd >= FD_SETSIZE) continue;
       FD_SET(fptr->fd, wp);
@@ -1343,11 +1324,12 @@ io_s_select(mrb_state *mrb, mrb_value klass)
     wp = NULL;
   }
 
+  fd_set eset, *ep;
   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++) {
+    for (int i = 0; i < RARRAY_LEN(except); i++) {
       fptr = io_get_open_fptr(mrb, RARRAY_PTR(except)[i]);
       if (fptr->fd >= FD_SETSIZE) continue;
       FD_SET(fptr->fd, ep);
@@ -1366,6 +1348,7 @@ io_s_select(mrb_state *mrb, mrb_value klass)
 
   max++;
 
+  int n;
 retry:
   n = select(max, rp, wp, ep, tp);
   if (n < 0) {
@@ -1386,14 +1369,14 @@ retry:
     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));
+  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++) {
+      for (int i = 0; i < RARRAY_LEN(read); i++) {
         fptr = io_get_open_fptr(mrb, RARRAY_PTR(read)[i]);
         if (FD_ISSET(fptr->fd, rp) ||
             FD_ISSET(fptr->fd, &pset)) {
@@ -1404,7 +1387,7 @@ retry:
 
     if (wp) {
       list = RARRAY_PTR(result)[1];
-      for (i = 0; i < RARRAY_LEN(write); i++) {
+      for (int i = 0; i < RARRAY_LEN(write); i++) {
         fptr = io_get_open_fptr(mrb, RARRAY_PTR(write)[i]);
         if (FD_ISSET(fptr->fd, wp)) {
           mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
@@ -1417,7 +1400,7 @@ retry:
 
     if (ep) {
       list = RARRAY_PTR(result)[2];
-      for (i = 0; i < RARRAY_LEN(except); i++) {
+      for (int i = 0; i < RARRAY_LEN(except); i++) {
         fptr = io_get_open_fptr(mrb, RARRAY_PTR(except)[i]);
         if (FD_ISSET(fptr->fd, ep)) {
           mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
@@ -1435,8 +1418,7 @@ retry:
 int
 mrb_io_fileno(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
-  fptr = io_get_open_fptr(mrb, io);
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
   return fptr->fd;
 }
 
@@ -1451,11 +1433,9 @@ io_fileno(mrb_state *mrb, mrb_value io)
 static mrb_value
 io_close_on_exec_p(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
   int ret;
 
-  fptr = io_get_open_fptr(mrb, io);
-
   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();
@@ -1473,13 +1453,14 @@ io_close_on_exec_p(mrb_state *mrb, mrb_value io)
 static mrb_value
 io_set_close_on_exec(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
-  int flag, ret;
+
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
   mrb_bool b;
 
-  fptr = io_get_open_fptr(mrb, io);
   mrb_get_args(mrb, "b", &b);
-  flag = b ? FD_CLOEXEC : 0;
+
+  int flag = b ? FD_CLOEXEC : 0;
+  int ret;
 
   if (fptr->fd2 >= 0) {
     if ((ret = fcntl(fptr->fd2, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
@@ -1507,10 +1488,9 @@ io_set_close_on_exec(mrb_state *mrb, mrb_value io)
 static mrb_value
 io_set_sync(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
   mrb_bool b;
 
-  fptr = io_get_open_fptr(mrb, io);
   mrb_get_args(mrb, "b", &b);
   fptr->sync = b;
   return mrb_bool_value(b);
@@ -1519,8 +1499,7 @@ io_set_sync(mrb_state *mrb, mrb_value io)
 static mrb_value
 io_sync(mrb_state *mrb, mrb_value io)
 {
-  struct mrb_io *fptr;
-  fptr = io_get_open_fptr(mrb, io);
+  struct mrb_io *fptr = io_get_open_fptr(mrb, io);
   return mrb_bool_value(fptr->sync);
 }
 
@@ -1571,10 +1550,9 @@ io_ungetc(mrb_state *mrb, mrb_value io)
   struct mrb_io *fptr = io_get_read_fptr(mrb, io);
   struct mrb_io_buf *buf = fptr->buf;
   mrb_value str;
-  mrb_int len;
 
   mrb_get_args(mrb, "S", &str);
-  len = RSTRING_LEN(str);
+  mrb_int len = RSTRING_LEN(str);
   if (len > SHRT_MAX) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "string too long to ungetc");
   }
@@ -1756,10 +1734,9 @@ static mrb_value
 io_gets(mrb_state *mrb, mrb_value io)
 {
   mrb_value rs = mrb_nil_value();
-  mrb_int limit;
   mrb_bool rs_given = FALSE;    /* newline break */
+  mrb_int limit;
   mrb_bool limit_given = FALSE; /* no limit */
-  mrb_value outbuf;
   struct mrb_io *fptr = io_get_read_fptr(mrb, io);
   struct mrb_io_buf *buf = fptr->buf;
 
@@ -1804,6 +1781,7 @@ io_gets(mrb_state *mrb, mrb_value io)
   io_fill_buf(mrb, fptr);
   if (fptr->eof) return mrb_nil_value();
 
+  mrb_value outbuf;
   if (limit_given) {
     if (limit == 0) return mrb_str_new(mrb, NULL, 0);
     outbuf = mrb_str_new_capa(mrb, limit);
@@ -1932,9 +1910,7 @@ io_flush(mrb_state *mrb, mrb_value io)
 void
 mrb_init_io(mrb_state *mrb)
 {
-  struct RClass *io;
-
-  io      = mrb_define_class(mrb, "IO", mrb->object_class);
+  struct RClass *io = mrb_define_class(mrb, "IO", mrb->object_class);
   MRB_SET_INSTANCE_TT(io, MRB_TT_CDATA);
 
   mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */