esruby 0.0.9 → 0.0.10

data/resources/mruby/mrbgems/mruby-io/mrblib/io.rb

@@ -93,8 +93,9 @@ class IO
       if path[0] == "|"
         io = IO.popen(path[1..-1], (opt[:mode] || "r"))
       else
-        fd = IO.sysopen(path)
-        io = IO.open(fd, opt[:mode] || "r")
+        mode = opt[:mode] || "r"
+        fd = IO.sysopen(path, mode)
+        io = IO.open(fd, mode)
       end
       io.seek(offset) if offset > 0
       str = io.read(length)

data/resources/mruby/mrbgems/mruby-io/src/file.c

@@ -332,6 +332,20 @@ mrb_file__gethome(mrb_state *mrb, mrb_value klass)
 #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)
 {
@@ -471,6 +485,7 @@ 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());
 
   cnst = mrb_define_module_under(mrb, file, "Constants");
   mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));

data/resources/mruby/mrbgems/mruby-io/src/io.c

@@ -180,7 +180,7 @@ mrb_io_flags_to_modenum(mrb_state *mrb, int flags)
   return modenum;
 }
 
-void
+static void
 mrb_fd_cloexec(mrb_state *mrb, int fd)
 {
 #if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
@@ -188,7 +188,8 @@ mrb_fd_cloexec(mrb_state *mrb, int fd)
 
   flags = fcntl(fd, F_GETFD);
   if (flags == -1) {
-    mrb_sys_fail(mrb, "fcntl");
+    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. */
@@ -198,7 +199,8 @@ mrb_fd_cloexec(mrb_state *mrb, int fd)
   }
   if (flags != flags2) {
     if (fcntl(fd, F_SETFD, flags2) == -1) {
-      mrb_sys_fail(mrb, "fcntl");
+      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
@@ -577,11 +579,17 @@ mrb_io_initialize_copy(mrb_state *mrb, mrb_value copy)
   if (failed) {
     mrb_sys_fail(mrb, 0);
   }
-  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->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;
@@ -676,7 +684,7 @@ fptr_finalize(mrb_state *mrb, struct mrb_io *fptr, int quiet)
       io_set_process_status(mrb, pid, status);
     }
 #else
-    HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, fptr->pid); 
+    HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, fptr->pid);
     DWORD status;
     if (WaitForSingleObject(h, INFINITE) && GetExitCodeProcess(h, &status))
       if (!quiet)

data/resources/mruby/mrbgems/mruby-io/test/file.rb

@@ -54,7 +54,7 @@ assert('File.extname') do
   assert_equal '', File.extname('.foo')
 end
 
-assert('IO#flock') do
+assert('File#flock') do
   f = File.open $mrbtest_io_rfname
   begin
     assert_equal(f.flock(File::LOCK_SH), 0)
@@ -68,6 +68,22 @@ assert('IO#flock') do
   end
 end
 
+assert('File#mtime') do
+  unless Object.const_defined?(:Time)
+    skip "File#mtime require Time"
+  end
+  begin
+    now = Time.now.to_i
+    mt = 0
+    File.open('mtime-test', 'w') do |f|
+      mt = f.mtime.to_i
+    end
+    assert_equal true, mt >= now
+  ensure
+    File.delete('mtime-test')
+  end
+end
+
 assert('File.join') do
   assert_equal "", File.join()
   assert_equal "a", File.join("a")

data/resources/mruby/mrbgems/mruby-io/test/io.rb

@@ -216,6 +216,10 @@ assert('IO#dup for readable') do
   dup = io.dup
   assert_true io != dup
   assert_true io.fileno != dup.fileno
+  begin
+    assert_true dup.close_on_exec?
+  rescue NotImplementedError
+  end
   assert_equal 'm', dup.sysread(1)
   assert_equal 'r', io.sysread(1)
   assert_equal 'u', dup.sysread(1)

data/resources/mruby/mrbgems/mruby-pack/src/pack.c

