From 27c2416d201de968789917f2b6923d96ce1b953f Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 3 Jun 2012 14:13:25 +0900
Subject: stack_extend boundary condition was wrong

---
 src/vm.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index be55a0124..865241a24 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -46,7 +46,7 @@ stack_extend(mrb_state *mrb, int room, int keep)
 {
   int size, off;
 
-  if (mrb->stack + room > mrb->stend) {
+  if (mrb->stack + room >= mrb->stend) {
     size = mrb->stend - mrb->stbase;
     off = mrb->stack - mrb->stbase;
 
-- 
cgit v1.2.3


From e88e30524ee878bf0bbf665c1a6bea11a60f07d4 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 3 Jun 2012 14:44:46 +0900
Subject: should have adjusted stack address kept in closures; close #222

---
 src/vm.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 865241a24..4f6deb877 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -41,12 +41,30 @@ stack_init(mrb_state *mrb)
   mrb->ci->target_class = mrb->object_class;
 }
 
+static void
+envadjust(mrb_state *mrb, mrb_value *oldbase, mrb_value *newbase)
+{
+  mrb_callinfo *ci = mrb->cibase;
+
+  while (ci <= mrb->ci) {
+    struct REnv *e = ci->env;
+    if (e && e->cioff >= 0) {
+      int off = e->stack - oldbase;
+
+      e->stack = newbase + off;
+    }
+    ci++;
+  }
+}
+
 static void
 stack_extend(mrb_state *mrb, int room, int keep)
 {
   int size, off;
 
   if (mrb->stack + room >= mrb->stend) {
+    mrb_value *oldbase = mrb->stbase;
+
     size = mrb->stend - mrb->stbase;
     off = mrb->stack - mrb->stbase;
 
@@ -57,6 +75,7 @@ stack_extend(mrb_state *mrb, int room, int keep)
     mrb->stbase = mrb_realloc(mrb, mrb->stbase, sizeof(mrb_value) * size);
     mrb->stack = mrb->stbase + off;
     mrb->stend = mrb->stbase + size;
+    envadjust(mrb, oldbase, mrb->stbase);
   }
   if (room > keep) {
     memset(mrb->stack+keep, 0, sizeof(mrb_value) * (room-keep));
-- 
cgit v1.2.3


From 4c01f002fdd234aa0a03f1eeb3c216b9638ea170 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 5 Jun 2012 23:20:36 +0900
Subject: mruby/array.h: rename buf to ptr

---
 include/mruby/array.h |   6 +--
 src/array.c           | 126 +++++++++++++++++++++++++-------------------------
 src/class.c           |   4 +-
 src/gc.c              |   4 +-
 src/vm.c              |  18 ++++----
 5 files changed, 79 insertions(+), 79 deletions(-)

(limited to 'src/vm.c')

diff --git a/include/mruby/array.h b/include/mruby/array.h
index c6c35a4e4..f42146f3e 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -13,7 +13,7 @@ extern "C" {
 
 struct mrb_shared_array {
   int refcnt;
-  mrb_value *buf;
+  mrb_value *ptr;
   int len;
 };
 
@@ -24,7 +24,7 @@ struct RArray {
     int capa;
     struct mrb_shared_array *shared;
   } aux;
-  mrb_value *buf;
+  mrb_value *ptr;
 };
 
 #define mrb_ary_ptr(v)    ((struct RArray*)((v).value.p))
@@ -32,7 +32,7 @@ struct RArray {
 #define RARRAY(v)  ((struct RArray*)((v).value.p))
 
 #define RARRAY_LEN(a) (RARRAY(a)->len)
-#define RARRAY_PTR(a) (RARRAY(a)->buf)
+#define RARRAY_PTR(a) (RARRAY(a)->ptr)
 #define MRB_ARY_SHARED      256
 
 void mrb_ary_decref(mrb_state*, struct mrb_shared_array*);
diff --git a/src/array.c b/src/array.c
index 8f2e4824e..2403a783d 100644
--- a/src/array.c
+++ b/src/array.c
@@ -46,8 +46,8 @@ ary_new_capa(mrb_state *mrb, int capa)
   }
 
   a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);
-  a->buf = mrb_malloc(mrb, blen);
-  memset(a->buf, 0, blen);
+  a->ptr = mrb_malloc(mrb, blen);
+  memset(a->ptr, 0, blen);
   a->aux.capa = capa;
   a->len = 0;
 
@@ -75,7 +75,7 @@ mrb_ary_new_from_values(mrb_state *mrb, int size, mrb_value *vals)
 
   ary = mrb_ary_new_capa(mrb, size);
   a = mrb_ary_ptr(ary);
-  memcpy(a->buf, vals, sizeof(mrb_value)*size);
+  memcpy(a->ptr, vals, sizeof(mrb_value)*size);
   a->len = size;
 
   return ary;
@@ -91,12 +91,12 @@ mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr)
 }
 
 static void
-ary_fill_with_nil(mrb_value *buf, int size)
+ary_fill_with_nil(mrb_value *ptr, int size)
 {
   mrb_value nil = mrb_nil_value();
 
   while((int)(size--)) {
-    *buf++ = nil;
+    *ptr++ = nil;
   }
 }
 
@@ -106,8 +106,8 @@ ary_modify(mrb_state *mrb, struct RArray *a)
   if (a->flags & MRB_ARY_SHARED) {
     struct mrb_shared_array *shared = a->aux.shared;
 
-    if (shared->refcnt == 1 && a->buf == shared->buf) {
-      a->buf = shared->buf;
+    if (shared->refcnt == 1 && a->ptr == shared->ptr) {
+      a->ptr = shared->ptr;
       a->aux.capa = a->len;
       mrb_free(mrb, shared);
     }
@@ -115,13 +115,13 @@ ary_modify(mrb_state *mrb, struct RArray *a)
       mrb_value *ptr, *p;
       int len;
 
-      p = a->buf;
+      p = a->ptr;
       len = a->len * sizeof(mrb_value);
       ptr = mrb_malloc(mrb, len);
       if (p) {
 	memcpy(ptr, p, len);
       }
-      a->buf = ptr;
+      a->ptr = ptr;
       a->aux.capa = len;
       mrb_ary_decref(mrb, shared);
     }
@@ -137,10 +137,10 @@ ary_make_shared(mrb_state *mrb, struct RArray *a)
 
     shared->refcnt = 1;
     if (a->aux.capa > a->len) {
-      a->buf = shared->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*a->len+1);
+      a->ptr = shared->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1);
     }
     else {
-      shared->buf = a->buf;
+      shared->ptr = a->ptr;
     }
     shared->len = a->len;
     a->aux.shared = shared;
@@ -174,7 +174,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, int len)
 
   if (capa > a->aux.capa) {
     a->aux.capa = capa;
-    a->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*capa);
+    a->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa);
   }
 }
 
@@ -196,7 +196,7 @@ ary_shrink_capa(mrb_state *mrb, struct RArray *a)
 
   if (capa > a->len && capa < a->aux.capa) {
     a->aux.capa = capa;
-    a->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*capa);
+    a->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa);
   }
 }
 
@@ -211,13 +211,13 @@ mrb_ary_s_create(mrb_state *mrb, mrb_value self)
 }
 
 static void
-ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *buf, int blen)
+ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *ptr, int blen)
 {
   int len = a->len + blen;
 
   ary_modify(mrb, a);
   if (a->aux.capa < len) ary_expand_capa(mrb, a, len);
-  memcpy(a->buf+a->len, buf, sizeof(mrb_value)*blen);
+  memcpy(a->ptr+a->len, ptr, sizeof(mrb_value)*blen);
   mrb_write_barrier(mrb, (struct RBasic*)a);
   a->len = len;
 }
@@ -227,17 +227,17 @@ mrb_ary_concat(mrb_state *mrb, mrb_value self, mrb_value other)
 {
   struct RArray *a2 = mrb_ary_ptr(other);
 
-  ary_concat(mrb, mrb_ary_ptr(self), a2->buf, a2->len);
+  ary_concat(mrb, mrb_ary_ptr(self), a2->ptr, a2->len);
 }
 
 mrb_value
 mrb_ary_concat_m(mrb_state *mrb, mrb_value self)
 {
-  mrb_value *buf;
+  mrb_value *ptr;
   int blen;
 
-  mrb_get_args(mrb, "a", &buf, &blen);
-  ary_concat(mrb, mrb_ary_ptr(self), buf, blen);
+  mrb_get_args(mrb, "a", &ptr, &blen);
+  ary_concat(mrb, mrb_ary_ptr(self), ptr, blen);
   return self;
 }
 
@@ -247,14 +247,14 @@ mrb_ary_plus(mrb_state *mrb, mrb_value self)
   struct RArray *a1 = mrb_ary_ptr(self);
   struct RArray *a2;
   mrb_value ary;
-  mrb_value *buf;
+  mrb_value *ptr;
   int blen;
 
-  mrb_get_args(mrb, "a", &buf, &blen);
+  mrb_get_args(mrb, "a", &ptr, &blen);
   ary = mrb_ary_new_capa(mrb, a1->len + blen);
   a2 = mrb_ary_ptr(ary);
-  memcpy(a2->buf, a1->buf, sizeof(mrb_value)*a1->len);
-  memcpy(a2->buf + a1->len, buf, sizeof(mrb_value)*blen);
+  memcpy(a2->ptr, a1->ptr, sizeof(mrb_value)*a1->len);
+  memcpy(a2->ptr + a1->len, ptr, sizeof(mrb_value)*blen);
   a2->len = a1->len + blen;
 
   return ary;
@@ -289,7 +289,7 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1)
   mrb_get_args(mrb, "o", &ary2);
   if (mrb_type(ary2) != MRB_TT_ARRAY) return mrb_nil_value();
   a1 = RARRAY(ary1); a2 = RARRAY(ary2);
-  if (a1->len == a2->len && a1->buf == a2->buf) return mrb_fixnum_value(0);
+  if (a1->len == a2->len && a1->ptr == a2->ptr) return mrb_fixnum_value(0);
   else {
     len = RARRAY_LEN(ary1);
     if (len > RARRAY_LEN(ary2)) {
@@ -310,7 +310,7 @@ ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, int len)
   ary_modify(mrb, a);
   if (a->aux.capa < len)
     ary_expand_capa(mrb, a, len);
-  memcpy(a->buf, argv, sizeof(mrb_value)*len);
+  memcpy(a->ptr, argv, sizeof(mrb_value)*len);
   mrb_write_barrier(mrb, (struct RBasic*)a);
   a->len = len;
 }
@@ -320,7 +320,7 @@ mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other)
 {
   struct RArray *a2 = mrb_ary_ptr(other);
 
-  ary_replace(mrb, mrb_ary_ptr(self), a2->buf, a2->len);
+  ary_replace(mrb, mrb_ary_ptr(self), a2->ptr, a2->len);
 }
 
 mrb_value
@@ -340,7 +340,7 @@ mrb_ary_times(mrb_state *mrb, mrb_value self)
   struct RArray *a1 = mrb_ary_ptr(self);
   struct RArray *a2;
   mrb_value ary;
-  mrb_value *buf;
+  mrb_value *ptr;
   mrb_int times;
 
   mrb_get_args(mrb, "i", &times);
@@ -351,10 +351,10 @@ mrb_ary_times(mrb_state *mrb, mrb_value self)
 
   ary = mrb_ary_new_capa(mrb, a1->len * times);
   a2 = mrb_ary_ptr(ary);
-  buf = a2->buf;
+  ptr = a2->ptr;
   while(times--) {
-    memcpy(buf, a1->buf, sizeof(mrb_value)*(a1->len));
-    buf += a1->len;
+    memcpy(ptr, a1->ptr, sizeof(mrb_value)*(a1->len));
+    ptr += a1->len;
     a2->len += a1->len;
   }
 
@@ -369,8 +369,8 @@ mrb_ary_reverse_bang(mrb_state *mrb, mrb_value self)
   if (a->len > 1) {
     mrb_value *p1, *p2;
 
-    p1 = a->buf;
-    p2 = a->buf + a->len - 1;
+    p1 = a->ptr;
+    p2 = a->ptr + a->len - 1;
 
     while(p1 < p2) {
       mrb_value tmp = *p1;
@@ -392,9 +392,9 @@ mrb_ary_reverse(mrb_state *mrb, mrb_value self)
   if (a->len > 0) {
     mrb_value *p1, *p2, *e;
 
-    p1 = a->buf;
+    p1 = a->ptr;
     e  = p1 + a->len;
-    p2 = b->buf + a->len - 1;
+    p2 = b->ptr + a->len - 1;
     while(p1 < e) {
       *p2-- = *p1++;
     }
@@ -431,7 +431,7 @@ mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem) /* mrb_ary_push */
   ary_modify(mrb, a);
   if (a->len == a->aux.capa)
     ary_expand_capa(mrb, a, a->len + 1);
-  a->buf[a->len++] = elem;
+  a->ptr[a->len++] = elem;
   mrb_write_barrier(mrb, (struct RBasic*)a);
 }
 
@@ -455,7 +455,7 @@ mrb_ary_pop(mrb_state *mrb, mrb_value ary)
   struct RArray *a = mrb_ary_ptr(ary);
 
   if (a->len == 0) return mrb_nil_value();
-  return a->buf[--a->len];
+  return a->ptr[--a->len];
 }
 
 #define ARY_SHIFT_SHARED_MIN 10
@@ -469,8 +469,8 @@ mrb_ary_shift(mrb_state *mrb, mrb_value self)
   if (a->len == 0) return mrb_nil_value();
   if (a->flags & MRB_ARY_SHARED) {
   L_SHIFT:
-    val = a->buf[0];
-    a->buf++;
+    val = a->ptr[0];
+    a->ptr++;
     a->len--;
     return val;
   }
@@ -479,13 +479,13 @@ mrb_ary_shift(mrb_state *mrb, mrb_value self)
     goto L_SHIFT;
   }
   else {
-    mrb_value *buf = a->buf;
+    mrb_value *ptr = a->ptr;
     int size = a->len;
 
-    val = *buf;
+    val = *ptr;
     while((int)(--size)) {
-      *buf = *(buf+1);
-      ++buf;
+      *ptr = *(ptr+1);
+      ++ptr;
     }
     --a->len;
   }
@@ -504,8 +504,8 @@ mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item)
   ary_modify(mrb, a);
   if (a->aux.capa < a->len + 1)
     ary_expand_capa(mrb, a, a->len + 1);
-  memmove(a->buf + 1, a->buf, sizeof(mrb_value)*a->len);
-  memcpy(a->buf, &item, sizeof(mrb_value));
+  memmove(a->ptr + 1, a->ptr, sizeof(mrb_value)*a->len);
+  memcpy(a->ptr, &item, sizeof(mrb_value));
   a->len += 1;
   mrb_write_barrier(mrb, (struct RBasic*)a);
 
@@ -524,8 +524,8 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self)
   if (len == 0) return self;
   if (a->aux.capa < a->len + len)
     ary_expand_capa(mrb, a, a->len + len);
-  memmove(a->buf + len, a->buf, sizeof(mrb_value)*a->len);
-  memcpy(a->buf, vals, sizeof(mrb_value)*len);
+  memmove(a->ptr + len, a->ptr, sizeof(mrb_value)*a->len);
+  memcpy(a->ptr, vals, sizeof(mrb_value)*len);
   a->len += len;
   mrb_write_barrier(mrb, (struct RBasic*)a);
 
@@ -541,7 +541,7 @@ mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n)
   if (n < 0) n += a->len;
   if (n < 0 || a->len <= (int)n) return mrb_nil_value();
 
-  return a->buf[n];
+  return a->ptr[n];
 }
 
 void
@@ -558,11 +558,11 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) /* rb_ary_s
   if (a->len <= (int)n) {
     if (a->aux.capa <= (int)n)
       ary_expand_capa(mrb, a, n + 1);
-    ary_fill_with_nil(a->buf + a->len, n + 1 - a->len);
+    ary_fill_with_nil(a->ptr + a->len, n + 1 - a->len);
     a->len = n + 1;
   }
 
-  a->buf[n] = val;
+  a->ptr[n] = val;
   mrb_write_barrier(mrb, (struct RBasic*)a);
 }
 
@@ -600,14 +600,14 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
     ary_expand_capa(mrb, a, size);
 
   if (head > a->len) {
-    ary_fill_with_nil(a->buf + a->len, (int)(head - a->len));
+    ary_fill_with_nil(a->ptr + a->len, (int)(head - a->len));
   }
   else if (head < a->len) {
-    memmove(a->buf + head + argc, a->buf + tail, sizeof(mrb_value)*(a->len - tail));
+    memmove(a->ptr + head + argc, a->ptr + tail, sizeof(mrb_value)*(a->len - tail));
   }
 
   for(i = 0; i < argc; i++) {
-    *(a->buf + head + i) = *(argv + i);
+    *(a->ptr + head + i) = *(argv + i);
   }
 
   a->len = size;
@@ -626,7 +626,7 @@ mrb_ary_decref(mrb_state *mrb, struct mrb_shared_array *shared)
 {
   shared->refcnt--;
   if (shared->refcnt == 0) {
-    mrb_free(mrb, shared->buf);
+    mrb_free(mrb, shared->ptr);
     mrb_free(mrb, shared);
   }
 }
@@ -638,7 +638,7 @@ ary_subseq(mrb_state *mrb, struct RArray *a, int beg, int len)
 
   ary_make_shared(mrb, a);
   b  = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);
-  b->buf = a->buf + beg;
+  b->ptr = a->ptr + beg;
   b->len = len;
   b->aux.shared = a->aux.shared;
   b->aux.shared->refcnt++;
@@ -714,20 +714,20 @@ mrb_ary_delete_at(mrb_state *mrb, mrb_value self)
   struct RArray *a = mrb_ary_ptr(self);
   mrb_int   index;
   mrb_value val;
-  mrb_value *buf;
+  mrb_value *ptr;
   int len;
 
   mrb_get_args(mrb, "i", &index);
   if (index < 0) index += a->len;
   if (index < 0 || a->len <= (int)index) return mrb_nil_value();
 
-  val = a->buf[index];
+  val = a->ptr[index];
 
-  buf = a->buf + index;
+  ptr = a->ptr + index;
   len = a->len - index;
   while((int)(--len)) {
-    *buf = *(buf+1);
-    ++buf;
+    *ptr = *(ptr+1);
+    ++ptr;
   }
   --a->len;
 
@@ -743,14 +743,14 @@ mrb_ary_first(mrb_state *mrb, mrb_value self)
   int size;
 
   if (mrb_get_args(mrb, "|i", &size) == 0) {
-    return (a->len > 0)? a->buf[0]: mrb_nil_value();
+    return (a->len > 0)? a->ptr[0]: mrb_nil_value();
   }
 
   if (size > a->len) size = a->len;
   if (a->flags & MRB_ARY_SHARED) {
     return ary_subseq(mrb, a, 0, size);
   }
-  return mrb_ary_new_from_values(mrb, size, a->buf);
+  return mrb_ary_new_from_values(mrb, size, a->ptr);
 }
 
 mrb_value
@@ -766,7 +766,7 @@ mrb_ary_last(mrb_state *mrb, mrb_value self)
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
   }
 
-  if (len == 0) return (a->len > 0)? a->buf[a->len - 1]: mrb_nil_value();
+  if (len == 0) return (a->len > 0)? a->ptr[a->len - 1]: mrb_nil_value();
 
   /* len == 1 */
   size = mrb_fixnum(*vals);
@@ -774,7 +774,7 @@ mrb_ary_last(mrb_state *mrb, mrb_value self)
   if ((a->flags & MRB_ARY_SHARED) || size > ARY_DEFAULT_LEN) {
     return ary_subseq(mrb, a, a->len - size, size);
   }
-  return mrb_ary_new_from_values(mrb, size, a->buf + a->len - size);
+  return mrb_ary_new_from_values(mrb, size, a->ptr + a->len - size);
 }
 
 mrb_value
diff --git a/src/class.c b/src/class.c
index 554f98550..b49ce00f8 100644
--- a/src/class.c
+++ b/src/class.c
@@ -389,7 +389,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     struct RArray *a = mrb_ary_ptr(mrb->stack[1]);
 
     argc = a->len;
-    sp = a->buf;
+    sp = a->ptr;
   }
   while ((c = *format++)) {
     switch (c) {
@@ -481,7 +481,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 	aa = to_ary(mrb, *sp);
 	a = mrb_ary_ptr(aa);
 	pb = va_arg(ap, mrb_value**);
-	*pb = a->buf;
+	*pb = a->ptr;
 	pl = va_arg(ap, int*);
 	*pl = a->len;
         i++; sp++;
diff --git a/src/gc.c b/src/gc.c
index 247c1ad85..6d22bf275 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -367,7 +367,7 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj)
       size_t i, e;
 
       for (i=0,e=a->len; i<e; i++) {
-        mrb_gc_mark_value(mrb, a->buf[i]);
+        mrb_gc_mark_value(mrb, a->ptr[i]);
       }
     }
     break;
@@ -460,7 +460,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
     if (obj->flags & MRB_ARY_SHARED)
       mrb_ary_decref(mrb, ((struct RArray*)obj)->aux.shared);
     else
-      mrb_free(mrb, ((struct RArray*)obj)->buf);
+      mrb_free(mrb, ((struct RArray*)obj)->ptr);
     break;
 
   case MRB_TT_HASH:
