From aeffe3f712ac9622f8e8a451bfb2d6100f89b413 Mon Sep 17 00:00:00 2001
From: Frank Celler <f.celler@triagens.de>
Date: Sat, 2 Jun 2012 11:54:14 +0200
Subject: fixed prototype: g++ will complain about definition not being a
 prototype, should work with GCC and VC as well

---
 include/mruby.h          | 8 ++++----
 include/mruby/variable.h | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 3bbc6e6cc..777683ccd 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -147,7 +147,7 @@ mrb_obj_value(void *p)
 }
 
 static inline mrb_value
-mrb_false_value()
+mrb_false_value(void)
 {
   mrb_value v;
 
@@ -157,7 +157,7 @@ mrb_false_value()
 }
 
 static inline mrb_value
-mrb_nil_value()
+mrb_nil_value(void)
 {
   mrb_value v;
 
@@ -167,7 +167,7 @@ mrb_nil_value()
 }
 
 static inline mrb_value
-mrb_true_value()
+mrb_true_value(void)
 {
   mrb_value v;
 
@@ -177,7 +177,7 @@ mrb_true_value()
 }
 
 static inline mrb_value
-mrb_undef_value()
+mrb_undef_value(void)
 {
   mrb_value v;
 
diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index 880d6217e..400dd50b0 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -14,8 +14,8 @@ extern "C" {
 typedef struct global_variable {
     int   counter;
     mrb_value *data;
-    mrb_value (*getter)();
-    void  (*setter)();
+    mrb_value (*getter)(void);
+    void  (*setter)(void);
     //void  (*marker)();
     //int block_trace;
     //struct trace_var *trace;
-- 
cgit v1.2.3


From c3e0aedece10344a6b3288e0e036273f6d5ba4ba Mon Sep 17 00:00:00 2001
From: Frank Celler <f.celler@triagens.de>
Date: Sat, 2 Jun 2012 12:09:43 +0200
Subject: export exception handling

---
 include/mruby.h | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 777683ccd..70bbdf3c2 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -416,6 +416,9 @@ mrb_value mrb_check_funcall(mrb_state *mrb, mrb_value recv, mrb_sym mid, int arg
 #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c)))
 #endif
 
+mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len);
+void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
+
 int mrb_block_given_p(void);
 void mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
 void rb_raise(struct RClass *c, const char *fmt, ...);
-- 
cgit v1.2.3


From 0e46f49aaafe0ff8b9f0616ea50d0b17df966c12 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 2 Jun 2012 21:26:30 +0900
Subject: changed prototype mrb_ary_replace to (mrb_state*,mrb_value,mrb_value)

---
 include/mruby/array.h |  3 +--
 src/array.c           | 19 +++++++++++++------
 2 files changed, 14 insertions(+), 8 deletions(-)

(limited to 'include')

diff --git a/include/mruby/array.h b/include/mruby/array.h
index e2acee535..17b26fc07 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -37,8 +37,7 @@ mrb_value mrb_ary_aget(mrb_state *mrb, mrb_value self);
 mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n);
 void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
 int mrb_ary_len(mrb_state *mrb, mrb_value ary);
-mrb_value mrb_ary_replace_m(mrb_state *mrb, mrb_value self);
-void mrb_ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, size_t len);
+void mrb_ary_replace(mrb_state *mrb, mrb_value a, mrb_value b);
 mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
 mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
 mrb_value mrb_ary_new4(mrb_state *mrb, long n, const mrb_value *elts);
diff --git a/src/array.c b/src/array.c
index 1ca6eaf1c..0c31b0da0 100644
--- a/src/array.c
+++ b/src/array.c
@@ -256,8 +256,8 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1)
   return mrb_fixnum_value((len == 0)? 0: (len > 0)? 1: -1);
 }
 
-void
-mrb_ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, size_t len)
+static void
+ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, size_t len)
 {
   if (a->capa < len) mrb_ary_expand_capa(mrb, a, len);
   memcpy(a->buf, argv, sizeof(mrb_value)*len);
@@ -265,14 +265,21 @@ mrb_ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, size_t len)
   a->len = len;
 }
 
+void
+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);
+}
+
 mrb_value
 mrb_ary_replace_m(mrb_state *mrb, mrb_value self)
 {
-  mrb_value *buf;
-  int blen;
+  mrb_value other;
 
-  mrb_get_args(mrb, "a", &buf, &blen);
-  mrb_ary_replace(mrb, mrb_ary_ptr(self), buf, blen);
+  mrb_get_args(mrb, "A", &other);
+  mrb_ary_replace(mrb, self, other);
 
   return self;
 }
-- 
cgit v1.2.3


From 92ee53146f72487787989847b02923215613278d Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 2 Jun 2012 21:30:04 +0900
Subject: unify long,size_t to int in array.[ch]

---
 include/mruby/array.h | 18 +++++++-------
 src/array.c           | 68 +++++++++++++++++++++++++--------------------------
 2 files changed, 43 insertions(+), 43 deletions(-)

(limited to 'include')

diff --git a/include/mruby/array.h b/include/mruby/array.h
index 17b26fc07..192ad7c4c 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -13,8 +13,8 @@ extern "C" {
 
 struct RArray {
   MRUBY_OBJECT_HEADER;
-  size_t len;
-  size_t capa;
+  int len;
+  int capa;
   mrb_value *buf;
 };
 
@@ -25,14 +25,14 @@ struct RArray {
 #define RARRAY_LEN(a) (RARRAY(a)->len)
 #define RARRAY_PTR(a) (RARRAY(a)->buf)
 
-mrb_value mrb_ary_new_capa(mrb_state*, size_t);
+mrb_value mrb_ary_new_capa(mrb_state*, int);
 mrb_value mrb_ary_new(mrb_state *mrb);
-mrb_value mrb_ary_new_elts(mrb_state *mrb, long n, const mrb_value *elts);
+mrb_value mrb_ary_new_elts(mrb_state *mrb, int n, const mrb_value *elts);
 void mrb_ary_concat(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_ary_splat(mrb_state*, mrb_value);
 void mrb_ary_push(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary);
-mrb_value mrb_ary_new_from_values(mrb_state *mrb, size_t size, mrb_value *vals);
+mrb_value mrb_ary_new_from_values(mrb_state *mrb, int size, mrb_value *vals);
 mrb_value mrb_ary_aget(mrb_state *mrb, mrb_value self);
 mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n);
 void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
@@ -40,11 +40,11 @@ int mrb_ary_len(mrb_state *mrb, mrb_value ary);
 void mrb_ary_replace(mrb_state *mrb, mrb_value a, mrb_value b);
 mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
 mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
-mrb_value mrb_ary_new4(mrb_state *mrb, long n, const mrb_value *elts);
+mrb_value mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts);
 mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
-mrb_value mrb_ary_entry(mrb_value ary, long offset);
-void mrb_mem_clear(mrb_value *mem, long size);
-mrb_value mrb_ary_tmp_new(mrb_state *mrb, long capa);
+mrb_value mrb_ary_entry(mrb_value ary, int offset);
+void mrb_mem_clear(mrb_value *mem, int size);
+mrb_value mrb_ary_tmp_new(mrb_state *mrb, int capa);
 mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary);
 mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
 
diff --git a/src/array.c b/src/array.c
index 0c31b0da0..9dc0e9d9c 100644
--- a/src/array.c
+++ b/src/array.c
@@ -56,7 +56,7 @@ ary_new_capa(mrb_state *mrb, size_t capa)
 }
 
 mrb_value
-mrb_ary_new_capa(mrb_state *mrb, size_t capa)
+mrb_ary_new_capa(mrb_state *mrb, int capa)
 {
   struct RArray *a = ary_new_capa(mrb, capa);
   return mrb_obj_value(a);
@@ -69,7 +69,7 @@ mrb_ary_new(mrb_state *mrb)
 }
 
 mrb_value
-mrb_ary_new_from_values(mrb_state *mrb, size_t size, mrb_value *vals)
+mrb_ary_new_from_values(mrb_state *mrb, int size, mrb_value *vals)
 {
   mrb_value ary;
   struct RArray *a;
@@ -92,7 +92,7 @@ mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr)
 }
 
 void
-ary_fill_with_nil(mrb_value *buf, size_t size)
+ary_fill_with_nil(mrb_value *buf, int size)
 {
   mrb_value nil = mrb_nil_value();
 
@@ -102,9 +102,9 @@ ary_fill_with_nil(mrb_value *buf, size_t size)
 }
 
 void
-mrb_ary_expand_capa(mrb_state *mrb, struct RArray *a, size_t len)
+mrb_ary_expand_capa(mrb_state *mrb, struct RArray *a, int len)
 {
-  size_t capa = a->capa;
+  int capa = a->capa;
 
 #ifdef LONG_MAX
   if (len > ARY_MAX_SIZE) {
@@ -134,7 +134,7 @@ mrb_ary_expand_capa(mrb_state *mrb, struct RArray *a, size_t len)
 void
 mrb_ary_shrink_capa(mrb_state *mrb, struct RArray *a)
 {
-  size_t capa = a->capa;
+  int capa = a->capa;
 
   if (capa < ARY_DEFAULT_LEN * 2) return;
   if (capa <= a->len * ARY_SHRINK_RATIO) return;
@@ -160,13 +160,13 @@ mrb_ary_s_create(mrb_state *mrb, mrb_value self)
   int len;
 
   mrb_get_args(mrb, "*", &vals, &len);
-  return mrb_ary_new_from_values(mrb, (size_t)len, vals);
+  return mrb_ary_new_from_values(mrb, (int)len, vals);
 }
 
 static void
-ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *buf, size_t blen)
+ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *buf, int blen)
 {
-  size_t len = a->len + blen;
+  int len = a->len + blen;
 
   if (a->capa < len) mrb_ary_expand_capa(mrb, a, len);
   memcpy(a->buf+a->len, buf, sizeof(mrb_value)*blen);
@@ -257,7 +257,7 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1)
 }
 
 static void
-ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, size_t len)
+ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, int len)
 {
   if (a->capa < len) mrb_ary_expand_capa(mrb, a, len);
   memcpy(a->buf, argv, sizeof(mrb_value)*len);
@@ -292,7 +292,7 @@ mrb_ary_times(mrb_state *mrb, mrb_value self)
   mrb_value ary;
   mrb_value *buf;
   mrb_int times;
-  //size_t len;
+  //int len;
 
   mrb_get_args(mrb, "i", &times);
   if (times < 0) {
@@ -355,7 +355,7 @@ mrb_ary_reverse(mrb_state *mrb, mrb_value self)
 }
 
 mrb_value
-mrb_ary_new4(mrb_state *mrb, long n, const mrb_value *elts)
+mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts)
 {
   mrb_value ary;
 
@@ -369,7 +369,7 @@ mrb_ary_new4(mrb_state *mrb, long n, const mrb_value *elts)
 }
 
 mrb_value
-mrb_ary_new_elts(mrb_state *mrb, long n, const mrb_value *elts)
+mrb_ary_new_elts(mrb_state *mrb, int n, const mrb_value *elts)
 {
   return mrb_ary_new4(mrb, n, elts);
 }
@@ -421,7 +421,7 @@ mrb_ary_shift(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
   mrb_value *buf = a->buf;
-  size_t size = a->len;
+  int size = a->len;
   mrb_value val;
 
   if (size == 0) return mrb_nil_value();
@@ -479,7 +479,7 @@ mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n)
 
   /* range check */
   if (n < 0) n += a->len;
-  if (n < 0 || a->len <= (size_t)n) return mrb_nil_value();
+  if (n < 0 || a->len <= (int)n) return mrb_nil_value();
 
   return a->buf[n];
 }
@@ -494,8 +494,8 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) /* rb_ary_s
   if (n < 0) {
     mrb_raise(mrb, E_INDEX_ERROR, "index %ld out of array", n - a->len);
   }
-  if (a->len <= (size_t)n) {
-    if (a->capa <= (size_t)n) mrb_ary_expand_capa(mrb, a, n + 1);
+  if (a->len <= (int)n) {
+    if (a->capa <= (int)n) mrb_ary_expand_capa(mrb, a, n + 1);
     ary_fill_with_nil(a->buf + a->len, n + 1 - a->len);
     a->len = n + 1;
   }
@@ -509,7 +509,7 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
 {
   struct RArray *a = mrb_ary_ptr(ary);
   mrb_int tail;
-  size_t size;
+  int size;
   mrb_value *argv;
   int i, argc;
 
@@ -536,7 +536,7 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
   if (size > a->capa) mrb_ary_expand_capa(mrb, a, size);
 
   if (head > a->len) {
-    ary_fill_with_nil(a->buf + a->len, (size_t)(head - a->len));
+    ary_fill_with_nil(a->buf + 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));
@@ -576,10 +576,10 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self)
     }
     len = mrb_fixnum(argv[0]);
     if (index < 0) index += a->len;
-    if (index < 0 || a->len < (size_t)index) return mrb_nil_value();
+    if (index < 0 || a->len < (int)index) return mrb_nil_value();
     if ((len = mrb_fixnum(argv[0])) < 0) return mrb_nil_value();
-    if (a->len == (size_t)index) return mrb_ary_new(mrb);
-    if ((size_t)len > a->len - index) len = a->len - index;
+    if (a->len == (int)index) return mrb_ary_new(mrb);
+    if ((int)len > a->len - index) len = a->len - index;
     return mrb_ary_new_from_values(mrb, len, a->buf + index);
 
   default:
@@ -625,11 +625,11 @@ mrb_ary_delete_at(mrb_state *mrb, mrb_value self)
   mrb_int   index;
   mrb_value val;
   mrb_value *buf;
-  size_t len;
+  int len;
 
   mrb_get_args(mrb, "i", &index);
   if (index < 0) index += a->len;
-  if (index < 0 || a->len <= (size_t)index) return mrb_nil_value();
+  if (index < 0 || a->len <= (int)index) return mrb_nil_value();
 
   val = a->buf[index];
 
@@ -651,7 +651,7 @@ mrb_ary_first(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
   //mrb_value ary;
-  size_t size;
+  int size;
   mrb_value *vals;
   int len;
 
@@ -673,7 +673,7 @@ mrb_ary_last(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
   //mrb_value ary;
-  size_t size;
+  int size;
   mrb_value *vals;
   int len;
 
@@ -765,7 +765,7 @@ mrb_check_array_type(mrb_state *mrb, mrb_value ary)
 }
 
 mrb_value
-mrb_ary_entry(mrb_value ary, long offset)
+mrb_ary_entry(mrb_value ary, int offset)
 {
   if (offset < 0) {
     offset += RARRAY_LEN(ary);
@@ -774,7 +774,7 @@ mrb_ary_entry(mrb_value ary, long offset)
 }
 
 void
-mrb_mem_clear(mrb_value *mem, long size)
+mrb_mem_clear(mrb_value *mem, int size)
 {
   while (size--) {
     *mem++ = mrb_nil_value();
@@ -782,15 +782,15 @@ mrb_mem_clear(mrb_value *mem, long size)
 }
 
 mrb_value
-mrb_ary_tmp_new(mrb_state *mrb, long capa)
+mrb_ary_tmp_new(mrb_state *mrb, int capa)
 {
-    return mrb_ary_new_capa(mrb, capa);//ary_new(0, capa);
+    return mrb_ary_new_capa(mrb, capa);
 }
 
 static mrb_value
 inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
 {
-  long i;
+  int i;
   mrb_value s, arystr;
   char *head = "[";
   char *sep = ", ";
@@ -853,7 +853,7 @@ mrb_ary_inspect(mrb_state *mrb, mrb_value ary)
 static mrb_value
 join_ary(mrb_state *mrb, mrb_value ary, mrb_value sep, mrb_value list)
 {
-  long i;
+  int i;
   mrb_value result, val, tmp;
 
   /* check recursive */
@@ -969,7 +969,7 @@ mrb_ary_equal(mrb_state *mrb, mrb_value ary1)
   }
   if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value();
   else {
-    long i;
+    int i;
 
     for (i=0; i<RARRAY_LEN(ary1); i++) {
       if (!mrb_equal(mrb, ary_elt(ary1, i), ary_elt(ary2, i)))
@@ -998,7 +998,7 @@ mrb_ary_eql(mrb_state *mrb, mrb_value ary1)
   if (mrb_type(ary2) != MRB_TT_ARRAY) return mrb_false_value();
   if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value();
   else {
-    long i;
+    int i;
 
     for (i=0; i<RARRAY_LEN(ary1); i++) {
       if (!mrb_eql(mrb, ary_elt(ary1, i), ary_elt(ary2, i)))
-- 
cgit v1.2.3


From 34c049c63e4c4c011fe1cfcbe954f20438919439 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 2 Jun 2012 21:34:10 +0900
Subject: remove unused mrb_mem_clear

---
 include/mruby/array.h | 1 -
 src/array.c           | 8 --------
 src/struct.c          | 4 +---
 3 files changed, 1 insertion(+), 12 deletions(-)

(limited to 'include')

diff --git a/include/mruby/array.h b/include/mruby/array.h
index 192ad7c4c..21d50152f 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -43,7 +43,6 @@ mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
 mrb_value mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts);
 mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
 mrb_value mrb_ary_entry(mrb_value ary, int offset);
-void mrb_mem_clear(mrb_value *mem, int size);
 mrb_value mrb_ary_tmp_new(mrb_state *mrb, int capa);
 mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary);
 mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
diff --git a/src/array.c b/src/array.c
index 6d41c0c3c..ed207a2a2 100644
--- a/src/array.c
+++ b/src/array.c
@@ -769,14 +769,6 @@ mrb_ary_entry(mrb_value ary, int offset)
   return ary_elt(ary, offset);
 }
 
-void
-mrb_mem_clear(mrb_value *mem, int size)
-{
-  while (size--) {
-    *mem++ = mrb_nil_value();
-  }
-}
-
 mrb_value
 mrb_ary_tmp_new(mrb_state *mrb, int capa)
 {
diff --git a/src/struct.c b/src/struct.c
index fbe018930..9f7010e0b 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -419,9 +419,7 @@ mrb_struct_initialize_withArg(mrb_state *mrb, int argc, mrb_value *argv, mrb_val
   st->ptr = mrb_malloc(mrb, sizeof(mrb_value)*argc);
   st->len = n;
   memcpy(st->ptr, argv, sizeof(mrb_value)*argc);
-  //if (n > argc) {
-  //  mrb_mem_clear(RSTRUCT_PTR(self)+argc, n-argc);
-  //}
+
   return self;
 }
 
-- 
cgit v1.2.3


From d9dfbb044afa59413afbd62b3d59cbe3f1fee342 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 2 Jun 2012 21:38:44 +0900
Subject: remove unused st_hash_end/unit reference

---
 include/mruby/hash.h | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'include')

diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 1bbd9bd97..6cb3d8ec8 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -17,9 +17,6 @@ struct RHash {
   struct kh_ht *ht;
 };
 
-#define mrb_hash_end(h) st_hash_end(h)
-#define mrb_hash_uint(h, i) st_hash_uint(h, i)
-
 #define mrb_hash_ptr(v)    ((struct RHash*)((v).value.p))
 #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 
-- 
cgit v1.2.3


From de133c37154fc2d433961ab900411b3c8cd23bef Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 2 Jun 2012 21:42:52 +0900
Subject: refactoring around mrb_hash_new

---
 include/mruby/hash.h |  4 ++--
 src/hash.c           | 10 ++++++----
 2 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'include')

diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 6cb3d8ec8..0e002052c 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -20,8 +20,8 @@ struct RHash {
 #define mrb_hash_ptr(v)    ((struct RHash*)((v).value.p))
 #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 
-mrb_value mrb_hash_new_capa(mrb_state*, size_t);
-mrb_value mrb_hash_new(mrb_state *mrb, int capa);
+mrb_value mrb_hash_new_capa(mrb_state*, int);
+mrb_value mrb_hash_new(mrb_state *mrb);
 
 void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
 mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
diff --git a/src/hash.c b/src/hash.c
index a06becd91..6c19919e5 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -81,21 +81,23 @@ mrb_gc_free_ht(mrb_state *mrb, struct RHash *hash)
 
 
 mrb_value
-mrb_hash_new_capa(mrb_state *mrb, size_t capa)
+mrb_hash_new_capa(mrb_state *mrb, int capa)
 {
   struct RHash *h;
 
   h = (struct RHash*)mrb_obj_alloc(mrb, MRB_TT_HASH, mrb->hash_class);
   h->ht = kh_init(ht, mrb);
-  kh_resize(ht, h->ht, capa);
+  if (capa > 0) {
+    kh_resize(ht, h->ht, capa);
+  }
   h->iv = 0;
   return mrb_obj_value(h);
 }
 
 mrb_value
-mrb_hash_new(mrb_state *mrb, int capa)
+mrb_hash_new(mrb_state *mrb)
 {
-  return mrb_hash_new_capa(mrb, capa);
+  return mrb_hash_new_capa(mrb, 0);
 }
 
 mrb_value
-- 
cgit v1.2.3


From 110cdd82e025999e07a448577cc5191aed113ac8 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 2 Jun 2012 21:47:27 +0900
Subject: naming convention consistency for hash.h

---
 include/mruby/hash.h |  2 +-
 src/hash.c           | 14 ++++----------
 src/sprintf.c        |  2 +-
 3 files changed, 6 insertions(+), 12 deletions(-)

(limited to 'include')

diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 0e002052c..01b042d46 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -25,7 +25,7 @@ mrb_value mrb_hash_new(mrb_state *mrb);
 
 void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
 mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
-mrb_value mrb_hash_getWithDef(mrb_state *mrb, mrb_value hash, mrb_value vkey, mrb_value def);
+mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
 mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
 mrb_value mrb_hash(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value self);
diff --git a/src/hash.c b/src/hash.c
index 6c19919e5..6d176e80c 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -101,7 +101,7 @@ mrb_hash_new(mrb_state *mrb)
 }
 
 mrb_value
-mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key) /* mrb_hash_aref */ /* mrb_hash_lookup */
+mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
   khiter_t k;
@@ -118,13 +118,13 @@ mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key) /* mrb_hash_aref */
 }
 
 mrb_value
-mrb_hash_getWithDef(mrb_state *mrb, mrb_value hash, mrb_value vkey, mrb_value def) /* mrb_hash_lookup2 */
+mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
   khiter_t k;
 
   if (h) {
-    k = kh_get(ht, h, vkey);
+    k = kh_get(ht, h, key);
     if (k != kh_end(h))
       return kh_value(h, k);
   }
@@ -332,16 +332,10 @@ mrb_hash_aget(mrb_state *mrb, mrb_value self)
   return mrb_hash_get(mrb, self, key);
 }
 
-mrb_value
-mrb_hash_lookup2(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def)
-{
-  return mrb_hash_getWithDef(mrb, hash, key, def);
-}
-
 mrb_value
 mrb_hash_lookup(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
-    return mrb_hash_lookup2(mrb, hash, key, mrb_nil_value());
+  return mrb_hash_get(mrb, hash, key);
 }
 
 /*
diff --git a/src/sprintf.c b/src/sprintf.c
index 79bd101ad..296a7c73e 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -165,7 +165,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
   (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after unnumbered(%d)", (len), (name), posarg), mrb_undef_value()) : \
   posarg == -1 ? \
   (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after numbered", (len), (name)), mrb_undef_value()) :    \
-  (posarg = -2, mrb_hash_getWithDef(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))
+  (posarg = -2, mrb_hash_fetch(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))
 
 #define GETNUM(n, val) \
   for (; p < end && ISDIGIT(*p); p++) {\
-- 
cgit v1.2.3


From 81c0e2e03115ad0eec31ac314cdb46ca364937e2 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 2 Jun 2012 23:43:13 +0900
Subject: make color in OBJECT_HEADER unsigned

---
 include/mruby/object.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mruby/object.h b/include/mruby/object.h
index 495c34083..4be060078 100644
--- a/include/mruby/object.h
+++ b/include/mruby/object.h
@@ -13,7 +13,7 @@ extern "C" {
 
 #define MRUBY_OBJECT_HEADER \
   enum mrb_vtype tt:8; \
-  int color:3;\
+  unsigned int color:3;\
   unsigned int flags:21;\
   struct RClass *c;\
   struct RBasic *gcnext
-- 
cgit v1.2.3


From cc86250297c4a8d4a2e3e350fab8cf96929283c3 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 3 Jun 2012 00:23:59 +0900
Subject: remove unsafe macros in hash.h

---
 include/mruby/hash.h |  2 --
 src/hash.c           | 24 ++++++++++++++++--------
 2 files changed, 16 insertions(+), 10 deletions(-)

(limited to 'include')

diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 01b042d46..369decdb4 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -33,8 +33,6 @@ mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value self);
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)((obj).value.p))
 #define RHASH_TBL(h)          (RHASH(h)->ht)
-#define RHASH_SIZE(h)         (RHASH_TBL(h)->size)
-#define RHASH_EMPTY_P(h)      (RHASH_SIZE(h) == 0)
 #define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern(mrb, "ifnone"))
 #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
 struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
diff --git a/src/hash.c b/src/hash.c
index 7b5481868..4a85fcec3 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -172,11 +172,11 @@ mrb_hash_dup(mrb_state *mrb, mrb_value hash)
   khash_t(ht) *h, *ret_h;
   khiter_t k, ret_k;
 
+  h = RHASH_TBL(hash);
   ret = (struct RHash*)mrb_obj_alloc(mrb, MRB_TT_HASH, mrb->hash_class);
   ret->ht = kh_init(ht, mrb);
 
-  if (!RHASH_EMPTY_P(hash)) {
-    h = RHASH_TBL(hash);
+  if (kh_size(h) > 0) {
     ret_h = ret->ht;
 
     for (k = kh_begin(h); k != kh_end(h); k++) {
@@ -818,7 +818,6 @@ static mrb_value
 mrb_hash_empty_p(mrb_state *mrb, mrb_value self)
 {
   khash_t(ht) *h = RHASH_TBL(self);
-  khiter_t k;
 
   if (h) {
     if (kh_size(h) == 0)
@@ -939,8 +938,10 @@ inspect_hash(mrb_state *mrb, mrb_value hash, int recur)
 static mrb_value
 mrb_hash_inspect(mrb_state *mrb, mrb_value hash)
 {
-  if (RHASH_EMPTY_P(hash))
-      return mrb_str_new_cstr(mrb, "{}");
+  khash_t(ht) *h = RHASH_TBL(hash);
+
+  if (!h || kh_size(h) == 0)
+    return mrb_str_new_cstr(mrb, "{}");
   return inspect_hash(mrb, hash, 0);
 }
 
@@ -1107,6 +1108,8 @@ mrb_hash_has_value(mrb_state *mrb, mrb_value hash)
 static mrb_value
 hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql)
 {
+  khash_t(ht) *h1, *h2;
+
   if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value();
   if (mrb_type(hash2) != MRB_TT_HASH) {
       if (!mrb_respond_to(mrb, hash2, mrb_intern(mrb, "to_hash"))) {
@@ -1117,10 +1120,15 @@ hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql)
       else
           return mrb_fixnum_value(mrb_equal(mrb, hash2, hash1));
   }
-  if (RHASH_SIZE(hash1) != RHASH_SIZE(hash2)) return mrb_false_value();
+  h1 = RHASH_TBL(hash1);
+  h2 = RHASH_TBL(hash2);
+  if (!h2) {
+    if (!h2)  return mrb_true_value();
+    return mrb_false_value();
+  }
+  if (!h2) return mrb_false_value();
+  if (kh_size(h1) != kh_size(h2)) return mrb_false_value();
   else {
-    khash_t(ht) *h1 = RHASH_TBL(hash1);
-    khash_t(ht) *h2 = RHASH_TBL(hash2);
     khiter_t k1, k2;
     mrb_value key;
 
-- 
cgit v1.2.3


From 12d75223d62ed90f334980c3a15e96618250fe90 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 3 Jun 2012 07:55:39 +0900
Subject: make shared string to reference-counted C structure to reduce GC
 pressure

---
 include/mruby/string.h | 15 +++++++-------
 src/gc.c               |  7 -------
 src/print.c            |  2 +-
 src/string.c           | 53 ++++++++++++++++++++++++++------------------------
 4 files changed, 36 insertions(+), 41 deletions(-)

(limited to 'include')

diff --git a/include/mruby/string.h b/include/mruby/string.h
index 39f119ae8..852c5ff02 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -25,12 +25,18 @@ extern "C" {
 
 extern const char mrb_digitmap[];
 
+struct mrb_shared_string {
+  int refcnt;
+  char *buf;
+  int len;
+};
+
 struct RString {
   MRUBY_OBJECT_HEADER;
   int len;
   union {
     int capa;
-    struct RString *shared;
+    struct mrb_shared_string *shared;
   } aux;
   char *buf;
 };
@@ -41,14 +47,7 @@ struct RString {
 #define RSTRING_LEN(s)    (RSTRING(s)->len)
 #define RSTRING_CAPA(s)   (RSTRING(s)->aux.capa)
 #define RSTRING_END(s)    (RSTRING(s)->buf + RSTRING(s)->len)
-
 #define MRB_STR_SHARED      256
-#define MRB_STR_SHARED_P(s) (FL_ALL(s, MRB_STR_SHARED))
-#define MRB_STR_NOCAPA      (MRB_STR_SHARED)
-#define MRB_STR_NOCAPA_P(s) (FL_ANY(s, MRB_STR_NOCAPA))
-#define MRB_STR_UNSET_NOCAPA(s) do {\
-  FL_UNSET(s, MRB_STR_NOCAPA);\
-} while (0)
 
 mrb_value mrb_str_literal(mrb_state*, mrb_value);
 void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
diff --git a/src/gc.c b/src/gc.c
index 04be437c1..03428765c 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -372,13 +372,6 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj)
     break;
 
   case MRB_TT_STRING:
-    {
-      struct RString *s = (struct RString*)obj;
-
-      if (s->flags & MRB_STR_SHARED) {
-	mrb_gc_mark(mrb, (struct RBasic*)s->aux.shared);
-      }
-    }
     break;
 
   case MRB_TT_RANGE:
diff --git a/src/print.c b/src/print.c
index 505597935..e6873913b 100644
--- a/src/print.c
+++ b/src/print.c
@@ -13,7 +13,7 @@ printstr(mrb_state *mrb, mrb_value obj)
 {
   struct RString *str;
   char *s;
-  size_t len;
+  int len;
 
   if (mrb_type(obj) == MRB_TT_STRING) {
     str = mrb_str_ptr(obj);
diff --git a/src/string.c b/src/string.c
index 26ed7b052..3d59948f3 100644
--- a/src/string.c
+++ b/src/string.c
@@ -49,6 +49,7 @@ str_modify(mrb_state *mrb, struct RString *s)
   if (s->flags & MRB_STR_SHARED) {
     char *ptr, *p;
     long len;
+    struct mrb_shared_string *shared = s->aux.shared;
 
     p = s->buf;
     len = s->len;
@@ -61,6 +62,12 @@ str_modify(mrb_state *mrb, struct RString *s)
     s->len = len;
     s->aux.capa = len;
     s->flags &= ~MRB_STR_SHARED;
+
+    shared->refcnt--;
+    if (shared->refcnt == 0) {
+      mrb_free(mrb, shared->buf);
+      mrb_free(mrb, shared);
+    }
   }
 }
 
@@ -76,9 +83,7 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, int len)
     if (slen < len || slen -len > 1024) {
       s->buf = mrb_realloc(mrb, s->buf, len+1);
     }
-    if (!(s->flags & MRB_STR_SHARED)) {
-      s->aux.capa = len;
-    }
+    s->aux.capa = len;
     s->len = len;
     s->buf[len] = '\0';		/* sentinel */
   }
@@ -178,13 +183,13 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len)
   }
   if (len == 0) return;
   capa = s->aux.capa;