@@ -107,6 +107,9 @@ static mrb_value
 str_len_ensure(mrb_state *mrb, mrb_value str, mrb_int len)
 {
   mrb_int n = RSTRING_LEN(str);
+  if (len < 0) {
+    mrb_raise(mrb, E_RANGE_ERROR, "negative (or overflowed) integer");
+  }
   if (len > n) {
     do {
       n *= 2;
@@ -515,7 +518,7 @@ utf8_to_uv(mrb_state *mrb, const char *p, long *lenp)
       c = *p++ & 0xff;
       if ((c & 0xc0) != 0x80) {
         *lenp -= n + 1;
-        mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character");
+        mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character");
       }
       else {
         c &= 0x3f;
@@ -525,7 +528,7 @@ utf8_to_uv(mrb_state *mrb, const char *p, long *lenp)
   }
   n = *lenp - 1;
   if (uv < utf8_limits[n]) {
-    mrb_raisef(mrb, E_ARGUMENT_ERROR, "redundant UTF-8 sequence");
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "redundant UTF-8 sequence");
   }
   return uv;
 }
@@ -726,7 +729,7 @@ pack_m(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, u
     count -= count % 3;
   }
 
-  dstlen = srclen / 3 * 4;
+  dstlen = (srclen+2) / 3 * 4;
   if (count > 0) {
     dstlen += (srclen / count) + ((srclen % count) == 0 ? 0 : 1);
   }
@@ -803,7 +806,7 @@ unpack_m(mrb_state *mrb, const void *src, int slen, mrb_value ary, unsigned int
 	  ch[i] = 0;
 	  padding++;
 	}
-      } while (ch[i] == PACK_BASE64_IGNORE);
+      } while (c >= sizeof(base64_dec_tab) || ch[i] == PACK_BASE64_IGNORE);
     }
 
     l = (ch[0] << 18) + (ch[1] << 12) + (ch[2] << 6) + ch[3];
@@ -833,16 +836,17 @@ pack_x(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, u
 {
   long i;
 
+  if (count < 0) return 0;
   dst = str_len_ensure(mrb, dst, didx + count);
   for (i = 0; i < count; i++) {
-    RSTRING_PTR(dst)[didx] = '\0';
+    RSTRING_PTR(dst)[didx + i] = '\0';
   }
   return count;
 }
-
 static int
 unpack_x(mrb_state *mrb, const void *src, int slen, mrb_value ary, int count, unsigned int flags)
 {
+  if (count < 0) return slen;
   if (slen < count) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "x outside of string");
   }
@@ -1050,6 +1054,9 @@ alias:
       count = ch - '0';
       while (tmpl->idx < tlen && isdigit(tptr[tmpl->idx])) {
         count = count * 10 + (tptr[tmpl->idx++] - '0');
+        if (count < 0) {
+          mrb_raisef(mrb, E_RUNTIME_ERROR, "too big template length");
+        }
       }
       continue;  /* special case */
     } else if (ch == '*')  {
@@ -1171,6 +1178,9 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary)
         count--;
       }
     }
+    if (ridx < 0) {
+      mrb_raise(mrb, E_RANGE_ERROR, "negative (or overflowed) template size");
+    }
   }
 
   mrb_str_resize(mrb, result, ridx);

data/resources/mruby/mrbgems/mruby-socket/mrbgem.rake

@@ -11,7 +11,7 @@ MRuby::Gem::Specification.new('mruby-socket') do |spec|
     spec.linker.libraries << "ws2_32"
   end
 
-  spec.add_dependency('mruby-io')
-  spec.add_dependency('mruby-pack')
+  spec.add_dependency('mruby-io', :core => 'mruby-io')
+  spec.add_dependency('mruby-pack', :core => 'mruby-pack')
   # spec.add_dependency('mruby-mtest')
 end

data/resources/mruby/mrbgems/mruby-socket/test/sockettest.c

@@ -2,18 +2,54 @@
 #include <stdlib.h>
 
 #include "mruby.h"
