From 265fa03d2c6863bf3425bfe00738ad15d62ba587 Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 17 Oct 2012 00:40:23 +0900
Subject: defining mrb_int also requires MRB_INT_{MAX,MIN} to be defined

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

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index d7ccb261d..76c1b37f9 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -62,8 +62,12 @@ typedef double mrb_float;
 
 #ifdef MRB_NAN_BOXING
 typedef int32_t mrb_int;
+#define MRB_INT_MIN INT32_MIN
+#define MRB_INT_MAX INT32_MAX
 #else
 typedef int mrb_int;
+#define MRB_INT_MIN INT_MIN
+#define MRB_INT_MAX INT_MAX
 #endif
 typedef short mrb_sym;
 
diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h
index fed9ad39a..9a5ba449f 100644
--- a/include/mruby/numeric.h
+++ b/include/mruby/numeric.h
@@ -13,8 +13,8 @@ extern "C" {
 
 #include <limits.h>
 
-#define POSFIXABLE(f) ((f) <= INT_MAX)
-#define NEGFIXABLE(f) ((f) >= INT_MIN)
+#define POSFIXABLE(f) ((f) <= MRB_INT_MAX)
+#define NEGFIXABLE(f) ((f) >= MRB_INT_MIN)
 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
 
 mrb_value mrb_flt2big(mrb_state *mrb, mrb_float d);
-- 
cgit v1.2.3


From 70abbb423a1b215563e6e4e58bfb76c02e59125d Mon Sep 17 00:00:00 2001
From: Yukihiro Matsumoto <matz@ruby-lang.org>
Date: Wed, 17 Oct 2012 02:57:40 +0900
Subject: should not free() static iseq from cdump

---
 include/mruby/irep.h | 10 ++++++----
 src/cdump.c          | 19 +++++++++++++------
 src/state.c          |  3 ++-
 3 files changed, 21 insertions(+), 11 deletions(-)

(limited to 'include')

diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index 0d8a05dbe..534590849 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -12,10 +12,10 @@ extern "C" {
 #endif
 
 typedef struct mrb_irep {
-  int idx;
-
-  int nlocals;
-  int nregs;
+  int idx:16;
+  int nlocals:16;
+  int nregs:16;
+  int flags:8;
 
   mrb_code *iseq;
   mrb_value *pool;
@@ -28,6 +28,8 @@ typedef struct mrb_irep {
   int ilen, plen, slen;
 } mrb_irep;
 
+#define MRB_ISEQ_NO_FREE 1
+
 void mrb_add_irep(mrb_state *mrb, int n);
 
 #if defined(__cplusplus)
diff --git a/src/cdump.c b/src/cdump.c
index ba05a1899..c7597e12f 100644
--- a/src/cdump.c
+++ b/src/cdump.c
@@ -113,6 +113,7 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
 
   SOURCE_CODE0     ("  ai = mrb->arena_idx;");
   SOURCE_CODE0     ("  irep = mrb->irep[idx] = mrb_malloc(mrb, sizeof(mrb_irep));");
+  SOURCE_CODE0     ("  irep->flags = MRB_ISEQ_NO_FREE;");
   SOURCE_CODE0     ("  irep->idx = idx++;");
   SOURCE_CODE      ("  irep->nlocals = %d;",                                          irep->nlocals);
   SOURCE_CODE      ("  irep->nregs = %d;",                                            irep->nregs);
@@ -124,13 +125,19 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
     SOURCE_CODE    ("  irep->syms = mrb_malloc(mrb, sizeof(mrb_sym)*%d);",            irep->slen);
     for (n=0; n<irep->slen; n++)
       if (irep->syms[n]) {
-        SOURCE_CODE  ("  irep->syms[%d] = mrb_intern(mrb, \"%s\");",                  n, mrb_sym2name(mrb, irep->syms[n]));
+	const char *name;
+	int len;
+
+	name = mrb_sym2name_len(mrb, irep->syms[n], &len);
+        SOURCE_CODE  ("  irep->syms[%d] = mrb_intern2(mrb, \"%s\", %d);",             n, name, len);
       }
   }
   else
     SOURCE_CODE0   ("  irep->syms = NULL;");
 
-  SOURCE_CODE      ("  irep->plen = %d;",                                             irep->plen);
+  SOURCE_CODE0     ("  irep->pool = NULL;");
+  SOURCE_CODE0     ("  mrb->irep_len = idx;");
+  SOURCE_CODE0     ("  irep->plen = 0;");
   if(irep->plen > 0) {
     SOURCE_CODE    ("  irep->pool = mrb_malloc(mrb, sizeof(mrb_value)*%d);",          irep->plen);
     for (n=0; n<irep->plen; n++) {
@@ -148,16 +155,16 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
           }
         }
         memset(buf, 0, buf_len);
-        SOURCE_CODE("  irep->pool[%d] = mrb_str_new(mrb, \"%s\", %d);",               n, str_to_format(irep->pool[n], buf), RSTRING_LEN(irep->pool[n])); break;
+        SOURCE_CODE("  irep->pool[%d] = mrb_str_new(mrb, \"%s\", %d);",               n, str_to_format(irep->pool[n], buf), RSTRING_LEN(irep->pool[n]));
+	SOURCE_CODE0     ("  mrb->arena_idx = ai;");
+	break;
       /* TODO MRB_TT_REGEX */
       default: break;
       }
+      SOURCE_CODE0("  irep->plen++;");
     }
   }
   else