-  if (s->len >= LONG_MAX - len) {
+  if (s->len >= INT_MAX - len) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "string sizes too big");
   }
   total = s->len+len;
   if (capa <= total) {
     while (total > capa) {
-        if (capa + 1 >= LONG_MAX / 2) {
+        if (capa + 1 >= INT_MAX / 2) {
           capa = (total + 4095) / 4096;
           break;
         }
@@ -258,12 +263,16 @@ str_make_shared(mrb_state *mrb, mrb_value str)
   str_with_class(mrb, s, str);
   orig = mrb_str_ptr(str);
   if (!(orig->flags & MRB_STR_SHARED)) {
-    struct RString *shared = mrb_obj_alloc_string(mrb);
+    struct mrb_shared_string *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_string));
 
-    shared->buf = orig->buf;
+    shared->refcnt = 1;
+    if (orig->aux.capa > orig->len) {
+      shared->buf = mrb_realloc(mrb, shared->buf, orig->len+1);
+    }
+    else {
+      shared->buf = orig->buf;
+    }
     shared->len = orig->len;
-    shared->aux.capa = orig->aux.capa;
-
     orig->aux.shared = shared;
     orig->flags |= MRB_STR_SHARED;
   }
@@ -285,16 +294,19 @@ str_make_shared(mrb_state *mrb, mrb_value str)
 mrb_value
 mrb_str_literal(mrb_state *mrb, mrb_value str)
 {
-  struct RString *orig, *s;
+  struct RString *s, *orig;
+  struct mrb_shared_string *shared;
 
   s = str_new(mrb, 0, 0);
   orig = mrb_str_ptr(str);
-  while (orig->flags & MRB_STR_SHARED) {
-    orig = orig->aux.shared;
+  if (!(orig->flags & MRB_STR_SHARED)) {
+    str_make_shared(mrb, str);
   }
-  s->buf = orig->buf;
-  s->len = orig->len;
-  s->aux.shared = orig;
+  shared = orig->aux.shared;
+  shared->refcnt++;
+  s->buf = shared->buf;
+  s->len = shared->len;
+  s->aux.shared = shared;
   s->flags |= MRB_STR_SHARED;
 
   return mrb_obj_value(s);
@@ -2849,19 +2861,10 @@ mrb_str_dump(mrb_state *mrb, mrb_value str)
 mrb_value
 mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len)
 {
-  struct RString *s = mrb_str_ptr(str);
-
   if (len < 0) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)");
   }
-  if (0/*STR_ASSOC_P(str)*/) {
-    mrb_realloc(mrb, s->buf, s->len+len+1);
-    memcpy(s->buf + s->len, ptr, len);
-    s->len += len;
-    s->buf[s->len] = '\0';	/* sentinel */
-    return str;
-  }
-  str_buf_cat(mrb, s, ptr, len);
+  str_buf_cat(mrb, mrb_str_ptr(str), ptr, len);
   return str;
 }
 
-- 
cgit v1.2.3


From 28b9619bb4c1a560392e0f958a5a5d9cedf12bc7 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 3 Jun 2012 15:45:06 +0900
Subject: should decref shared string body on gc_free

---
 include/mruby/string.h |  1 +
 src/gc.c               |  4 +++-
 src/string.c           | 16 +++++++++++-----
 3 files changed, 15 insertions(+), 6 deletions(-)

(limited to 'include')

diff --git a/include/mruby/string.h b/include/mruby/string.h
index 852c5ff02..91a59d92d 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -49,6 +49,7 @@ struct RString {
 #define RSTRING_END(s)    (RSTRING(s)->buf + RSTRING(s)->len)
 #define MRB_STR_SHARED      256
 
+void mrb_str_decref(mrb_state*, struct mrb_shared_string*);
 mrb_value mrb_str_literal(mrb_state*, mrb_value);
 void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_obj_to_str(mrb_state*, mrb_value);
diff --git a/src/gc.c b/src/gc.c
index 03428765c..cce35efa4 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -460,7 +460,9 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
     break;
 
   case MRB_TT_STRING:
-    if (!(obj->flags & MRB_STR_SHARED))
+    if (obj->flags & MRB_STR_SHARED)
+      mrb_str_decref(mrb, ((struct RString*)obj)->aux.shared);
+    else
       mrb_free(mrb, ((struct RString*)obj)->buf);
     break;
 
diff --git a/src/string.c b/src/string.c
index 8bc299987..6eba9cb20 100644
--- a/src/string.c
+++ b/src/string.c
@@ -43,6 +43,16 @@ static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len)
       s->aux.capa = capacity;\
 } while (0)
 
+void
+mrb_str_decref(mrb_state *mrb, struct mrb_shared_string *shared)
+{
+  shared->refcnt--;
+  if (shared->refcnt == 0) {
+    mrb_free(mrb, shared->buf);
+    mrb_free(mrb, shared);
+  }
+}
+
 static void
 str_modify(mrb_state *mrb, struct RString *s)
 {
@@ -63,11 +73,7 @@ str_modify(mrb_state *mrb, struct RString *s)
     s->aux.capa = len;
     s->flags &= ~MRB_STR_SHARED;
 
-    shared->refcnt--;
-    if (shared->refcnt == 0) {
-      mrb_free(mrb, shared->buf);
-      mrb_free(mrb, shared);
-    }
+    mrb_str_decref(mrb, shared);
   }
 }
 
-- 
cgit v1.2.3


From 4e46abb86914b36e70b5f3ad0826d0b648e9b4ef Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 3 Jun 2012 17:52:04 +0900
Subject: remove unused mrb_exec_recursive

---
 include/mruby.h | 2 --
 src/etc.c       | 8 --------
 2 files changed, 10 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 70bbdf3c2..3dc160535 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -469,8 +469,6 @@ mrb_value mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *
 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);
 
-mrb_value mrb_exec_recursive(mrb_state *mrb, mrb_value(*)(mrb_state *, mrb_value, mrb_value, int),mrb_value,void *);
-
 #ifndef xmalloc
 #define xmalloc     malloc
 #define xrealloc    realloc
diff --git a/src/etc.c b/src/etc.c
index 90ec47fb9..5d70c8bc7 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -111,14 +111,6 @@ mrb_exec_recursive(mrb_state *mrb, mrb_value (*func) (mrb_state *, mrb_value, mr
  * current method is called recursively on the ordered pair <obj, paired_obj>
  */
 
-mrb_value
-mrb_exec_recursive_paired(mrb_state *mrb, mrb_value (*func) (mrb_state *, mrb_value, mrb_value, int),
-                                             mrb_value obj, mrb_value paired_obj, void* arg)
-{
-  //  return mrb_exec_recursive_paired(mrb, recursive_eql, hash1, hash2, mrb_fixnum_value((int)&data));
-  return func(mrb, obj, paired_obj, 0);
-}
-
 mrb_sym
 mrb_to_id(mrb_state *mrb, mrb_value name)
 {
-- 
cgit v1.2.3


From e4529c065dfcd844dbea11ba3822af7528393450 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 3 Jun 2012 23:05:31 +0900
Subject: make arrays to share bodies

---
 include/mruby/array.h |  14 ++-
 src/array.c           | 231 ++++++++++++++++++++++++++++++++++----------------
 src/gc.c              |   5 +-
 src/struct.c          |   2 +-
 4 files changed, 175 insertions(+), 77 deletions(-)

(limited to 'include')

diff --git a/include/mruby/array.h b/include/mruby/array.h
index 21d50152f..c6c35a4e4 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -11,10 +11,19 @@
 extern "C" {
 #endif
 
+struct mrb_shared_array {
+  int refcnt;
+  mrb_value *buf;
+  int len;
+};
+
 struct RArray {
   MRUBY_OBJECT_HEADER;
   int len;
-  int capa;
+  union {
+    int capa;
+    struct mrb_shared_array *shared;
+  } aux;
   mrb_value *buf;
 };
 
@@ -24,7 +33,9 @@ struct RArray {
 
 #define RARRAY_LEN(a) (RARRAY(a)->len)
 #define RARRAY_PTR(a) (RARRAY(a)->buf)
+#define MRB_ARY_SHARED      256
 
+void mrb_ary_decref(mrb_state*, struct mrb_shared_array*);
 mrb_value mrb_ary_new_capa(mrb_state*, int);
 mrb_value mrb_ary_new(mrb_state *mrb);
 mrb_value mrb_ary_new_elts(mrb_state *mrb, int n, const mrb_value *elts);
@@ -43,7 +54,6 @@ mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
 mrb_value mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts);
 mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
 mrb_value mrb_ary_entry(mrb_value ary, int offset);
-mrb_value mrb_ary_tmp_new(mrb_state *mrb, int capa);
 mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary);
 mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
 
diff --git a/src/array.c b/src/array.c
index ed207a2a2..8f2e4824e 100644
--- a/src/array.c
+++ b/src/array.c
@@ -12,12 +12,12 @@
 
 #define ARY_DEFAULT_LEN   4
 #define ARY_SHRINK_RATIO  5 /* must be larger than 2 */
-#ifdef LONG_MAX
-#  define ARY_MAX_SIZE (LONG_MAX / sizeof(mrb_value))
+#ifdef INT_MAX
+#  define ARY_MAX_SIZE (INT_MAX / sizeof(mrb_value))
 #endif
 
 static inline mrb_value
-ary_elt(mrb_value ary, long offset)
+ary_elt(mrb_value ary, int offset)
 {
   if (RARRAY_LEN(ary) == 0) return mrb_nil_value();
   if (offset < 0 || RARRAY_LEN(ary) <= offset) {
@@ -27,12 +27,12 @@ ary_elt(mrb_value ary, long offset)
 }
 
 static struct RArray*
-ary_new_capa(mrb_state *mrb, size_t capa)
+ary_new_capa(mrb_state *mrb, int capa)
 {
   struct RArray *a;
-  size_t blen;
+  int blen;
 
-#ifdef LONG_MAX
+#ifdef INT_MAX
   if (capa > ARY_MAX_SIZE) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "ary size too big");
   }
@@ -48,7 +48,7 @@ ary_new_capa(mrb_state *mrb, size_t 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->capa = capa;
+  a->aux.capa = capa;
   a->len = 0;
 
   return a;
@@ -90,7 +90,7 @@ mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr)
   return mrb_ary_new_from_values(mrb, 2, arv);
 }
 
-void
+static void
 ary_fill_with_nil(mrb_value *buf, int size)
 {
   mrb_value nil = mrb_nil_value();
@@ -100,12 +100,60 @@ ary_fill_with_nil(mrb_value *buf, int size)
   }
 }
 
-void
-mrb_ary_expand_capa(mrb_state *mrb, struct RArray *a, int len)
+static void
+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;
+      a->aux.capa = a->len;
+      mrb_free(mrb, shared);
+    }
+    else {
+      mrb_value *ptr, *p;
+      int len;
+
+      p = a->buf;
+      len = a->len * sizeof(mrb_value);
+      ptr = mrb_malloc(mrb, len);
+      if (p) {
+	memcpy(ptr, p, len);
+      }
+      a->buf = ptr;
+      a->aux.capa = len;
+      mrb_ary_decref(mrb, shared);
+    }
+    a->flags &= ~MRB_ARY_SHARED;
+  }
+}
+
+static void
+ary_make_shared(mrb_state *mrb, struct RArray *a)
 {
-  int capa = a->capa;
+  if (!(a->flags & MRB_ARY_SHARED)) {
+    struct mrb_shared_array *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_array));
 
-#ifdef LONG_MAX
+    shared->refcnt = 1;
+    if (a->aux.capa > a->len) {
+      a->buf = shared->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*a->len+1);
+    }
+    else {
+      shared->buf = a->buf;
+    }
+    shared->len = a->len;
+    a->aux.shared = shared;
+    a->flags |= MRB_ARY_SHARED;
+  }
+}
+
+static void
+ary_expand_capa(mrb_state *mrb, struct RArray *a, int len)
+{
+  int capa = a->aux.capa;
+
+#ifdef INT_MAX
   if (len > ARY_MAX_SIZE) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
   }
@@ -120,20 +168,20 @@ mrb_ary_expand_capa(mrb_state *mrb, struct RArray *a, int len)
     }
   }
 
-#ifdef LONG_MAX
+#ifdef INT_MAX
   if (capa > ARY_MAX_SIZE) capa = ARY_MAX_SIZE; /* len <= capa <= ARY_MAX_SIZE */
 #endif
 
-  if (capa > a->capa) {
-    a->capa = capa;
+  if (capa > a->aux.capa) {
+    a->aux.capa = capa;
     a->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*capa);
   }
 }
 
-void
-mrb_ary_shrink_capa(mrb_state *mrb, struct RArray *a)
+static void
+ary_shrink_capa(mrb_state *mrb, struct RArray *a)
 {
-  int capa = a->capa;
+  int capa = a->aux.capa;
 
   if (capa < ARY_DEFAULT_LEN * 2) return;
   if (capa <= a->len * ARY_SHRINK_RATIO) return;
@@ -146,8 +194,8 @@ mrb_ary_shrink_capa(mrb_state *mrb, struct RArray *a)
     }
   } while(capa > a->len * ARY_SHRINK_RATIO);
 
-  if (capa > a->len && capa < a->capa) {
-    a->capa = capa;
+  if (capa > a->len && capa < a->aux.capa) {
+    a->aux.capa = capa;
     a->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*capa);
   }
 }
@@ -167,7 +215,8 @@ ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *buf, int blen)
 {
   int len = a->len + blen;
 
-  if (a->capa < len) mrb_ary_expand_capa(mrb, a, len);
+  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);
   mrb_write_barrier(mrb, (struct RBasic*)a);
   a->len = len;
@@ -235,7 +284,7 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1)
   mrb_value ary2;
   struct RArray *a1, *a2;
   mrb_value r = mrb_nil_value();
-  long i, len;
+  int i, len;
 
   mrb_get_args(mrb, "o", &ary2);
   if (mrb_type(ary2) != MRB_TT_ARRAY) return mrb_nil_value();
@@ -258,7 +307,9 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1)
 static void
 ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, int len)
 {
-  if (a->capa < len) mrb_ary_expand_capa(mrb, a, len);
+  ary_modify(mrb, a);
+  if (a->aux.capa < len)
+    ary_expand_capa(mrb, a, len);
   memcpy(a->buf, argv, sizeof(mrb_value)*len);
   mrb_write_barrier(mrb, (struct RBasic*)a);
   a->len = len;
@@ -377,21 +428,13 @@ mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem) /* mrb_ary_push */
 {
   struct RArray *a = mrb_ary_ptr(ary);
 
-  if (a->len == a->capa) mrb_ary_expand_capa(mrb, a, a->len + 1);
+  ary_modify(mrb, a);
+  if (a->len == a->aux.capa)
+    ary_expand_capa(mrb, a, a->len + 1);
   a->buf[a->len++] = elem;
   mrb_write_barrier(mrb, (struct RBasic*)a);
 }
 
-mrb_value
-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];
-}
-
 mrb_value
 mrb_ary_push_m(mrb_state *mrb, mrb_value self)
 {
@@ -407,30 +450,45 @@ mrb_ary_push_m(mrb_state *mrb, mrb_value self)
 }
 
 mrb_value
-mrb_ary_pop_m(mrb_state *mrb, mrb_value self)
+mrb_ary_pop(mrb_state *mrb, mrb_value ary)
 {
-  struct RArray *a = mrb_ary_ptr(self);
+  struct RArray *a = mrb_ary_ptr(ary);
 
-  return ((a->len == 0)? mrb_nil_value(): mrb_ary_pop(mrb, self));
+  if (a->len == 0) return mrb_nil_value();
+  return a->buf[--a->len];
 }
 
+#define ARY_SHIFT_SHARED_MIN 10
+
 mrb_value
 mrb_ary_shift(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
-  mrb_value *buf = a->buf;
-  int size = a->len;
   mrb_value val;
 
-  if (size == 0) return mrb_nil_value();
-
-  val = *buf;
-  while((int)(--size)) {
-    *buf = *(buf+1);
-    ++buf;
+  if (a->len == 0) return mrb_nil_value();
+  if (a->flags & MRB_ARY_SHARED) {
+  L_SHIFT:
+    val = a->buf[0];
+    a->buf++;
+    a->len--;
+    return val;
   }
-  --a->len;
+  if (a->len > ARY_SHIFT_SHARED_MIN) {
+    ary_make_shared(mrb, a);
+    goto L_SHIFT;
+  }
+  else {
+    mrb_value *buf = a->buf;
+    int size = a->len;
 
+    val = *buf;
+    while((int)(--size)) {
+      *buf = *(buf+1);
+      ++buf;
+    }
+    --a->len;
+  }
   return val;
 }
 
@@ -443,7 +501,9 @@ mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item)
 {
   struct RArray *a = mrb_ary_ptr(self);
 
-  if (a->capa < a->len + 1) mrb_ary_expand_capa(mrb, a, a->len + 1);
+  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));
   a->len += 1;
@@ -459,9 +519,11 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self)
   mrb_value *vals;
   int len;
 
+  ary_modify(mrb, a);
   mrb_get_args(mrb, "*", &vals, &len);
   if (len == 0) return self;
-  if (a->capa < a->len + len) mrb_ary_expand_capa(mrb, a, a->len + len);
+  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);
   a->len += len;
@@ -487,13 +549,15 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) /* rb_ary_s
 {
   struct RArray *a = mrb_ary_ptr(ary);
 
+  ary_modify(mrb, a);
   /* range check */
   if (n < 0) n += a->len;
   if (n < 0) {
     mrb_raise(mrb, E_INDEX_ERROR, "index %ld out of array", n - a->len);
   }
   if (a->len <= (int)n) {
-    if (a->capa <= (int)n) mrb_ary_expand_capa(mrb, a, n + 1);
+    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);
     a->len = n + 1;
   }
@@ -511,6 +575,7 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
   mrb_value *argv;
   int i, argc;
 
+  ary_modify(mrb, a);
   /* range check */
   if (head < 0) head += a->len;
   if (head < 0) {
@@ -531,7 +596,8 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
 
   if (tail < a->len) size += a->len - tail;
 
-  if (size > a->capa) mrb_ary_expand_capa(mrb, a, size);
+  if (size > a->aux.capa)
+    ary_expand_capa(mrb, a, size);
 
   if (head > a->len) {
     ary_fill_with_nil(a->buf + a->len, (int)(head - a->len));
@@ -555,6 +621,32 @@ mrb_ary_alen(mrb_state *mrb, mrb_value ary)
   return RARRAY_LEN(ary);
 }
 
+void
+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);
+  }
+}
+
+static mrb_value
+ary_subseq(mrb_state *mrb, struct RArray *a, int beg, int len)
+{
+  struct RArray *b;
+
+  ary_make_shared(mrb, a);
+  b  = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);
+  b->buf = a->buf + beg;
+  b->len = len;
+  b->aux.shared = a->aux.shared;
+  b->aux.shared->refcnt++;
+  b->flags |= MRB_ARY_SHARED;
+
+  return mrb_obj_value(b);
+}
+
 mrb_value
 mrb_ary_aget(mrb_state *mrb, mrb_value self)
 {
@@ -578,7 +670,7 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self)
     if ((len = mrb_fixnum(argv[0])) < 0) return mrb_nil_value();
     if (a->len == (int)index) return mrb_ary_new(mrb);
     if ((int)len > a->len - index) len = a->len - index;
-    return mrb_ary_new_from_values(mrb, len, a->buf + index);
+    return ary_subseq(mrb, a, index, len);
 
   default:
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
@@ -639,7 +731,7 @@ mrb_ary_delete_at(mrb_state *mrb, mrb_value self)
   }
   --a->len;
 
-  mrb_ary_shrink_capa(mrb, a);
+  ary_shrink_capa(mrb, a);
 
   return val;
 }
@@ -649,19 +741,15 @@ mrb_ary_first(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
   int size;
-  mrb_value *vals;
-  int len;
 
-  mrb_get_args(mrb, "*", &vals, &len);
-  if (len > 1) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
+  if (mrb_get_args(mrb, "|i", &size) == 0) {
+    return (a->len > 0)? a->buf[0]: mrb_nil_value();
   }
 
-  if (len == 0) return (a->len > 0)? a->buf[0]: mrb_nil_value();
-
-  /* len == 1 */
-  size = mrb_fixnum(*vals);
   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);
 }
 
@@ -683,6 +771,9 @@ mrb_ary_last(mrb_state *mrb, mrb_value self)
   /* len == 1 */
   size = mrb_fixnum(*vals);
   if (size > a->len) size = a->len;
+  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);
 }
 
@@ -690,7 +781,7 @@ mrb_value
 mrb_ary_index_m(mrb_state *mrb, mrb_value self)
 {
   mrb_value obj;
-  long i;
+  int i;
 
   mrb_get_args(mrb, "o", &obj);
   for (i = 0; i < RARRAY_LEN(self); i++) {
@@ -705,7 +796,7 @@ mrb_value
 mrb_ary_rindex_m(mrb_state *mrb, mrb_value self)
 {
   mrb_value obj;
-  long i;
+  int i;
 
   mrb_get_args(mrb, "o", &obj);
   for (i = RARRAY_LEN(self) - 1; i >= 0; i--) {
@@ -741,7 +832,7 @@ mrb_ary_clear(mrb_state *mrb, mrb_value self)
   struct RArray *a = mrb_ary_ptr(self);
 
   a->len = 0;
-  mrb_ary_shrink_capa(mrb, a);
+  ary_shrink_capa(mrb, a);
 
   return self;
 }
@@ -769,12 +860,6 @@ mrb_ary_entry(mrb_value ary, int offset)
   return ary_elt(ary, offset);
 }
 
-mrb_value
-mrb_ary_tmp_new(mrb_state *mrb, int capa)
-{
-    return mrb_ary_new_capa(mrb, capa);
-}
-
 static mrb_value
 inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
 {
@@ -1013,13 +1098,13 @@ mrb_init_array(mrb_state *mrb)
   mrb_define_method(mrb, a, "concat",          mrb_ary_concat_m,     ARGS_REQ(1)); /* 15.2.12.5.8  */
   mrb_define_method(mrb, a, "delete_at",       mrb_ary_delete_at,    ARGS_REQ(1)); /* 15.2.12.5.9  */
   mrb_define_method(mrb, a, "empty?",          mrb_ary_empty_p,      ARGS_NONE()); /* 15.2.12.5.12 */
-  mrb_define_method(mrb, a, "first",           mrb_ary_first,        ARGS_ANY());  /* 15.2.12.5.13 */
+  mrb_define_method(mrb, a, "first",           mrb_ary_first,        ARGS_OPT(1)); /* 15.2.12.5.13 */
   mrb_define_method(mrb, a, "index",           mrb_ary_index_m,      ARGS_REQ(1)); /* 15.2.12.5.14 */
   mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m,    ARGS_REQ(1)); /* 15.2.12.5.16 */
   mrb_define_method(mrb, a, "join",            mrb_ary_join_m,       ARGS_ANY());  /* 15.2.12.5.17 */
   mrb_define_method(mrb, a, "last",            mrb_ary_last,         ARGS_ANY());  /* 15.2.12.5.18 */
   mrb_define_method(mrb, a, "length",          mrb_ary_size,         ARGS_NONE()); /* 15.2.12.5.19 */
-  mrb_define_method(mrb, a, "pop",             mrb_ary_pop_m,        ARGS_NONE()); /* 15.2.12.5.21 */
+  mrb_define_method(mrb, a, "pop",             mrb_ary_pop,          ARGS_NONE()); /* 15.2.12.5.21 */
   mrb_define_method(mrb, a, "push",            mrb_ary_push_m,       ARGS_ANY());  /* 15.2.12.5.22 */
   mrb_define_method(mrb, a, "replace",         mrb_ary_replace_m,    ARGS_REQ(1)); /* 15.2.12.5.23 */
   mrb_define_method(mrb, a, "reverse",         mrb_ary_reverse,      ARGS_NONE()); /* 15.2.12.5.24 */
@@ -1034,5 +1119,5 @@ mrb_init_array(mrb_state *mrb)
   mrb_define_alias(mrb,   a, "to_s", "inspect");                                   /* 15.2.12.5.32 (x) */
   mrb_define_method(mrb, a, "==",              mrb_ary_equal,        ARGS_REQ(1)); /* 15.2.12.5.33 (x) */
   mrb_define_method(mrb, a, "eql?",            mrb_ary_eql,          ARGS_REQ(1)); /* 15.2.12.5.34 (x) */
-  mrb_define_method(mrb, a, "<=>",              mrb_ary_cmp,         ARGS_REQ(1)); /* 15.2.12.5.36 (x) */
+  mrb_define_method(mrb, a, "<=>",             mrb_ary_cmp,          ARGS_REQ(1)); /* 15.2.12.5.36 (x) */
 }
diff --git a/src/gc.c b/src/gc.c
index b269ecfb4..b7c08de65 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -457,7 +457,10 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
     break;
 
   case MRB_TT_ARRAY:
-    mrb_free(mrb, ((struct RArray*)obj)->buf);
+    if (obj->flags & MRB_ARY_SHARED)
+      mrb_ary_decref(mrb, ((struct RArray*)obj)->aux.shared);
+    else
+      mrb_free(mrb, ((struct RArray*)obj)->buf);
     break;
 
   case MRB_TT_HASH:
diff --git a/src/struct.c b/src/struct.c
index e9266ad17..2e2e0c10f 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -450,7 +450,7 @@ mrb_struct_new(mrb_state *mrb, struct RClass *klass, ...)
 
     size = mrb_long2int(num_members(mrb, klass));
     if (size > numberof(tmpargs)) {
-      tmpargs[0] = mrb_ary_tmp_new(mrb, size);
+      tmpargs[0] = mrb_ary_new_capa(mrb, size);
       mem = RARRAY_PTR(tmpargs[0]);
     }
     va_start(args, klass);
-- 
cgit v1.2.3


From 30b6507817a349cd1bdc5139533010b58faf9d14 Mon Sep 17 00:00:00 2001
From: Jon <jon.forums@gmail.com>
Date: Sun, 3 Jun 2012 18:58:19 -0400
Subject: Refactor hardcoded PARSER_DUMP macro

---
 include/mrbconf.h | 7 +++++++
 src/parse.y       | 2 --
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index e90b685bb..5a54ebeef 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -21,6 +21,9 @@ typedef int mrb_int;
 typedef intptr_t mrb_sym;
 #define readint(p,base) strtol((p),NULL,(base))
 
+#undef  PARSER_DUMP        /* do not print out parser state */
+//#define PARSER_DUMP        /* print out parser state */
+
 #undef  INCLUDE_ENCODING   /* not use encoding classes (ascii only) */
 //#define INCLUDE_ENCODING   /* use UTF-8 encoding classes */
 
@@ -31,6 +34,10 @@ typedef intptr_t mrb_sym;
 # define INCLUDE_ENCODING  /* Regexp depends Encoding */
 #endif
 
+#ifdef  MRUBY_DEBUG_BUILD
+# define PARSER_DUMP
+#endif
+
 #undef  HAVE_UNISTD_H /* WINDOWS */
 #define HAVE_UNISTD_H /* LINUX */
 
diff --git a/src/parse.y b/src/parse.y
index eae9fb373..495954538 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4761,8 +4761,6 @@ mrb_parse_string(mrb_state *mrb, const char *s)
   return mrb_parse_nstring(mrb, s, strlen(s));
 }
 
-#define PARSER_DUMP
-
 void parser_dump(mrb_state *mrb, node *tree, int offset);
 
 int
-- 
cgit v1.2.3


From b7cc7fffe7030834c160ce2cb78c398ba23ac145 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 5 Jun 2012 08:34:09 +0900
Subject: symbol can contain non printable characters

---
 include/mruby.h |  3 ++
 src/dump.c      |  6 ++--
 src/load.c      |  2 +-
 src/string.c    |  6 ----
 src/symbol.c    | 99 +++++++++++++++++++++++++++++++++++++++++++--------------
 5 files changed, 83 insertions(+), 33 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 3dc160535..579375d9f 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -332,7 +332,10 @@ 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_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);
 const char *mrb_sym2name(mrb_state*,mrb_sym);
+const char *mrb_sym2name_len(mrb_state*,mrb_sym,int*);
 mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
 
 void *mrb_malloc(mrb_state*, size_t);
diff --git a/src/dump.c b/src/dump.c
index f3cbef3a0..7b2199a02 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -268,8 +268,10 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep, int type)
 
     size += DUMP_SIZE(MRB_DUMP_SIZE_OF_SHORT, type); /* snl(n) */
     if (irep->syms[sym_no] != 0) {
-      name = mrb_sym2name(mrb, irep->syms[sym_no]);
-      nlen = str_dump_len((char*)name, strlen(name), type);
+      int len;
+
+      name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
+      nlen = str_dump_len((char*)name, len, type);
       size += nlen; /* sn(n) */
     }
   }
diff --git a/src/load.c b/src/load.c
index c0684f1aa..1b607909c 100644
--- a/src/load.c
+++ b/src/load.c
@@ -477,7 +477,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
       memcpy(buf, src, snl);                  //symbol name
       src += snl;
       buf[snl] = '\0';
-      irep->syms[i] = mrb_intern(mrb, buf);
+      irep->syms[i] = mrb_intern2(mrb, buf, snl);
     }
   }
   crc = calc_crc_16_ccitt((unsigned char*)pStart, src - pStart);     //Calculate CRC
diff --git a/src/string.c b/src/string.c
index d09d8942b..eabf9f8ef 100644
--- a/src/string.c
+++ b/src/string.c
@@ -1616,12 +1616,6 @@ mrb_str_init(mrb_state *mrb, mrb_value self)
   return self;
 }
 
-mrb_sym
-mrb_intern_str(mrb_state *mrb, mrb_value str)
-{
-  return mrb_intern(mrb, RSTRING_PTR(str));
-}
-
 /* 15.2.10.5.25 */
 /* 15.2.10.5.41 */
 /*
diff --git a/src/symbol.c b/src/symbol.c
index d09833689..986709520 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -17,59 +17,92 @@
 #include <stdio.h>
 
 /* ------------------------------------------------------ */
-KHASH_INIT(s2n, mrb_sym, const char*, 1, kh_int_hash_func, kh_int_hash_equal)
-KHASH_MAP_INIT_STR(n2s, mrb_sym);
+typedef struct symbol_name {
+  int len;
+  const char *name;
+} symbol_name;
+
+static inline khint_t
+sym_hash_func(mrb_state *mrb, const symbol_name s)
+{
+  khint_t h = 0;
+  size_t i;
+  const char *p = s.name;
+
+  for (i=0; i<s.len; i++) {
+    h = (h << 5) - h + *p++;
+  }
+  return h;
+}
+#define sym_hash_equal(mrb,a, b) (a.len == b.len && memcmp(a.name, b.name, a.len) == 0)
+
+KHASH_INIT(n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal)
 /* ------------------------------------------------------ */
 mrb_sym
-mrb_intern(mrb_state *mrb, const char *name)
+mrb_intern2(mrb_state *mrb, const char *name, int len)
 {
   khash_t(n2s) *h = mrb->name2sym;
-  khash_t(s2n) *rh = mrb->sym2name;
   khiter_t k;
-  size_t len;
   char *p;
   mrb_sym sym;
+  symbol_name sname;
 
-  k = kh_get(n2s, h, name);
+  sname.name = name;
+  sname.len = len;
+  k = kh_get(n2s, h, sname);
   if (k != kh_end(h))
     return kh_value(h, k);
 
   sym = ++mrb->symidx;
-  len = strlen(name);
   p = mrb_malloc(mrb, len+1);
   memcpy(p, name, len);
   p[len] = 0;
-  k = kh_put(n2s, h, p);
+  sname.name = p;
+  k = kh_put(n2s, h, sname);
   kh_value(h, k) = sym;
 
-  k = kh_put(s2n, rh, sym);
-  kh_value(rh, k) = p;
-
   return sym;
 }
 
+mrb_sym
+mrb_intern(mrb_state *mrb, const char *name)
+{
+  return mrb_intern2(mrb, name, strlen(name));
+}
+
+mrb_sym
+mrb_intern_str(mrb_state *mrb, mrb_value str)
+{
+  return mrb_intern(mrb, RSTRING_PTR(str));
+}
+
 const char*
-mrb_sym2name(mrb_state *mrb, mrb_sym sym)
+mrb_sym2name_len(mrb_state *mrb, mrb_sym sym, int *lenp)
 {
-  khash_t(s2n) *h = mrb->sym2name;
+  khash_t(n2s) *h = mrb->name2sym;
   khiter_t k;
+  symbol_name sname;
 
-  k = kh_get(s2n, h, sym);
+  for (k = kh_begin(h); k != kh_end(h); k++) {
+    if (kh_exist(h, k) && kh_value(h, k) == sym) break;
+  }
   if (k == kh_end(h)) {
+    *lenp = 0;
     return NULL;                /* missing */
   }
-  return kh_value(h, k);
+  sname = kh_key(h, k);
+  *lenp = sname.len;
+  return sname.name;
 }
 
 void
 mrb_free_symtbls(mrb_state *mrb)
 {
-  khash_t(s2n) *h = mrb->sym2name;
+  khash_t(n2s) *h = mrb->name2sym;
   khiter_t k;
 
-  for (k = kh_begin(h); k != kh_end(h); ++k)
-    if (kh_exist(h, k)) mrb_free(mrb, (char*)kh_value(h, k));
-  kh_destroy(s2n,mrb->sym2name);
+  for (k = kh_begin(h); k != kh_end(h); k++)
+    if (kh_exist(h, k)) mrb_free(mrb, (char*)kh_key(h, k).name);
   kh_destroy(n2s,mrb->name2sym);
 }
 
@@ -77,7 +110,6 @@ void
 mrb_init_symtbl(mrb_state *mrb)
 {
   mrb->name2sym = kh_init(n2s, mrb);
-  mrb->sym2name = kh_init(s2n, mrb);
 }
 
 /**********************************************************************
@@ -148,8 +180,11 @@ mrb_value
 mrb_sym_to_s(mrb_state *mrb, mrb_value sym)
 {
   mrb_sym id = SYM2ID(sym);
+  const char *p;
+  int len;
 
-  return mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id));
+  p = mrb_sym2name_len(mrb, id, &len);
+  return mrb_str_new(mrb, p, len);
 }
 
 /* 15.2.11.3.4  */
