webruby 0.2.2 → 0.2.4

data/modules/mruby/src/vm.c

@@ -69,19 +69,23 @@ The value below allows about 60000 recursive calls in the simplest case. */
 #define TO_STR(x) TO_STR_(x)
 #define TO_STR_(x) #x
 
+#define ARENA_RESTORE(mrb,ai) (mrb)->arena_idx = (ai)
+
 static inline void
 stack_clear(mrb_value *from, size_t count)
 {
+#ifndef MRB_NAN_BOXING
   const mrb_value mrb_value_zero = { { 0 } };
 
   while (count-- > 0) {
-#ifndef MRB_NAN_BOXING
     *from++ = mrb_value_zero;
+  }
 #else
+  while (count-- > 0) {
     SET_NIL_VALUE(*from);
     from++;
-#endif
   }
+#endif
 }
 
 static inline void
@@ -128,39 +132,39 @@ envadjust(mrb_state *mrb, mrb_value *oldbase, mrb_value *newbase)
 /** def rec ; $deep =+ 1 ; if $deep > 1000 ; return 0 ; end ; rec ; end  */
 
 static void
+stack_extend_alloc(mrb_state *mrb, int room)
+{
+  mrb_value *oldbase = mrb->c->stbase;
+  int size = mrb->c->stend - mrb->c->stbase;
+  int off = mrb->c->stack - mrb->c->stbase;
+
+  /* Use linear stack growth.
+     It is slightly slower than doubling the stack space,
+     but it saves memory on small devices. */
+  if (room <= size)
+    size += MRB_STACK_GROWTH;
+  else
+    size += room;
+
+  mrb->c->stbase = (mrb_value *)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size);
+  mrb->c->stack = mrb->c->stbase + off;
+  mrb->c->stend = mrb->c->stbase + size;
+  envadjust(mrb, oldbase, mrb->c->stbase);
+  /* Raise an exception if the new stack size will be too large,
+     to prevent infinite recursion. However, do this only after resizing the stack, so mrb_raise has stack space to work with. */
+  if (size > MRB_STACK_MAX) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "stack level too deep. (limit=" TO_STR(MRB_STACK_MAX) ")");
+  }
+}
+
+static inline void
 stack_extend(mrb_state *mrb, int room, int keep)
 {
   if (mrb->c->stack + room >= mrb->c->stend) {
-    int size, off;
-
-    mrb_value *oldbase = mrb->c->stbase;
-
-    size = mrb->c->stend - mrb->c->stbase;
-    off = mrb->c->stack - mrb->c->stbase;
-
-    /* do not leave uninitialized malloc region */
-    if (keep > size) keep = size;
-
-    /* Use linear stack growth.
-       It is slightly slower than doubling thestack space,
-       but it saves memory on small devices. */
-    if (room <= size)
-      size += MRB_STACK_GROWTH;
-    else
-      size += room;
-
-    mrb->c->stbase = (mrb_value *)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size);
-    mrb->c->stack = mrb->c->stbase + off;
-    mrb->c->stend = mrb->c->stbase + size;
-    envadjust(mrb, oldbase, mrb->c->stbase);
-    /* Raise an exception if the new stack size will be too large,
-    to prevent infinite recursion. However, do this only after resizing the stack, so mrb_raise has stack space to work with. */
-    if (size > MRB_STACK_MAX) {
-      mrb_raise(mrb, E_RUNTIME_ERROR, "stack level too deep. (limit=" TO_STR(MRB_STACK_MAX) ")");
-    }
+    stack_extend_alloc(mrb, room);
   }
-
   if (room > keep) {
+    /* do not leave uninitialized malloc region */
     stack_clear(&(mrb->c->stack[keep]), room - keep);
   }
 }
@@ -355,7 +359,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mr
     p = mrb_method_search_vm(mrb, &c, mid);
     if (!p) {
       undef = mid;
-      mid = mrb_intern2(mrb, "method_missing", 14);
+      mid = mrb_intern_lit(mrb, "method_missing");
       p = mrb_method_search_vm(mrb, &c, mid);
       n++; argc++;
     }