diff --git a/src/vm.c b/src/vm.c
index 4f6deb877..f74315fb2 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -899,17 +899,17 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         if (stack[m1].tt == MRB_TT_ARRAY) {
           struct RArray *ary = mrb_ary_ptr(stack[m1]);
 
-          pp = ary->buf;
+          pp = ary->ptr;
           len = ary->len;
         }
         regs[a] = mrb_ary_new_capa(mrb, m1+len+m2);
         rest = mrb_ary_ptr(regs[a]);
-        memcpy(rest->buf, stack, sizeof(mrb_value)*m1);
+        memcpy(rest->ptr, stack, sizeof(mrb_value)*m1);
         if (len > 0) {
-          memcpy(rest->buf+m1, pp, sizeof(mrb_value)*len);
+          memcpy(rest->ptr+m1, pp, sizeof(mrb_value)*len);
         }
         if (m2 > 0) {
-          memcpy(rest->buf+m1+len, stack+m1+1, sizeof(mrb_value)*m2);
+          memcpy(rest->ptr+m1+len, stack+m1+1, sizeof(mrb_value)*m2);
         }
         rest->len = m1+len+m2;
       }
@@ -936,7 +936,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
       if (argc < 0) {
         struct RArray *ary = mrb_ary_ptr(regs[1]);
-        argv = ary->buf;
+        argv = ary->ptr;
         argc = ary->len;
         regs[len+2] = regs[1];  /* save argary in register */
       }
@@ -950,7 +950,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       }
       else if (len > 1 && argc == 1 && argv[0].tt == MRB_TT_ARRAY) {
         argc = mrb_ary_ptr(argv[0])->len;
-        argv = mrb_ary_ptr(argv[0])->buf;
+        argv = mrb_ary_ptr(argv[0])->ptr;
       }
       mrb->ci->argc = len;
       if (argc < len) {
@@ -1398,15 +1398,15 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         int i;
 
         if (len > pre + post) {
-          regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->buf+pre);
+          regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->ptr+pre);
           while (post--) {
-            regs[a++] = ary->buf[len-post-1];
+            regs[a++] = ary->ptr[len-post-1];
           }
         }
         else {
           regs[a++] = mrb_ary_new_capa(mrb, 0);
           for (i=0; i+pre<len; i++) {
-            regs[a+i] = ary->buf[pre+i];
+            regs[a+i] = ary->ptr[pre+i];
           }
           while (i < post) {
             SET_NIL_VALUE(regs[a+i]);
-- 
cgit v1.2.3


From 85901e05469d644e2bb63700fbd1bbc80934dc0d Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 10 Jun 2012 21:44:57 +0900
Subject: fixed typo DISPACTH to DISPATCH

---
 src/vm.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index f74315fb2..508d8fe77 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -356,20 +356,20 @@ argnum_error(mrb_state *mrb, int num)
 
 #ifndef DIRECT_THREADED
 
-#define INIT_DISPACTH for (;;) { i = *pc; switch (GET_OPCODE(i)) {
+#define INIT_DISPATCH for (;;) { i = *pc; switch (GET_OPCODE(i)) {
 #define CASE(op) case op:
 #define NEXT mrb->arena_idx = ai; pc++; break
 #define JUMP break
-#define END_DISPACTH }}
+#define END_DISPATCH }}
 
 #else
 
-#define INIT_DISPACTH JUMP; return mrb_nil_value();
+#define INIT_DISPATCH JUMP; return mrb_nil_value();
 #define CASE(op) L_ ## op:
 #define NEXT mrb->arena_idx = ai; i=*++pc; goto *optable[GET_OPCODE(i)]
 #define JUMP i=*pc; goto *optable[GET_OPCODE(i)]
 
-#define END_DISPACTH
+#define END_DISPATCH
 
 #endif
 
@@ -432,7 +432,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   mrb->ci->nregs = irep->nregs + 2;
   regs = mrb->stack;
 
-  INIT_DISPACTH {
+  INIT_DISPATCH {
     CASE(OP_NOP) {
       /* do nothing */
       NEXT;
@@ -1594,5 +1594,5 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       goto L_RAISE;
     }
   }
-  END_DISPACTH;
+  END_DISPATCH;
 }
-- 
cgit v1.2.3


From 13a542d48d5d86b866dbc4d6a4f0ec17bee49c12 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 11 Jun 2012 15:55:04 +0900
Subject: zsuper should respect block given; close #185

---
 src/codegen.c |  9 +++++++--
 src/parse.y   | 16 +++++++++++++---
 src/vm.c      |  7 ++++---
 3 files changed, 24 insertions(+), 8 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/codegen.c b/src/codegen.c
index 117588b6e..105a27cef 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -1280,7 +1280,7 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       int n = 0;
 
-      push();
+      push();			/* room for receiver */
       if (tree) {
         node *args = tree->car;
         while (args) {
@@ -1307,14 +1307,19 @@ codegen(codegen_scope *s, node *tree, int val)
       codegen_scope *s2 = s;
       int lv = 0, ainfo = 0;
 
+      push(); 			/* room for receiver */
       while (s2->ainfo < 0) {
         lv++;
         s2 = s2->prev;
         if (!s2) break;
       }
       if (s2) ainfo = s2->ainfo;
-      push();
       genop(s, MKOP_ABx(OP_ARGARY, cursp(), (ainfo<<4)|(lv & 0xf)));
+      if (tree && tree->cdr) {
+	push();
+        codegen(s, tree->cdr, VAL);
+        pop_n(2);
+      }
       pop();
       genop(s, MKOP_ABC(OP_SUPER, cursp(), 0, CALL_MAXARGS));
       if (val) push();
diff --git a/src/parse.y b/src/parse.y
index 3f542a3b3..d31711b68 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -754,11 +754,21 @@ args_with_block(parser_state *p, node *a, node *b)
 static void
 call_with_block(parser_state *p, node *a, node *b)
 {
-  node *n = a->cdr->cdr->cdr;
+  node *n;
 
-  if (!n->car) n->car = cons(0, b);
+  if (a->car == (node*)NODE_SUPER ||
+      a->car == (node*)NODE_ZSUPER) {
+    if (!a->cdr) a->cdr = cons(0, b);
+    else {
+      args_with_block(p, a->cdr, b);
+    }
+  }
   else {
-    args_with_block(p, n->car, b);
+    n = a->cdr->cdr->cdr;
+    if (!n->car) n->car = cons(0, b);
+    else {
+      args_with_block(p, n->car, b);
+    }
   }
 }
 
diff --git a/src/vm.c b/src/vm.c
index 508d8fe77..5a521c357 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -933,12 +933,13 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       int argc = mrb->ci->argc;
       mrb_value *argv = regs+1;
       int len = m1 + o + r + m2;
+      mrb_value *blk = &argv[argc < 0 ? 1 : argc];
 
       if (argc < 0) {
         struct RArray *ary = mrb_ary_ptr(regs[1]);
         argv = ary->ptr;
         argc = ary->len;
-        regs[len+2] = regs[1];  /* save argary in register */
+	mrb_gc_protect(mrb, regs[1]);
       }
       if (mrb->ci->proc && MRB_PROC_STRICT_P(mrb->ci->proc)) {
         if (argc >= 0) {
@@ -954,7 +955,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       }
       mrb->ci->argc = len;
       if (argc < len) {
-        regs[len+1] = argv[argc]; /* move block */
+        regs[len+1] = *blk; /* move block */
         memmove(&regs[1], argv, sizeof(mrb_value)*(argc-m2)); /* m1 + o */
         memmove(&regs[len-m2+1], &argv[argc-m2], sizeof(mrb_value)*m2); /* m2 */
         if (r) {                  /* r */
@@ -968,7 +969,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
           regs[m1+o+1] = mrb_ary_new_elts(mrb, argc-m1-o-m2, argv+m1+o);
         }
         memmove(&regs[m1+o+r+1], &argv[argc-m2], sizeof(mrb_value)*m2);
-        regs[len+1] = argv[argc]; /* move block */
+        regs[len+1] = *blk; /* move block */
         pc += o + 1;
       }
       JUMP;
-- 
cgit v1.2.3


From 6247eafc7167d5f18a5dae4d7508be06c370c1f9 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 12 Jun 2012 01:24:11 +0900
Subject: should raise error on top-level super/yield

---
 src/vm.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 5a521c357..c449a9b3c 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -886,6 +886,13 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       if (lv == 0) stack = regs + 1;
       else {
         struct REnv *e = uvenv(mrb, lv-1);
+	if (!e) {
+	  mrb_value exc;
+	  const char *m = "super called outside of method";
+	  exc = mrb_exc_new(mrb, E_NOMETHOD_ERROR, m, strlen(m));
+	  mrb->exc = (struct RObject*)mrb_object(exc);
+	  goto L_RAISE;
+	}
         stack = e->stack + 1;
       }
       if (r == 0) {
@@ -1140,6 +1147,10 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       if (lv == 0) stack = regs + 1;
       else {
         struct REnv *e = uvenv(mrb, lv-1);
+	if (!e) {
+	  localjump_error(mrb, "yield");
+	  goto L_RAISE;
+	}
         stack = e->stack + 1;
       }
       regs[a] = stack[m1+r+m2];
-- 
cgit v1.2.3


From 6a5019d37fd595abd9e8297bb3d35a1ee054becf Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 13 Jun 2012 15:38:18 +0900
Subject: optimized OP_{ADD,SUB,MUL,DIV} to use numeric function for fixnums to
 handle overflow

---
 include/mruby/numeric.h |   5 ++
 src/numeric.c           | 198 +++++++++++++++++++++++++++++-------------------
 src/vm.c                |  39 +++-------
 3 files changed, 133 insertions(+), 109 deletions(-)

(limited to 'src/vm.c')

diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h
index 1bea51152..95792e9a6 100644
--- a/include/mruby/numeric.h
+++ b/include/mruby/numeric.h
@@ -22,6 +22,11 @@ mrb_value mrb_flt2big(mrb_state *mrb, mrb_float d);
 void mrb_num_zerodiv(mrb_state *mrb);
 mrb_value mrb_fix2str(mrb_state *mrb, mrb_value x, int base);
 
+mrb_value mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/src/numeric.c b/src/numeric.c
index e1f711478..2d668fa79 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -118,6 +118,12 @@ num_pow(mrb_state *mrb, mrb_value x)
  * result.
  */
 
+mrb_value
+mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  return mrb_float_value(mrb_to_flo(mrb, x) / mrb_to_flo(mrb, y));
+}
+
 /* 15.2.9.3.19(x) */
 /*
  *  call-seq:
@@ -404,7 +410,7 @@ flo_to_f(mrb_state *mrb, mrb_value num)
  */
 
 static mrb_value
-flo_is_infinite_p(mrb_state *mrb, mrb_value num)
+flo_infinite_p(mrb_state *mrb, mrb_value num)
 {
   mrb_float value = mrb_float(num);
 
@@ -426,7 +432,7 @@ flo_is_infinite_p(mrb_state *mrb, mrb_value num)
  */
 
 static mrb_value
-flo_is_finite_p(mrb_state *mrb, mrb_value num)
+flo_finite_p(mrb_state *mrb, mrb_value num)
 {
   mrb_float value = mrb_float(num);
 
@@ -691,9 +697,31 @@ int_succ(mrb_state *mrb, mrb_value num)
   return mrb_funcall(mrb, num, "+", 1, mrb_fixnum_value(1));
 }
 
-#define SQRT_LONG_MAX ((SIGNED_VALUE)1<<((sizeof(mrb_int)*CHAR_BIT-1)/2))
+#define SQRT_INT_MAX ((SIGNED_VALUE)1<<((sizeof(mrb_int)*CHAR_BIT-1)/2))
 /*tests if N*N would overflow*/
-#define FIT_SQRT_LONG(n) (((n)<SQRT_LONG_MAX)&&((n)>=-SQRT_LONG_MAX))
+#define FIT_SQRT_INT(n) (((n)<SQRT_INT_MAX)&&((n)>=-SQRT_INT_MAX))
+
+mrb_value
+mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  mrb_int a;
+  
+  a = mrb_fixnum(x);
+  if (a == 0) return x;
+  if (FIXNUM_P(y)) {
+    mrb_int b, c;
+
+    b = mrb_fixnum(y);
+    if (FIT_SQRT_INT(a) && FIT_SQRT_INT(b))
+      return mrb_fixnum_value(a*b);
+    c = a * b;
+    if (c/a != b) {
+      return mrb_float_value((mrb_float)a*(mrb_float)b);
+    }
+    return mrb_fixnum_value(c);;
+  }
+  return mrb_float_value((mrb_float)a * mrb_to_flo(mrb, y));
+}
 
 /* 15.2.8.3.3  */
 /*
@@ -709,27 +737,8 @@ static mrb_value
 fix_mul(mrb_state *mrb, mrb_value x)
 {
   mrb_value y;
-  mrb_int a;
   mrb_get_args(mrb, "o", &y);
-
-  a = mrb_fixnum(x);
-  if (FIXNUM_P(y)) {
-    mrb_int b, c;
-    mrb_value r;
-
-    b = mrb_fixnum(y);
-    if (FIT_SQRT_LONG(a) && FIT_SQRT_LONG(b))
-      return mrb_fixnum_value(a*b);
-    c = a * b;
-    r = mrb_fixnum_value(c);
-
-    if (a == 0) return x;
-    if (mrb_fixnum(r) != c || c/a != b) {
-      r = mrb_float_value((mrb_float)a*(mrb_float)b);
-    }
-    return r;
-  }
-  return mrb_float_value((mrb_float)a * mrb_to_flo(mrb, y));
+  return mrb_fixnum_mul(mrb, x, y);
 }
 
 static void
@@ -942,8 +951,28 @@ fix_xor(mrb_state *mrb, mrb_value x)
   return mrb_fixnum_value(val);
 }
 
-static mrb_value fix_lshift(mrb_state *mrb, mrb_int, unsigned long);
-static mrb_value fix_rshift(mrb_int, unsigned long);
+static mrb_value
+lshift(mrb_state *mrb, mrb_int val, unsigned long width)
+{
+  if (width > (sizeof(mrb_int)*CHAR_BIT-1)
+      || ((unsigned long)abs(val))>>(sizeof(mrb_int)*CHAR_BIT-1-width) > 0) {
+      mrb_raise(mrb, E_RANGE_ERROR, "width(%d) > (%d:sizeof(mrb_int)*CHAR_BIT-1)", width,
+		sizeof(mrb_int)*CHAR_BIT-1);
+  }
+  val = val << width;
+  return mrb_fixnum_value(val);
+}
+
+static mrb_value
+rshift(mrb_int val, unsigned long i)
+{
+    if (i >= sizeof(mrb_int)*CHAR_BIT-1) {
+        if (val < 0) return mrb_fixnum_value(-1);
+        return mrb_fixnum_value(0);
+    }
+    val = RSHIFT(val, i);
+    return mrb_fixnum_value(val);
+}
 
 /* 15.2.8.3.12 */
 /*
@@ -954,7 +983,7 @@ static mrb_value fix_rshift(mrb_int, unsigned long);
  */
 
 static mrb_value
-mrb_fix_lshift(mrb_state *mrb, mrb_value x)
+fix_lshift(mrb_state *mrb, mrb_value x)
 {
   mrb_value y;
   mrb_int val, width;
@@ -964,20 +993,8 @@ mrb_fix_lshift(mrb_state *mrb, mrb_value x)
   y = bit_coerce(mrb, y);
   width = mrb_fixnum(y);
   if (width < 0)
-      return fix_rshift(val, (unsigned long)-width);
-  return fix_lshift(mrb, val, width);
-}
-
-static mrb_value
-fix_lshift(mrb_state *mrb, mrb_int val, unsigned long width)
-{
-  if (width > (sizeof(mrb_int)*CHAR_BIT-1)
-      || ((unsigned long)abs(val))>>(sizeof(mrb_int)*CHAR_BIT-1-width) > 0) {
-      mrb_raise(mrb, E_RANGE_ERROR, "width(%d) > (%d:sizeof(mrb_int)*CHAR_BIT-1)", width,
-		sizeof(mrb_int)*CHAR_BIT-1);
-  }
-  val = val << width;
-  return mrb_fixnum_value(val);
+      return rshift(val, (unsigned long)-width);
+  return lshift(mrb, val, width);
 }
 
 /* 15.2.8.3.13 */
@@ -989,7 +1006,7 @@ fix_lshift(mrb_state *mrb, mrb_int val, unsigned long width)
  */
 
 static mrb_value
-mrb_fix_rshift(mrb_state *mrb, mrb_value x)
+fix_rshift(mrb_state *mrb, mrb_value x)
 {
   mrb_value y;
   mrb_int i, val;
@@ -1000,19 +1017,8 @@ mrb_fix_rshift(mrb_state *mrb, mrb_value x)
   i = mrb_fixnum(y);
     if (i == 0) return x;
     if (i < 0)
-        return fix_lshift(mrb, val, (unsigned long)-i);
-    return fix_rshift(val, i);
-}
-
-static mrb_value
-fix_rshift(mrb_int val, unsigned long i)
-{
-    if (i >= sizeof(mrb_int)*CHAR_BIT-1) {
-        if (val < 0) return mrb_fixnum_value(-1);
-        return mrb_fixnum_value(0);
-    }
-    val = RSHIFT(val, i);
-    return mrb_fixnum_value(val);
+        return lshift(mrb, val, (unsigned long)-i);
+    return rshift(val, i);
 }
 
 /* 15.2.8.3.23 */
@@ -1066,7 +1072,27 @@ flt2big(mrb_state *mrb, mrb_float d)
 mrb_value
 mrb_flt2big(mrb_state *mrb, mrb_float d)
 {
-    return mrb_fixnum_value(flt2big(mrb, d));
+  return mrb_fixnum_value(flt2big(mrb, d));
+}
+
+mrb_value
+mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  mrb_int a;
+  
+  a = mrb_fixnum(x);
+  if (a == 0) return y;
+  if (FIXNUM_P(y)) {
+    mrb_int b, c;
+
+    b = mrb_fixnum(y);
+    c = a + b;
+    if (c - b != a) {
+      return mrb_float_value((mrb_float)a + (mrb_float)b);
+    }
+    return mrb_fixnum_value(c);
+  }
+  return mrb_float_value((mrb_float)a + mrb_to_flo(mrb, y));
 }
 
 /* 15.2.8.3.1  */
@@ -1079,15 +1105,32 @@ mrb_flt2big(mrb_state *mrb, mrb_float d)
  * result.
  */
 static mrb_value
-mrb_fixnum_plus(mrb_state *mrb, mrb_value self)
+fix_plus(mrb_state *mrb, mrb_value self)
 {
-  mrb_int x, y;
+  mrb_value other;
+
+  mrb_get_args(mrb, "o", &other);
+  return mrb_fixnum_plus(mrb, self, other);
+}
 
-  x = mrb_fixnum(self);
-  mrb_get_args(mrb, "i", &y);
+mrb_value
+mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  mrb_int a;
+  
+  a = mrb_fixnum(x);
+  if (a == 0) return y;
+  if (FIXNUM_P(y)) {
+    mrb_int b, c;
 
-  DEBUG(printf("%d + %d = %d\n", x, y, x+y));
-  return mrb_fixnum_value(x + y);
+    b = mrb_fixnum(y);
+    c = a - b;
+    if (c + b != a) {
+      return mrb_float_value((mrb_float)a - (mrb_float)b);
+    }
+    return mrb_fixnum_value(c);
+  }
+  return mrb_float_value((mrb_float)a - mrb_to_flo(mrb, y));
 }
 
 /* 15.2.8.3.2  */
@@ -1101,15 +1144,12 @@ mrb_fixnum_plus(mrb_state *mrb, mrb_value self)
  * result.
  */
 static mrb_value
-mrb_fixnum_minus(mrb_state *mrb, mrb_value self)
+fix_minus(mrb_state *mrb, mrb_value self)
 {
-  mrb_int x, y;
-
-  x = mrb_fixnum(self);
-  mrb_get_args(mrb, "i", &y);
+  mrb_value other;
 
-  DEBUG(printf("%d - %d = %d\n", x, y, x-y));
-  return mrb_fixnum_value(x - y);
+  mrb_get_args(mrb, "o", &other);
+  return mrb_fixnum_minus(mrb, self, other);
 }
 
 /* 15.2.8.3.29 (x) */
@@ -1179,7 +1219,7 @@ mrb_fix_to_s(mrb_state *mrb, mrb_value self, int argc, mrb_value *argv)
  *
  */
 static mrb_value
-mrb_fixnum_to_s(mrb_state *mrb, mrb_value self) /* fix_to_s */
+fix_to_s(mrb_state *mrb, mrb_value self) /* fix_to_s */
 {
   mrb_value *argv;
   int argc;
@@ -1236,7 +1276,7 @@ num_cmp(mrb_state *mrb, mrb_value self)
  * and <code>other</code>.
  */
 static mrb_value
-mrb_float_plus(mrb_state *mrb, mrb_value self)
+flo_plus(mrb_state *mrb, mrb_value self)
 {
   mrb_float x,  y;
 
@@ -1267,8 +1307,8 @@ mrb_init_numeric(mrb_state *mrb)
   fixnum = mrb->fixnum_class = mrb_define_class(mrb, "Fixnum", integer);
 
   mrb_undef_method(mrb,  fixnum, "new");
-  mrb_define_method(mrb, fixnum,  "+",        mrb_fixnum_plus,   ARGS_REQ(1)); /* 15.2.8.3.1  */
-  mrb_define_method(mrb, fixnum,  "-",        mrb_fixnum_minus,  ARGS_REQ(1)); /* 15.2.8.3.2  */
+  mrb_define_method(mrb, fixnum,  "+",        fix_plus,          ARGS_REQ(1)); /* 15.2.8.3.1  */
+  mrb_define_method(mrb, fixnum,  "-",        fix_minus,         ARGS_REQ(1)); /* 15.2.8.3.2  */
   mrb_define_method(mrb, fixnum,  "-@",       fix_uminus,        ARGS_REQ(1)); /* 15.2.7.4.2  */
   mrb_define_method(mrb, fixnum,  "*",        fix_mul,           ARGS_REQ(1)); /* 15.2.8.3.3  */
   mrb_define_method(mrb, fixnum,  "%",        fix_mod,           ARGS_REQ(1)); /* 15.2.8.3.5  */
@@ -1277,8 +1317,8 @@ mrb_init_numeric(mrb_state *mrb)
   mrb_define_method(mrb, fixnum,  "&",        fix_and,           ARGS_REQ(1)); /* 15.2.8.3.9  */
   mrb_define_method(mrb, fixnum,  "|",        fix_or,            ARGS_REQ(1)); /* 15.2.8.3.10 */
   mrb_define_method(mrb, fixnum,  "^",        fix_xor,           ARGS_REQ(1)); /* 15.2.8.3.11 */
-  mrb_define_method(mrb, fixnum,  "<<",       mrb_fix_lshift,    ARGS_REQ(1)); /* 15.2.8.3.12 */
-  mrb_define_method(mrb, fixnum,  ">>",       mrb_fix_rshift,    ARGS_REQ(1)); /* 15.2.8.3.13 */
+  mrb_define_method(mrb, fixnum,  "<<",       fix_lshift,        ARGS_REQ(1)); /* 15.2.8.3.12 */
+  mrb_define_method(mrb, fixnum,  ">>",       fix_rshift,        ARGS_REQ(1)); /* 15.2.8.3.13 */
   mrb_define_method(mrb, fixnum,  "ceil",     int_to_i,          ARGS_NONE()); /* 15.2.8.3.14 */
   mrb_define_method(mrb, fixnum,  "eql?",     num_eql,           ARGS_REQ(1)); /* 15.2.8.3.16 */
   mrb_define_method(mrb, fixnum,  "floor",    num_floor,         ARGS_NONE()); /* 15.2.8.3.17 */
@@ -1288,22 +1328,22 @@ mrb_init_numeric(mrb_state *mrb)
   mrb_define_method(mrb, fixnum,  "succ",     fix_succ,          ARGS_NONE()); /* 15.2.8.3.21 */
   mrb_define_method(mrb, fixnum,  "to_f",     fix_to_f,          ARGS_NONE()); /* 15.2.8.3.23 */
   mrb_define_method(mrb, fixnum,  "to_i",     int_to_i,          ARGS_NONE()); /* 15.2.8.3.24 */
-  mrb_define_method(mrb, fixnum,  "to_s",     mrb_fixnum_to_s,   ARGS_NONE()); /* 15.2.8.3.25 */
+  mrb_define_method(mrb, fixnum,  "to_s",     fix_to_s,          ARGS_NONE()); /* 15.2.8.3.25 */
   mrb_define_method(mrb, fixnum,  "truncate", int_to_i,          ARGS_NONE()); /* 15.2.8.3.26 */
   mrb_define_method(mrb, fixnum,  "divmod",   fix_divmod,        ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
 
   /* Float Class */
   fl = mrb->float_class = mrb_define_class(mrb, "Float", numeric);
   mrb_undef_method(mrb,  fl, "new");
-  mrb_define_method(mrb, fl,      "+",         mrb_float_plus,   ARGS_REQ(1)); /* 15.2.9.3.1  */
+  mrb_define_method(mrb, fl,      "+",         flo_plus,         ARGS_REQ(1)); /* 15.2.9.3.1  */
   mrb_define_method(mrb, fl,      "-",         flo_minus,        ARGS_REQ(1)); /* 15.2.9.3.2  */
   mrb_define_method(mrb, fl,      "*",         flo_mul,          ARGS_REQ(1)); /* 15.2.9.3.3  */
   mrb_define_method(mrb, fl,      "%",         flo_mod,          ARGS_REQ(1)); /* 15.2.9.3.5  */
   mrb_define_method(mrb, fl,      "==",        flo_eq,           ARGS_REQ(1)); /* 15.2.9.3.7  */
   mrb_define_method(mrb, fl,      "ceil",      flo_ceil,         ARGS_NONE()); /* 15.2.9.3.8  */
-  mrb_define_method(mrb, fl,      "finite?",   flo_is_finite_p,  ARGS_NONE()); /* 15.2.9.3.9  */
+  mrb_define_method(mrb, fl,      "finite?",   flo_finite_p,     ARGS_NONE()); /* 15.2.9.3.9  */
   mrb_define_method(mrb, fl,      "floor",     flo_floor,        ARGS_NONE()); /* 15.2.9.3.10 */
-  mrb_define_method(mrb, fl,      "infinite?", flo_is_infinite_p,ARGS_NONE()); /* 15.2.9.3.11 */
+  mrb_define_method(mrb, fl,      "infinite?", flo_infinite_p,   ARGS_NONE()); /* 15.2.9.3.11 */
   mrb_define_method(mrb, fl,      "round",     flo_round,        ARGS_ANY());  /* 15.2.9.3.12 */
   mrb_define_method(mrb, fl,      "to_f",      flo_to_f,         ARGS_NONE()); /* 15.2.9.3.13 */
   mrb_define_method(mrb, fl,      "to_i",      flo_truncate,     ARGS_NONE()); /* 15.2.9.3.14 */
diff --git a/src/vm.c b/src/vm.c
index c449a9b3c..3d4d0370b 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1162,12 +1162,12 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   regs[a].value.v1 = regs[a].value.v1 op regs[a+1].value.v2;\
 } while(0)
 
-#define OP_MATH(op) do {\
+#define OP_MATH(op,iop,s) do {\
   int a = GETARG_A(i);\
-  /* need to check if - is overridden */\
+  /* need to check if op is overridden */\
   switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
   case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
-    OP_MATH_BODY(op,i,i);                  \
+    regs[a] = iop(mrb, regs[a], regs[a+1]);\
     break;\
   case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\
     {\
@@ -1182,6 +1182,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
     OP_MATH_BODY(op,f,f);\
     break;\
+    s\
   default:\
     i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));\
     goto L_SEND;\
@@ -1190,50 +1191,28 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
     CASE(OP_ADD) {
       /* A B C  R(A) := R(A)+R(A+1) (Syms[B]=:+,C=1)*/
-      int a = GETARG_A(i);
-
-      switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
-      case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
-        OP_MATH_BODY(+,i,i);
-        break;
-      case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):
-        {
-          mrb_int x = regs[a].value.i;
-          mrb_float y = regs[a+1].value.f;
-          SET_FLOAT_VALUE(regs[a], (mrb_float)x + y);
-        }
-        break;
-      case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):
-        OP_MATH_BODY(+,f,i);
-        break;
-      case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):
-        OP_MATH_BODY(+,f,f);
-        break;
+      OP_MATH(+,mrb_fixnum_plus,
       case TYPES2(MRB_TT_STRING,MRB_TT_STRING):
         regs[a] = mrb_str_plus(mrb, regs[a], regs[a+1]);
-        break;
-      default:
-        i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));
-        goto L_SEND;
-      }
+	break;);
       NEXT;
     }
 
     CASE(OP_SUB) {
       /* A B C  R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)*/
-      OP_MATH(-);
+      OP_MATH(-,mrb_fixnum_minus,;);
       NEXT;
     }
 
     CASE(OP_MUL) {
       /* A B C  R(A) := R(A)*R(A+1) (Syms[B]=:*,C=1)*/
-      OP_MATH(*);
+      OP_MATH(*,mrb_fixnum_mul,;);
       NEXT;
     }
 
     CASE(OP_DIV) {
       /* A B C  R(A) := R(A)/R(A+1) (Syms[B]=:/,C=1)*/
-      OP_MATH(/);
+      OP_MATH(/,mrb_num_div,;);
       NEXT;
     }
 