@@ -258,7 +293,7 @@ symname_p(const char *name)
         if (*++m == '@') ++m;
         break;
 
-      case '|': case '^': case '&': case '/': case '%': case '~': case '`':
+      case '|': case '^': case '&': case '/': case '%': case '~': case '`': case '!':
         ++m;
         break;
 
@@ -288,9 +323,10 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
   mrb_value str;
   const char *name;
   mrb_sym id = SYM2ID(sym);
+  int len;
 
-  name = mrb_sym2name(mrb, id); //mrb_id2name(id);
-  str = mrb_str_new(mrb, 0, strlen(name)+1);
+  name = mrb_sym2name_len(mrb, id, &len);
+  str = mrb_str_new(mrb, 0, len+1);
   RSTRING(str)->buf[0] = ':';
   strcpy(RSTRING(str)->buf+1, name);
   if (!symname_p(name)) {
@@ -300,6 +336,21 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
   return str;
 }
 
+const char*
+mrb_sym2name(mrb_state *mrb, mrb_sym sym)
+{
+  int len;
+  const char *name = mrb_sym2name_len(mrb, sym, &len);
+
+  if (!name) return NULL;
+  if (symname_p(name) && strlen(name) == len) {
+    return name;
+  }
+  else {
+    mrb_value str = mrb_str_dump(mrb, mrb_str_new(mrb, name, len));
+    return RSTRING(str)->buf;
+  }
+}
 
 void
 mrb_init_symbols(mrb_state *mrb)
-- 
cgit v1.2.3


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

---
 include/mruby/string.h |   8 ++--
 src/class.c            |   8 ++--
 src/gc.c               |   2 +-
 src/object.c           |   6 +--
 src/print.c            |   2 +-
 src/string.c           | 124 ++++++++++++++++++++++++-------------------------
 src/symbol.c           |   8 ++--
 7 files changed, 79 insertions(+), 79 deletions(-)

(limited to 'include')

diff --git a/include/mruby/string.h b/include/mruby/string.h
index 91a59d92d..1449a2edf 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -27,7 +27,7 @@ extern const char mrb_digitmap[];
 
 struct mrb_shared_string {
   int refcnt;
-  char *buf;
+  char *ptr;
   int len;
 };
 
@@ -38,15 +38,15 @@ struct RString {
     int capa;
     struct mrb_shared_string *shared;
   } aux;
-  char *buf;
+  char *ptr;
 };
 
 #define mrb_str_ptr(s)    ((struct RString*)((s).value.p))
 #define RSTRING(s)        ((struct RString*)((s).value.p))
-#define RSTRING_PTR(s)    (RSTRING(s)->buf)
+#define RSTRING_PTR(s)    (RSTRING(s)->ptr)
 #define RSTRING_LEN(s)    (RSTRING(s)->len)
 #define RSTRING_CAPA(s)   (RSTRING(s)->aux.capa)
-#define RSTRING_END(s)    (RSTRING(s)->buf + RSTRING(s)->len)
+#define RSTRING_END(s)    (RSTRING(s)->ptr + RSTRING(s)->len)
 #define MRB_STR_SHARED      256
 
 void mrb_str_decref(mrb_state*, struct mrb_shared_string*);
diff --git a/src/class.c b/src/class.c
index 594ed08bc..554f98550 100644
--- a/src/class.c
+++ b/src/class.c
@@ -449,7 +449,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 	ss = to_str(mrb, *sp);
 	s = mrb_str_ptr(ss);
 	ps = va_arg(ap, char**);
-	*ps = s->buf;
+	*ps = s->ptr;
 	pl = va_arg(ap, int*);
 	*pl = s->len;
         i++; sp++;
@@ -463,11 +463,11 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
 	ss = to_str(mrb, *sp);
 	s = mrb_str_ptr(ss);
-	if (strlen(s->buf) != s->len) {
+	if (strlen(s->ptr) != s->len) {
 	  mrb_raise(mrb, E_ARGUMENT_ERROR, "String contains NUL");
 	}
 	ps = va_arg(ap, char**);
-	*ps = s->buf;
+	*ps = s->ptr;
         i++; sp++;
       }
       break;
@@ -959,7 +959,7 @@ mrb_class_name(mrb_state *mrb, struct RClass* c)
 {
   mrb_value path = mrb_class_path(mrb, c);
   if (mrb_nil_p(path)) return 0;
-  return mrb_str_ptr(path)->buf;
+  return mrb_str_ptr(path)->ptr;
 }
 
 const char*
diff --git a/src/gc.c b/src/gc.c
index b7c08de65..247c1ad85 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -472,7 +472,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
     if (obj->flags & MRB_STR_SHARED)
       mrb_str_decref(mrb, ((struct RString*)obj)->aux.shared);
     else
-      mrb_free(mrb, ((struct RString*)obj)->buf);
+      mrb_free(mrb, ((struct RString*)obj)->ptr);
     break;
 
   case MRB_TT_RANGE:
diff --git a/src/object.c b/src/object.c
index 81e3867a7..817137d8e 100644
--- a/src/object.c
+++ b/src/object.c
@@ -433,7 +433,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
         }
         else if (mrb_special_const_p(x)) {
           s = mrb_str_ptr(mrb_obj_as_string(mrb, x));
-          etype = s->buf;
+          etype = s->ptr;
         }
         else {
           etype = mrb_obj_classname(mrb, x);
@@ -471,8 +471,8 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj)
   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->buf, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p));
-  s->len = strlen(s->buf);
+  sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p));
+  s->len = strlen(s->ptr);
 
   return str;
 }
diff --git a/src/print.c b/src/print.c
index e6873913b..e27a723dc 100644
--- a/src/print.c
+++ b/src/print.c
@@ -17,7 +17,7 @@ printstr(mrb_state *mrb, mrb_value obj)
 
   if (mrb_type(obj) == MRB_TT_STRING) {
     str = mrb_str_ptr(obj);
-    s = str->buf;
+    s = str->ptr;
     len = str->len;
     while (len--) {
       putc(*s, stdout);
diff --git a/src/string.c b/src/string.c
index 805b52a28..e955b3f22 100644
--- a/src/string.c
+++ b/src/string.c
@@ -39,7 +39,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->buf = mrb_realloc(mrb, s->buf, (capacity)+1);\
+      s->ptr = mrb_realloc(mrb, s->ptr, (capacity)+1);\
       s->aux.capa = capacity;\
 } while (0)
 
@@ -48,7 +48,7 @@ mrb_str_decref(mrb_state *mrb, struct mrb_shared_string *shared)
 {
   shared->refcnt--;
   if (shared->refcnt == 0) {
-    mrb_free(mrb, shared->buf);
+    mrb_free(mrb, shared->ptr);
     mrb_free(mrb, shared);
   }
 }
@@ -59,8 +59,8 @@ str_modify(mrb_state *mrb, struct RString *s)
   if (s->flags & MRB_STR_SHARED) {
     struct mrb_shared_string *shared = s->aux.shared;
 
-    if (shared->refcnt == 1 && s->buf == shared->buf) {
-      s->buf = shared->buf;
+    if (shared->refcnt == 1 && s->ptr == shared->ptr) {
+      s->ptr = shared->ptr;
       s->aux.capa = shared->len;
       mrb_free(mrb, shared);
     }
@@ -68,14 +68,14 @@ str_modify(mrb_state *mrb, struct RString *s)
       char *ptr, *p;
       long len;
 
-      p = s->buf;
+      p = s->ptr;
       len = s->len;
       ptr = mrb_malloc(mrb, len+1);
       if (p) {
 	memcpy(ptr, p, len);
       }
       ptr[len] = 0;
-      s->buf = ptr;
+      s->ptr = ptr;
       s->aux.capa = len;
       mrb_str_decref(mrb, shared);
     }
@@ -93,11 +93,11 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, int len)
   slen = s->len;
   if (len != slen) {
     if (slen < len || slen -len > 1024) {
-      s->buf = mrb_realloc(mrb, s->buf, len+1);
+      s->ptr = mrb_realloc(mrb, s->ptr, len+1);
     }
     s->aux.capa = len;
     s->len = len;
-    s->buf[len] = '\0';		/* sentinel */
+    s->ptr[len] = '\0';		/* sentinel */
   }
   return str;
 }
@@ -107,7 +107,7 @@ str_mod_check(mrb_state *mrb, mrb_value str, char *p, mrb_int len)
 {
   struct RString *s = mrb_str_ptr(str);
 
-  if (s->buf != p || s->len != len) {
+  if (s->ptr != p || s->len != len) {
     mrb_raise(mrb, mrb->eRuntimeError_class, "string modified");
   }
 }
@@ -122,7 +122,7 @@ str_alloc(mrb_state *mrb, struct RClass *c)
   s = mrb_obj_alloc_string(mrb);
 
   s->c = c;
-  s->buf = 0;
+  s->ptr = 0;
   s->len = 0;
   s->aux.capa = 0;
 
@@ -143,11 +143,11 @@ str_new(mrb_state *mrb, const char *p, int len)
 
   s->len = len;
   s->aux.capa = len;
-  s->buf = mrb_malloc(mrb, len+1);
+  s->ptr = mrb_malloc(mrb, len+1);
   if (p) {
-    memcpy(s->buf, p, len);
+    memcpy(s->ptr, p, len);
   }
-  s->buf[len] = '\0';
+  s->ptr[len] = '\0';
   return s;
 }
 
@@ -178,8 +178,8 @@ mrb_str_buf_new(mrb_state *mrb, int capa)
   }
   s->len = 0;
   s->aux.capa = capa;
-  s->buf = mrb_malloc(mrb, capa+1);
-  s->buf[0] = '\0';
+  s->ptr = mrb_malloc(mrb, capa+1);
+  s->ptr[0] = '\0';
 
   return mrb_obj_value(s);
 }
@@ -190,8 +190,8 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len)
   long capa, total, off = -1;
 
   str_modify(mrb, s);
-  if (ptr >= s->buf && ptr <= s->buf + s->len) {
-      off = ptr - s->buf;
+  if (ptr >= s->ptr && ptr <= s->ptr + s->len) {
+      off = ptr - s->ptr;
   }
   if (len == 0) return;
   capa = s->aux.capa;
@@ -210,11 +210,11 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len)
     RESIZE_CAPA(s, capa);
   }
   if (off != -1) {
-      ptr = s->buf + off;
+      ptr = s->ptr + off;
   }
-  memcpy(s->buf + s->len, ptr, len);
+  memcpy(s->ptr + s->len, ptr, len);
   s->len = total;
-  s->buf[total] = '\0';		/* sentinel */
+  s->ptr[total] = '\0';		/* sentinel */
 }
 
 mrb_value
@@ -257,9 +257,9 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p)
   int len = strlen(p);
 
   s = mrb_obj_alloc_string(mrb);
-  s->buf = mrb_malloc(mrb, len+1);
-  memcpy(s->buf, p, len);
-  s->buf[len] = 0;
+  s->ptr = mrb_malloc(mrb, len+1);
+  memcpy(s->ptr, p, len);
+  s->ptr[len] = 0;
   s->len = len;
   s->aux.capa = len;
 
@@ -274,10 +274,10 @@ str_make_shared(mrb_state *mrb, struct RString *s)
 
     shared->refcnt = 1;
     if (s->aux.capa > s->len) {
-      s->buf = shared->buf = mrb_realloc(mrb, s->buf, s->len+1);
+      s->ptr = shared->ptr = mrb_realloc(mrb, s->ptr, s->len+1);
     }
     else {
-      shared->buf = s->buf;
+      shared->ptr = s->ptr;
     }
     shared->len = s->len;
     s->aux.shared = shared;
@@ -305,7 +305,7 @@ mrb_str_literal(mrb_state *mrb, mrb_value str)
   }
   shared = orig->aux.shared;
   shared->refcnt++;
-  s->buf = shared->buf;
+  s->ptr = shared->ptr;
   s->len = shared->len;
   s->aux.shared = shared;
   s->flags |= MRB_STR_SHARED;
@@ -325,7 +325,7 @@ mrb_str_body(mrb_value str, int *len_p)
   struct RString *s = mrb_str_ptr(str);
 
   *len_p = s->len;
-  return s->buf;
+  return s->ptr;
 }
 
 /*
@@ -349,11 +349,11 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
 
   if (s1->aux.capa < len) {
     s1->aux.capa = len;
-    s1->buf = mrb_realloc(mrb, s1->buf, len+1);
+    s1->ptr = mrb_realloc(mrb, s1->ptr, len+1);
   }
-  memcpy(s1->buf+s1->len, s2->buf, s2->len);
+  memcpy(s1->ptr+s1->len, s2->ptr, s2->len);
   s1->len = len;
-  s1->buf[len] = 0;
+  s1->ptr[len] = 0;
 }
 
 /*
@@ -370,8 +370,8 @@ mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b)
   struct RString *t;
 
   t = str_new(mrb, 0, s->len + s2->len);
-  memcpy(t->buf, s->buf, s->len);
-  memcpy(t->buf + s->len, s2->buf, s2->len);
+  memcpy(t->ptr, s->ptr, s->len);
+  memcpy(t->ptr + s->len, s2->ptr, s2->len);
 
   return mrb_obj_value(t);
 }
@@ -446,7 +446,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self)
   len = RSTRING_LEN(self)*times;
   str2 = str_new(mrb, 0, len);
   str_with_class(mrb, str2, self);
-  p = str2->buf;
+  p = str2->ptr;
   if (len > 0) {
     n = RSTRING_LEN(self);
     memcpy(p, RSTRING_PTR(self), n);
@@ -481,7 +481,7 @@ mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2)
   struct RString *s2 = mrb_str_ptr(str2);
 
   len = lesser(s1->len, s2->len);
-  retval = memcmp(s1->buf, s2->buf, len);
+  retval = memcmp(s1->ptr, s2->ptr, len);
   if (retval == 0) {
     if (s1->len == s2->len) return 0;
     if (s1->len > s2->len)  return 1;
@@ -725,7 +725,7 @@ mrb_str_dup(mrb_state *mrb, mrb_value str)
   /* should return shared string */
   struct RString *s = mrb_str_ptr(str);
 
-  return mrb_str_new(mrb, s->buf, s->len);
+  return mrb_str_new(mrb, s->ptr, s->len);
 }
 
 static mrb_value
@@ -871,8 +871,8 @@ mrb_str_capitalize_bang(mrb_state *mrb, mrb_value str)
   struct RString *s = mrb_str_ptr(str);
 
   str_modify(mrb, s);
-  if (s->len == 0 || !s->buf) return mrb_nil_value();
-  p = s->buf; pend = s->buf + s->len;
+  if (s->len == 0 || !s->ptr) return mrb_nil_value();
+  p = s->ptr; pend = s->ptr + s->len;
   if (ISLOWER(*p)) {
     *p = toupper(*p);
     modify = 1;
@@ -931,14 +931,14 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)
   if (mrb_get_args(mrb, "|S", &rs) == 0) {
     if (len == 0) return mrb_nil_value();
   smart_chomp:
-    if (s->buf[len-1] == '\n') {
+    if (s->ptr[len-1] == '\n') {
       s->len--;
       if (s->len > 0 &&
-	  s->buf[s->len-1] == '\r') {
+	  s->ptr[s->len-1] == '\r') {
 	s->len--;
       }
     }
-    else if (s->buf[len-1] == '\r') {
+    else if (s->ptr[len-1] == '\r') {
       s->len--;
     }
     else {
@@ -948,7 +948,7 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)
   }
 
   if (len == 0 || mrb_nil_p(rs)) return mrb_nil_value();
-  p = s->buf;
+  p = s->ptr;
   rslen = RSTRING_LEN(rs);
   if (rslen == 0) {
     while (len>0 && p[len-1] == '\n') {
@@ -1028,14 +1028,14 @@ mrb_str_chop_bang(mrb_state *mrb, mrb_value str)
   if (s->len > 0) {
     int len;
     len = s->len - 1;
-    if (s->buf[len] == '\n') {
+    if (s->ptr[len] == '\n') {
       if (len > 0 &&
-          s->buf[len-1] == '\r') {
+          s->ptr[len-1] == '\r') {
         len--;
       }
     }
     s->len = len;
-    s->buf[len] = '\0';
+    s->ptr[len] = '\0';
     return str;
   }
   return mrb_nil_value();
@@ -1083,8 +1083,8 @@ mrb_str_downcase_bang(mrb_state *mrb, mrb_value str)
   struct RString *s = mrb_str_ptr(str);
 
   str_modify(mrb, s);
-  p = s->buf;
-  pend = s->buf + s->len;
+  p = s->ptr;
+  pend = s->ptr + s->len;
   while (p < pend) {
     if (ISUPPER(*p)) {
       *p = tolower(*p);
@@ -1206,7 +1206,7 @@ mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len)
   str_make_shared(mrb, s);
   shared = s->aux.shared;
   s = mrb_obj_alloc_string(mrb);
-  s->buf = shared->buf + beg;
+  s->ptr = shared->ptr + beg;
   s->len = len;
   s->aux.shared = shared;
   s->flags |= MRB_STR_SHARED;
@@ -1391,7 +1391,7 @@ mrb_str_hash(mrb_state *mrb, mrb_value str)
   /* 1-8-7 */
   struct RString *s = mrb_str_ptr(str);
   long len = s->len;
-  char *p = s->buf;
+  char *p = s->ptr;
   mrb_int key = 0;
 
   while (len--) {
@@ -1555,7 +1555,7 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2)
 {
   if (s2->flags & MRB_STR_SHARED) {
   L_SHARE:
-    s1->buf = s2->buf;
+    s1->ptr = s2->ptr;
     s1->len = s2->len;
     s1->aux.shared = s2->aux.shared;
     s1->flags |= MRB_STR_SHARED;
@@ -1567,13 +1567,13 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2)
   else {
     if (s1->flags & MRB_STR_SHARED) {
       mrb_str_decref(mrb, s1->aux.shared);
-      s1->buf = mrb_malloc(mrb, s2->len+1);
+      s1->ptr = mrb_malloc(mrb, s2->len+1);
     }
     else {
-      s1->buf = mrb_realloc(mrb, s1->buf, s2->len+1);
+      s1->ptr = mrb_realloc(mrb, s1->ptr, s2->len+1);
     }
-    memcpy(s1->buf, s2->buf, s2->len);
-    s1->buf[s2->len] = 0;
+    memcpy(s1->ptr, s2->ptr, s2->len);
+    s1->ptr[s2->len] = 0;
     s1->len = s2->len;
     s2->aux.capa = s2->len;
   }
@@ -1754,7 +1754,7 @@ mrb_str_reverse(mrb_state *mrb, mrb_value str)
   s2 = str_new(mrb, 0, RSTRING(str)->len);
   str_with_class(mrb, s2, str);
   s = RSTRING_PTR(str); e = RSTRING_END(str) - 1;
-  p = s2->buf;
+  p = s2->ptr;
 
   while (e >= s) {
     *p++ = *e--;
@@ -1778,7 +1778,7 @@ mrb_str_reverse_bang(mrb_state *mrb, mrb_value str)
 
   str_modify(mrb, s);
   if (s->len > 1) {
-    p = s->buf;
+    p = s->ptr;
     e = p + s->len - 1;
     while (p < e) {
       c = *p;
@@ -1820,13 +1820,13 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos)
   if (ps->len - pos < len) {
     pos = ps->len - len;
   }
-  sbeg = ps->buf;
-  s = ps->buf + pos;
-  t = psub->buf;
+  sbeg = ps->ptr;
+  s = ps->ptr + pos;
+  t = psub->ptr;
   if (len) {
     while (sbeg <= s) {
       if (memcmp(s, t, len) == 0) {
-        return s - ps->buf;
+        return s - ps->ptr;
       }
       s--;
     }
@@ -2028,7 +2028,7 @@ mrb_str_scan(mrb_state *mrb, mrb_value str)
   mrb_int start = 0;
   mrb_value match = mrb_nil_value();
   struct RString *ps = mrb_str_ptr(str);
-  char *p = ps->buf;
+  char *p = ps->ptr;
   long len = ps->len;
 
   mrb_get_args(mrb, "o&", &pat, &b);
@@ -2513,7 +2513,7 @@ char *
 mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
 {
   struct RString *ps = mrb_str_ptr(*ptr);
-  char *s = ps->buf;
+  char *s = ps->ptr;
 
   if (!s || ps->len != strlen(s)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
@@ -2820,7 +2820,7 @@ mrb_str_dump(mrb_state *mrb, mrb_value str)
     result = str_new(mrb, 0, len);
     str_with_class(mrb, result, str);
     p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
-    q = result->buf;
+    q = result->ptr;
 
     *q++ = '"';
     while (p < pend) {
diff --git a/src/symbol.c b/src/symbol.c
index 6754325a5..2658b35dc 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -331,11 +331,11 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
 
   name = mrb_sym2name_len(mrb, id, &len);
   str = mrb_str_new(mrb, 0, len+1);
-  RSTRING(str)->buf[0] = ':';
-  memcpy(RSTRING(str)->buf+1, name, len);
+  RSTRING(str)->ptr[0] = ':';
+  memcpy(RSTRING(str)->ptr+1, name, len);
   if (!symname_p(name) || strlen(name) != len) {
     str = mrb_str_dump(mrb, str);
-    strncpy(RSTRING(str)->buf, ":\"", 2);
+    strncpy(RSTRING(str)->ptr, ":\"", 2);
   }
   return str;
 }
@@ -352,7 +352,7 @@ mrb_sym2name(mrb_state *mrb, mrb_sym sym)
   }
   else {
     mrb_value str = mrb_str_dump(mrb, mrb_str_new(mrb, name, len));
-    return RSTRING(str)->buf;
+    return RSTRING(str)->ptr;
   }
 }
 
-- 
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 'include')

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 1a369de4897eb4764c30146d56761444beb5b46c Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 7 Jun 2012 01:18:17 +0900
Subject: remove src/gc.h

---
 include/mruby/class.h    |  4 ++++
 include/mruby/hash.h     |  5 +++++
 include/mruby/variable.h |  7 +++++++
 src/gc.c                 | 25 +++++++++++++++++++++-
 src/gc.h                 | 54 ------------------------------------------------
 5 files changed, 40 insertions(+), 55 deletions(-)
 delete mode 100644 src/gc.h

(limited to 'include')

diff --git a/include/mruby/class.h b/include/mruby/class.h
index 0afd331b0..28365ee58 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -78,6 +78,10 @@ struct RClass* mrb_class_real(struct RClass* cl);
 
 void mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv);
 
+void mrb_gc_mark_mt(mrb_state*, struct RClass*);
+size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
+void mrb_gc_free_mt(mrb_state*, struct RClass*);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 369decdb4..e7162c3ab 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -42,6 +42,11 @@ struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
 
 mrb_value mrb_obj_is_proc(mrb_value proc);
 
+/* GC functions */
+void mrb_gc_mark_ht(mrb_state*, struct RHash*);
+size_t mrb_gc_mark_ht_size(mrb_state*, struct RHash*);
+void mrb_gc_free_ht(mrb_state*, struct RHash*);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index 400dd50b0..fb686fd47 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -48,6 +48,13 @@ mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
 mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
 void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
 
+/* GC functions */
+void mrb_gc_mark_gv(mrb_state*);
+void mrb_gc_free_gv(mrb_state*);
+void mrb_gc_mark_iv(mrb_state*, struct RObject*);
+size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
+void mrb_gc_free_iv(mrb_state*, struct RObject*);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/src/gc.c b/src/gc.c
index 6d22bf275..1b4b3eed4 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -18,6 +18,7 @@
 #include "mruby/proc.h"
 #include "mruby/data.h"
 #include "mruby/numeric.h"
+#include "mruby/variable.h"
 
 /*
   = Tri-color Incremental Garbage Collection
@@ -74,7 +75,29 @@
 #include "re.h"
 #endif
 
-#include "gc.h"
+struct free_obj {
+  MRUBY_OBJECT_HEADER;
+  struct RBasic *next;
+};
+
+typedef struct {
+  union {
+    struct free_obj free;
+    struct RBasic basic;
+    struct RObject object;
+    struct RClass klass;
+    struct RString string;
+    struct RArray array;
+    struct RHash hash;
+    struct RRange range;
+    struct RStruct structdata;
+    struct RProc procdata;
+#ifdef INCLUDE_REGEXP
+    struct RMatch match;
+    struct RRegexp regexp;
+#endif
+  } as;
+} RVALUE;
 
 #ifdef GC_PROFILE
 #include <sys/time.h>
diff --git a/src/gc.h b/src/gc.h
deleted file mode 100644
index fea761d1b..000000000
--- a/src/gc.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-** gc.h - garbage collector for RiteVM
-**
-** See Copyright Notice in mruby.h
-*/
-
-#ifndef MRUBY_GC_H
-#define MRUBY_GC_H
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-struct free_obj {
-  MRUBY_OBJECT_HEADER;
-  struct RBasic *next;
-};
-
-typedef struct {
-  union {
-    struct free_obj free;
-    struct RBasic basic;
-    struct RObject object;
-    struct RClass klass;
-    struct RString string;
-    struct RArray array;
-    struct RHash hash;
-    struct RRange range;
-    struct RStruct structdata;
-    struct RProc procdata;
-#ifdef INCLUDE_REGEXP
-    struct RMatch match;
-    struct RRegexp regexp;
-#endif
-  } as;
-} RVALUE;
-
-void mrb_gc_mark_gv(mrb_state*);
-void mrb_gc_free_gv(mrb_state*);
-void mrb_gc_mark_iv(mrb_state*, struct RObject*);
-size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
-void mrb_gc_free_iv(mrb_state*, struct RObject*);
-void mrb_gc_mark_mt(mrb_state*, struct RClass*);
-size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
-void mrb_gc_free_mt(mrb_state*, struct RClass*);
-void mrb_gc_mark_ht(mrb_state*, struct RHash*);
-size_t mrb_gc_mark_ht_size(mrb_state*, struct RHash*);
-void mrb_gc_free_ht(mrb_state*, struct RHash*);
-
-#if defined(__cplusplus)
-}  /* extern "C" { */
-#endif
-
-#endif  /* MRUBY_GC_H */
-- 
cgit v1.2.3


From e0909fef4471976c72e04ad2cc8c8d55eed047a7 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Thu, 7 Jun 2012 09:34:27 +0900
Subject: Use value.i for nil/false check.

---
 include/mruby/class.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mruby/class.h b/include/mruby/class.h
index 0afd331b0..58b648579 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -28,7 +28,7 @@ mrb_class(mrb_state *mrb, mrb_value v)
 {
   switch (mrb_type(v)) {
   case MRB_TT_FALSE:
-    if (v.value.p)
+    if (v.value.i)
       return mrb->false_class;
     return mrb->nil_class;
   case MRB_TT_TRUE:
-- 
cgit v1.2.3


From 9ecc209ca02f84db5a8d87ad19568d4025cea68f Mon Sep 17 00:00:00 2001
From: SatoshiOdawara <Satoshi_Odawara@fukuoka-csk.co.jp>
Date: Thu, 7 Jun 2012 16:03:53 +0900
Subject: memory leak in kh_resize_##name()

---
 include/mruby/khash.h | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index 06c451e44..f8958781a 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -129,6 +129,9 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
 	  kh_value(h,k) = old_vals[i];                                  \
 	}                                                               \
       }                                                                 \
+      mrb_free(h->mrb, old_e_flags);                                    \
+      mrb_free(h->mrb, old_keys);                                       \
+      mrb_free(h->mrb, old_vals);                                       \
     }                                                                   \
   }                                                                     \
   static inline khint_t kh_put_##name(kh_##name##_t *h, khkey_t key)    \
-- 
cgit v1.2.3


From 5046375d518b77721559df0571e6caee1fa0ae26 Mon Sep 17 00:00:00 2001
From: Yuichiro MASUI <masui@masuidrive.jp>
Date: Fri, 8 Jun 2012 00:59:26 +0900
Subject: add auxiliary data pointer to mrb_state

---
 include/mruby.h | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 579375d9f..167808b14 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -280,6 +280,8 @@ typedef struct mrb_state {
   struct RClass *eException_class;
   struct RClass *eStandardError_class;
   struct RClass *eRuntimeError_class;
+
+  void *ud; /* auxiliary data */
 } mrb_state;
 
 typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value);
-- 
cgit v1.2.3


From 21304086cdd6297feb8dc754357a7b9d35fff742 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 12 Jun 2012 01:41:20 +0900
Subject: remove khash#kh_debug

---
 include/mruby/khash.h | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index f8958781a..22df48ebb 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -163,15 +163,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   {                                                                     \
     h->d_flags[x/8] |= __m[x%8];                                        \
     h->size--;                                                          \
-  }                                                                     \
-  static inline void kh_debug_##name(kh_##name##_t *h)                  \
-  {                                                                     \
-    khint_t i;                                                          \
-    printf("idx:e_flag:d_flag\n");                                      \
-    for( i=0 ; i<h->n_buckets/8 ; i++ ){                                \
-      printf("%4d:%02X:%02X\n", i, h->e_flags[i], h->d_flags[i]);       \
-    }                                                                   \
-  }                                                                     \
+  }
 
 #define khash_t(name) kh_##name##_t
 
@@ -182,7 +174,6 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
 #define kh_put(name, h, k) kh_put_##name(h, k)
 #define kh_get(name, h, k) kh_get_##name(h, k)
 #define kh_del(name, h, k) kh_del_##name(h, k)
-#define kh_debug(name, h) kh_debug_##name(h)
 
 #define kh_exist(h, x) (!__ac_iseither((h)->e_flags, (h)->d_flags, (x)))
 #define kh_key(h, x) ((h)->keys[x])
-- 
cgit v1.2.3


From e1e4ceb3e42dab35038a52d89064ca6378a08c7d Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Tue, 12 Jun 2012 17:46:38 +0900
Subject: Make sprintf/format optional.

---
 include/mrbconf.h | 3 +++
 src/kernel.c      | 2 ++
 src/sprintf.c     | 5 +++++
 3 files changed, 10 insertions(+)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 5a54ebeef..f2b23258e 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -34,6 +34,9 @@ typedef intptr_t mrb_sym;
 # define INCLUDE_ENCODING  /* Regexp depends Encoding */
 #endif
 
+//#undef INCLUDE_KERNEL_SPRINTF     /* not use Kernel.sprintf method. */
+#define INCLUDE_KERNEL_SPRINTF     /* not use Kernel.sprintf method. */
+
 #ifdef  MRUBY_DEBUG_BUILD
 # define PARSER_DUMP
 #endif
diff --git a/src/kernel.c b/src/kernel.c
index 15a4158a4..bc8e0059b 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -1425,8 +1425,10 @@ mrb_init_kernel(mrb_state *mrb)
   mrb_define_method(mrb, krn, "singleton_methods",          mrb_obj_singleton_methods_m,     ARGS_ANY());     /* 15.3.1.3.45 */
   mrb_define_method(mrb, krn, "to_s",                       mrb_any_to_s,                    ARGS_NONE());    /* 15.3.1.3.46 */
 
+#ifdef INCLUDE_KERNEL_SPRINTF
   mrb_define_method(mrb, krn, "sprintf",                    mrb_f_sprintf,                   ARGS_ANY());     /* in sprintf.c */
   mrb_define_method(mrb, krn, "format",                     mrb_f_sprintf,                   ARGS_ANY());     /* in sprintf.c */
+#endif
 
   mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
 }
diff --git a/src/sprintf.c b/src/sprintf.c
index 296a7c73e..c7e7badc4 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -5,6 +5,9 @@
 */
 
 #include "mruby.h"
+
+#ifdef INCLUDE_KERNEL_SPRINTF
+
 #include <stdio.h>
 #include <string.h>
 #include "encoding.h"
@@ -1078,3 +1081,5 @@ fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
     *buf++ = c;
     *buf = '\0';
 }
+
+#endif //INCLUDE_KERNEL_SPRINTF
-- 
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 'include')

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 db3d72a471a0ee4d8d6ea248e99b2b062b390511 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 13 Jun 2012 15:40:41 +0900
Subject: move RSHIFT from numeric.h to numeric.c

---
 include/mruby/numeric.h | 1 -
 src/numeric.c           | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'include')

diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h
index 95792e9a6..a3768db2f 100644
--- a/include/mruby/numeric.h
+++ b/include/mruby/numeric.h
@@ -13,7 +13,6 @@ extern "C" {
 
 #include <limits.h>
 
-#define RSHIFT(x,y) ((x)>>(int)(y))
 #define POSFIXABLE(f) ((f) <= INT_MAX)
 #define NEGFIXABLE(f) ((f) >= INT_MIN)
 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
diff --git a/src/numeric.c b/src/numeric.c
index 2d668fa79..e894b3dc3 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -28,7 +28,7 @@
 #include <ieeefp.h>
 #endif
 
-#define SIGNED_VALUE intptr_t
+#define RSHIFT(x,y) ((x)>>(int)(y))
 
 #ifdef MRB_USE_FLOAT
 #define floor(f) floorf(f)
@@ -697,7 +697,7 @@ int_succ(mrb_state *mrb, mrb_value num)
   return mrb_funcall(mrb, num, "+", 1, mrb_fixnum_value(1));
 }
 
