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 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'include/mruby.h')

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;
 
-- 
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/mruby.h')

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 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/mruby.h')

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 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/mruby.h')

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 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/mruby.h')

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 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/mruby.h')

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/mruby.h')

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/mruby.h')

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 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/mruby.h')

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 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/mruby.h')

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/mruby.h')

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/mruby.h')

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 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/mruby.h')

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 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/mruby.h')

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/mruby.h')

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 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/mruby.h')

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 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/mruby.h')

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/mruby.h')

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 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/mruby.h')

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