+#include "mruby/error.h"
+
+#if defined(_WIN32) || defined(_WIN64)
+
+#include <io.h>
+
+#ifdef _MSC_VER
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#define close _close
+#define unlink _unlink
+
+static int
+mkstemp(char *p)
+{
+  int fd;
+  char* fname = _mktemp(p);
+  if (fname == NULL)
+    return -1;
+  fd = open(fname, O_RDWR | O_CREAT | O_EXCL, _S_IREAD | _S_IWRITE);
+  if (fd >= 0)
+    return fd;
+  return -1;
+}
+#endif
+
+#else
+
+#include <unistd.h>
 
-#ifdef _WIN32
-  #define tempnam _tempnam
 #endif
 
 mrb_value
 mrb_sockettest_tmppath(mrb_state *mrb, mrb_value klass)
 {
-  char *tmp = tempnam(NULL, "mruby-socket");
-  mrb_value str = mrb_str_new_cstr(mrb, tmp);
-  free(tmp);
-  return str;
+  char name[] = "mruby-socket.XXXXXXXX";
+  int fd = mkstemp(name);
+  if (fd == -1) {
+    mrb_sys_fail(mrb, 0);
+  }
+  if (close(fd) == -1) {
+    mrb_sys_fail(mrb, 0);
+  }
+  if (unlink(name) == -1) {
+    mrb_sys_fail(mrb, 0);
+  }
+  return mrb_str_new_cstr(mrb, name);
 }
 
 mrb_value

data/resources/mruby/mrbgems/mruby-test/init_mrbtest.c

@@ -31,6 +31,7 @@ mrb_init_mrbtest(mrb_state *mrb)
 
   if (mrb->exc) {
     mrb_print_error(mrb);
+    mrb_close(mrb);
     exit(EXIT_FAILURE);
   }
   mrb_close(core_test);

data/resources/mruby/mrbgems/mruby-test/mrbgem.rake

