use new mrb_format API from mrb_raisef; its only format specifier is "%S" (stringify) and takes mrb_value; close #1062

11 files changed, 69 insertions, 68 deletions

diff --git a/src/array.c b/src/array.c
index f9cc9119c..a20fa6daf 100644
--- a/src/array.c
+++ b/src/array.c
@@ -578,7 +578,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_raisef(mrb, E_INDEX_ERROR, "index %" PRIdMRB_INT " out of array", n - a->len);
+      mrb_raisef(mrb, E_INDEX_ERROR, "index %S out of array", mrb_fixnum_value(n - a->len));
     }
   }
   if (a->len <= (int)n) {
diff --git a/src/class.c b/src/class.c
index 875457eb8..4b19ba87e 100644
--- a/src/class.c
+++ b/src/class.c
@@ -177,11 +177,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_raisef(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)", super);
       }
 
       if (!c->super || mrb_class_ptr(super) != mrb_class_real(c->super)) {
-        mrb_raisef(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_sym2str(mrb, id));
       }
     }
     return c;
@@ -189,7 +189,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_raisef(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)", super);
     }
     s = mrb_class_ptr(super);
   }
@@ -216,7 +216,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_raisef(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_sym2str(mrb, id));
   }
   return mrb_class_ptr(c);
 }
@@ -252,13 +252,13 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s
   if (mrb_const_defined_at(mrb, outer, 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));
+        mrb_name_error(mrb, id, "%S is already defined", mrb_sym2str(mrb, id));
     }
     return c;
   }
   if (!super) {
-    mrb_warn("no super class for `%s::%s', Object assumed",
-             mrb_obj_classname(mrb, mrb_obj_value(outer)), mrb_sym2name(mrb, id));
+    mrb_warn("no super class for `%S::%S', Object assumed",
+             mrb_obj_value(outer), mrb_sym2str(mrb, id));
   }
   c = mrb_class_new(mrb, super);
   setup_class(mrb, mrb_obj_value(outer), c, id);
@@ -337,7 +337,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_raisef(mrb, E_TYPE_ERROR, "expected %s", c);
+    mrb_raisef(mrb, E_TYPE_ERROR, "expected %S", mrb_str_new_cstr(mrb, c));
   }
   return tmp;
 }
@@ -606,8 +606,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
           }
           else {
             mrb_value obj = mrb_funcall(mrb, ss, "inspect", 0);
-            mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a symbol",
-                mrb_string_value_ptr(mrb, obj));
+            mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", obj);
           }
           i++;
         }
@@ -655,7 +654,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
       }
       break;
     default:
-      mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid argument specifier %c", c);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid argument specifier %S", mrb_str_new(mrb, &c, 1));
       break;
     }
   }
@@ -981,8 +980,8 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
     if (RSTRING_LEN(inspect) > 64) {
       inspect = mrb_any_to_s(mrb, mrb_obj_value(c));
     }
-    mrb_raisef(mrb, E_NAME_ERROR, "undefined method '%s' for class %s",
-        mrb_sym2name(mrb, mid), RSTRING_PTR(inspect));
+    mrb_raisef(mrb, E_NAME_ERROR, "undefined method '%S' for class %S",
+               mrb_sym2str(mrb, mid), inspect);
   }
   return m;
 }
@@ -1147,8 +1146,8 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
     inspect = mrb_any_to_s(mrb, mod);
   }
 
-  mrb_raisef(mrb, E_NOMETHOD_ERROR, "undefined method '%s' for %s",
-      mrb_sym2name(mrb, mrb_symbol(name)), RSTRING_PTR(inspect));
+  mrb_raisef(mrb, E_NOMETHOD_ERROR, "undefined method '%S' for %S",
+             mrb_sym2str(mrb, mrb_symbol(name)), inspect);
   /* not reached */
   return mrb_nil_value();
 }