@@ -488,7 +492,7 @@ localjump_error(mrb_state *mrb, localjump_error_kind kind)
   msg = mrb_str_buf_new(mrb, sizeof(lead) + 7);
   mrb_str_buf_cat(mrb, msg, lead, sizeof(lead) - 1);
   mrb_str_buf_cat(mrb, msg, kind_str[kind], kind_str_len[kind]);
-  exc = mrb_exc_new3(mrb, E_LOCALJUMP_ERROR, msg);
+  exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg);
   mrb->exc = mrb_obj_ptr(exc);
 }
 
@@ -507,11 +511,12 @@ argnum_error(mrb_state *mrb, int num)
     str = mrb_format(mrb, "wrong number of arguments (%S for %S)",
                   mrb_fixnum_value(mrb->c->ci->argc), mrb_fixnum_value(num));
   }
-  exc = mrb_exc_new3(mrb, E_ARGUMENT_ERROR, str);
+  exc = mrb_exc_new_str(mrb, E_ARGUMENT_ERROR, str);
   mrb->exc = mrb_obj_ptr(exc);
 }
 
-#define ERR_PC_HOOK(mrb, pc) mrb->c->ci->err = pc;
+#define ERR_PC_SET(mrb, pc) mrb->c->ci->err = pc;
+#define ERR_PC_CLR(mrb)     mrb->c->ci->err = 0;
 #ifdef ENABLE_DEBUG
 #define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
 #else
@@ -547,7 +552,7 @@ void mrb_gv_val_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
 #define CALL_MAXARGS 127
 
 mrb_value
-mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
+mrb_context_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
 {
   /* mrb_assert(mrb_proc_cfunc_p(proc)) */
   mrb_irep *irep = proc->body.irep;
@@ -595,7 +600,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   if (!mrb->c->stack) {
     stack_init(mrb);
   }
-  stack_extend(mrb, irep->nregs, irep->nregs);
+  stack_extend(mrb, irep->nregs, stack_keep);
   mrb->c->ci->err = pc;
   mrb->c->ci->proc = proc;
   mrb->c->ci->nregs = irep->nregs + 1;
@@ -616,7 +621,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
     CASE(OP_LOADL) {
       /* A Bx   R(A) := Pool(Bx) */
-      regs[GETARG_A(i)] = pool[GETARG_Bx(i)];
+      regs[GETARG_A(i)] =  pool[GETARG_Bx(i)];
       NEXT;
     }
 
@@ -688,8 +693,9 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
     CASE(OP_GETCV) {
       /* A B    R(A) := ivget(Sym(B)) */
-      ERR_PC_HOOK(mrb, pc);
+      ERR_PC_SET(mrb, pc);
       regs[GETARG_A(i)] = mrb_vm_cv_get(mrb, syms[GETARG_Bx(i)]);
+      ERR_PC_CLR(mrb);
       NEXT;
     }
 
@@ -703,8 +709,9 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       /* A B    R(A) := constget(Sym(B)) */
       mrb_value val;
 
-      ERR_PC_HOOK(mrb, pc);
+      ERR_PC_SET(mrb, pc);
       val = mrb_vm_const_get(mrb, syms[GETARG_Bx(i)]);
+      ERR_PC_CLR(mrb);
       regs = mrb->c->stack;
       regs[GETARG_A(i)] = val;
       NEXT;
@@ -721,8 +728,9 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       mrb_value val;
       int a = GETARG_A(i);
 
-      ERR_PC_HOOK(mrb, pc);
+      ERR_PC_SET(mrb, pc);
       val = mrb_const_get(mrb, regs[a], syms[GETARG_Bx(i)]);
+      ERR_PC_CLR(mrb);
       regs = mrb->c->stack;
       regs[a] = val;
       NEXT;
@@ -830,7 +838,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       /* Bx     ensure_push(SEQ[Bx]) */
       struct RProc *p;
 
-      p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_Bx(i)]);
+      p = mrb_closure_new(mrb, irep->reps[GETARG_Bx(i)]);
       /* push ensure_stack */
       if (mrb->c->esize <= mrb->c->ci->eidx) {
         if (mrb->c->esize == 0) mrb->c->esize = 16;
@@ -838,7 +846,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         mrb->c->ensure = (struct RProc **)mrb_realloc(mrb, mrb->c->ensure, sizeof(struct RProc*) * mrb->c->esize);
       }
       mrb->c->ensure[mrb->c->ci->eidx++] = p;
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -850,7 +858,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       for (n=0; n<a; n++) {
         ecall(mrb, --mrb->c->ci->eidx);
       }
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -891,7 +899,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       if (!m) {
         mrb_value sym = mrb_symbol_value(mid);
 
-        mid = mrb_intern2(mrb, "method_missing", 14);
+        mid = mrb_intern_lit(mrb, "method_missing");
         m = mrb_method_search_vm(mrb, &c, mid);
         if (n == CALL_MAXARGS) {
           mrb_ary_unshift(mrb, regs[a+1], sym);
@@ -1048,7 +1056,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       c = mrb->c->ci->target_class->super;
       m = mrb_method_search_vm(mrb, &c, mid);
       if (!m) {
-        mid = mrb_intern2(mrb, "method_missing", 14);
+        mid = mrb_intern_lit(mrb, "method_missing");
         m = mrb_method_search_vm(mrb, &c, mid);
         if (n == CALL_MAXARGS) {
           mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(ci->mid));
@@ -1156,7 +1164,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         rest->len = m1+len+m2;
       }
       regs[a+1] = stack[m1+r+m2];
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -1261,8 +1269,8 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
       L_RAISE:
         ci = mrb->c->ci;
-        mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern2(mrb, "lastpc", 6), mrb_cptr_value(mrb, pc));
-        mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern2(mrb, "ciidx", 5), mrb_fixnum_value(ci - mrb->c->cibase));
+        mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern_lit(mrb, "lastpc"), mrb_cptr_value(mrb, pc));
+        mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern_lit(mrb, "ciidx"), mrb_fixnum_value(ci - mrb->c->cibase));
         eidx = ci->eidx;
         if (ci == mrb->c->cibase) {
           if (ci->ridx == 0) goto L_STOP;
@@ -1279,10 +1287,12 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
             mrb->jmp = prev_jmp;
             mrb_longjmp(mrb);
           }