-#define SQRT_INT_MAX ((SIGNED_VALUE)1<<((sizeof(mrb_int)*CHAR_BIT-1)/2))
+#define SQRT_INT_MAX ((mrb_int)1<<((sizeof(mrb_int)*CHAR_BIT-1)/2))
 /*tests if N*N would overflow*/
 #define FIT_SQRT_INT(n) (((n)<SQRT_INT_MAX)&&((n)>=-SQRT_INT_MAX))
 
-- 
cgit v1.2.3


From 6919ca61edb2da9ea81217fdc355eef1208a6398 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 13 Jun 2012 23:16:53 +0900
Subject: stop using strtol (via readint) except in load.c; use custom
 readint_float

---
 include/mrbconf.h |  1 -
 src/codegen.c     | 19 +++++++++++--------
 src/load.c        |  2 +-
 3 files changed, 12 insertions(+), 10 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index f2b23258e..5848eee1a 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -19,7 +19,6 @@ typedef double mrb_float;
 
 typedef int mrb_int;
 typedef intptr_t mrb_sym;
-#define readint(p,base) strtol((p),NULL,(base))
 
 #undef  PARSER_DUMP        /* do not print out parser state */
 //#define PARSER_DUMP        /* print out parser state */
diff --git a/src/codegen.c b/src/codegen.c
index 5f8d17314..63531eac1 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -1575,16 +1575,18 @@ codegen(codegen_scope *s, node *tree, int val)
     if (val) {
       char *p = (char*)tree->car;
       int base = (intptr_t)tree->cdr->car;
-      long i = readint(p, base);
+      mrb_float f;
+      mrb_int i;
       mrb_code co;
 
-      if ((i == LONG_MAX && errno == ERANGE) || !FIXABLE(i)) {
-	mrb_float f = readint_float(s, p, base);
+      f = readint_float(s, p, base);
+      if (!FIXABLE(f)) {
 	int off = new_lit(s, mrb_float_value(f));
 
 	genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
       }
       else {
+	i = (mrb_int)f;
 	if (i < MAXARG_sBx && i > -MAXARG_sBx) {
 	  co = MKOP_AsBx(OP_LOADI, cursp(), i);
 	}
@@ -1629,17 +1631,18 @@ codegen(codegen_scope *s, node *tree, int val)
         {
           char *p = (char*)tree->car;
           int base = (intptr_t)tree->cdr->car;
-          long i = readint(p, base);
+	  mrb_float f;
+          mrb_int i;
           mrb_code co;
 
-	  if ((i == LONG_MAX && errno == ERANGE) || !FIXABLE(i)) {
-	    mrb_float f = readint_float(s, p, base);
+	  f = readint_float(s, p, base);
+	  if (!FIXABLE(f)) {
 	    int off = new_lit(s, mrb_float_value(-f));
-
+	    
 	    genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
 	  }
 	  else {
-	    i = -i;
+	    i = (mrb_int)-f;
 	    if (i < MAXARG_sBx && i > -MAXARG_sBx) {
 	      co = MKOP_AsBx(OP_LOADI, cursp(), i);
 	    }
diff --git a/src/load.c b/src/load.c
index 1b607909c..053ec2d7e 100644
--- a/src/load.c
+++ b/src/load.c
@@ -413,7 +413,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
 
       switch (tt) {                           //pool data
       case MRB_TT_FIXNUM:
-        fix_num = readint(buf, 10);
+        fix_num = strtol(buf, NULL, 10);
         irep->pool[i] = mrb_fixnum_value(fix_num);
         break;
 
-- 
cgit v1.2.3


From 764a791f439bb843838239909d98b26ac90a9e02 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 14 Jun 2012 00:59:35 +0900
Subject: make Math module optional

---
 include/mrbconf.h | 13 ++++++++-----
 src/init.c        |  2 ++
 src/math.c        |  3 +++
 3 files changed, 13 insertions(+), 5 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 5848eee1a..3744c1827 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -20,21 +20,24 @@ typedef double mrb_float;
 typedef int mrb_int;
 typedef intptr_t mrb_sym;
 
-#undef  PARSER_DUMP        /* do not print out parser state */
 //#define PARSER_DUMP        /* print out parser state */
+#undef  PARSER_DUMP        /* do not print out parser state */
 
-#undef  INCLUDE_ENCODING   /* not use encoding classes (ascii only) */
 //#define INCLUDE_ENCODING   /* use UTF-8 encoding classes */
+#undef  INCLUDE_ENCODING   /* not use encoding classes (ascii only) */
 
-#undef  INCLUDE_REGEXP     /* not use regular expression classes */
 //#define INCLUDE_REGEXP     /* use regular expression classes */
+#undef  INCLUDE_REGEXP     /* not use regular expression classes */
 
 #ifdef  INCLUDE_REGEXP
 # define INCLUDE_ENCODING  /* Regexp depends Encoding */
 #endif
 
-//#undef INCLUDE_KERNEL_SPRINTF     /* not use Kernel.sprintf method. */
-#define INCLUDE_KERNEL_SPRINTF     /* not use Kernel.sprintf method. */
+#define INCLUDE_KERNEL_SPRINTF     /* not use Kernel.sprintf method */
+//#undef INCLUDE_KERNEL_SPRINTF     /* not use Kernel.sprintf method */
+
+#define INCLUDE_MATH	/* use (non ISO) Math module */
+//#undef INCLUDE_MATH     /* not use (non ISO) Math module */
 
 #ifdef  MRUBY_DEBUG_BUILD
 # define PARSER_DUMP
diff --git a/src/init.c b/src/init.c
index 17ce24313..1f7d4d364 100644
--- a/src/init.c
+++ b/src/init.c
@@ -57,7 +57,9 @@ mrb_init_core(mrb_state *mrb)
   mrb_init_exception(mrb);
   mrb_init_print(mrb);
   mrb_init_time(mrb);
+#ifdef INCLUDE_MATH
   mrb_init_math(mrb);
+#endif
 
   mrb_init_mrblib(mrb);
 
diff --git a/src/math.c b/src/math.c
index 1de9c0d8f..3898146b6 100644
--- a/src/math.c
+++ b/src/math.c
@@ -5,6 +5,8 @@
 */
 
 #include "mruby.h"
+
+#ifdef INCLUDE_MATH
 #include <math.h>
 
 #define domain_error(msg) \
@@ -679,3 +681,4 @@ mrb_init_math(mrb_state *mrb)
   mrb_define_module_function(mrb, mrb_math, "erf",  math_erf,  ARGS_REQ(1));
   mrb_define_module_function(mrb, mrb_math, "erfc", math_erfc, ARGS_REQ(1));
 }
+#endif	/* INCLUDE_MATH */
-- 
cgit v1.2.3


From 3fb9408669ac44f1e366d764262f65c452d4d907 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Thu, 14 Jun 2012 18:28:05 +0900
Subject: Fix redundant declraration warnings by gcc.

---
 include/mruby.h | 1 -
 src/cdump.c     | 1 -
 src/error.h     | 2 --
 3 files changed, 4 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 167808b14..25fc96b53 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -481,7 +481,6 @@ mrb_value mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass);
 #define xfree       free
 #endif
 
-void mrb_garbage_collect(mrb_state *mrb);
 void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
 void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
diff --git a/src/cdump.c b/src/cdump.c
index f9525d042..4f680d4f3 100644
--- a/src/cdump.c
+++ b/src/cdump.c
@@ -195,7 +195,6 @@ mrb_cdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname)
 
   SOURCE_CODE0("  mrb->irep_len = idx;");
   SOURCE_CODE0("");
-  SOURCE_CODE0("  extern mrb_value mrb_top_self(mrb_state *mrb);");
   SOURCE_CODE0("  mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));");
   SOURCE_CODE0("}");
 
diff --git a/src/error.h b/src/error.h
index babf93a7d..8a86e7d3d 100644
--- a/src/error.h
+++ b/src/error.h
@@ -12,13 +12,11 @@ struct RException {
 };
 
 void mrb_sys_fail(mrb_state *mrb, const char *mesg);
-void mrb_exc_raise(mrb_state *mrb, mrb_value mesg);
 void mrb_bug_errno(const char*, int);
 int sysexit_status(mrb_state *mrb, mrb_value err);
 void error_pos(void);
 mrb_value mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str);
 mrb_value make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr);
-mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len);
 mrb_value mrb_make_exception(mrb_state *mrb, int argc, mrb_value *argv);
 mrb_value mrb_sprintf(mrb_state *mrb, const char *fmt, ...);
 void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...);
-- 
cgit v1.2.3


From 195d1dd685124edf93735a751f8ec34a7bfe76c0 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 15 Jun 2012 14:03:02 +0900
Subject: do not use fixed sized buffer in mrb_bug/mrb_warn; close #287

---
 include/mruby.h |  1 -
 src/error.c     | 12 +++++-------
 2 files changed, 5 insertions(+), 8 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 25fc96b53..94fb44ad2 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -428,7 +428,6 @@ int mrb_block_given_p(void);
 void mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
 void rb_raise(struct RClass *c, const char *fmt, ...);
 void mrb_warn(const char *fmt, ...);
-void mrb_warning(const char *fmt, ...);
 void mrb_bug(const char *fmt, ...);
 
 #define E_TYPE_ERROR                (mrb_class_obj_get(mrb, "TypeError"))
diff --git a/src/error.c b/src/error.c
index 590fad5a5..3ef08a631 100644
--- a/src/error.c
+++ b/src/error.c
@@ -229,25 +229,23 @@ void
 mrb_warn(const char *fmt, ...)
 {
   va_list args;
-  char buf[256];
 
   va_start(args, fmt);
-  snprintf(buf, 256, "warning: %s", fmt);
-  printf(buf, args);
+  printf("warning: ");
+  vprintf(fmt, args);
   va_end(args);
 }
 
-
 void
 mrb_bug(const char *fmt, ...)
 {
   va_list args;
-  char buf[256];
 
   va_start(args, fmt);
-  snprintf(buf, 256, "bug: %s", fmt);
-  printf(buf, args);
+  printf("bug: ");
+  vprintf(fmt, args);
   va_end(args);
+  exit(EXIT_FAILURE);
 }
 
 static const char *
-- 
cgit v1.2.3


From 9e78fea7b3d2d0cb99d57913885fa48dc6843d09 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 15 Jun 2012 14:04:25 +0900
Subject: remove unreference Error class macros

---
 include/mruby.h | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 94fb44ad2..ef742cef4 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -438,13 +438,9 @@ void mrb_bug(const char *fmt, ...);
 #define E_NOMETHOD_ERROR            (mrb_class_obj_get(mrb, "NoMethodError"))
 #define E_SCRIPT_ERROR              (mrb_class_obj_get(mrb, "ScriptError"))
 #define E_SYNTAX_ERROR              (mrb_class_obj_get(mrb, "SyntaxError"))
-#define E_LOAD_ERROR                (mrb_class_obj_get(mrb, "LoadError"))
-#define E_SYSTEMCALL_ERROR          (mrb_class_obj_get(mrb, "SystemCallError"))
 #define E_LOCALJUMP_ERROR           (mrb_class_obj_get(mrb, "LocalJumpError"))
 #define E_REGEXP_ERROR              (mrb_class_obj_get(mrb, "RegexpError"))
-#define E_ZERODIVISION_ERROR        (mrb_class_obj_get(mrb, "ZeroDivisionError"))
 
-#define E_ENCODING_ERROR            (mrb_class_obj_get(mrb, "EncodingError"))
 #define E_NOTIMP_ERROR              (mrb_class_obj_get(mrb, "NotImplementedError"))
 #define E_FLOATDOMAIN_ERROR         (mrb_class_obj_get(mrb, "FloatDomainError"))
 
-- 
cgit v1.2.3


From 8c838de4a83956fec100e2da8dc4f49c4ace6298 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 15 Jun 2012 14:07:24 +0900
Subject: Time class made optinal

---
 include/mrbconf.h | 3 +++
 src/init.c        | 2 ++
 src/time.c        | 3 +++
 3 files changed, 8 insertions(+)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 3744c1827..f4f3ccaef 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -39,6 +39,9 @@ typedef intptr_t mrb_sym;
 #define INCLUDE_MATH	/* use (non ISO) Math module */
 //#undef INCLUDE_MATH     /* not use (non ISO) Math module */
 
+#define INCLUDE_TIME	/* use Time module */
+//#undef INCLUDE_TIME     /* not use Time module */
+
 #ifdef  MRUBY_DEBUG_BUILD
 # define PARSER_DUMP
 #endif
diff --git a/src/init.c b/src/init.c
index 1f7d4d364..13b074fd1 100644
--- a/src/init.c
+++ b/src/init.c
@@ -56,7 +56,9 @@ mrb_init_core(mrb_state *mrb)
 #endif
   mrb_init_exception(mrb);
   mrb_init_print(mrb);
+#ifdef INCLUDE_TIME
   mrb_init_time(mrb);
+#endif
 #ifdef INCLUDE_MATH
   mrb_init_math(mrb);
 #endif
diff --git a/src/time.c b/src/time.c
index 862ff57a9..1acde8ed9 100644
--- a/src/time.c
+++ b/src/time.c
@@ -6,6 +6,7 @@
 
 
 #include "mruby.h"
+#ifdef INCLUDE_TIME
 #include <string.h>
 #include <stdio.h>
 #include <time.h>
@@ -742,3 +743,5 @@ mrb_init_time(mrb_state *mrb)
       utc_offset(15.2.19.7.29)
   */
 }
+#endif
+
-- 
cgit v1.2.3


From 76f7aecff326666543d9bac31fe13e0cab8e05f4 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 15 Jun 2012 15:34:49 +0900
Subject: use ENABLE/DISABLE instead of INCLUDE for configuration macro names

---
 include/mrbconf.h     | 50 ++++++++++++++++----------------
 include/mruby/class.h |  9 +-----
 src/dump.c            |  6 ++--
 src/gc.c              |  8 +++---
 src/init.c            |  6 ++--
 src/load.c            |  4 +--
 src/math.c            |  4 +--
 src/parse.y           |  6 ----
 src/re.c              |  8 +++---
 src/regcomp.c         |  8 +++---
 src/regerror.c        |  4 +--
 src/regexec.c         |  4 +--
 src/regparse.c        |  8 +++---
 src/string.c          | 80 +++++++++++++++++++++++++--------------------------
 src/struct.c          |  2 +-
 src/time.c            |  3 +-
 src/variable.c        |  2 +-
 17 files changed, 98 insertions(+), 114 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index f4f3ccaef..4b778e6de 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -8,8 +8,21 @@
 #define MRUBYCONF_H
 
 #include <stdint.h>
+
+/* configuration options: */
+/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
 #undef MRB_USE_FLOAT
 
+/* -DDISABLE_XXXX to change to drop the feature */
+#define DISABLE_REGEXP	        /* regular expression classes */
+#undef DISABLE_KERNEL_SPRINTF	/* Kernel.sprintf method */
+#undef DISABLE_MATH		/* Math functions */
+#undef DISABLE_TIME		/* Time class */
+
+#undef  HAVE_UNISTD_H /* WINDOWS */
+#define HAVE_UNISTD_H /* LINUX */
+/* end of configuration */
+
 #ifdef MRB_USE_FLOAT
 typedef float mrb_float;
 #else
@@ -20,34 +33,19 @@ typedef double mrb_float;
 typedef int mrb_int;
 typedef intptr_t mrb_sym;
 
-//#define PARSER_DUMP        /* print out parser state */
-#undef  PARSER_DUMP        /* do not print out parser state */
-
-//#define INCLUDE_ENCODING   /* use UTF-8 encoding classes */
-#undef  INCLUDE_ENCODING   /* not use encoding classes (ascii only) */
-
-//#define INCLUDE_REGEXP     /* use regular expression classes */
-#undef  INCLUDE_REGEXP     /* not use regular expression classes */
-
-#ifdef  INCLUDE_REGEXP
-# define INCLUDE_ENCODING  /* Regexp depends Encoding */
+/* define ENABLE_XXXX from DISABLE_XXX */
+#ifndef DISABLE_REGEXP
+#define ENABLE_REGEXP
 #endif
-
-#define INCLUDE_KERNEL_SPRINTF     /* not use Kernel.sprintf method */
-//#undef INCLUDE_KERNEL_SPRINTF     /* not use Kernel.sprintf method */
-
-#define INCLUDE_MATH	/* use (non ISO) Math module */
-//#undef INCLUDE_MATH     /* not use (non ISO) Math module */
-
-#define INCLUDE_TIME	/* use Time module */
-//#undef INCLUDE_TIME     /* not use Time module */
-
-#ifdef  MRUBY_DEBUG_BUILD
-# define PARSER_DUMP
+#ifndef DISABLE_KERNEL_SPRINTF
+#define ENABLE_KERNEL_SPRINTF
+#endif
+#ifndef DISABLE_MATH
+#define ENABLE_MATH
+#endif
+#ifndef DISABLE_TIME
+#define ENABLE_TIME
 #endif
-
-#undef  HAVE_UNISTD_H /* WINDOWS */
-#define HAVE_UNISTD_H /* LINUX */
 
 #ifndef FALSE
 # define FALSE 0
diff --git a/include/mruby/class.h b/include/mruby/class.h
index 35dd0ec1d..2cc90310e 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -40,14 +40,7 @@ mrb_class(mrb_state *mrb, mrb_value v)
   case MRB_TT_FLOAT:
     return mrb->float_class;
 
-#ifdef INCLUDE_REGEXP
-//  case MRB_TT_REGEX:
-//    return mrb->regex_class;
-//  case MRB_TT_MATCH:
-//    return mrb->match_class;
-//  case MRB_TT_DATA:
-//    return mrb->encode_class;
-#else
+#ifdef ENABLE_REGEXP
   case MRB_TT_REGEX:
   case MRB_TT_MATCH:
     mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given",
diff --git a/src/dump.c b/src/dump.c
index 7b2199a02..daf2868f1 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -8,7 +8,7 @@
 #include "mruby/dump.h"
 
 #include "mruby/string.h"
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include "re.h"
 #endif
 #include "mruby/irep.h"
@@ -237,7 +237,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type)
       nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
       size += nlen;
       break;
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
     case MRB_TT_REGEX:
       str = mrb_reg_to_s(mrb, irep->pool[pool_no]);
       nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
@@ -365,7 +365,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
       str_dump(RSTRING_PTR(str), char_buf, RSTRING_LEN(str), type);
       break;
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
     case MRB_TT_REGEX:
       str = mrb_reg_to_s(mrb, irep->pool[pool_no]);
       nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
diff --git a/src/gc.c b/src/gc.c
index 1b4b3eed4..c07c9b13b 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -71,7 +71,7 @@
 
 */
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include "re.h"
 #endif
 
@@ -92,7 +92,7 @@ typedef struct {
     struct RRange range;
     struct RStruct structdata;
     struct RProc procdata;
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
     struct RMatch match;
     struct RRegexp regexp;
 #endif
@@ -412,7 +412,7 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj)
     }
     break;
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
   case MRB_TT_MATCH:
     {
       struct RMatch *m = (struct RMatch*)obj;
@@ -611,7 +611,7 @@ gc_gray_mark(mrb_state *mrb, struct RBasic *obj)
     children+=2;
     break;
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
   case MRB_TT_MATCH:
     children+=2;
     break;
diff --git a/src/init.c b/src/init.c
index 351874b32..a515ee880 100644
--- a/src/init.c
+++ b/src/init.c
@@ -51,15 +51,15 @@ mrb_init_core(mrb_state *mrb)
   mrb_init_range(mrb);
   mrb_init_struct(mrb);
   mrb_init_gc(mrb);
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
   mrb_init_regexp(mrb);
 #endif
   mrb_init_exception(mrb);
   mrb_init_print(mrb);
-#ifdef INCLUDE_TIME
+#ifdef ENABLE_TIME
   mrb_init_time(mrb);
 #endif
-#ifdef INCLUDE_MATH
+#ifdef ENABLE_MATH
   mrb_init_math(mrb);
 #endif
 
diff --git a/src/load.c b/src/load.c
index 1f853df00..d3766da9d 100644
--- a/src/load.c
+++ b/src/load.c
@@ -8,7 +8,7 @@
 #include "mruby/dump.h"
 
 #include "mruby/string.h"
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include "re.h"
 #endif
 #include "mruby/irep.h"
@@ -418,7 +418,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
         irep->pool[i] = mrb_str_new(mrb, buf, pdl);
         break;
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
       case MRB_TT_REGEX:
         str = mrb_str_new(mrb, buf, pdl);
         irep->pool[i] = mrb_reg_quote(mrb, str);
diff --git a/src/math.c b/src/math.c
index f3a2dc12c..cf9a20489 100644
--- a/src/math.c
+++ b/src/math.c
@@ -6,7 +6,7 @@
 
 #include "mruby.h"
 
-#ifdef INCLUDE_MATH
+#ifdef ENABLE_MATH
 #include <math.h>
 
 #define domain_error(msg) \
@@ -681,4 +681,4 @@ mrb_init_math(mrb_state *mrb)
   mrb_define_module_function(mrb, mrb_math, "erf",  math_erf,  ARGS_REQ(1));
   mrb_define_module_function(mrb, mrb_math, "erfc", math_erfc, ARGS_REQ(1));
 }
-#endif	/* INCLUDE_MATH */
+#endif	/* ENABLE_MATH */
diff --git a/src/parse.y b/src/parse.y
index 5e44dd85a..b7eaaa4e4 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4776,9 +4776,6 @@ mrb_compile_file(mrb_state * mrb, FILE *f)
   if (!p) return -1;
   if (!p->tree) return -1;
   if (p->nerr) return -1;
-#ifdef PARSER_DUMP
-  parser_dump(mrb, p->tree, 0);
-#endif
   n = mrb_generate_code(mrb, p->tree);
   mrb_pool_close(p->pool);
 
@@ -4795,9 +4792,6 @@ mrb_compile_nstring(mrb_state *mrb, char *s, size_t len)
   if (!p) return -1;
   if (!p->tree) return -1;
   if (p->nerr) return -1;
-#ifdef PARSER_DUMP
-  parser_dump(mrb, p->tree, 0);
-#endif
   n = mrb_generate_code(mrb, p->tree);
   mrb_pool_close(p->pool);
 
diff --git a/src/re.c b/src/re.c
index b4134c81c..17b4f3da7 100644
--- a/src/re.c
+++ b/src/re.c
@@ -13,7 +13,7 @@
 #include "regint.h"
 #include "mruby/class.h"
 #include "error.h"
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 
 #define REGEX_CLASS (mrb_class_obj_get(mrb, "Regexp"))
 #define MATCH_CLASS (mrb_class_obj_get(mrb, "MatchData"))
@@ -2318,7 +2318,7 @@ mrb_backref_set(mrb_state *mrb, mrb_value val)
 {
   vm_svar_set(mrb, 1, val);
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 #ifdef INCLUDE_ENCODING
 static inline long
@@ -2421,7 +2421,7 @@ mrb_memsearch(mrb_state *mrb, const void *x0, int m, const void *y0, int n, mrb_
 }
 #endif //INCLUDE_ENCODING
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 mrb_value
 mrb_reg_init_str(mrb_state *mrb, mrb_value re, mrb_value s, int options)
 {
@@ -2469,7 +2469,7 @@ re_adjust_startpos(struct re_pattern_buffer *bufp, const char *string, int size,
   }*/
   return startpos;
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 #ifdef INCLUDE_ENCODING
 static const unsigned char mbctab_ascii[] = {
diff --git a/src/regcomp.c b/src/regcomp.c
index 523124b26..b8c652999 100644
--- a/src/regcomp.c
+++ b/src/regcomp.c
@@ -30,7 +30,7 @@
 #include "mruby.h"
 #include <string.h>
 #include "regparse.h"
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 
 OnigCaseFoldType OnigDefaultCaseFoldFlag = ONIGENC_CASE_FOLD_MIN;
 
@@ -5628,7 +5628,7 @@ onig_end(void)
   THREAD_SYSTEM_END;
   return 0;
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 #ifdef INCLUDE_ENCODING
 extern int
@@ -5653,7 +5653,7 @@ onig_is_in_code_range(const UChar* p, OnigCodePoint code)
 }
 #endif //INCLUDE_ENCODING
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 extern int
 onig_is_code_in_cc_len(int elen, OnigCodePoint code, CClassNode* cc)
 {
@@ -6285,4 +6285,4 @@ print_tree(FILE* f, Node* node)
   print_indent_tree(f, node, 0);
 }
 #endif
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
diff --git a/src/regerror.c b/src/regerror.c
index 2ba879f78..df60b49cc 100644
--- a/src/regerror.c
+++ b/src/regerror.c
@@ -28,7 +28,7 @@
  */
 
 #include "mruby.h"
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include <string.h>
 #include "regint.h"
 #include <stdio.h> /* for vsnprintf() */
@@ -372,4 +372,4 @@ onig_snprintf_with_pattern(UChar buf[], int bufsize, OnigEncoding enc,
           pat, pat_end, fmt, args);
   va_end(args);
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
diff --git a/src/regexec.c b/src/regexec.c
index 4d8950b73..d265cc803 100644
--- a/src/regexec.c
+++ b/src/regexec.c
@@ -28,7 +28,7 @@
  */
 
 #include "mruby.h"
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include <string.h>
 #include "regint.h"
 
@@ -3754,4 +3754,4 @@ onig_copy_encoding(OnigEncoding to, OnigEncoding from)
 {
   *to = *from;
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
diff --git a/src/regparse.c b/src/regparse.c
index 509740ac3..f7bb23306 100644
--- a/src/regparse.c
+++ b/src/regparse.c
@@ -32,7 +32,7 @@
 #include <string.h>
 #include "regparse.h"
 #include <stdarg.h>
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 
 #define WARN_BUFSIZE    256
 
@@ -298,7 +298,7 @@ strcat_capa_from_static(UChar* dest, UChar* dest_end,
   onig_strcpy(r + (dest_end - dest), src, src_end);
   return r;
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 #ifdef INCLUDE_ENCODING
 #ifdef USE_ST_LIBRARY
@@ -393,7 +393,7 @@ onig_st_insert_strend(hash_table_type* table, const UChar* str_key,
 #endif /* USE_ST_LIBRARY */
 #endif //INCLUDE_ENCODING
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #ifdef USE_NAMED_GROUP
 
 #define INIT_NAME_BACKREFS_ALLOC_NUM   8
@@ -5597,4 +5597,4 @@ onig_scan_env_set_error_string(ScanEnv* env, int ecode ARG_UNUSED,
   env->error     = arg;
   env->error_end = arg_end;
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
diff --git a/src/string.c b/src/string.c
index a9e155c72..566c056cf 100644
--- a/src/string.c
+++ b/src/string.c
@@ -17,10 +17,10 @@
 #include "mruby/variable.h"
 #include <stdio.h>
 #include "re.h"
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include "regex.h"
 #include "st.h"
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 #ifndef FALSE
 #define FALSE   0
@@ -32,9 +32,9 @@
 
 const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 static mrb_value get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote);
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2);
 static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len);
 
@@ -743,12 +743,12 @@ num_index:
       return str;
 
     case MRB_TT_REGEX:
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
       return mrb_str_subpat(mrb, str, indx, 0); //mrb_str_subpat(str, indx, INT2FIX(0));
 #else
       mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");
       return mrb_nil_value();
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
     case MRB_TT_STRING:
       if (mrb_str_index(mrb, str, indx, 0) != -1)
@@ -835,12 +835,12 @@ mrb_str_aref_m(mrb_state *mrb, mrb_value str)
   argc = mrb_get_args(mrb, "o|o", &a1, &a2);
   if (argc == 2) {
     if (mrb_type(a1) == MRB_TT_REGEX) {
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
       return mrb_str_subpat(mrb, str, argv[0], mrb_fixnum(argv[1]));
 #else
       mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");
       return mrb_nil_value();
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
     }
     return mrb_str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2));
   }
@@ -1246,7 +1246,7 @@ mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2)
   return str;
 }
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 static mrb_value
 str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang)
 {
@@ -1383,7 +1383,7 @@ mrb_str_gsub_bang(mrb_state *mrb, mrb_value self)
   str_modify(mrb, s);
   return str_gsub(mrb, s, 1);
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 mrb_int
 mrb_str_hash(mrb_state *mrb, mrb_value str)
@@ -1506,7 +1506,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
 
   switch (mrb_type(sub)) {
     case MRB_TT_REGEX:
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
       if (pos > RSTRING_LEN(str))
         return mrb_nil_value();
       pos = mrb_str_offset(mrb, str, pos);
@@ -1514,7 +1514,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
       pos = mrb_str_sublen(mrb, str, pos);
 #else
       mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
       break;
 
     case MRB_TT_FIXNUM: {
@@ -1668,7 +1668,7 @@ mrb_check_string_type(mrb_state *mrb, mrb_value str)
   return mrb_check_convert_type(mrb, str, MRB_TT_STRING, "String", "to_str");
 }
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 static mrb_value
 get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote)
 {
@@ -1696,7 +1696,7 @@ get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote)
 
   return mrb_reg_regcomp(mrb, pat);
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 /* 15.2.10.5.27 */
 /*
@@ -1711,7 +1711,7 @@ get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote)
  *     'hello'.match(/(.)\1/)[0]   #=> "ll"
  *     'hello'.match('xx')         #=> nil
  */
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 static mrb_value
 mrb_str_match_m(mrb_state *mrb, mrb_value self)
 {
@@ -1731,7 +1731,7 @@ mrb_str_match_m(mrb_state *mrb, mrb_value self)
   }
   return result;
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 /* ---------------------------------- */
 /* 15.2.10.5.29 */
@@ -1883,11 +1883,11 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
       pos += len;
       if (pos < 0) {
         if (mrb_type(sub) == MRB_TT_REGEX) {
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
           mrb_backref_set(mrb, mrb_nil_value());
 #else
           mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
         }
         return mrb_nil_value();
       }
@@ -1904,7 +1904,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
 
   switch (mrb_type(sub)) {
     case MRB_TT_REGEX:
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
       pos = mrb_str_offset(mrb, str, pos);
       if (!RREGEXP(sub)->ptr || RREGEXP_SRC_LEN(sub)) {
         pos = mrb_reg_search(mrb, sub, str, pos, 1);
@@ -1913,7 +1913,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
       if (pos >= 0) return mrb_fixnum_value(pos);
 #else
       mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
       break;
 
     case MRB_TT_FIXNUM: {
@@ -1947,7 +1947,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
   return mrb_nil_value();
 }
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 static mrb_value
 scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start)
 {
@@ -1986,7 +1986,7 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start)
   }
   return mrb_nil_value();
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 /* 15.2.10.5.32 */
 /*
@@ -2019,7 +2019,7 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start)
  *     <<cruel>> <<world>>
  *     rceu lowlr
  */
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 static mrb_value
 mrb_str_scan(mrb_state *mrb, mrb_value str)
 {
@@ -2053,7 +2053,7 @@ mrb_str_scan(mrb_state *mrb, mrb_value str)
   mrb_backref_set(mrb, match);
   return str;
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 static const char isspacetable[256] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
@@ -2146,28 +2146,28 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
 //fs_set:
     if (mrb_type(spat) == MRB_TT_STRING) {
       split_type = string;
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
       if (RSTRING_LEN(spat) == 0) {
         /* Special case - split into chars */
         spat = mrb_reg_regcomp(mrb, spat);
         split_type = regexp;
       }
       else {
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
         if (RSTRING_LEN(spat) == 1 && RSTRING_PTR(spat)[0] == ' '){
             split_type = awk;
         }
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
       }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
     }
     else {
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
       spat = get_pat(mrb, spat, 1);
       split_type = regexp;
 #else
       mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
     }
   }
 
@@ -2230,7 +2230,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
     beg = ptr - temp;
   }
   else {
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
     char *ptr = RSTRING_PTR(str);
     long len = RSTRING_LEN(str);
     long start = beg;
@@ -2276,7 +2276,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
     }
 #else
     mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
   }
   if (RSTRING_LEN(str) > 0 && (lim >= 0 || RSTRING_LEN(str) > beg || lim < 0)) {
     if (RSTRING_LEN(str) == beg)
@@ -2314,14 +2314,14 @@ mrb_block_given_p()
  *  returning <i>str</i>, or <code>nil</code> if no substitutions were
  *  performed.
  */
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 static mrb_value
 mrb_str_sub_bang(mrb_state *mrb, mrb_value str)
 {
   str_modify(mrb, str);
   return mrb_nil_value();
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 /* 15.2.10.5.36 */
 
@@ -2362,7 +2362,7 @@ mrb_str_sub_bang(mrb_state *mrb, mrb_value str)
  *      #=> "Is /bin/bash your preferred shell?"
  */
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 static mrb_value
 mrb_str_sub(mrb_state *mrb, mrb_value self)
 {
@@ -2371,7 +2371,7 @@ mrb_str_sub(mrb_state *mrb, mrb_value self)
   mrb_str_sub_bang(mrb, str);
   return str;
 }
-#endif //INCLUDE_REGEXP
+#endif //ENABLE_REGEXP
 
 mrb_value
 mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
@@ -3030,7 +3030,7 @@ mrb_init_string(mrb_state *mrb)
   mrb_define_method(mrb, s, "each_line",       mrb_str_each_line,       ARGS_REQ(1));              /* 15.2.10.5.15 */
   mrb_define_method(mrb, s, "empty?",          mrb_str_empty_p,         ARGS_NONE());              /* 15.2.10.5.16 */
   mrb_define_method(mrb, s, "eql?",            mrb_str_eql,             ARGS_REQ(1));              /* 15.2.10.5.17 */
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
   mrb_define_method(mrb, s, "gsub",            mrb_str_gsub,            ARGS_REQ(1));              /* 15.2.10.5.18 */
   mrb_define_method(mrb, s, "gsub!",           mrb_str_gsub_bang,       ARGS_REQ(1));              /* 15.2.10.5.19 */
 #endif
@@ -3040,19 +3040,19 @@ mrb_init_string(mrb_state *mrb)
   mrb_define_method(mrb, s, "initialize",      mrb_str_init,            ARGS_REQ(1));              /* 15.2.10.5.23 */
   mrb_define_method(mrb, s, "initialize_copy", mrb_str_replace,         ARGS_REQ(1));              /* 15.2.10.5.24 */
   mrb_define_method(mrb, s, "intern",          mrb_str_intern,          ARGS_NONE());              /* 15.2.10.5.25 */
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
   mrb_define_method(mrb, s, "match",           mrb_str_match_m,         ARGS_REQ(1));              /* 15.2.10.5.27 */
 #endif
   mrb_define_method(mrb, s, "replace",         mrb_str_replace,         ARGS_REQ(1));              /* 15.2.10.5.28 */
   mrb_define_method(mrb, s, "reverse",         mrb_str_reverse,         ARGS_NONE());              /* 15.2.10.5.29 */
   mrb_define_method(mrb, s, "reverse!",        mrb_str_reverse_bang,    ARGS_NONE());              /* 15.2.10.5.30 */
   mrb_define_method(mrb, s, "rindex",          mrb_str_rindex_m,        ARGS_ANY());               /* 15.2.10.5.31 */
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
   mrb_define_method(mrb, s, "scan",            mrb_str_scan,            ARGS_REQ(1));              /* 15.2.10.5.32 */
 #endif
   mrb_define_method(mrb, s, "slice",           mrb_str_aref_m,          ARGS_ANY());               /* 15.2.10.5.34 */
   mrb_define_method(mrb, s, "split",           mrb_str_split_m,         ARGS_ANY());               /* 15.2.10.5.35 */
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
   mrb_define_method(mrb, s, "sub",             mrb_str_sub,             ARGS_REQ(1));              /* 15.2.10.5.36 */
   mrb_define_method(mrb, s, "sub!",            mrb_str_sub_bang,        ARGS_REQ(1));              /* 15.2.10.5.37 */
 #endif
diff --git a/src/struct.c b/src/struct.c
index 2e2e0c10f..5d759776f 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -12,7 +12,7 @@
 #include <stdarg.h>
 //#include "defines.h"
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include "encoding.h"
 #endif
 
diff --git a/src/time.c b/src/time.c
index 1acde8ed9..55060729b 100644
--- a/src/time.c
+++ b/src/time.c
@@ -6,7 +6,7 @@
 
 
 #include "mruby.h"
-#ifdef INCLUDE_TIME
+#ifdef ENABLE_TIME
 #include <string.h>
 #include <stdio.h>
 #include <time.h>
@@ -744,4 +744,3 @@ mrb_init_time(mrb_state *mrb)
   */
 }
 #endif
-
diff --git a/src/variable.c b/src/variable.c
index 47029da28..b11143b02 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -14,7 +14,7 @@
 #include "error.h"
 #include "mruby/array.h"
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include "re.h"
 #include "st.h"
 #endif
-- 
cgit v1.2.3


From ede3049f33f8c6cdb703784619fb4143bfe3b441 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 17 Jun 2012 23:36:34 +0900
Subject: allow disabling Struct class

---
 include/mrbconf.h | 4 ++++
 src/init.c        | 2 ++
 src/struct.c      | 2 ++
 3 files changed, 8 insertions(+)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 4b778e6de..21b8fea18 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -18,6 +18,7 @@
 #undef DISABLE_KERNEL_SPRINTF	/* Kernel.sprintf method */
 #undef DISABLE_MATH		/* Math functions */
 #undef DISABLE_TIME		/* Time class */
+#undef DISABLE_STRUCT		/* Struct class */
 
 #undef  HAVE_UNISTD_H /* WINDOWS */
 #define HAVE_UNISTD_H /* LINUX */
@@ -46,6 +47,9 @@ typedef intptr_t mrb_sym;
 #ifndef DISABLE_TIME
 #define ENABLE_TIME
 #endif
+#ifndef DISABLE_STRUCT
+#define ENABLE_STRUCT
+#endif
 
 #ifndef FALSE
 # define FALSE 0
diff --git a/src/init.c b/src/init.c
index a515ee880..e2ab62339 100644
--- a/src/init.c
+++ b/src/init.c
@@ -49,7 +49,9 @@ mrb_init_core(mrb_state *mrb)
   mrb_init_hash(mrb);
   mrb_init_numeric(mrb);
   mrb_init_range(mrb);
+#ifdef ENABLE_STRUCT
   mrb_init_struct(mrb);
+#endif
   mrb_init_gc(mrb);
 #ifdef ENABLE_REGEXP
   mrb_init_regexp(mrb);
diff --git a/src/struct.c b/src/struct.c
index 8e9804cbc..c0af85d0e 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -5,6 +5,7 @@
 */
 
 #include "mruby.h"
+#ifdef ENABLE_STRUCT
 #include <string.h>
 #include "error.h"
 #include "mruby/struct.h"
@@ -793,3 +794,4 @@ mrb_init_struct(mrb_state *mrb)
   mrb_define_method(mrb, st,       "eql?",            mrb_struct_eql,         ARGS_REQ(1)); /* 15.2.18.4.12(x)  */
 
 }
