admin/mruby-mruby
1
0
Fork 0
mirror of https://github.com/mruby/mruby synced 2026-06-08 16:11:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Yukihiro Matz Matsumoto
2013-03-27 23:41:23 +09:00
parent 8ce842a5d9
commit 18b2683b97
12 changed files with 70 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/array.c
+1 -1
View File
@@ -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) {
src/class.c
+15 -17
View File
@@ -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");
src/error.c
+4 -8
View File
@@ -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) {
src/etc.c
+3 -5
View File
@@ -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 */
src/kernel.c
+2 -2
View File
@@ -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);
src/numeric.c
+4 -3
View File
@@ -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) {
src/object.c
+9 -14
View File
@@ -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;
}
src/string.c
+8 -10
View File
@@ -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;
src/symbol.c
+15
View File
@@ -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)
{
src/variable.c
+4 -4
View File
@@ -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();
}
src/vm.c
+4 -4
View File
@@ -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);