-          while (eidx > ci->eidx) {
-            ecall(mrb, --eidx);
+          if (ci > mrb->c->cibase) {
+            while (eidx > ci[-1].eidx) {
+              ecall(mrb, --eidx);
+            }
           }
-          if (ci == mrb->c->cibase) {
+          else if (ci == mrb->c->cibase) {
             if (ci->ridx == 0) {
               regs = mrb->c->stack = mrb->c->stbase;
               goto L_STOP;
@@ -1327,13 +1337,14 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
               goto L_RAISE;
             }
             if (mrb->c->prev->ci == mrb->c->prev->cibase) {
-              mrb_value exc = mrb_exc_new3(mrb, E_RUNTIME_ERROR, mrb_str_new(mrb, "double resume", 13));
+              mrb_value exc = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, mrb_str_new(mrb, "double resume", 13));
               mrb->exc = mrb_obj_ptr(exc);
               goto L_RAISE;
             }
             /* automatic yield at the end */
             mrb->c->status = MRB_FIBER_TERMINATED;
             mrb->c = mrb->c->prev;
+            mrb->c->status = MRB_FIBER_RUNNING;
           }
           ci = mrb->c->ci;
           break;
@@ -1386,7 +1397,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       if (!m) {
         mrb_value sym = mrb_symbol_value(mid);
 
-        mid = mrb_intern2(mrb, "method_missing", 14);
+        mid = mrb_intern_lit(mrb, "method_missing");
         m = mrb_method_search_vm(mrb, &c, mid);
         if (n == CALL_MAXARGS) {
           mrb_ary_unshift(mrb, regs[a+1], sym);
@@ -1530,7 +1541,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       default:
         goto L_SEND;
       }
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -1847,7 +1858,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     CASE(OP_ARRAY) {
       /* A B C          R(A) := ary_new(R(B),R(B+1)..R(B+C)) */
       regs[GETARG_A(i)] = mrb_ary_new_from_values(mrb, GETARG_C(i), &regs[GETARG_B(i)]);
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -1855,7 +1866,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       /* A B            mrb_ary_concat(R(A),R(B)) */
       mrb_ary_concat(mrb, regs[GETARG_A(i)],
                      mrb_ary_splat(mrb, regs[GETARG_B(i)]));
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -1927,14 +1938,14 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
           }
         }
       }
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
     CASE(OP_STRING) {
       /* A Bx           R(A) := str_new(Lit(Bx)) */
-      regs[GETARG_A(i)] = mrb_str_literal(mrb, pool[GETARG_Bx(i)]);
-      mrb_gc_arena_restore(mrb, ai);
+      regs[GETARG_A(i)] = mrb_str_dup(mrb, pool[GETARG_Bx(i)]);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -1956,7 +1967,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         b+=2;
       }
       regs[GETARG_A(i)] = hash;
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -1966,14 +1977,14 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       int c = GETARG_c(i);
 
       if (c & OP_L_CAPTURE) {
-        p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
+        p = mrb_closure_new(mrb, irep->reps[GETARG_b(i)]);
       }
       else {
-        p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
+        p = mrb_proc_new(mrb, irep->reps[GETARG_b(i)]);
       }
       if (c & OP_L_STRICT) p->flags |= MRB_PROC_STRICT;
       regs[GETARG_A(i)] = mrb_obj_value(p);
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -1997,7 +2008,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       }
       c = mrb_vm_define_class(mrb, base, super, id);
       regs[a] = mrb_obj_value(c);
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -2014,7 +2025,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       }
       c = mrb_vm_define_module(mrb, base, id);
       regs[a] = mrb_obj_value(c);
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -2037,7 +2048,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       /* prepare stack */
       mrb->c->stack += a;
 