-- 
cgit v1.2.3


From 6adaf3b80fd255668f4fe500afc4fd1d0dfad50b Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 14 Jun 2012 01:47:31 +0900
Subject: should invoke ensure clauses just before terminating mrb_sun; close
 #270

---
 src/vm.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 3d4d0370b..ef3535d53 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -164,6 +164,7 @@ ecall(mrb_state *mrb, int i)
   struct RProc *p;
   mrb_callinfo *ci;
   mrb_value *self = mrb->stack;
+  struct RObject *exc;
 
   p = mrb->ensure[i];
   ci = cipush(mrb);
@@ -175,7 +176,9 @@ ecall(mrb_state *mrb, int i)
   ci->nregs = p->body.irep->nregs;
   ci->target_class = p->target_class;
   mrb->stack = mrb->stack + ci[-1].nregs;
+  exc = mrb->exc; mrb->exc = 0;
   mrb_run(mrb, p, *self);
+  mrb->exc = exc;
 }
 
 mrb_value
@@ -999,13 +1002,18 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     L_RETURN:
       if (mrb->exc) {
         mrb_callinfo *ci;
+        int eidx;
 
       L_RAISE:
         ci = mrb->ci;
+	eidx = mrb->ci->eidx;
         if (ci == mrb->cibase) goto L_STOP;
         while (ci[0].ridx == ci[-1].ridx) {
           cipop(mrb);
           ci = mrb->ci;
+	  while (eidx > mrb->ci->eidx) {
+	    ecall(mrb, --eidx);
+	  }
           if (ci == mrb->cibase) {
             if (ci->ridx == 0) {
 	      mrb->stack = mrb->stbase;
@@ -1569,6 +1577,13 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     CASE(OP_STOP) {
       /*        stop VM */
     L_STOP:
+      {
+	int n = mrb->ci->eidx;
+
+	while (n--) {
+	  ecall(mrb, n);
+	}
+      }
       mrb->jmp = prev_jmp;
       if (mrb->exc) {
 	return mrb_obj_value(mrb->exc);
-- 
cgit v1.2.3


From 36a1c80d3ce37c7b5202a4415e0a8ab8ebe677d6 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 14 Jun 2012 03:44:45 +0900
Subject: uvenv(): proc->env may be NULL be before uplevel

---
 src/vm.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index ef3535d53..e229a4a54 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -94,8 +94,8 @@ uvenv(mrb_state *mrb, int up)
 {
   struct REnv *e = mrb->ci->proc->env;
 
-  if (!e) return 0;
   while (up--) {
+    if (!e) return 0;
     e = (struct REnv*)e->c;
   }
   return e;
-- 
cgit v1.2.3


From 2eeaab4e81ea475d80af9d49cf333bb416fd666f Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 14 Jun 2012 04:44:02 +0900
Subject: do not offset jump from OP_ENTER if no optional argument given

---
 src/vm.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index e229a4a54..951c63b21 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -971,7 +971,9 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         if (r) {                  /* r */
           regs[m1+o+1] = mrb_ary_new_capa(mrb, 0);
         }
-        pc += argc - m1 - m2 + 1;
+	if (o == 0) pc++;
+	else
+	  pc += argc - m1 - m2 + 1;
       }
       else {
         memmove(&regs[1], argv, sizeof(mrb_value)*(m1+o)); /* m1 + o */
-- 
cgit v1.2.3


From 49133111554a3e0d6a4ff415641cc5ec721d8df4 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 15 Jun 2012 16:20:25 +0900
Subject: should not swallow exceptions from ensure clause

---
 src/vm.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 951c63b21..32d2a6a24 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -178,7 +178,7 @@ ecall(mrb_state *mrb, int i)
   mrb->stack = mrb->stack + ci[-1].nregs;
   exc = mrb->exc; mrb->exc = 0;
   mrb_run(mrb, p, *self);
-  mrb->exc = exc;
+  if (!mrb->exc) mrb->exc = exc;
 }
 
 mrb_value
-- 
cgit v1.2.3


From 5353b8555cac47f1615899e5622acb411a501eab Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 15 Jun 2012 22:57:11 +0900
Subject: exception jump should not cross mrb_funcall border; close #276

---
 src/vm.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 32d2a6a24..826cdafef 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1013,6 +1013,10 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         while (ci[0].ridx == ci[-1].ridx) {
           cipop(mrb);
           ci = mrb->ci;
+	  if (ci->acc < 0) {
+	    mrb->jmp = prev_jmp;
+	    longjmp(*(jmp_buf*)mrb->jmp, 1);
+	  }
 	  while (eidx > mrb->ci->eidx) {
 	    ecall(mrb, --eidx);
 	  }
-- 
cgit v1.2.3


From 88db589e7f965e5b16b82eca76f2e1febd82d124 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 20 Jun 2012 15:12:35 +0900
Subject: protect crash from empty irep

---
 src/vm.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 826cdafef..c78799c6d 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -788,6 +788,10 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         /* setup environment for calling method */
         proc = m;
         irep = m->body.irep;
+	if (!irep) {
+	  mrb->stack[0] = mrb_nil_value();
+	  goto L_RETURN;
+	}
         pool = irep->pool;
         syms = irep->syms;
         ci->nregs = irep->nregs;
-- 
cgit v1.2.3


From ef50e63a63c9b3759a2030816c9e2c5ec4e14cd0 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 20 Jun 2012 20:43:27 +0900
Subject: remove RuntimeError from mrb_state

---
 include/mruby.h | 2 +-
 src/error.c     | 8 ++++----
 src/gc.c        | 2 +-
 src/kernel.c    | 6 +++---
 src/re.c        | 2 +-
 src/string.c    | 2 +-
 src/vm.c        | 2 +-
 7 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'src/vm.c')

diff --git a/include/mruby.h b/include/mruby.h
index ef742cef4..aadd56e94 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -279,7 +279,6 @@ typedef struct mrb_state {
 
   struct RClass *eException_class;
   struct RClass *eStandardError_class;
-  struct RClass *eRuntimeError_class;
 
   void *ud; /* auxiliary data */
 } mrb_state;
@@ -430,6 +429,7 @@ void rb_raise(struct RClass *c, const char *fmt, ...);
 void mrb_warn(const char *fmt, ...);
 void mrb_bug(const char *fmt, ...);
 
+#define E_RUNTIME_ERROR             (mrb_class_obj_get(mrb, "RuntimeError"))
 #define E_TYPE_ERROR                (mrb_class_obj_get(mrb, "TypeError"))
 #define E_ARGUMENT_ERROR            (mrb_class_obj_get(mrb, "ArgumentError"))
 #define E_INDEX_ERROR               (mrb_class_obj_get(mrb, "IndexError"))
diff --git a/src/error.c b/src/error.c
index b2d9a8c8d..1183d8643 100644
--- a/src/error.c
+++ b/src/error.c
@@ -301,7 +301,7 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr)
       if (isstr) {
         mesg = mrb_check_string_type(mrb, argv[0]);
         if (!mrb_nil_p(mesg)) {
-          mesg = mrb_exc_new3(mrb, mrb->eRuntimeError_class, mesg);
+          mesg = mrb_exc_new3(mrb, E_RUNTIME_ERROR, mesg);
           break;
         }
       }
@@ -352,7 +352,7 @@ mrb_make_exception(mrb_state *mrb, int argc, mrb_value *argv)
 void
 mrb_sys_fail(mrb_state *mrb, const char *mesg)
 {
-  mrb_raise(mrb, mrb->eRuntimeError_class, "%s", mesg);
+  mrb_raise(mrb, E_RUNTIME_ERROR, "%s", mesg);
 }
 
 void
@@ -369,6 +369,6 @@ mrb_init_exception(mrb_state *mrb)
   mrb_define_method(mrb, e, "message", exc_message, ARGS_NONE());
   mrb_define_method(mrb, e, "inspect", exc_inspect, ARGS_NONE());
 
-  mrb->eStandardError_class     = mrb_define_class(mrb, "StandardError",       mrb->eException_class);     /* 15.2.23 */
-  mrb->eRuntimeError_class      = mrb_define_class(mrb, "RuntimeError",        mrb->eStandardError_class); /* 15.2.28 */
+  mrb->eStandardError_class     = mrb_define_class(mrb, "StandardError",       mrb->eException_class); /* 15.2.23 */
+  mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class);                                    /* 15.2.28 */
 }
diff --git a/src/gc.c b/src/gc.c
index c07c9b13b..a7537a015 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -277,7 +277,7 @@ gc_protect(mrb_state *mrb, struct RBasic *p)
   if (mrb->arena_idx > MRB_ARENA_SIZE) {
     /* arena overflow error */
     mrb->arena_idx = MRB_ARENA_SIZE - 4; /* force room in arena */
-    mrb_raise(mrb, mrb->eRuntimeError_class, "arena overflow error");
+    mrb_raise(mrb, E_RUNTIME_ERROR, "arena overflow error");
   }
   mrb->arena[mrb->arena_idx++] = p;
 }
diff --git a/src/kernel.c b/src/kernel.c
index 5b65714b6..209eaa91d 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -573,7 +573,7 @@ mrb_obj_instance_eval(mrb_state *mrb, mrb_value self)
   mrb_value a, b;
 
   if (mrb_get_args(mrb, "|S&", &a, &b) == 1) {
-    mrb_raise(mrb, mrb->eRuntimeError_class, "instance_eval with string not implemented");
+    mrb_raise(mrb, E_RUNTIME_ERROR, "instance_eval with string not implemented");
   }
   return mrb_yield_with_self(mrb, b, 0, 0, self);
 }
@@ -1019,13 +1019,13 @@ mrb_f_raise(mrb_state *mrb, mrb_value self)
   argc = mrb_get_args(mrb, "|oo", &a[0], &a[1]);
   switch (argc) {
   case 0:
-    mrb_raise(mrb, mrb->eRuntimeError_class, "");
+    mrb_raise(mrb, E_RUNTIME_ERROR, "");
     break;
   case 1:
     a[1] = mrb_check_string_type(mrb, a[0]);
     if (!mrb_nil_p(a[1])) {
       argc = 2;
-      a[0] = mrb_obj_value(mrb->eRuntimeError_class);
+      a[0] = mrb_obj_value(E_RUNTIME_ERROR);
     }
     /* fall through */
   default:
diff --git a/src/re.c b/src/re.c
index 70e7c59b6..b821d2e71 100644
--- a/src/re.c
+++ b/src/re.c
@@ -2143,7 +2143,7 @@ mrb_reg_regsub(mrb_state *mrb, mrb_value str, mrb_value src, struct re_registers
                 break;
             }
             else {
-                mrb_raise(mrb, mrb->eRuntimeError_class, "invalid group name reference format");
+                mrb_raise(mrb, E_RUNTIME_ERROR, "invalid group name reference format");
             }
         }
 
diff --git a/src/string.c b/src/string.c
index 6392b504c..585edf8a3 100644
--- a/src/string.c
+++ b/src/string.c
@@ -100,7 +100,7 @@ str_mod_check(mrb_state *mrb, mrb_value str, char *p, mrb_int len)
   struct RString *s = mrb_str_ptr(str);
 
   if (s->ptr != p || s->len != len) {
-    mrb_raise(mrb, mrb->eRuntimeError_class, "string modified");
+    mrb_raise(mrb, E_RUNTIME_ERROR, "string modified");
   }
 }
 
diff --git a/src/vm.c b/src/vm.c
index c78799c6d..f3e5a497a 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1604,7 +1604,7 @@ 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 exc = mrb_exc_new3(mrb, mrb->eRuntimeError_class, msg);
+      mrb_value exc = mrb_exc_new3(mrb, E_RUNTIME_ERROR, msg);
 
       mrb->exc = (struct RObject*)mrb_object(exc);
       goto L_RAISE;
-- 
cgit v1.2.3


From 2d781f5c1da6f627d9b4d3c2c7e9444108e09221 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 23 Jun 2012 09:49:14 +0900
Subject: remove assertion for false assumption; mrb_str_new(0, len) where len
 > 0 can be used to allocate an unintialized string

---
 src/string.c | 3 +--
 src/vm.c     | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/string.c b/src/string.c
index 6b2df1590..a943512c7 100644
--- a/src/string.c
+++ b/src/string.c
@@ -21,7 +21,6 @@
 #include "regex.h"
 #include "st.h"
 #endif //ENABLE_REGEXP
-#include <assert.h>
 
 const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
@@ -222,7 +221,7 @@ mrb_value
 mrb_str_new(mrb_state *mrb, const char *p, int len)
 {
   struct RString *s;
-  assert(!(!p && len));
+
   s = str_new(mrb, p, len);
   return mrb_obj_value(s);
 }
diff --git a/src/vm.c b/src/vm.c
index f3e5a497a..04392891f 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -393,7 +393,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   mrb_code i;
   int ai = mrb->arena_idx;
   jmp_buf c_jmp;