@@ -1250,8 +1249,7 @@ void
 mrb_check_inheritable(mrb_state *mrb, struct RClass *super)
 {
   if (super->tt != MRB_TT_CLASS) {
-    mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)",
-           mrb_obj_classname(mrb, mrb_obj_value(super)));
+    mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%S given)", mrb_obj_value(super));
   }
   if (super->tt == MRB_TT_SCLASS) {
     mrb_raise(mrb, E_TYPE_ERROR, "can't make subclass of singleton class");
diff --git a/src/error.c b/src/error.c
index 954140418..52e4958a1 100644
--- a/src/error.c
+++ b/src/error.c
@@ -281,16 +281,12 @@ void
 mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
 {
   va_list args;
-  char buf[256];
-  int n;
+  mrb_value mesg;
 
   va_start(args, fmt);
-  n = vsnprintf(buf, sizeof(buf), fmt, args);
+  mesg = mrb_vformat(mrb, fmt, args);
   va_end(args);
-  if (n < 0) {
-    n = 0;
-  }
-  mrb_exc_raise(mrb, mrb_exc_new(mrb, c, buf, n));
+  mrb_exc_raise(mrb, mrb_exc_new3(mrb, c, mesg));
 }
 
 void
@@ -393,7 +389,7 @@ exception_call:
 
       break;
     default:
-      mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 0..3)", argc);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 0..3)", mrb_fixnum_value(argc));
       break;
   }
   if (argc > 0) {
diff --git a/src/etc.c b/src/etc.c
index 5d2c836e7..0b58ad67c 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -37,14 +37,13 @@ mrb_get_datatype(mrb_state *mrb, mrb_value obj, const mrb_data_type *type)
 void *
 mrb_check_datatype(mrb_state *mrb, mrb_value obj, const mrb_data_type *type)
 {
-  static const char mesg[] = "wrong argument type %s (expected %s)";
-
   if (mrb_special_const_p(obj) || (mrb_type(obj) != MRB_TT_DATA)) {
     mrb_check_type(mrb, obj, MRB_TT_DATA);
   }
   if (DATA_TYPE(obj) != type) {
     const char *etype = DATA_TYPE(obj)->struct_name;
-    mrb_raisef(mrb, E_TYPE_ERROR, mesg, etype, type->struct_name);
+    mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %S (expected %S)",
+               mrb_str_new_cstr(mrb, etype), mrb_str_new_cstr(mrb, type->struct_name));
   }
   return DATA_PTR(obj);
 }
@@ -93,8 +92,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_raisef(mrb, E_TYPE_ERROR, "%s is not a symbol",
-             RSTRING_PTR(tmp));
+        mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", tmp);
       }
       name = tmp;
       /* fall through */
diff --git a/src/kernel.c b/src/kernel.c
index 96dbf0635..23b0153ab 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -345,7 +345,7 @@ mrb_obj_clone(mrb_state *mrb, mrb_value self)
   mrb_value clone;
 
   if (mrb_special_const_p(self)) {
-      mrb_raisef(mrb, E_TYPE_ERROR, "can't clone %s", mrb_obj_classname(mrb, self));
+      mrb_raisef(mrb, E_TYPE_ERROR, "can't clone %S", self);
   }
   p = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
   p->c = mrb_singleton_class_clone(mrb, self);