+#endif	/* ENABLE_STRUCT */
-- 
cgit v1.2.3


From cd68190480785430b8e350d9a5d2127ab04e1074 Mon Sep 17 00:00:00 2001
From: crimsonwoods <crimsonwoods@gmail.com>
Date: Tue, 19 Jun 2012 23:00:29 +0900
Subject: split declaration and definition for 'khash_xxx'.

---
 include/mruby/khash.h | 63 +++++++++++++++++++++++++++++++++------------------
 src/class.c           |  3 ---
 src/hash.c            |  3 ++-
 src/kernel.c          |  3 ---
 src/khash.c           |  5 ++++
 src/symbol.c          |  3 ++-
 src/variable.c        |  2 --
 7 files changed, 50 insertions(+), 32 deletions(-)
 create mode 100644 src/khash.c

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index 22df48ebb..6cb2b383d 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -32,16 +32,14 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
 #define __ac_iseither(e_flag, d_flag, i) (__ac_isempty(e_flag,d_flag,i)||__ac_isdel(e_flag,d_flag,i))
 
 
-/* struct kh_xxx
+/* declare struct kh_xxx and kh_xxx_funcs
 
    name: ash name
    khkey_t: key data type
    khval_t: value data type
    kh_is_map: (not implemented / not used in RiteVM )
-   __hash_func: hash function
-   __hash_equal: hash comparation function
 */
-#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+#define KHASH_DECLARE(name, khkey_t, khval_t, kh_is_map)                \
   typedef struct kh_##name {                                            \
     khint_t n_buckets;                                                  \
     khint_t size;                                                       \
@@ -55,7 +53,26 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     khint_t inc;                                                        \
     mrb_state *mrb;                                                     \
   } kh_##name##_t;                                                      \
-  static void kh_alloc_##name(kh_##name##_t *h)                         \
+  void kh_alloc_##name(kh_##name##_t *h);                               \
+  kh_##name##_t *kh_init_##name(mrb_state *mrb);                        \
+  void kh_destroy_##name(kh_##name##_t *h);                             \
+  void kh_clear_##name(kh_##name##_t *h);                               \
+  khint_t kh_get_##name(kh_##name##_t *h, khkey_t key);                 \
+  khint_t kh_put_##name(kh_##name##_t *h, khkey_t key);                 \
+  void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets);       \
+  void kh_del_##name(kh_##name##_t *h, khint_t x);                      \
+
+/* define kh_xxx_funcs
+
+   name: ash name
+   khkey_t: key data type
+   khval_t: value data type
+   kh_is_map: (not implemented / not used in RiteVM )
+   __hash_func: hash function
+   __hash_equal: hash comparation function
+*/
+#define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+  void kh_alloc_##name(kh_##name##_t *h)                                \
   {                                                                     \
     khint_t sz = h->n_buckets;                                          \
     h->size = h->n_occupied = 0;                                        \
@@ -69,14 +86,14 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     h->mask = sz-1;                                                     \
     h->inc = sz/2-1;                                                    \
   }                                                                     \
-  static inline kh_##name##_t *kh_init_##name(mrb_state *mrb){          \
+  kh_##name##_t *kh_init_##name(mrb_state *mrb){                        \
     kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
     h->n_buckets = INITIAL_HASH_SIZE;                                   \
     h->mrb = mrb;                                                       \
     kh_alloc_##name(h);                                                 \
     return h;                                                           \
   }                                                                     \
-  static inline void kh_destroy_##name(kh_##name##_t *h)                \
+  void kh_destroy_##name(kh_##name##_t *h)                              \
   {                                                                     \
     if( h ){                                                            \
       mrb_free(h->mrb, h->keys);                                        \
@@ -85,7 +102,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
       mrb_free(h->mrb, h);                                              \
     }                                                                   \
   }                                                                     \
-  static inline void kh_clear_##name(kh_##name##_t *h)                  \
+  void kh_clear_##name(kh_##name##_t *h)                                \
   {                                                                     \
     if( h && h->e_flags ){                                              \
       memset(h->e_flags, 0xff, h->n_buckets/8*sizeof(uint8_t));         \
@@ -93,7 +110,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
       h->size = h->n_occupied = 0;                                      \
     }                                                                   \
   }                                                                     \
-  static inline khint_t kh_get_##name(kh_##name##_t *h, khkey_t key)    \
+  khint_t kh_get_##name(kh_##name##_t *h, khkey_t key)                  \
   {                                                                     \
     khint_t k = __hash_func(h->mrb,key) & (h->mask);                    \
     while( !__ac_isempty(h->e_flags, h->d_flags, k) ){                  \
@@ -104,8 +121,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     }                                                                   \
     return h->n_buckets;                                                \
   }                                                                     \
-  static inline khint_t kh_put_##name(kh_##name##_t *h, khkey_t key);   \
-  static void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \
+  void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets)        \
   {                                                                     \
     if( new_n_buckets<INITIAL_HASH_SIZE ){                              \
       new_n_buckets = INITIAL_HASH_SIZE;                                \
@@ -114,7 +130,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
       new_n_buckets = INITIAL_HASH_SIZE;                                \
       while( new_n_buckets < limit ) new_n_buckets *= 2;                \
     }                                                                   \
-    {					                                \
+    {					                                                \
       uint8_t *old_e_flags = h->e_flags;                                \
       khkey_t *old_keys = h->keys;                                      \
       khval_t *old_vals = h->vals;                                      \
@@ -124,17 +140,17 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
       kh_alloc_##name(h);                                               \
       /* relocate */                                                    \
       for( i=0 ; i<old_n_buckets ; i++ ){                               \
-	if( !__ac_isempty(old_e_flags, old_d_flags, i) ){               \
-	  khint_t k = kh_put_##name(h, old_keys[i]);                    \
-	  kh_value(h,k) = old_vals[i];                                  \
-	}                                                               \
+	if( !__ac_isempty(old_e_flags, old_d_flags, i) ){                   \
+	  khint_t k = kh_put_##name(h, old_keys[i]);                        \
+	  kh_value(h,k) = old_vals[i];                                      \
+	}                                                                   \
       }                                                                 \
       mrb_free(h->mrb, old_e_flags);                                    \
       mrb_free(h->mrb, old_keys);                                       \
       mrb_free(h->mrb, old_vals);                                       \
     }                                                                   \
   }                                                                     \
-  static inline khint_t kh_put_##name(kh_##name##_t *h, khkey_t key)    \
+  khint_t kh_put_##name(kh_##name##_t *h, khkey_t key)                  \
   {                                                                     \
     khint_t k;                                                          \
     if( h->n_occupied >= h->upper_bound ){                              \
@@ -159,12 +175,13 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     }                                                                   \
     return k;                                                           \
   }                                                                     \
-  static inline void kh_del_##name(kh_##name##_t *h, khint_t x)         \
+  void kh_del_##name(kh_##name##_t *h, khint_t x)                       \
   {                                                                     \
     h->d_flags[x/8] |= __m[x%8];                                        \
     h->size--;                                                          \
   }
 
+
 #define khash_t(name) kh_##name##_t
 
 #define kh_init(name,mrb) kh_init_##name(mrb)
@@ -197,11 +214,13 @@ static inline khint_t __ac_X31_hash_string(const char *s)
 #define kh_str_hash_func(mrb,key) __ac_X31_hash_string(key)
 #define kh_str_hash_equal(mrb,a, b) (strcmp(a, b) == 0)
 
-#define KHASH_MAP_INIT_INT(name, khval_t)                               \
-    KHASH_INIT(name, uint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
 typedef const char *kh_cstr_t;
-#define KHASH_MAP_INIT_STR(name, khval_t)                               \
-    KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
+
+/* declare common hash types. */
+#include "mruby.h"
+
+KHASH_DECLARE(mt, mrb_sym,   struct RProc*, 1)
+KHASH_DECLARE(iv, mrb_sym,   mrb_value,     1)
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/src/class.c b/src/class.c
index df02a832a..434ecb037 100644
--- a/src/class.c
+++ b/src/class.c
@@ -17,9 +17,6 @@
 
 #include "mruby/khash.h"
 
-KHASH_INIT(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal)
-KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal)
-
 typedef struct fc_result {
     mrb_sym name;
     struct RClass * klass;
diff --git a/src/hash.c b/src/hash.c
index fe5336dc1..08f906800 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -31,7 +31,8 @@ mrb_hash_ht_hash_equal(mrb_state *mrb, mrb_value a, mrb_value b)
   return mrb_eql(mrb, a, b);
 }
 
-KHASH_INIT(ht, mrb_value, mrb_value, 1, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal);
+KHASH_DECLARE(ht, mrb_value, mrb_value, 1);
+KHASH_DEFINE (ht, mrb_value, mrb_value, 1, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal);
 
 static void mrb_hash_modify(mrb_state *mrb, mrb_value hash);
 
diff --git a/src/kernel.c b/src/kernel.c
index b5bde628a..75c588a81 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -34,9 +34,6 @@ typedef enum {
     NOEX_RESPONDS  = 0x80
 } mrb_method_flag_t;
 
-KHASH_INIT(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal)
-KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal)
-
 struct obj_ivar_tag {
   mrb_value obj;
   int (*func)(mrb_sym key, mrb_value val, void * arg);
diff --git a/src/khash.c b/src/khash.c
new file mode 100644
index 000000000..7ea09cfe7
--- /dev/null
+++ b/src/khash.c
@@ -0,0 +1,5 @@
+#include "mruby/khash.h"
+
+KHASH_DEFINE(mt, mrb_sym,   struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal)
+KHASH_DEFINE(iv, mrb_sym,   mrb_value,     1, kh_int_hash_func, kh_int_hash_equal)
+
diff --git a/src/symbol.c b/src/symbol.c
index b80174e7b..d2ae09655 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -36,7 +36,8 @@ sym_hash_func(mrb_state *mrb, const symbol_name s)
 }
 #define sym_hash_equal(mrb,a, b) (a.len == b.len && memcmp(a.name, b.name, a.len) == 0)
 
-KHASH_INIT(n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal)
+KHASH_DECLARE(n2s, symbol_name, mrb_sym, 1)
+KHASH_DEFINE (n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal)
 /* ------------------------------------------------------ */
 mrb_sym
 mrb_intern2(mrb_state *mrb, const char *name, int len)
diff --git a/src/variable.c b/src/variable.c
index b11143b02..d89e9d6bb 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -19,8 +19,6 @@
 #include "st.h"
 #endif
 
-KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal)
-
 static void
 mark_tbl(mrb_state *mrb, struct kh_iv *h)
 {
-- 
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 'include')

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 396397bce17a0f03eab8ed6512651e665aa89c8a Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 21 Jun 2012 11:04:36 +0900
Subject: move KHASH_DECLARE to header files

---
 include/mruby/khash.h    |  6 ------
 include/mruby/proc.h     |  3 +++
 include/mruby/variable.h |  7 ++++++-
 src/class.c              |  6 ++----
 src/kernel.c             | 37 +++++--------------------------------
 src/variable.c           | 47 ++++++++++++++++++++++++++++++++++++++++++++---
 6 files changed, 60 insertions(+), 46 deletions(-)

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index 6cb2b383d..e236f0bea 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -216,12 +216,6 @@ static inline khint_t __ac_X31_hash_string(const char *s)
 
 typedef const char *kh_cstr_t;
 
-/* declare common hash types. */
-#include "mruby.h"
-
-KHASH_DECLARE(mt, mrb_sym,   struct RProc*, 1)
-KHASH_DECLARE(iv, mrb_sym,   mrb_value,     1)
-
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/proc.h b/include/mruby/proc.h
index 52dc5a98e..8f178790e 100644
--- a/include/mruby/proc.h
+++ b/include/mruby/proc.h
@@ -50,6 +50,9 @@ struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
 struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
 struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
 
+#include "mruby/khash.h"
+KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index fb686fd47..440c4cc8b 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -20,6 +20,7 @@ typedef struct global_variable {
     //int block_trace;
     //struct trace_var *trace;
 } global_variable;
+
 struct global_entry {
     global_variable *var;
     mrb_sym id;
@@ -41,7 +42,8 @@ mrb_value mrb_obj_iv_get(mrb_state*, struct RObject*, mrb_sym);
 void mrb_obj_iv_set(mrb_state*, struct RObject*, mrb_sym, mrb_value);
 const char * mrb_class2name(mrb_state *mrb, struct RClass* klass);
 mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym);
-void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v); /* mrb_iv_set */
+void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v);
+mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym);
 void mrb_copy_generic_ivar(mrb_value clone, mrb_value obj);
 int mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id);
 mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
@@ -55,6 +57,9 @@ void mrb_gc_mark_iv(mrb_state*, struct RObject*);
 size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
 void mrb_gc_free_iv(mrb_state*, struct RObject*);
 
+#include "mruby/khash.h"
+KHASH_DECLARE(iv, mrb_sym, mrb_value, 1)
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/src/class.c b/src/class.c
index 72fef70aa..56ab8c06f 100644
--- a/src/class.c
+++ b/src/class.c
@@ -15,7 +15,8 @@
 #include "mruby/array.h"
 #include "error.h"
 
-#include "mruby/khash.h"
+KHASH_DEFINE(iv, mrb_sym, mrb_value,     1, kh_int_hash_func, kh_int_hash_equal);
+KHASH_DEFINE(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal);
 
 typedef struct fc_result {
     mrb_sym name;
@@ -25,9 +26,6 @@ typedef struct fc_result {
     struct fc_result *prev;
 } fcresult_t;
 
-int kiv_lookup(khash_t(iv) *table, mrb_sym key, mrb_value *value);
-extern struct kh_iv *mrb_class_tbl;
-
 void
 mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
 {
diff --git a/src/kernel.c b/src/kernel.c
index a9f4792d7..fd0440e05 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -10,14 +10,12 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "mruby/proc.h"
-
 #include "mruby/range.h"
 #include "mruby/array.h"
 #include "mruby/hash.h"
 #include "mruby/class.h"
 #include "mruby/struct.h"
 #include "mruby/variable.h"
-#include "mruby/khash.h"
 #include "error.h"
 
 typedef enum {
@@ -1057,39 +1055,14 @@ mrb_value
 mrb_obj_remove_instance_variable(mrb_state *mrb, mrb_value self)
 {
   mrb_sym sym;
-  mrb_value name;
-  khash_t(iv) *h;
-  khiter_t k;
   mrb_value val;
-  mrb_value Qundef = mrb_undef_value();
 
-  mrb_get_args(mrb, "o", &name);
-  sym = mrb_to_id(mrb, name);
-  //if (OBJ_FROZEN(obj)) mrb_error_frozen("object");
-  //if (!mrb_is_instance_id(id)) {
-  //    mrb_name_error(mrb, id, "`%s' is not allowed as an instance variable name", mrb_sym2name(mrb, id));
-  //}
-  switch (mrb_type(self)) {
-    case MRB_TT_OBJECT:
-    case MRB_TT_CLASS:
-    case MRB_TT_MODULE:
-      if (!mrb_obj_ptr(self)->iv) break;
-      h = mrb_obj_ptr(self)->iv;
-      if (!h) break;
-      k = kh_get(iv, h, sym);
-      if (k != kh_end(h)) {
-        val = kh_value(h, k);
-        if (!mrb_obj_equal(mrb, val, Qundef)) {
-          kh_value(h, k) = Qundef;
-          return val;
-        }
-      }
-      break;
-    default:
-      break;
+  mrb_get_args(mrb, "n", &sym);
+  val = mrb_iv_remove(mrb, self, sym);
+  if (UNDEF_P(val)) {
+    mrb_name_error(mrb, sym, "instance variable %s not defined", mrb_sym2name(mrb, sym));
   }
-  mrb_name_error(mrb, sym, "instance variable %s not defined", mrb_sym2name(mrb, sym));
-  return mrb_nil_value();            /* not reached */
+  return val;
 }
 
 static inline int
diff --git a/src/variable.c b/src/variable.c
index d89e9d6bb..051c971d6 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -94,10 +94,28 @@ mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
   return ivget(mrb, obj->iv, sym);
 }
 
+static int
+obj_iv_p(mrb_value obj)
+{
+  switch (mrb_type(obj)) {
+    case MRB_TT_OBJECT:
+    case MRB_TT_CLASS:
+    case MRB_TT_MODULE:
+    case MRB_TT_HASH:
+    case MRB_TT_DATA:
+      return TRUE;
+    default:
+      return FALSE;
+  }
+}
+
 mrb_value
 mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
-  return mrb_obj_iv_get(mrb, mrb_obj_ptr(obj), sym);
+  if (obj_iv_p(obj)) {
+    return mrb_obj_iv_get(mrb, mrb_obj_ptr(obj), sym);
+  }
+  return mrb_nil_value();
 }
 
 static void
@@ -127,7 +145,30 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 void
 mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v) /* mrb_ivar_set */
 {
-  mrb_obj_iv_set(mrb, mrb_obj_ptr(obj), sym, v);
+  if (obj_iv_p(obj)) {
+    mrb_obj_iv_set(mrb, mrb_obj_ptr(obj), sym, v);
+  }
+}
+
+mrb_value
+mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
+{
+  mrb_value val;
+
+  if (obj_iv_p(obj)) {
+    khash_t(iv) *h = mrb_obj_ptr(obj)->iv;
+    khiter_t k;
+
+    if (h) {
+      k = kh_get(iv, h, sym);
+      if (k != kh_end(h)) {
+	val = kh_value(h, k);
+	kh_del(iv, h, k);
+	return val;
+      }
+    }
+  }
+  return mrb_undef_value();
 }
 
 mrb_value
@@ -366,7 +407,7 @@ mrb_st_lookup(struct kh_iv *table, mrb_sym id, khiter_t *value)
   }
 }
 
-int
+static int
 kiv_lookup(khash_t(iv)* table, mrb_sym key, mrb_value *value)
 {
   khash_t(iv) *h=table;
-- 
cgit v1.2.3


From 766ae4ee5f99ea96dac166a3dfa0791baa77f353 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 21 Jun 2012 16:27:16 +0900
Subject: dislose mrb_hash_keys; close #304

---
 include/mruby/hash.h | 1 +
 src/hash.c           | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index e7162c3ab..7a16d7b5a 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -27,6 +27,7 @@ void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
 mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
 mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
 mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
+mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
 mrb_value mrb_hash(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value self);
 
diff --git a/src/hash.c b/src/hash.c
index 7b9ae6a8a..0e06cd246 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -965,7 +965,7 @@ mrb_hash_to_hash(mrb_state *mrb, mrb_value hash)
  *
  */
 
-static mrb_value
+mrb_value
 mrb_hash_keys(mrb_state *mrb, mrb_value hash)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
-- 
cgit v1.2.3


From 1fa63930fd072847d24ffe9c20a57109c41387ec Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 23 Jun 2012 10:40:17 +0900
Subject: check object type before retrieving instance variabls; close #311

---
 include/mruby/variable.h |  1 +
 src/kernel.c             | 40 ----------------------------------------
 src/variable.c           | 44 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 45 insertions(+), 40 deletions(-)

(limited to 'include')

diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index 440c4cc8b..a4ed9a0ee 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -49,6 +49,7 @@ int mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id);
 mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
 mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
 void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
+mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
 
 /* GC functions */
 void mrb_gc_mark_gv(mrb_state*);
diff --git a/src/kernel.c b/src/kernel.c
index fd0440e05..8f2b15378 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -708,46 +708,6 @@ mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
   return val;
 }
 
-/* 15.3.1.3.23 */
-/*
- *  call-seq:
- *     obj.instance_variables    -> array
- *
- *  Returns an array of instance variable names for the receiver. Note
- *  that simply defining an accessor does not create the corresponding
- *  instance variable.
- *
- *     class Fred
- *       attr_accessor :a1
- *       def initialize
- *         @iv = 3
- *       end
- *     end
- *     Fred.new.instance_variables   #=> [:@iv]
- */
-mrb_value
-mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
-{
-    mrb_value ary;
-    kh_iv_t *h = RCLASS_IV_TBL(self);
-    khint_t i;
-    const char* p;
-
-    ary = mrb_ary_new(mrb);
-    if (h) {
-      for (i=0;i<kh_end(h);i++) {
-        if (kh_exist(h, i)) {
-          p = mrb_sym2name(mrb, kh_key(h,i));
-          if (*p == '@') {
-            if (mrb_type(kh_value(h, i)) != MRB_TT_UNDEF)
-              mrb_ary_push(mrb, ary, mrb_str_new_cstr(mrb, p));
-          }
-        }
-      }
-    }
-    return ary;
-}
-
 /* 15.3.1.3.24 */
 /* 15.3.1.3.26 */
 /*
diff --git a/src/variable.c b/src/variable.c
index 051c971d6..e785d56b7 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -185,6 +185,50 @@ mrb_vm_iv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   mrb_iv_set(mrb, mrb->stack[0], sym, v);
 }
 
+/* 15.3.1.3.23 */
+/*
+ *  call-seq:
+ *     obj.instance_variables    -> array
+ *
+ *  Returns an array of instance variable names for the receiver. Note
+ *  that simply defining an accessor does not create the corresponding
+ *  instance variable.
+ *
+ *     class Fred
+ *       attr_accessor :a1
+ *       def initialize
+ *         @iv = 3
+ *       end
+ *     end
+ *     Fred.new.instance_variables   #=> [:@iv]
+ */
+mrb_value
+mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
+{
+  mrb_value ary;
+  kh_iv_t *h;
+  khint_t i;
+  int len;
+  const char* p;
+
+  ary = mrb_ary_new(mrb);
+  if (obj_iv_p(self)) {
+    h = ROBJECT_IVPTR(self);
+    if (h) {
+      for (i=0;i<kh_end(h);i++) {
+        if (kh_exist(h, i)) {
+          p = mrb_sym2name_len(mrb, kh_key(h,i), &len);
+          if (len > 1 && *p == '@') {
+            if (mrb_type(kh_value(h, i)) != MRB_TT_UNDEF)
+              mrb_ary_push(mrb, ary, mrb_str_new(mrb, p, len));
+          }
+        }
+      }
+    }
+  }
+  return ary;
+}
+
 mrb_value
 mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
 {
-- 
cgit v1.2.3


From 2a2ffe7f7dc5202b29a1f59ab5e128b7040e0d86 Mon Sep 17 00:00:00 2001
From: Masamitsu MURASE <masamitsu.murase@gmail.com>
Date: Thu, 21 Jun 2012 02:00:05 +0900
Subject: Modify Kernel#clone and Kernel#dup.

Kernel#clone, Kernel#dup:
 - 'iv' should not be shared with the original object,
   but it should be copied.

Kernel#clone:
 - 'mt' of singleton_class should be copied.
---
 include/mruby/khash.h | 16 ++++++++++++++++
 src/kernel.c          | 13 +++++++++----
 2 files changed, 25 insertions(+), 4 deletions(-)

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index e236f0bea..0803521b7 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -61,6 +61,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   khint_t kh_put_##name(kh_##name##_t *h, khkey_t key);                 \
   void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets);       \
   void kh_del_##name(kh_##name##_t *h, khint_t x);                      \
+  kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h);
 
 /* define kh_xxx_funcs
 
@@ -179,6 +180,20 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   {                                                                     \
     h->d_flags[x/8] |= __m[x%8];                                        \
     h->size--;                                                          \
+  }                                                                     \
+  kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h)       \
+  {                                                                     \
+    kh_##name##_t *h2;                                                  \
+    khiter_t k, k2;                                                     \
+                                                                        \
+    h2 = kh_init_##name(mrb);                                           \
+    for (k = kh_begin(h); k != kh_end(h); k++) {                        \
+      if (kh_exist(h, k)) {                                             \
+        k2 = kh_put_##name(h2, kh_key(h, k));                           \
+        kh_value(h2, k2) = kh_value(h, k);                              \
+      }                                                                 \
+    }                                                                   \
+    return h2;                                                          \
   }
 
 
@@ -191,6 +206,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
 #define kh_put(name, h, k) kh_put_##name(h, k)
 #define kh_get(name, h, k) kh_get_##name(h, k)
 #define kh_del(name, h, k) kh_del_##name(h, k)
+#define kh_copy(name, mrb, h) kh_copy_##name(mrb, h)
 
 #define kh_exist(h, x) (!__ac_iseither((h)->e_flags, (h)->d_flags, (x)))
 #define kh_key(h, x) ((h)->keys[x])
diff --git a/src/kernel.c b/src/kernel.c
index 8da112ee5..5e17d4b5a 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -338,7 +338,12 @@ mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
       if (klass->iv) {
           clone->iv = klass->iv;
       }
-    clone->mt = kh_init(mt, mrb);
+      if (klass->mt) {
+          clone->mt = kh_copy(mt, mrb, klass->mt);
+      }
+      else {
+          clone->mt = kh_init(mt, mrb);
+      }
       clone->tt = MRB_TT_SCLASS;
       return clone;
   }
@@ -361,10 +366,11 @@ init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
       case MRB_TT_CLASS:
       case MRB_TT_MODULE:
         if (ROBJECT(dest)->iv) {
+            kh_destroy(iv, ROBJECT(dest)->iv);
             ROBJECT(dest)->iv = 0;
         }
         if (ROBJECT(obj)->iv) {
-            ROBJECT(dest)->iv = ROBJECT(obj)->iv;
+            ROBJECT(dest)->iv = kh_copy(iv, mrb, ROBJECT(obj)->iv);
         }
         break;
 
@@ -446,9 +452,8 @@ mrb_obj_dup(mrb_state *mrb, mrb_value obj)
         mrb_raise(mrb, E_TYPE_ERROR, "can't dup %s", mrb_obj_classname(mrb, obj));
     }
     p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj));
-    //init_copy(dup, obj);
     dup = mrb_obj_value(p);
-    mrb_funcall(mrb, dup, "initialize_copy", 1, obj);
+    init_copy(mrb, dup, obj);
 
     return dup;
 }
-- 
cgit v1.2.3


From 6410cdf3bffcbbb3d97f0153720922242c4f800f Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 27 Jun 2012 01:13:21 +0900
Subject: do not undef config macros

---
 include/mrbconf.h | 12 ++++++------
 src/kernel.c      |  2 +-
 src/sprintf.c     |  4 ++--
 3 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 21b8fea18..f496c53d9 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -15,10 +15,10 @@
 
 /* -DDISABLE_XXXX to change to drop the feature */
 #define DISABLE_REGEXP	        /* regular expression classes */