-  jmp_buf *prev_jmp = NULL;
+  volatile jmp_buf *prev_jmp = NULL;
 
 #ifdef DIRECT_THREADED
   static void *optable[] = {
-- 
cgit v1.2.3


From f045e646751bfe0f399aae59746befa6384b96aa Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 23 Jun 2012 13:51:50 +0900
Subject: reduce calling mrb_str_new_cstr() to avoid strlen(); #301

---
 src/class.c   | 17 ++++++++++++-----
 src/codegen.c | 10 ++++++----
 src/hash.c    |  6 +++---
 src/kernel.c  |  2 +-
 src/object.c  |  8 +++-----
 src/re.c      | 13 +++++++------
 src/sprintf.c | 10 ++++++----
 src/string.c  |  5 ++---
 src/struct.c  |  9 +++++----
 src/time.c    | 13 +++++++------
 src/vm.c      | 18 ++++++++++--------
 11 files changed, 62 insertions(+), 49 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/class.c b/src/class.c
index 56ab8c06f..a9bf54a3b 100644
--- a/src/class.c
+++ b/src/class.c
@@ -972,15 +972,23 @@ mrb_class_path(mrb_state *mrb, struct RClass *c)
     struct RClass *outer = mrb_class_outer_module(mrb, c);
     mrb_sym sym = class_sym(mrb, c, outer);
     if (outer && outer != mrb->object_class) {
+      char *name;
+      int len;
+
       mrb_value base = mrb_class_path(mrb, outer);
-      path = mrb_str_plus(mrb, base, mrb_str_new_cstr(mrb, "::"));
-      mrb_str_concat(mrb, path, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym)));
+      path = mrb_str_plus(mrb, base, mrb_str_new(mrb, "::", 2));
+      name = mrb_sym2name_len(mrb, sym, &len);
+      mrb_str_concat(mrb, path, mrb_str_new(mrb, name, len));
     }
     else if (sym == 0) {
       return mrb_nil_value();
     }
     else {
-      path = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym));
+      char *name;
+      int len;
+
+      name = mrb_sym2name_len(mrb, sym, &len);
+      path = mrb_str_new(mrb, name, len);
     }
     mrb_obj_iv_set(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__"), path);
   }
@@ -1114,9 +1122,8 @@ mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const
 static mrb_value
 mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
 {
-  //if (FL_TEST(klass, FL_SINGLETON)) {
   if (mrb_type(klass) == MRB_TT_SCLASS) {
-    mrb_value s = mrb_str_new_cstr(mrb, "#<");
+    mrb_value s = mrb_str_new(mrb, "#<", 2);
     mrb_value v = mrb_iv_get(mrb, klass, mrb_intern(mrb, "__attached__"));
 
     mrb_str_cat2(mrb, s, "Class:");
diff --git a/src/codegen.c b/src/codegen.c
index 72fc1097d..cbf401a1f 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -1534,10 +1534,11 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_BACK_REF:
     {
       char buf[4];
+      int len;
       int sym;
 
-      snprintf(buf, 3, "$%c", (int)(intptr_t)tree);
-      sym = new_sym(s, mrb_intern(s->mrb, buf));
+      len = snprintf(buf, 3, "$%c", (int)(intptr_t)tree);
+      sym = new_sym(s, mrb_intern2(s->mrb, buf, len));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
     }
@@ -1546,10 +1547,11 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_NTH_REF:
     {
       char buf[4];
+      int len;
       int sym;
 
-      snprintf(buf, 3, "$%d", (int)(intptr_t)tree);
-      sym = new_sym(s, mrb_intern(s->mrb, buf));
+      len = snprintf(buf, 3, "$%d", (int)(intptr_t)tree);
+      sym = new_sym(s, mrb_intern2(s->mrb, buf, len));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
     }
diff --git a/src/hash.c b/src/hash.c
index 0e06cd246..a87ca97d4 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -889,9 +889,9 @@ inspect_hash(mrb_state *mrb, mrb_value hash, int recur)
   khash_t(ht) *h = RHASH_TBL(hash);
   khiter_t k;
 
-  if (recur) return mrb_str_new_cstr(mrb, "{...}");
+  if (recur) return mrb_str_new(mrb, "{...}", 5);
 
-  str = mrb_str_new_cstr(mrb, "{");
+  str = mrb_str_new(mrb, "{", 1);
   if (h && kh_size(h) > 0) {
     for (k = kh_begin(h); k != kh_end(h); k++) {
       int ai;
@@ -934,7 +934,7 @@ mrb_hash_inspect(mrb_state *mrb, mrb_value hash)
   khash_t(ht) *h = RHASH_TBL(hash);
 
   if (!h || kh_size(h) == 0)
-    return mrb_str_new_cstr(mrb, "{}");
+    return mrb_str_new(mrb, "{}", 2);
   return inspect_hash(mrb, hash, 0);
 }
 
diff --git a/src/kernel.c b/src/kernel.c
index 8f2b15378..8da112ee5 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -117,7 +117,7 @@ mrb_obj_inspect(mrb_state *mrb, mrb_value obj)
     return mrb_any_to_s(mrb, obj);
   }
   else if (mrb_nil_p(obj)) {
-    return mrb_str_new_cstr(mrb, "nil");
+    return mrb_str_new(mrb, "nil", 3);
   }
   return mrb_funcall(mrb, obj, "to_s", 0, 0);
 }
diff --git a/src/object.c b/src/object.c
index a30e7c58a..eb63c1293 100644
--- a/src/object.c
+++ b/src/object.c
@@ -151,7 +151,7 @@ true_xor(mrb_state *mrb, mrb_value obj)
 static mrb_value
 true_to_s(mrb_state *mrb, mrb_value obj)
 {
-    return mrb_str_new_cstr(mrb, "true");
+  return mrb_str_new(mrb, "true", 4);
 }
 
 /* 15.2.5.3.4  */
@@ -264,7 +264,7 @@ false_or(mrb_state *mrb, mrb_value obj)
 static mrb_value
 false_to_s(mrb_state *mrb, mrb_value obj)
 {
-    return mrb_str_new_cstr(mrb, "false");
+  return mrb_str_new(mrb, "false", 5);
 }
 
 void
@@ -462,9 +462,7 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj)
   len = strlen(cname)+6+16;
   str = mrb_str_new(mrb, 0, len); /* 6:tags 16:addr */
   s = mrb_str_ptr(str);
-  //  snprintf(RSTRING(str)->ptr, len+1, "#<%s:0x%lx>", cname, obj);
-  sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p));
-  s->len = strlen(s->ptr);
+  s->len = sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p));
 
   return str;
 }
diff --git a/src/re.c b/src/re.c
index 12061eacf..a7552de11 100644
--- a/src/re.c
+++ b/src/re.c
@@ -354,10 +354,10 @@ mrb_reg_options(mrb_state *mrb, mrb_value re)
 static mrb_value
 mrb_reg_desc(mrb_state *mrb, const char *s, long len, mrb_value re)
 {
-  mrb_value str = mrb_str_new_cstr(mrb, "/");//mrb_str_buf_new2("/");
+  mrb_value str = mrb_str_new(mrb, "/", 1);
 
   mrb_reg_expr_str(mrb, str, s, len);
-  mrb_str_buf_cat(mrb, str, "/", sizeof("/"));
+  mrb_str_buf_cat(mrb, str, "/", 1);
   if (re.tt) {
     char opts[4];
     mrb_reg_check(mrb, re);
@@ -1688,9 +1688,10 @@ mrb_reg_expr_str(mrb_state *mrb, mrb_value str, const char *s, long len)
       }
       else if (!ISSPACE(c)) {
         char b[8];
+	int n;
 
-        snprintf(b, sizeof(b), "\\x%02X", c);
-        mrb_str_buf_cat(mrb, str, b, 4);
+        n = snprintf(b, sizeof(b), "\\x%02X", c);
+        mrb_str_buf_cat(mrb, str, b, n);
       }
       else {
         mrb_str_buf_cat(mrb, str, p, 1);
@@ -1728,7 +1729,7 @@ mrb_reg_to_s(mrb_state *mrb, mrb_value re)
   const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND;
   long len;
   const UChar* ptr;
-  mrb_value str = mrb_str_new_cstr(mrb, "(?");
+  mrb_value str = mrb_str_new(mrb, "(?", 2);
   char optbuf[5];
   mrb_encoding *enc = mrb_enc_get(mrb, re);
 
@@ -1918,7 +1919,7 @@ mrb_match_inspect(mrb_state *mrb, mrb_value match)
     onig_foreach_name(regexp->ptr,
             match_inspect_name_iter, names);
 
-    str = mrb_str_new_cstr(mrb, "#<");//mrb_str_buf_new2("#<");
+    str = mrb_str_new(mrb, "#<", 2);
     mrb_str_buf_cat(mrb, str, cname, strlen(cname));
 
     for (i = 0; i < num_regs; i++) {
diff --git a/src/sprintf.c b/src/sprintf.c
index e01bf572e..56141e482 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -1061,6 +1061,8 @@ static void
 fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
 {
     char *end = buf + size;
+    int n;
+
     *buf++ = '%';
     if (flags & FSHARP) *buf++ = '#';
     if (flags & FPLUS)  *buf++ = '+';
@@ -1069,13 +1071,13 @@ fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
     if (flags & FSPACE) *buf++ = ' ';
 
     if (flags & FWIDTH) {
-      snprintf(buf, end - buf, "%d", width);
-      buf += strlen(buf);
+      n = snprintf(buf, end - buf, "%d", width);
+      buf += n;
     }
 
     if (flags & FPREC) {
-      snprintf(buf, end - buf, ".%d", prec);
-      buf += strlen(buf);
+      n = snprintf(buf, end - buf, ".%d", prec);
+      buf += n;
     }
 
     *buf++ = c;
diff --git a/src/string.c b/src/string.c
index a943512c7..1ef0cdc33 100644
--- a/src/string.c
+++ b/src/string.c
@@ -2517,6 +2517,7 @@ bad:
       printf("Integer");
   return mrb_fixnum_value(0);
 }
+
 char *
 mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
 {
@@ -2535,10 +2536,8 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck)
   char *s;
   int len;
 
-  //StringValue(str);
   mrb_string_value(mrb, &str);
   if (badcheck) {
-    //s = StringValueCStr(str);
     s = mrb_string_value_cstr(mrb, &str);
   }
   else {
@@ -2949,7 +2948,7 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str)
 {
     const char *p, *pend;
     char buf[CHAR_ESC_LEN + 1];
-    mrb_value result = mrb_str_new_cstr(mrb, "\"");
+    mrb_value result = mrb_str_new(mrb, "\"", 1);
 
     p = RSTRING_PTR(str); pend = RSTRING_END(str);
     for (;p < pend; p++) {
diff --git a/src/struct.c b/src/struct.c
index 7e422f140..60a0edb5b 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -521,8 +521,11 @@ inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur)
       slot = ptr_members[i];
       id = SYM2ID(slot);
       if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
-        //mrb_str_append(str, mrb_id2str(id));
-        mrb_str_append(mrb, str, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id)));
+	char *name;
+	int len;
+
+	name = mrb_sym2name_len(mrb, id, &len);
+        mrb_str_append(mrb, str, mrb_str_new(mrb, name, len));
       }
       else {
           mrb_str_append(mrb, str, mrb_inspect(mrb, slot));
@@ -804,9 +807,7 @@ mrb_init_struct(mrb_state *mrb)
 {
   struct RClass *st;
   st = mrb_define_class(mrb, "Struct",  mrb->object_class);
-  //mrb_include_module(mrb_cStruct, rb_mEnumerable);
 
-  //mrb_undef_alloc_func(mrb_cStruct);
   mrb_define_class_method(mrb, st, "new",             mrb_struct_s_def,       ARGS_ANY());  /* 15.2.18.3.1  */
 
   mrb_define_method(mrb, st,       "==",              mrb_struct_equal,       ARGS_REQ(1)); /* 15.2.18.4.1  */
diff --git a/src/time.c b/src/time.c
index 55060729b..28cc3c1a3 100644
--- a/src/time.c
+++ b/src/time.c
@@ -430,16 +430,17 @@ mrb_time_asctime(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm;
   struct tm *d;
   char buf[256];
+  int len;
 
   tm = mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   d = &tm->datetime;
-  snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d",
-	   wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, 
-	   d->tm_hour, d->tm_min, d->tm_sec,
-	   tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "",
-	   d->tm_year + 1900);
-  return mrb_str_new_cstr(mrb, buf);
+  len = snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d",
+		 wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, 
+		 d->tm_hour, d->tm_min, d->tm_sec,
+		 tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "",
+		 d->tm_year + 1900);
+  return mrb_str_new(mrb, buf, len);
 }
 
 /* 15.2.19.7.6 */
diff --git a/src/vm.c b/src/vm.c
index 04392891f..daba0acc6 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -292,10 +292,11 @@ static void
 localjump_error(mrb_state *mrb, const char *kind)
 {
   char buf[256];
+  int len;
   mrb_value exc;
 
-  snprintf(buf, 256, "unexpected %s", kind);
-  exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, strlen(buf));
+  len = snprintf(buf, 256, "unexpected %s", kind);
+  exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, len);
   mrb->exc = (struct RObject*)mrb_object(exc);
 }
 
@@ -303,18 +304,19 @@ static void
 argnum_error(mrb_state *mrb, int num)
 {
   char buf[256];
+  int len;
   mrb_value exc;
 
   if (mrb->ci->mid) {
-    snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)",
-	     mrb_sym2name(mrb, mrb->ci->mid),
-	     mrb->ci->argc, num);
+    len = snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)",
+		   mrb_sym2name(mrb, mrb->ci->mid),
+		   mrb->ci->argc, num);
   }
   else {
-    snprintf(buf, 256, "wrong number of arguments (%d for %d)",
-	     mrb->ci->argc, num);
+    len = snprintf(buf, 256, "wrong number of arguments (%d for %d)",
+		   mrb->ci->argc, num);
   }
-  exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, strlen(buf));
+  exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, len);
   mrb->exc = (struct RObject*)mrb_object(exc);
 }
 
-- 
cgit v1.2.3


From c261e4f360106eeb5d9193c30410818884e19ccc Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 24 Jun 2012 00:15:22 +0900
Subject: resolve crash issue on LLVM; longjmp cleared some local variable

---
 src/vm.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index daba0acc6..d7048f8f0 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -394,8 +394,8 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   mrb_value *regs = NULL;
   mrb_code i;
   int ai = mrb->arena_idx;
+  jmp_buf *prev_jmp = mrb->jmp;
   jmp_buf c_jmp;
-  volatile jmp_buf *prev_jmp = NULL;
 
 #ifdef DIRECT_THREADED
   static void *optable[] = {
@@ -424,7 +424,6 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
 
   if (setjmp(c_jmp) == 0) {
-    prev_jmp = mrb->jmp;
     mrb->jmp = &c_jmp;
   }
   else {
-- 
cgit v1.2.3


From c99b806f8bd29ff49b0f7384a105fe4cebc8511f Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 25 Jun 2012 19:24:57 +0900
Subject: ci->acc should not be left uninitialized; close #303

---
 src/vm.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index d7048f8f0..136ece3bd 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -711,6 +711,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       if (ci->argc == CALL_MAXARGS) ci->argc = -1;
       ci->target_class = m->target_class;
       ci->pc = pc + 1;
+      ci->acc = a;
 
       /* prepare stack */
       mrb->stack += a;
@@ -725,9 +726,6 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         NEXT;
       }
       else {
-        /* fill callinfo */
-        ci->acc = a;
-
         /* setup environment for calling method */
         proc = mrb->ci->proc = m;
         irep = m->body.irep;
-- 
cgit v1.2.3


From d534f26f16ba94c2182a44e4201352d1fb277af0 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Wed, 27 Jun 2012 10:36:39 +0900
Subject: Use sizeof to get char array sizes.

---
 src/class.c   | 4 ++--
 src/codegen.c | 4 ++--
 src/error.c   | 6 +++---
 src/time.c    | 2 +-
 src/vm.c      | 6 +++---
 5 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/class.c b/src/class.c
index 071d7aebe..599db9da5 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1149,11 +1149,11 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
 
       switch (mrb_type(klass)) {
         case MRB_TT_CLASS:
-          snprintf(buf, 256, "#<Class:%p>", c);
+          snprintf(buf, sizeof(buf), "#<Class:%p>", c);
           break;
 
         case MRB_TT_MODULE:
-          snprintf(buf, 256, "#<Module:%p>", c);
+          snprintf(buf, sizeof(buf), "#<Module:%p>", c);
           break;
 
         default:
diff --git a/src/codegen.c b/src/codegen.c
index cbf401a1f..fb0006625 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -1537,7 +1537,7 @@ codegen(codegen_scope *s, node *tree, int val)
       int len;
       int sym;
 
-      len = snprintf(buf, 3, "$%c", (int)(intptr_t)tree);
+      len = snprintf(buf, sizeof(buf), "$%c", (int)(intptr_t)tree);
       sym = new_sym(s, mrb_intern2(s->mrb, buf, len));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
@@ -1550,7 +1550,7 @@ codegen(codegen_scope *s, node *tree, int val)
       int len;
       int sym;
 
-      len = snprintf(buf, 3, "$%d", (int)(intptr_t)tree);
+      len = snprintf(buf, sizeof(buf), "$%d", (int)(intptr_t)tree);
       sym = new_sym(s, mrb_intern2(s->mrb, buf, len));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
diff --git a/src/error.c b/src/error.c
index 1183d8643..e46e37cbb 100644
--- a/src/error.c
+++ b/src/error.c
@@ -180,7 +180,7 @@ mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
   int n;
 
   va_start(args, fmt);
-  n = vsnprintf(buf, 256, fmt, args);
+  n = vsnprintf(buf, sizeof(buf), fmt, args);
   va_end(args);
   if (n < 0) {
     n = 0;
@@ -197,7 +197,7 @@ mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...)
   int n;
 
   va_start(args, fmt);
-  n = vsnprintf(buf, 256, fmt, args);
+  n = vsnprintf(buf, sizeof(buf), fmt, args);
   va_end(args);
   if (n < 0) {
     n = 0;
@@ -216,7 +216,7 @@ mrb_sprintf(mrb_state *mrb, const char *fmt, ...)
   int n;
 
   va_start(args, fmt);
-  n = vsnprintf(buf, 256, fmt, args);
+  n = vsnprintf(buf, sizeof(buf), fmt, args);
   va_end(args);
   if (n < 0) {
     n = 0;
diff --git a/src/time.c b/src/time.c
index 28cc3c1a3..3da824e82 100644
--- a/src/time.c
+++ b/src/time.c
@@ -435,7 +435,7 @@ mrb_time_asctime(mrb_state *mrb, mrb_value self)
   tm = mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   d = &tm->datetime;
-  len = snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d",
+  len = snprintf(buf, sizeof(buf), "%s %s %02d %02d:%02d:%02d %s%d",
 		 wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, 
 		 d->tm_hour, d->tm_min, d->tm_sec,
 		 tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "",
diff --git a/src/vm.c b/src/vm.c
index 136ece3bd..d69081c9c 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -295,7 +295,7 @@ localjump_error(mrb_state *mrb, const char *kind)
   int len;
   mrb_value exc;
 
-  len = snprintf(buf, 256, "unexpected %s", kind);
+  len = snprintf(buf, sizeof(buf), "unexpected %s", kind);
   exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, len);
   mrb->exc = (struct RObject*)mrb_object(exc);
 }
@@ -308,12 +308,12 @@ argnum_error(mrb_state *mrb, int num)
   mrb_value exc;
 
   if (mrb->ci->mid) {
-    len = snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)",
+    len = snprintf(buf, sizeof(buf), "'%s': wrong number of arguments (%d for %d)",
 		   mrb_sym2name(mrb, mrb->ci->mid),
 		   mrb->ci->argc, num);
   }
   else {
-    len = snprintf(buf, 256, "wrong number of arguments (%d for %d)",
+    len = snprintf(buf, sizeof(buf), "wrong number of arguments (%d for %d)",
 		   mrb->ci->argc, num);
   }
   exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, len);
-- 
cgit v1.2.3


From ca930538eaac4aa64ce65ef6dbf6c60fe3caccab Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 5 Jul 2012 01:40:23 +0900
Subject: prepare for OP_TAILCALL

---
 src/codegen.c | 5 +++++
 src/vm.c      | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

(limited to 'src/vm.c')

diff --git a/src/codegen.c b/src/codegen.c
index 963e94b21..3236713e2 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -2149,6 +2149,11 @@ codedump(mrb_state *mrb, int n)
              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
              GETARG_C(c));
       break;
+    case OP_TAILCALL:
+      printf("OP_TAILCALL\tR%d\t:%s\t%d\n", GETARG_A(c),
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
+             GETARG_C(c));
+      break;
     case OP_SUPER:
       printf("OP_SUPER\tR%d\t%d\n", GETARG_A(c),
              GETARG_C(c));
diff --git a/src/vm.c b/src/vm.c
index d69081c9c..62fba24d0 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1120,7 +1120,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
 
       /* replace callinfo */
-      mrb->ci = ci = &mrb->ci[-1];
+      ci = mrb->ci;
       ci->mid = mid;
       ci->target_class = m->target_class;
       ci->argc = n;
-- 
cgit v1.2.3


From 611cf71a10051d77a7bb8998d8a7c34e26b0b1b0 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Sun, 8 Jul 2012 11:33:49 +0900
Subject: Use mrb_calloc if you want zero cleard buffers.

---
 src/array.c | 3 +--
 src/dump.c  | 7 ++-----
 src/gc.c    | 4 +---
 src/parse.y | 3 +--
 src/state.c | 3 +--
 src/vm.c    | 6 ++----
 6 files changed, 8 insertions(+), 18 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/array.c b/src/array.c
index 29f58d17e..d65a99cc4 100644
--- a/src/array.c
+++ b/src/array.c
@@ -46,8 +46,7 @@ ary_new_capa(mrb_state *mrb, int capa)
   }
 
   a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);