@@ -101,6 +101,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
             end
             f.puts %Q[  if (mrb2->exc) {]
             f.puts %Q[    mrb_print_error(mrb2);]
+            f.puts %Q[    mrb_close(mrb2);]
             f.puts %Q[    exit(EXIT_FAILURE);]
             f.puts %Q[  }]
             f.puts %Q[  mrb_const_set(mrb2, mrb_obj_value(mrb2->object_class), mrb_intern_lit(mrb2, "GEMNAME"), mrb_str_new(mrb2, "#{g.name}", #{g.name.length}));]

data/resources/mruby/mrbgems/mruby-time/src/time.c

@@ -67,6 +67,11 @@ double round(double x) {
 /* define following macro to use probably faster timegm() on the platform */
 /* #define USE_SYSTEM_TIMEGM */
 
+/* time_t */
+/* If your platform supports time_t as uint (e.g. uint32_t, uint64_t), */
+/* uncomment following macro. */
+/* #define MRB_TIME_T_UINT */
+
 /** end of Time class configuration */
 
 #ifndef NO_GETTIMEOFDAY
@@ -138,8 +143,14 @@ timegm(struct tm *tm)
   int i;
   unsigned int *nday = (unsigned int*) ndays[is_leapyear(tm->tm_year+1900)];
 
-  for (i = 70; i < tm->tm_year; ++i)
-    r += is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
+  static const int epoch_year = 70;
+  if(tm->tm_year >= epoch_year) {
+    for (i = epoch_year; i < tm->tm_year; ++i)
+      r += is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
+  } else {
+    for (i = tm->tm_year; i < epoch_year; ++i)
+      r -= is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
+  }
   for (i = 0; i < tm->tm_mon; ++i)
     r += nday[i] * 24 * 60 * 60;
   r += (tm->tm_mday - 1) * 24 * 60 * 60;
@@ -234,13 +245,21 @@ time_alloc(mrb_state *mrb, double sec, double usec, enum mrb_timezone timezone)
 
   mrb_check_num_exact(mrb, (mrb_float)sec);
   mrb_check_num_exact(mrb, (mrb_float)usec);
-
+#ifndef MRB_TIME_T_UINT
   if (sizeof(time_t) == 4 && (sec > (double)INT32_MAX || (double)INT32_MIN > sec)) {
     goto out_of_range;
   }
   if (sizeof(time_t) == 8 && (sec > (double)INT64_MAX || (double)INT64_MIN > sec)) {
     goto out_of_range;
   }
+#else
+  if (sizeof(time_t) == 4 && (sec > (double)UINT32_MAX || (double)0 > sec)) {
+    goto out_of_range;
+  }
+  if (sizeof(time_t) == 8 && (sec > (double)UINT64_MAX || (double)0 > sec)) {
+    goto out_of_range;
+  }
+#endif
   tsec  = (time_t)sec;
   if ((sec > 0 && tsec < 0) || (sec < 0 && (double)tsec > sec)) {
   out_of_range:

data/resources/mruby/mrbgems/mruby-time/test/time.rb

@@ -226,3 +226,7 @@ assert('2000 times 500us make a second') do
   end
   t.usec == 0
 end
+
+assert('Time.gm with Dec 31 23:59:59 1969 raise ArgumentError') do
+  assert_raise(ArgumentError) {Time.gm(1969, 12, 31, 23, 59, 59)}
+end

data/resources/mruby/mrblib/array.rb

@@ -200,28 +200,27 @@ class Array
 
   ##
   # Quick sort
-  # a     : the array to sort
   # left  : the beginning of sort region
   # right : the end of sort region
-  def __sort_sub__(a, left, right, &block)
+  def __sort_sub__(left, right, &block)
     if left < right
       i = left
       j = right
-      pivot = a[i + (j - i) / 2]
+      pivot = self[i + (j - i) / 2]
       while true
-        while ((block)? block.call(a[i], pivot): (a[i] <=> pivot)) < 0
+        while ((block)? block.call(self[i], pivot): (self[i] <=> pivot)) < 0
           i += 1
         end
-        while ((block)? block.call(pivot, a[j]): (pivot <=> a[j])) < 0
+        while ((block)? block.call(pivot, self[j]): (pivot <=> self[j])) < 0
           j -= 1
         end
         break if (i >= j)
-        tmp = a[i]; a[i] = a[j]; a[j] = tmp;
+        tmp = self[i]; self[i] = self[j]; self[j] = tmp;
         i += 1
         j -= 1
       end
-      __sort_sub__(a, left, i-1, &block)
-      __sort_sub__(a, j+1, right, &block)
+      __sort_sub__(left, i-1, &block)
+      __sort_sub__(j+1, right, &block)
     end
   end
   #  private :__sort_sub__
@@ -232,7 +231,7 @@ class Array
   def sort!(&block)
     size = self.size
     if size > 1
-      __sort_sub__(self, 0, size - 1, &block)
+      __sort_sub__(0, size - 1, &block)
     end
     self
   end

data/resources/mruby/mrblib/enum.rb

@@ -325,7 +325,7 @@ module Enumerable
   #
   # ISO 15.3.2.2.19
   def sort(&block)
-    self.map{|*val| val.__svalue}.sort
+    self.map{|*val| val.__svalue}.sort(&block)
   end
 
   ##

data/resources/mruby/src/array.c

@@ -256,7 +256,6 @@ mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len)
   ary_modify(mrb, a);
   old_len = RARRAY_LEN(ary);
   if (old_len != new_len) {
-    ARY_SET_LEN(a, new_len);
     if (new_len < old_len) {
       ary_shrink_capa(mrb, a);
     }
@@ -264,6 +263,7 @@ mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len)
       ary_expand_capa(mrb, a, new_len);
       ary_fill_with_nil(ARY_PTR(a) + old_len, new_len - old_len);
     }
+    ARY_SET_LEN(a, new_len);
   }
 
   return ary;

data/resources/mruby/src/class.c

@@ -593,7 +593,7 @@ mrb_get_argv(mrb_state *mrb)
     n:      Symbol         [mrb_sym]
     d:      Data           [void*,mrb_data_type const] 2nd argument will be used to check data type so it won't be modified
     I:      Inline struct  [void*]
-    &:      Block          [mrb_value]
+    &:      Block          [mrb_value]            &! raises exception if no block given
     *:      rest argument  [mrb_value*,mrb_int]   The rest of the arguments as an array; *! avoid copy of the stack
     |:      optional                              Following arguments are optional
     ?:      optional given [mrb_bool]             true if preceding argument (optional) is given
@@ -937,6 +937,12 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         else {
           bp = mrb->c->stack + mrb->c->ci->argc + 1;
         }
+        if (*format == '!') {
+          format ++;
+          if (mrb_nil_p(*bp)) {
+            mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
+          }
+        }
         *p = *bp;
       }
       break;
@@ -1744,7 +1750,7 @@ mrb_class_path(mrb_state *mrb, struct RClass *c)
     return mrb_class_find_path(mrb, c);
   }
   else if (mrb_symbol_p(path)) {
-    /* topleve class/module */
+    /* toplevel class/module */
     const char *str;
     mrb_int len;
 

data/resources/mruby/src/error.c

@@ -229,7 +229,8 @@ mrb_exc_set(mrb_state *mrb, mrb_value exc)
   }
   else {
     mrb->exc = mrb_obj_ptr(exc);
-    if ((struct RBasic*)mrb->exc == mrb->gc.arena[mrb->gc.arena_idx-1]) {
+    if (mrb->gc.arena_idx > 0 &&
+        (struct RBasic*)mrb->exc == mrb->gc.arena[mrb->gc.arena_idx-1]) {
       mrb->gc.arena_idx--;
     }
     if (!mrb->gc.out_of_memory) {

data/resources/mruby/src/gc.c

@@ -658,7 +658,7 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
       struct REnv *e = (struct REnv*)obj;
       mrb_int i, len;
 
-      if (MRB_ENV_STACK_SHARED_P(e) && e->cxt->fib) {
+      if (MRB_ENV_STACK_SHARED_P(e) && e->cxt && e->cxt->fib) {
         mrb_gc_mark(mrb, (struct RBasic*)e->cxt->fib);
       }
       len = MRB_ENV_STACK_LEN(e);

data/resources/mruby/src/object.c

@@ -569,8 +569,8 @@ arg_error:
     mrb_raise(mrb, E_ARGUMENT_ERROR, "base specified for non string value");
   }
   tmp = convert_type(mrb, val, "Integer", "to_int", FALSE);
-  if (mrb_nil_p(tmp)) {
-    return mrb_to_integer(mrb, val, "to_i");
+  if (mrb_nil_p(tmp) || !mrb_fixnum_p(tmp)) {
+    tmp = mrb_to_integer(mrb, val, "to_i");
   }
   return tmp;
 }

data/resources/mruby/src/string.c

@@ -926,7 +926,7 @@ mrb_str_cmp_m(mrb_state *mrb, mrb_value str1)
     else {
       mrb_value tmp = mrb_funcall(mrb, str2, "<=>", 1, str1);
 
-      if (!mrb_nil_p(tmp)) return mrb_nil_value();
+      if (mrb_nil_p(tmp)) return mrb_nil_value();
       if (!mrb_fixnum_p(tmp)) {
         return mrb_funcall(mrb, mrb_fixnum_value(0), "-", 1, tmp);
       }
@@ -2542,10 +2542,10 @@ mrb_str_dump(mrb_state *mrb, mrb_value str)
         }
         else {
           *q++ = '\\';
-          q[2] = '0' + c % 8; c /= 8;
-          q[1] = '0' + c % 8; c /= 8;
-          q[0] = '0' + c % 8;
-          q += 3;
+          *q++ = 'x';
+          q[1] = mrb_digitmap[c % 16]; c /= 16;
+          q[0] = mrb_digitmap[c % 16];
+          q += 2;
         }
     }
   }
@@ -2685,9 +2685,9 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str)
     }
     else {
       buf[0] = '\\';
-      buf[3] = '0' + c % 8; c /= 8;
-      buf[2] = '0' + c % 8; c /= 8;
-      buf[1] = '0' + c % 8;
+      buf[1] = 'x';
+      buf[3] = mrb_digitmap[c % 16]; c /= 16;
+      buf[2] = mrb_digitmap[c % 16];
       mrb_str_cat(mrb, result, buf, 4);
       continue;
     }

