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

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

(limited to 'src/object.c')

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;
 }
-- 
cgit v1.2.3


From a6ebdc6580125847a79a455573bba32a92308bb9 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 14 Jun 2012 00:04:05 +0900
Subject: error message from mrb_convert_type has been changed

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

(limited to 'src/object.c')

diff --git a/src/object.c b/src/object.c
index 817137d8e..c9ea3f8eb 100644
--- a/src/object.c
+++ b/src/object.c
@@ -350,8 +350,8 @@ mrb_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname,
   if (mrb_type(val) == type) return val;
   v = convert_type(mrb, val, tname, method, 1/*Qtrue*/);
   if (mrb_type(v) != type) {
-    mrb_raise(mrb, E_TYPE_ERROR, "%s#%s should return %s",
-     mrb_obj_classname(mrb, val), method, tname);
+    mrb_raise(mrb, E_TYPE_ERROR, "%s cannot be converted to %s by #%s",
+     mrb_obj_classname(mrb, val), tname, method);
   }
   return v;
 }
-- 
cgit v1.2.3


From f564ec7e822c55e8ef6973170818263675b2499f Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Fri, 15 Jun 2012 00:56:00 +0900
Subject: Remove some redundant code.

---
 src/codegen.c  | 12 ------------
 src/error.c    | 30 ------------------------------
 src/error.h    |  1 -
 src/etc.c      |  8 --------
 src/hash.c     |  8 --------
 src/kernel.c   | 13 -------------
 src/load.c     |  8 --------
 src/object.c   |  8 --------
 src/parse.y    |  8 --------
 src/range.c    |  8 --------
 src/string.c   |  2 +-
 src/variable.c |  8 --------
 12 files changed, 1 insertion(+), 113 deletions(-)

(limited to 'src/object.c')

diff --git a/src/codegen.c b/src/codegen.c
index 1bdc2d21c..b64a18b96 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -298,20 +298,8 @@ push_(codegen_scope *s)
   s->sp++;
   nregs_update;
 }
-#if 0
-static void
-push_n_(codegen_scope *s, int n)
-{
-  if (s->sp + n > 511) {
-    codegen_error(s, "too complex expression");
-  }
-  s->sp += n;
-  nregs_update;
-}
-#endif
 
 #define push() push_(s)
-#define push_n(n) push_n_(s, n)
 #define pop()  (s->sp--)
 #define pop_n(n) (s->sp-=(n))
 #define cursp() (s->sp)
diff --git a/src/error.c b/src/error.c
index bb334322f..e6ccdf096 100644
--- a/src/error.c
+++ b/src/error.c
@@ -20,14 +20,6 @@
 
 #define warn_printf printf
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 mrb_value
 mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len)
 {
@@ -300,28 +292,6 @@ sysexit_status(mrb_state *mrb, mrb_value err)
   return mrb_fixnum(st);
 }
 
