From 891839b976c75c77f238931123ac472e3284e95d Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Thu, 24 May 2018 15:19:06 +0900
Subject: New bytecode implementation of mruby VM.

---
 include/mruby.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'include/mruby.h')

diff --git a/include/mruby.h b/include/mruby.h
index b0bfe78b5..7cbc690b3 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -93,7 +93,7 @@
  */
 MRB_BEGIN_DECL
 
-typedef uint32_t mrb_code;
+typedef uint8_t mrb_code;
 
 /**
  * Required arguments signature type.
@@ -123,9 +123,9 @@ typedef struct {
   mrb_sym mid;
   struct RProc *proc;
   mrb_value *stackent;
-  int nregs;
-  int ridx;
-  int epos;
+  uint16_t nregs;
+  uint16_t ridx;
+  uint16_t epos;
   struct REnv *env;
   mrb_code *pc;                 /* return address */
   mrb_code *err;                /* error position */
@@ -152,10 +152,10 @@ struct mrb_context {
   mrb_callinfo *ci;
   mrb_callinfo *cibase, *ciend;
 
-  mrb_code **rescue;                      /* exception handler stack */
+  uint16_t *rescue;                       /* exception handler stack */
   int rsize;
   struct RProc **ensure;                  /* ensure handler stack */
-  int esize, eidx;
+  uint8_t esize, eidx;
 
   enum mrb_fiber_state status;
   mrb_bool vmexec;
@@ -486,9 +486,10 @@ MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_
  *     }
  * @param [mrb_state*] mrb_state* The mruby state reference.
  * @param [struct RClass*] RClass* A class the method will be undefined from.
- * @param [const char*] constchar* The name of the method to be undefined.
+ * @param [const char] const char* The name of the method to be undefined.
  */
 MRB_API void mrb_undef_method(mrb_state*, struct RClass*, const char*);
+MRB_API void mrb_undef_method_id(mrb_state*, struct RClass*, mrb_sym);
 
 /**
  * Undefine a class method.
@@ -1197,7 +1198,6 @@ typedef enum call_type {
   CALL_TYPE_MAX
 } call_type;
 
-MRB_API void mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2);
 MRB_API const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
 MRB_API void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
 
-- 
cgit v1.2.3


From 91c08d7631e0495bf29d8b8910cca2073f8b192b Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Wed, 1 Aug 2018 13:18:32 +0900
Subject: Remove `nregs` member from `mrb_callinfo`.

This means reducing one word per a call frame.
---
 include/mruby.h                 |  1 -
 mrbgems/mruby-fiber/src/fiber.c |  1 -
 src/gc.c                        | 32 +++++++++++---
 src/vm.c                        | 97 ++++++++++++++++++++++++-----------------
 4 files changed, 83 insertions(+), 48 deletions(-)

(limited to 'include/mruby.h')

diff --git a/include/mruby.h b/include/mruby.h
index 7cbc690b3..12ddb95b3 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -123,7 +123,6 @@ typedef struct {
   mrb_sym mid;
   struct RProc *proc;
   mrb_value *stackent;
-  uint16_t nregs;
   uint16_t ridx;
   uint16_t epos;
   struct REnv *env;
diff --git a/mrbgems/mruby-fiber/src/fiber.c b/mrbgems/mruby-fiber/src/fiber.c
index 27b74dba5..17ce77c5d 100644
--- a/mrbgems/mruby-fiber/src/fiber.c
+++ b/mrbgems/mruby-fiber/src/fiber.c
@@ -127,7 +127,6 @@ fiber_init(mrb_state *mrb, mrb_value self)
   ci->proc = p;
   mrb_field_write_barrier(mrb, (struct RBasic*)mrb_obj_ptr(self), (struct RBasic*)p);
   ci->pc = p->body.irep->iseq;
-  ci->nregs = p->body.irep->nregs;
   ci[1] = ci[0];
   c->ci++;                      /* push dummy callinfo */
 
diff --git a/src/gc.c b/src/gc.c
index c52641959..33d83f28e 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -548,21 +548,39 @@ add_gray_list(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
   gc->gray_list = obj;
 }
 