data/resources/mruby/src/variable.c

@@ -955,27 +955,61 @@ find_class_sym(mrb_state *mrb, struct RClass *outer, struct RClass *c)
   return arg.sym;
 }
 
+static struct RClass*
+outer_class(mrb_state *mrb, struct RClass *c)
+{
+  mrb_value ov;
+
+  ov = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"));
+  if (mrb_nil_p(ov)) return NULL;
+  switch (mrb_type(ov)) {
+  case MRB_TT_CLASS:
+  case MRB_TT_MODULE:
+    return mrb_class_ptr(ov);
+  default:
+    break;
+  }
+  return NULL;
+}
+
+static mrb_bool
+detect_outer_loop(mrb_state *mrb, struct RClass *c)
+{
+  struct RClass *t = c;         /* tortoise */
+  struct RClass *h = c;         /* hare */
+
+  for (;;) {
+    if (h == NULL) return FALSE;
+    h = outer_class(mrb, h);
+    if (h == NULL) return FALSE;
+    h = outer_class(mrb, h);
+    t = outer_class(mrb, t);
+    if (t == h) return TRUE;
+  }
+}
+
 mrb_value
 mrb_class_find_path(mrb_state *mrb, struct RClass *c)
 {
-  mrb_value outer, path;
+  struct RClass *outer;
+  mrb_value path;
   mrb_sym name;
   const char *str;
   mrb_int len;
-  mrb_sym osym = mrb_intern_lit(mrb, "__outer__");
 
-  outer = mrb_obj_iv_get(mrb, (struct RObject*)c, osym);
-  if (mrb_nil_p(outer)) return outer;
-  name = find_class_sym(mrb, mrb_class_ptr(outer), c);
+  if (detect_outer_loop(mrb, c)) return mrb_nil_value();
+  outer = outer_class(mrb, c);
+  if (outer == NULL) return mrb_nil_value();
+  name = find_class_sym(mrb, outer, c);
   if (name == 0) return mrb_nil_value();
-  str = mrb_class_name(mrb, mrb_class_ptr(outer));
+  str = mrb_class_name(mrb, outer);
   path = mrb_str_new_capa(mrb, 40);
   mrb_str_cat_cstr(mrb, path, str);
   mrb_str_cat_cstr(mrb, path, "::");
 
   str = mrb_sym2name_len(mrb, name, &len);
   mrb_str_cat(mrb, path, str, len);
-  iv_del(mrb, c->iv, osym, NULL);
+  iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
   iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
   mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
   return path;

data/resources/mruby/src/vm.c

@@ -516,7 +516,7 @@ mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p)
   }
   ci->nregs = p->body.irep->nregs;
   if (ci->argc < 0) keep = 3;