-    SOURCE_CODE0   ("  irep->pool = NULL;");
-  SOURCE_CODE0     ("  mrb->irep_len = idx;");
-  SOURCE_CODE0     ("  mrb->arena_idx = ai;");
   SOURCE_CODE0("");
   return MRB_CDUMP_OK;
 }
diff --git a/src/state.c b/src/state.c
index 40d9bfc45..991be310e 100644
--- a/src/state.c
+++ b/src/state.c
@@ -92,7 +92,8 @@ mrb_close(mrb_state *mrb)
   mrb_free(mrb, mrb->stbase);
   mrb_free(mrb, mrb->cibase);
   for (i=0; i<mrb->irep_len; i++) {
-    mrb_free(mrb, mrb->irep[i]->iseq);
+    if (!(mrb->irep[i]->flags & MRB_ISEQ_NO_FREE))
+      mrb_free(mrb, mrb->irep[i]->iseq);
     mrb_free(mrb, mrb->irep[i]->pool);
     mrb_free(mrb, mrb->irep[i]->syms);
     mrb_free(mrb, mrb->irep[i]->lines);
-- 
cgit v1.2.3


From fed285d1945d1fa3104b441cf51db2d7118a5d01 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Mon, 22 Oct 2012 11:17:31 +0900
Subject: Use MRB_DUMP_SIZE_OF_CHAR instead of sizeof(char).

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

(limited to 'include')

diff --git a/include/mruby/dump.h b/include/mruby/dump.h
index 0826606e9..cad797275 100644
--- a/include/mruby/dump.h
+++ b/include/mruby/dump.h
@@ -41,6 +41,7 @@ int mrb_bdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname);
 #define MRB_DUMP_SIZE_OF_LONG          4
 #define MRB_DUMP_SIZE_OF_INT           4
 #define MRB_DUMP_SIZE_OF_SHORT         2
+#define MRB_DUMP_SIZE_OF_CHAR          1
 
 /* null symbol length */
 #define MRB_DUMP_NULL_SYM_LEN          0xFFFF
diff --git a/src/dump.c b/src/dump.c
index c8f92ec72..e7e1a4807 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -84,7 +84,7 @@ uint8_dump(unsigned char bin, char *hex, int type)
     *hex++  = bin2hex[(bin >> 4) & 0x0f];
     *hex    = bin2hex[bin & 0x0f];
   }
-  return DUMP_SIZE(sizeof(char), type);
+  return DUMP_SIZE(MRB_DUMP_SIZE_OF_CHAR, type);
 }
 
 static inline int
-- 
cgit v1.2.3


From 6069a33089916d7059c2bd2aeddc02a3eb440520 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Tue, 23 Oct 2012 09:42:22 +0900
Subject: mrb_raisef(): new function. Same as previou version of mrb_raise().
 mrb_raise(): API modified. It cannot treat variable arguments.

---
 include/mruby.h |  4 ++--
 src/array.c     |  2 +-
 src/class.c     | 20 ++++++++++----------
 src/error.c     | 14 +++++++++++---
 src/etc.c       |  4 ++--
 src/kernel.c    |  4 ++--
 src/numeric.c   |  4 ++--
 src/object.c    | 10 +++++-----
 src/range.c     |  2 +-
 src/sprintf.c   | 30 +++++++++++++++---------------
 src/string.c    | 14 +++++++-------
 src/struct.c    | 12 ++++++------
 src/variable.c  |  2 +-
 src/vm.c        |  4 ++--
 14 files changed, 67 insertions(+), 59 deletions(-)

(limited to 'include')

diff --git a/include/mruby.h b/include/mruby.h
index b741e6444..94fa393ea 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -282,8 +282,8 @@ mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long le
 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, ...);
+void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg);
+void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
 void mrb_warn(const char *fmt, ...);
 void mrb_bug(const char *fmt, ...);
 
diff --git a/src/array.c b/src/array.c
index 726271d1c..2e2536368 100644
--- a/src/array.c
+++ b/src/array.c
@@ -580,7 +580,7 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) /* rb_ary_s
   if (n < 0) {
     n += a->len;
     if (n < 0) {
-      mrb_raise(mrb, E_INDEX_ERROR, "index %ld out of array", n - a->len);
+      mrb_raisef(mrb, E_INDEX_ERROR, "index %ld out of array", n - a->len);
     }
   }
   if (a->len <= (int)n) {
diff --git a/src/class.c b/src/class.c
index a73f42566..c4058ad67 100644
--- a/src/class.c
+++ b/src/class.c
@@ -171,11 +171,11 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id
     c = mrb_class_ptr(v);
     if (!mrb_nil_p(super)) {
       if (mrb_type(super) != MRB_TT_CLASS) {
-        mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super));
+        mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super));
       }
 
       if (!c->super || mrb_class_ptr(super) != mrb_class_real(c->super)) {
-        mrb_raise(mrb, E_TYPE_ERROR, "superclass mismatch for class %s", mrb_sym2name(mrb, id));
+        mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for class %s", mrb_sym2name(mrb, id));
       }
     }
 
@@ -184,7 +184,7 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id
 
   if (!mrb_nil_p(super)) {
     if (mrb_type(super) != MRB_TT_CLASS) {
-      mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super));
+      mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super));
     }
     s = mrb_class_ptr(super);
   }
@@ -205,7 +205,7 @@ 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 (mrb_type(c) != MRB_TT_MODULE && mrb_type(c) != MRB_TT_CLASS) {
-    mrb_raise(mrb, E_TYPE_ERROR, "%s is not a class/module", mrb_sym2name(mrb, id));
+    mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a class/module", mrb_sym2name(mrb, id));
   }
   return mrb_class_ptr(c);
 }
@@ -318,7 +318,7 @@ check_type(mrb_state *mrb, mrb_value val, enum mrb_vtype t, const char *c, const
 
   tmp = mrb_check_convert_type(mrb, val, t, c, m);
   if (mrb_nil_p(tmp)) {
-    mrb_raise(mrb, E_TYPE_ERROR, "expected %s", c);
+    mrb_raisef(mrb, E_TYPE_ERROR, "expected %s", c);
   }
   return tmp;
 }
@@ -618,7 +618,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
       }
       break;
     default:
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide argument specifier %c", c);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalide argument specifier %c", c);
       break;
     }
   }
@@ -852,7 +852,7 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
 
   m = mrb_method_search_vm(mrb, &c, mid);
   if (!m) {
-    mrb_raise(mrb, E_NOMETHOD_ERROR, "no method named %s\n", mrb_sym2name(mrb, mid));
+    mrb_raisef(mrb, E_NOMETHOD_ERROR, "no method named %s\n", mrb_sym2name(mrb, mid));
   }
   return m;
 }
@@ -1008,7 +1008,7 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
   if (!SYMBOL_P(name)) {
     mrb_raise(mrb, E_TYPE_ERROR, "name should be a symbol");
   }
-  mrb_raise(mrb, E_NOMETHOD_ERROR, "no method named %s", mrb_sym2name(mrb, mrb_symbol(name)));
+  mrb_raisef(mrb, E_NOMETHOD_ERROR, "no method named %s", mrb_sym2name(mrb, mrb_symbol(name)));
   /* not reached */
   return mrb_nil_value();
 }
