From eddd3249793b3b307da2fe7734d5923cd238a35b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 25 Apr 2020 14:29:58 +0900 Subject: Add `MRB_SYM()` for inline symbols. --- mrbgems/mruby-method/src/method.c | 132 +++++++++++++++++++------------------- 1 file changed, 66 insertions(+), 66 deletions(-) (limited to 'mrbgems/mruby-method/src') diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c index 111b031b9..502494dd3 100644 --- a/mrbgems/mruby-method/src/method.c +++ b/mrbgems/mruby-method/src/method.c @@ -29,24 +29,24 @@ static mrb_value unbound_method_bind(mrb_state *mrb, mrb_value self) { struct RObject *me; - mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")); - mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name")); - mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc")); - mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass")); + mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner)); + mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name)); + mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc)); + mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass)); mrb_value recv = mrb_get_arg1(mrb); bind_check(mrb, recv, owner); me = method_object_alloc(mrb, mrb_class_get(mrb, "Method")); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), owner); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), recv); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), name); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), proc); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), klass); + mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), owner); + mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv); + mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name); + mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), proc); + mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), klass); return mrb_obj_value(me); } -#define IV_GET(value, name) mrb_iv_get(mrb, value, mrb_intern_lit(mrb, name)) +#define IV_GET(value, name) mrb_iv_get(mrb, value, name) static mrb_value method_eql(mrb_state *mrb, mrb_value self) { @@ -61,22 +61,22 @@ method_eql(mrb_state *mrb, mrb_value self) if (mrb_class(mrb, self) != mrb_class(mrb, other)) return mrb_false_value(); - klass = mrb_class_ptr(IV_GET(self, "_klass")); - if (klass != mrb_class_ptr(IV_GET(other, "_klass"))) + klass = mrb_class_ptr(IV_GET(self, MRB_SYM(_klass))); + if (klass != mrb_class_ptr(IV_GET(other, MRB_SYM(_klass)))) return mrb_false_value(); - owner = mrb_class_ptr(IV_GET(self, "_owner")); - if (owner != mrb_class_ptr(IV_GET(other, "_owner"))) + owner = mrb_class_ptr(IV_GET(self, MRB_SYM(_owner))); + if (owner != mrb_class_ptr(IV_GET(other, MRB_SYM(_owner)))) return mrb_false_value(); - receiver = IV_GET(self, "_recv"); - if (!mrb_obj_equal(mrb, receiver, IV_GET(other, "_recv"))) + receiver = IV_GET(self, MRB_SYM(_recv)); + if (!mrb_obj_equal(mrb, receiver, IV_GET(other, MRB_SYM(_recv)))) return mrb_false_value(); - orig_proc = IV_GET(self, "_proc"); - other_proc = IV_GET(other, "_proc"); + orig_proc = IV_GET(self, MRB_SYM(_proc)); + other_proc = IV_GET(other, MRB_SYM(_proc)); if (mrb_nil_p(orig_proc) && mrb_nil_p(other_proc)) { - if (mrb_symbol(IV_GET(self, "_name")) == mrb_symbol(IV_GET(other, "_name"))) + if (mrb_symbol(IV_GET(self, MRB_SYM(_name))) == mrb_symbol(IV_GET(other, MRB_SYM(_name)))) return mrb_true_value(); else return mrb_false_value(); @@ -118,7 +118,7 @@ mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RCl if (mrb_nil_p(proc)) { mrb_value missing_argv = mrb_ary_new_from_values(mrb, argc, argv); mrb_ary_unshift(mrb, missing_argv, name); - ret = mrb_funcall_argv(mrb, recv, mrb_intern_lit(mrb, "method_missing"), argc + 1, RARRAY_PTR(missing_argv)); + ret = mrb_funcall_argv(mrb, recv, MRB_SYM(method_missing), argc + 1, RARRAY_PTR(missing_argv)); } else if (!mrb_nil_p(block)) { /* @@ -137,10 +137,10 @@ mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RCl static mrb_value method_call(mrb_state *mrb, mrb_value self) { - mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc")); - mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name")); - mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv")); - struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"))); + mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc)); + mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name)); + mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv)); + struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, MRB_SYM(_owner))); mrb_int argc; mrb_value *argv, block; @@ -151,10 +151,10 @@ method_call(mrb_state *mrb, mrb_value self) static mrb_value method_bcall(mrb_state *mrb, mrb_value self) { - mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc")); - mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name")); - mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv")); - mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")); + mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc)); + mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name)); + mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv)); + mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner)); mrb_int argc; mrb_value *argv, block; @@ -167,17 +167,17 @@ static mrb_value method_unbind(mrb_state *mrb, mrb_value self) { struct RObject *ume; - mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")); - mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name")); - mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc")); - mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass")); + mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner)); + mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name)); + mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc)); + mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass)); ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod")); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_owner"), owner); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_recv"), mrb_nil_value()); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_name"), name); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_proc"), proc); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_klass"), klass); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_owner), owner); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_recv), mrb_nil_value()); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_name), name); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_proc), proc); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_klass), klass); return mrb_obj_value(ume); } @@ -196,10 +196,10 @@ method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid) static mrb_value method_super_method(mrb_state *mrb, mrb_value self) { - mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv")); - mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass")); - mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")); - mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name")); + mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv)); + mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass)); + mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner)); + mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name)); struct RClass *super, *rklass; struct RProc *proc; struct RObject *me; @@ -225,11 +225,11 @@ method_super_method(mrb_state *mrb, mrb_value self) super = super->c; me = method_object_alloc(mrb, mrb_obj_class(mrb, self)); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(super)); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), recv); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), name); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), mrb_obj_value(proc)); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), mrb_obj_value(rklass)); + mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), mrb_obj_value(super)); + mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv); + mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name); + mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), mrb_obj_value(proc)); + mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), mrb_obj_value(rklass)); return mrb_obj_value(me); } @@ -237,7 +237,7 @@ method_super_method(mrb_state *mrb, mrb_value self) static mrb_value method_arity(mrb_state *mrb, mrb_value self) { - mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc")); + mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc)); mrb_int arity = mrb_nil_p(proc) ? -1 : mrb_proc_arity(mrb_proc_ptr(proc)); return mrb_fixnum_value(arity); } @@ -245,7 +245,7 @@ method_arity(mrb_state *mrb, mrb_value self) static mrb_value method_source_location(mrb_state *mrb, mrb_value self) { - mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc")); + mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc)); struct RProc *rproc; struct RClass *orig; mrb_value ret; @@ -264,13 +264,13 @@ method_source_location(mrb_state *mrb, mrb_value self) static mrb_value method_parameters(mrb_state *mrb, mrb_value self) { - mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc")); + mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc)); struct RProc *rproc; struct RClass *orig; mrb_value ret; if (mrb_nil_p(proc)) { - mrb_value rest = mrb_symbol_value(mrb_intern_lit(mrb, "rest")); + mrb_value rest = mrb_symbol_value(MRB_SYM(rest)); mrb_value arest = mrb_ary_new_from_values(mrb, 1, &rest); return mrb_ary_new_from_values(mrb, 1, &arest); } @@ -286,9 +286,9 @@ method_parameters(mrb_state *mrb, mrb_value self) static mrb_value method_to_s(mrb_state *mrb, mrb_value self) { - mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")); - mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass")); - mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name")); + mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner)); + mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass)); + mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name)); mrb_value str = mrb_str_new_lit(mrb, "#<"); struct RClass *rklass; @@ -354,11 +354,11 @@ mrb_kernel_method(mrb_state *mrb, mrb_value self) mrb_search_method_owner(mrb, mrb_class(mrb, self), self, name, &owner, &proc, FALSE); me = method_object_alloc(mrb, mrb_class_get(mrb, "Method")); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(owner)); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), self); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), mrb_symbol_value(name)); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), proc ? mrb_obj_value(proc) : mrb_nil_value()); - mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), mrb_obj_value(mrb_class(mrb, self))); + mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), mrb_obj_value(owner)); + mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), self); + mrb_obj_iv_set(mrb, me, MRB_SYM(_name), mrb_symbol_value(name)); + mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), proc ? mrb_obj_value(proc) : mrb_nil_value()); + mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), mrb_obj_value(mrb_class(mrb, self))); return mrb_obj_value(me); } @@ -376,11 +376,11 @@ mrb_module_instance_method(mrb_state *mrb, mrb_value self) mrb_search_method_owner(mrb, mrb_class_ptr(self), self, name, &owner, &proc, TRUE); ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod")); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(owner)); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_recv"), mrb_nil_value()); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_name"), mrb_symbol_value(name)); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_proc"), proc ? mrb_obj_value(proc) : mrb_nil_value()); - mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_klass"), self); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_owner), mrb_obj_value(owner)); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_recv), mrb_nil_value()); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_name), mrb_symbol_value(name)); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_proc), proc ? mrb_obj_value(proc) : mrb_nil_value()); + mrb_obj_iv_set(mrb, ume, MRB_SYM(_klass), self); return mrb_obj_value(ume); } @@ -388,19 +388,19 @@ mrb_module_instance_method(mrb_state *mrb, mrb_value self) static mrb_value method_owner(mrb_state *mrb, mrb_value self) { - return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")); + return mrb_iv_get(mrb, self, MRB_SYM(_owner)); } static mrb_value method_receiver(mrb_state *mrb, mrb_value self) { - return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv")); + return mrb_iv_get(mrb, self, MRB_SYM(_recv)); } static mrb_value method_name(mrb_state *mrb, mrb_value self) { - return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name")); + return mrb_iv_get(mrb, self, MRB_SYM(_name)); } void -- cgit v1.2.3 From b941e918664af9390d4a61d6645dd2d1b9336c9d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 16 May 2020 21:39:29 +0900 Subject: Use more `MRB_QSYM()`. --- mrbgems/mruby-compiler/core/parse.y | 50 ++++++++++++++++++------------------- mrbgems/mruby-method/src/method.c | 2 +- 2 files changed, 26 insertions(+), 26 deletions(-) (limited to 'mrbgems/mruby-method/src') diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index e0adbfc4b..70988d13f 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -2085,7 +2085,7 @@ arg : lhs '=' arg_rhs } | primary_value '[' opt_call_args ']' tOP_ASGN arg_rhs { - $$ = new_op_asgn(p, new_call(p, $1, intern_lit("[]"), $3, '.'), $5, $6); + $$ = new_op_asgn(p, new_call(p, $1, MRB_QSYM(aref), $3, '.'), $5, $6); } | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs { @@ -2295,9 +2295,9 @@ paren_args : '(' opt_call_args ')' new_block_arg(p, new_lvar(p, b))); } #else - mrb_sym r = mrb_intern_lit(p->mrb, "*"); - mrb_sym k = mrb_intern_lit(p->mrb, "**"); - mrb_sym b = mrb_intern_lit(p->mrb, "&"); + mrb_sym r = MRB_QSYM(mul); + mrb_sym k = MRB_QSYM(pow); + mrb_sym b = MRB_QSYM(and); if (local_var_p(p, r) && local_var_p(p, k) && local_var_p(p, b)) { $$ = cons(list2(new_splat(p, new_lvar(p, r)), new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k))))), @@ -3026,7 +3026,7 @@ method_call : operation paren_args } | primary_value '[' opt_call_args ']' { - $$ = new_call(p, $1, intern_lit("[]"), $3, '.'); + $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.'); } ; @@ -3409,15 +3409,15 @@ f_arglist : '(' f_args rparen { #if 1 /* til real keyword args implemented */ - mrb_sym r = mrb_intern_lit(p->mrb, "*"); - mrb_sym b = mrb_intern_lit(p->mrb, "&"); + mrb_sym r = MRB_QSYM(mul); + mrb_sym b = MRB_QSYM(and); local_add_f(p, r); $$ = new_args(p, 0, 0, r, 0, new_args_tail(p, 0, 0, b)); #else - mrb_sym r = mrb_intern_lit(p->mrb, "*"); - mrb_sym k = mrb_intern_lit(p->mrb, "**"); - mrb_sym b = mrb_intern_lit(p->mrb, "&"); + mrb_sym r = MRB_QSYM(mul); + mrb_sym k = MRB_QSYM(pow); + mrb_sym b = MRB_QSYM(and); local_add_f(p, r); local_add_f(p, k); $$ = new_args(p, 0, 0, r, 0, new_args_tail(p, 0, new_kw_rest_args(p, nsym(k)), b)); @@ -3580,7 +3580,7 @@ f_args : f_arg ',' f_optarg ',' f_rest_arg opt_args_tail } | /* none */ { - local_add_f(p, intern_lit("&")); + local_add_f(p, MRB_QSYM(and)); $$ = new_args(p, 0, 0, 0, 0, 0); } ; @@ -3704,7 +3704,7 @@ f_rest_arg : restarg_mark tIDENTIFIER } | restarg_mark { - local_add_f(p, intern_lit("*")); + local_add_f(p, MRB_QSYM(and)); $$ = -1; } ; @@ -4961,7 +4961,7 @@ parser_yylex(parser_state *p) case '*': if ((c = nextc(p)) == '*') { if ((c = nextc(p)) == '=') { - pylval.id = intern_lit("**"); + pylval.id = MRB_QSYM(pow); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -4979,7 +4979,7 @@ parser_yylex(parser_state *p) } else { if (c == '=') { - pylval.id = intern_lit("*"); + pylval.id = MRB_QSYM(mul); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5095,7 +5095,7 @@ parser_yylex(parser_state *p) } if (c == '<') { if ((c = nextc(p)) == '=') { - pylval.id = intern_lit("<<"); + pylval.id = MRB_QSYM(lshift); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5117,7 +5117,7 @@ parser_yylex(parser_state *p) } if (c == '>') { if ((c = nextc(p)) == '=') { - pylval.id = intern_lit(">>"); + pylval.id = MRB_QSYM(rshift); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5225,7 +5225,7 @@ parser_yylex(parser_state *p) if ((c = nextc(p)) == '&') { p->lstate = EXPR_BEG; if ((c = nextc(p)) == '=') { - pylval.id = intern_lit("&&"); + pylval.id = MRB_QSYM(andand); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5237,7 +5237,7 @@ parser_yylex(parser_state *p) return tANDDOT; } else if (c == '=') { - pylval.id = intern_lit("&"); + pylval.id = MRB_QSYM(and); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5264,7 +5264,7 @@ parser_yylex(parser_state *p) if ((c = nextc(p)) == '|') { p->lstate = EXPR_BEG; if ((c = nextc(p)) == '=') { - pylval.id = intern_lit("||"); + pylval.id = MRB_QSYM(oror); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5272,7 +5272,7 @@ parser_yylex(parser_state *p) return tOROP; } if (c == '=') { - pylval.id = intern_lit("|"); + pylval.id = MRB_QSYM(or); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5296,7 +5296,7 @@ parser_yylex(parser_state *p) return '+'; } if (c == '=') { - pylval.id = intern_lit("+"); + pylval.id = MRB_QSYM(add); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5324,7 +5324,7 @@ parser_yylex(parser_state *p) return '-'; } if (c == '=') { - pylval.id = intern_lit("-"); + pylval.id = MRB_QSYM(sub); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5644,7 +5644,7 @@ parser_yylex(parser_state *p) return tREGEXP_BEG; } if ((c = nextc(p)) == '=') { - pylval.id = intern_lit("/"); + pylval.id = MRB_QSYM(div); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5663,7 +5663,7 @@ parser_yylex(parser_state *p) case '^': if ((c = nextc(p)) == '=') { - pylval.id = intern_lit("^"); + pylval.id = MRB_QSYM(xor); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -5840,7 +5840,7 @@ parser_yylex(parser_state *p) } } if ((c = nextc(p)) == '=') { - pylval.id = intern_lit("%"); + pylval.id = MRB_QSYM(mod); p->lstate = EXPR_BEG; return tOP_ASGN; } diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c index 502494dd3..13584294f 100644 --- a/mrbgems/mruby-method/src/method.c +++ b/mrbgems/mruby-method/src/method.c @@ -322,7 +322,7 @@ mrb_search_method_owner(mrb_state *mrb, struct RClass *c, mrb_value obj, mrb_sym if (unbound) { goto name_error; } - if (!mrb_respond_to(mrb, obj, mrb_intern_lit(mrb, "respond_to_missing?"))) { + if (!mrb_respond_to(mrb, obj, MRB_QSYM(respond_to_missing_p))) { goto name_error; } ret = mrb_funcall(mrb, obj, "respond_to_missing?", 2, mrb_symbol_value(name), mrb_true_value()); -- cgit v1.2.3 From 00f5ddc9aeeab49d656044d14a03765bd6fdfc53 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 27 May 2020 23:24:31 +0900 Subject: Use `mrb_funcall_id()` extensively. Except for support files e.g. `mruby-test/driver.c`, which are not target of symbol collection via `rake gensym`. --- mrbgems/mruby-array-ext/src/array.c | 4 ++-- mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c | 2 +- mrbgems/mruby-bin-mirb/tools/mirb/mirb.c | 4 ++-- mrbgems/mruby-compiler/core/codegen.c | 2 +- mrbgems/mruby-io/src/io.c | 2 +- mrbgems/mruby-kernel-ext/src/kernel.c | 2 +- mrbgems/mruby-metaprog/src/metaprog.c | 2 +- mrbgems/mruby-method/src/method.c | 6 +++--- mrbgems/mruby-range-ext/src/range.c | 4 ++-- mrbgems/mruby-socket/src/socket.c | 16 ++++++++-------- mrbgems/mruby-sprintf/src/sprintf.c | 2 +- src/array.c | 2 +- src/error.c | 2 +- src/hash.c | 8 ++++---- src/kernel.c | 8 ++++---- src/numeric.c | 2 +- src/object.c | 6 +++--- 17 files changed, 37 insertions(+), 37 deletions(-) (limited to 'mrbgems/mruby-method/src') diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c index 3ce5d822e..996679b6e 100644 --- a/mrbgems/mruby-array-ext/src/array.c +++ b/mrbgems/mruby-array-ext/src/array.c @@ -149,10 +149,10 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self) return mrb_nil_value(); } case MRB_TT_FIXNUM: - val = mrb_funcall(mrb, self, "delete_at", 1, index); + val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index); return val; default: - val = mrb_funcall(mrb, self, "delete_at", 1, index); + val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index); return val; } } diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c index e8702f4df..f3fefc712 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c @@ -67,7 +67,7 @@ mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t recv = dbg->regs[0]; - v = mrb_funcall(mrb, recv, "instance_eval", 1, ruby_code); + v = mrb_funcall_id(mrb, recv, MRB_SYM(instance_eval), 1, ruby_code); } if (exc) { diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c index 19d0bfc06..ffe22b885 100644 --- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c +++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c @@ -104,13 +104,13 @@ p(mrb_state *mrb, mrb_value obj, int prompt) mrb_value val; char* msg; - val = mrb_funcall(mrb, obj, "inspect", 0); + val = mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0); if (prompt) { if (!mrb->exc) { fputs(" => ", stdout); } else { - val = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0); + val = mrb_funcall_id(mrb, mrb_obj_value(mrb->exc), MRB_SYM(inspect), 0); } } if (!mrb_string_p(val)) { diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 980906e38..b8dd55bd4 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1603,7 +1603,7 @@ codegen(codegen_scope *s, node *tree, int val) { node *n = tree->car->cdr; mrb_sym mid = nsym(n->cdr->car); - mrb_sym mnil = mrb_intern_lit(s->mrb, "nil?"); + mrb_sym mnil = MRB_QSYM(nil_p); if (mid == mnil && n->cdr->cdr->car == NULL) { nil_p = TRUE; codegen(s, n->car, VAL); diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 2c9cba84a..608fc1623 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -109,7 +109,7 @@ io_set_process_status(mrb_state *mrb, pid_t pid, int status) } } if (c_status != NULL) { - v = mrb_funcall(mrb, mrb_obj_value(c_status), "new", 2, mrb_fixnum_value(pid), mrb_fixnum_value(status)); + v = mrb_funcall_id(mrb, mrb_obj_value(c_status), MRB_SYM(new), 2, mrb_fixnum_value(pid), mrb_fixnum_value(status)); } else { v = mrb_fixnum_value(WEXITSTATUS(status)); } diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index 1d183aecd..8d9a3fab7 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -57,7 +57,7 @@ mrb_f_caller(mrb_state *mrb, mrb_value self) return mrb_ary_new(mrb); } - return mrb_funcall(mrb, bt, "[]", 2, mrb_fixnum_value(lev), mrb_fixnum_value(n)); + return mrb_funcall_id(mrb, bt, MRB_QSYM(aref), 2, mrb_fixnum_value(lev), mrb_fixnum_value(n)); } /* diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c index 6c0dc5ad3..01cf723fb 100644 --- a/mrbgems/mruby-metaprog/src/metaprog.c +++ b/mrbgems/mruby-metaprog/src/metaprog.c @@ -622,7 +622,7 @@ remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid) k = kh_get(mt, mrb, h, mid); if (k != kh_end(h)) { kh_del(mt, mrb, h, k); - mrb_funcall(mrb, mod, "method_removed", 1, mrb_symbol_value(mid)); + mrb_funcall_id(mrb, mod, MRB_SYM(method_removed), 1, mrb_symbol_value(mid)); return; } } diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c index 13584294f..d7df381ea 100644 --- a/mrbgems/mruby-method/src/method.c +++ b/mrbgems/mruby-method/src/method.c @@ -256,7 +256,7 @@ method_source_location(mrb_state *mrb, mrb_value self) rproc = mrb_proc_ptr(proc); orig = rproc->c; rproc->c = mrb->proc_class; - ret = mrb_funcall(mrb, proc, "source_location", 0); + ret = mrb_funcall_id(mrb, proc, MRB_SYM(source_location), 0); rproc->c = orig; return ret; } @@ -278,7 +278,7 @@ method_parameters(mrb_state *mrb, mrb_value self) rproc = mrb_proc_ptr(proc); orig = rproc->c; rproc->c = mrb->proc_class; - ret = mrb_funcall(mrb, proc, "parameters", 0); + ret = mrb_funcall_id(mrb, proc, MRB_SYM(parameters), 0); rproc->c = orig; return ret; } @@ -325,7 +325,7 @@ mrb_search_method_owner(mrb_state *mrb, struct RClass *c, mrb_value obj, mrb_sym if (!mrb_respond_to(mrb, obj, MRB_QSYM(respond_to_missing_p))) { goto name_error; } - ret = mrb_funcall(mrb, obj, "respond_to_missing?", 2, mrb_symbol_value(name), mrb_true_value()); + ret = mrb_funcall_id(mrb, obj, MRB_QSYM(respond_to_missing_p), 2, mrb_symbol_value(name), mrb_true_value()); if (!mrb_test(ret)) { goto name_error; } diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c index 2a0b4e97d..633894070 100644 --- a/mrbgems/mruby-range-ext/src/range.c +++ b/mrbgems/mruby-range-ext/src/range.c @@ -81,8 +81,8 @@ range_last(mrb_state *mrb, mrb_value range) return mrb_range_end(mrb, range); } - array = mrb_funcall(mrb, range, "to_a", 0); - return mrb_funcall(mrb, array, "last", 1, mrb_to_int(mrb, num)); + array = mrb_funcall_id(mrb, range, MRB_SYM(to_a), 0); + return mrb_funcall_id(mrb, array, MRB_SYM(last), 1, mrb_to_int(mrb, num)); } /* diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 3916e35b9..63e2b665b 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -177,7 +177,7 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass) for (res = res0; res != NULL; res = res->ai_next) { sa = mrb_str_new(mrb, (char*)res->ai_addr, res->ai_addrlen); - ai = mrb_funcall(mrb, klass, "new", 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol)); + ai = mrb_funcall_id(mrb, klass, MRB_SYM(new), 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol)); mrb_ary_push(mrb, ary, ai); mrb_gc_arena_restore(mrb, arena_idx); } @@ -200,7 +200,7 @@ mrb_addrinfo_getnameinfo(mrb_state *mrb, mrb_value self) host = mrb_str_buf_new(mrb, NI_MAXHOST); serv = mrb_str_buf_new(mrb, NI_MAXSERV); - sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr")); + sastr = mrb_iv_get(mrb, self, MRB_QSYM(a_sockaddr)); if (!mrb_string_p(sastr)) { mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr"); } @@ -222,7 +222,7 @@ mrb_addrinfo_unix_path(mrb_state *mrb, mrb_value self) { mrb_value sastr; - sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr")); + sastr = mrb_iv_get(mrb, self, MRB_QSYM(a_sockaddr)); if (((struct sockaddr *)RSTRING_PTR(sastr))->sa_family != AF_UNIX) mrb_raise(mrb, E_SOCKET_ERROR, "need AF_UNIX address"); if (RSTRING_LEN(sastr) < (mrb_int)offsetof(struct sockaddr_un, sun_path) + 1) { @@ -269,7 +269,7 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen) static int socket_fd(mrb_state *mrb, mrb_value sock) { - return (int)mrb_fixnum(mrb_funcall(mrb, sock, "fileno", 0)); + return (int)mrb_fixnum(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0)); } static int @@ -350,7 +350,7 @@ mrb_basicsocket_getsockopt(mrb_state *mrb, mrb_value self) c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Socket")), MRB_SYM(Option)); family = socket_family(s); data = mrb_str_new(mrb, opt, optlen); - return mrb_funcall(mrb, c, "new", 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data); + return mrb_funcall_id(mrb, c, MRB_SYM(new), 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data); } static mrb_value @@ -472,9 +472,9 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self) } else if (argc == 1) { if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option"); - level = mrb_fixnum(mrb_funcall(mrb, so, "level", 0)); - optname = mrb_fixnum(mrb_funcall(mrb, so, "optname", 0)); - optval = mrb_funcall(mrb, so, "data", 0); + level = mrb_fixnum(mrb_funcall_id(mrb, so, MRB_SYM(level), 0)); + optname = mrb_fixnum(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0)); + optval = mrb_funcall_id(mrb, so, MRB_SYM(data), 0); } else { mrb_argnum_error(mrb, argc, 3, 3); } diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index bf7a4d725..0cf462ef7 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -763,7 +763,7 @@ retry: tmp = mrb_str_new(mrb, buf, 1); } else { - tmp = mrb_funcall(mrb, val, "chr", 0); + tmp = mrb_funcall_id(mrb, val, MRB_SYM(chr), 0); mrb_check_type(mrb, tmp, MRB_TT_STRING); } #endif diff --git a/src/array.c b/src/array.c index 5a4639da7..71a957c9e 100644 --- a/src/array.c +++ b/src/array.c @@ -1090,7 +1090,7 @@ mrb_ary_splat(mrb_state *mrb, mrb_value v) return mrb_ary_new_from_values(mrb, 1, &v); } - ary = mrb_funcall(mrb, v, "to_a", 0); + ary = mrb_funcall_id(mrb, v, MRB_SYM(to_a), 0); if (mrb_nil_p(ary)) { return mrb_ary_new_from_values(mrb, 1, &v); } diff --git a/src/error.c b/src/error.c index 30835e206..742049ace 100644 --- a/src/error.c +++ b/src/error.c @@ -114,7 +114,7 @@ exc_to_s(mrb_state *mrb, mrb_value exc) static mrb_value exc_message(mrb_state *mrb, mrb_value exc) { - return mrb_funcall(mrb, exc, "to_s", 0); + return mrb_funcall_id(mrb, exc, MRB_SYM(to_s), 0); } /* diff --git a/src/hash.c b/src/hash.c index a9ac79226..edff1ef1d 100644 --- a/src/hash.c +++ b/src/hash.c @@ -72,7 +72,7 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key) break; default: - hv = mrb_funcall(mrb, key, "hash", 0); + hv = mrb_funcall_id(mrb, key, MRB_SYM(hash), 0); h = (size_t)tt ^ (size_t)mrb_fixnum(hv); break; } @@ -856,7 +856,7 @@ hash_default(mrb_state *mrb, mrb_value hash, mrb_value key) { if (MRB_RHASH_DEFAULT_P(hash)) { if (MRB_RHASH_PROCDEFAULT_P(hash)) { - return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key); + return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, key); } else { return RHASH_IFNONE(hash); @@ -897,7 +897,7 @@ mrb_hash_default(mrb_state *mrb, mrb_value hash) if (MRB_RHASH_DEFAULT_P(hash)) { if (MRB_RHASH_PROCDEFAULT_P(hash)) { if (!given) return mrb_nil_value(); - return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key); + return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, key); } else { return RHASH_IFNONE(hash); @@ -1083,7 +1083,7 @@ mrb_hash_shift(mrb_state *mrb, mrb_value hash) if (MRB_RHASH_DEFAULT_P(hash)) { if (MRB_RHASH_PROCDEFAULT_P(hash)) { - return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, mrb_nil_value()); + return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, mrb_nil_value()); } else { return RHASH_IFNONE(hash); diff --git a/src/kernel.c b/src/kernel.c index bc42a75d7..519052f4b 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -310,7 +310,7 @@ init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj) default: break; } - mrb_funcall(mrb, dest, "initialize_copy", 1, obj); + mrb_funcall_id(mrb, dest, MRB_SYM(initialize_copy), 1, obj); } /* 15.3.1.3.8 */ @@ -411,8 +411,8 @@ mrb_obj_extend(mrb_state *mrb, mrb_int argc, mrb_value *argv, mrb_value obj) mrb_check_type(mrb, argv[i], MRB_TT_MODULE); } while (argc--) { - mrb_funcall(mrb, argv[argc], "extend_object", 1, obj); - mrb_funcall(mrb, argv[argc], "extended", 1, obj); + mrb_funcall_id(mrb, argv[argc], MRB_SYM(extend_object), 1, obj); + mrb_funcall_id(mrb, argv[argc], MRB_SYM(extended), 1, obj); } return obj; } @@ -749,7 +749,7 @@ obj_respond_to(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "n|b", &id, &priv); respond_to_p = basic_obj_respond_to(mrb, self, id, !priv); if (!respond_to_p) { - rtm_id = mrb_intern_lit(mrb, "respond_to_missing?"); + rtm_id = MRB_QSYM(respond_to_missing_p); if (basic_obj_respond_to(mrb, self, rtm_id, !priv)) { mrb_value args[2], v; args[0] = mrb_symbol_value(id); diff --git a/src/numeric.c b/src/numeric.c index f4961928b..725960cf6 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1558,7 +1558,7 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2) return -2; return mrb_str_cmp(mrb, obj1, obj2); default: - v = mrb_funcall(mrb, obj1, "<=>", 1, obj2); + v = mrb_funcall_id(mrb, obj1, MRB_SYM(cmp), 1, obj2); if (mrb_nil_p(v) || !mrb_fixnum_p(v)) return -2; return mrb_fixnum(v); diff --git a/src/object.c b/src/object.c index 7257f402d..2ef6228e8 100644 --- a/src/object.c +++ b/src/object.c @@ -58,7 +58,7 @@ mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2) return TRUE; } #endif - result = mrb_funcall(mrb, obj1, "==", 1, obj2); + result = mrb_funcall_id(mrb, obj1, MRB_QSYM(eq), 1, obj2); if (mrb_test(result)) return TRUE; return FALSE; } @@ -648,12 +648,12 @@ mrb_check_hash_type(mrb_state *mrb, mrb_value hash) MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj) { - return mrb_obj_as_string(mrb, mrb_funcall(mrb, obj, "inspect", 0)); + return mrb_obj_as_string(mrb, mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0)); } MRB_API mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2) { if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE; - return mrb_test(mrb_funcall(mrb, obj1, "eql?", 1, obj2)); + return mrb_test(mrb_funcall_id(mrb, obj1, MRB_QSYM(eql_p), 1, obj2)); } -- cgit v1.2.3 From 2a366ffba8397c6f848d659dce76e03e1bf05d17 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 1 Jun 2020 10:36:28 +0900 Subject: Use functions that take symbols to reduce string litrals in C. --- mrbgems/mruby-complex/src/complex.c | 4 +- mrbgems/mruby-eval/src/eval.c | 2 +- mrbgems/mruby-io/src/file.c | 58 ++++++++++++++--------------- mrbgems/mruby-io/src/io.c | 8 ++-- mrbgems/mruby-math/src/math.c | 14 +++---- mrbgems/mruby-method/src/method.c | 2 +- mrbgems/mruby-numeric-ext/src/numeric_ext.c | 20 +++++----- mrbgems/mruby-object-ext/src/object.c | 2 +- mrbgems/mruby-random/src/random.c | 2 +- mrbgems/mruby-socket/src/socket.c | 8 ++-- mrbgems/mruby-struct/src/struct.c | 2 +- mrbgems/mruby-time/src/time.c | 2 +- src/class.c | 8 ++-- src/numeric.c | 4 +- 14 files changed, 68 insertions(+), 68 deletions(-) (limited to 'mrbgems/mruby-method/src') diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 0432da633..24dad4235 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -69,7 +69,7 @@ complex_ptr(mrb_state *mrb, mrb_value v) static mrb_value complex_new(mrb_state *mrb, mrb_float real, mrb_float imaginary) { - struct RClass *c = mrb_class_get(mrb, "Complex"); + struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Complex)); struct mrb_complex *p; struct RBasic *comp = complex_alloc(mrb, c, &p); p->real = real; @@ -224,7 +224,7 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb) #ifdef COMPLEX_USE_ISTRUCT mrb_assert(sizeof(struct mrb_complex) < ISTRUCT_DATA_SIZE); #endif - comp = mrb_define_class(mrb, "Complex", mrb_class_get(mrb, "Numeric")); + comp = mrb_define_class(mrb, "Complex", mrb_class_get_id(mrb, MRB_SYM(Numeric))); #ifdef COMPLEX_USE_ISTRUCT MRB_SET_INSTANCE_TT(comp, MRB_TT_ISTRUCT); #else diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c index af6837b81..4271954e5 100644 --- a/mrbgems/mruby-eval/src/eval.c +++ b/mrbgems/mruby-eval/src/eval.c @@ -179,7 +179,7 @@ void mrb_mruby_eval_gem_init(mrb_state* mrb) { mrb_define_module_function(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_ARG(1, 3)); - mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK()); + mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK()); } void diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c index 53ed4b69d..04dece910 100644 --- a/mrbgems/mruby-io/src/file.c +++ b/mrbgems/mruby-io/src/file.c @@ -614,36 +614,36 @@ mrb_init_file(mrb_state *mrb) mrb_define_method(mrb, file, "size", mrb_file_size, MRB_ARGS_NONE()); mrb_define_method(mrb, file, "truncate", mrb_file_truncate, MRB_ARGS_REQ(1)); - cnst = mrb_define_module_under(mrb, file, "Constants"); - mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH)); - mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX)); - mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN)); - mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB)); - mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR)); - mrb_define_const(mrb, cnst, "PATH_SEPARATOR", mrb_str_new_cstr(mrb, PATH_SEPARATOR)); + cnst = mrb_define_module_under_id(mrb, file, MRB_SYM(Constants)); + mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_SH), mrb_fixnum_value(LOCK_SH)); + mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_EX), mrb_fixnum_value(LOCK_EX)); + mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_UN), mrb_fixnum_value(LOCK_UN)); + mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_NB), mrb_fixnum_value(LOCK_NB)); + mrb_define_const_id(mrb, cnst, MRB_SYM(SEPARATOR), mrb_str_new_cstr(mrb, FILE_SEPARATOR)); + mrb_define_const_id(mrb, cnst, MRB_SYM(PATH_SEPARATOR), mrb_str_new_cstr(mrb, PATH_SEPARATOR)); #if defined(_WIN32) || defined(_WIN64) - mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR)); + mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR)); #else - mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value()); + mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_nil_value()); #endif - mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE)); - - mrb_define_const(mrb, cnst, "RDONLY", mrb_fixnum_value(MRB_O_RDONLY)); - mrb_define_const(mrb, cnst, "WRONLY", mrb_fixnum_value(MRB_O_WRONLY)); - mrb_define_const(mrb, cnst, "RDWR", mrb_fixnum_value(MRB_O_RDWR)); - mrb_define_const(mrb, cnst, "APPEND", mrb_fixnum_value(MRB_O_APPEND)); - mrb_define_const(mrb, cnst, "CREAT", mrb_fixnum_value(MRB_O_CREAT)); - mrb_define_const(mrb, cnst, "EXCL", mrb_fixnum_value(MRB_O_EXCL)); - mrb_define_const(mrb, cnst, "TRUNC", mrb_fixnum_value(MRB_O_TRUNC)); - mrb_define_const(mrb, cnst, "NONBLOCK", mrb_fixnum_value(MRB_O_NONBLOCK)); - mrb_define_const(mrb, cnst, "NOCTTY", mrb_fixnum_value(MRB_O_NOCTTY)); - mrb_define_const(mrb, cnst, "BINARY", mrb_fixnum_value(MRB_O_BINARY)); - mrb_define_const(mrb, cnst, "SHARE_DELETE", mrb_fixnum_value(MRB_O_SHARE_DELETE)); - mrb_define_const(mrb, cnst, "SYNC", mrb_fixnum_value(MRB_O_SYNC)); - mrb_define_const(mrb, cnst, "DSYNC", mrb_fixnum_value(MRB_O_DSYNC)); - mrb_define_const(mrb, cnst, "RSYNC", mrb_fixnum_value(MRB_O_RSYNC)); - mrb_define_const(mrb, cnst, "NOFOLLOW", mrb_fixnum_value(MRB_O_NOFOLLOW)); - mrb_define_const(mrb, cnst, "NOATIME", mrb_fixnum_value(MRB_O_NOATIME)); - mrb_define_const(mrb, cnst, "DIRECT", mrb_fixnum_value(MRB_O_DIRECT)); - mrb_define_const(mrb, cnst, "TMPFILE", mrb_fixnum_value(MRB_O_TMPFILE)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NULL), mrb_str_new_cstr(mrb, NULL_FILE)); + + mrb_define_const_id(mrb, cnst, MRB_SYM(RDONLY), mrb_fixnum_value(MRB_O_RDONLY)); + mrb_define_const_id(mrb, cnst, MRB_SYM(WRONLY), mrb_fixnum_value(MRB_O_WRONLY)); + mrb_define_const_id(mrb, cnst, MRB_SYM(RDWR), mrb_fixnum_value(MRB_O_RDWR)); + mrb_define_const_id(mrb, cnst, MRB_SYM(APPEND), mrb_fixnum_value(MRB_O_APPEND)); + mrb_define_const_id(mrb, cnst, MRB_SYM(CREAT), mrb_fixnum_value(MRB_O_CREAT)); + mrb_define_const_id(mrb, cnst, MRB_SYM(EXCL), mrb_fixnum_value(MRB_O_EXCL)); + mrb_define_const_id(mrb, cnst, MRB_SYM(TRUNC), mrb_fixnum_value(MRB_O_TRUNC)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NONBLOCK), mrb_fixnum_value(MRB_O_NONBLOCK)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NOCTTY), mrb_fixnum_value(MRB_O_NOCTTY)); + mrb_define_const_id(mrb, cnst, MRB_SYM(BINARY), mrb_fixnum_value(MRB_O_BINARY)); + mrb_define_const_id(mrb, cnst, MRB_SYM(SHARE_DELETE), mrb_fixnum_value(MRB_O_SHARE_DELETE)); + mrb_define_const_id(mrb, cnst, MRB_SYM(SYNC), mrb_fixnum_value(MRB_O_SYNC)); + mrb_define_const_id(mrb, cnst, MRB_SYM(DSYNC), mrb_fixnum_value(MRB_O_DSYNC)); + mrb_define_const_id(mrb, cnst, MRB_SYM(RSYNC), mrb_fixnum_value(MRB_O_RSYNC)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NOFOLLOW), mrb_fixnum_value(MRB_O_NOFOLLOW)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NOATIME), mrb_fixnum_value(MRB_O_NOATIME)); + mrb_define_const_id(mrb, cnst, MRB_SYM(DIRECT), mrb_fixnum_value(MRB_O_DIRECT)); + mrb_define_const_id(mrb, cnst, MRB_SYM(TMPFILE), mrb_fixnum_value(MRB_O_TMPFILE)); } diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 608fc1623..988d19b02 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -102,10 +102,10 @@ io_set_process_status(mrb_state *mrb, pid_t pid, int status) mrb_value v; c_status = NULL; - if (mrb_class_defined(mrb, "Process")) { - c_process = mrb_module_get(mrb, "Process"); - if (mrb_const_defined(mrb, mrb_obj_value(c_process), mrb_intern_cstr(mrb, "Status"))) { - c_status = mrb_class_get_under(mrb, c_process, "Status"); + if (mrb_class_defined_id(mrb, MRB_SYM(Process))) { + c_process = mrb_module_get_id(mrb, MRB_SYM(Process)); + if (mrb_const_defined(mrb, mrb_obj_value(c_process), MRB_SYM(Status))) { + c_status = mrb_class_get_under_id(mrb, c_process, MRB_SYM(Status)); } } if (c_status != NULL) { diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c index 88b33771b..ff1e84684 100644 --- a/mrbgems/mruby-math/src/math.c +++ b/mrbgems/mruby-math/src/math.c @@ -16,8 +16,8 @@ static void domain_error(mrb_state *mrb, const char *func) { - struct RClass *math = mrb_module_get(mrb, "Math"); - struct RClass *domainerror = mrb_class_get_under(mrb, math, "DomainError"); + struct RClass *math = mrb_module_get_id(mrb, MRB_SYM(Math)); + struct RClass *domainerror = mrb_class_get_under_id(mrb, math, MRB_SYM(DomainError)); mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %s", func); } @@ -730,18 +730,18 @@ mrb_mruby_math_gem_init(mrb_state* mrb) struct RClass *mrb_math; mrb_math = mrb_define_module(mrb, "Math"); - mrb_define_class_under(mrb, mrb_math, "DomainError", mrb->eStandardError_class); + mrb_define_class_under_id(mrb, mrb_math, MRB_SYM(DomainError), mrb->eStandardError_class); #ifdef M_PI - mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, M_PI)); + mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, M_PI)); #else - mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, atan(1.0)*4.0)); + mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, atan(1.0)*4.0)); #endif #ifdef M_E - mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, M_E)); + mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, M_E)); #else - mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, exp(1.0))); + mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, exp(1.0))); #endif mrb_define_module_function(mrb, mrb_math, "sin", math_sin, MRB_ARGS_REQ(1)); diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c index d7df381ea..c6de6a7bd 100644 --- a/mrbgems/mruby-method/src/method.c +++ b/mrbgems/mruby-method/src/method.c @@ -36,7 +36,7 @@ unbound_method_bind(mrb_state *mrb, mrb_value self) mrb_value recv = mrb_get_arg1(mrb); bind_check(mrb, recv, owner); - me = method_object_alloc(mrb, mrb_class_get(mrb, "Method")); + me = method_object_alloc(mrb, mrb_class_get_id(mrb, MRB_SYM(Method))); mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), owner); mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv); mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name); diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index f8aff54bc..fd7072ccd 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -60,16 +60,16 @@ mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1)); #ifndef MRB_WITHOUT_FLOAT - mrb_define_const(mrb, mrb->float_class, "RADIX", mrb_fixnum_value(MRB_FLT_RADIX)); - mrb_define_const(mrb, mrb->float_class, "MANT_DIG", mrb_fixnum_value(MRB_FLT_MANT_DIG)); - mrb_define_const(mrb, mrb->float_class, "EPSILON", mrb_float_value(mrb, MRB_FLT_EPSILON)); - mrb_define_const(mrb, mrb->float_class, "DIG", mrb_fixnum_value(MRB_FLT_DIG)); - mrb_define_const(mrb, mrb->float_class, "MIN_EXP", mrb_fixnum_value(MRB_FLT_MIN_EXP)); - mrb_define_const(mrb, mrb->float_class, "MIN", mrb_float_value(mrb, MRB_FLT_MIN)); - mrb_define_const(mrb, mrb->float_class, "MIN_10_EXP", mrb_fixnum_value(MRB_FLT_MIN_10_EXP)); - mrb_define_const(mrb, mrb->float_class, "MAX_EXP", mrb_fixnum_value(MRB_FLT_MAX_EXP)); - mrb_define_const(mrb, mrb->float_class, "MAX", mrb_float_value(mrb, MRB_FLT_MAX)); - mrb_define_const(mrb, mrb->float_class, "MAX_10_EXP", mrb_fixnum_value(MRB_FLT_MAX_10_EXP)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX), mrb_fixnum_value(MRB_FLT_RADIX)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG), mrb_fixnum_value(MRB_FLT_MANT_DIG)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON), mrb_float_value(mrb, MRB_FLT_EPSILON)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(DIG), mrb_fixnum_value(MRB_FLT_DIG)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_EXP), mrb_fixnum_value(MRB_FLT_MIN_EXP)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN), mrb_float_value(mrb, MRB_FLT_MIN)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_10_EXP), mrb_fixnum_value(MRB_FLT_MIN_10_EXP)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP), mrb_fixnum_value(MRB_FLT_MAX_EXP)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX), mrb_float_value(mrb, MRB_FLT_MAX)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP), mrb_fixnum_value(MRB_FLT_MAX_10_EXP)); #endif /* MRB_WITHOUT_FLOAT */ } diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c index 31bb689f6..57361e8e2 100644 --- a/mrbgems/mruby-object-ext/src/object.c +++ b/mrbgems/mruby-object-ext/src/object.c @@ -123,7 +123,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, mrb->kernel_module, "itself", mrb_f_itself, MRB_ARGS_NONE()); - mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK()); + mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK()); } void diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index c3a3f61b4..c91df35f3 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -135,7 +135,7 @@ get_opt(mrb_state* mrb) static void random_check(mrb_state *mrb, mrb_value random) { - struct RClass *c = mrb_class_get(mrb, "Random"); + struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random)); if (!mrb_obj_is_kind_of(mrb, random, c) || !mrb_istruct_p(random)) { mrb_raise(mrb, E_TYPE_ERROR, "Random instance required"); } diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 63e2b665b..f158959a7 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -53,7 +53,7 @@ #endif #endif -#define E_SOCKET_ERROR (mrb_class_get(mrb, "SocketError")) +#define E_SOCKET_ERROR mrb_class_get_id(mrb, MRB_SYM(SocketError)) #if !defined(mrb_cptr) #define mrb_cptr_value(m,p) mrb_voidp_value((m),(p)) @@ -347,7 +347,7 @@ mrb_basicsocket_getsockopt(mrb_state *mrb, mrb_value self) optlen = sizeof(opt); if (getsockopt(s, (int)level, (int)optname, opt, &optlen) == -1) mrb_sys_fail(mrb, "getsockopt"); - c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Socket")), MRB_SYM(Option)); + c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get_id(mrb, MRB_SYM(Socket))), MRB_SYM(Option)); family = socket_family(s); data = mrb_str_new(mrb, opt, optlen); return mrb_funcall_id(mrb, c, MRB_SYM(new), 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data); @@ -869,7 +869,7 @@ mrb_mruby_socket_gem_init(mrb_state* mrb) mrb_define_method(mrb, ai, "unix_path", mrb_addrinfo_unix_path, MRB_ARGS_NONE()); #endif - io = mrb_class_get(mrb, "IO"); + io = mrb_class_get_id(mrb, MRB_SYM(IO)); bsock = mrb_define_class(mrb, "BasicSocket", io); mrb_define_method(mrb, bsock, "_recvfrom", mrb_basicsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1)); @@ -948,7 +948,7 @@ void mrb_mruby_socket_gem_final(mrb_state* mrb) { mrb_value ai; - ai = mrb_mod_cv_get(mrb, mrb_class_get(mrb, "Addrinfo"), MRB_SYM(_lastai)); + ai = mrb_mod_cv_get(mrb, mrb_class_get_id(mrb, MRB_SYM(Addrinfo)), MRB_SYM(_lastai)); if (mrb_cptr_p(ai)) { freeaddrinfo((struct addrinfo*)mrb_cptr(ai)); } diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index ee5ef85ae..4f50fe5dd 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -20,7 +20,7 @@ static struct RClass * struct_class(mrb_state *mrb) { - return mrb_class_get(mrb, "Struct"); + return mrb_class_get_id(mrb, MRB_SYM(Struct)); } static inline mrb_value diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 5fa700848..621fda42b 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -420,7 +420,7 @@ mrb_time_now(mrb_state *mrb, mrb_value self) MRB_API mrb_value mrb_time_at(mrb_state *mrb, time_t sec, time_t usec, enum mrb_timezone zone) { - return mrb_time_make_time(mrb, mrb_class_get(mrb, "Time"), sec, usec, zone); + return mrb_time_make_time(mrb, mrb_class_get_id(mrb, MRB_SYM(Time)), sec, usec, zone); } /* 15.2.19.6.1 */ diff --git a/src/class.c b/src/class.c index 2bf26f659..2864fdda9 100644 --- a/src/class.c +++ b/src/class.c @@ -2353,10 +2353,10 @@ mrb_init_class(mrb_state *mrb) make_metaclass(mrb, cls); /* name basic classes */ - mrb_define_const(mrb, bob, "BasicObject", mrb_obj_value(bob)); - mrb_define_const(mrb, obj, "Object", mrb_obj_value(obj)); - mrb_define_const(mrb, obj, "Module", mrb_obj_value(mod)); - mrb_define_const(mrb, obj, "Class", mrb_obj_value(cls)); + mrb_define_const_id(mrb, bob, MRB_SYM(BasicObject), mrb_obj_value(bob)); + mrb_define_const_id(mrb, obj, MRB_SYM(Object), mrb_obj_value(obj)); + mrb_define_const_id(mrb, obj, MRB_SYM(Module), mrb_obj_value(mod)); + mrb_define_const_id(mrb, obj, MRB_SYM(Class), mrb_obj_value(cls)); /* name each classes */ mrb_class_name_class(mrb, NULL, bob, MRB_SYM(BasicObject)); diff --git a/src/numeric.c b/src/numeric.c index 725960cf6..195bd40cf 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1688,10 +1688,10 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, fl, "nan?", flo_nan_p, MRB_ARGS_NONE()); #ifdef INFINITY - mrb_define_const(mrb, fl, "INFINITY", mrb_float_value(mrb, INFINITY)); + mrb_define_const_id(mrb, fl, MRB_SYM(INFINITY), mrb_float_value(mrb, INFINITY)); #endif #ifdef NAN - mrb_define_const(mrb, fl, "NAN", mrb_float_value(mrb, NAN)); + mrb_define_const_id(mrb, fl, MRB_SYM(NAN), mrb_float_value(mrb, NAN)); #endif mrb_include_module(mrb, fl, integral); -- cgit v1.2.3