-#undef DISABLE_KERNEL_SPRINTF	/* Kernel.sprintf method */
-#undef DISABLE_MATH		/* Math functions */
-#undef DISABLE_TIME		/* Time class */
-#undef DISABLE_STRUCT		/* Struct class */
+//#define DISABLE_SPRINTF	/* Kernel.sprintf method */
+//#define DISABLE_MATH		/* Math functions */
+//#define DISABLE_TIME		/* Time class */
+//#define DISABLE_STRUCT	/* Struct class */
 
 #undef  HAVE_UNISTD_H /* WINDOWS */
 #define HAVE_UNISTD_H /* LINUX */
@@ -38,8 +38,8 @@ typedef intptr_t mrb_sym;
 #ifndef DISABLE_REGEXP
 #define ENABLE_REGEXP
 #endif
-#ifndef DISABLE_KERNEL_SPRINTF
-#define ENABLE_KERNEL_SPRINTF
+#ifndef DISABLE_SPRINTF
+#define ENABLE_SPRINTF
 #endif
 #ifndef DISABLE_MATH
 #define ENABLE_MATH
diff --git a/src/kernel.c b/src/kernel.c
index 5e17d4b5a..605b84124 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -1168,7 +1168,7 @@ mrb_init_kernel(mrb_state *mrb)
   mrb_define_method(mrb, krn, "singleton_methods",          mrb_obj_singleton_methods_m,     ARGS_ANY());     /* 15.3.1.3.45 */
   mrb_define_method(mrb, krn, "to_s",                       mrb_any_to_s,                    ARGS_NONE());    /* 15.3.1.3.46 */
 
-#ifdef ENABLE_KERNEL_SPRINTF
+#ifdef ENABLE_SPRINTF
   mrb_define_method(mrb, krn, "sprintf",                    mrb_f_sprintf,                   ARGS_ANY());     /* in sprintf.c */
   mrb_define_method(mrb, krn, "format",                     mrb_f_sprintf,                   ARGS_ANY());     /* in sprintf.c */
 #endif
diff --git a/src/sprintf.c b/src/sprintf.c
index 86c3b66bc..68addef89 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -6,7 +6,7 @@
 
 #include "mruby.h"
 
-#ifdef ENABLE_KERNEL_SPRINTF
+#ifdef ENABLE_SPRINTF
 
 #include <stdio.h>
 #include <string.h>
@@ -1084,4 +1084,4 @@ fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
     *buf = '\0';
 }
 
-#endif	/* ENABLE_KERNEL_SPRINTF */
+#endif	/* ENABLE_SPRINTF */
-- 
cgit v1.2.3


From e9d56f4ccfcd71fa34be36f9457fd60e897036bd Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 28 Jun 2012 14:37:32 +0900
Subject: do not undef config macro MRB_USE_FLOAT

---
 include/mrbconf.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index f496c53d9..4ed481e0b 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -11,7 +11,7 @@
 
 /* configuration options: */
 /* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
-#undef MRB_USE_FLOAT
+//#define MRB_USE_FLOAT
 
 /* -DDISABLE_XXXX to change to drop the feature */
 #define DISABLE_REGEXP	        /* regular expression classes */
-- 
cgit v1.2.3


From 3be4e91376804c1815e38d4a591ab152fba9d3b3 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 3 Jul 2012 14:27:34 +0900
Subject: remove size_t from parser

---
 include/mruby/compile.h |  4 ++--
 src/parse.y             | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index b41eed57e..e549a2f5c 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -91,12 +91,12 @@ void mrb_parser_parse(struct mrb_parser_state*);
 /* utility functions */
 struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*);
 struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*);
-struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t);
+struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int);
 int mrb_generate_code(mrb_state*, mrb_ast_node*);
 
 int mrb_compile_file(mrb_state*,FILE*);
 int mrb_compile_string(mrb_state*,char*);
-int mrb_compile_nstring(mrb_state*,char*,size_t);
+int mrb_compile_nstring(mrb_state*,char*,int);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/src/parse.y b/src/parse.y
index af8b93cfa..8a85b6fc6 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -686,7 +686,7 @@ new_float(parser_state *p, const char *s)
 
 // (:str . (s . len))
 static node*
-new_str(parser_state *p, const char *s, size_t len)
+new_str(parser_state *p, const char *s, int len)
 {
   return cons((node*)NODE_STR, cons((node*)strndup(s, len), (node*)len));
 }
@@ -2961,7 +2961,7 @@ static void
 yyerror(parser_state *p, const char *s)
 {
   char* c;
-  size_t n;
+  int n;
 
   if (! p->capture_errors) {
     if (p->filename) {
@@ -2995,7 +2995,7 @@ static void
 yywarn(parser_state *p, const char *s)
 {
   char* c;
-  size_t n;
+  int n;
 
   if (! p->capture_errors) {
     if (p->filename) {
@@ -4774,7 +4774,7 @@ mrb_parse_file(mrb_state *mrb, FILE *f)
 }
 
 parser_state*
-mrb_parse_nstring(mrb_state *mrb, const char *s, size_t len)
+mrb_parse_nstring(mrb_state *mrb, const char *s, int len)
 {
   parser_state *p;
 
@@ -4812,7 +4812,7 @@ mrb_compile_file(mrb_state * mrb, FILE *f)
 }
 
 int
-mrb_compile_nstring(mrb_state *mrb, char *s, size_t len)
+mrb_compile_nstring(mrb_state *mrb, char *s, int len)
 {
   parser_state *p;
   int n;
-- 
cgit v1.2.3


From 97b1c57600b243e086114179cd61e3503beaa1e6 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 3 Jul 2012 14:28:19 +0900
Subject: constify parser input strings

---
 include/mruby/compile.h | 4 ++--
 src/parse.y             | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index e549a2f5c..fa21d81a6 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -95,8 +95,8 @@ struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int);
 int mrb_generate_code(mrb_state*, mrb_ast_node*);
 
 int mrb_compile_file(mrb_state*,FILE*);
-int mrb_compile_string(mrb_state*,char*);
-int mrb_compile_nstring(mrb_state*,char*,int);
+int mrb_compile_string(mrb_state*,const char*);
+int mrb_compile_nstring(mrb_state*,const char*,int);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/src/parse.y b/src/parse.y
index 8a85b6fc6..ae53d2cf7 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4812,7 +4812,7 @@ mrb_compile_file(mrb_state * mrb, FILE *f)
 }
 
 int
-mrb_compile_nstring(mrb_state *mrb, char *s, int len)
+mrb_compile_nstring(mrb_state *mrb, const char *s, int len)
 {
   parser_state *p;
   int n;
@@ -4828,7 +4828,7 @@ mrb_compile_nstring(mrb_state *mrb, char *s, int len)
 }
 
 int
-mrb_compile_string(mrb_state *mrb, char *s)
+mrb_compile_string(mrb_state *mrb, const char *s)
 {
   return mrb_compile_nstring(mrb, s, strlen(s));
 }
-- 
cgit v1.2.3


From ce49d90dc82bc165880a800ae95dc327b729143f Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 3 Jul 2012 15:26:11 +0900
Subject: modify compiler API; replace mrb_compie_xxx with mrb_load_xxx() that
 combines compilatoin and execution

---
 include/mruby/compile.h |  7 ++++---
 src/parse.y             | 56 ++++++++++++++++++++++++++-----------------------
 2 files changed, 34 insertions(+), 29 deletions(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index fa21d81a6..2ea141da8 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -94,9 +94,10 @@ struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*);
 struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int);
 int mrb_generate_code(mrb_state*, mrb_ast_node*);
 
-int mrb_compile_file(mrb_state*,FILE*);
-int mrb_compile_string(mrb_state*,const char*);
-int mrb_compile_nstring(mrb_state*,const char*,int);
+/* program load functions */
+mrb_value mrb_load_file(mrb_state*,FILE*);
+mrb_value mrb_load_string(mrb_state *mrb, const char *path);
+mrb_value mrb_load_nstring(mrb_state *mrb, const char *path, int len);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/src/parse.y b/src/parse.y
index ae53d2cf7..7f40534b9 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -20,6 +20,7 @@
 
 #include "mruby.h"
 #include "mruby/compile.h"
+#include "mruby/proc.h"
 #include "node.h"
 #include "st.h"
 
@@ -4793,46 +4794,49 @@ mrb_parse_string(mrb_state *mrb, const char *s)
   return mrb_parse_nstring(mrb, s, strlen(s));
 }
 
-void parser_dump(mrb_state *mrb, node *tree, int offset);
-
-int
-mrb_compile_file(mrb_state * mrb, FILE *f)
+static mrb_value
+load_exec(mrb_state *mrb, parser_state *p)
 {
-  parser_state *p;
   int n;
 
-  p = mrb_parse_file(mrb, f);
-  if (!p) return -1;
-  if (!p->tree) return -1;
-  if (p->nerr) return -1;
+  if (!p || !p->tree || p->nerr) {
+    char buf[256];
+
+    n = snprintf(buf, sizeof(buf), "line %d: %s\n",
+		 p->error_buffer[0].lineno, p->error_buffer[0].message);
+    mrb_pool_close(p->pool);
+    mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, n));
+    return mrb_nil_value();
+  }
   n = mrb_generate_code(mrb, p->tree);
   mrb_pool_close(p->pool);
-
-  return n;
+  if (n < 0) {
+    mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, E_SCRIPT_ERROR, "codegen error", 13));
+    return mrb_nil_value();
+  }
+  return mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
 }
 
-int
-mrb_compile_nstring(mrb_state *mrb, const char *s, int len)
+mrb_value
+mrb_load_file(mrb_state *mrb, FILE *f)
 {
-  parser_state *p;
-  int n;
-
-  p = mrb_parse_nstring(mrb, s, len);
-  if (!p) return -1;
-  if (!p->tree) return -1;
-  if (p->nerr) return -1;
-  n = mrb_generate_code(mrb, p->tree);
-  mrb_pool_close(p->pool);
+  return load_exec(mrb, mrb_parse_file(mrb, f));
+}
 
-  return n;
+mrb_value
+mrb_load_nstring(mrb_state *mrb, const char *s, int len)
+{
+  return load_exec(mrb, mrb_parse_nstring(mrb, s, len));
 }
 
-int
-mrb_compile_string(mrb_state *mrb, const char *s)
+mrb_value
+mrb_load_string(mrb_state *mrb, const char *s)
 {
-  return mrb_compile_nstring(mrb, s, strlen(s));
+  return load_exec(mrb, mrb_parse_nstring(mrb, s, strlen(s)));
 }
 
+void parser_dump(mrb_state *mrb, node *tree, int offset);
+
 static void
 dump_prefix(int offset)
 {
-- 
cgit v1.2.3


From 65096c4c1bd1bfb6f547808fc01ab6ea223d9dc6 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 3 Jul 2012 20:59:07 +0900
Subject: add context to parser, that would hold local variable info, filename,
 and line number.  mrbc_context argument has been added to mrb_parse_xxx()
 functions.  Normally, you just to need to add NULL (or 0) to the last
 argument of the above functions.

---
 include/mruby/compile.h | 37 +++++++++++++++++-------
 src/parse.y             | 77 +++++++++++++++++++++++++++++++++++++------------
 test/driver.c           | 12 ++------
 tools/mrbc/mrbc.c       |  2 +-
 tools/mruby/mruby.c     | 15 +++++-----
 5 files changed, 95 insertions(+), 48 deletions(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index 2ea141da8..401f52854 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -14,13 +14,26 @@ extern "C" {
 #include "mruby.h"
 #include <stdio.h>
 #include <setjmp.h>
+#include <stdio.h>
+
+/* load context */
+typedef struct mrbc_context {
+  mrb_sym *syms;
+  int slen;
+  char *filename;
+  int lineno;
+} mrbc_context;
+
+mrbc_context* mrbc_context_new(mrb_state *mrb);
+void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
+const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
 
+/* AST node structure */
 typedef struct mrb_ast_node {
   struct mrb_ast_node *car, *cdr;
 } mrb_ast_node;
 
-#include <stdio.h>
-
+/* lexer states */
 enum mrb_lex_state_enum {
     EXPR_BEG,                   /* ignore newline, +/- is a sign. */
     EXPR_END,                   /* newline significant, +/- is an operator. */
@@ -36,21 +49,23 @@ enum mrb_lex_state_enum {
     EXPR_MAX_STATE
 };
 
+/* saved error message */
 struct mrb_parser_message {
   int lineno;
   int column;
   char* message;
 };
 
+/* parser structure */
 struct mrb_parser_state {
   mrb_state *mrb;
   struct mrb_pool *pool;
   mrb_ast_node *cells;
   const char *s, *send;
   FILE *f;
+  char *filename;
   int lineno;
   int column;
-  const char *filename;
 
   enum mrb_lex_state_enum lstate;
   int sterm;
@@ -59,6 +74,8 @@ struct mrb_parser_state {
   unsigned int cmdarg_stack;
   int paren_nest;
   int lpar_beg;
+  int in_def, in_single, cmd_start;
+  mrb_ast_node *locals;
 
   mrb_ast_node *pb;
   char buf[1024];
@@ -66,9 +83,6 @@ struct mrb_parser_state {
 
   mrb_ast_node *heredoc;
 
-  int in_def, in_single, cmd_start;
-  mrb_ast_node *locals;
-
   void *ylval;
 
   int nerr;
@@ -82,22 +96,23 @@ struct mrb_parser_state {
   jmp_buf jmp;
 };
 
-/* parser structure */
 struct mrb_parser_state* mrb_parser_new(mrb_state*);
 const char *mrb_parser_filename(struct mrb_parser_state*, const char*);
-int mrb_parser_lineno(struct mrb_parser_state*, int);
 void mrb_parser_parse(struct mrb_parser_state*);
 
 /* utility functions */
-struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*);
-struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*);
-struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int);
+struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
+struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
+struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int,mrbc_context*);
 int mrb_generate_code(mrb_state*, mrb_ast_node*);
 
 /* program load functions */
 mrb_value mrb_load_file(mrb_state*,FILE*);
 mrb_value mrb_load_string(mrb_state *mrb, const char *path);
 mrb_value mrb_load_nstring(mrb_state *mrb, const char *path, int len);
+mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
+mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *path, mrbc_context *cxt);
+mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *path, int len, mrbc_context *cxt);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/src/parse.y b/src/parse.y
index 7f40534b9..78d7d7a7e 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4730,7 +4730,6 @@ mrb_parser_new(mrb_state *mrb)
   p->in_def = p->in_single = FALSE;
 
   p->capture_errors = 0;
-
   p->lineno = 1;
   p->column = 0;
 #if defined(PARSER_TEST) || defined(PARSER_DEBUG)
@@ -4740,33 +4739,56 @@ mrb_parser_new(mrb_state *mrb)
   return p;
 }
 
+mrbc_context*
+mrbc_context_new(mrb_state *mrb)
+{
+  mrbc_context *c;
+
+  c = mrb_malloc(mrb, sizeof(mrbc_context));
+  memset(c, 0, sizeof(mrbc_context));
+  return c;
+}
+
+void
+mrbc_context_free(mrb_state *mrb, mrbc_context *cxt)
+{
+  mrb_free(mrb, cxt->syms);
+  mrb_free(mrb, cxt->filename);
+  mrb_free(mrb, cxt);
+}
+
 const char*
-mrb_parser_filename(parser_state *p, const char *s)
+mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s)
 {
   if (s) {
-    p->filename = strdup(s);
+    int len = strlen(s);
+    char *p = mrb_malloc(mrb, len);
+
+    memcpy(p, s, len);
+    if (c->filename) mrb_free(mrb, c->filename);
+    c->filename = p;
+    c->lineno = 1;
   }
-  return p->filename;
+  return c->filename;
 }
 
-int
-mrb_parser_lineno(struct mrb_parser_state *p, int n)
+static void
+parser_init_cxt(parser_state *p, mrbc_context *cxt)
 {
-  if (n <= 0) {
-    return p->lineno;
+  if (cxt) {
+    if (cxt->lineno) p->lineno = cxt->lineno;
+    if (cxt->filename) p->filename = cxt->filename;
   }
-  p->column = 0;
-  p->lineno = n;
-  return n;
 }
 
 parser_state*
-mrb_parse_file(mrb_state *mrb, FILE *f)
+mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
 {
   parser_state *p;
  
   p = mrb_parser_new(mrb);
   if (!p) return 0;
+  parser_init_cxt(p, c);
   p->s = p->send = NULL;
   p->f = f;
 
@@ -4775,12 +4797,13 @@ mrb_parse_file(mrb_state *mrb, FILE *f)
 }
 
 parser_state*
-mrb_parse_nstring(mrb_state *mrb, const char *s, int len)
+mrb_parse_nstring(mrb_state *mrb, const char *s, int len, mrbc_context *c)
 {
   parser_state *p;
 
   p = mrb_parser_new(mrb);
   if (!p) return 0;
+  parser_init_cxt(p, c);
   p->s = s;
   p->send = s + len;
 
@@ -4789,9 +4812,9 @@ mrb_parse_nstring(mrb_state *mrb, const char *s, int len)
 }
 
 parser_state*
-mrb_parse_string(mrb_state *mrb, const char *s)
+mrb_parse_string(mrb_state *mrb, const char *s, mrbc_context *c)
 {
-  return mrb_parse_nstring(mrb, s, strlen(s));
+  return mrb_parse_nstring(mrb, s, strlen(s), c);
 }
 
 static mrb_value
@@ -4817,22 +4840,40 @@ load_exec(mrb_state *mrb, parser_state *p)
   return mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
 }
 
+mrb_value
+mrb_load_file_cxt(mrb_state *mrb, FILE *f, mrbc_context *c)
+{
+  return load_exec(mrb, mrb_parse_file(mrb, f, c));
+}
+
 mrb_value
 mrb_load_file(mrb_state *mrb, FILE *f)
 {
-  return load_exec(mrb, mrb_parse_file(mrb, f));
+  return mrb_load_file_cxt(mrb, f, NULL);
+}
+
+mrb_value
+mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *c)
+{
+  return load_exec(mrb, mrb_parse_nstring(mrb, s, len, c));
 }
 
 mrb_value
 mrb_load_nstring(mrb_state *mrb, const char *s, int len)
 {
-  return load_exec(mrb, mrb_parse_nstring(mrb, s, len));
+  return mrb_load_nstring_cxt(mrb, s, len, NULL);
+}
+
+mrb_value
+mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *c)
+{
+  return load_exec(mrb, mrb_parse_nstring(mrb, s, strlen(s), c));
 }
 
 mrb_value
 mrb_load_string(mrb_state *mrb, const char *s)
 {
-  return load_exec(mrb, mrb_parse_nstring(mrb, s, strlen(s)));
+  return mrb_load_string_cxt(mrb, s, NULL);
 }
 
 void parser_dump(mrb_state *mrb, node *tree, int offset);
diff --git a/test/driver.c b/test/driver.c
index 6b42d025b..6b1697f14 100644
--- a/test/driver.c
+++ b/test/driver.c
@@ -42,16 +42,8 @@ main(void)
   }
 
   mrb_init_mrbtest(mrb);
-  parser = mrb_parse_nstring(mrb, prog, strlen(prog));
-
-  /* generate bytecode */
-  byte_code = mrb_generate_code(mrb, parser->tree);
-
-  /* evaluate the bytecode */
-  return_value = mrb_run(mrb,
-    /* pass a proc for evaulation */
-    mrb_proc_new(mrb, mrb->irep[byte_code]),
-    mrb_top_self(mrb));
+  /* evaluate the test */
+  return_value = mrb_load_string(mrb, prog);
   /* did an exception occur? */
   if (mrb->exc) {
     mrb_p(mrb, return_value);
diff --git a/tools/mrbc/mrbc.c b/tools/mrbc/mrbc.c
index 99fea76d8..9b69244e5 100644
--- a/tools/mrbc/mrbc.c
+++ b/tools/mrbc/mrbc.c
@@ -172,7 +172,7 @@ main(int argc, char **argv)
     return n;
   }
 
-  p = mrb_parse_file(mrb, args.rfp);
+  p = mrb_parse_file(mrb, args.rfp, NULL);
   if (!p || !p->tree || p->nerr) {
     cleanup(&args);
     mrb_close(mrb);
diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c
index 5cf3d8a37..b4b37516b 100644
--- a/tools/mruby/mruby.c
+++ b/tools/mruby/mruby.c
@@ -165,17 +165,16 @@ main(int argc, char **argv)
     n = mrb_load_irep(mrb, args.rfp);
   }
   else {
+    mrbc_context *c = mrbc_context_new(mrb);
     if (args.cmdline) {
-      p = mrb_parse_string(mrb, (char*)args.cmdline);
-    }
+      mrbc_filename(mrb, c, "-e");
+      p = mrb_parse_string(mrb, (char*)args.cmdline, c); 
+   }
     else {
-      p = mrb_parser_new(mrb);
-      if (p) {
-	mrb_parser_filename(p, argv[1]);
-	p->f = args.rfp;
-	mrb_parser_parse(p);
-      }
+      mrbc_filename(mrb, c, argv[1]);
+      p = mrb_parse_file(mrb, args.rfp, c);
     }
+    mrbc_context_free(mrb, c);
     if (!p || !p->tree || p->nerr) {
       cleanup(mrb, &args);
       return -1;
-- 
cgit v1.2.3


From 39689441e78c59fb92d7563ed40f14287df9b575 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 3 Jul 2012 21:13:10 +0900
Subject: add context arg to mrb_parser_parse()

---
 include/mruby/compile.h |  2 +-
 src/parse.y             | 27 +++++++++++++--------------
 tools/mirb/mirb.c       |  2 +-
 3 files changed, 15 insertions(+), 16 deletions(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index 401f52854..c4e480577 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -98,7 +98,7 @@ struct mrb_parser_state {
 
 struct mrb_parser_state* mrb_parser_new(mrb_state*);
 const char *mrb_parser_filename(struct mrb_parser_state*, const char*);
-void mrb_parser_parse(struct mrb_parser_state*);
+void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
 
 /* utility functions */
 struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
diff --git a/src/parse.y b/src/parse.y
index 78d7d7a7e..90534cb32 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4669,8 +4669,17 @@ yylex(void *lval, parser_state *p)
     return t;
 }
 
+static void
+parser_init_cxt(parser_state *p, mrbc_context *cxt)
+{
+  if (cxt) {
+    if (cxt->lineno) p->lineno = cxt->lineno;
+    if (cxt->filename) p->filename = cxt->filename;
+  }
+}
+
 void
-mrb_parser_parse(parser_state *p)
+mrb_parser_parse(parser_state *p, mrbc_context *c)
 {
   node *tree;
 
@@ -4685,6 +4694,7 @@ mrb_parser_parse(parser_state *p)
   p->in_def = p->in_single = FALSE;
   p->nerr = p->nwarn = 0;
   p->sterm = 0;
+  parser_init_cxt(p, c);
 
   yyparse(p);
   tree = p->tree;
@@ -4772,15 +4782,6 @@ mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s)
   return c->filename;
 }
 
-static void
-parser_init_cxt(parser_state *p, mrbc_context *cxt)
-{
-  if (cxt) {
-    if (cxt->lineno) p->lineno = cxt->lineno;
-    if (cxt->filename) p->filename = cxt->filename;
-  }
-}
-
 parser_state*
 mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
 {
@@ -4788,11 +4789,10 @@ mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
  
   p = mrb_parser_new(mrb);
   if (!p) return 0;
-  parser_init_cxt(p, c);
   p->s = p->send = NULL;
   p->f = f;
 
-  mrb_parser_parse(p);
+  mrb_parser_parse(p, c);
   return p;
 }
 
@@ -4803,11 +4803,10 @@ mrb_parse_nstring(mrb_state *mrb, const char *s, int len, mrbc_context *c)
 
   p = mrb_parser_new(mrb);
   if (!p) return 0;
-  parser_init_cxt(p, c);
   p->s = s;
   p->send = s + len;
 
-  mrb_parser_parse(p);
+  mrb_parser_parse(p, c);
   return p;
 }
 
diff --git a/tools/mirb/mirb.c b/tools/mirb/mirb.c
index 35558acfb..fb61dd272 100644
--- a/tools/mirb/mirb.c
+++ b/tools/mirb/mirb.c
@@ -196,7 +196,7 @@ main(void)
       parser->send = ruby_code + strlen(ruby_code);
       parser->capture_errors = 1;
       parser->lineno = 1;
-      mrb_parser_parse(parser);
+      mrb_parser_parse(parser, NULL);
       code_block_open = is_code_block_open(parser); 
 
       if (code_block_open) {
-- 
cgit v1.2.3


From 137570acf0f8f9dbfbdc8678d13650bfcfe9c140 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 3 Jul 2012 21:32:37 +0900
Subject: capture_errors can be specified by mrbc_context

---
 include/mruby/compile.h | 1 +
 src/parse.y             | 1 +
 2 files changed, 2 insertions(+)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index c4e480577..8f65932ba 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -22,6 +22,7 @@ typedef struct mrbc_context {
   int slen;
   char *filename;
   int lineno;
+  int capture_errors:1;
 } mrbc_context;
 
 mrbc_context* mrbc_context_new(mrb_state *mrb);
diff --git a/src/parse.y b/src/parse.y
index 5376182a0..217e82a37 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4683,6 +4683,7 @@ parser_init_cxt(parser_state *p, mrbc_context *cxt)
       local_add_f(p, cxt->syms[len]);
     }
   }
+  p->capture_errors = cxt->capture_errors;
 }
 
 static void
-- 
cgit v1.2.3


From fc27f71289b84f700efc780ae79eea66f212c0c4 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 3 Jul 2012 21:52:11 +0900
Subject: add new function mrb_parser_free()

---
 include/mruby/compile.h | 1 +
 src/parse.y             | 5 +++++
 tools/mirb/mirb.c       | 2 +-
 3 files changed, 7 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index 8f65932ba..42820896e 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -98,6 +98,7 @@ struct mrb_parser_state {
 };
 
 struct mrb_parser_state* mrb_parser_new(mrb_state*);
+void mrb_parser_free(struct mrb_parser_state*);
 const char *mrb_parser_filename(struct mrb_parser_state*, const char*);
 void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
 
diff --git a/src/parse.y b/src/parse.y
index 63d39ec5f..b0d399a98 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4775,6 +4775,11 @@ mrb_parser_new(mrb_state *mrb)
   return p;
 }
 
+void
+mrb_parser_free(parser_state *p) {
+  mrb_pool_close(p->pool);
+}
+
 mrbc_context*
 mrbc_context_new(mrb_state *mrb)
 {
diff --git a/tools/mirb/mirb.c b/tools/mirb/mirb.c
index d46bcff3c..8b36cb5a6 100644
--- a/tools/mirb/mirb.c
+++ b/tools/mirb/mirb.c
@@ -231,7 +231,7 @@ main(void)
         memset(ruby_code, 0, sizeof(*ruby_code));
         memset(ruby_code, 0, sizeof(*last_code_line));
       }
-      mrb_pool_close(parser->pool);
+      mrb_parser_free(parser);
     }
   }
   mrbc_context_free(mrb, cxt);
-- 
cgit v1.2.3


From ff42f8f4854525bfecb1a76252730aaad137080f Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 5 Jul 2012 22:56:51 +0900
Subject: move RDoc comments

---
 include/mruby.h |  2 +-
 src/etc.c       | 29 +----------------------------
 src/kernel.c    | 27 +++++++++++++++++++++------
 3 files changed, 23 insertions(+), 35 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index aadd56e94..7e2d2575f 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -358,7 +358,7 @@ mrb_value mrb_top_self(mrb_state *);
 mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
 
 mrb_value mrb_p(mrb_state*, mrb_value);
-int mrb_obj_id(mrb_value obj);
+mrb_int mrb_obj_id(mrb_value obj);
 mrb_sym mrb_to_id(mrb_state *mrb, mrb_value name);
 
 int mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
diff --git a/src/etc.c b/src/etc.c
index ac1f79f2f..36da0c943 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -126,34 +126,7 @@ mrb_block_proc(void)
   return mrb_nil_value();//proc_new(mrb_cProc, FALSE);
 }
 
-/*
- *  Document-method: __id__
- *  Document-method: object_id
- *
- *  call-seq:
- *     obj.__id__       -> fixnum
- *     obj.object_id    -> fixnum
- *
- *  Returns an integer identifier for <i>obj</i>. The same number will
- *  be returned on all calls to <code>id</code> for a given object, and
- *  no two active objects will share an id.
- *  <code>Object#object_id</code> is a different concept from the
- *  <code>:name</code> notation, which returns the symbol id of
- *  <code>name</code>. Replaces the deprecated <code>Object#id</code>.
- */
-
-/*
- *  call-seq:
- *     obj.hash    -> fixnum
- *
- *  Generates a <code>Fixnum</code> hash value for this object. This
- *  function must have the property that <code>a.eql?(b)</code> implies
- *  <code>a.hash == b.hash</code>. The hash value is used by class
- *  <code>Hash</code>. Any hash value that exceeds the capacity of a
- *  <code>Fixnum</code> will be truncated before being used.
- */
-
-int
+mrb_int
 mrb_obj_id(mrb_value obj)
 {
     /*
diff --git a/src/kernel.c b/src/kernel.c
index 605b84124..d230305da 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -207,14 +207,19 @@ mrb_equal_m(mrb_state *mrb, mrb_value self)
 /* 15.3.1.3.3  */
 /* 15.3.1.3.33 */
 /*
+ *  Document-method: __id__
+ *  Document-method: object_id
+ *
  *  call-seq:
- *     obj.hash    -> fixnum
+ *     obj.__id__       -> fixnum
+ *     obj.object_id    -> fixnum
  *
- *  Generates a <code>Fixnum</code> hash value for this object. This
- *  function must have the property that <code>a.eql?(b)</code> implies
- *  <code>a.hash == b.hash</code>. The hash value is used by class
- *  <code>Hash</code>. Any hash value that exceeds the capacity of a
- *  <code>Fixnum</code> will be truncated before being used.
+ *  Returns an integer identifier for <i>obj</i>. The same number will
+ *  be returned on all calls to <code>id</code> for a given object, and
+ *  no two active objects will share an id.
+ *  <code>Object#object_id</code> is a different concept from the
+ *  <code>:name</code> notation, which returns the symbol id of
+ *  <code>name</code>. Replaces the deprecated <code>Object#id</code>.
  */
 static mrb_value
 mrb_obj_id_m(mrb_state *mrb, mrb_value self)
@@ -526,6 +531,16 @@ mrb_obj_extend_m(mrb_state *mrb, mrb_value self)
 //mrb_f_global_variables(mrb_state *mrb, mrb_value self)
 
 /* 15.3.1.3.15 */
+/*
+ *  call-seq:
+ *     obj.hash    -> fixnum
+ *
+ *  Generates a <code>Fixnum</code> hash value for this object. This
+ *  function must have the property that <code>a.eql?(b)</code> implies
+ *  <code>a.hash == b.hash</code>. The hash value is used by class
+ *  <code>Hash</code>. Any hash value that exceeds the capacity of a
+ *  <code>Fixnum</code> will be truncated before being used.
+ */
 mrb_value
 mrb_obj_hash(mrb_state *mrb, mrb_value self)
 {
-- 
cgit v1.2.3


From 8268ba2755ec467d100c799dbf53c13f38fda436 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 6 Jul 2012 19:52:50 +0900
Subject: remove MRB_TT_THREAD,MRB_TT_THREADGRP

---
 include/mruby.h | 4 +---
 src/etc.c       | 2 --
 2 files changed, 1 insertion(+), 5 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 7e2d2575f..0acd20842 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -60,9 +60,7 @@ enum mrb_vtype {
   MRB_TT_FILE,        /*  21 */
   MRB_TT_ENV,         /*  22 */
   MRB_TT_DATA,        /*  23 */
-  MRB_TT_THREAD,      /*  24 */
-  MRB_TT_THREADGRP,   /*  25 */
-  MRB_TT_MAXDEFINE    /*  26 */
+  MRB_TT_MAXDEFINE    /*  24 */
 };
 
 typedef struct mrb_value {
diff --git a/src/etc.c b/src/etc.c
index 10aba12a0..73cf31087 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -183,8 +183,6 @@ mrb_obj_id(mrb_value obj)
   case  MRB_TT_MATCH:
   case  MRB_TT_FILE:
   case  MRB_TT_DATA:
-  case  MRB_TT_THREAD:
-  case  MRB_TT_THREADGRP:
   default:
     return MakeID(obj.value.p);
   }
-- 
cgit v1.2.3


From 0e2a81740a284e823894ec5b1d804e282df15b7e Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 9 Jul 2012 11:42:15 +0900
Subject: we don't need xmalloc; close #356

---
 include/mruby.h | 7 -------
 1 file changed, 7 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 0acd20842..a9027d896 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -467,13 +467,6 @@ mrb_value mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *
 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);
 
-#ifndef xmalloc
-#define xmalloc     malloc
-#define xrealloc    realloc
-#define xcalloc     calloc
-#define xfree       free
-#endif
-
 void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
 void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
-- 
cgit v1.2.3


From 9e64e753a227e85425c990283117129d3a5fd625 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 12 Jul 2012 23:59:13 +0900
Subject: remove double stdio.h inclusion

---
 include/mruby/compile.h | 1 -
 1 file changed, 1 deletion(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index 42820896e..e3361feed 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -14,7 +14,6 @@ extern "C" {
 #include "mruby.h"
 #include <stdio.h>
 #include <setjmp.h>
-#include <stdio.h>
 
 /* load context */
 typedef struct mrbc_context {
-- 
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 'include')

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 8e1c842b7e17ecb58e25e48e0cac253bceb00f14 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 13 Jul 2012 15:36:43 +0900
Subject: simpify mruby/mrbc using context

---
 include/mruby/compile.h |  2 ++
 src/parse.y             | 20 ++++++++++++-----
 tools/mrbc/mrbc.c       | 24 ++++++++------------
 tools/mruby/mruby.c     | 58 ++++++++++++++++++++-----------------------------
 4 files changed, 49 insertions(+), 55 deletions(-)

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index e3361feed..4dd369adb 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -22,6 +22,8 @@ typedef struct mrbc_context {
   char *filename;
   int lineno;
   int capture_errors:1;
+  int dump_result:1;
+  int no_exec:1;
 } mrbc_context;
 
 mrbc_context* mrbc_context_new(mrb_state *mrb);
diff --git a/src/parse.y b/src/parse.y
index 8d626b5d8..5a22b3883 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4721,6 +4721,9 @@ parser_update_cxt(parser_state *p, mrbc_context *cxt)
   }
 }
 
+void codedump_all(mrb_state*, int);
+void parser_dump(mrb_state *mrb, node *tree, int offset);
+
 void
 mrb_parser_parse(parser_state *p, mrbc_context *c)
 {
@@ -4756,6 +4759,9 @@ mrb_parser_parse(parser_state *p, mrbc_context *c)
       append(tree, p->tree);
     }
   }