@@ -1105,7 +1105,7 @@ void
 mrb_check_inheritable(mrb_state *mrb, struct RClass *super)
 {
   if (super->tt != MRB_TT_CLASS) {
-    mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)",
+    mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)",
            mrb_obj_classname(mrb, mrb_obj_value(super)));
   }
   if (super->tt == MRB_TT_SCLASS) {
@@ -1323,7 +1323,7 @@ mrb_sym_value(mrb_state *mrb, mrb_value val)
   }
   else if(mrb_type(val) != MRB_TT_SYMBOL) {
     mrb_value obj = mrb_funcall(mrb, val, "inspect", 0);
-    mrb_raise(mrb, E_TYPE_ERROR, "%s is not a symbol",
+    mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a symbol",
          mrb_string_value_ptr(mrb, obj));
   }
   return mrb_symbol(val);
diff --git a/src/error.c b/src/error.c
index 5570d35f9..858c70820 100644
--- a/src/error.c
+++ b/src/error.c
@@ -217,7 +217,15 @@ mrb_exc_raise(mrb_state *mrb, mrb_value exc)
 }
 
 void
-mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
+mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg)
+{
+  mrb_value mesg;
+  mesg = mrb_str_new2(mrb, msg);
+  mrb_exc_raise(mrb, mrb_exc_new3(mrb, c, mesg));
+}
+
+void
+mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
 {
   va_list args;
   char buf[256];
@@ -369,7 +377,7 @@ exception_call:
 
       break;
     default:
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 0..3)", argc);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 0..3)", argc);
       break;
   }
   if (argc > 0) {
@@ -391,7 +399,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, E_RUNTIME_ERROR, "%s", mesg);
+  mrb_raise(mrb, E_RUNTIME_ERROR, mesg);
 }
 
 void
diff --git a/src/etc.c b/src/etc.c
index 7dfa044f6..c38f2a0bc 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -44,7 +44,7 @@ mrb_check_datatype(mrb_state *mrb, mrb_value obj, const struct mrb_data_type *ty
   }
   if (DATA_TYPE(obj) != type) {
     const char *etype = DATA_TYPE(obj)->struct_name;
-    mrb_raise(mrb, E_TYPE_ERROR, mesg, etype, type->struct_name);
+    mrb_raisef(mrb, E_TYPE_ERROR, mesg, etype, type->struct_name);
   }
   return DATA_PTR(obj);
 }
@@ -94,7 +94,7 @@ mrb_to_id(mrb_state *mrb, mrb_value name)
       tmp = mrb_check_string_type(mrb, name);
       if (mrb_nil_p(tmp)) {
         tmp = mrb_inspect(mrb, name);
-        mrb_raise(mrb, E_TYPE_ERROR, "%s is not a symbol",
+        mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a symbol",
              RSTRING_PTR(tmp));
       }
       name = tmp;
diff --git a/src/kernel.c b/src/kernel.c
index 43820173c..050dd73bc 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -348,7 +348,7 @@ mrb_obj_clone(mrb_state *mrb, mrb_value self)
   struct RObject *clone;
 
   if (mrb_special_const_p(self)) {
-      mrb_raise(mrb, E_TYPE_ERROR, "can't clone %s", mrb_obj_classname(mrb, self));
+      mrb_raisef(mrb, E_TYPE_ERROR, "can't clone %s", mrb_obj_classname(mrb, self));
   }
   clone = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
   clone->c = mrb_singleton_class_clone(mrb, self);
@@ -383,7 +383,7 @@ mrb_obj_dup(mrb_state *mrb, mrb_value obj)
     mrb_value dup;
 
     if (mrb_special_const_p(obj)) {
-        mrb_raise(mrb, E_TYPE_ERROR, "can't dup %s", mrb_obj_classname(mrb, obj));
+        mrb_raisef(mrb, E_TYPE_ERROR, "can't dup %s", mrb_obj_classname(mrb, obj));
     }
     p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj));
     dup = mrb_obj_value(p);