-  a->ptr = mrb_malloc(mrb, blen);
-  memset(a->ptr, 0, blen);
+  a->ptr = mrb_calloc(mrb, blen, 1);
   a->aux.capa = capa;
   a->len = 0;
 
diff --git a/src/dump.c b/src/dump.c
index 0e40cf3ed..a720090fa 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -460,11 +460,10 @@ calc_crc_section(mrb_state *mrb, mrb_irep *irep, uint16_t *crc, int section)
   default: return MRB_DUMP_GENERAL_FAILURE;
   }
 
-  if ((buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((buf = mrb_calloc(mrb, 1, buf_size)) == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
   buf_top = buf;
-  memset(buf, 0, buf_size);
 
   switch (section) {
   case DUMP_IREP_HEADER: buf += write_irep_header(mrb, irep, buf, type); break;
@@ -598,11 +597,9 @@ dump_irep_record(mrb_state *mrb, int irep_no, FILE* fp, uint32_t *rlen)
   if (irep_record_size == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
-  if ((buf = mrb_malloc(mrb, irep_record_size)) == 0)
+  if ((buf = mrb_calloc(mrb, 1, irep_record_size)) == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
-  memset( buf, 0, irep_record_size);
-
   if ((rc = write_irep_record(mrb, irep_no, buf, rlen, DUMP_TYPE_HEX)) != MRB_DUMP_OK) {
     rc = MRB_DUMP_GENERAL_FAILURE;
     goto error_exit;
diff --git a/src/gc.c b/src/gc.c
index 2149a2d43..78d8ee6a9 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -246,12 +246,10 @@ unlink_free_heap_page(mrb_state *mrb, struct heap_page *page)
 static void
 add_heap(mrb_state *mrb)
 {
-  struct heap_page *page = mrb_malloc(mrb, sizeof(struct heap_page));
+  struct heap_page *page = mrb_calloc(mrb, 1, sizeof(struct heap_page));
   RVALUE *p, *e;
   struct RBasic *prev = NULL;
 
-  memset(page, 0, sizeof(struct heap_page));
-
   for (p = page->objects, e=p+HEAP_PAGE_SIZE; p<e; p++) {
     p->as.free.tt = MRB_TT_FREE;
     p->as.free.next = prev;
diff --git a/src/parse.y b/src/parse.y
index af91f09b6..dd1738010 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4792,8 +4792,7 @@ mrbc_context_new(mrb_state *mrb)
 {
   mrbc_context *c;
 
-  c = mrb_malloc(mrb, sizeof(mrbc_context));
-  memset(c, 0, sizeof(mrbc_context));
+  c = mrb_calloc(mrb, 1, sizeof(mrbc_context));
   return c;
 }
 
diff --git a/src/state.c b/src/state.c
index e4729ca70..7f74606ff 100644
--- a/src/state.c
+++ b/src/state.c
@@ -76,8 +76,7 @@ mrb_add_irep(mrb_state *mrb, int idx)
     int max = 256;
 
     if (idx > max) max = idx+1;
-    mrb->irep = mrb_malloc(mrb, sizeof(mrb_irep*)*max);
-    memset(mrb->irep, 0, sizeof(mrb_irep*)*max);
+    mrb->irep = mrb_calloc(mrb, max, sizeof(mrb_irep*));
     mrb->irep_capa = max;
   }
   else if (mrb->irep_capa <= idx) {
diff --git a/src/vm.c b/src/vm.c
index 62fba24d0..9ee6b9883 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -28,16 +28,14 @@ static void
 stack_init(mrb_state *mrb)
 {
   /* assert(mrb->stack == NULL); */
-  mrb->stbase = mrb_malloc(mrb, sizeof(mrb_value) * STACK_INIT_SIZE);
-  memset(mrb->stbase, 0, sizeof(mrb_value) * STACK_INIT_SIZE);
+  mrb->stbase = mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value));
   mrb->stend = mrb->stbase + STACK_INIT_SIZE;
   mrb->stack = mrb->stbase;
 
   /* assert(mrb->ci == NULL); */
-  mrb->cibase = mrb_malloc(mrb, sizeof(mrb_callinfo)*CALLINFO_INIT_SIZE);
+  mrb->cibase = mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo));
   mrb->ciend = mrb->cibase + CALLINFO_INIT_SIZE;
   mrb->ci = mrb->cibase;
-  memset(mrb->ci, 0, sizeof(mrb_callinfo));
   mrb->ci->target_class = mrb->object_class;
 }
 
-- 
cgit v1.2.3


From 737eaea038af56794b8fdb5a66bb4138dbd446f6 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 13 Jul 2012 15:00:45 +0900
Subject: allow DISABLE/ENABLE_SATDIO

---
 include/mrbconf.h |  4 ++++
 src/codegen.c     |  8 ++++++++
 src/object.c      | 10 ++--------
 src/parse.y       |  7 ++++++-
 src/vm.c          |  4 ++++
 5 files changed, 24 insertions(+), 9 deletions(-)

(limited to 'src/vm.c')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 4ed481e0b..5d307e66f 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -19,6 +19,7 @@
 //#define DISABLE_MATH		/* Math functions */
 //#define DISABLE_TIME		/* Time class */
 //#define DISABLE_STRUCT	/* Struct class */
+//#define DISABLE_STDIO		/* use of stdio */
 
 #undef  HAVE_UNISTD_H /* WINDOWS */
 #define HAVE_UNISTD_H /* LINUX */
@@ -50,6 +51,9 @@ typedef intptr_t mrb_sym;
 #ifndef DISABLE_STRUCT
 #define ENABLE_STRUCT
 #endif
+#ifndef DISABLE_STDIO
+#define ENABLE_STDIO
+#endif
 
 #ifndef FALSE
 # define FALSE 0
diff --git a/src/codegen.c b/src/codegen.c
index 3ef52a0d4..6db09f310 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -94,7 +94,9 @@ codegen_error(codegen_scope *s, const char *message)
     s = s->prev;
   }
   mrb_pool_close(s->mpool);
+#ifdef ENABLE_STDIO
   fprintf(stderr, "codegen error: %s\n", message);
+#endif
   longjmp(s->jmp, 1);
 }
 
@@ -270,7 +272,9 @@ dispatch(codegen_scope *s, int pc)
   case OP_ONERR:
     break;
   default:
+#ifdef ENABLE_STDIO
     fprintf(stderr, "bug: dispatch on non JMP op\n");
+#endif
     scope_error(s);
   }
   s->iseq[pc] = MKOP_AsBx(c, GETARG_A(i), diff);
@@ -739,7 +743,9 @@ gen_assignment(codegen_scope *s, node *node, int sp, int val)
     break;
 
   default:
+#ifdef ENABLE_STDIO
     printf("unknown lhs %d\n", type);
+#endif
     break;
   }
   if (val) push();
@@ -2047,6 +2053,7 @@ loop_pop(codegen_scope *s, int val)
 static void
 codedump(mrb_state *mrb, int n)
 {
+#ifdef ENABLE_STDIO
   mrb_irep *irep = mrb->irep[n];
   int i;
   mrb_code c;
@@ -2342,6 +2349,7 @@ codedump(mrb_state *mrb, int n)
     }
   }
   printf("\n");
+#endif
 }
 
 void
diff --git a/src/object.c b/src/object.c
index eb63c1293..29684b118 100644
--- a/src/object.c
+++ b/src/object.c
@@ -403,11 +403,6 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
   struct RString *s;
   int xt;
 
-  /*if (x == Qundef) {
-    //mrb_bug("undef leaked to the Ruby space");
-    printf ("undef leaked to the Ruby space\n");
-  }*/
-
   xt = mrb_type(x);
   if ((xt != t) || (xt == MRB_TT_DATA)) {
     while (type->type < MRB_TT_MAXDEFINE) {
@@ -431,12 +426,11 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
           etype = mrb_obj_classname(mrb, x);
         }
         mrb_raise(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
-          etype, type->name);
+		  etype, type->name);
       }
       type++;
     }
-    /*mrb_bug("unknown type 0x%x", t);*/
-    printf ("unknown type 0x%x (0x%x given)", t, mrb_type(x));
+    mrb_raise(mrb, E_TYPE_ERROR, "unknown type 0x%x (0x%x given)", t, mrb_type(x));
   }
 }
 
diff --git a/src/parse.y b/src/parse.y
index 13643f68e..8d626b5d8 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -2964,12 +2964,14 @@ yyerror(parser_state *p, const char *s)
   int n;
 
   if (! p->capture_errors) {
+#ifdef ENABLE_STDIO
     if (p->filename) {
       fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s);
     }
     else {
       fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
     }
+#endif
   }
   else if (p->nerr < sizeof(p->error_buffer) / sizeof(p->error_buffer[0])) {
     n = strlen(s);
@@ -2998,12 +3000,14 @@ yywarn(parser_state *p, const char *s)
   int n;
 
   if (! p->capture_errors) {
+#ifdef ENABLE_STDIO
     if (p->filename) {
       fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s);
     }
     else {
       fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
     }
+#endif
   }
   else if (p->nerr < sizeof(p->warn_buffer) / sizeof(p->warn_buffer[0])) {
     n = strlen(s);
@@ -4943,6 +4947,7 @@ dump_recur(mrb_state *mrb, node *tree, int offset)
 void
 parser_dump(mrb_state *mrb, node *tree, int offset)
 {
+#ifdef ENABLE_STDIO
   int n;
 
   if (!tree) return;
@@ -5631,7 +5636,7 @@ parser_dump(mrb_state *mrb, node *tree, int offset)
     printf("node type: %d (0x%x)\n", (int)n, (int)n);
     break;
   }
-  return;
+#endif
 }
 
 #ifdef PARSER_TEST
diff --git a/src/vm.c b/src/vm.c
index 9ee6b9883..ef323f785 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1577,7 +1577,11 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
     CASE(OP_DEBUG) {
       /* A      debug print R(A),R(B),R(C) */
+#ifdef ENABLE_STDIO
       printf("OP_DEBUG %d %d %d\n", GETARG_A(i), GETARG_B(i), GETARG_C(i));
+#else
+      abort();
+#endif
       NEXT;
     }
 
-- 
cgit v1.2.3


From cd502421462db2ad588cf8fe8c80a590f3d6f640 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Mon, 16 Jul 2012 17:54:13 +0900
Subject: Reduce strlen(). refs #301

---
 src/dump.c | 9 +++++----
 src/vm.c   | 4 ++--
 2 files changed, 7 insertions(+), 6 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/dump.c b/src/dump.c
index a720090fa..d8768f771 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -222,15 +222,16 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type)
 
   for (pool_no = 0; pool_no < irep->plen; pool_no++) {
     uint16_t nlen =0;
+    int len;
 
     switch (irep->pool[pool_no].tt) {
     case MRB_TT_FIXNUM:
-      sprintf( buf, "%d", irep->pool[pool_no].value.i);
-      size += strlen(buf);
+      len = sprintf( buf, "%d", irep->pool[pool_no].value.i);
+      size += (uint32_t)len;
       break;
     case MRB_TT_FLOAT:
-      sprintf( buf, "%.16e", irep->pool[pool_no].value.f);
-      size += strlen(buf);
+      len = sprintf( buf, "%.16e", irep->pool[pool_no].value.f);
+      size += (uint32_t)len;
       break;
     case MRB_TT_STRING:
       str = mrb_string_value( mrb, &irep->pool[pool_no]);
diff --git a/src/vm.c b/src/vm.c
index ef323f785..bd3d05d81 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -892,8 +892,8 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         struct REnv *e = uvenv(mrb, lv-1);
 	if (!e) {
 	  mrb_value exc;
-	  const char *m = "super called outside of method";
-	  exc = mrb_exc_new(mrb, E_NOMETHOD_ERROR, m, strlen(m));
+	  static const char m[] = "super called outside of method";
+	  exc = mrb_exc_new(mrb, E_NOMETHOD_ERROR, m, sizeof(m) - 1);
 	  mrb->exc = (struct RObject*)mrb_object(exc);
 	  goto L_RAISE;
 	}
-- 
cgit v1.2.3


From 88b638cf823741e3db204856e43f422229a1005c Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 24 Jul 2012 23:16:41 +0900
Subject: instance_eval should set target_class in the block

---
 include/mruby.h |  1 -
 src/kernel.c    |  6 +++++-
 src/vm.c        | 17 +++++++++++++----
 3 files changed, 18 insertions(+), 6 deletions(-)

(limited to 'src/vm.c')

diff --git a/include/mruby.h b/include/mruby.h
index 7abf66cb9..4fd7bccd5 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -464,7 +464,6 @@ NUM2CHR(mrb_value x)
 
 mrb_value mrb_yield(mrb_state *mrb, mrb_value v, mrb_value blk);
 mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv);
-mrb_value mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self);
 mrb_value mrb_class_new_instance(mrb_state *mrb, int, mrb_value*, struct RClass *);
 mrb_value mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass);
 
diff --git a/src/kernel.c b/src/kernel.c
index e75fcfc88..468891b23 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -555,6 +555,8 @@ mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
   return self;
 }
 
+mrb_value mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c);
+
 /* 15.3.1.3.18 */
 /*
  *  call-seq:
@@ -580,11 +582,13 @@ mrb_value
 mrb_obj_instance_eval(mrb_state *mrb, mrb_value self)
 {
   mrb_value a, b;
+  mrb_value cv;
 
   if (mrb_get_args(mrb, "|S&", &a, &b) == 1) {
     mrb_raise(mrb, E_NOTIMP_ERROR, "instance_eval with string not implemented");
   }
-  return mrb_yield_with_self(mrb, b, 0, 0, self);
+  cv = mrb_singleton_class(mrb, self);
+  return mrb_yield_internal(mrb, b, 0, 0, self, mrb_class_ptr(cv));
 }
 
 int
diff --git a/src/vm.c b/src/vm.c
index bd3d05d81..62ef5069d 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -237,7 +237,7 @@ mrb_funcall_argv(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb
 }
 
 mrb_value
-mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self)
+mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c)
 {
   struct RProc *p;
   mrb_sym mid = mrb->ci->mid;
@@ -251,7 +251,7 @@ mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_
   ci->proc = p;
   ci->stackidx = mrb->stack - mrb->stbase;
   ci->argc = argc;
-  ci->target_class = p->target_class;
+  ci->target_class = c;
   ci->nregs = argc + 2;
   ci->acc = -1;
   mrb->stack = mrb->stack + n;
@@ -277,13 +277,17 @@ mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_
 mrb_value
 mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv)
 {
-  return mrb_yield_with_self(mrb, b, argc, argv, mrb->stack[0]);
+  struct RProc *p = mrb_proc_ptr(b);
+
+  return mrb_yield_internal(mrb, b, argc, argv, mrb->stack[0], p->target_class);
 }
 
 mrb_value
 mrb_yield(mrb_state *mrb, mrb_value b, mrb_value v)
 {
-  return mrb_yield_with_self(mrb, b, 1, &v, mrb->stack[0]);
+  struct RProc *p = mrb_proc_ptr(b);
+
+  return mrb_yield_internal(mrb, b, 1, &v, mrb->stack[0], p->target_class);
 }
 
 static void
@@ -1564,6 +1568,11 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
     CASE(OP_TCLASS) {
       /* A B    R(A) := target_class */
+      if (!mrb->ci->target_class) {
+	mrb_value exc = mrb_exc_new(mrb, E_TYPE_ERROR, "no target class or module", 25);
+	mrb->exc = (struct RObject*)mrb_object(exc);
+	goto L_RAISE;
+      }
       regs[GETARG_A(i)] = mrb_obj_value(mrb->ci->target_class);
       NEXT;
     }
-- 
cgit v1.2.3


From 638a66fd7801624a47858d4e8e3927ca69a52f00 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 27 Jul 2012 10:05:47 +0900
Subject: adjust ci->nregs for C implemented methods

---
 src/gc.c | 2 ++
 src/vm.c | 4 ++--
 2 files changed, 4 insertions(+), 2 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/gc.c b/src/gc.c
index c0d4e1599..1468dd994 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -545,6 +545,8 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
   obj->tt = MRB_TT_FREE;
 }
 
+#include <stdio.h>
+
 static void
 root_scan_phase(mrb_state *mrb)
 {
diff --git a/src/vm.c b/src/vm.c
index 62ef5069d..9aa21eed4 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -121,7 +121,6 @@ uvset(mrb_state *mrb, int up, int idx, mrb_value v)
 static mrb_callinfo*
 cipush(mrb_state *mrb)
 {
-  size_t nregs = mrb->ci->nregs;
   int eidx = mrb->ci->eidx;
   int ridx = mrb->ci->ridx;
 
@@ -133,7 +132,7 @@ cipush(mrb_state *mrb)
     mrb->ciend = mrb->cibase + size * 2;
   }
   mrb->ci++;
-  mrb->ci->nregs = nregs;
+  mrb->ci->nregs = 0;
   mrb->ci->eidx = eidx;
   mrb->ci->ridx = ridx;
   mrb->ci->env = 0;
@@ -719,6 +718,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       mrb->stack += a;
 
       if (MRB_PROC_CFUNC_P(m)) {
+	ci->nregs = n + 1;
         mrb->stack[0] = m->body.func(mrb, recv);
         mrb->arena_idx = ai;
         if (mrb->exc) goto L_RAISE;
-- 
cgit v1.2.3


From a985cf7945d6aec6d483f76b9427382bb5d984e1 Mon Sep 17 00:00:00 2001
From: Masamitsu MURASE <masamitsu.murase@gmail.com>
Date: Sat, 28 Jul 2012 19:16:54 +0900
Subject: Modify ci->nregs.

---
 src/vm.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 9aa21eed4..e8dcf1b80 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -718,7 +718,12 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       mrb->stack += a;
 
       if (MRB_PROC_CFUNC_P(m)) {
-	ci->nregs = n + 1;
+        if (n == CALL_MAXARGS) {
+          ci->nregs = 3;
+        }
+        else {
+          ci->nregs = n + 2;
+        }
         mrb->stack[0] = m->body.func(mrb, recv);
         mrb->arena_idx = ai;
         if (mrb->exc) goto L_RAISE;
-- 
cgit v1.2.3


From 5a4beeed2d0c229a3a558650f03c8390da2d556c Mon Sep 17 00:00:00 2001
From: Max Anselm <silverhammermba+github@gmail.com>
Date: Sun, 29 Jul 2012 19:45:27 -0400
Subject: Make all(?) void casts explicit for C++

---
 src/array.c   | 12 +++++------
 src/cdump.c   |  4 ++--
 src/codegen.c | 26 ++++++++++++------------
 src/dump.c    | 14 ++++++-------
 src/gc.c      |  2 +-
 src/kernel.c  |  2 +-
 src/load.c    | 22 ++++++++++----------
 src/math.c    |  1 +
 src/pool.c    |  4 ++--
 src/proc.c    |  4 ++--
 src/range.c   |  2 +-
 src/st.c      | 12 +++++------
 src/state.c   |  6 +++---
 src/string.c  | 30 ++++++++++++++--------------
 src/struct.c  |  4 ++--
 src/symbol.c  |  2 +-
 src/time.c    | 64 +++++++++++++++++++++++++++++------------------------------
 src/vm.c      | 16 +++++++--------
 18 files changed, 114 insertions(+), 113 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/array.c b/src/array.c
index ccd22674e..c385fe99b 100644
--- a/src/array.c
+++ b/src/array.c
@@ -46,7 +46,7 @@ ary_new_capa(mrb_state *mrb, int capa)
   }
 
   a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);
-  a->ptr = mrb_calloc(mrb, blen, 1);
+  a->ptr = (mrb_value *)mrb_calloc(mrb, blen, 1);
   a->aux.capa = capa;
   a->len = 0;
 
@@ -116,7 +116,7 @@ ary_modify(mrb_state *mrb, struct RArray *a)
 
       p = a->ptr;
       len = a->len * sizeof(mrb_value);
-      ptr = mrb_malloc(mrb, len);
+      ptr = (mrb_value *)mrb_malloc(mrb, len);
       if (p) {
 	memcpy(ptr, p, len);
       }
@@ -132,11 +132,11 @@ static void
 ary_make_shared(mrb_state *mrb, struct RArray *a)
 {
   if (!(a->flags & MRB_ARY_SHARED)) {
-    struct mrb_shared_array *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_array));
+    struct mrb_shared_array *shared = (struct mrb_shared_array *)mrb_malloc(mrb, sizeof(struct mrb_shared_array));
 
     shared->refcnt = 1;
     if (a->aux.capa > a->len) {
-      a->ptr = shared->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1);
+      a->ptr = shared->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1);
     }
     else {
       shared->ptr = a->ptr;
@@ -173,7 +173,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, int len)
 
   if (capa > a->aux.capa) {
     a->aux.capa = capa;
-    a->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa);
+    a->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa);
   }
 }
 
@@ -195,7 +195,7 @@ ary_shrink_capa(mrb_state *mrb, struct RArray *a)
 
   if (capa > a->len && capa < a->aux.capa) {
     a->aux.capa = capa;
-    a->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa);
+    a->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa);
   }
 }
 