@@ -381,7 +381,7 @@ mrb_obj_dup(mrb_state *mrb, mrb_value obj)
     mrb_value dup;
 
     if (mrb_special_const_p(obj)) {
-        mrb_raisef(mrb, E_TYPE_ERROR, "can't dup %s", mrb_obj_classname(mrb, obj));
+        mrb_raisef(mrb, E_TYPE_ERROR, "can't dup %S", 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 becb3adb9..78c23b27b 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -1039,8 +1039,9 @@ static mrb_value
 lshift(mrb_state *mrb, mrb_int val, int width)
 {
   if (width > NUMERIC_SHIFT_WIDTH_MAX) {
-      mrb_raisef(mrb, E_RANGE_ERROR, "width(%d) > (%d:sizeof(mrb_int)*CHAR_BIT-1)", width,
-        NUMERIC_SHIFT_WIDTH_MAX);
+    mrb_raisef(mrb, E_RANGE_ERROR, "width(%S) > (%S:sizeof(mrb_int)*CHAR_BIT-1)",
+               mrb_fixnum_value(width),
+               mrb_fixnum_value(NUMERIC_SHIFT_WIDTH_MAX));
   }
   val = val << width;
   return mrb_fixnum_value(val);
@@ -1283,7 +1284,7 @@ mrb_fix2str(mrb_state *mrb, mrb_value x, int base)
   mrb_int val = mrb_fixnum(x);
 
   if (base < 2 || 36 < base) {
-    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %S", mrb_fixnum_value(base));
   }
 
   if (val == 0) {
diff --git a/src/object.c b/src/object.c
index b3ec5c5b9..c3a398db8 100644
--- a/src/object.c
+++ b/src/object.c
@@ -305,12 +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_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" :
-         mrb_obj_classname(mrb, val),
-         tname);
+      mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %S into %S", val, mrb_str_new_cstr(mrb, tname));
       return mrb_nil_value();
     }
     else {
@@ -341,8 +336,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_raisef(mrb, E_TYPE_ERROR, "%s cannot be converted to %s by #%s",
-      mrb_obj_classname(mrb, val), tname, method);
+    mrb_raisef(mrb, E_TYPE_ERROR, "%S cannot be converted to %S by #%S", val,
+               mrb_str_new_cstr(mrb, tname), mrb_str_new_cstr(mrb, method));
   }
   return v;
 }
@@ -416,12 +411,13 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
         else {
           etype = mrb_obj_classname(mrb, x);
         }
-        mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
-          etype, type->name);
+        mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %S (expected %S)",
+                   mrb_str_new_cstr(mrb, etype), mrb_str_new_cstr(mrb, type->name));
       }
       type++;
     }
-    mrb_raisef(mrb, E_TYPE_ERROR, "unknown type 0x%x (0x%x given)", t, mrb_type(x));
+    mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %S (%S given)",
+               mrb_fixnum_value(t), mrb_fixnum_value(mrb_type(x)));
   }
 }
 
@@ -507,9 +503,8 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method)
     if (mrb_fixnum_p(val)) 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);
-      mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %s to Integer (%s#%s gives %s)",
-               cname, cname, method, mrb_obj_classname(mrb, v));
+      mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %s to Integer (%S#%S gives %S)",
+                 val, val, mrb_str_new_cstr(mrb, method), v);
     }
     return v;
 }
diff --git a/src/string.c b/src/string.c
index 65f21a091..4f19663d7 100644
--- a/src/string.c
+++ b/src/string.c
@@ -839,7 +839,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_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1)", argc);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 1)", mrb_fixnum_value(argc));
   }
   return mrb_str_aref(mrb, str, a1);
 }
@@ -1392,8 +1392,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
 
       tmp = mrb_check_string_type(mrb, sub);
       if (mrb_nil_p(tmp)) {
-        mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %s given",
-           mrb_obj_classname(mrb, sub));
+        mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %S given", sub);
       }
       sub = tmp;
     }
@@ -1760,8 +1759,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
 
       tmp = mrb_check_string_type(mrb, sub);
       if (mrb_nil_p(tmp)) {
-        mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %s given",
-                 mrb_obj_classname(mrb, sub));
+        mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %S given", sub);
       }
       sub = tmp;
     }
@@ -2153,7 +2151,7 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
       break;
     default:
       if (base < 2 || 36 < base) {
-        mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base);
+        mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %S", mrb_fixnum_value(base));
       }
       break;
   } /* end of switch (base) { */
@@ -2178,7 +2176,7 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
 
   n = strtoul((char*)str, &end, base);
   if (n > MRB_INT_MAX) {
-    mrb_raisef(mrb, E_ARGUMENT_ERROR, "string (%s) too big for integer", str);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "string (%S) too big for integer", mrb_str_new_cstr(mrb, str));
   }
   val = n;
   if (badcheck) {
@@ -2189,7 +2187,7 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
 
   return mrb_fixnum_value(sign ? val : -val);
 bad:
-  mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid string for number(%s)", str);
+  mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid string for number(%S)", mrb_str_new_cstr(mrb, str));
   /* not reached */
   return mrb_fixnum_value(0);
 }