+  if (c && c->dump_result) {
+    parser_dump(p->mrb, p->tree, 0);
+  }
 }
 
 parser_state*
@@ -4862,7 +4868,7 @@ mrb_parse_string(mrb_state *mrb, const char *s, mrbc_context *c)
 }
 
 static mrb_value
-load_exec(mrb_state *mrb, parser_state *p)
+load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
 {
   int n;
 
@@ -4885,13 +4891,17 @@ load_exec(mrb_state *mrb, parser_state *p)
     mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, E_SCRIPT_ERROR, "codegen error", 13));
     return mrb_nil_value();
   }
+  if (c) {
+    if (c->dump_result) codedump_all(mrb, n);
+    if (c->no_exec) return mrb_fixnum_value(n);
+  }
   return mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
 }
 
 mrb_value
 mrb_load_file_cxt(mrb_state *mrb, FILE *f, mrbc_context *c)
 {
-  return load_exec(mrb, mrb_parse_file(mrb, f, c));
+  return load_exec(mrb, mrb_parse_file(mrb, f, c), c);
 }
 
 mrb_value
@@ -4903,7 +4913,7 @@ mrb_load_file(mrb_state *mrb, FILE *f)
 mrb_value
 mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *c)
 {
-  return load_exec(mrb, mrb_parse_nstring(mrb, s, len, c));
+  return load_exec(mrb, mrb_parse_nstring(mrb, s, len, c), c);
 }
 
 mrb_value
@@ -4915,7 +4925,7 @@ mrb_load_nstring(mrb_state *mrb, const char *s, int len)
 mrb_value
 mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *c)
 {
-  return load_exec(mrb, mrb_parse_nstring(mrb, s, strlen(s), c));
+  return mrb_load_nstring_cxt(mrb, s, strlen(s), c);
 }
 
 mrb_value
@@ -4924,8 +4934,6 @@ mrb_load_string(mrb_state *mrb, const char *s)
   return mrb_load_string_cxt(mrb, s, NULL);
 }
 
-void parser_dump(mrb_state *mrb, node *tree, int offset);
-
 static void
 dump_prefix(int offset)
 {
diff --git a/tools/mrbc/mrbc.c b/tools/mrbc/mrbc.c
index 8da37832a..a70353d63 100644
--- a/tools/mrbc/mrbc.c
+++ b/tools/mrbc/mrbc.c
@@ -158,7 +158,8 @@ main(int argc, char **argv)
   mrb_state *mrb = mrb_open();
   int n = -1;
   struct _args args;
-  struct mrb_parser_state *p;
+  mrbc_context *c;
+  mrb_value result;
 
   if (mrb == NULL) {
     fprintf(stderr, "Invalid mrb_state, exiting mrbc");
@@ -166,7 +167,6 @@ main(int argc, char **argv)
   }
 
   n = parse_args(mrb, argc, argv, &args);
-
   if (n < 0 || args.rfp == NULL) {
     cleanup(&args);
     usage(argv[0]);
@@ -174,22 +174,17 @@ main(int argc, char **argv)
     return n;
   }
 
-  p = mrb_parse_file(mrb, args.rfp, NULL);
-  if (!p || !p->tree || p->nerr) {
+  c = mrbc_context_new(mrb);
+  if (args.verbose)
+    c->dump_result = 1;
+  c->no_exec = 1;
+  result = mrb_load_file_cxt(mrb, args.rfp, c);
+  if (mrb_nil_p(result)) {
     cleanup(&args);
     mrb_close(mrb);
     return -1;
   }
-
-  if (args.verbose)
-    parser_dump(mrb, p->tree, 0);
-
-  n = mrb_generate_code(mrb, p->tree);
-  mrb_parser_free(p);
-
-  if (args.verbose)
-    codedump_all(mrb, n);
-
+  n = mrb_fixnum(result);
   if (n < 0 || args.check_syntax) {
     cleanup(&args);
     mrb_close(mrb);
@@ -215,4 +210,3 @@ void
 mrb_init_mrblib(mrb_state *mrb)
 {
 }
-
diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c
index 12cdc86e9..65eae57e1 100644
--- a/tools/mruby/mruby.c
+++ b/tools/mruby/mruby.c
@@ -9,8 +9,6 @@
 
 void mrb_show_version(mrb_state *);
 void mrb_show_copyright(mrb_state *);
-void parser_dump(mrb_state*, struct mrb_ast_node*, int);
-void codedump_all(mrb_state*, int);
 
 struct _args {
   FILE *rfp;
@@ -149,7 +147,7 @@ main(int argc, char **argv)
   int n = -1;
   int i;
   struct _args args;
-  struct mrb_parser_state *p;
+  mrb_value ARGV;
 
   if (mrb == NULL) {
     fprintf(stderr, "Invalid mrb_state, exiting mruby");
@@ -163,50 +161,42 @@ main(int argc, char **argv)
     return n;
   }
 
+  ARGV = mrb_ary_new(mrb);
+  for (i = 0; i < args.argc; i++) {
+    mrb_ary_push(mrb, ARGV, mrb_str_new(mrb, args.argv[i], strlen(args.argv[i])));
+  }
+  mrb_define_global_const(mrb, "ARGV", ARGV);
+
   if (args.mrbfile) {
     n = mrb_load_irep(mrb, args.rfp);
+    if (n >= 0) {
+      if (!args.check_syntax) {
+	mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
+	if (mrb->exc) {
+	  mrb_p(mrb, mrb_obj_value(mrb->exc));
+	}
+      }
+    }
   }
   else {
     mrbc_context *c = mrbc_context_new(mrb);
+
+    if (args.verbose)
+      c->dump_result = 1;
+    if (args.check_syntax)
+      c->no_exec = 1;
+
     if (args.cmdline) {
       mrbc_filename(mrb, c, "-e");
-      p = mrb_parse_string(mrb, (char*)args.cmdline, c); 
-   }
+      mrb_load_string_cxt(mrb, (char*)args.cmdline, c);
+    }
     else {
       mrbc_filename(mrb, c, argv[1]);
-      p = mrb_parse_file(mrb, args.rfp, c);
+      mrb_load_file_cxt(mrb, args.rfp, c);
     }
     mrbc_context_free(mrb, c);
-    if (!p || !p->tree || p->nerr) {
-      cleanup(mrb, &args);
       return -1;
-    }
-
-    if (args.verbose)
-      parser_dump(mrb, p->tree, 0);
-
-    n = mrb_generate_code(mrb, p->tree);
-    mrb_parser_free(p);
-  }
-
-  if (n >= 0) {
-    mrb_value ARGV = mrb_ary_new(mrb);
-    for (i = 0; i < args.argc; i++) {
-      mrb_ary_push(mrb, ARGV, mrb_str_new(mrb, args.argv[i], strlen(args.argv[i])));
-    }
-    mrb_define_global_const(mrb, "ARGV", ARGV);
-
-    if (args.verbose)
-      codedump_all(mrb, n);
-
-    if (!args.check_syntax) {
-      mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
-      if (mrb->exc) {
-        mrb_p(mrb, mrb_obj_value(mrb->exc));
-      }
-    }
   }
-
   cleanup(mrb, &args);
 
   return n > 0 ? 0 : 1;
-- 
cgit v1.2.3


From e3806922245c15ff9417ca4513c9052ebfa40021 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sat, 14 Jul 2012 07:38:43 +0900
Subject: mrb_load_xxx to return undef + mrb_undef_p

---
 include/mruby.h   | 2 +-
 src/kernel.c      | 2 +-
 src/parse.y       | 6 +++---
 src/sprintf.c     | 8 ++++----
 tools/mrbc/mrbc.c | 2 +-
 5 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index a9027d896..1124ba89c 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -81,7 +81,7 @@ typedef struct mrb_value {
 #define mrb_symbol(o) (o).value.sym
 #define mrb_object(o) ((struct RBasic *) (o).value.p)
 #define FIXNUM_P(o)   ((o).tt == MRB_TT_FIXNUM)
-#define UNDEF_P(o)    ((o).tt == MRB_TT_UNDEF)
+#define mrb_undef_p(o) ((o).tt == MRB_TT_UNDEF)
 
 #include "mruby/object.h"
 
diff --git a/src/kernel.c b/src/kernel.c
index 1040dbe05..240c0dcb3 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -1038,7 +1038,7 @@ mrb_obj_remove_instance_variable(mrb_state *mrb, mrb_value self)
 
   mrb_get_args(mrb, "n", &sym);
   val = mrb_iv_remove(mrb, self, sym);
-  if (UNDEF_P(val)) {
+  if (mrb_undef_p(val)) {
     mrb_name_error(mrb, sym, "instance variable %s not defined", mrb_sym2name(mrb, sym));
   }
   return val;
diff --git a/src/parse.y b/src/parse.y
index 5a22b3883..40960e313 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4874,7 +4874,7 @@ load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
 
   if (!p) {
     mrb_parser_free(p);
-    return mrb_nil_value();
+    return mrb_undef_value();
   }
   if (p->capture_errors && (!p->tree || p->nerr)) {
     char buf[256];
@@ -4883,13 +4883,13 @@ load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
 		 p->error_buffer[0].lineno, p->error_buffer[0].message);
     mrb->exc = (struct RObject*)mrb_object(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, n));
     mrb_parser_free(p);
-    return mrb_nil_value();
+    return mrb_undef_value();
   }
   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", 13));
-    return mrb_nil_value();
+    return mrb_undef_value();
   }
   if (c) {
     if (c->dump_result) codedump_all(mrb, n);
diff --git a/src/sprintf.c b/src/sprintf.c
index d6104ad48..b597ff343 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -145,7 +145,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
   blen += (l);\
 } while (0)
 
-#define GETARG() (!UNDEF_P(nextvalue) ? nextvalue : \
+#define GETARG() (!mrb_undef_p(nextvalue) ? nextvalue : \
   posarg == -1 ? \
   (mrb_raise(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with numbered", nextarg), mrb_undef_value()) : \
   posarg == -2 ? \
@@ -201,7 +201,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
 {
   mrb_value tmp;
 
-  if (!UNDEF_P(*hash)) return *hash;
+  if (!mrb_undef_p(*hash)) return *hash;
   if (argc != 2) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
   }
@@ -586,7 +586,7 @@ retry:
       n = 0;
       GETNUM(n, width);
       if (*p == '$') {
-        if (!UNDEF_P(nextvalue)) {
+        if (!mrb_undef_p(nextvalue)) {
           mrb_raise(mrb, E_ARGUMENT_ERROR, "value given twice - %d$", n);
         }
         nextvalue = GETPOSARG(n);
@@ -614,7 +614,7 @@ retry:
         symname = mrb_str_new(mrb, start + 1, p - start - 1);
         id = mrb_intern_str(mrb, symname);
         nextvalue = GETNAMEARG(mrb_symbol_value(id), start, (int)(p - start + 1));
-        if (UNDEF_P(nextvalue)) {
+        if (mrb_undef_p(nextvalue)) {
           mrb_raise(mrb, E_KEY_ERROR, "key%.*s not found", (int)(p - start + 1), start);
         }
         if (term == '}') goto format_s;
diff --git a/tools/mrbc/mrbc.c b/tools/mrbc/mrbc.c
index a70353d63..a121eaa0e 100644
--- a/tools/mrbc/mrbc.c
+++ b/tools/mrbc/mrbc.c
@@ -179,7 +179,7 @@ main(int argc, char **argv)
     c->dump_result = 1;
   c->no_exec = 1;
   result = mrb_load_file_cxt(mrb, args.rfp, c);
-  if (mrb_nil_p(result)) {
+  if (mrb_undef_p(result)) {
     cleanup(&args);
     mrb_close(mrb);
     return -1;
-- 
cgit v1.2.3


From 96366117ea4bd91bccf00110469765ebc1ebaa8c Mon Sep 17 00:00:00 2001
From: Junji Sawada <junjis@dzeta.jp>
Date: Sat, 14 Jul 2012 11:39:25 +0900
Subject: Remove unnecessary header inclusion

---
 include/mruby/khash.h | 1 -
 src/cdump.c           | 1 -
 src/codegen.c         | 3 ---
 src/error.c           | 5 -----
 src/gc.c              | 3 +--
 src/hash.c            | 1 -
 src/kernel.c          | 5 -----
 src/numeric.c         | 4 ----
 src/proc.c            | 1 -
 src/range.c           | 3 ---
 src/sprintf.c         | 1 -
 src/string.c          | 3 +--
 src/struct.c          | 4 ----
 src/symbol.c          | 4 ----
 src/variable.c        | 2 --
 15 files changed, 2 insertions(+), 39 deletions(-)

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index 0803521b7..09b23f6af 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -12,7 +12,6 @@ extern "C" {
 #endif
 
 #include <stdint.h>
-#include <stdlib.h>
 #include <string.h>
 
 typedef uint32_t khint_t;
diff --git a/src/cdump.c b/src/cdump.c
index 16c1dc8ae..a4a2ac5e1 100644
--- a/src/cdump.c
+++ b/src/cdump.c
@@ -10,7 +10,6 @@
 
 #include "mruby/irep.h"
 #include "mruby/string.h"
-#include "re.h"
 
 #define MRB_CDUMP_LINE_LEN 128
 
diff --git a/src/codegen.c b/src/codegen.c
index 6db09f310..9166b7144 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -10,15 +10,12 @@
 #include "mruby.h"
 #include "mruby/string.h"
 #include "mruby/irep.h"
-#include "mruby/proc.h"
 #include "mruby/compile.h"
 #include "mruby/numeric.h"
 #include "opcode.h"
 #include "node.h"
 #include <string.h>
 #include <stdlib.h>
-#include <errno.h>
-#include <limits.h>
 #include <ctype.h>
 
 typedef mrb_ast_node node;
diff --git a/src/error.c b/src/error.c
index e46e37cbb..5bfbc4319 100644
--- a/src/error.c
+++ b/src/error.c
@@ -6,14 +6,9 @@
 
 #include "mruby.h"
 #include <stdarg.h>
-#include <string.h>
 #include <stdio.h>
 #include <setjmp.h>
 #include "error.h"
-#include "opcode.h"
-#include "mruby/irep.h"
-#include "mruby/proc.h"
-#include "mruby/numeric.h"
 #include "mruby/variable.h"
 #include "mruby/string.h"
 #include "mruby/class.h"
diff --git a/src/gc.c b/src/gc.c
index ada0bf31f..3c00bb015 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -11,12 +11,10 @@
 #include "mruby/string.h"
 #include "mruby/hash.h"
 #include "mruby/range.h"
-#include "mruby/khash.h"
 #include <string.h>
 #include "mruby/struct.h"
 #include "mruby/proc.h"
 #include "mruby/data.h"
-#include "mruby/numeric.h"
 #include "mruby/variable.h"
 
 /*
@@ -101,6 +99,7 @@ typedef struct {
 } RVALUE;
 
 #ifdef GC_PROFILE
+#include <stdio.h>
 #include <sys/time.h>
 
 static double program_invoke_time = 0;
diff --git a/src/hash.c b/src/hash.c
index ed8b70270..dacef4713 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -11,7 +11,6 @@
 #include "mruby/array.h"
 #include "mruby/string.h"
 #include "mruby/variable.h"
-#include <string.h>
 
 static inline khint_t
 mrb_hash_ht_hash_func(mrb_state *mrb, mrb_value key)
diff --git a/src/kernel.c b/src/kernel.c
index 240c0dcb3..f5a1f3d53 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -6,14 +6,9 @@
 
 #include "mruby.h"
 #include "mruby/string.h"
-#include <string.h>
-#include <stdlib.h>
 #include "mruby/proc.h"
-#include "mruby/range.h"
 #include "mruby/array.h"
-#include "mruby/hash.h"
 #include "mruby/class.h"
-#include "mruby/struct.h"
 #include "mruby/variable.h"
 #include "error.h"
 
diff --git a/src/numeric.c b/src/numeric.c
index 6638cf62c..ec3f97ca6 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -8,11 +8,7 @@
 #include "mruby/numeric.h"
 #include "mruby/string.h"
 #include "mruby/array.h"
-#include <string.h>
-#include "mruby/class.h"
-#include "mruby/variable.h"
 
-#include <ctype.h>
 #include <math.h>
 #include <stdio.h>
 #include <assert.h>
diff --git a/src/proc.c b/src/proc.c
index 98f753ac6..3e9bf1f67 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -6,7 +6,6 @@
 
 #include "mruby.h"
 #include "mruby/proc.h"
-#include "mruby/array.h"
 #include "mruby/class.h"
 #include "opcode.h"
 
diff --git a/src/range.c b/src/range.c
index 703ad12aa..b05836914 100644
--- a/src/range.c
+++ b/src/range.c
@@ -7,9 +7,6 @@
 #include "mruby.h"
 #include "mruby/class.h"
 #include "mruby/range.h"
-#include "mruby/variable.h"
-#include "error.h"
-#include "mruby/numeric.h"
 #include "mruby/string.h"
 #include <string.h>
 
diff --git a/src/sprintf.c b/src/sprintf.c
index b597ff343..519e40b4b 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -15,7 +15,6 @@
 #include "mruby/hash.h"
 #include "mruby/numeric.h"
 #include <math.h>
-#include <stdarg.h>
 #include <ctype.h>
 
 #ifdef HAVE_IEEEFP_H
diff --git a/src/string.c b/src/string.c
index 14da83c51..e41116ebc 100644
--- a/src/string.c
+++ b/src/string.c
@@ -10,11 +10,10 @@
 #include <string.h>
 #include "mruby/string.h"
 #include <ctype.h>
-#include "mruby/numeric.h"
+#include <limits.h>
 #include "mruby/range.h"
 #include "mruby/array.h"
 #include "mruby/class.h"
-#include "mruby/variable.h"
 #include <stdio.h>
 #ifdef ENABLE_REGEXP
 #include "re.h"
diff --git a/src/struct.c b/src/struct.c
index 25cd02d3d..6d8ce057f 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -17,13 +17,9 @@
 #include "encoding.h"
 #endif
 
-#include "mruby/numeric.h"
-#include "mruby/hash.h"
 #include "mruby/string.h"
 #include "mruby/class.h"
 #include "mruby/variable.h"
-#include "mruby/range.h"
-#include "error.h"
 //#include "defines.h"
 #define mrb_long2int(n) ((int)(n))
 
diff --git a/src/symbol.c b/src/symbol.c
index baab0fb3c..40484d4b5 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -8,12 +8,8 @@
 #include "mruby/khash.h"
 #include <string.h>
 
-#include <stdarg.h>
-#include <string.h>
 #include "mruby/string.h"
 #include <ctype.h>
-#include "mruby/class.h"
-#include "mruby/variable.h"
 
 /* ------------------------------------------------------ */
 typedef struct symbol_name {
diff --git a/src/variable.c b/src/variable.c
index e2f3a7d08..be686bf72 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -8,8 +8,6 @@
 #include "mruby/class.h"
 #include "mruby/khash.h"
 #include "mruby/variable.h"
-#include "mruby/string.h"
-#include "mruby/range.h"
 #include "error.h"
 #include "mruby/array.h"
 
-- 
cgit v1.2.3


From 7bbac9cfdf3a1b8e8c5697c060b5cb812a1f6949 Mon Sep 17 00:00:00 2001
From: Junji Sawada <junjis@dzeta.jp>
Date: Sat, 14 Jul 2012 12:13:48 +0900
Subject: Rename confusable argument name

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

(limited to 'include')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index 4dd369adb..aae1b06b1 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -111,11 +111,11 @@ int mrb_generate_code(mrb_state*, mrb_ast_node*);
 
 /* program load functions */
 mrb_value mrb_load_file(mrb_state*,FILE*);
-mrb_value mrb_load_string(mrb_state *mrb, const char *path);
-mrb_value mrb_load_nstring(mrb_state *mrb, const char *path, int len);
+mrb_value mrb_load_string(mrb_state *mrb, const char *s);
+mrb_value mrb_load_nstring(mrb_state *mrb, const char *s, int len);
 mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
-mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *path, mrbc_context *cxt);
-mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *path, int len, mrbc_context *cxt);
+mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *cxt);
+mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *cxt);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
-- 
cgit v1.2.3


From 234b8e853cc8b3bac2945832d589562e41da1456 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Sun, 15 Jul 2012 16:37:23 +0900
Subject: make class_from_sym static

---
 include/mruby.h |  1 -
 src/class.c     | 27 +++++++++++++++++++--------
 src/variable.c  | 13 -------------
 3 files changed, 19 insertions(+), 22 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 1124ba89c..137a1b94e 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -297,7 +297,6 @@ void mrb_undef_method(mrb_state*, struct RClass*, const char*);
 mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
 struct RClass * mrb_module_new(mrb_state *mrb);
-struct RClass * mrb_class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym name);
 struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
 struct RClass * mrb_class_obj_get(mrb_state *mrb, const char *name);
 
diff --git a/src/class.c b/src/class.c
index 783627a7d..3985800d0 100644
--- a/src/class.c
+++ b/src/class.c
@@ -216,6 +216,23 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id
   return c;
 }
 
+static struct RClass *
+class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id)
+{
+  mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id);
+
+  if (c.tt != MRB_TT_MODULE && c.tt != MRB_TT_CLASS) {
+    mrb_raise(mrb, E_TYPE_ERROR, "%s is not a class/module", mrb_sym2name(mrb, id));
+  }
+  return mrb_class_ptr(c);
+}
+
+struct RClass *
+mrb_class_get(mrb_state *mrb, const char *name)
+{
+  return class_from_sym(mrb, mrb->object_class, mrb_intern(mrb, name));
+}
+
 /*!
  * Defines a class under the namespace of \a outer.
  * \param outer  a class which contains the new class.
@@ -239,10 +256,7 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s
   mrb_sym id = mrb_intern(mrb, name);
 
   if (mrb_const_defined_at(mrb, outer, id)) {
-    c = mrb_class_from_sym(mrb, outer, id);
-    if (c->tt != MRB_TT_CLASS) {
-        mrb_raise(mrb, E_TYPE_ERROR, "%s is not a class", mrb_sym2name(mrb, id));
-    }
+    c = class_from_sym(mrb, outer, id);
     if (mrb_class_real(c->super) != super) {
         mrb_name_error(mrb, id, "%s is already defined", mrb_sym2name(mrb, id));
     }
@@ -266,10 +280,7 @@ mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
   mrb_sym id = mrb_intern(mrb, name);
 
   if (mrb_const_defined_at(mrb, outer, id)) {
-    c = mrb_class_from_sym(mrb, outer, id);
-    if (c->tt != MRB_TT_MODULE) {
-        mrb_raise(mrb, E_TYPE_ERROR, "%s is not a module", mrb_sym2name(mrb, id));
-    }
+    c = class_from_sym(mrb, outer, id);
     return c;
   }
   c = mrb_module_new(mrb);
diff --git a/src/variable.c b/src/variable.c
index be686bf72..501bed5a6 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -495,19 +495,6 @@ mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id)
   return mrb_const_defined_0(mrb, klass, id, TRUE, FALSE);
 }
 
-struct RClass *
-mrb_class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id)
-{
-  mrb_value c = const_get(mrb, klass, id);
-  return mrb_class_ptr(c);
-}
-
-struct RClass *
-mrb_class_get(mrb_state *mrb, const char *name)
-{
-  return mrb_class_from_sym(mrb, mrb->object_class, mrb_intern(mrb, name));
-}
-
 mrb_value
 mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id)
 {
-- 
cgit v1.2.3


From 36664174cb5f4150533f51b36b19491474023988 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Tue, 17 Jul 2012 23:48:55 +0900
Subject: change return type of mrb_p() to void

---
 include/mruby.h | 2 +-
 src/print.c     | 6 ++----
 2 files changed, 3 insertions(+), 5 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 137a1b94e..8afde3439 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -354,7 +354,7 @@ int mrb_checkstack(mrb_state*,int);
 mrb_value mrb_top_self(mrb_state *);
 mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
 
-mrb_value mrb_p(mrb_state*, mrb_value);
+void mrb_p(mrb_state*, mrb_value);
 mrb_int mrb_obj_id(mrb_value obj);
 mrb_sym mrb_to_id(mrb_state *mrb, mrb_value name);
 
diff --git a/src/print.c b/src/print.c
index 1b199fb44..e081989d2 100644
--- a/src/print.c
+++ b/src/print.c
@@ -27,13 +27,12 @@ printstr(mrb_state *mrb, mrb_value obj)
   }
 }
 
-mrb_value
+void
 mrb_p(mrb_state *mrb, mrb_value obj)
 {
   obj = mrb_funcall(mrb, obj, "inspect", 0);
   printstr(mrb, obj);
   putc('\n', stdout);
-  return obj;
 }
 
 /* 15.3.1.2.9  */
@@ -72,10 +71,9 @@ mrb_show_copyright(mrb_state *mrb)
   printf("mruby - Copyright (c) 2010-2012 mruby developers\n");
 }
 #else
-mrb_value
+void
 mrb_p(mrb_state *mrb, mrb_value obj)
 {
-  return obj;
 }
 
 void
-- 
cgit v1.2.3


From f146fd039706c426c738fc1186a86fa1fca89a4a Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Wed, 18 Jul 2012 15:47:57 +0900
Subject: MRB_FUNCALL_ARGC_MAX support. (refs comments in #324).

---
 include/mrbconf.h |  4 ++++
 src/class.c       | 20 +++++++++++++++-----
 2 files changed, 19 insertions(+), 5 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 5d307e66f..757192d89 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -23,6 +23,10 @@
 
 #undef  HAVE_UNISTD_H /* WINDOWS */
 #define HAVE_UNISTD_H /* LINUX */
+
+#define MRB_FUNCALL_ARGC_MAX 16U /* Allocate arrays using auto variable. */
+//#undef MRB_FUNCALL_ARGC_MAX /* Allocate arrays using mrb_malloc if undefned. */
+
 /* end of configuration */
 
 #ifdef MRB_USE_FLOAT
diff --git a/src/class.c b/src/class.c
index bf63198dd..762fa1591 100644
--- a/src/class.c
+++ b/src/class.c
@@ -7,7 +7,6 @@
 #include "mruby.h"
 #include <stdarg.h>
 #include <stdio.h>
-#include <assert.h>
 #include "mruby/class.h"
 #include "mruby/proc.h"
 #include "mruby/string.h"
@@ -866,27 +865,38 @@ 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;
+#if defined(MRB_FUNCALL_ARGC_MAX)
+  mrb_value args[MRB_FUNCALL_ARGC_MAX];
+#else
+  mrb_value *args = NULL;
+#endif
   mrb_value result;
   va_list ap;
   int i;
 
   if (argc != 0) {
+#if !defined(MRB_FUNCALL_ARGC_MAX)
     args = mrb_malloc(mrb, sizeof(mrb_value) * argc);
-    assert(args != 0);
+#else
+    if (argc > MRB_FUNCALL_ARGC_MAX) {
+      mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)\n", MRB_FUNCALL_ARGC_MAX);
+    } 
+#endif
 
     va_start(ap, argc);
     for (i = 0; i < argc; i++) {
       args[i] = va_arg(ap, mrb_value);
     }
     va_end(ap);
-  } else {
-    args = NULL;
   }
+
   result = mrb_funcall_argv(mrb, self, name, argc, args);
+
+#if !defined(MRB_FUNCALL_ARGC_MAX)
   if (args != NULL) {
     mrb_free(mrb, args);
   }
+#endif
 
   return result;
 }
-- 
cgit v1.2.3


From 8ae67d10b33aef56eab8ccd13b2a7471968df1ee Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 19 Jul 2012 11:28:06 +0900
Subject: make MRB_ARENA_SIZE to be configurable

---
 include/mruby.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 8afde3439..7abf66cb9 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -190,7 +190,9 @@ struct mrb_state;
 
 typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t);
 
-#define MRB_ARENA_SIZE 1024  //256 up kusuda 2011/04/30
+#ifndef MRB_ARENA_SIZE
+#define MRB_ARENA_SIZE 1024
+#endif
 #define ruby_debug   (mrb_nil_value())
 #define ruby_verbose (mrb_nil_value())
 
-- 
cgit v1.2.3


From 4b9ef5dabee09115edc15ecad05b335ecfaf598d Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 19 Jul 2012 17:45:13 +0900
Subject: use no malloc in mrb_funcall; close #386

---
 include/mrbconf.h |  5 ++---
 src/class.c       | 24 +++++-------------------
 2 files changed, 7 insertions(+), 22 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 757192d89..cf8217b23 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -21,12 +21,11 @@
 //#define DISABLE_STRUCT	/* Struct class */
 //#define DISABLE_STDIO		/* use of stdio */
 
+//#define MRB_FUNCALL_ARGC_MAX 16 /* argv size in mrb_funcall */
+
 #undef  HAVE_UNISTD_H /* WINDOWS */
 #define HAVE_UNISTD_H /* LINUX */
 
-#define MRB_FUNCALL_ARGC_MAX 16U /* Allocate arrays using auto variable. */
-//#undef MRB_FUNCALL_ARGC_MAX /* Allocate arrays using mrb_malloc if undefned. */
-
 /* end of configuration */
 
 #ifdef MRB_USE_FLOAT
diff --git a/src/class.c b/src/class.c
index 762fa1591..38eb5ea1f 100644
--- a/src/class.c
+++ b/src/class.c
@@ -862,26 +862,21 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
   return m;
 }
 
+#ifndef MRB_FUNCALL_ARGC_MAX
+#define MRB_FUNCALL_ARGC_MAX 16
+#endif
+
 mrb_value
 mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
 {
-#if defined(MRB_FUNCALL_ARGC_MAX)
   mrb_value args[MRB_FUNCALL_ARGC_MAX];
-#else
-  mrb_value *args = NULL;
-#endif
-  mrb_value result;
   va_list ap;
   int i;
 
   if (argc != 0) {
-#if !defined(MRB_FUNCALL_ARGC_MAX)
-    args = mrb_malloc(mrb, sizeof(mrb_value) * argc);
-#else
     if (argc > MRB_FUNCALL_ARGC_MAX) {
       mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)\n", MRB_FUNCALL_ARGC_MAX);
     } 
-#endif
 
     va_start(ap, argc);
     for (i = 0; i < argc; i++) {
@@ -889,16 +884,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
     }
     va_end(ap);
   }
-
-  result = mrb_funcall_argv(mrb, self, name, argc, args);
-
-#if !defined(MRB_FUNCALL_ARGC_MAX)
-  if (args != NULL) {
-    mrb_free(mrb, args);
-  }
-#endif
-
-  return result;
+  return mrb_funcall_argv(mrb, self, name, argc, args);
 }
 
 
-- 
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 'include')

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 ea259129993cf7eb6ffc0b8bb76719913fea314c Mon Sep 17 00:00:00 2001
From: Max Anselm <silverhammermba+github@gmail.com>
Date: Wed, 25 Jul 2012 18:22:26 -0400
Subject: Undefine new for class rather than instance.

Applies to NilClass, TrueClass, FalseClass, Fixnum, and Float. Add
mrb_undef_class_method for DRYness.
---
 include/mruby.h | 1 +
 src/class.c     | 6 ++++++
 src/numeric.c   | 4 ++--
 src/object.c    | 6 +++---
 src/re.c        | 2 +-
 5 files changed, 13 insertions(+), 6 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index 4fd7bccd5..6fcda4d35 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -296,6 +296,7 @@ void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_f
 void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t,int);
 void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
 void mrb_undef_method(mrb_state*, struct RClass*, const char*);