+static int
+ci_nregs(mrb_callinfo *ci)
+{
+  struct RProc *p = ci->proc;
+  int n = 0;
+
+  if (!p) {
+    if (ci->argc < 0) return 3;
+    return ci->argc+2;
+  }
+  if (!MRB_PROC_CFUNC_P(p) && p->body.irep) {
+    n = p->body.irep->nregs;
+  }
+  if (ci->argc < 0) {
+    if (n < 3) n = 3; /* self + args + blk */
+  }
+  if (ci->argc > n) {
+    n = ci->argc + 2; /* self + blk */
+  }
+  return n;
+}
+
 static void
 mark_context_stack(mrb_state *mrb, struct mrb_context *c)
 {
   size_t i;
   size_t e;
   mrb_value nil;
-  mrb_int nregs;
 
   if (c->stack == NULL) return;
   e = c->stack - c->stbase;
   if (c->ci) {
-    nregs = c->ci->argc + 2;
-    if (c->ci->nregs > nregs)
-      nregs = c->ci->nregs;
-    e += nregs;
+    e += ci_nregs(c->ci);
   }
   if (c->stbase + e > c->stend) e = c->stend - c->stbase;
   for (i=0; i<e; i++) {
@@ -950,7 +968,9 @@ gc_gray_mark(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
       if (!c) break;
       /* mark stack */
       i = c->stack - c->stbase;
-      if (c->ci) i += c->ci->nregs;
+      if (c->ci) {
+        i += ci_nregs(c->ci);
+      }
       if (c->stbase + i > c->stend) i = c->stend - c->stbase;
       children += i;
 
diff --git a/src/vm.c b/src/vm.c
index d47b4c7fc..91c617a83 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -356,7 +356,6 @@ ecall(mrb_state *mrb)
   ci->acc = CI_ACC_SKIP;
   ci->argc = 0;
   ci->proc = p;
-  ci->nregs = p->body.irep->nregs;
   ci->target_class = MRB_PROC_TARGET_CLASS(p);
   env = MRB_PROC_ENV(p);
   mrb_assert(env);
@@ -396,6 +395,30 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...)
   return mrb_funcall_argv(mrb, self, mid, argc, argv);
 }
 
+static int
+ci_nregs(mrb_callinfo *ci)
+{
+  struct RProc *p;
+  int n = 0;
+
+  if (!ci) return 3;
+  p = ci->proc;
+  if (!p) {
+    if (ci->argc < 0) return 3;
+    return ci->argc+2;
+  }
+  if (!MRB_PROC_CFUNC_P(p) && p->body.irep) {
+    n = p->body.irep->nregs;
+  }
+  if (ci->argc < 0) {
+    if (n < 3) n = 3; /* self + args + blk */
+  }
+  if (ci->argc > n) {
+    n = ci->argc + 2; /* self + blk */
+  }
+  return n;
+}
+
 MRB_API mrb_value
 mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv, mrb_value blk)
 {
@@ -426,13 +449,12 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
     mrb_method_t m;
     struct RClass *c;
     mrb_callinfo *ci;
-    int n;
+    int n = ci_nregs(mrb->c->ci);
     ptrdiff_t voff = -1;
 
     if (!mrb->c->stack) {
       stack_init(mrb);
     }
-    n = mrb->c->ci->nregs;
     if (argc < 0) {
       mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%S)", mrb_fixnum_value(argc));
     }