@@ -2264,7 +2262,7 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self)
     base = mrb_fixnum(argv[0]);
 
   if (base < 0) {
-    mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %S", mrb_fixnum_value(base));
   }
   return mrb_str_to_inum(mrb, self, base, 0/*Qfalse*/);
 }
@@ -2293,7 +2291,7 @@ mrb_cstr_to_dbl(mrb_state *mrb, const char * p, int badcheck)
   if (p == end) {
     if (badcheck) {
 bad:
-      mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid string for float(%s)", p);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid string for float(%S)", mrb_str_new_cstr(mrb, p));
       /* not reached */
     }
     return d;
diff --git a/src/symbol.c b/src/symbol.c
index 37090111a..2612e0d15 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -348,6 +348,21 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
   return str;
 }
 
+mrb_value
+mrb_sym2str(mrb_state *mrb, mrb_sym sym)
+{
+  size_t len;
+  const char *name = mrb_sym2name_len(mrb, sym, &len);
+
+  if (!name) return mrb_undef_value(); /* can't happen */
+  if (symname_p(name) && strlen(name) == len) {
+    return mrb_str_new(mrb, name, len);
+  }
+  else {
+    return mrb_str_dump(mrb, mrb_str_new(mrb, name, len));
+  }
+}
+
 const char*
 mrb_sym2name(mrb_state *mrb, mrb_sym sym)
 {
diff --git a/src/variable.c b/src/variable.c
index 5bacd5141..3f9aacc0a 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -690,8 +690,8 @@ mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym)
     }
     c = c->super;
   }
-  mrb_raisef(mrb, E_NAME_ERROR, "uninitialized class variable %s in %s",
-             mrb_sym2name(mrb, sym), mrb_class_name(mrb, cls));
+  mrb_raisef(mrb, E_NAME_ERROR, "uninitialized class variable %S in %S",
+             mrb_sym2str(mrb, sym), cls);
   /* not reached */
   return mrb_nil_value();
 }
@@ -846,8 +846,8 @@ L_RETRY:
     }
     c = c->super;
   }
-  mrb_raisef(mrb, E_NAME_ERROR, "uninitialized constant %s",
-            mrb_sym2name(mrb, sym));
+  mrb_raisef(mrb, E_NAME_ERROR, "uninitialized constant %S",
+             mrb_sym2str(mrb, sym));
   /* not reached */
   return mrb_nil_value();
 }
diff --git a/src/vm.c b/src/vm.c
index 2e8f79b5a..f067d82b8 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -134,8 +134,8 @@ stack_extend(mrb_state *mrb, int room, int keep)
     envadjust(mrb, oldbase, mrb->stbase);
     /* Raise an exception if the new stack size will be too large,
     to prevent infinite recursion. However, do this only after resizing the stack, so mrb_raisef has stack space to work with. */
-    if(size > MRB_STACK_MAX) {
-      mrb_raisef(mrb, E_RUNTIME_ERROR, "stack level too deep. (limit=%d)", MRB_STACK_MAX);
+    if (size > MRB_STACK_MAX) {
+      mrb_raisef(mrb, E_RUNTIME_ERROR, "stack level too deep. (limit=%S)", mrb_fixnum_value(MRB_STACK_MAX));
     }
   }
 
@@ -275,7 +275,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
     int i;
 
     if (argc > MRB_FUNCALL_ARGC_MAX) {
-      mrb_raisef(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)", MRB_FUNCALL_ARGC_MAX);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%S)", mrb_fixnum_value(MRB_FUNCALL_ARGC_MAX));
     }
 
     va_start(ap, argc);
@@ -323,7 +323,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_raisef(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%d)", argc);
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%S)", mrb_fixnum_value(argc));
     }
     c = mrb_class(mrb, self);
     p = mrb_method_search_vm(mrb, &c, mid);