+void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
 mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
 struct RClass * mrb_module_new(mrb_state *mrb);
diff --git a/src/class.c b/src/class.c
index b8532cdcc..f0393c7ec 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1307,6 +1307,12 @@ mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name)
   undef_method(mrb, c, mrb_intern(mrb, name));
 }
 
+void
+mrb_undef_class_method(mrb_state *mrb, struct RClass *c, const char *name)
+{
+  mrb_undef_method(mrb,  mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
+}
+
 mrb_value
 mrb_mod_undef(mrb_state *mrb, mrb_value mod)
 {
diff --git a/src/numeric.c b/src/numeric.c
index ec3f97ca6..d294597ee 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -1288,7 +1288,7 @@ mrb_init_numeric(mrb_state *mrb)
   integer = mrb_define_class(mrb, "Integer",  numeric);
   fixnum = mrb->fixnum_class = mrb_define_class(mrb, "Fixnum", integer);
 
-  mrb_undef_method(mrb,  fixnum, "new");
+  mrb_undef_class_method(mrb,  fixnum, "new");
   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  */
@@ -1316,7 +1316,7 @@ mrb_init_numeric(mrb_state *mrb)
 
   /* Float Class */
   fl = mrb->float_class = mrb_define_class(mrb, "Float", numeric);
-  mrb_undef_method(mrb,  fl, "new");
+  mrb_undef_class_method(mrb,  fl, "new");
   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  */
diff --git a/src/object.c b/src/object.c
index 29684b118..43e064fb0 100644
--- a/src/object.c
+++ b/src/object.c
@@ -275,7 +275,7 @@ mrb_init_object(mrb_state *mrb)
   struct RClass *f;
 
   n = mrb->nil_class   = mrb_define_class(mrb, "NilClass",   mrb->object_class);
-  mrb_undef_method(mrb,  n, "new");
+  mrb_undef_class_method(mrb, n, "new");
   mrb_define_method(mrb, n, "&",    false_and,      ARGS_REQ(1));  /* 15.2.4.3.1  */
   mrb_define_method(mrb, n, "^",    false_xor,      ARGS_REQ(1));  /* 15.2.4.3.2  */
   mrb_define_method(mrb, n, "|",    false_or,       ARGS_REQ(1));  /* 15.2.4.3.3  */
@@ -283,14 +283,14 @@ mrb_init_object(mrb_state *mrb)
   mrb_define_method(mrb, n, "to_s", nil_to_s,       ARGS_NONE());  /* 15.2.4.3.5  */
 
   t = mrb->true_class  = mrb_define_class(mrb, "TrueClass",  mrb->object_class);
-  mrb_undef_method(mrb,  n, "new");
+  mrb_undef_class_method(mrb, t, "new");
   mrb_define_method(mrb, t, "&",    true_and,       ARGS_REQ(1));  /* 15.2.5.3.1  */
   mrb_define_method(mrb, t, "^",    true_xor,       ARGS_REQ(1));  /* 15.2.5.3.2  */
   mrb_define_method(mrb, t, "to_s", true_to_s,      ARGS_NONE());  /* 15.2.5.3.3  */
   mrb_define_method(mrb, t, "|",    true_or,        ARGS_REQ(1));  /* 15.2.5.3.4  */
 
   f = mrb->false_class = mrb_define_class(mrb, "FalseClass", mrb->object_class);
-  mrb_undef_method(mrb,  n, "new");
+  mrb_undef_class_method(mrb, f, "new");
   mrb_define_method(mrb, f, "&",    false_and,      ARGS_REQ(1));  /* 15.2.6.3.1  */
   mrb_define_method(mrb, f, "^",    false_xor,      ARGS_REQ(1));  /* 15.2.6.3.2  */
   mrb_define_method(mrb, f, "to_s", false_to_s,     ARGS_NONE());  /* 15.2.6.3.3  */
diff --git a/src/re.c b/src/re.c
index 3639a41c6..f3cfea484 100644
--- a/src/re.c
+++ b/src/re.c
@@ -2041,7 +2041,7 @@ mrb_init_regexp(mrb_state *mrb)
     mrb_define_const(mrb, s, "FIXEDENCODING", mrb_fixnum_value(ARG_ENCODING_FIXED));
 
     s = mrb_define_class(mrb, "MatchData", mrb->object_class);
-    //mrb_undef_method(CLASS_OF(rb_cMatch), "new");
+    //mrb_undef_class_method(CLASS_OF(rb_cMatch), "new");
 
     mrb_define_method(mrb, s, "[]",              mrb_match_aref,        ARGS_ANY());                     /* 15.2.16.3.1  */
     mrb_define_method(mrb, s, "begin",           mrb_match_begin,       ARGS_REQ(1));                    /* 15.2.16.3.2  */
-- 
cgit v1.2.3


From 22b032fcdf4bc73eb2aaaafc823c10b5cd0ade31 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Sun, 29 Jul 2012 20:11:43 +0900
Subject: mrb_hash_delete_key(), mrb_hash_keys() : Declare as static.
 mrb_check_hash_type(): Remove as no implementation.

---
 include/mruby/hash.h | 3 ---
 src/hash.c           | 4 ++--
 2 files changed, 2 insertions(+), 5 deletions(-)

(limited to 'include')

diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 7a16d7b5a..f3755eb25 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -26,10 +26,7 @@ mrb_value mrb_hash_new(mrb_state *mrb);
 void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
 mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
 mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
-mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
-mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
 mrb_value mrb_hash(mrb_state *mrb, mrb_value obj);
-mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value self);
 
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)((obj).value.p))
diff --git a/src/hash.c b/src/hash.c
index 5d3835019..927e40e66 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -488,7 +488,7 @@ mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash)
   return ifnone;
 }
 
-mrb_value
+static mrb_value
 mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
@@ -965,7 +965,7 @@ mrb_hash_to_hash(mrb_state *mrb, mrb_value hash)
  *
  */
 
-mrb_value
+static mrb_value
 mrb_hash_keys(mrb_state *mrb, mrb_value hash)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
-- 
cgit v1.2.3


From 7ac4b56141db4a4bea28ddd1874b98b92f231150 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Sun, 29 Jul 2012 20:35:23 +0900
Subject: Remove unimplemented declarations.

---
 include/mruby/array.h    | 1 -
 include/mruby/numeric.h  | 1 -
 include/mruby/string.h   | 3 ---
 include/mruby/struct.h   | 3 ---
 include/mruby/variable.h | 1 -
 5 files changed, 9 deletions(-)

(limited to 'include')

diff --git a/include/mruby/array.h b/include/mruby/array.h
index f42146f3e..bc10d8919 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -54,7 +54,6 @@ mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
 mrb_value mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts);
 mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
 mrb_value mrb_ary_entry(mrb_value ary, int offset);
-mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary);
 mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
 
 #if defined(__cplusplus)
diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h
index a3768db2f..867aa27d9 100644
--- a/include/mruby/numeric.h
+++ b/include/mruby/numeric.h
@@ -18,7 +18,6 @@ extern "C" {
 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
 
 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);
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 1449a2edf..c6f7c4ab5 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -52,7 +52,6 @@ struct RString {
 void mrb_str_decref(mrb_state*, struct mrb_shared_string*);
 mrb_value mrb_str_literal(mrb_state*, mrb_value);
 void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
-mrb_value mrb_obj_to_str(mrb_state*, mrb_value);
 mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, int len); /* mrb_str_resize */
@@ -78,8 +77,6 @@ int mrb_str_hash_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
 mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2);
 mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
 int mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
-mrb_value * mrb_svar(mrb_int cnt);
-mrb_value mrb_str_drop_bytes(mrb_state *mrb, mrb_value str, long len);
 mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len);
 mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
diff --git a/include/mruby/struct.h b/include/mruby/struct.h
index 1aee64883..514f66dfe 100644
--- a/include/mruby/struct.h
+++ b/include/mruby/struct.h
@@ -20,9 +20,6 @@ struct RStruct {
 #define RSTRUCT_LEN(st) ((int)(RSTRUCT(st)->len))
 #define RSTRUCT_PTR(st) (RSTRUCT(st)->ptr)
 
-mrb_value mrb_yield_values(int n, ...);
-mrb_value mrb_mod_module_eval(mrb_state *mrb, int argc, mrb_value *argv, mrb_value mod);
-
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index a4ed9a0ee..e93a77c55 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -44,7 +44,6 @@ const char * mrb_class2name(mrb_state *mrb, struct RClass* klass);
 mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym);
 void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v);
 mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym);
-void mrb_copy_generic_ivar(mrb_value clone, mrb_value obj);
 int mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id);
 mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
 mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
-- 
cgit v1.2.3


From ee899778c4f6cb0d201e50996e73639eabf98704 Mon Sep 17 00:00:00 2001
From: Max Anselm <silverhammermba+github@gmail.com>
Date: Sun, 29 Jul 2012 19:44:49 -0400
Subject: Define __STDC_LIMIT_MACROS for INT32_MAX in C++

---
 include/mrbconf.h | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index cf8217b23..b0a33aa43 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -7,6 +7,9 @@
 #ifndef MRUBYCONF_H
 #define MRUBYCONF_H
 
+#if defined(__cplusplus)
+#define __STDC_LIMIT_MACROS
+#endif
 #include <stdint.h>
 
 /* configuration options: */
-- 
cgit v1.2.3


From eb34ad365b4fc70f174398b6898e14f3001aca69 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 30 Jul 2012 09:45:37 +0900
Subject: fixed the comment English

---
 include/mrbconf.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index b0a33aa43..45a5afabb 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -16,7 +16,7 @@
 /* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
 //#define MRB_USE_FLOAT
 
-/* -DDISABLE_XXXX to change to drop the feature */
+/* -DDISABLE_XXXX to drop the feature */
 #define DISABLE_REGEXP	        /* regular expression classes */
 //#define DISABLE_SPRINTF	/* Kernel.sprintf method */
 //#define DISABLE_MATH		/* Math functions */
-- 
cgit v1.2.3


From 446005620babeb0bf5ef8b8d2b6552c3c85aefd1 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 30 Jul 2012 10:51:24 +0900
Subject: remove __STDC_LIMIT_MACROS for INT32_MAX

---
 include/mrbconf.h | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 45a5afabb..0113136d6 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -7,9 +7,6 @@
 #ifndef MRUBYCONF_H
 #define MRUBYCONF_H
 
-#if defined(__cplusplus)
-#define __STDC_LIMIT_MACROS
-#endif
 #include <stdint.h>
 
 /* configuration options: */
-- 
cgit v1.2.3


From b1cc715b36166bcd6c1fff3ef3180115743cdae7 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Mon, 30 Jul 2012 15:31:49 +0900
Subject: MRB_INITIAL_HASH_SIZE : Make the initial hash size configurable.

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

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index 09b23f6af..a50698fc9 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -17,7 +17,10 @@ extern "C" {
 typedef uint32_t khint_t;
 typedef khint_t khiter_t;
 
-#define INITIAL_HASH_SIZE 32
+#if !defined(MRB_INITIAL_HASH_SIZE)
+# define MRB_INITIAL_HASH_SIZE 32
+#endif
+
 #define UPPER_BOUND(x) ((x)>>2|(x>>1))
 
 //extern uint8_t __m[];
@@ -88,7 +91,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   }                                                                     \
   kh_##name##_t *kh_init_##name(mrb_state *mrb){                        \
     kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
-    h->n_buckets = INITIAL_HASH_SIZE;                                   \
+    h->n_buckets = MRB_INITIAL_HASH_SIZE;                               \
     h->mrb = mrb;                                                       \
     kh_alloc_##name(h);                                                 \
     return h;                                                           \
@@ -123,14 +126,16 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   }                                                                     \
   void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets)        \
   {                                                                     \
-    if( new_n_buckets<INITIAL_HASH_SIZE ){                              \
-      new_n_buckets = INITIAL_HASH_SIZE;                                \
+    if( new_n_buckets<MRB_INITIAL_HASH_SIZE ){                          \
+      new_n_buckets = MRB_INITIAL_HASH_SIZE;                            \
     } else {                                                            \
       khint_t limit = new_n_buckets;                                    \
-      new_n_buckets = INITIAL_HASH_SIZE;                                \
-      while( new_n_buckets < limit ) new_n_buckets *= 2;                \
+      new_n_buckets = MRB_INITIAL_HASH_SIZE;                            \
+      while( new_n_buckets < limit ) {                                  \
+        new_n_buckets *= 2;                                             \
+      }                                                                 \
     }                                                                   \
-    {					                                                \
+    {                                                                   \
       uint8_t *old_e_flags = h->e_flags;                                \
       khkey_t *old_keys = h->keys;                                      \
       khval_t *old_vals = h->vals;                                      \
@@ -140,10 +145,10 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
       kh_alloc_##name(h);                                               \
       /* relocate */                                                    \
       for( i=0 ; i<old_n_buckets ; i++ ){                               \
-	if( !__ac_isempty(old_e_flags, old_d_flags, i) ){                   \
-	  khint_t k = kh_put_##name(h, old_keys[i]);                        \
-	  kh_value(h,k) = old_vals[i];                                      \
-	}                                                                   \
+        if( !__ac_isempty(old_e_flags, old_d_flags, i) ){               \
+          khint_t k = kh_put_##name(h, old_keys[i]);                    \
+          kh_value(h,k) = old_vals[i];                                  \
+        }                                                               \
       }                                                                 \
       mrb_free(h->mrb, old_e_flags);                                    \
       mrb_free(h->mrb, old_keys);                                       \
-- 
cgit v1.2.3


From c808f647aa8fde6e1698b25df15d7a93bafe4f42 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 30 Jul 2012 16:41:05 +0900
Subject: allow specifying khash initial size

---
 include/mruby/khash.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index a50698fc9..87ba44674 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -17,7 +17,7 @@ extern "C" {
 typedef uint32_t khint_t;
 typedef khint_t khiter_t;
 
-#if !defined(MRB_INITIAL_HASH_SIZE)
+#ifndef MRB_INITIAL_HASH_SIZE
 # define MRB_INITIAL_HASH_SIZE 32
 #endif
 
@@ -89,13 +89,16 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     h->mask = sz-1;                                                     \
     h->inc = sz/2-1;                                                    \
   }                                                                     \
-  kh_##name##_t *kh_init_##name(mrb_state *mrb){                        \
+  kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size) {  \
     kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
-    h->n_buckets = MRB_INITIAL_HASH_SIZE;                               \
+    h->n_buckets = size;                                                \
     h->mrb = mrb;                                                       \
     kh_alloc_##name(h);                                                 \
     return h;                                                           \
   }                                                                     \
+  kh_##name##_t *kh_init_##name(mrb_state *mrb){                        \
+    return kh_init_##name##_size(mrb, MRB_INITIAL_HASH_SIZE);           \
+  }                                                                     \
   void kh_destroy_##name(kh_##name##_t *h)                              \
   {                                                                     \
     if( h ){                                                            \
-- 
cgit v1.2.3


From e75c76ecee3a0b5b1b0b19d4fdd8c31b3e8bbd9b Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 30 Jul 2012 17:16:05 +0900
Subject: iv khash initial size to 8

---
 include/mruby/khash.h | 34 ++++++++++++++++++----------------
 src/variable.c        |  4 ++--
 2 files changed, 20 insertions(+), 18 deletions(-)

(limited to 'include')

diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index 87ba44674..b28cd0702 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -39,7 +39,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
    name: ash name
    khkey_t: key data type
    khval_t: value data type
-   kh_is_map: (not implemented / not used in RiteVM )
+   kh_is_map: (not implemented / not used in RiteVM)
 */
 #define KHASH_DECLARE(name, khkey_t, khval_t, kh_is_map)                \
   typedef struct kh_##name {                                            \
@@ -56,6 +56,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     mrb_state *mrb;                                                     \
   } kh_##name##_t;                                                      \
   void kh_alloc_##name(kh_##name##_t *h);                               \
+  kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size);   \
   kh_##name##_t *kh_init_##name(mrb_state *mrb);                        \
   void kh_destroy_##name(kh_##name##_t *h);                             \
   void kh_clear_##name(kh_##name##_t *h);                               \
@@ -70,7 +71,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
    name: ash name
    khkey_t: key data type
    khval_t: value data type
-   kh_is_map: (not implemented / not used in RiteVM )
+   kh_is_map: (not implemented / not used in RiteVM)
    __hash_func: hash function
    __hash_equal: hash comparation function
 */
@@ -101,7 +102,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   }                                                                     \
   void kh_destroy_##name(kh_##name##_t *h)                              \
   {                                                                     \
-    if( h ){                                                            \
+    if (h) {                                                            \
       mrb_free(h->mrb, h->keys);                                        \
       mrb_free(h->mrb, h->vals);                                        \
       mrb_free(h->mrb, h->e_flags);                                     \
@@ -110,7 +111,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   }                                                                     \
   void kh_clear_##name(kh_##name##_t *h)                                \
   {                                                                     \
-    if( h && h->e_flags ){                                              \
+    if (h && h->e_flags) {                                              \
       memset(h->e_flags, 0xff, h->n_buckets/8*sizeof(uint8_t));         \
       memset(h->d_flags, 0x00, h->n_buckets/8*sizeof(uint8_t));         \
       h->size = h->n_occupied = 0;                                      \
@@ -119,9 +120,9 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   khint_t kh_get_##name(kh_##name##_t *h, khkey_t key)                  \
   {                                                                     \
     khint_t k = __hash_func(h->mrb,key) & (h->mask);                    \
-    while( !__ac_isempty(h->e_flags, h->d_flags, k) ){                  \
-      if( !__ac_isdel(h->e_flags, h->d_flags, k) ){                     \
-        if( __hash_equal(h->mrb,h->keys[k], key) ) return k;            \
+    while (!__ac_isempty(h->e_flags, h->d_flags, k)) {                  \
+      if (!__ac_isdel(h->e_flags, h->d_flags, k)) {                     \
+        if (__hash_equal(h->mrb,h->keys[k], key)) return k;             \
       }                                                                 \
       k = (k+h->inc) & (h->mask);                                       \
     }                                                                   \
@@ -129,12 +130,12 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   }                                                                     \
   void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets)        \
   {                                                                     \
-    if( new_n_buckets<MRB_INITIAL_HASH_SIZE ){                          \
+    if (new_n_buckets<MRB_INITIAL_HASH_SIZE) {                          \
       new_n_buckets = MRB_INITIAL_HASH_SIZE;                            \
     } else {                                                            \
       khint_t limit = new_n_buckets;                                    \
       new_n_buckets = MRB_INITIAL_HASH_SIZE;                            \
-      while( new_n_buckets < limit ) {                                  \
+      while (new_n_buckets < limit)  {                                  \
         new_n_buckets *= 2;                                             \
       }                                                                 \
     }                                                                   \
@@ -147,8 +148,8 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
       h->n_buckets = new_n_buckets;                                     \
       kh_alloc_##name(h);                                               \
       /* relocate */                                                    \
-      for( i=0 ; i<old_n_buckets ; i++ ){                               \
-        if( !__ac_isempty(old_e_flags, old_d_flags, i) ){               \
+      for (i=0 ; i<old_n_buckets ; i++) {                               \
+        if (!__ac_isempty(old_e_flags, old_d_flags, i)) {               \
           khint_t k = kh_put_##name(h, old_keys[i]);                    \
           kh_value(h,k) = old_vals[i];                                  \
         }                                                               \
@@ -161,21 +162,21 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   khint_t kh_put_##name(kh_##name##_t *h, khkey_t key)                  \
   {                                                                     \
     khint_t k;                                                          \
-    if( h->n_occupied >= h->upper_bound ){                              \
+    if (h->n_occupied >= h->upper_bound) {                              \
       kh_resize_##name(h, h->n_buckets*2);                              \
     }                                                                   \
     k = __hash_func(h->mrb,key) & (h->mask);                            \
-    while( !__ac_iseither(h->e_flags, h->d_flags, k) ){                 \
-      if( __hash_equal(h->mrb,h->keys[k], key) ) break;                 \
+    while (!__ac_iseither(h->e_flags, h->d_flags, k)) {                 \
+      if (__hash_equal(h->mrb,h->keys[k], key)) break;                  \
       k = (k+h->inc) & (h->mask);                                       \
     }                                                                   \
-    if( __ac_isempty(h->e_flags, h->d_flags, k) ) {                     \
+    if (__ac_isempty(h->e_flags, h->d_flags, k)) {                      \
       /* put at empty */                                                \
       h->keys[k] = key;                                                 \
       h->e_flags[k/8] &= ~__m[k%8];                                     \
       h->size++;                                                        \
       h->n_occupied++;                                                  \
-    } else if( __ac_isdel(h->e_flags, h->d_flags, k) ) {                \
+    } else if (__ac_isdel(h->e_flags, h->d_flags, k)) {                 \
       /* put at del */                                                  \
       h->keys[k] = key;                                                 \
       h->d_flags[k/8] &= ~__m[k%8];                                     \
@@ -206,6 +207,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
 
 #define khash_t(name) kh_##name##_t
 
+#define kh_init_size(name,mrb,size) kh_init_##name##_size(mrb,size)
 #define kh_init(name,mrb) kh_init_##name(mrb)
 #define kh_destroy(name, h) kh_destroy_##name(h)
 #define kh_clear(name, h) kh_clear_##name(h)
diff --git a/src/variable.c b/src/variable.c
index 04e5ad9f7..49665a9ae 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -130,7 +130,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   khash_t(iv) *h;
 
   if (!obj->iv) {
-    h = obj->iv = kh_init(iv, mrb);
+    h = obj->iv = kh_init_size(iv, mrb, 8);
   }
   else {
     h = obj->iv;
@@ -266,7 +266,7 @@ mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   c = mrb->ci->target_class;
   h = c->iv;
   if (!h) {
-    c->iv = h = kh_init(iv, mrb);
+    c->iv = h = kh_init_size(iv, mrb, 8);
   }
   k = kh_put(iv, h, sym);
   kh_value(h, k) = v;
-- 
cgit v1.2.3


From d91f475e5514248ad660172d35ccdf21872d63e7 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 30 Jul 2012 17:16:13 +0900
Subject: better mrbconf decsription

---
 include/mrbconf.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 0113136d6..c4cf23017 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -13,6 +13,12 @@
 /* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
 //#define MRB_USE_FLOAT
 
+/* initial size of khash table bucket; should be power of 2 (n >= 8) */
+//#define MRB_INITIAL_HASH_SIZE 32
+
+/* argv max size in mrb_funcall */
+//#define MRB_FUNCALL_ARGC_MAX 16 
+
 /* -DDISABLE_XXXX to drop the feature */
 #define DISABLE_REGEXP	        /* regular expression classes */
 //#define DISABLE_SPRINTF	/* Kernel.sprintf method */
@@ -21,8 +27,6 @@
 //#define DISABLE_STRUCT	/* Struct class */
 //#define DISABLE_STDIO		/* use of stdio */
 
-//#define MRB_FUNCALL_ARGC_MAX 16 /* argv size in mrb_funcall */
-
 #undef  HAVE_UNISTD_H /* WINDOWS */
 #define HAVE_UNISTD_H /* LINUX */
 
-- 
cgit v1.2.3


From 0c55f7ecc3fa61fc3a1fd19c2632389377779305 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 30 Jul 2012 17:18:32 +0900
Subject: add description of MRB_HEAP_PAGE_SIZE

---
 include/mrbconf.h | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index c4cf23017..f5f8de969 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -19,6 +19,9 @@
 /* argv max size in mrb_funcall */
 //#define MRB_FUNCALL_ARGC_MAX 16 
 
+/* number of object per heap page */
+//#define MRB_HEAP_PAGE_SIZE 1024
+
 /* -DDISABLE_XXXX to drop the feature */
 #define DISABLE_REGEXP	        /* regular expression classes */
 //#define DISABLE_SPRINTF	/* Kernel.sprintf method */
-- 
cgit v1.2.3


From 515862cc015097144a003aa0f253af3a58dbab37 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 30 Jul 2012 23:55:35 +0900
Subject: khash refactoring; no more MRB_KHASH_INITIAL_SIZE

---
 include/mrbconf.h     |  6 +++---
 include/mruby/khash.h | 32 +++++++++++++++++++-------------
 2 files changed, 22 insertions(+), 16 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index f5f8de969..955e6538b 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -13,15 +13,15 @@
 /* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
 //#define MRB_USE_FLOAT
 
-/* initial size of khash table bucket; should be power of 2 (n >= 8) */
-//#define MRB_INITIAL_HASH_SIZE 32
-
 /* argv max size in mrb_funcall */
 //#define MRB_FUNCALL_ARGC_MAX 16 
 
 /* number of object per heap page */
 //#define MRB_HEAP_PAGE_SIZE 1024
 
+/* default size of khash table bucket */
+//#define KHASH_DEFAULT_SIZE 32
+
 /* -DDISABLE_XXXX to drop the feature */
 #define DISABLE_REGEXP	        /* regular expression classes */
 //#define DISABLE_SPRINTF	/* Kernel.sprintf method */
diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index b28cd0702..16a35c3d5 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -17,9 +17,10 @@ extern "C" {
 typedef uint32_t khint_t;
 typedef khint_t khiter_t;
 
-#ifndef MRB_INITIAL_HASH_SIZE
-# define MRB_INITIAL_HASH_SIZE 32
+#ifndef KHASH_DEFAULT_SIZE
+# define KHASH_DEFAULT_SIZE 32
 #endif
+#define KHASH_MIN_SIZE 8
 
 #define UPPER_BOUND(x) ((x)>>2|(x>>1))
 
@@ -32,7 +33,15 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
 #define __ac_isempty(e_flag, d_flag, i) (e_flag[(i)/8]&__m[(i)%8])
 #define __ac_isdel(e_flag, d_flag, i) (d_flag[(i)/8]&__m[(i)%8])
 #define __ac_iseither(e_flag, d_flag, i) (__ac_isempty(e_flag,d_flag,i)||__ac_isdel(e_flag,d_flag,i))
-
+#define khash_power2(v) do { \
+  v--;\
+  v |= v >> 1;\
+  v |= v >> 2;\
+  v |= v >> 4;\
+  v |= v >> 8;\
+  v |= v >> 16;\
+  v++;\
+} while (0);
 
 /* declare struct kh_xxx and kh_xxx_funcs
 
@@ -92,13 +101,16 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   }                                                                     \
   kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size) {  \
     kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
+    if (size < KHASH_MIN_SIZE)                                          \
+      size = KHASH_MIN_SIZE;                                            \
+    khash_power2(size);                                                 \
     h->n_buckets = size;                                                \
     h->mrb = mrb;                                                       \
     kh_alloc_##name(h);                                                 \
     return h;                                                           \
   }                                                                     \
   kh_##name##_t *kh_init_##name(mrb_state *mrb){                        \
-    return kh_init_##name##_size(mrb, MRB_INITIAL_HASH_SIZE);           \
+    return kh_init_##name##_size(mrb, KHASH_DEFAULT_SIZE);              \
   }                                                                     \
   void kh_destroy_##name(kh_##name##_t *h)                              \
   {                                                                     \
@@ -130,15 +142,9 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
   }                                                                     \
   void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets)        \
   {                                                                     \
-    if (new_n_buckets<MRB_INITIAL_HASH_SIZE) {                          \
-      new_n_buckets = MRB_INITIAL_HASH_SIZE;                            \
-    } else {                                                            \
-      khint_t limit = new_n_buckets;                                    \
-      new_n_buckets = MRB_INITIAL_HASH_SIZE;                            \
-      while (new_n_buckets < limit)  {                                  \
-        new_n_buckets *= 2;                                             \
-      }                                                                 \
-    }                                                                   \
+    if (new_n_buckets < KHASH_MIN_SIZE)                                 \
+      new_n_buckets = KHASH_MIN_SIZE;                                   \
+    khash_power2(new_n_buckets);                                        \
     {                                                                   \
       uint8_t *old_e_flags = h->e_flags;                                \
       khkey_t *old_keys = h->keys;                                      \
-- 
cgit v1.2.3


From d749ccfd3eb3f6020146ab287b0cea74f35e169f Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Mon, 30 Jul 2012 23:56:34 +0900
Subject: add description of MRB_IV_INITIAL_SIZE

---
 include/mrbconf.h | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 955e6538b..3d1e1757d 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -19,6 +19,9 @@
 /* number of object per heap page */
 //#define MRB_HEAP_PAGE_SIZE 1024
 
+/* initial size for IV khash */
+//#define MRB_IV_INITIAL_SIZE 8
+
 /* default size of khash table bucket */
 //#define KHASH_DEFAULT_SIZE 32
 
-- 
cgit v1.2.3


From 0cee3bb5317a220da7c123059a2c08daec288d30 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Tue, 31 Jul 2012 16:47:53 +0900
Subject: POOL_ALIGNMENT POOL_PAGE_SIZE : Configurable parameters.

---
 include/mrbconf.h | 6 ++++++
 src/pool.c        | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 3d1e1757d..20f49ec29 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -25,6 +25,12 @@
 /* default size of khash table bucket */
 //#define KHASH_DEFAULT_SIZE 32
 
+/* allocated memory address alignment */
+//#define POOL_ALIGNMENT 4
+
+/* page size of memory pool */
+//#define POOL_PAGE_SIZE 16000
+
 /* -DDISABLE_XXXX to drop the feature */
 #define DISABLE_REGEXP	        /* regular expression classes */
 //#define DISABLE_SPRINTF	/* Kernel.sprintf method */
diff --git a/src/pool.c b/src/pool.c
index 36c6fa8eb..daa6d0f69 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -9,7 +9,7 @@
 #include <string.h>
 
 /* configuration section */
-/* allcated memory address should be multiple of POOL_ALLOC_ALIGN */
+/* allocated memory address should be multiple of POOL_ALIGNMENT */
 /* or undef it if alignment does not matter */
 #ifndef POOL_ALIGNMENT
 #define POOL_ALIGNMENT 4
-- 
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 'include')

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 730f53045eb85cf995b0b675ea2818a682810a4f Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Fri, 3 Aug 2012 20:17:04 +0900
Subject: define_method to copy block body

---
 include/mruby/proc.h |  1 +
 src/class.c          |  7 +++++--
 src/proc.c           | 10 +++++-----
 3 files changed, 11 insertions(+), 7 deletions(-)

(limited to 'include')

diff --git a/include/mruby/proc.h b/include/mruby/proc.h
index 8f178790e..f6bef23a5 100644
--- a/include/mruby/proc.h
+++ b/include/mruby/proc.h
@@ -49,6 +49,7 @@ struct RProc {
 struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
 struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
 struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
+void mrb_proc_copy(struct RProc *a, struct RProc *b);
 
 #include "mruby/khash.h"
 KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1);
diff --git a/src/class.c b/src/class.c
index 29ec18e13..df42820e5 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1364,14 +1364,17 @@ static mrb_value
 mod_define_method(mrb_state *mrb, mrb_value self)
 {
   struct RClass *c = mrb_class_ptr(self);
+  struct RProc *p;
   mrb_sym mid;
   mrb_value blk;
 
   mrb_get_args(mrb, "n&", &mid, &blk);
   if (mrb_nil_p(blk)) {
-    /* raise */
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
   }
-  mrb_define_method_raw(mrb, c, mid, mrb_proc_ptr(blk));
+  p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class);
+  mrb_proc_copy(p, mrb_proc_ptr(blk));
+  mrb_define_method_raw(mrb, c, mid, p);
   return blk;
 }
 
diff --git a/src/proc.c b/src/proc.c
index d223fa760..a1f8b180e 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -55,8 +55,8 @@ mrb_proc_new_cfunc(mrb_state *mrb, mrb_func_t func)
   return p;
 }
 
-static inline void
-proc_copy(struct RProc *a, struct RProc *b)
+void
+mrb_proc_copy(struct RProc *a, struct RProc *b)
 {
   a->flags = b->flags;
   a->body = b->body;
@@ -75,7 +75,7 @@ mrb_proc_initialize(mrb_state *mrb, mrb_value self)
     mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block");
   }
   else {
-    proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(blk));
+    mrb_proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(blk));
   }
   return self;
 }
@@ -89,7 +89,7 @@ mrb_proc_init_copy(mrb_state *mrb, mrb_value self)
   if (mrb_type(proc) != MRB_TT_PROC) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "not a proc");
   }
-  proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(proc));
+  mrb_proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(proc));
   return self;
 }
 
@@ -133,7 +133,7 @@ proc_lambda(mrb_state *mrb, mrb_value self)
   p = mrb_proc_ptr(blk);
   if (!MRB_PROC_STRICT_P(p)) {
     struct RProc *p2 = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, p->c);
-    proc_copy(p2, p);
+    mrb_proc_copy(p2, p);
     p2->flags |= MRB_PROC_STRICT;
     return mrb_obj_value(p2);
   }
-- 
cgit v1.2.3