-  else keep = ci->argc + 1;
+  else keep = ci->argc + 2;
   if (ci->nregs < keep) {
     stack_extend(mrb, keep);
   }
@@ -1351,6 +1351,7 @@ RETRY_TRY_BLOCK:
       for (n=0; n<a; n++) {
         proc = mrb->c->ensure[epos+n];
         mrb->c->ensure[epos+n] = NULL;
+        if (proc == NULL) continue;
         irep = proc->body.irep;
         ci = cipush(mrb);
         ci->mid = ci[-1].mid;
@@ -1661,6 +1662,9 @@ RETRY_TRY_BLOCK:
       if (MRB_METHOD_CFUNC_P(m)) {
         mrb_value v;
         ci->nregs = (argc < 0) ? 3 : n+2;
+        if (MRB_METHOD_PROC_P(m)) {
+          ci->proc = MRB_METHOD_PROC(m);
+        }
         v = MRB_METHOD_CFUNC(m)(mrb, recv);
         mrb_gc_arena_restore(mrb, ai);
         if (mrb->exc) goto L_RAISE;
@@ -2934,9 +2938,6 @@ RETRY_TRY_BLOCK:
     CASE(OP_STOP) {
       /*        stop VM */
     L_STOP:
-      while (mrb->c->ci > mrb->c->cibase) {
-        cipop(mrb);
-      }
       while (mrb->c->eidx > 0) {
         ecall(mrb);
       }