diff --git a/src/numeric.c b/src/numeric.c
index 284d0a82e..102e52827 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -950,7 +950,7 @@ static mrb_value
 lshift(mrb_state *mrb, mrb_int val, unsigned long width)
 {
   if (width > (sizeof(mrb_int)*CHAR_BIT-1)) {
-      mrb_raise(mrb, E_RANGE_ERROR, "width(%d) > (%d:sizeof(mrb_int)*CHAR_BIT-1)", width,
+      mrb_raisef(mrb, E_RANGE_ERROR, "width(%d) > (%d:sizeof(mrb_int)*CHAR_BIT-1)", width,
 		sizeof(mrb_int)*CHAR_BIT-1);
   }
   val = val << width;
@@ -1164,7 +1164,7 @@ mrb_fix2str(mrb_state *mrb, mrb_value x, int base)
   int neg = 0;
 
   if (base < 2 || 36 < base) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);
   }
   if (val == 0) {
     return mrb_str_new(mrb, "0", 1);
diff --git a/src/object.c b/src/object.c
index 093e8fd2b..a23e397f6 100644
--- a/src/object.c
+++ b/src/object.c
@@ -305,7 +305,7 @@ convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *metho
   m = mrb_intern(mrb, method);
   if (!mrb_respond_to(mrb, val, m)) {
     if (raise) {
-      mrb_raise(mrb, E_TYPE_ERROR, "can't convert %s into %s",
+      mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %s into %s",
          mrb_nil_p(val) ? "nil" :
          (mrb_type(val) == MRB_TT_TRUE) ? "true" :
          (mrb_type(val) == MRB_TT_FALSE) ? "false" :
@@ -341,7 +341,7 @@ 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 cannot be converted to %s by #%s",
+    mrb_raisef(mrb, E_TYPE_ERROR, "%s cannot be converted to %s by #%s",
 	      mrb_obj_classname(mrb, val), tname, method);
   }
   return v;
@@ -419,12 +419,12 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
         else {
           etype = mrb_obj_classname(mrb, x);
         }
-        mrb_raise(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
+        mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
 		  etype, type->name);
       }
       type++;
     }
-    mrb_raise(mrb, E_TYPE_ERROR, "unknown type 0x%x (0x%x given)", t, mrb_type(x));
+    mrb_raisef(mrb, E_TYPE_ERROR, "unknown type 0x%x (0x%x given)", t, mrb_type(x));
   }
 }
 
@@ -513,7 +513,7 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method)
     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);
-      mrb_raise(mrb, E_TYPE_ERROR, "can't convert %s to Integer (%s#%s gives %s)",
+      mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %s to Integer (%s#%s gives %s)",
                cname, cname, method, mrb_obj_classname(mrb, v));
     }
     return v;
diff --git a/src/range.c b/src/range.c
index cdcfcca53..6fe7964fe 100644
--- a/src/range.c
+++ b/src/range.c
@@ -296,7 +296,7 @@ mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp,
 
 out_of_range:
   if (err) {
-    mrb_raise(mrb, E_RANGE_ERROR, "%ld..%s%ld out of range",
+    mrb_raisef(mrb, E_RANGE_ERROR, "%ld..%s%ld out of range",
       b, r->excl? "." : "", e);
   }
   return OTHER;
diff --git a/src/sprintf.c b/src/sprintf.c
index eccbff04d..2bd72ffc6 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -81,7 +81,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
   char d;
 
   if (base != 2) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);
   }
 
   if (val >= (1 << 10))
@@ -146,17 +146,17 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
 
 #define GETARG() (!mrb_undef_p(nextvalue) ? nextvalue : \
   posarg == -1 ? \
-  (mrb_raise(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with numbered", nextarg), mrb_undef_value()) : \
+  (mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with numbered", nextarg), mrb_undef_value()) : \
   posarg == -2 ? \
-  (mrb_raise(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with named", nextarg), mrb_undef_value()) : \
+  (mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with named", nextarg), mrb_undef_value()) : \
   (posarg = nextarg++, GETNTHARG(posarg)))
 
 #define GETPOSARG(n) (posarg > 0 ? \
-  (mrb_raise(mrb, E_ARGUMENT_ERROR, "numbered(%d) after unnumbered(%d)", n, posarg), mrb_undef_value()) : \
+  (mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%d) after unnumbered(%d)", n, posarg), mrb_undef_value()) : \
   posarg == -2 ? \
-  (mrb_raise(mrb, E_ARGUMENT_ERROR, "numbered(%d) after named", n), mrb_undef_value()) : \
+  (mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%d) after named", n), mrb_undef_value()) : \
   ((n < 1) ? \
-  (mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid index - %d$", n), mrb_undef_value()) : \
+  (mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %d$", n), mrb_undef_value()) : \
   (posarg = -1, GETNTHARG(n))))
 
 #define GETNTHARG(nth) \
@@ -164,9 +164,9 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
 
 #define GETNAMEARG(id, name, len) ( \
   posarg > 0 ? \
-  (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after unnumbered(%d)", (len), (name), posarg), mrb_undef_value()) : \
+  (mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%.*s after unnumbered(%d)", (len), (name), posarg), mrb_undef_value()) : \
   posarg == -1 ? \
-  (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after numbered", (len), (name)), mrb_undef_value()) :    \
+  (mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%.*s after numbered", (len), (name)), mrb_undef_value()) :    \
   (posarg = -2, mrb_hash_fetch(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))
 
 #define GETNUM(n, val) \