@@ -463,22 +485,22 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
       voff = argv - mrb->c->stbase;
     }
     if (MRB_METHOD_CFUNC_P(m)) {
-      ci->nregs = (int)(argc + 2);
-      mrb_stack_extend(mrb, ci->nregs);
+      mrb_stack_extend(mrb, argc + 2);
     }
     else if (argc >= CALL_MAXARGS) {
       mrb_value args = mrb_ary_new_from_values(mrb, argc, argv);
-      mrb_stack_extend(mrb, ci->nregs+2);
+
+      mrb_stack_extend(mrb, 3);
       mrb->c->stack[1] = args;
       ci->argc = -1;
       argc = 1;
     }
     else {
       struct RProc *p = MRB_METHOD_PROC(m);
+
       ci->proc = p;
       if (argc < 0) argc = 1;
-      ci->nregs = (int)(p->body.irep->nregs + argc);
-      mrb_stack_extend(mrb, ci->nregs);
+      mrb_stack_extend(mrb, p->body.irep->nregs + argc);
     }
     if (voff >= 0) {
       argv = mrb->c->stbase + voff;
@@ -520,26 +542,25 @@ mrb_value
 mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p)
 {
   mrb_callinfo *ci = mrb->c->ci;
-  int keep;
+  int keep, nregs;
 
   mrb->c->stack[0] = self;
   ci->proc = p;
   if (MRB_PROC_CFUNC_P(p)) {
     return MRB_PROC_CFUNC(p)(mrb, self);
   }
-  ci->nregs = p->body.irep->nregs;
+  nregs = p->body.irep->nregs;
   if (ci->argc < 0) keep = 3;
   else keep = ci->argc + 2;
-  if (ci->nregs < keep) {
+  if (nregs < keep) {
     mrb_stack_extend(mrb, keep);
   }
   else {
-    mrb_stack_extend(mrb, ci->nregs);
-    stack_clear(mrb->c->stack+keep, ci->nregs-keep);
+    mrb_stack_extend(mrb, nregs);
+    stack_clear(mrb->c->stack+keep, nregs-keep);
   }
 
   ci = cipush(mrb);
-  ci->nregs = 0;
   ci->target_class = 0;
   ci->pc = p->body.irep->iseq;
   ci->stackent = mrb->c->stack;
@@ -618,6 +639,7 @@ eval_under(mrb_state *mrb, mrb_value self, mrb_value blk, struct RClass *c)
 {
   struct RProc *p;
   mrb_callinfo *ci;
+  int nregs;
 
   if (mrb_nil_p(blk)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
@@ -639,13 +661,12 @@ eval_under(mrb_state *mrb, mrb_value self, mrb_value blk, struct RClass *c)
     mrb->c->stack[2] = mrb_nil_value();
     return MRB_PROC_CFUNC(p)(mrb, self);
   }
-  ci->nregs = p->body.irep->nregs;
-  mrb_stack_extend(mrb, (ci->nregs < 3) ? 3 : ci->nregs);
+  nregs = p->body.irep->nregs;
+  mrb_stack_extend(mrb, (nregs < 3) ? 3 : nregs);
   mrb->c->stack[0] = self;
   mrb->c->stack[1] = self;
   mrb->c->stack[2] = mrb_nil_value();
   ci = cipush(mrb);
-  ci->nregs = 0;
   ci->target_class = 0;
   ci->pc = p->body.irep->iseq;
   ci->stackent = mrb->c->stack;
@@ -728,13 +749,15 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value
   struct RProc *p;
   mrb_sym mid = mrb->c->ci->mid;
   mrb_callinfo *ci;
-  int n = mrb->c->ci->nregs;
   mrb_value val;
+  int n;
 
   if (mrb_nil_p(b)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
   }
-  if (mrb->c->ci - mrb->c->cibase > MRB_FUNCALL_DEPTH_MAX) {
+  ci = mrb->c->ci;
+  n = ci_nregs(ci);
+  if (ci - mrb->c->cibase > MRB_FUNCALL_DEPTH_MAX) {
     mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
   }
   p = mrb_proc_ptr(b);
@@ -745,9 +768,9 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value
   ci->argc = (int)argc;
   ci->target_class = c;
   ci->acc = CI_ACC_SKIP;
+  n = MRB_PROC_CFUNC_P(p) ? (int)(argc+2) : p->body.irep->nregs;
   mrb->c->stack = mrb->c->stack + n;
-  ci->nregs = MRB_PROC_CFUNC_P(p) ? (int)(argc+2) : p->body.irep->nregs;
-  mrb_stack_extend(mrb, ci->nregs);
+  mrb_stack_extend(mrb, n);
 
   mrb->c->stack[0] = self;
   if (argc > 0) {
@@ -1008,7 +1031,6 @@ RETRY_TRY_BLOCK:
   }
   mrb->jmp = &c_jmp;
   mrb->c->ci->proc = proc;
-  mrb->c->ci->nregs = irep->nregs;
 
 #define regs (mrb->c->stack)
   INIT_DISPATCH {
@@ -1296,6 +1318,8 @@ RETRY_TRY_BLOCK:
       if (a > (int)mrb->c->eidx - epos)
         a = mrb->c->eidx - epos;
       for (n=0; n<a; n++) {
+        int nregs = irep->nregs;
+
         proc = mrb->c->ensure[epos+n];
         mrb->c->ensure[epos+n] = NULL;
         if (proc == NULL) continue;
@@ -1305,12 +1329,11 @@ RETRY_TRY_BLOCK:
         ci->argc = 0;
         ci->proc = proc;
         ci->stackent = mrb->c->stack;
-        ci->nregs = irep->nregs;
         ci->target_class = target_class;
         ci->pc = pc;
-        ci->acc = ci[-1].nregs;
+        ci->acc = nregs;
         mrb->c->stack += ci->acc;
-        mrb_stack_extend(mrb, ci->nregs);
+        mrb_stack_extend(mrb, irep->nregs);
         regs[0] = self;
         pc = irep->iseq;
       }
@@ -1350,7 +1373,7 @@ RETRY_TRY_BLOCK:
       mrb_value recv, blk;
       mrb_sym mid = syms[b];
 
-      mrb_assert(bidx < ci->nregs);
+      mrb_assert(bidx < irep->nregs);
 
       recv = regs[a];
       blk = regs[bidx];
@@ -1396,7 +1419,6 @@ RETRY_TRY_BLOCK:
       mrb->c->stack += a;
 
       if (MRB_METHOD_CFUNC_P(m)) {
-        ci->nregs = (argc < 0) ? 3 : c+2;
         if (MRB_METHOD_PROC_P(m)) {
           struct RProc *p = MRB_METHOD_PROC(m);
 
@@ -1442,8 +1464,7 @@ RETRY_TRY_BLOCK:
         irep = proc->body.irep;
         pool = irep->pool;
         syms = irep->syms;
-        ci->nregs = irep->nregs;
-        mrb_stack_extend(mrb, (argc < 0 && ci->nregs < 3) ? 3 : ci->nregs);
+        mrb_stack_extend(mrb, (argc < 0 && irep->nregs < 3) ? 3 : irep->nregs);
         pc = irep->iseq;
         JUMP;
       }
@@ -1498,8 +1519,7 @@ RETRY_TRY_BLOCK:
         }
         pool = irep->pool;
         syms = irep->syms;
-        ci->nregs = irep->nregs;
-        mrb_stack_extend(mrb, ci->nregs);
+        mrb_stack_extend(mrb, irep->nregs);
         if (ci->argc < 0) {
           if (irep->nregs > 3) {
             stack_clear(regs+3, irep->nregs-3);
@@ -1526,7 +1546,7 @@ RETRY_TRY_BLOCK:
       mrb_sym mid = ci->mid;
       struct RClass* target_class = MRB_PROC_TARGET_CLASS(ci->proc);
 
-      mrb_assert(bidx < ci->nregs);
+      mrb_assert(bidx < irep->nregs);
 
       if (mid == 0 || !target_class) {
         mrb_value exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
@@ -1572,7 +1592,7 @@ RETRY_TRY_BLOCK:
         }
         mid = missing;
         if (argc >= 0) {
-          if (a+2 >= ci->nregs) {
+          if (a+2 >= irep->nregs) {
             mrb_stack_extend(mrb, a+3);
           }
           regs[a+1] = mrb_ary_new_from_values(mrb, b, regs+a+1);
@@ -1596,7 +1616,7 @@ RETRY_TRY_BLOCK:
 
       if (MRB_METHOD_CFUNC_P(m)) {
         mrb_value v;
-        ci->nregs = (argc < 0) ? 3 : b+2;
+
         if (MRB_METHOD_PROC_P(m)) {
           ci->proc = MRB_METHOD_PROC(m);
         }
@@ -1633,8 +1653,7 @@ RETRY_TRY_BLOCK:
         irep = proc->body.irep;
         pool = irep->pool;
         syms = irep->syms;
-        ci->nregs = irep->nregs;
-        mrb_stack_extend(mrb, (argc < 0 && ci->nregs < 3) ? 3 : ci->nregs);
+        mrb_stack_extend(mrb, (argc < 0 && irep->nregs < 3) ? 3 : irep->nregs);
         pc = irep->iseq;
         JUMP;
       }
@@ -2795,9 +2814,8 @@ RETRY_TRY_BLOCK:
       irep = p->body.irep;
       pool = irep->pool;
       syms = irep->syms;
-      ci->nregs = irep->nregs;
-      mrb_stack_extend(mrb, ci->nregs);
-      stack_clear(regs+1, ci->nregs-1);
+      mrb_stack_extend(mrb, irep->nregs);
+      stack_clear(regs+1, irep->nregs-1);
       pc = irep->iseq;
       JUMP;
     }
@@ -2946,7 +2964,6 @@ mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int sta
   }
   ci = cipush(mrb);
   ci->mid = 0;
-  ci->nregs = 1;   /* protect the receiver */
   ci->acc = CI_ACC_SKIP;
   ci->target_class = mrb->object_class;
   v = mrb_vm_run(mrb, proc, self, stack_keep);
-- 
cgit v1.2.3


From 2b2ff844a17f07a80a6b8f22d8963ea050f82344 Mon Sep 17 00:00:00 2001
From: Kazuhiro Sera <seratch@gmail.com>
Date: Sat, 11 Aug 2018 00:28:32 +0900
Subject: Fix misspelling words in comments

---
 doc/guides/mrbgems.md                       | 4 ++--
 include/mruby.h                             | 4 ++--
 minirake                                    | 2 +-
 mrbgems/mruby-bin-debugger/bintest/print.rb | 2 +-
 mrbgems/mruby-socket/src/socket.c           | 2 +-
 test/t/literals.rb                          | 2 +-
 test/t/module.rb                            | 4 ++--
 7 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'include/mruby.h')

diff --git a/doc/guides/mrbgems.md b/doc/guides/mrbgems.md
index 8dac0dc86..0fcc936ed 100644
--- a/doc/guides/mrbgems.md
+++ b/doc/guides/mrbgems.md
@@ -179,11 +179,11 @@ Version requirement supports following operators:
 
 When more than one version requirements is passed, the dependency must satisfy all of it.
 
-You can have default gem to use as depedency when it's not defined in *build_config.rb*.
+You can have default gem to use as dependency when it's not defined in *build_config.rb*.
 When the last argument of `add_dependency` call is `Hash`, it will be treated as default gem information.
 Its format is same as argument of method `MRuby::Build#gem`, expect that it can't be treated as path gem location.
 
-When a special version of depedency is required,
+When a special version of dependency is required,
 use `MRuby::Build#gem` in *build_config.rb* to override default gem.
 
 If you have conflicting GEMs use the following method:
diff --git a/include/mruby.h b/include/mruby.h
index 12ddb95b3..542d7491f 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -783,7 +783,7 @@ MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *o
 #define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
 
 /**
- * Funtion takes n optional arguments
+ * Function takes n optional arguments
  *
  * @param n
  *      The number of optional arguments.
@@ -791,7 +791,7 @@ MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *o
 #define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
 
 /**
- * Funtion takes n1 mandatory arguments and n2 optional arguments
+ * Function takes n1 mandatory arguments and n2 optional arguments
  *
  * @param n1
  *      The number of required arguments.
diff --git a/minirake b/minirake
index 8b6bfa296..ad8276a6d 100755
--- a/minirake
+++ b/minirake
@@ -95,7 +95,7 @@ module MiniRake
     def done?; @done end
     def running?; @running end
 
-    # Invoke the task if it is needed.  Prerequites are invoked first.
+    # Invoke the task if it is needed. Prerequisites are invoked first.
     def invoke
       puts "Invoke #{name} (already=[#{@already_invoked}], needed=[#{needed?}])" if $trace
       return if @already_invoked
diff --git a/mrbgems/mruby-bin-debugger/bintest/print.rb b/mrbgems/mruby-bin-debugger/bintest/print.rb
index 0d4aad011..6675392b8 100644
--- a/mrbgems/mruby-bin-debugger/bintest/print.rb
+++ b/mrbgems/mruby-bin-debugger/bintest/print.rb
@@ -317,7 +317,7 @@ TestConstNameSubClass.new.m()
 bp = nil
 SRC
 
-  # todo: wait for 'break' to be implimented
+  # todo: wait for 'break' to be implemented
   tc = []
   9.times { tc << {:cmd=>"s"} }
   tc << {:cmd=>"p CONST", :exp=>"super class"}
diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c
index b3ca8b1c9..b44371544 100644
--- a/mrbgems/mruby-socket/src/socket.c
+++ b/mrbgems/mruby-socket/src/socket.c
@@ -300,7 +300,7 @@ mrb_basicsocket_getpeereid(mrb_state *mrb, mrb_value self)
   mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)egid));
   return ary;
 #else
-  mrb_raise(mrb, E_RUNTIME_ERROR, "getpeereid is not avaialble on this system");
+  mrb_raise(mrb, E_RUNTIME_ERROR, "getpeereid is not available on this system");
   return mrb_nil_value();
 #endif
 }
diff --git a/test/t/literals.rb b/test/t/literals.rb
index 51a37c32d..6344219aa 100644
--- a/test/t/literals.rb
+++ b/test/t/literals.rb
@@ -22,7 +22,7 @@ assert('Literals Numerical', '8.7.6.2') do
   # decimal
   assert_equal 999, 0d999
   assert_equal 999, 0D999
-  # decimal seperator
+  # decimal separator
   assert_equal 10000000, 10_000_000
   assert_equal       10, 1_0
   # integer with exponent
diff --git a/test/t/module.rb b/test/t/module.rb
index 5a46c24ff..fb82fc934 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -699,7 +699,7 @@ end
     end
   end
 
-  # these assertions will not run without a #assert_seperately method
+  # these assertions will not run without a #assert_separately method
   #assert 'test_prepend_optmethod' do
   #  bug7983 = '[ruby-dev:47124] [Bug #7983]'
   #  assert_separately [], %{
@@ -807,7 +807,7 @@ end
     assert_equal([m, c2, m, c1], c2.ancestors[0, 4], "should accesisble prepended module in superclass")
   end
 
-  # requires #assert_seperately
+  # requires #assert_separately
   #assert 'Module#prepend call super' do
   #  assert_separately([], <<-'end;') #do
   #    bug10847 = '[ruby-core:68093] [Bug #10847]'
-- 
cgit v1.2.3


From 471288f37d18e640f98029fabcdcb7ee16b95d93 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Sat, 25 Aug 2018 16:58:01 +0900
Subject: Reduce integer casting warnings.

---
 include/mruby.h                       | 2 +-
 mrbgems/mruby-compiler/core/codegen.c | 8 ++++----
 mrbgems/mruby-eval/src/eval.c         | 6 +++---
 src/codedump.c                        | 6 +++---
 src/load.c                            | 4 ++--
 src/vm.c                              | 2 +-
 6 files changed, 14 insertions(+), 14 deletions(-)

(limited to 'include/mruby.h')

diff --git a/include/mruby.h b/include/mruby.h
index 542d7491f..872396899 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -1234,7 +1234,7 @@ MRB_API mrb_value mrb_fiber_alive_p(mrb_state *mrb, mrb_value fib);
  * @mrbgem mruby-fiber
  */
 #define E_FIBER_ERROR (mrb_exc_get(mrb, "FiberError"))
-MRB_API void mrb_stack_extend(mrb_state*, int);
+MRB_API void mrb_stack_extend(mrb_state*, mrb_int);
 
 /* memory pool implementation */
 typedef struct mrb_pool mrb_pool;
diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c
index 075945b3b..a835a563e 100644
--- a/mrbgems/mruby-compiler/core/codegen.c
+++ b/mrbgems/mruby-compiler/core/codegen.c
@@ -400,7 +400,7 @@ genjmp2(codegen_scope *s, mrb_code i, uint16_t a, int pc, int val)
   }
   else {
     gen_B(s, i);
-    gen_B(s, a);
+    gen_B(s, (uint8_t)a);
     pos = s->pc;
     gen_S(s, pc);
   }
@@ -494,10 +494,10 @@ gen_addsub(codegen_scope *s, uint8_t op, uint16_t dst, uint16_t idx)
       if (data.b >= 128) goto normal;
       s->pc = s->lastpc;
       if (op == OP_ADD) {
-        genop_3(s, OP_ADDI, dst, idx, data.b);
+        genop_3(s, OP_ADDI, dst, idx, (uint8_t)data.b);
       }
       else {
-        genop_3(s, OP_SUBI, dst, idx, data.b);
+        genop_3(s, OP_SUBI, dst, idx, (uint8_t)data.b);
       }
       break;
     default:
@@ -2441,7 +2441,7 @@ codegen(codegen_scope *s, node *tree, int val)
 #endif
             if (i == -1) genop_1(s, OP_LOADI__1, cursp());
             else if (i >= -0xffff) {
-              genop_2(s, OP_LOADINEG, cursp(), -i);
+              genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i);
             }
             else {
               int off = new_lit(s, mrb_fixnum_value(i));
diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c
index f1e50e83d..b9c87f6d1 100644
--- a/mrbgems/mruby-eval/src/eval.c
+++ b/mrbgems/mruby-eval/src/eval.c
@@ -154,7 +154,7 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top)
         if (arg != 0) {
           /* must replace */
           irep->iseq[i] = insn = OP_SETUPVAR;
-          irep->iseq[i+1] = b;
+          irep->iseq[i+1] = (mrb_code)b;
           irep->iseq[i+2] = arg >> 8;
           irep->iseq[i+3] = arg & 0xff;
         }
@@ -169,7 +169,7 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top)
         int lev = c+1;
         mrb_irep *tmp = search_irep(top, bnest, lev, irep);
         if (potential_upvar_p(tmp->lv, b, irep_argc(tmp), tmp->nlocals)) {
-          mrb_code arg = search_variable(mrb, tmp->lv[b-1].name, bnest);
+          uint16_t arg = search_variable(mrb, tmp->lv[b-1].name, bnest);
           if (arg != 0) {
             /* must replace */
             irep->iseq[i] = OP_GETUPVAR;
@@ -188,7 +188,7 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top)
         int lev = c+1;
         mrb_irep *tmp = search_irep(top, bnest, lev, irep);
         if (potential_upvar_p(tmp->lv, b, irep_argc(tmp), tmp->nlocals)) {
-          mrb_code arg = search_variable(mrb, tmp->lv[b-1].name, bnest);
+          uint16_t arg = search_variable(mrb, tmp->lv[b-1].name, bnest);
           if (arg != 0) {
             /* must replace */
             irep->iseq[i] = OP_SETUPVAR;
diff --git a/src/codedump.c b/src/codedump.c
index 9174ebe3d..80802778f 100644
--- a/src/codedump.c
+++ b/src/codedump.c
@@ -48,7 +48,7 @@ print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b)
 #endif
 
 static void
-print_header(mrb_irep *irep, int i)
+print_header(mrb_irep *irep, ptrdiff_t i)
 {
   int32_t line;
 
@@ -60,7 +60,7 @@ print_header(mrb_irep *irep, int i)
     printf("%5d ", line);
   }
 
-  printf("%03d ", i);
+  printf("%03d ", (int)i);
 }
 
 #define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn
@@ -91,7 +91,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
   pc = irep->iseq;
   pcend = pc + irep->ilen;
   while (pc < pcend) {
-    int i;
+    ptrdiff_t i;
     uint32_t a;
     uint16_t b;
     uint8_t c;
diff --git a/src/load.c b/src/load.c
index 20878aa56..54b50b14d 100644
--- a/src/load.c
+++ b/src/load.c
@@ -68,7 +68,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag
 
   /* Binary Data Section */
   /* ISEQ BLOCK */
-  irep->ilen = (size_t)bin_to_uint32(src);
+  irep->ilen = (uint16_t)bin_to_uint32(src);
   src += sizeof(uint32_t);
   src += skip_padding(src);
 
@@ -157,7 +157,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag
   }
 
   /* SYMS BLOCK */
-  irep->slen = (size_t)bin_to_uint32(src);  /* syms length */
+  irep->slen = (uint16_t)bin_to_uint32(src);  /* syms length */
   src += sizeof(uint32_t);
   if (irep->slen > 0) {
     if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) {
diff --git a/src/vm.c b/src/vm.c
index d0ea6b3bd..44472e311 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -218,7 +218,7 @@ stack_extend_alloc(mrb_state *mrb, int room)
 }
 
 MRB_API void
-mrb_stack_extend(mrb_state *mrb, int room)
+mrb_stack_extend(mrb_state *mrb, mrb_int room)
 {
   if (mrb->c->stack + room >= mrb->c->stend) {
     stack_extend_alloc(mrb, room);
-- 
cgit v1.2.3