diff --git a/src/cdump.c b/src/cdump.c
index a4a2ac5e1..32982e6fe 100644
--- a/src/cdump.c
+++ b/src/cdump.c
@@ -107,7 +107,7 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
     return -1;
 
   buf_len = MRB_CDUMP_LINE_LEN;
-  if ((buf = mrb_malloc(mrb, buf_len)) == 0 ) {
+  if ((buf = (char *)mrb_malloc(mrb, buf_len)) == 0 ) {
     return MRB_CDUMP_GENERAL_FAILURE;
   }
 
@@ -144,7 +144,7 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
         str_len = str_format_len(irep->pool[n]) + 1;
         if ( str_len > buf_len ) {
           buf_len = str_len;
-          if ((buf = mrb_realloc(mrb, buf, buf_len)) == 0 ) {
+          if ((buf = (char *)mrb_realloc(mrb, buf, buf_len)) == 0 ) {
             return MRB_CDUMP_GENERAL_FAILURE;
           }
         }
diff --git a/src/codegen.c b/src/codegen.c
index 3bf0e496c..2e8104fdd 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -136,7 +136,7 @@ genop(codegen_scope *s, mrb_code i)
 {
   if (s->pc == s->icapa) {
     s->icapa *= 2;
-    s->iseq = codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa);
+    s->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa);
   }
   s->iseq[s->pc] = i;
   s->pc++;
@@ -323,7 +323,7 @@ new_lit(codegen_scope *s, mrb_value val)
   }
   if (s->plen == s->pcapa) {
     s->pcapa *= 2;
-    s->pool = codegen_realloc(s, s->pool, sizeof(mrb_value)*s->pcapa);
+    s->pool = (mrb_value *)codegen_realloc(s, s->pool, sizeof(mrb_value)*s->pcapa);
   }
   s->pool[s->plen] = val;
   return s->plen++;
@@ -357,7 +357,7 @@ new_sym(codegen_scope *s, mrb_sym sym)
     if (s->syms[i] == sym) return i;
   }
   if (s->slen > 125 && s->slen < 256) {
-    s->syms = codegen_realloc(s, s->syms, sizeof(mrb_sym)*65536);
+    s->syms = (mrb_sym *)codegen_realloc(s, s->syms, sizeof(mrb_sym)*65536);
     memset(s->syms+s->slen, 0, sizeof(mrb_sym)*(256-s->slen));
     s->slen = 256;
   }
@@ -556,7 +556,7 @@ attrsym(codegen_scope *s, mrb_sym a)
   char *name2;
 
   name = mrb_sym2name_len(s->mrb, a, &len);
-  name2 = codegen_palloc(s, len+1);
+  name2 = (char *)codegen_palloc(s, len+1);
   memcpy(name2, name, len);
   name2[len] = '=';
   name2[len+1] = '\0';
@@ -1927,7 +1927,7 @@ static codegen_scope*
 scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
 {
   mrb_pool *pool = mrb_pool_open(mrb);
-  codegen_scope *p = mrb_pool_alloc(pool, sizeof(codegen_scope));
+  codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
   if (!p) return 0;
 
   memset(p, 0, sizeof(codegen_scope));
@@ -1940,12 +1940,12 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
 
   p->mrb = prev->mrb;
   p->icapa = 1024;
-  p->iseq = mrb_malloc(mrb, sizeof(mrb_code)*p->icapa);
+  p->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code)*p->icapa);
 
   p->pcapa = 32;
-  p->pool = mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa);
+  p->pool = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa);
 
-  p->syms = mrb_malloc(mrb, sizeof(mrb_sym)*256);
+  p->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym)*256);
 
   p->lv = lv;
   p->sp += node_len(lv)+2;
@@ -1964,20 +1964,20 @@ scope_finish(codegen_scope *s, int idx)
   mrb_irep *irep;
 
   mrb_add_irep(mrb, idx);
-  irep = mrb->irep[idx] = mrb_malloc(mrb, sizeof(mrb_irep));
+  irep = mrb->irep[idx] = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep));
 
   irep->idx = idx;
   irep->flags = 0;
   if (s->iseq) {
-    irep->iseq = codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc);
+    irep->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc);
     irep->ilen = s->pc;
   }
   if (s->pool) {
-    irep->pool = codegen_realloc(s, s->pool, sizeof(mrb_value)*s->plen);
+    irep->pool = (mrb_value *)codegen_realloc(s, s->pool, sizeof(mrb_value)*s->plen);
     irep->plen = s->plen;
   }
   if (s->syms) {
-    irep->syms = codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->slen);
+    irep->syms = (mrb_sym *)codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->slen);
     irep->slen = s->slen;
   }
 
@@ -1991,7 +1991,7 @@ scope_finish(codegen_scope *s, int idx)
 static struct loopinfo*
 loop_push(codegen_scope *s, enum looptype t)
 {
-  struct loopinfo *p = codegen_palloc(s, sizeof(struct loopinfo));
+  struct loopinfo *p = (struct loopinfo *)codegen_palloc(s, sizeof(struct loopinfo));
 
   p->type = t;
   p->pc1 = p->pc2 = p->pc3 = 0;
diff --git a/src/dump.c b/src/dump.c
index d8768f771..230ba9bba 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -335,7 +335,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
   int len;
 
   buf_size = MRB_DUMP_DEFAULT_STR_LEN;
-  if ((char_buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0)
     goto error_exit;
 
   buf += uint32_dump((uint32_t)irep->plen, buf, type); /* number of pool */
@@ -360,7 +360,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
       nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
       if ( nlen > buf_size - 1) {
         buf_size = nlen + 1;
-        if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
+        if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0)
           goto error_exit;
         memset(char_buf, 0, buf_size);
       }
@@ -409,7 +409,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
   uint16_t buf_size =0;
 
   buf_size = MRB_DUMP_DEFAULT_STR_LEN;
-  if ((char_buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0)
     goto error_exit;
 
   buf += uint32_dump((uint32_t)irep->slen, buf, type); /* number of symbol */
@@ -425,7 +425,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
       nlen = str_dump_len((char*)name, len, type);
       if ( nlen > buf_size - 1) {
         buf_size = nlen + 1;
-        if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
+        if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0)
           goto error_exit;
       }
       memset(char_buf, 0, buf_size);
@@ -461,7 +461,7 @@ calc_crc_section(mrb_state *mrb, mrb_irep *irep, uint16_t *crc, int section)
   default: return MRB_DUMP_GENERAL_FAILURE;
   }
 
-  if ((buf = mrb_calloc(mrb, 1, buf_size)) == 0)
+  if ((buf = (char *)mrb_calloc(mrb, 1, buf_size)) == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
   buf_top = buf;
@@ -598,7 +598,7 @@ dump_irep_record(mrb_state *mrb, int irep_no, FILE* fp, uint32_t *rlen)
   if (irep_record_size == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
-  if ((buf = mrb_calloc(mrb, 1, irep_record_size)) == 0)
+  if ((buf = (char *)mrb_calloc(mrb, 1, irep_record_size)) == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
   if ((rc = write_irep_record(mrb, irep_no, buf, rlen, DUMP_TYPE_HEX)) != MRB_DUMP_OK) {
@@ -690,7 +690,7 @@ mrb_bdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname)
     buf_size += get_irep_record_size(mrb, irep_no, DUMP_TYPE_BIN);
   buf_size += MRB_DUMP_SIZE_OF_LONG; /* end of file */
 
-  if ((buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((buf = (char *)mrb_malloc(mrb, buf_size)) == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
   rc = mrb_write_irep(mrb, n, buf);
diff --git a/src/gc.c b/src/gc.c
index c0d4e1599..59a6b7eb4 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -248,7 +248,7 @@ unlink_free_heap_page(mrb_state *mrb, struct heap_page *page)
 static void
 add_heap(mrb_state *mrb)
 {
-  struct heap_page *page = mrb_calloc(mrb, 1, sizeof(struct heap_page));
+  struct heap_page *page = (struct heap_page *)mrb_calloc(mrb, 1, sizeof(struct heap_page));
   RVALUE *p, *e;
   struct RBasic *prev = NULL;
 
diff --git a/src/kernel.c b/src/kernel.c
index 8aba1a808..36dfbe769 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -853,7 +853,7 @@ mrb_obj_methods_m(mrb_state *mrb, mrb_value self)
   int argc;
 
   mrb_get_args(mrb, "*", &argv, &argc);
-  return mrb_obj_methods(mrb, argc, argv, self, 0); /* everything but private */
+  return mrb_obj_methods(mrb, argc, argv, self, (mrb_method_flag_t)0); /* everything but private */
 }
 
 /* 15.3.1.3.32 */
diff --git a/src/load.c b/src/load.c
index c1c0a7eed..cee985f43 100644
--- a/src/load.c
+++ b/src/load.c
@@ -143,7 +143,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_
   uint16_t buf_size =0;
 
   buf_size = MRB_DUMP_DEFAULT_STR_LEN;
-  if ((char_buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0)
     goto error_exit;
 
   pStart = dst;
@@ -192,7 +192,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_
 
     if ( pdl > buf_size - 1) {
       buf_size = pdl + 1;
-      if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
+      if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0)
         goto error_exit;
     }
     memset(char_buf, '\0', buf_size);
@@ -219,7 +219,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_
 
     if ( snl > buf_size - 1) {
       buf_size = snl + 1;
-      if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
+      if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0)
         goto error_exit;
     }
     memset(char_buf, '\0', buf_size);
@@ -262,7 +262,7 @@ mrb_load_irep(mrb_state *mrb, FILE* fp)
     return ret;
 
   len = sizeof(rite_binary_header) + bin_to_uint32(bin_header.rbds);
-  if ((rite_dst = mrb_malloc(mrb, len)) == NULL)
+  if ((rite_dst = (unsigned char *)mrb_malloc(mrb, len)) == NULL)
     return MRB_DUMP_GENERAL_FAILURE;
 
   dst = rite_dst;
@@ -331,7 +331,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
   int ai = mrb_gc_arena_save(mrb);
 
   recordStart = src;
-  buf = mrb_malloc(mrb, bufsize);
+  buf = (char *)mrb_malloc(mrb, bufsize);
   if (buf == NULL) {
     ret = MRB_DUMP_INVALID_IREP;
     goto error_exit;
@@ -359,7 +359,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
   irep->ilen = bin_to_uint32(src);          //iseq length
   src += MRB_DUMP_SIZE_OF_LONG;
   if (irep->ilen > 0) {
-    if ((irep->iseq = mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen)) == NULL) {
+    if ((irep->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen)) == NULL) {
       ret = MRB_DUMP_GENERAL_FAILURE;
       goto error_exit;
     }
@@ -380,7 +380,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
   irep->plen = bin_to_uint32(src);          //pool length
   src += MRB_DUMP_SIZE_OF_LONG;
   if (irep->plen > 0) {
-    irep->pool = mrb_malloc(mrb, sizeof(mrb_value) * irep->plen);
+    irep->pool = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value) * irep->plen);
     if (irep->pool == NULL) {
       ret = MRB_DUMP_INVALID_IREP;
       goto error_exit;
@@ -394,7 +394,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
       if (pdl > bufsize - 1) {
         mrb_free(mrb, buf);
         bufsize = pdl + 1;
-        if ((buf = mrb_malloc(mrb, bufsize)) == NULL) {
+        if ((buf = (char *)mrb_malloc(mrb, bufsize)) == NULL) {
           ret = MRB_DUMP_GENERAL_FAILURE;
           goto error_exit;
         }
@@ -443,7 +443,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
   irep->slen = bin_to_uint32(src);          //syms length
   src += MRB_DUMP_SIZE_OF_LONG;
   if (irep->slen > 0) {
-    if ((irep->syms = mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen)) == NULL) {
+    if ((irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen)) == NULL) {
       ret = MRB_DUMP_INVALID_IREP;
       goto error_exit;
     }
@@ -461,7 +461,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
       if (snl > bufsize - 1) {
         mrb_free(mrb, buf);
         bufsize = snl + 1;
-        if ((buf = mrb_malloc(mrb, bufsize)) == NULL) {
+        if ((buf = (char *)mrb_malloc(mrb, bufsize)) == NULL) {
           ret = MRB_DUMP_GENERAL_FAILURE;
           goto error_exit;
         }
@@ -509,7 +509,7 @@ mrb_read_irep(mrb_state *mrb, const char *bin)
   mrb_add_irep(mrb, sirep + nirep);
 
   for (n=0,i=sirep; n<nirep; n++,i++) {
-    if ((mrb->irep[i] = mrb_malloc(mrb, sizeof(mrb_irep))) == NULL) {
+    if ((mrb->irep[i] = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep))) == NULL) {
       ret = MRB_DUMP_GENERAL_FAILURE;
       goto error_exit;
     }
diff --git a/src/math.c b/src/math.c
index cf9a20489..ecf9fbf43 100644
--- a/src/math.c
+++ b/src/math.c
@@ -5,6 +5,7 @@
 */
 
 #include "mruby.h"
+#include "mruby/array.h"
 
 #ifdef ENABLE_MATH
 #include <math.h>
diff --git a/src/pool.c b/src/pool.c
index 0f1baa776..36c6fa8eb 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -49,7 +49,7 @@ struct mrb_pool {
 mrb_pool*
 mrb_pool_open(mrb_state *mrb)
 {
-  mrb_pool *pool = mrb_malloc(mrb, sizeof(mrb_pool));
+  mrb_pool *pool = (mrb_pool *)mrb_malloc(mrb, sizeof(mrb_pool));
 
   if (pool) {
     pool->mrb = mrb;
@@ -81,7 +81,7 @@ page_alloc(mrb_pool *pool, size_t len)
 
   if (len < POOL_PAGE_SIZE)
     len = POOL_PAGE_SIZE;
-  page = mrb_malloc(pool->mrb, sizeof(struct mrb_pool_page)+len-1);
+  page = (struct mrb_pool_page *)mrb_malloc(pool->mrb, sizeof(struct mrb_pool_page)+len-1);
   if (page) {
     page->offset = 0;
     page->len = len;
diff --git a/src/proc.c b/src/proc.c
index e27d5d578..d223fa760 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -144,8 +144,8 @@ void
 mrb_init_proc(mrb_state *mrb)
 {
   struct RProc *m;
-  mrb_code *call_iseq = mrb_malloc(mrb, sizeof(mrb_code));
-  mrb_irep *call_irep = mrb_calloc(mrb, sizeof(mrb_irep), 1);
+  mrb_code *call_iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code));
+  mrb_irep *call_irep = (mrb_irep *)mrb_calloc(mrb, sizeof(mrb_irep), 1);
 
   if ( call_iseq == NULL || call_irep == NULL )
     return;
diff --git a/src/range.c b/src/range.c
index 9113a810a..db17c7d40 100644
--- a/src/range.c
+++ b/src/range.c
@@ -43,7 +43,7 @@ mrb_range_new(mrb_state *mrb, mrb_value beg, mrb_value end, int excl)
   struct RRange *r;
 
   r = (struct RRange*)mrb_obj_alloc(mrb, MRB_TT_RANGE, RANGE_CLASS);
-  r->edges = mrb_malloc(mrb, sizeof(struct mrb_range_edges));
+  r->edges = (struct mrb_range_edges *)mrb_malloc(mrb, sizeof(struct mrb_range_edges));
   range_check(mrb, beg, end);
   r->edges->beg = beg;
   r->edges->end = end;
diff --git a/src/st.c b/src/st.c
index 257da7e2b..c3c20c80a 100644
--- a/src/st.c
+++ b/src/st.c
@@ -24,21 +24,21 @@
 static int numcmp(long, long);
 static st_index_t numhash(long);
 static struct st_hash_type type_numhash = {
-    numcmp,
-    numhash,
+    (int (*)(ANYARGS))numcmp,
+    (st_index_t (*)(ANYARGS))numhash,
 };
 
 /* extern int strcmp(const char *, const char *); */
 static st_index_t strhash(const char*);
 static struct st_hash_type type_strhash = {
-    strcmp,
-    strhash,
+    (int (*)(ANYARGS))strcmp,
+    (st_index_t (*)(ANYARGS))strhash,
 };
 
 static st_index_t strcasehash(st_data_t);
 static const struct st_hash_type type_strcasehash = {
-    st_strcasecmp,
-    strcasehash,
+    (int (*)(ANYARGS))st_strcasecmp,
+    (st_index_t (*)(ANYARGS))strcasehash,
 };
 
 static void rehash(st_table*);
diff --git a/src/state.c b/src/state.c
index 0d236e660..26e7dff4a 100644
--- a/src/state.c
+++ b/src/state.c
@@ -15,7 +15,7 @@ void mrb_init_ext(mrb_state*);
 mrb_state*
 mrb_open_allocf(mrb_allocf f)
 {
-  mrb_state *mrb = (f)(NULL, NULL, sizeof(mrb_state));
+  mrb_state *mrb = (mrb_state *)(f)(NULL, NULL, sizeof(mrb_state));
   if (mrb == NULL) return NULL;
 
   memset(mrb, 0, sizeof(mrb_state));
@@ -76,14 +76,14 @@ mrb_add_irep(mrb_state *mrb, int idx)
     int max = 256;
 
     if (idx > max) max = idx+1;
-    mrb->irep = mrb_calloc(mrb, max, sizeof(mrb_irep*));
+    mrb->irep = (mrb_irep **)mrb_calloc(mrb, max, sizeof(mrb_irep*));
     mrb->irep_capa = max;
   }
   else if (mrb->irep_capa <= idx) {
     while (mrb->irep_capa <= idx) {
       mrb->irep_capa *= 2;
     }
-    mrb->irep = mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa);
+    mrb->irep = (mrb_irep **)mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa);
   }
 }
 
diff --git a/src/string.c b/src/string.c
index 0a5dee88e..11990c22d 100644
--- a/src/string.c
+++ b/src/string.c
@@ -29,7 +29,7 @@ static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString
 static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len);
 
 #define RESIZE_CAPA(s,capacity) do {\
-      s->ptr = mrb_realloc(mrb, s->ptr, (capacity)+1);\
+      s->ptr = (char *)mrb_realloc(mrb, s->ptr, (capacity)+1);\
       s->aux.capa = capacity;\
 } while (0)
 
@@ -60,7 +60,7 @@ str_modify(mrb_state *mrb, struct RString *s)
 
       p = s->ptr;
       len = s->len;
-      ptr = mrb_malloc(mrb, len+1);
+      ptr = (char *)mrb_malloc(mrb, len+1);
       if (p) {
 	memcpy(ptr, p, len);
       }
@@ -83,7 +83,7 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, int len)
   slen = s->len;
   if (len != slen) {
     if (slen < len || slen -len > 1024) {
-      s->ptr = mrb_realloc(mrb, s->ptr, len+1);
+      s->ptr = (char *)mrb_realloc(mrb, s->ptr, len+1);
     }
     s->aux.capa = len;
     s->len = len;
@@ -133,7 +133,7 @@ str_new(mrb_state *mrb, const char *p, int len)
 
   s->len = len;
   s->aux.capa = len;
-  s->ptr = mrb_malloc(mrb, len+1);
+  s->ptr = (char *)mrb_malloc(mrb, len+1);
   if (p) {
     memcpy(s->ptr, p, len);
   }
@@ -168,7 +168,7 @@ mrb_str_buf_new(mrb_state *mrb, int capa)
   }
   s->len = 0;
   s->aux.capa = capa;
-  s->ptr = mrb_malloc(mrb, capa+1);
+  s->ptr = (char *)mrb_malloc(mrb, capa+1);
   s->ptr[0] = '\0';
 
   return mrb_obj_value(s);
@@ -249,7 +249,7 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p)
   int len = strlen(p);
 
   s = mrb_obj_alloc_string(mrb);
-  s->ptr = mrb_malloc(mrb, len+1);
+  s->ptr = (char *)mrb_malloc(mrb, len+1);
   memcpy(s->ptr, p, len);
   s->ptr[len] = 0;
   s->len = len;
@@ -262,11 +262,11 @@ static void
 str_make_shared(mrb_state *mrb, struct RString *s)
 {
   if (!(s->flags & MRB_STR_SHARED)) {
-    struct mrb_shared_string *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_string));
+    struct mrb_shared_string *shared = (struct mrb_shared_string *)mrb_malloc(mrb, sizeof(struct mrb_shared_string));
 
     shared->refcnt = 1;
     if (s->aux.capa > s->len) {
-      s->ptr = shared->ptr = mrb_realloc(mrb, s->ptr, s->len+1);
+      s->ptr = shared->ptr = (char *)mrb_realloc(mrb, s->ptr, s->len+1);
     }
     else {
       shared->ptr = s->ptr;
@@ -341,7 +341,7 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
 
   if (s1->aux.capa < len) {
     s1->aux.capa = len;
-    s1->ptr = mrb_realloc(mrb, s1->ptr, len+1);
+    s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, len+1);
   }
   memcpy(s1->ptr+s1->len, s2->ptr, s2->len);
   s1->len = len;
@@ -664,7 +664,7 @@ mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long
 static int
 mrb_memsearch(const void *x0, int m, const void *y0, int n)
 {
-  const unsigned char *x = x0, *y = y0;
+  const unsigned char *x = (const unsigned char *)x0, *y = (const unsigned char *)y0;
 
   if (m > n) return -1;
   else if (m == n) {
@@ -681,7 +681,7 @@ mrb_memsearch(const void *x0, int m, const void *y0, int n)
     }
     return -1;
   }
-  return mrb_memsearch_qs(x0, m, y0, n);
+  return mrb_memsearch_qs((const unsigned char *)x0, m, (const unsigned char *)y0, n);
 }
 
 static mrb_int
@@ -1564,10 +1564,10 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2)
     if (s1->flags & MRB_STR_SHARED) {
       mrb_str_decref(mrb, s1->aux.shared);
       s1->flags &= ~MRB_STR_SHARED;
-      s1->ptr = mrb_malloc(mrb, s2->len+1);
+      s1->ptr = (char *)mrb_malloc(mrb, s2->len+1);
     }
     else {
-      s1->ptr = mrb_realloc(mrb, s1->ptr, s2->len+1);
+      s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, s2->len+1);
     }
     memcpy(s1->ptr, s2->ptr, s2->len);
     s1->ptr[s2->len] = 0;
@@ -2541,7 +2541,7 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck)
   if (s) {
     len = RSTRING_LEN(str);
     if (s[len]) {    /* no sentinel somehow */
-      char *p = mrb_malloc(mrb, len+1);
+      char *p = (char *)mrb_malloc(mrb, len+1);
 
       //MEMCPY(p, s, char, len);
       memcpy(p, s, sizeof(char)*len);
@@ -2675,7 +2675,7 @@ mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck)
       mrb_raise(mrb, E_ARGUMENT_ERROR, "string for Float contains null byte");
     }
     if (s[len]) {    /* no sentinel somehow */
-      char *p = mrb_malloc(mrb, len+1);
+      char *p = (char *)mrb_malloc(mrb, len+1);
 
       memcpy(p, s, sizeof(char)*len);
       p[len] = '\0';
diff --git a/src/struct.c b/src/struct.c
index 0a95f9e49..a133dc046 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -184,7 +184,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id)
   mrb_sym mid;
 
   name = mrb_sym2name_len(mrb, id, &len);
-  buf = mrb_malloc(mrb, len+2);
+  buf = (char *)mrb_malloc(mrb, len+2);
   memcpy(buf, name, len);
   buf[len] = '=';
   buf[len+1] = '\0';
@@ -427,7 +427,7 @@ mrb_struct_initialize_withArg(mrb_state *mrb, int argc, mrb_value *argv, mrb_val
     mrb_raise(mrb, E_ARGUMENT_ERROR, "struct size differs");
   }
   st = RSTRUCT(self);
-  st->ptr = mrb_calloc(mrb, sizeof(mrb_value), n);
+  st->ptr = (mrb_value *)mrb_calloc(mrb, sizeof(mrb_value), n);
   st->len = n;
   memcpy(st->ptr, argv, sizeof(mrb_value)*argc);
 
diff --git a/src/symbol.c b/src/symbol.c
index 6e92fb6c7..b81296929 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -50,7 +50,7 @@ mrb_intern2(mrb_state *mrb, const char *name, int len)
     return kh_value(h, k);
 
   sym = ++mrb->symidx;
-  p = mrb_malloc(mrb, len+1);
+  p = (char *)mrb_malloc(mrb, len+1);
   memcpy(p, name, len);
   p[len] = 0;
   sname.name = (const char*)p;
diff --git a/src/time.c b/src/time.c
index c988d0fd0..e71fc17fe 100644
--- a/src/time.c
+++ b/src/time.c
@@ -164,7 +164,7 @@ mrb_time_alloc(mrb_state *mrb, mrb_float sec, mrb_float usec, enum mrb_timezone
 {
   struct mrb_time *tm;
 
-  tm = mrb_malloc(mrb, sizeof(struct mrb_time));
+  tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(struct mrb_time));
   tm->sec  = (time_t)sec;
   tm->usec = (sec - tm->sec) * 1.0e6 + usec;
   while (tm->usec < 0) {
@@ -192,7 +192,7 @@ current_mrb_time(mrb_state *mrb)
 {
   struct mrb_time *tm;  
 
-  tm = mrb_malloc(mrb, sizeof(*tm));
+  tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
 #ifdef NO_GETTIMEOFDAY
   {
     static time_t last_sec = 0, last_usec = 0;
@@ -304,8 +304,8 @@ mrb_time_eq(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm1, *tm2;
 
   mrb_get_args(mrb, "o", &other);
-  tm1 = mrb_get_datatype(mrb, self, &mrb_time_type);
-  tm2 = mrb_get_datatype(mrb, other, &mrb_time_type);
+  tm1 = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm2 = (struct mrb_time *)mrb_get_datatype(mrb, other, &mrb_time_type);
   if (!tm1 || !tm2) return mrb_false_value();
   if (tm1->sec == tm2->sec && tm1->usec == tm2->usec) {
     return mrb_true_value();
@@ -320,8 +320,8 @@ mrb_time_cmp(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm1, *tm2;
 
   mrb_get_args(mrb, "o", &other);
-  tm1 = mrb_get_datatype(mrb, self, &mrb_time_type);
-  tm2 = mrb_get_datatype(mrb, other, &mrb_time_type);
+  tm1 = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm2 = (struct mrb_time *)mrb_get_datatype(mrb, other, &mrb_time_type);
   if (!tm1 || !tm2) return mrb_nil_value();
   if (tm1->sec > tm2->sec) {
     return mrb_fixnum_value(1);
@@ -346,7 +346,7 @@ mrb_time_plus(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm;
 
   mrb_get_args(mrb, "f", &f);
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_time_make(mrb, mrb_obj_class(mrb, self), tm->sec+f, tm->usec, tm->timezone);
 }
@@ -359,10 +359,10 @@ mrb_time_minus(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm, *tm2;
 
   mrb_get_args(mrb, "o", &other);
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
 
-  tm2 = mrb_get_datatype(mrb, other, &mrb_time_type);
+  tm2 = (struct mrb_time *)mrb_get_datatype(mrb, other, &mrb_time_type);
   if (tm2) {
     f = (mrb_float)(tm->sec - tm2->sec)
       + (mrb_float)(tm->usec - tm2->usec) / 1.0e6;
@@ -381,7 +381,7 @@ mrb_time_wday(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_wday);
 }
@@ -393,7 +393,7 @@ mrb_time_yday(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_check_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_check_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_yday);
 }
@@ -405,7 +405,7 @@ mrb_time_year(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_year + 1900);
 }
@@ -417,7 +417,7 @@ mrb_time_zone(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   if (tm->timezone <= MRB_TIMEZONE_NONE) return mrb_nil_value();
   if (tm->timezone >= MRB_TIMEZONE_LAST) return mrb_nil_value();
@@ -434,7 +434,7 @@ mrb_time_asctime(mrb_state *mrb, mrb_value self)
   char buf[256];
   int len;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   d = &tm->datetime;
   len = snprintf(buf, sizeof(buf), "%s %s %02d %02d:%02d:%02d %s%d",
@@ -452,7 +452,7 @@ mrb_time_day(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_mday);
 }
@@ -465,7 +465,7 @@ mrb_time_dstp(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_bool_value(tm->datetime.tm_isdst);
 }
@@ -478,9 +478,9 @@ mrb_time_getutc(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm, *tm2;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return self;
-  tm2 = mrb_malloc(mrb, sizeof(*tm));
+  tm2 = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
   *tm2 = *tm;
   tm2->timezone = MRB_TIMEZONE_UTC;
   mrb_time_update_datetime(tm2);
@@ -494,9 +494,9 @@ mrb_time_getlocal(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm, *tm2;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return self;
-  tm2 = mrb_malloc(mrb, sizeof(*tm));
+  tm2 = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
   *tm2 = *tm;
   tm2->timezone = MRB_TIMEZONE_LOCAL;
   mrb_time_update_datetime(tm2);
@@ -510,7 +510,7 @@ mrb_time_hour(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_hour);
 }
@@ -524,7 +524,7 @@ mrb_time_initialize(mrb_state *mrb, mrb_value self)
   amin = 0, asec = 0, ausec = 0;
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (tm) {
     mrb_time_free(mrb, tm);
   }
@@ -568,7 +568,7 @@ mrb_time_localtime(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return self;
   tm->timezone = MRB_TIMEZONE_LOCAL;
   mrb_time_update_datetime(tm);
@@ -582,7 +582,7 @@ mrb_time_mday(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_mday);
 }
@@ -594,7 +594,7 @@ mrb_time_min(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_min);
 }
@@ -606,7 +606,7 @@ mrb_time_mon(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_mon + 1);
 }
@@ -618,7 +618,7 @@ mrb_time_sec(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->datetime.tm_sec);
 }
@@ -631,7 +631,7 @@ mrb_time_to_f(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_float_value((mrb_float)tm->sec + (mrb_float)tm->usec/1.0e6);
 }
@@ -643,7 +643,7 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->sec);
 }
@@ -655,7 +655,7 @@ mrb_time_usec(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_fixnum_value(tm->usec);
 }
@@ -667,7 +667,7 @@ mrb_time_utc(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
 
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (tm) {
     tm->timezone = MRB_TIMEZONE_UTC;
     mrb_time_update_datetime(tm);
@@ -681,7 +681,7 @@ static mrb_value
 mrb_time_utcp(mrb_state *mrb, mrb_value self)
 {
   struct mrb_time *tm;
-  tm = mrb_get_datatype(mrb, self, &mrb_time_type);
+  tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   return mrb_bool_value(tm->timezone == MRB_TIMEZONE_UTC);
 }
diff --git a/src/vm.c b/src/vm.c
index e8dcf1b80..5e14ff139 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -28,12 +28,12 @@ static void
 stack_init(mrb_state *mrb)
 {
   /* assert(mrb->stack == NULL); */
-  mrb->stbase = mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value));
+  mrb->stbase = (mrb_value *)mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value));
   mrb->stend = mrb->stbase + STACK_INIT_SIZE;
   mrb->stack = mrb->stbase;
 
   /* assert(mrb->ci == NULL); */
-  mrb->cibase = mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo));
+  mrb->cibase = (mrb_callinfo *)mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo));
   mrb->ciend = mrb->cibase + CALLINFO_INIT_SIZE;
   mrb->ci = mrb->cibase;
   mrb->ci->target_class = mrb->object_class;
@@ -70,7 +70,7 @@ stack_extend(mrb_state *mrb, int room, int keep)
       size *= 2;
     else
       size += room;
-    mrb->stbase = mrb_realloc(mrb, mrb->stbase, sizeof(mrb_value) * size);
+    mrb->stbase = (mrb_value *)mrb_realloc(mrb, mrb->stbase, sizeof(mrb_value) * size);
     mrb->stack = mrb->stbase + off;
     mrb->stend = mrb->stbase + size;
     envadjust(mrb, oldbase, mrb->stbase);
@@ -127,7 +127,7 @@ cipush(mrb_state *mrb)
   if (mrb->ci + 1 == mrb->ciend) {
     size_t size = mrb->ci - mrb->cibase;
 
-    mrb->cibase = mrb_realloc(mrb, mrb->cibase, sizeof(mrb_callinfo)*size*2);
+    mrb->cibase = (mrb_callinfo *)mrb_realloc(mrb, mrb->cibase, sizeof(mrb_callinfo)*size*2);
     mrb->ci = mrb->cibase + size;
     mrb->ciend = mrb->cibase + size * 2;
   }
@@ -145,7 +145,7 @@ cipop(mrb_state *mrb)
   if (mrb->ci->env) {
     struct REnv *e = mrb->ci->env;
     int len = (int)e->flags;
-    mrb_value *p = mrb_malloc(mrb, sizeof(mrb_value)*len);
+    mrb_value *p = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*len);
 
     e->cioff = -1;
     memcpy(p, e->stack, sizeof(mrb_value)*len);
@@ -395,7 +395,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   mrb_value *regs = NULL;
   mrb_code i;
   int ai = mrb->arena_idx;
-  jmp_buf *prev_jmp = mrb->jmp;
+  jmp_buf *prev_jmp = (jmp_buf *)mrb->jmp;
   jmp_buf c_jmp;
 
 #ifdef DIRECT_THREADED
@@ -620,7 +620,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       if (mrb->rsize <= mrb->ci->ridx) {
         if (mrb->rsize == 0) mrb->rsize = 16;
         else mrb->rsize *= 2;
-        mrb->rescue = mrb_realloc(mrb, mrb->rescue, sizeof(mrb_code*) * mrb->rsize);
+        mrb->rescue = (mrb_code **)mrb_realloc(mrb, mrb->rescue, sizeof(mrb_code*) * mrb->rsize);
       }
       mrb->rescue[mrb->ci->ridx++] = pc + GETARG_sBx(i);
       NEXT;
@@ -657,7 +657,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       if (mrb->esize <= mrb->ci->eidx) {
         if (mrb->esize == 0) mrb->esize = 16;
         else mrb->esize *= 2;
-        mrb->ensure = mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize);
+        mrb->ensure = (struct RProc **)mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize);
       }
       mrb->ensure[mrb->ci->eidx++] = p;
       NEXT;