@@ -178,7 +178,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
     n = next_n; \
   } \
   if (p >= end) { \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %%*[0-9]"); \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %*[0-9]"); \
   }
 
 #define GETASTER(num) do { \
@@ -548,7 +548,7 @@ mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt)
 retry:
     switch (*p) {
       default:
-        mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p);
+        mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p);
         break;
 
       case ' ':
@@ -587,7 +587,7 @@ retry:
         GETNUM(n, width);
         if (*p == '$') {
           if (!mrb_undef_p(nextvalue)) {
-            mrb_raise(mrb, E_ARGUMENT_ERROR, "value given twice - %d$", n);
+            mrb_raisef(mrb, E_ARGUMENT_ERROR, "value given twice - %d$", n);
           }
           nextvalue = GETPOSARG(n);
           p++;
@@ -607,14 +607,14 @@ retry:
         for (; p < end && *p != term; )
           p++;
         if (id) {
-          mrb_raise(mrb, E_ARGUMENT_ERROR, "name%.*s after <%s>",
+          mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%.*s after <%s>",
                     (int)(p - start + 1), start, mrb_sym2name(mrb, id));
         }
         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 (mrb_undef_p(nextvalue)) {
-          mrb_raise(mrb, E_KEY_ERROR, "key%.*s not found", (int)(p - start + 1), start);
+          mrb_raisef(mrb, E_KEY_ERROR, "key%.*s not found", (int)(p - start + 1), start);
         }
         if (term == '}') goto format_s;
         p++;
@@ -658,7 +658,7 @@ retry:
         
       case '%':
         if (flags != FNONE) {
-          mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format character - %%");
+          mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format character - %");
         }
         PUSH("%", 1);
         break;
@@ -1052,7 +1052,7 @@ retry:
    */
   if (posarg >= 0 && nextarg < argc) {
     const char *mesg = "too many arguments for format string";
-    if (RTEST(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, "%s", mesg);
+    if (RTEST(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, mesg);
     if (RTEST(ruby_verbose)) mrb_warn("%s", mesg);
   }
   mrb_str_resize(mrb, result, blen);
diff --git a/src/string.c b/src/string.c
index 11e760ca1..f3ceb6d96 100644
--- a/src/string.c
+++ b/src/string.c
@@ -840,7 +840,7 @@ mrb_str_aref_m(mrb_state *mrb, mrb_value str)
     return mrb_str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2));
   }
   if (argc != 1) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1)", argc);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1)", argc);
   }
   return mrb_str_aref(mrb, str, a1);
 }
@@ -1525,7 +1525,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
 
       tmp = mrb_check_string_type(mrb, sub);
       if (mrb_nil_p(tmp)) {
-        mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given",
+        mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %s given",
            mrb_obj_classname(mrb, sub));
       }
       sub = tmp;
@@ -1931,7 +1931,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
 
       tmp = mrb_check_string_type(mrb, sub);
       if (mrb_nil_p(tmp)) {
-        mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given",
+        mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %s given",
                  mrb_obj_classname(mrb, sub));
       }
       sub = tmp;
@@ -2466,7 +2466,7 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
       break;
     default:
       if (base < 2 || 36 < base) {
-        mrb_raise(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base);
+        mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base);
       }
       if (base <= 32) {
         len = 5;
@@ -2510,7 +2510,7 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
     return mrb_fixnum_value(result);
   }
 bad:
-  mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide string for number(%s)", str);
+  mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalide string for number(%s)", str);
   /* not reached */
   return mrb_fixnum_value(0);
 }
@@ -2589,7 +2589,7 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self)
     base = mrb_fixnum(argv[0]);
 
   if (base < 0) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base);
   }
   return mrb_str_to_inum(mrb, self, base, 0/*Qfalse*/);
 }
@@ -2620,7 +2620,7 @@ mrb_cstr_to_dbl(mrb_state *mrb, const char * p, int badcheck)
   if (p == end) {
     if (badcheck) {
 bad:
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide string for float(%s)", p);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalide string for float(%s)", p);
       /* not reached */
     }
     return d;
diff --git a/src/struct.c b/src/struct.c
index 64f0e8a4a..2a391d0b1 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -70,7 +70,7 @@ mrb_struct_members(mrb_state *mrb, mrb_value s)
   mrb_value members = mrb_struct_s_members(mrb, mrb_obj_value(mrb_obj_class(mrb, s)));
   if (mrb_type(s) == MRB_TT_STRUCT) {
     if (RSTRUCT_LEN(s) != RARRAY_LEN(members)) {
-      mrb_raise(mrb, E_TYPE_ERROR, "struct size differs (%ld required %ld given)",
+      mrb_raisef(mrb, E_TYPE_ERROR, "struct size differs (%ld required %ld given)",
              RARRAY_LEN(members), RSTRUCT_LEN(s));
     }
   }
@@ -595,10 +595,10 @@ mrb_struct_aref_n(mrb_state *mrb, mrb_value s, mrb_value idx)
   i = mrb_fixnum(idx);
   if (i < 0) i = RSTRUCT_LEN(s) + i;
   if (i < 0)
-      mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)",
+      mrb_raisef(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)",
            i, RSTRUCT_LEN(s));
   if (RSTRUCT_LEN(s) <= i)
-      mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)",
+      mrb_raisef(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)",
            i, RSTRUCT_LEN(s));
   return RSTRUCT_PTR(s)[i];
 }