-void
-error_pos(void)
-{
-#if 0
-  const char *sourcefile = mrb_sourcefile();
-  int sourceline = mrb_sourceline();
-
-  if (sourcefile) {
-    if (sourceline == 0) {
-      warn_printf("%s", sourcefile);
-    }
-    else if (mrb_frame_callee()) {
-      warn_printf("%s:%d:in `%s'", sourcefile, sourceline,
-                mrb_sym2name(mrb, mrb_frame_callee()));
-    }
-    else {
-      warn_printf("%s:%d", sourcefile, sourceline);
-    }
-  }
-#endif
-}
-
 static void
 set_backtrace(mrb_state *mrb, mrb_value info, mrb_value bt)
 {
diff --git a/src/error.h b/src/error.h
index 8a86e7d3d..e4d6acb6c 100644
--- a/src/error.h
+++ b/src/error.h
@@ -14,7 +14,6 @@ struct RException {
 void mrb_sys_fail(mrb_state *mrb, const char *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_make_exception(mrb_state *mrb, int argc, mrb_value *argv);
diff --git a/src/etc.c b/src/etc.c
index 5d70c8bc7..40a00c1f5 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -10,14 +10,6 @@
 #include "mruby/numeric.h"
 #include "mruby/data.h"
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 struct RData*
 mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const struct mrb_data_type *type)
 {
diff --git a/src/hash.c b/src/hash.c
index 4a85fcec3..fe5336dc1 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -33,14 +33,6 @@ mrb_hash_ht_hash_equal(mrb_state *mrb, mrb_value a, mrb_value b)
 
 KHASH_INIT(ht, mrb_value, mrb_value, 1, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal);
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 static void mrb_hash_modify(mrb_state *mrb, mrb_value hash);
 
 static inline mrb_value
diff --git a/src/kernel.c b/src/kernel.c
index 4856af7ad..6dfe6be19 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -34,22 +34,9 @@ typedef enum {
     NOEX_RESPONDS  = 0x80
 } mrb_method_flag_t;
 
-#ifdef INCLUDE_REGEXP
-#include "re.h"
-#include "regint.h"
-#endif
-
 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)
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 struct obj_ivar_tag {
   mrb_value obj;
   int (*func)(mrb_sym key, mrb_value val, void * arg);
diff --git a/src/load.c b/src/load.c
index 053ec2d7e..1f853df00 100644
--- a/src/load.c
+++ b/src/load.c
@@ -13,14 +13,6 @@
 #endif
 #include "mruby/irep.h"
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 typedef struct _RiteFILE
 {
   FILE* fp;
diff --git a/src/object.c b/src/object.c
index c9ea3f8eb..a30e7c58a 100644
--- a/src/object.c
+++ b/src/object.c
@@ -11,14 +11,6 @@
 #include "mruby/class.h"
 #include "mruby/numeric.h"
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 int
 mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
 {
diff --git a/src/parse.y b/src/parse.y
index 7ca0cda80..5e44dd85a 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -41,14 +41,6 @@ static void backref_error(parser_state *p, node *n);
 
 #define identchar(c) (isalnum(c) || (c) == '_' || !isascii(c))
 
-#ifndef TRUE
-#define TRUE  1
-#endif
-
-#ifndef FALSE
-#define FALSE 0
-#endif
-
 typedef unsigned int stack_type;
 
 #define BITSTACK_PUSH(stack, n)	((stack) = ((stack)<<1)|((n)&1))
diff --git a/src/range.c b/src/range.c
index acec1514e..a158dd920 100644
--- a/src/range.c
+++ b/src/range.c
@@ -15,14 +15,6 @@
 #include <stdio.h>
 #include <string.h>
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 #ifndef OTHER
 #define OTHER 2
 #endif
diff --git a/src/string.c b/src/string.c
index 14041127a..a9e155c72 100644
--- a/src/string.c
+++ b/src/string.c
@@ -763,7 +763,7 @@ num_index:
 
         len = RSTRING_LEN(str);
         switch (mrb_range_beg_len(mrb, indx, &beg, &len, len, 0)) {
-          case 0/*FLASE*/:
+          case FALSE:
             break;
           case 2/*OTHER*/:
             return mrb_nil_value();
diff --git a/src/variable.c b/src/variable.c
index b8957fb6a..47029da28 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -21,14 +21,6 @@
 
 KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal)
 
-#ifndef FALSE
-#define FALSE   0
-#endif
-
-#ifndef TRUE
-#define TRUE    1
-#endif
-
 static void
 mark_tbl(mrb_state *mrb, struct kh_iv *h)
 {
-- 
cgit v1.2.3


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

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

(limited to 'src/object.c')

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


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

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

(limited to 'src/object.c')

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


From 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 'src/object.c')

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 b2fc62f3a917e9ab1d562b49312f8d7dd2e057c5 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Sun, 29 Jul 2012 15:25:14 +0900
Subject: Remove commented out code.

---
 src/error.c    |  9 -------
 src/etc.c      |  5 ----
 src/hash.c     |  8 +++----
 src/kernel.c   | 76 ++++++++++++++++------------------------------------------
 src/object.c   |  1 -
 src/range.c    |  1 -
 src/string.c   |  9 -------
 src/struct.c   |  9 -------
 src/variable.c |  5 ----
 9 files changed, 24 insertions(+), 99 deletions(-)

(limited to 'src/object.c')

diff --git a/src/error.c b/src/error.c
index 5bfbc4319..e71245509 100644
--- a/src/error.c
+++ b/src/error.c
@@ -29,7 +29,6 @@ mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str)
   return mrb_funcall(mrb, mrb_obj_value(c), "new", 1, str);
 }
 
-//mrb_value make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr);
 /*
  * call-seq:
  *    Exception.new(msg = nil)   ->  exception
@@ -307,14 +306,6 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr)
     case 3:
       n = 1;
 exception_call:
-      //if (argv[0] == sysstack_error) return argv[0];
-
-      //CONST_ID(mrb, exception, "exception");
-      //mesg = mrb_check_funcall(mrb, argv[0], exception, n, argv+1);
-      //if (mrb_nil_p(mesg)) {
-      //  /* undef */
-      //  mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected");
-      //}
       if (mrb_respond_to(mrb, argv[0], mrb_intern(mrb, "exception"))) {
         mesg = mrb_funcall_argv(mrb, argv[0], "exception", n, argv+1);
       }
diff --git a/src/etc.c b/src/etc.c
index 7e9381d16..d14498d9c 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -52,11 +52,6 @@ mrb_check_datatype(mrb_state *mrb, mrb_value obj, const struct mrb_data_type *ty
 mrb_value
 mrb_lastline_get(mrb_state *mrb)
 {
-  //mrb_value *var = mrb_svar(0);
-  //if (var) {
-  //  return *var;
-  //}
-  //return mrb_nil_value();
   mrb_value *argv;
   int argc;
 
diff --git a/src/hash.c b/src/hash.c
index 04e8c60be..5d3835019 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -1339,9 +1339,9 @@ mrb_init_hash(mrb_state *mrb)
   mrb_define_method(mrb, h, "default_proc",    mrb_hash_default_proc,ARGS_NONE()); /* 15.2.13.4.7  */
   mrb_define_method(mrb, h, "default_proc=",   mrb_hash_set_default_proc,ARGS_REQ(1)); /* 15.2.13.4.7  */
   mrb_define_method(mrb, h, "__delete",        mrb_hash_delete,      ARGS_REQ(1)); /* core of 15.2.13.4.8  */
-//mrb_define_method(mrb, h, "each",            mrb_hash_each_pair,   ARGS_NONE()); /* 15.2.13.4.9  */ /* move to mrblib\hash.rb */
-//mrb_define_method(mrb, h, "each_key",        mrb_hash_each_key,    ARGS_NONE()); /* 15.2.13.4.10 */ /* move to mrblib\hash.rb */
-//mrb_define_method(mrb, h, "each_value",      mrb_hash_each_value,  ARGS_NONE()); /* 15.2.13.4.11 */ /* move to mrblib\hash.rb */
+// "each"                                                                             15.2.13.4.9  move to mrblib/hash.rb
+// "each_key"                                                                         15.2.13.4.10 move to mrblib/hash.rb
+// "each_value"                                                                       15.2.13.4.11 move to mrblib/hash.rb
   mrb_define_method(mrb, h, "empty?",          mrb_hash_empty_p,     ARGS_NONE()); /* 15.2.13.4.12 */
   mrb_define_method(mrb, h, "has_key?",        mrb_hash_has_key,     ARGS_REQ(1)); /* 15.2.13.4.13 */
   mrb_define_method(mrb, h, "has_value?",      mrb_hash_has_value,   ARGS_REQ(1)); /* 15.2.13.4.14 */
@@ -1352,7 +1352,7 @@ mrb_init_hash(mrb_state *mrb)
   mrb_define_method(mrb, h, "keys",            mrb_hash_keys,        ARGS_NONE()); /* 15.2.13.4.19 */
   mrb_define_method(mrb, h, "length",          mrb_hash_size_m,      ARGS_NONE()); /* 15.2.13.4.20 */
   mrb_define_method(mrb, h, "member?",         mrb_hash_has_key,     ARGS_REQ(1)); /* 15.2.13.4.21 */
-//mrb_define_method(mrb, h, "merge",           mrb_hash_merge,       ARGS_REQ(1)); /* 15.2.13.4.22 */ /* move to mrblib\hash.rb */
+// "merge"                                                                            15.2.13.4.22 move to mrblib/hash.rb
   mrb_define_method(mrb, h, "replace",         mrb_hash_replace,     ARGS_REQ(1)); /* 15.2.13.4.23 */
   mrb_define_method(mrb, h, "shift",           mrb_hash_shift,       ARGS_NONE()); /* 15.2.13.4.24 */
   mrb_define_method(mrb, h, "size",            mrb_hash_size_m,      ARGS_NONE()); /* 15.2.13.4.25 */
diff --git a/src/kernel.c b/src/kernel.c
index 468891b23..8aba1a808 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -72,9 +72,6 @@ inspect_obj(mrb_state *mrb, mrb_value obj, mrb_value str, int recur)
 int
 mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj)
 {
-    //const mrb_method_entry_t *me = mrb_method_entry(CLASS_OF(obj), mrb_intern("to_s"));
-    //if (me && me->def && me->def->type == VM_METHOD_TYPE_CFUNC &&
-    //me->def->body.cfunc.func == mrb_any_to_s)
     struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern(mrb, "to_s"));
     if (me && MRB_PROC_CFUNC_P(me) && (me->body.func == mrb_any_to_s))
       return 1;
@@ -314,52 +311,38 @@ mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
 {
   struct RClass *klass = RBASIC(obj)->c;
 
-  //if (!FL_TEST(klass, FL_SINGLETON))
-      //return klass;
   if (klass->tt != MRB_TT_SCLASS)
     return klass;
   else {
-      //struct clone_method_data data;
-      /* copy singleton(unnamed) class */
-      //VALUE clone = class_alloc(RBASIC(klass)->flags, 0);
+    /* copy singleton(unnamed) class */
     struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
-    //clone->super = objklass->super;
 
-      if ((mrb_type(obj) == MRB_TT_CLASS) ||
-          (mrb_type(obj) == MRB_TT_SCLASS)) { /* BUILTIN_TYPE(obj) == T_CLASS */
-          clone->c = clone;
-      }
-      else {
-          clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
-      }
+    if ((mrb_type(obj) == MRB_TT_CLASS) ||
+      (mrb_type(obj) == MRB_TT_SCLASS)) { /* BUILTIN_TYPE(obj) == T_CLASS */
+      clone->c = clone;
+    }
+    else {
+      clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
+    }
 
-      clone->super = klass->super;
-      if (klass->iv) {
-          clone->iv = klass->iv;
-      }
-      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;
+    clone->super = klass->super;
+    if (klass->iv) {
+      clone->iv = klass->iv;
+    }
+    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;
   }
 }
 
 static void
 init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
 {
-    //if (OBJ_FROZEN(dest)) {
-    //    rb_raise(rb_eTypeError, "[bug] frozen object (%s) allocated", rb_obj_classname(dest));
-    //}
-    //RBASIC(dest)->flags &= ~(T_MASK|FL_EXIVAR);
-    //RBASIC(dest)->flags |= RBASIC(obj)->flags & (T_MASK|FL_EXIVAR|FL_TAINT);
-    //if (FL_TEST(obj, FL_EXIVAR)) {
-    //    mrb_copy_generic_ivar(dest, obj);
-    //}
-    //mrb_gc_copy_finalizer(dest, obj);
     switch (mrb_type(obj)) {
       case MRB_TT_OBJECT:
       case MRB_TT_CLASS:
@@ -416,8 +399,6 @@ mrb_obj_clone(mrb_state *mrb, mrb_value self)
   clone = (struct RObject*)mrb_obj_alloc(mrb, self.tt, mrb_obj_class(mrb, self));
   clone->c = mrb_singleton_class_clone(mrb, self);
   init_copy(mrb, mrb_obj_value(clone), self);
-  //1-9-2 no bug mrb_funcall(mrb, clone, "initialize_clone", 1, self);
-  //RBASIC(clone)->flags |= RBASIC(obj)->flags & FL_FREEZE;
 
   return mrb_obj_value(clone);
 }
@@ -466,7 +447,6 @@ mrb_obj_extend(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj)
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (at least 1)");
   }
   for (i = 0; i < argc; i++) {
-    //Check_Type(argv[i], T_MODULE);
     mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
   }
   while (argc--) {
@@ -511,19 +491,6 @@ mrb_obj_extend_m(mrb_state *mrb, mrb_value self)
   return mrb_obj_extend(mrb, argc, argv, self);
 }
 
-/* 15.3.1.2.4  */
-/* 15.3.1.3.14 */
-/*
- *  call-seq:
- *     global_variables    -> array
- *
- *  Returns an array of the names of global variables.
- *
- *     global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]
- */
-//mrb_value
-//mrb_f_global_variables(mrb_state *mrb, mrb_value self)
-
 /* 15.3.1.3.15 */
 /*
  *  call-seq:
@@ -824,7 +791,6 @@ mrb_obj_singleton_methods(mrb_state *mrb, int argc, mrb_value *argv, mrb_value o
       recur = mrb_true_value();
   }
   else {
-      //mrb_scan_args(argc, argv, "01", &recur);
       recur = argv[0];
   }
   klass = mrb_class(mrb, obj);
@@ -853,7 +819,6 @@ retry:
   else {
       mrb_value recur;
 
-      //mrb_scan_args(argc, argv, "1", &recur);
       recur = argv[0];
       if (mrb_test(recur)) {
           argc = 0;
@@ -1073,7 +1038,6 @@ obj_respond_to(mrb_state *mrb, mrb_value self)
   mrb_sym id;
 
   mrb_get_args(mrb, "*", &argv, &argc);
-  //mrb_scan_args(argc, argv, "11", &mid, &priv);
   mid = argv[0];
   if (argc > 1) priv = argv[1];
   else priv = mrb_nil_value();
diff --git a/src/object.c b/src/object.c
index 43e064fb0..4f5fb1d28 100644
--- a/src/object.c
+++ b/src/object.c
@@ -516,7 +516,6 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method)
     mrb_value v;
 
     if (FIXNUM_P(val)) return val;
-    //if (TYPE(val) == T_BIGNUM) return val;
     v = convert_type(mrb, val, "Integer", method, TRUE);
     if (!mrb_obj_is_kind_of(mrb, v, mrb->fixnum_class)) {
       const char *cname = mrb_obj_classname(mrb, val);
diff --git a/src/range.c b/src/range.c
index 14fa2a6a3..9113a810a 100644
--- a/src/range.c
+++ b/src/range.c
@@ -412,7 +412,6 @@ range_initialize_copy(mrb_state *mrb, mrb_value copy)
   mrb_get_args(mrb, "o", &src);
 
   if (mrb_obj_equal(mrb, copy, src)) return copy;
-  //mrb_check_frozen(copy);
   if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
     mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
   }
diff --git a/src/string.c b/src/string.c
index e41116ebc..0a5dee88e 100644
--- a/src/string.c
+++ b/src/string.c
@@ -1354,7 +1354,6 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang)
 static mrb_value
 mrb_str_gsub(mrb_state *mrb, mrb_value self)
 {
-  //return str_gsub(argc, argv, self, 0);
   return str_gsub(mrb, self, 0);
 }
 
@@ -1469,10 +1468,8 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
   int argc;
 
   mrb_value sub;
-  //mrb_value initpos;
   mrb_int pos;
 
-  //if (mrb_scan_args(argc, argv, "11", &sub, &initpos) == 2) {
   mrb_get_args(mrb, "*", &argv, &argc);
   if (argc == 2) {
     pos = mrb_fixnum(argv[1]);
@@ -1959,7 +1956,6 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start)
 
   if (mrb_reg_search(mrb, pat, str, *start, 0) >= 0) {
     match = mrb_backref_get(mrb);
-    //regs = RMATCH(match)->regs;
     pmatch = mrb_match_ptr(match);
     regs = &pmatch->rmatch->regs;
     if (regs->beg[0] == regs->end[0]) {
@@ -2143,7 +2139,6 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
     split_type = awk;
   }
   else {
-//fs_set:
     if (mrb_type(spat) == MRB_TT_STRING) {
       split_type = string;
 #ifdef ENABLE_REGEXP
@@ -2546,7 +2541,6 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck)
   if (s) {
     len = RSTRING_LEN(str);
     if (s[len]) {    /* no sentinel somehow */
-      //char *p = ALLOCA_N(char, len+1);
       char *p = mrb_malloc(mrb, len+1);
 
       //MEMCPY(p, s, char, len);
@@ -2584,10 +2578,8 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self)
 {
   mrb_value *argv;
   int argc;
-  //mrb_value b;
   int base;
 
-  //mrb_scan_args(argc, *argv, "01", &b);
   mrb_get_args(mrb, "*", &argv, &argc);
   if (argc == 0)
     base = 10;
@@ -2710,7 +2702,6 @@ mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck)
 static mrb_value
 mrb_str_to_f(mrb_state *mrb, mrb_value self)
 {
-  //return mrb_float_new(mrb_str_to_dbl(self, 0/*Qfalse*/));
   return mrb_float_value(mrb_str_to_dbl(mrb, self, 0/*Qfalse*/));
 }
 
diff --git a/src/struct.c b/src/struct.c
index 6d8ce057f..0a95f9e49 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -38,8 +38,6 @@ struct_ivar_get(mrb_state *mrb, mrb_value c, mrb_sym id)
 
   mrb_value ans;
     for (;;) {
-      //if (mrb_ivar_defined(c, id))
-      //    return mrb_iv_get(mrb, c, id);
       ans = mrb_iv_get(mrb, c, id);
       if (!mrb_nil_p(ans)) return ans;
       kclass = RCLASS_SUPER(c);
@@ -260,19 +258,15 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k
     //OBJ_FREEZE(members);
     if (mrb_nil_p(name)) {
       c = mrb_class_new(mrb, klass);
-      //mrb_make_metaclass(nstr, RBASIC(klass)->c);
-      //mrb_class_inherited(klass, nstr);
     }
     else {
       /* old style: should we warn? */
       name = mrb_str_to_str(mrb, name);
       id = mrb_to_id(mrb, name);
       if (!mrb_is_const_id(id)) {
-          //mrb_name_error(id, "identifier %s needs to be constant", StringValuePtr(name));
           mrb_name_error(mrb, id, "identifier %s needs to be constant", mrb_string_value_ptr(mrb, name));
       }
       if (mrb_const_defined_at(mrb, klass, id)) {
-          //mrb_warn("redefining constant Struct::%s", StringValuePtr(name));
           mrb_warn("redefining constant Struct::%s", mrb_string_value_ptr(mrb, name));
           //?rb_mod_remove_const(klass, mrb_sym2name(mrb, id));
       }
@@ -376,7 +370,6 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
   mrb_get_args(mrb, "&*", &b, &argv, &argc);
   if (argc > 0) name = argv[0];
   if (argc > 1) rest = argv[1];
-  //mrb_scan_args(argc, argv, "1*", &name, &rest);
   if (mrb_type(rest) == MRB_TT_ARRAY) {
     if (!mrb_nil_p(name) && SYMBOL_P(name)) {
       /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
@@ -389,7 +382,6 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
     argcnt = argc-1;
     if (!mrb_nil_p(name) && SYMBOL_P(name)) {
       /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
-      //mrb_ary_unshift(mrb, rest, name);
       name = mrb_nil_value();
       pargv = &argv[0];
       argcnt++;
@@ -557,7 +549,6 @@ mrb_struct_init_copy(mrb_state *mrb, mrb_value copy)
   mrb_get_args(mrb, "o", &s);
 
   if (mrb_obj_equal(mrb, copy, s)) return copy;
-  //mrb_check_frozen(copy);
   if (!mrb_obj_is_instance_of(mrb, s, mrb_obj_class(mrb, copy))) {
     mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
   }
diff --git a/src/variable.c b/src/variable.c
index a1a7f2e82..04e5ad9f7 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -460,10 +460,6 @@ kiv_lookup(khash_t(iv)* table, mrb_sym key, mrb_value *value)
   khash_t(iv) *h=table;
   khiter_t k;
 
-  // you must check(iv==0), before you call this function.
-  //if (!obj->iv) {
-  //  return 0;
-  //}
   k = kh_get(iv, h, key);
   if (k != kh_end(h)) {
     *value = kh_value(h, k);
@@ -505,7 +501,6 @@ mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id)
 mrb_value
 mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id)
 {
-  //return ivar_get(obj, id, FALSE);
   return mrb_iv_get(mrb, obj, id);
 }
 
-- 
cgit v1.2.3


From bce9198732d489daa3d179b185c532544a6d6c60 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 2 Aug 2012 01:53:35 +0900
Subject: reduce invoking mrb_intern from convert_type

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

(limited to 'src/object.c')

diff --git a/src/object.c b/src/object.c
index 4f5fb1d28..25439e1d2 100644
--- a/src/object.c
+++ b/src/object.c
@@ -317,7 +317,7 @@ convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *metho
       return mrb_nil_value();
     }
   }
-  return mrb_funcall(mrb, val, method, 0);
+  return mrb_funcall_argv(mrb, val, m, 0, 0);
 }
 
 mrb_value
-- 
cgit v1.2.3


From 1549502079ed1b3b7bbae66e661e4a15a9a3f3d6 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Thu, 2 Aug 2012 01:58:20 +0900
Subject: mrb_check_convert_type should always return nil on error

---
 src/object.c | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

(limited to 'src/object.c')

diff --git a/src/object.c b/src/object.c
index 25439e1d2..26df48afd 100644
--- a/src/object.c
+++ b/src/object.c
@@ -327,8 +327,7 @@ mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method)
 
     if (mrb_type(val) == MRB_TT_FIXNUM) return val;
     v = convert_type(mrb, val, "Integer", method, FALSE);
-    if (mrb_nil_p(v)) return (v);
-    if (!mrb_obj_is_kind_of(mrb, v, mrb_obj_class(mrb, v))) {
+    if (mrb_nil_p(v) || mrb_type(v) != MRB_TT_FIXNUM) {
       return mrb_nil_value();
     }
     return v;
@@ -343,7 +342,7 @@ mrb_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname,
   v = convert_type(mrb, val, tname, method, 1/*Qtrue*/);
   if (mrb_type(v) != type) {
     mrb_raise(mrb, E_TYPE_ERROR, "%s cannot be converted to %s by #%s",
-     mrb_obj_classname(mrb, val), tname, method);
+	      mrb_obj_classname(mrb, val), tname, method);
   }
   return v;
 }
@@ -353,14 +352,9 @@ mrb_check_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *
 {
   mrb_value v;
 
-  /* always convert T_DATA */
   if (mrb_type(val) == type && type != MRB_TT_DATA) return val;
   v = convert_type(mrb, val, tname, method, 0/*Qfalse*/);
-  if (mrb_nil_p(v)) return mrb_nil_value();
-  if (mrb_type(v) != type) {
-    mrb_raise(mrb, E_TYPE_ERROR, "%s#%s should return %s",
-     mrb_obj_classname(mrb, val), method, tname);
-  }
+  if (mrb_nil_p(v) || mrb_type(v) != type) return mrb_nil_value();
   return v;
 }
 
-- 
cgit v1.2.3