-- 
cgit v1.2.3


From 998830e1bc995d722e98067b6e658b926b93f970 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 31 Jul 2012 10:55:30 +0900
Subject: reduce restoration of arena_idx in vm loop

---
 src/vm.c | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 5e14ff139..b646ced77 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -364,7 +364,7 @@ argnum_error(mrb_state *mrb, int num)
 
 #define INIT_DISPATCH for (;;) { i = *pc; switch (GET_OPCODE(i)) {
 #define CASE(op) case op:
-#define NEXT mrb->arena_idx = ai; pc++; break
+#define NEXT pc++; break
 #define JUMP break
 #define END_DISPATCH }}
 
@@ -372,7 +372,7 @@ argnum_error(mrb_state *mrb, int num)
 
 #define INIT_DISPATCH JUMP; return mrb_nil_value();
 #define CASE(op) L_ ## op:
-#define NEXT mrb->arena_idx = ai; i=*++pc; goto *optable[GET_OPCODE(i)]
+#define NEXT i=*++pc; goto *optable[GET_OPCODE(i)]
 #define JUMP i=*pc; goto *optable[GET_OPCODE(i)]
 
 #define END_DISPATCH
@@ -660,6 +660,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         mrb->ensure = (struct RProc **)mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize);
       }
       mrb->ensure[mrb->ci->eidx++] = p;
+      mrb->arena_idx = ai;
       NEXT;
     }
 
@@ -671,6 +672,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       for (n=0; n<a; n++) {
         ecall(mrb, --mrb->ci->eidx);
       }
+      mrb->arena_idx = ai;
       NEXT;
     }
 
@@ -934,6 +936,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->arena_idx = ai;
       NEXT;
     }
 
@@ -1219,6 +1222,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       case TYPES2(MRB_TT_STRING,MRB_TT_STRING):
         regs[a] = mrb_str_plus(mrb, regs[a], regs[a+1]);
 	break;);
+      mrb->arena_idx = ai;
       NEXT;
     }
 
@@ -1351,6 +1355,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         mrb_ary_push(mrb, ary, regs[b++]);
       }
       regs[GETARG_A(i)] = ary;
+      mrb->arena_idx = ai;
       NEXT;
     }
 
@@ -1358,6 +1363,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->arena_idx = ai;
       NEXT;
     }
 
@@ -1429,12 +1435,14 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
           }
         }
       }
+      mrb->arena_idx = 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->arena_idx = ai;
       NEXT;
     }
 
@@ -1456,6 +1464,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         b+=2;
       }
       regs[GETARG_A(i)] = hash;
+      mrb->arena_idx = ai;
       NEXT;
     }
 
@@ -1472,6 +1481,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       }
       if (c & OP_L_STRICT) p->flags |= MRB_PROC_STRICT;
       regs[GETARG_A(i)] = mrb_obj_value(p);
+      mrb->arena_idx = ai;
       NEXT;
     }
 
@@ -1495,6 +1505,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->arena_idx = ai;
       NEXT;
     }
 
@@ -1511,6 +1522,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->arena_idx = ai;
       NEXT;
     }
 
@@ -1562,12 +1574,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->arena_idx = 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->arena_idx = ai;
       NEXT;
     }
 
@@ -1586,6 +1600,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->arena_idx = ai;
       NEXT;
     }
 
-- 
cgit v1.2.3


From 0220953efe0c4dba5ce4af5057faa2d56fda6553 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 1 Aug 2012 02:33:55 +0900
Subject: no OP_LOADNIL for operators (OP_ADD, etc)

---
 src/codegen.c | 28 ++++++++++++++++------------
 src/vm.c      |  4 ++++
 2 files changed, 20 insertions(+), 12 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/codegen.c b/src/codegen.c
index 69ad744fd..5cfd6d3f2 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -606,7 +606,7 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val)
 {
   mrb_sym sym = name ? name : (mrb_sym)tree->cdr->car;
   int idx;
-  int n = 0, noop = 0, sendv = 0;
+  int n = 0, noop = 0, sendv = 0, blk = 0;
 
   codegen(s, tree->car, VAL); /* receiver */
   idx = new_msym(s, sym);
@@ -636,40 +636,44 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val)
     pop();
   }
   else {
-    genop(s, MKOP_A(OP_LOADNIL, cursp()));
+    blk = cursp();
   }
   pop_n(n+1);
   {
-    const char *name = mrb_sym2name(s->mrb, sym);
+    int len;
+    const char *name = mrb_sym2name_len(s->mrb, sym, &len);
 
-    if (!noop && name[0] == '+' && name[1] == '\0')  {
+    if (!noop && len == 1 && name[0] == '+')  {
       genop(s, MKOP_ABC(OP_ADD, cursp(), idx, n));
     }
-    else if (!noop && name[0] == '-' && name[1] == '\0')  {
+    else if (!noop && len == 1 && name[0] == '-')  {
       genop(s, MKOP_ABC(OP_SUB, cursp(), idx, n));
     }
-    else if (!noop && name[0] == '*' && name[1] == '\0')  {
+    else if (!noop && len == 1 && name[0] == '*')  {
       genop(s, MKOP_ABC(OP_MUL, cursp(), idx, n));
     }
-    else if (!noop && name[0] == '/' && name[1] == '\0')  {
+    else if (!noop && len == 1 && name[0] == '/')  {
       genop(s, MKOP_ABC(OP_DIV, cursp(), idx, n));
     }
-    else if (!noop && name[0] == '<' && name[1] == '\0')  {
+    else if (!noop && len == 1 && name[0] == '<')  {
       genop(s, MKOP_ABC(OP_LT, cursp(), idx, n));
     }
-    else if (!noop && name[0] == '<' && name[1] == '=' && name[2] == '\0')  {
+    else if (!noop && len == 2 && name[0] == '<' && name[1] == '=')  {
       genop(s, MKOP_ABC(OP_LE, cursp(), idx, n));
     }
-    else if (!noop && name[0] == '>' && name[1] == '\0')  {
+    else if (!noop && len == 1 && name[0] == '>')  {
       genop(s, MKOP_ABC(OP_GT, cursp(), idx, n));
     }
-    else if (!noop && name[0] == '>' && name[1] == '=' && name[2] == '\0')  {
+    else if (!noop && len == 2 && name[0] == '>' && name[1] == '=')  {
       genop(s, MKOP_ABC(OP_GE, cursp(), idx, n));
     }
-    else if (!noop && name[0] == '=' && name[1] == '=' && name[2] == '\0')  {
+    else if (!noop && len == 2 && name[0] == '=' && name[1] == '=')  {
       genop(s, MKOP_ABC(OP_EQ, cursp(), idx, n));
     }
     else {
+      if (blk > 0) {		 /* no block */
+	genop(s, MKOP_A(OP_LOADNIL, blk));
+      }
       if (sendv) n = CALL_MAXARGS;
       genop(s, MKOP_ABC(OP_SEND, cursp(), idx, n));
     }
diff --git a/src/vm.c b/src/vm.c
index b646ced77..3e7dd2084 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1211,6 +1211,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     break;\
     s\
   default:\
+    SET_NIL_VALUE(regs[a+2]);\
     i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));\
     goto L_SEND;\
   }\
@@ -1257,6 +1258,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         regs[a].value.f += GETARG_C(i);
         break;
       default:
+	SET_NIL_VALUE(regs[a+2]);
         SET_INT_VALUE(regs[a+1], GETARG_C(i));
         i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
         goto L_SEND;
@@ -1277,6 +1279,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         regs[a].value.f -= GETARG_C(i);
         break;
       default:
+	SET_NIL_VALUE(regs[a+2]);
         SET_INT_VALUE(regs[a+1], GETARG_C(i));
         i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
         goto L_SEND;
@@ -1310,6 +1313,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     OP_CMP_BODY(op,f,f);\
     break;\
   default:\
+    SET_NIL_VALUE(regs[a+2]);\
     i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));\
     goto L_SEND;\
   }\
-- 
cgit v1.2.3


From 7511508a64250af30fdad4b7e342bb703e7af6c9 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 1 Aug 2012 12:54:57 +0900
Subject: restore arena index after funcall

---
 src/vm.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 3e7dd2084..2a13f0ea4 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -219,7 +219,9 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int arg
   mrb->stack[argc+1] = blk;
 
   if (MRB_PROC_CFUNC_P(p)) {
+    int ai = mrb->arena_idx;
     val = p->body.func(mrb, self);
+    mrb->arena_idx = ai;
     mrb->stack = mrb->stbase + ci->stackidx;
     cipop(mrb);
   }
-- 
cgit v1.2.3


From d271bf0aa6e44a315802cf4246f5b92552be010a Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 1 Aug 2012 13:15:02 +0900
Subject: make mrb_funcall_argv and mrb_funcall_with_block to take mrb_sym as a
 method name

---
 include/mruby.h |  4 ++--
 src/class.c     | 36 ++++++++++++++++++++++++------------
 src/error.c     | 17 ++++++++++-------
 src/kernel.c    |  2 +-
 src/re.c        |  2 +-
 src/variable.c  |  4 ++--
 src/vm.c        | 10 ++++++----
 7 files changed, 46 insertions(+), 29 deletions(-)

(limited to 'src/vm.c')

diff --git a/include/mruby.h b/include/mruby.h
index 6fcda4d35..451b4eb8b 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -330,8 +330,8 @@ struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, co
 int mrb_get_args(mrb_state *mrb, const char *format, ...);
 
 mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
-mrb_value mrb_funcall_argv(mrb_state*, mrb_value, const char*, int, mrb_value*);
-mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, const char*, int, mrb_value*, mrb_value);
+mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*);
+mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value);
 mrb_sym mrb_intern(mrb_state*,const char*);
 mrb_sym mrb_intern2(mrb_state*,const char*,int);
 mrb_sym mrb_intern_str(mrb_state*,mrb_value);
diff --git a/src/class.c b/src/class.c
index 6efc9f5e7..50d0b6317 100644
--- a/src/class.c
+++ b/src/class.c
@@ -723,8 +723,8 @@ mrb_mod_include(mrb_state *mrb, mrb_value klass)
     mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
   }
   while (argc--) {
-    mrb_funcall_argv(mrb, argv[argc], "append_features", 1, &klass);
-    mrb_funcall_argv(mrb, argv[argc], "included", 1, &klass);
+    mrb_funcall(mrb, argv[argc], "append_features", 1, klass);
+    mrb_funcall(mrb, argv[argc], "included", 1, klass);
   }
 
   return klass;