@@ -622,7 +622,7 @@ mrb_struct_aset_id(mrb_state *mrb, mrb_value s, mrb_sym id, mrb_value val)
     len = RARRAY_LEN(members);
     mrb_struct_modify(s);
     if (RSTRUCT_LEN(s) != len) {
-      mrb_raise(mrb, E_TYPE_ERROR, "struct size differs (%ld required %ld given)",
+      mrb_raisef(mrb, E_TYPE_ERROR, "struct size differs (%ld required %ld given)",
              len, RSTRUCT_LEN(s));
     }
     ptr = RSTRUCT_PTR(s);
@@ -675,11 +675,11 @@ mrb_struct_aset(mrb_state *mrb, mrb_value s)
   i = mrb_fixnum(idx);
   if (i < 0) i = RSTRUCT_LEN(s) + i;
   if (i < 0) {
-    mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)",
+    mrb_raisef(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)",
 	      i, RSTRUCT_LEN(s));
   }
   if (RSTRUCT_LEN(s) <= i) {
-    mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)",
+    mrb_raisef(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)",
 	      i, RSTRUCT_LEN(s));
   }
   mrb_struct_modify(s);
diff --git a/src/variable.c b/src/variable.c
index 74dfc02c9..e3e4c4fb5 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -712,7 +712,7 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym)
     }
     c = c->super;
   }
-  mrb_raise(mrb, E_NAME_ERROR, "uninitialized constant %s",
+  mrb_raisef(mrb, E_NAME_ERROR, "uninitialized constant %s",
             mrb_sym2name(mrb, sym));
   /* not reached */
   return mrb_nil_value();
diff --git a/src/vm.c b/src/vm.c
index b580df5a5..693e2413a 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -236,7 +236,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
     mrb_value argv[MRB_FUNCALL_ARGC_MAX];
 
     if (argc > MRB_FUNCALL_ARGC_MAX) {
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)", MRB_FUNCALL_ARGC_MAX);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)", MRB_FUNCALL_ARGC_MAX);
     }
 
     va_start(ap, argc);
@@ -277,7 +277,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mr
   }
   n = mrb->ci->nregs;
   if (argc < 0) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%d)", argc);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%d)", argc);
   }
   c = mrb_class(mrb, self);
   p = mrb_method_search_vm(mrb, &c, mid);
-- 
cgit v1.2.3


From 1933e2660c86c0731806993a9a212116bb454622 Mon Sep 17 00:00:00 2001
From: Masaki Muranaka <monaka@monami-ya.jp>
Date: Wed, 24 Oct 2012 17:00:54 +0900
Subject: Use substitution instead of memset in structure initialization.

---
 include/mruby/data.h | 2 +-
 src/codegen.c        | 8 ++++++--
 src/gc.c             | 3 ++-
 src/load.c           | 8 ++++++--
 src/parse.y          | 3 ++-
 src/proc.c           | 3 ++-
 src/state.c          | 8 ++++++--
 src/vm.c             | 9 +++++----
 8 files changed, 30 insertions(+), 14 deletions(-)

(limited to 'include')

diff --git a/include/mruby/data.h b/include/mruby/data.h
index ad91e0044..b9bedb3f9 100644
--- a/include/mruby/data.h
+++ b/include/mruby/data.h
@@ -30,7 +30,7 @@ struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass, void *
 
 #define Data_Make_Struct(mrb,klass,strct,type,sval) (\
   sval = mrb_malloc(mrb, sizeof(strct)),\
-  memset(sval, 0, sizeof(strct)),\
+  { static const strct zero = { 0 }; *sval = zero},\
   Data_Wrap_Struct(mrb,klass,type,sval)\
 )
 
diff --git a/src/codegen.c b/src/codegen.c
index 2d01ed701..7c3182599 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -453,7 +453,10 @@ new_sym(codegen_scope *s, mrb_sym sym)
   }
   if (s->slen > 125 && s->slen < 256) {
     s->syms = (mrb_sym *)codegen_realloc(s, s->syms, sizeof(mrb_sym)*65536);
-    memset(s->syms+s->slen, 0, sizeof(mrb_sym)*(256-s->slen));
+    for (i = 0; i < 256 - s->slen; i++) {
+      static const mrb_sym mrb_sym_zero = { 0 };
+      s->syms[i + s->slen] = mrb_sym_zero;
+    }
     s->slen = 256;
   }
   s->syms[s->slen] = sym;
@@ -2049,11 +2052,12 @@ codegen(codegen_scope *s, node *tree, int val)
 static codegen_scope*
 scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
 {
+  static const codegen_scope codegen_scope_zero = { 0 };
   mrb_pool *pool = mrb_pool_open(mrb);
   codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
   if (!p) return 0;
 
-  memset(p, 0, sizeof(codegen_scope));
+  *p = codegen_scope_zero;
   p->mrb = mrb;
   p->mpool = pool;
   if (!prev) return p;
diff --git a/src/gc.c b/src/gc.c
index 46699aea3..d92a231b8 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -326,6 +326,7 @@ struct RBasic*
 mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls)
 {
   struct RBasic *p;
+  static const RVALUE RVALUE_zero = { 0 };
 
 #ifdef MRB_GC_STRESS
   mrb_garbage_collect(mrb);
@@ -345,7 +346,7 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls)
 
   mrb->live++;
   gc_protect(mrb, p);
-  memset(p, 0, sizeof(RVALUE));
+  *(RVALUE *)p = RVALUE_zero;
   p->tt = ttype;
   p->c = cls;
   paint_partial_white(mrb, p);
diff --git a/src/load.c b/src/load.c
index a2ae4100b..751c2619b 100644
--- a/src/load.c
+++ b/src/load.c
@@ -448,7 +448,10 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
       goto error_exit;
     }
 