-      p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_Bx(i)]);
+      p = mrb_proc_new(mrb, irep->reps[GETARG_Bx(i)]);
       p->target_class = ci->target_class;
       ci->proc = p;
 
@@ -2068,14 +2079,14 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       struct RClass *c = mrb_class_ptr(regs[a]);
 
       mrb_define_method_vm(mrb, c, syms[GETARG_B(i)], regs[a+1]);
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
     CASE(OP_SCLASS) {
       /* A B    R(A) := R(B).singleton_class */
       regs[GETARG_A(i)] = mrb_singleton_class(mrb, regs[GETARG_B(i)]);
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -2095,7 +2106,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       /* A B C  R(A) := range_new(R(B),R(B+1),C) */
       int b = GETARG_B(i);
       regs[GETARG_A(i)] = mrb_range_new(mrb, regs[b], regs[b+1], GETARG_C(i));
-      mrb_gc_arena_restore(mrb, ai);
+      ARENA_RESTORE(mrb, ai);
       NEXT;
     }
 
@@ -2119,6 +2130,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
           ecall(mrb, n);
         }
       }
+      mrb->c->ci->err = 0;
       mrb->jmp = prev_jmp;
       if (mrb->exc) {
         return mrb_obj_value(mrb->exc);
@@ -2128,14 +2140,14 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
     CASE(OP_ERR) {
       /* Bx     raise RuntimeError with message Lit(Bx) */
-      mrb_value msg = pool[GETARG_Bx(i)];
+      mrb_value msg = mrb_str_dup(mrb, pool[GETARG_Bx(i)]);
       mrb_value exc;
 
       if (GETARG_A(i) == 0) {
-        exc = mrb_exc_new3(mrb, E_RUNTIME_ERROR, msg);
+        exc = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, msg);
       }
       else {
-        exc = mrb_exc_new3(mrb, E_LOCALJUMP_ERROR, msg);
+        exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg);
       }
       mrb->exc = mrb_obj_ptr(exc);
       goto L_RAISE;
@@ -2144,6 +2156,12 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   END_DISPATCH;
 }
 