@@ -877,29 +877,41 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
 mrb_value
 mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
 {
-  mrb_value args[MRB_FUNCALL_ARGC_MAX];
+  mrb_sym mid = mrb_intern(mrb, name);
   va_list ap;
   int i;
 
-  if (argc != 0) {
+  if (argc == 0) {
+    return mrb_funcall_argv(mrb, self, mid, 0, 0);
+  }
+  else if (argc == 1) {
+    mrb_value v;
+
+    va_start(ap, argc);
+    v = va_arg(ap, mrb_value);
+    va_end(ap);
+    return mrb_funcall_argv(mrb, self, mid, 1, &v);
+  }
+  else {
+    mrb_value argv[MRB_FUNCALL_ARGC_MAX];
+
     if (argc > MRB_FUNCALL_ARGC_MAX) {
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)\n", MRB_FUNCALL_ARGC_MAX);
-    } 
+      mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)", MRB_FUNCALL_ARGC_MAX);
+    }
 
     va_start(ap, argc);
     for (i = 0; i < argc; i++) {
-      args[i] = va_arg(ap, mrb_value);
+      argv[i] = va_arg(ap, mrb_value);
     }
     va_end(ap);
+    return mrb_funcall_argv(mrb, self, mid, argc, argv);
   }
-  return mrb_funcall_argv(mrb, self, name, argc, args);
 }
 
-
 void
 mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv)
 {
-  mrb_funcall_argv(mrb, obj, "initialize", argc, argv);
+  mrb_funcall_argv(mrb, obj, mrb_intern(mrb, "initialize"), argc, argv);
 }
 
 /*
@@ -938,7 +950,7 @@ mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass)
   c = (struct RClass*)mrb_obj_alloc(mrb, k->tt, k);
   c->super = k;
   obj = mrb_obj_value(c);
-  mrb_funcall_with_block(mrb, obj, "initialize", argc, argv, blk);
+  mrb_funcall_with_block(mrb, obj, mrb_intern(mrb, "initialize"), argc, argv, blk);
 
   return obj;
 }
@@ -957,7 +969,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv)
   o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c);
   obj = mrb_obj_value(o);
   mrb_get_args(mrb, "*&", &argv, &argc, &blk);
-  mrb_funcall_with_block(mrb, obj, "initialize", argc, argv, blk);
+  mrb_funcall_with_block(mrb, obj, mrb_intern(mrb, "initialize"), argc, argv, blk);
 
   return obj;
 }
diff --git a/src/error.c b/src/error.c
index e71245509..6fe839cb2 100644
--- a/src/error.c
+++ b/src/error.c
@@ -144,7 +144,7 @@ exc_equal(mrb_state *mrb, mrb_value exc)
   if (mrb_obj_equal(mrb, exc, obj)) return mrb_true_value();
 
   if (mrb_obj_class(mrb, exc) != mrb_obj_class(mrb, obj)) {
-    if ( mrb_respond_to(mrb, obj, mrb_intern(mrb, "message")) ) {
+    if (mrb_respond_to(mrb, obj, mrb_intern(mrb, "message"))) {
       mesg = mrb_funcall(mrb, obj, "message", 0);
     }
     else
@@ -306,12 +306,15 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr)
     case 3:
       n = 1;
 exception_call:
-      if (mrb_respond_to(mrb, argv[0], mrb_intern(mrb, "exception"))) {
-        mesg = mrb_funcall_argv(mrb, argv[0], "exception", n, argv+1);
-      }
-      else {
-        /* undef */
-        mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected");
+      {
+	mrb_sym exc = mrb_intern(mrb, "exception");
+	if (mrb_respond_to(mrb, argv[0], exc)) {
+	  mesg = mrb_funcall_argv(mrb, argv[0], exc, n, argv+1);
+	}
+	else {
+	  /* undef */
+	  mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected");
+	}
       }
 
       break;
diff --git a/src/kernel.c b/src/kernel.c
index 36dfbe769..740960f80 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -245,7 +245,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self)
   int argc;
   
   mrb_get_args(mrb, "n*&", &name, &argv, &argc, &block);
-  return mrb_funcall_with_block(mrb,self, mrb_sym2name(mrb, name), argc, argv, block);
+  return mrb_funcall_with_block(mrb,self, name, argc, argv, block);
 }
 
 /* 15.3.1.2.2  */
diff --git a/src/re.c b/src/re.c
index f3cfea484..0022f9a9c 100644
--- a/src/re.c
+++ b/src/re.c
@@ -76,7 +76,7 @@ mrb_reg_s_new_instance(mrb_state *mrb, /*int argc, mrb_value *argv, */mrb_value
   re->ptr = 0;
   re->src = 0;
   re->usecnt = 0;
-  return mrb_funcall_argv(mrb, mrb_obj_value(re), "initialize", argc, argv);
+  return mrb_funcall_argv(mrb, mrb_obj_value(re), mrb_intern(mrb, "initialize"), argc, argv);
 }
 
 mrb_value
diff --git a/src/variable.c b/src/variable.c
index b81b292d9..a62e7e126 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -320,8 +320,8 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym)
         return kh_value(h, k);
       }
       if (mrb_respond_to(mrb, mrb_obj_value(c), cm)) {
-        mrb_value argv = mrb_symbol_value(sym);
-        return mrb_funcall_argv(mrb, mrb_obj_value(c), "const_missing", 1, &argv);
+        mrb_value name = mrb_symbol_value(sym);
+        return mrb_funcall(mrb, mrb_obj_value(c), "const_missing", 1, name);
       }
     }
     c = c->super;
diff --git a/src/vm.c b/src/vm.c
index 2a13f0ea4..130e56071 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -179,16 +179,18 @@ ecall(mrb_state *mrb, int i)
 }
 
 mrb_value
-mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv, mrb_value blk)
+mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mrb_value *argv, mrb_value blk)
 {
   struct RProc *p;
   struct RClass *c;
-  mrb_sym mid = mrb_intern(mrb, name);
   mrb_sym undef = 0;
   mrb_callinfo *ci;
   int n = mrb->ci->nregs;
   mrb_value val;
 
+  if (argc < 0) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%d)", argc);
+  }
   c = mrb_class(mrb, self);
   p = mrb_method_search_vm(mrb, &c, mid);
   if (!p) {
@@ -232,9 +234,9 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int arg
 }
 
 mrb_value
-mrb_funcall_argv(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv)
+mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mrb_value *argv)
 {
-  return mrb_funcall_with_block(mrb, self, name, argc, argv, mrb_nil_value());
+  return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value());
 }
 
 mrb_value
-- 
cgit v1.2.3


From 47ff5a06430a3e8cf00f53a585cef1013ff8011d Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 2 Aug 2012 00:43:38 +0900
Subject: move OP_LOADNIL just before OP_SEND to improve performance on some
 platforms

---
 src/vm.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 130e56071..9075f74bd 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -481,14 +481,6 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       NEXT;
     }
 
-    CASE(OP_LOADNIL) {
-      /* A B    R(A) := nil */
-      int a = GETARG_A(i);
-
-      SET_NIL_VALUE(regs[a]);
-      NEXT;
-    }
-
     CASE(OP_LOADSELF) {
       /* A      R(A) := self */
       regs[GETARG_A(i)] = mrb->stack[0];
@@ -680,6 +672,14 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       NEXT;
     }
 
+    CASE(OP_LOADNIL) {
+      /* A B    R(A) := nil */
+      int a = GETARG_A(i);
+
+      SET_NIL_VALUE(regs[a]);
+      NEXT;
+    }
+
   L_SEND:
     CASE(OP_SEND) {
       /* A B C  R(A) := call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
-- 
cgit v1.2.3


From 9ccf9767e1661739bb046cc8956a4437e2e75b55 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 2 Aug 2012 01:13:45 +0900
Subject: protect return value from mrb_funcall

---
 src/vm.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 9075f74bd..c04216c94 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -224,6 +224,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mr
     int ai = mrb->arena_idx;
     val = p->body.func(mrb, self);
     mrb->arena_idx = ai;
+    mrb_gc_protect(mrb, val);
     mrb->stack = mrb->stbase + ci->stackidx;
     cipop(mrb);
   }
-- 
cgit v1.2.3


From 29d4eb6e200bf1d886d2737776fff9d615b67a73 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 2 Aug 2012 04:00:42 +0900
Subject: stack pos should be adjusted for CFUNC OP_EXEC

---
 src/vm.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index c04216c94..875a6d94f 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1551,6 +1551,9 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       ci->argc = 0;
       ci->target_class = mrb_class_ptr(regs[GETARG_A(i)]);
 
+      /* prepare stack */
+      mrb->stack += a;
+
       p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_Bx(i)]);
       p->target_class = ci->target_class;
       ci->proc = p;
@@ -1569,8 +1572,8 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         irep = p->body.irep;
         pool = irep->pool;
         syms = irep->syms;
-        mrb->stack += a;
         stack_extend(mrb, irep->nregs, 1);
+	ci->nregs = irep->nregs;
         regs = mrb->stack;
         pc = irep->iseq;
         JUMP;
-- 
cgit v1.2.3


From 90323f545f4e1c317062821653f032ec151ba63e Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 2 Aug 2012 07:56:23 +0900
Subject: keep minimal stack space (recv and blk)

---
 src/vm.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 875a6d94f..f3c408809 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -132,7 +132,7 @@ cipush(mrb_state *mrb)
     mrb->ciend = mrb->cibase + size * 2;
   }
   mrb->ci++;
-  mrb->ci->nregs = 0;
+  mrb->ci->nregs = 2;
   mrb->ci->eidx = eidx;
   mrb->ci->ridx = ridx;
   mrb->ci->env = 0;
@@ -1549,7 +1549,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       ci->mid = 0;
       ci->stackidx = mrb->stack - mrb->stbase;
       ci->argc = 0;
-      ci->target_class = mrb_class_ptr(regs[GETARG_A(i)]);
+      ci->target_class = mrb_class_ptr(recv);
 
       /* prepare stack */
       mrb->stack += a;
-- 
cgit v1.2.3


From 91318da3bc2f7465ed490544afb531041aa4a092 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 2 Aug 2012 12:57:57 +0900
Subject: wrong return value from empty block/lambda

---
 src/codegen.c | 13 ++++++++++---
 src/vm.c      |  3 +--
 2 files changed, 11 insertions(+), 5 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/codegen.c b/src/codegen.c
index 866bfcb44..321223d9d 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -308,7 +308,8 @@ push_(codegen_scope *s)
 }
 
 #define push() push_(s)
-#define pop()  (s->sp--)
+#define pop_(s) ((s)->sp--)
+#define pop() pop_(s)
 #define pop_n(n) (s->sp-=(n))
 #define cursp() (s->sp)
 
@@ -508,6 +509,9 @@ lambda_body(codegen_scope *s, node *tree, int blk)
   pop();
   c = s->iseq[s->pc-1];
   if (GET_OPCODE(c) != OP_RETURN || GETARG_B(c) != OP_R_NORMAL || s->pc == s->lastlabel) {
+    if (s->nregs == 0) {
+      genop(s, MKOP_A(OP_LOADNIL, cursp()));
+    }
     genop(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL));
   }
   if (blk) {
@@ -524,12 +528,15 @@ scope_body(codegen_scope *s, node *tree)
   codegen_scope *scope = scope_new(s->mrb, s, tree->car);
   int idx = scope->idx;
 
+  codegen(scope, tree->cdr, VAL);
   if (!s->iseq) {
-    codegen(scope, tree->cdr, VAL);
     genop(scope, MKOP_A(OP_STOP, 0));
   }
   else {
-    codegen(scope, tree->cdr, VAL);
+    pop_(scope);
+    if (scope->nregs == 0) {
+      genop(scope, MKOP_A(OP_LOADNIL, scope->sp));
+    }
     genop(scope, MKOP_AB(OP_RETURN, scope->sp, OP_R_NORMAL));
   }
   scope_finish(scope, idx);
diff --git a/src/vm.c b/src/vm.c
index f3c408809..7b5e1e87a 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1563,12 +1563,11 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         mrb->arena_idx = ai;
         if (mrb->exc) goto L_RAISE;
         /* pop stackpos */
-        regs = mrb->stack = mrb->stbase + ci->stackidx;
+        mrb->stack = mrb->stbase + ci->stackidx;
         cipop(mrb);
         NEXT;
       }
       else {
-        /* setup environment for calling method */
         irep = p->body.irep;
         pool = irep->pool;
         syms = irep->syms;
-- 
cgit v1.2.3


From 5aff0d3f25f28bee364256d40e909d39a7cae679 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 3 Aug 2012 00:40:36 +0900
Subject: update regs after cfunc call

---
 src/vm.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index 7b5e1e87a..fc4d11891 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -867,7 +867,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         mrb->arena_idx = ai;
         if (mrb->exc) goto L_RAISE;
         /* pop stackpos */
-        mrb->stack = mrb->stbase + ci->stackidx;
+        regs = mrb->stack = mrb->stbase + ci->stackidx;
         cipop(mrb);
         NEXT;
       }
@@ -1563,7 +1563,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         mrb->arena_idx = ai;
         if (mrb->exc) goto L_RAISE;
         /* pop stackpos */
-        mrb->stack = mrb->stbase + ci->stackidx;
+        regs = mrb->stack = mrb->stbase + ci->stackidx;
         cipop(mrb);
         NEXT;
       }
-- 
cgit v1.2.3


From 6fb88f7e1dfb9c6e62fd994ef8158360e1823f01 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 3 Aug 2012 01:02:43 +0900
Subject: update regs after cfunc call [2]

---
 src/vm.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/vm.c b/src/vm.c
index fc4d11891..c2b461fd0 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -735,7 +735,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
         mrb->arena_idx = ai;
         if (mrb->exc) goto L_RAISE;
         /* pop stackpos */
-        mrb->stack = mrb->stbase + ci->stackidx;
+        regs = mrb->stack = mrb->stbase + ci->stackidx;
         cipop(mrb);
         NEXT;
       }
@@ -1040,7 +1040,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 	  }
           if (ci == mrb->cibase) {
             if (ci->ridx == 0) {
-	      mrb->stack = mrb->stbase;
+	      regs = mrb->stack = mrb->stbase;
 	      goto L_STOP;
 	    }
             break;
-- 
cgit v1.2.3


From 472d214a71f69fe25e681d9fea6a04fa12e60fb0 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 4 Aug 2012 06:44:53 +0900
Subject: super look-up scheme fixed; close #415

---
 src/class.c | 1 -
 src/proc.c  | 2 +-
 src/vm.c    | 5 ++---
 3 files changed, 3 insertions(+), 5 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/class.c b/src/class.c
index df42820e5..7802c34bd 100644
--- a/src/class.c
+++ b/src/class.c
@@ -333,7 +333,6 @@ mrb_define_method_vm(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_value b
   if (!h) h = c->mt = kh_init(mt, mrb);
   k = kh_put(mt, h, name);
   p = mrb_proc_ptr(body);
-  if (p) p->target_class = c;
   kh_value(h, k) = p;
 }
 
diff --git a/src/proc.c b/src/proc.c
index a1f8b180e..e5c233e1b 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -15,8 +15,8 @@ mrb_proc_new(mrb_state *mrb, mrb_irep *irep)
   struct RProc *p;
 
   p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class);
-  p->body.irep = irep;
   p->target_class = (mrb->ci) ? mrb->ci->target_class : 0;
+  p->body.irep = irep;
   p->env = 0;
 
   return p;
diff --git a/src/vm.c b/src/vm.c
index c2b461fd0..be6ee3944 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -717,7 +717,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       ci->stackidx = mrb->stack - mrb->stbase;
       ci->argc = n;
       if (ci->argc == CALL_MAXARGS) ci->argc = -1;
-      ci->target_class = m->target_class;
+      ci->target_class = c;
       ci->pc = pc + 1;
       ci->acc = a;
 
@@ -832,10 +832,9 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       int n = GETARG_C(i);
 
       recv = regs[0];
-      c = mrb->ci->proc->target_class->super;
+      c = mrb->ci->target_class->super;
       m = mrb_method_search_vm(mrb, &c, mid);
       if (!m) {
-        c = mrb->ci->proc->target_class;
         mid = mrb_intern(mrb, "method_missing");
         m = mrb_method_search_vm(mrb, &c, mid);
         if (n == CALL_MAXARGS) {
-- 
cgit v1.2.3


From b231bcb812c586d5823ea4d5dd4df12da5a237b1 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Sat, 4 Aug 2012 19:54:21 +0900
Subject: load_exec(): Fix message lenghtes in mrb_exc_new(). mrb_run(): Fix
 not to use a magic number but sizeof.

---
 src/parse.y |  6 ++++--
 src/vm.c    | 21 +++++++++++----------
 2 files changed, 15 insertions(+), 12 deletions(-)

(limited to 'src/vm.c')

diff --git a/src/parse.y b/src/parse.y
index a9afc5c96..50f55bf7b 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4875,7 +4875,8 @@ load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
       return mrb_undef_value();
     }
     else {
-      mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, E_SYNTAX_ERROR, "syntax error", 0));
+      static const char msg[] = "syntax error";
+      mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, E_SYNTAX_ERROR, msg, sizeof(msg) - 1));
       mrb_parser_free(p);
       return mrb_nil_value();
     }
@@ -4883,7 +4884,8 @@ load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
   n = mrb_generate_code(mrb, p->tree);
   mrb_parser_free(p);
   if (n < 0) {
-    mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, E_SCRIPT_ERROR, "codegen error", 0));
+    static const char msg[] = "codegen error";
+    mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, E_SCRIPT_ERROR, msg, sizeof(msg) - 1));
     return mrb_nil_value();
   }
   if (c) {
diff --git a/src/vm.c b/src/vm.c
index be6ee3944..cbea3ee77 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -905,13 +905,13 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       if (lv == 0) stack = regs + 1;
       else {
         struct REnv *e = uvenv(mrb, lv-1);
-	if (!e) {
-	  mrb_value exc;
-	  static const char m[] = "super called outside of method";
-	  exc = mrb_exc_new(mrb, E_NOMETHOD_ERROR, m, sizeof(m) - 1);
-	  mrb->exc = (struct RObject*)mrb_object(exc);
-	  goto L_RAISE;
-	}
+        if (!e) {
+          mrb_value exc;
+          static const char m[] = "super called outside of method";
+          exc = mrb_exc_new(mrb, E_NOMETHOD_ERROR, m, sizeof(m) - 1);
+          mrb->exc = (struct RObject*)mrb_object(exc);
+          goto L_RAISE;
+        }
         stack = e->stack + 1;
       }
       if (r == 0) {
@@ -1598,9 +1598,10 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     CASE(OP_TCLASS) {
       /* A B    R(A) := target_class */
       if (!mrb->ci->target_class) {
-	mrb_value exc = mrb_exc_new(mrb, E_TYPE_ERROR, "no target class or module", 25);
-	mrb->exc = (struct RObject*)mrb_object(exc);
-	goto L_RAISE;
+        static const char msg[] = "no target class or module";
+        mrb_value exc = mrb_exc_new(mrb, E_TYPE_ERROR, msg, sizeof(msg) - 1);
+        mrb->exc = (struct RObject*)mrb_object(exc);
+        goto L_RAISE;
       }
       regs[GETARG_A(i)] = mrb_obj_value(mrb->ci->target_class);
       NEXT;
-- 
cgit v1.2.3