-    memset(irep->syms, 0, sizeof(mrb_sym)*(irep->slen));
+    for (i = 0; i < irep->slen; i++) {
+      static const mrb_sym mrb_sym_zero = { 0 };
+      *irep->syms = mrb_sym_zero;
+    }
     for (i=0; i<irep->slen; i++) {
       snl = bin_to_uint16(src);               //symbol name length
       src += MRB_DUMP_SIZE_OF_SHORT;
@@ -509,11 +512,12 @@ mrb_read_irep(mrb_state *mrb, const char *bin)
   mrb_add_irep(mrb, sirep + nirep);
 
   for (n=0,i=sirep; n<nirep; n++,i++) {
+    static const mrb_irep mrb_irep_zero = { 0 };
     if ((mrb->irep[i] = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep))) == NULL) {
       ret = MRB_DUMP_GENERAL_FAILURE;
       goto error_exit;
     }
-    memset(mrb->irep[i], 0, sizeof(mrb_irep));
+    *mrb->irep[i] = mrb_irep_zero;
   }
   src += sizeof(bin_header) + MRB_DUMP_SIZE_OF_SHORT;  //header + crc
 
diff --git a/src/parse.y b/src/parse.y
index b903ac840..cffb6ba09 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -4747,13 +4747,14 @@ mrb_parser_new(mrb_state *mrb)
 {
   mrb_pool *pool;
   parser_state *p;
+  static const parser_state parser_state_zero = { 0 };
 
   pool = mrb_pool_open(mrb);
   if (!pool) return 0;
   p = (parser_state *)mrb_pool_alloc(pool, sizeof(parser_state));
   if (!p) return 0;
 
-  memset(p, 0, sizeof(parser_state));
+  *p = parser_state_zero;
   p->mrb = mrb;
   p->pool = pool;
   p->in_def = p->in_single = 0;
diff --git a/src/proc.c b/src/proc.c
index 3321c2a91..07834e86d 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -149,11 +149,12 @@ mrb_init_proc(mrb_state *mrb)
 {
   struct RProc *m;
   mrb_irep *call_irep = (mrb_irep *)mrb_alloca(mrb, sizeof(mrb_irep));
+  static const mrb_irep mrb_irep_zero = { 0 };
 
   if ( call_iseq == NULL || call_irep == NULL )
     return;
 
-  memset(call_irep, 0, sizeof(mrb_irep));
+  *call_irep = mrb_irep_zero;
   call_irep->flags = MRB_ISEQ_NO_FREE;
   call_irep->idx = -1;
   call_irep->iseq = call_iseq;
diff --git a/src/state.c b/src/state.c
index 991be310e..8bd222fb5 100644
--- a/src/state.c
+++ b/src/state.c
@@ -16,10 +16,11 @@ void mrb_init_ext(mrb_state*);
 mrb_state*
 mrb_open_allocf(mrb_allocf f, void *ud)
 {
+  static const mrb_state mrb_state_zero = { 0 };
   mrb_state *mrb = (mrb_state *)(f)(NULL, NULL, sizeof(mrb_state), ud);
   if (mrb == NULL) return NULL;
 
-  memset(mrb, 0, sizeof(mrb_state));
+  *mrb = mrb_state_zero;
   mrb->ud = ud;
   mrb->allocf = f;
   mrb->current_white_part = MRB_GC_WHITE_A;
@@ -119,12 +120,15 @@ mrb_add_irep(mrb_state *mrb, int idx)
     mrb->irep_capa = max;
   }
   else if (mrb->irep_capa <= idx) {
+    int i;
     size_t old_capa = mrb->irep_capa;
     while (mrb->irep_capa <= idx) {
       mrb->irep_capa *= 2;
     }
     mrb->irep = (mrb_irep **)mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa);
-    memset(mrb->irep + old_capa, 0, sizeof(mrb_irep*) * (mrb->irep_capa - old_capa));
+    for (i = old_capa; i < mrb->irep_capa - old_capa; i++) {
+      mrb->irep[i] = NULL;
+    }
   }
 }
 
diff --git a/src/vm.c b/src/vm.c
index 693e2413a..120e0d4c0 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -100,15 +100,16 @@ stack_extend(mrb_state *mrb, int room, int keep)
     envadjust(mrb, oldbase, mrb->stbase);
   }
   if (room > keep) {
-#ifndef MRB_NAN_BOXING
-    memset(mrb->stack+keep, 0, sizeof(mrb_value) * (room-keep));
-#else
     int i;
 
     for (i=keep; i<room; i++) {
+#ifndef MRB_NAN_BOXING
+      static const mrb_value mrb_value_zero = { { 0 } };
+      mrb->stack[i] = mrb_value_zero;
+#else
       SET_NIL_VALUE(mrb->stack[i]);
-    }
 #endif
+    }
   }
 }
 
-- 
cgit v1.2.3


From 15f46a1feba74cba4f25ec99df79a3f1e07b0b09 Mon Sep 17 00:00:00 2001
From: Yuichiro MASUI <masui@masuidrive.jp>
Date: Sat, 27 Oct 2012 14:26:50 +0900
Subject: define convert method mrb_int/mrb_float with C string

---
 include/mrbconf.h |  9 ++++++++-
 src/codegen.c     |  4 ++--
 src/dump.c        |  8 ++++----
 src/load.c        |  4 ++--
 src/numeric.c     | 10 +++++-----
 5 files changed, 21 insertions(+), 14 deletions(-)

(limited to 'include')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 76c1b37f9..841ef1823 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -55,19 +55,26 @@
 
 #ifdef MRB_USE_FLOAT
 typedef float mrb_float;