+mrb_value
+mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
+{
+    return mrb_context_run(mrb, proc, self, mrb->c->ci->argc + 2); /* argc + 2 (receiver and block) */
+}
+
 void
 mrb_longjmp(mrb_state *mrb)
 {

data/modules/mruby/tasks/mruby_build.rake

@@ -87,6 +87,11 @@ module MRuby
       MRuby.targets[@name].instance_eval(&block)
     end
 
+    def enable_debug
+      compilers.each { |c| c.defines += %w(MRB_DEBUG) }
+      @mrbc.compile_options += ' -g'
+    end
+
     def toolchain(name)
       tc = Toolchain.toolchains[name.to_s]
       fail "Unknown #{name} toolchain" unless tc
@@ -98,7 +103,7 @@ module MRuby
     end
 
     def mrbcfile
-      MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc")
+      MRuby.targets[@name].exefile("#{MRuby.targets[@name].build_dir}/bin/mrbc")
     end
 
     def compilers
@@ -199,6 +204,10 @@ module MRuby
   super
     end
 
+    def mrbcfile
+      MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc")
+    end
+
     def run_test
       mrbtest = exefile("#{build_dir}/test/mrbtest")
       if (@test_runner.command == nil)

data/modules/mruby/tasks/toolchains/gcc.rake

@@ -1,7 +1,7 @@
 MRuby::Toolchain.new(:gcc) do |conf|
-  [conf.cc, conf.cxx, conf.objc, conf.asm].each do |cc|
+  [conf.cc, conf.objc, conf.asm].each do |cc|
     cc.command = ENV['CC'] || 'gcc'
-    cc.flags = [ENV['CFLAGS'] || %w(-g -O3 -Wall -Werror-implicit-function-declaration)]
+    cc.flags = [ENV['CFLAGS'] || %w(-g -std=gnu99 -O3 -Wall -Werror-implicit-function-declaration)]
     cc.include_paths = ["#{MRUBY_ROOT}/include"]
     cc.defines = %w(DISABLE_GEMS)
     cc.option_include_path = '-I%s'
@@ -9,6 +9,16 @@ MRuby::Toolchain.new(:gcc) do |conf|
     cc.compile_options = '%{flags} -MMD -o %{outfile} -c %{infile}'
   end
 
+  [conf.cxx].each do |cxx|
+    cxx.command = ENV['CXX'] || 'g++'
+    cxx.flags = [ENV['CXXFLAGS'] || ENV['CFLAGS'] || %w(-g -O3 -Wall -Werror-implicit-function-declaration)]
+    cxx.include_paths = ["#{MRUBY_ROOT}/include"]
+    cxx.defines = %w(DISABLE_GEMS)
+    cxx.option_include_path = '-I%s'
+    cxx.option_define = '-D%s'
+    cxx.compile_options = '%{flags} -MMD -o %{outfile} -c %{infile}'
+  end
+
   conf.linker do |linker|
     linker.command = ENV['LD'] || 'gcc'
     linker.flags = [ENV['LDFLAGS'] || %w()]

data/modules/mruby/tasks/toolchains/{vs2012.rake → visualcpp.rake}

@@ -1,4 +1,4 @@
-MRuby::Toolchain.new(:vs2012) do |conf|
+MRuby::Toolchain.new(:visualcpp) do |conf|
   [conf.cc, conf.cxx].each do |cc|
     cc.command = ENV['CC'] || 'cl.exe'
     cc.flags = [ENV['CFLAGS'] || %w(/c /nologo /W3 /D_DEBUG /MDd /Zi /Od /RTC1 /DHAVE_STRING_H /DNO_GETTIMEOFDAY /D_CRT_SECURE_NO_WARNINGS)]

data/modules/mruby/test/driver.c

@@ -34,8 +34,8 @@ check_error(mrb_state *mrb)
 {
   /* Error check */
   /* $ko_test and $kill_test should be 0 */
-  mrb_value ko_test = mrb_gv_get(mrb, mrb_intern2(mrb, "$ko_test", 8));
-  mrb_value kill_test = mrb_gv_get(mrb, mrb_intern2(mrb, "$kill_test", 10));
+  mrb_value ko_test = mrb_gv_get(mrb, mrb_intern(mrb, "$ko_test", 8));
+  mrb_value kill_test = mrb_gv_get(mrb, mrb_intern(mrb, "$kill_test", 10));
 
   return mrb_fixnum_p(ko_test) && mrb_fixnum(ko_test) == 0 && mrb_fixnum_p(kill_test) && mrb_fixnum(kill_test) == 0;
 }
@@ -104,7 +104,7 @@ main(int argc, char **argv)
 
   if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'v') {
     printf("verbose mode: enable\n\n");
-    mrb_gv_set(mrb, mrb_intern2(mrb, "$mrbtest_verbose", 16), mrb_true_value());
+    mrb_gv_set(mrb, mrb_intern(mrb, "$mrbtest_verbose", 16), mrb_true_value());
   }
 
   krn = mrb->kernel_module;