+#define mrb_float_to_str(buf, i) sprintf((buf), "%.7e", (i))
+#define str_to_mrb_float(buf) (mrb_float)strtof((buf),NULL)
 #else
 typedef double mrb_float;
+#define mrb_float_to_str(buf, i) sprintf((buf), "%.16e", (i))
+#define str_to_mrb_float(buf) (mrb_float)strtod((buf),NULL)
 #endif
-#define readfloat(p) (mrb_float)strtod((p),NULL)
 
 #ifdef MRB_NAN_BOXING
 typedef int32_t mrb_int;
 #define MRB_INT_MIN INT32_MIN
 #define MRB_INT_MAX INT32_MAX
+#define mrb_int_to_str(buf, i) sprintf((buf), "%d", (i))
+#define str_to_mrb_int(buf) (mrb_int)strtol((buf), NULL, 10);
 #else
 typedef int mrb_int;
 #define MRB_INT_MIN INT_MIN
 #define MRB_INT_MAX INT_MAX
+#define mrb_int_to_str(buf, i) sprintf((buf), "%d", (i))
+#define str_to_mrb_int(buf) (mrb_int)strtol((buf), NULL, 10);
 #endif
 typedef short mrb_sym;
 
diff --git a/src/codegen.c b/src/codegen.c
index 2d01ed701..9bba9de71 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -1738,7 +1738,7 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_FLOAT:
     if (val) {
       char *p = (char*)tree;
-      mrb_float f = readfloat(p);
+      mrb_float f = str_to_mrb_float(p);
       int off = new_lit(s, mrb_float_value(f));
 
       genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
@@ -1754,7 +1754,7 @@ codegen(codegen_scope *s, node *tree, int val)
       case NODE_FLOAT:
         {
           char *p = (char*)tree;
-          mrb_float f = readfloat(p);
+          mrb_float f = str_to_mrb_float(p);
           int off = new_lit(s, mrb_float_value(-f));
 
           genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
diff --git a/src/dump.c b/src/dump.c
index 15e11153e..5100014d9 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -226,11 +226,11 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type)
 
     switch (mrb_type(irep->pool[pool_no])) {
     case MRB_TT_FIXNUM:
-      len = sprintf( buf, "%d", mrb_fixnum(irep->pool[pool_no]));
+      len = mrb_int_to_str( buf, mrb_fixnum(irep->pool[pool_no]));
       size += (uint32_t)len;
       break;
     case MRB_TT_FLOAT:
-      len = sprintf( buf, "%.16e", mrb_float(irep->pool[pool_no]));
+      len = mrb_float_to_str( buf, mrb_float(irep->pool[pool_no]));
       size += (uint32_t)len;
       break;
     case MRB_TT_STRING:
@@ -346,11 +346,11 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
 
     switch (mrb_type(irep->pool[pool_no])) {
     case MRB_TT_FIXNUM:
-      len = sprintf(char_buf, "%d", mrb_fixnum(irep->pool[pool_no]));
+      len = mrb_int_to_str(char_buf, mrb_fixnum(irep->pool[pool_no]));
       break;
 
     case MRB_TT_FLOAT:
-      len = sprintf(char_buf, "%.16e", mrb_float(irep->pool[pool_no]));
+      len = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no]));
       break;
 
     case MRB_TT_STRING:
diff --git a/src/load.c b/src/load.c
index a2ae4100b..1575ffb4d 100644
--- a/src/load.c
+++ b/src/load.c
@@ -405,12 +405,12 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
 
       switch (tt) {                           //pool data
       case MRB_TT_FIXNUM:
-        fix_num = strtol(buf, NULL, 10);
+        fix_num = str_to_mrb_int(buf);
         irep->pool[i] = mrb_fixnum_value(fix_num);
         break;
 
       case MRB_TT_FLOAT:
-        f = readfloat(buf);
+        f = str_to_mrb_float(buf);
         irep->pool[i] = mrb_float_value(f);
         break;
 
diff --git a/src/numeric.c b/src/numeric.c
index 102e52827..c1491ac51 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -246,8 +246,8 @@ flodivmod(mrb_state *mrb, mrb_float x, mrb_float y, mrb_float *divp, mrb_float *
   mrb_float div, mod;
 
   if (y == 0.0) {
-    *divp = strtod("inf", NULL);
-    *modp = strtod("nan", NULL);
+    *divp = str_to_mrb_float("inf");
+    *modp = str_to_mrb_float("nan");
     return;
   }
   mod = fmod(x, y);
@@ -778,7 +778,7 @@ fix_mod(mrb_state *mrb, mrb_value x)
     mrb_int mod;
 
     if (mrb_fixnum(y) == 0) {
-      return mrb_float_value(strtod("nan", NULL));
+      return mrb_float_value(str_to_mrb_float("nan"));
     }
     fixdivmod(mrb, a, mrb_fixnum(y), 0, &mod);
     return mrb_fixnum_value(mod);
@@ -807,8 +807,8 @@ fix_divmod(mrb_state *mrb, mrb_value x)
     mrb_int div, mod;
 
     if (mrb_fixnum(y) == 0) {
-      return mrb_assoc_new(mrb, mrb_float_value(strtod("inf", NULL)),
-			        mrb_float_value(strtod("nan", NULL)));
+      return mrb_assoc_new(mrb, mrb_float_value(str_to_mrb_float("inf")),
+			        mrb_float_value(str_to_mrb_float("nan")));
     }
     fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod);
     return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod));
-- 
cgit v1.2.3