data/modules/mruby/test/t/array.rb

@@ -17,7 +17,11 @@ assert('Array.[]', '15.2.12.4.1') do
   assert_equal([1, 2, 3], Array.[](1,2,3))
 end
 
-assert('Array#*', '15.2.12.5.1') do
+assert('Array#+', '15.2.12.5.1') do
+  assert_equal([1, 1], [1].+([1]))
+end
+
+assert('Array#*', '15.2.12.5.2') do
   assert_raise(ArgumentError) do
     # this will cause an exception due to the wrong argument
     [1].*(-1)
@@ -26,10 +30,6 @@ assert('Array#*', '15.2.12.5.1') do
   assert_equal([], [1].*(0))
 end
 
-assert('Array#+', '15.2.12.5.2') do
-  assert_equal([1, 1], [1].+([1]))
-end
-
 assert('Array#<<', '15.2.12.5.3') do
   assert_equal([1, 1], [1].<<(1))
 end

data/modules/mruby/test/t/class.rb

@@ -9,7 +9,15 @@ assert('Class superclass', '15.2.3.2') do
   assert_equal(Module, Class.superclass)
 end
 
-# Class#initialize '15.2.3.3.1' is tested in Class#new
+assert('Class#initialize', '15.2.3.3.1') do
+  c = Class.new do
+    def test
+      :test
+    end
+  end.new
+
+  assert_equal(c.test, :test)
+end
 
 assert('Class#initialize_copy', '15.2.3.3.2') do
   class TestClass
@@ -222,6 +230,11 @@ assert('Class new') do
   assert_equal(Class, Class.new.class)
 end
 
+assert('class to return the last value') do
+  m = class C; :m end
+  assert_equal(m, :m)
+end
+
 assert('Class#inherited') do
   class Foo
     @@subclass_name = nil

data/modules/mruby/test/t/kernel.rb

@@ -281,6 +281,10 @@ end
 assert('Kernel#is_a?', '15.3.1.3.24') do
   assert_true is_a?(Kernel)
   assert_false is_a?(Array)
+
+  assert_raise TypeError do
+    42.is_a?(42)
+  end
 end
 
 assert('Kernel#iterator?', '15.3.1.3.25') do

data/modules/mruby/test/t/module.rb

@@ -276,16 +276,16 @@ end
 assert('Module.constants', '15.2.2.4.24') do
   $n = []
   module TestA
-    Const = 1
+    C = 1
   end
   class TestB
     include TestA
-    Const2 = 1
+    C2 = 1
     $n = constants.sort
   end
 
-  assert_equal [ :Const ], TestA.constants
-  assert_equal [ :Const, :Const2 ], $n
+  assert_equal [ :C ], TestA.constants
+  assert_equal [ :C, :C2 ], $n
 end
 
 assert('Module#include', '15.2.2.4.27') do

data/modules/mruby/test/t/nameerror.rb

@@ -20,7 +20,7 @@ assert('NameError#name', '15.2.31.2.1') do
     $test_dummy_result = e.name
   end
 
-  assert_equal $test_dummy_result, :bar
+  assert_equal :bar, $test_dummy_result
 end
 
 assert('NameError#initialize', '15.2.31.2.2') do