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. --- include/mruby.h | 1 + include/mruby/hash.h | 2 +- include/mruby/presym.h | 19 ++++ mrbgems/mruby-bin-mirb/tools/mirb/mirb.c | 2 +- mrbgems/mruby-compiler/core/codegen.c | 16 +-- mrbgems/mruby-compiler/core/parse.y | 16 +-- mrbgems/mruby-method/src/method.c | 132 +++++++++++----------- mrbgems/mruby-objectspace/src/mruby_objectspace.c | 4 +- mrbgems/mruby-random/src/random.c | 4 +- mrbgems/mruby-socket/src/socket.c | 14 +-- mrbgems/mruby-struct/src/struct.c | 6 +- src/array.c | 10 +- src/backtrace.c | 6 +- src/class.c | 32 +++--- src/error.c | 12 +- src/hash.c | 10 +- src/kernel.c | 6 +- src/print.c | 4 +- src/proc.c | 4 +- src/range.c | 2 +- src/symbol.c | 2 + src/variable.c | 20 ++-- src/vm.c | 6 +- 23 files changed, 175 insertions(+), 155 deletions(-) create mode 100644 include/mruby/presym.h diff --git a/include/mruby.h b/include/mruby.h index 6d884b146..148addf36 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -89,6 +89,7 @@ #include #include #include +#include #include #ifndef MRB_WITHOUT_FLOAT diff --git a/include/mruby/hash.h b/include/mruby/hash.h index 86fbe329d..7dab4a85c 100644 --- a/include/mruby/hash.h +++ b/include/mruby/hash.h @@ -201,7 +201,7 @@ MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2); /* RHASH_TBL allocates st_table if not available. */ #define RHASH(obj) ((struct RHash*)(mrb_ptr(obj))) #define RHASH_TBL(h) (RHASH(h)->ht) -#define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone")) +#define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), MRB_SYM(ifnone)) #define RHASH_PROCDEFAULT(h) RHASH_IFNONE(h) #define MRB_HASH_DEFAULT 1 diff --git a/include/mruby/presym.h b/include/mruby/presym.h new file mode 100644 index 000000000..38e733f25 --- /dev/null +++ b/include/mruby/presym.h @@ -0,0 +1,19 @@ +/** +** @file mruby/presym.h - Preallocated Symbols +** +** See Copyright Notice in mruby.h +*/ + +#ifndef MRUBY_PRESYM_H +#define MRUBY_PRESYM_H + +#undef MRB_PRESYM_MAX +#define MRB_PRESYM_CSYM(sym, num) MRB_PRESYM__##sym = (num<<1), +#define MRB_PRESYM_SYM(sym, num) + +enum mruby_presym { +#include <../build/presym.inc> +}; + +#define MRB_SYM(sym) MRB_PRESYM__##sym +#endif /* MRUBY_PRESYM_H */ diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c index 51ba3fd78..19d0bfc06 100644 --- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c +++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c @@ -672,7 +672,7 @@ main(int argc, char **argv) } else { /* no */ - if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect"))){ + if (!mrb_respond_to(mrb, result, MRB_SYM(inspect))){ result = mrb_any_to_s(mrb, result); } p(mrb, result, 1); diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index c64ffc473..c0d130182 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -737,7 +737,7 @@ for_body(codegen_scope *s, node *tree) genop_2(s, OP_BLOCK, cursp(), s->irep->rlen-1); push();pop(); /* space for a block */ pop(); - idx = new_sym(s, mrb_intern_lit(s->mrb, "each")); + idx = new_sym(s, MRB_SYM(each)); genop_3(s, OP_SENDB, cursp(), idx, 0); } @@ -1489,14 +1489,14 @@ codegen(codegen_scope *s, node *tree, int val) gen_move(s, cursp(), exc, 0); push_n(2); pop_n(2); /* space for one arg and a block */ pop(); - genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1); + genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(__case_eqq)), 1); } else { if (n4) { codegen(s, n4->car, VAL); } else { - genop_2(s, OP_GETCONST, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "StandardError"))); + genop_2(s, OP_GETCONST, cursp(), new_sym(s, MRB_SYM(StandardError))); push(); } pop(); @@ -1739,7 +1739,7 @@ codegen(codegen_scope *s, node *tree, int val) gen_move(s, cursp(), head, 0); push(); push(); pop(); pop(); pop(); if (nint(n->car->car) == NODE_SPLAT) { - genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1); + genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(__case_eqq)), 1); } else { genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "===")), 1); @@ -2266,7 +2266,7 @@ codegen(codegen_scope *s, node *tree, int val) pop_n(n+1); genop_2S(s, OP_BLKPUSH, cursp(), (ainfo<<4)|(lv & 0xf)); if (sendv) n = CALL_MAXARGS; - genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "call")), n); + genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(call)), n); if (val) push(); } break; @@ -2618,7 +2618,7 @@ codegen(codegen_scope *s, node *tree, int val) { node *n; int ai = mrb_gc_arena_save(s->mrb); - int sym = new_sym(s, mrb_intern_lit(s->mrb, "Kernel")); + int sym = new_sym(s, MRB_SYM(Kernel)); genop_1(s, OP_LOADSELF, cursp()); push(); @@ -2698,7 +2698,7 @@ codegen(codegen_scope *s, node *tree, int val) } push(); /* space for a block */ pop_n(argc+2); - sym = new_sym(s, mrb_intern_lit(s->mrb, "compile")); + sym = new_sym(s, MRB_SYM(compile)); genop_3(s, OP_SEND, cursp(), sym, argc); mrb_gc_arena_restore(s->mrb, ai); push(); @@ -2752,7 +2752,7 @@ codegen(codegen_scope *s, node *tree, int val) } push(); /* space for a block */ pop_n(argc+2); - sym = new_sym(s, mrb_intern_lit(s->mrb, "compile")); + sym = new_sym(s, MRB_SYM(compile)); genop_3(s, OP_SEND, cursp(), sym, argc); mrb_gc_arena_restore(s->mrb, ai); push(); diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 9de45a536..393d6b098 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -311,14 +311,14 @@ static void local_add_blk(parser_state *p, mrb_sym blk) { /* allocate register for block */ - local_add_f(p, blk ? blk : mrb_intern_lit(p->mrb, "&")); + local_add_f(p, blk ? blk : intern_lit("&")); } static void local_add_kw(parser_state *p, mrb_sym kwd) { /* allocate register for keywords hash */ - local_add_f(p, kwd ? kwd : mrb_intern_lit(p->mrb, "**")); + local_add_f(p, kwd ? kwd : intern_lit("**")); } static node* @@ -932,13 +932,13 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b) static node* new_imaginary(parser_state *p, node *imaginary) { - return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Complex"), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1); + return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Complex), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1); } static node* new_rational(parser_state *p, node *rational) { - return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Rational"), list1(list1(rational)), 1); + return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Rational), list1(list1(rational)), 1); } /* (:int . i) */ @@ -3010,11 +3010,11 @@ method_call : operation paren_args } | primary_value call_op paren_args { - $$ = new_call(p, $1, intern_lit("call"), $3, $2); + $$ = new_call(p, $1, MRB_SYM(call), $3, $2); } | primary_value tCOLON2 paren_args { - $$ = new_call(p, $1, intern_lit("call"), $3, tCOLON2); + $$ = new_call(p, $1, MRB_SYM(call), $3, tCOLON2); } | keyword_super paren_args { @@ -3580,7 +3580,7 @@ f_args : f_arg ',' f_optarg ',' f_rest_arg opt_args_tail } | /* none */ { - local_add_f(p, mrb_intern_lit(p->mrb, "&")); + local_add_f(p, intern_lit("&")); $$ = new_args(p, 0, 0, 0, 0, 0); } ; @@ -3704,7 +3704,7 @@ f_rest_arg : restarg_mark tIDENTIFIER } | restarg_mark { - local_add_f(p, mrb_intern_lit(p->mrb, "*")); + local_add_f(p, intern_lit("*")); $$ = -1; } ; 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 diff --git a/mrbgems/mruby-objectspace/src/mruby_objectspace.c b/mrbgems/mruby-objectspace/src/mruby_objectspace.c index bded3afa8..16edafced 100644 --- a/mrbgems/mruby-objectspace/src/mruby_objectspace.c +++ b/mrbgems/mruby-objectspace/src/mruby_objectspace.c @@ -71,8 +71,8 @@ os_count_objects(mrb_state *mrb, mrb_value self) mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count); - mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "TOTAL")), mrb_fixnum_value(obj_count.total)); - mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "FREE")), mrb_fixnum_value(obj_count.freed)); + mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(TOTAL)), mrb_fixnum_value(obj_count.total)); + mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(FREE)), mrb_fixnum_value(obj_count.freed)); for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) { mrb_value type; diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index 10c81b946..c3a3f61b4 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -144,7 +144,7 @@ random_check(mrb_state *mrb, mrb_value random) { static mrb_value random_default(mrb_state *mrb) { struct RClass *c = mrb_class_get(mrb, "Random"); - mrb_value d = mrb_const_get(mrb, mrb_obj_value(c), mrb_intern_lit(mrb, "DEFAULT")); + mrb_value d = mrb_const_get(mrb, mrb_obj_value(c), MRB_SYM(DEFAULT)); if (!mrb_obj_is_kind_of(mrb, d, c)) { mrb_raise(mrb, E_TYPE_ERROR, "Random::DEFAULT replaced"); } @@ -401,7 +401,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb) mrb_define_method(mrb, array, "shuffle!", mrb_ary_shuffle_bang, MRB_ARGS_OPT(1)); mrb_define_method(mrb, array, "sample", mrb_ary_sample, MRB_ARGS_OPT(2)); - mrb_const_set(mrb, mrb_obj_value(random), mrb_intern_lit(mrb, "DEFAULT"), + mrb_const_set(mrb, mrb_obj_value(random), MRB_SYM(DEFAULT), mrb_obj_new(mrb, random, 0, NULL)); } diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index a819dcb29..3916e35b9 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -163,17 +163,17 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass) hints.ai_protocol = (int)mrb_fixnum(protocol); } - lastai = mrb_cv_get(mrb, klass, mrb_intern_lit(mrb, "_lastai")); + lastai = mrb_cv_get(mrb, klass, MRB_SYM(_lastai)); if (mrb_cptr_p(lastai)) { freeaddrinfo((struct addrinfo*)mrb_cptr(lastai)); - mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value()); + mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_nil_value()); } error = getaddrinfo(hostname, servname, &hints, &res0); if (error) { mrb_raisef(mrb, E_SOCKET_ERROR, "getaddrinfo: %s", gai_strerror(error)); } - mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_cptr_value(mrb, res0)); + mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_cptr_value(mrb, res0)); for (res = res0; res != NULL; res = res->ai_next) { sa = mrb_str_new(mrb, (char*)res->ai_addr, res->ai_addrlen); @@ -183,7 +183,7 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass) } freeaddrinfo(res0); - mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value()); + mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_nil_value()); return ary; } @@ -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_intern_lit(mrb, "Option")); + 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); @@ -862,7 +862,7 @@ mrb_mruby_socket_gem_init(mrb_state* mrb) #endif ai = mrb_define_class(mrb, "Addrinfo", mrb->object_class); - mrb_mod_cv_set(mrb, ai, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value()); + mrb_mod_cv_set(mrb, ai, MRB_SYM(_lastai), mrb_nil_value()); mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(4)); mrb_define_method(mrb, ai, "getnameinfo", mrb_addrinfo_getnameinfo, MRB_ARGS_OPT(1)); #ifndef _WIN32 @@ -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_intern_lit(mrb, "_lastai")); + ai = mrb_mod_cv_get(mrb, mrb_class_get(mrb, "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 7fbf9225f..ee5ef85ae 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -42,7 +42,7 @@ struct_ivar_get(mrb_state *mrb, mrb_value cls, mrb_sym id) static mrb_value struct_s_members(mrb_state *mrb, struct RClass *klass) { - mrb_value members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern_lit(mrb, "__members__")); + mrb_value members = struct_ivar_get(mrb, mrb_obj_value(klass), MRB_SYM(__members__)); if (mrb_nil_p(members)) { mrb_raise(mrb, E_TYPE_ERROR, "uninitialized struct"); @@ -214,7 +214,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass *kl } MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY); nstr = mrb_obj_value(c); - mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members); + mrb_iv_set(mrb, nstr, MRB_SYM(__members__), members); mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY()); mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY()); @@ -310,7 +310,7 @@ num_members(mrb_state *mrb, struct RClass *klass) { mrb_value members; - members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern_lit(mrb, "__members__")); + members = struct_ivar_get(mrb, mrb_obj_value(klass), MRB_SYM(__members__)); if (!mrb_array_p(members)) { mrb_raise(mrb, E_TYPE_ERROR, "broken members"); } diff --git a/src/array.c b/src/array.c index c33641264..567ed7d8b 100644 --- a/src/array.c +++ b/src/array.c @@ -1312,11 +1312,11 @@ init_ary_each(mrb_state *mrb, struct RClass *ary) *each_irep = mrb_irep_zero; each_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5); - each_irep->syms[0] = mrb_intern_lit(mrb, "each"); - each_irep->syms[1] = mrb_intern_lit(mrb, "to_enum"); + each_irep->syms[0] = MRB_SYM(each); + each_irep->syms[1] = MRB_SYM(to_enum); each_irep->syms[2] = mrb_intern_lit(mrb, "[]"); - each_irep->syms[3] = mrb_intern_lit(mrb, "call"); - each_irep->syms[4] = mrb_intern_lit(mrb, "length"); + each_irep->syms[3] = MRB_SYM(call); + each_irep->syms[4] = MRB_SYM(length); each_irep->slen = 5; each_irep->flags = MRB_ISEQ_NO_FREE; each_irep->iseq = each_iseq; @@ -1326,7 +1326,7 @@ init_ary_each(mrb_state *mrb, struct RClass *ary) p = mrb_proc_new(mrb, each_irep); p->flags |= MRB_PROC_SCOPE | MRB_PROC_STRICT; MRB_METHOD_FROM_PROC(m, p); - mrb_define_method_raw(mrb, ary, mrb_intern_lit(mrb, "each"), m); + mrb_define_method_raw(mrb, ary, MRB_SYM(each), m); } void diff --git a/src/backtrace.c b/src/backtrace.c index 591f4ea4b..b614a04be 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -114,7 +114,7 @@ mrb_print_backtrace(mrb_state *mrb) return; } - backtrace = mrb_obj_iv_get(mrb, mrb->exc, mrb_intern_lit(mrb, "backtrace")); + backtrace = mrb_obj_iv_get(mrb, mrb->exc, MRB_SYM(backtrace)); if (mrb_nil_p(backtrace)) return; if (!mrb_array_p(backtrace)) backtrace = mrb_unpack_backtrace(mrb, backtrace); print_backtrace(mrb, mrb->exc, backtrace); @@ -171,7 +171,7 @@ packed_backtrace(mrb_state *mrb) void mrb_keep_backtrace(mrb_state *mrb, mrb_value exc) { - mrb_sym sym = mrb_intern_lit(mrb, "backtrace"); + mrb_sym sym = MRB_SYM(backtrace); mrb_value backtrace; int ai; @@ -221,7 +221,7 @@ mrb_exc_backtrace(mrb_state *mrb, mrb_value exc) mrb_sym attr_name; mrb_value backtrace; - attr_name = mrb_intern_lit(mrb, "backtrace"); + attr_name = MRB_SYM(backtrace); backtrace = mrb_iv_get(mrb, exc, attr_name); if (mrb_nil_p(backtrace) || mrb_array_p(backtrace)) { return backtrace; diff --git a/src/class.c b/src/class.c index fcbdadea8..465577e1a 100644 --- a/src/class.c +++ b/src/class.c @@ -58,7 +58,7 @@ void mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb_sym id) { mrb_value name; - mrb_sym nsym = mrb_intern_lit(mrb, "__classname__"); + mrb_sym nsym = MRB_SYM(__classname__); if (mrb_obj_iv_defined(mrb, (struct RObject*)c, nsym)) return; if (outer == NULL || outer == mrb->object_class) { @@ -68,7 +68,7 @@ mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb name = mrb_class_path(mrb, outer); if (mrb_nil_p(name)) { /* unnamed outer class */ if (outer != mrb->object_class && outer != c) { - mrb_obj_iv_set_force(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"), + mrb_obj_iv_set_force(mrb, (struct RObject*)c, MRB_SYM(__outer__), mrb_obj_value(outer)); } return; @@ -132,7 +132,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o) o->c = sc; mrb_field_write_barrier(mrb, (struct RBasic*)o, (struct RBasic*)sc); mrb_field_write_barrier(mrb, (struct RBasic*)sc, (struct RBasic*)o); - mrb_obj_iv_set(mrb, (struct RObject*)sc, mrb_intern_lit(mrb, "__attached__"), mrb_obj_value(o)); + mrb_obj_iv_set(mrb, (struct RObject*)sc, MRB_SYM(__attached__), mrb_obj_value(o)); sc->flags |= o->flags & MRB_FL_OBJ_IS_FROZEN; } @@ -302,7 +302,7 @@ mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass) super->flags |= MRB_FL_CLASS_IS_INHERITED; s = mrb_obj_value(super); mrb_mc_clear_by_class(mrb, klass); - mid = mrb_intern_lit(mrb, "inherited"); + mid = MRB_SYM(inherited); if (!mrb_func_basic_p(mrb, s, mid, mrb_bob_init)) { mrb_value c = mrb_obj_value(klass); mrb_funcall_argv(mrb, s, mid, 1, &c); @@ -1578,7 +1578,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv) mrb_get_args(mrb, "*!&", &argv, &argc, &blk); obj = mrb_instance_alloc(mrb, cv); - init = mrb_intern_lit(mrb, "initialize"); + init = MRB_SYM(initialize); if (!mrb_func_basic_p(mrb, obj, init, mrb_bob_init)) { mrb_funcall_with_block(mrb, obj, init, argc, argv, blk); } @@ -1592,7 +1592,7 @@ mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *arg mrb_sym mid; obj = mrb_instance_alloc(mrb, mrb_obj_value(c)); - mid = mrb_intern_lit(mrb, "initialize"); + mid = MRB_SYM(initialize); if (!mrb_func_basic_p(mrb, obj, mid, mrb_bob_init)) { mrb_funcall_argv(mrb, obj, mid, argc, argv); } @@ -1624,7 +1624,7 @@ mrb_class_new_class(mrb_state *mrb, mrb_value cv) super = mrb_obj_value(mrb->object_class); } new_class = mrb_obj_value(mrb_class_new(mrb, mrb_class_ptr(super))); - mid = mrb_intern_lit(mrb, "initialize"); + mid = MRB_SYM(initialize); if (mrb_func_basic_p(mrb, new_class, mid, mrb_class_initialize)) { mrb_class_initialize(mrb, new_class); } @@ -1722,7 +1722,7 @@ MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c) { mrb_value path; - mrb_sym nsym = mrb_intern_lit(mrb, "__classname__"); + mrb_sym nsym = MRB_SYM(__classname__); path = mrb_obj_iv_get(mrb, (struct RObject*)c, nsym); if (mrb_nil_p(path)) { @@ -1891,7 +1891,7 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass) { if (mrb_sclass_p(klass)) { - mrb_value v = mrb_iv_get(mrb, klass, mrb_intern_lit(mrb, "__attached__")); + mrb_value v = mrb_iv_get(mrb, klass, MRB_SYM(__attached__)); mrb_value str = mrb_str_new_lit(mrb, "#syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*2); - new_irep->syms[0] = mrb_intern_lit(mrb, "allocate"); - new_irep->syms[1] = mrb_intern_lit(mrb, "initialize"); + new_irep->syms[0] = MRB_SYM(allocate); + new_irep->syms[1] = MRB_SYM(initialize); new_irep->slen = 2; new_irep->flags = MRB_ISEQ_NO_FREE; new_irep->iseq = new_iseq; @@ -2249,7 +2249,7 @@ init_class_new(mrb_state *mrb, struct RClass *cls) new_irep->nlocals = 3; p = mrb_proc_new(mrb, new_irep); MRB_METHOD_FROM_PROC(m, p); - mrb_define_method_raw(mrb, cls, mrb_intern_lit(mrb, "new"), m); + mrb_define_method_raw(mrb, cls, MRB_SYM(new), m); } void @@ -2279,10 +2279,10 @@ mrb_init_class(mrb_state *mrb) mrb_define_const(mrb, obj, "Class", mrb_obj_value(cls)); /* name each classes */ - mrb_class_name_class(mrb, NULL, bob, mrb_intern_lit(mrb, "BasicObject")); - mrb_class_name_class(mrb, NULL, obj, mrb_intern_lit(mrb, "Object")); /* 15.2.1 */ - mrb_class_name_class(mrb, NULL, mod, mrb_intern_lit(mrb, "Module")); /* 15.2.2 */ - mrb_class_name_class(mrb, NULL, cls, mrb_intern_lit(mrb, "Class")); /* 15.2.3 */ + mrb_class_name_class(mrb, NULL, bob, MRB_SYM(BasicObject)); + mrb_class_name_class(mrb, NULL, obj, MRB_SYM(Object)); /* 15.2.1 */ + mrb_class_name_class(mrb, NULL, mod, MRB_SYM(Module)); /* 15.2.2 */ + mrb_class_name_class(mrb, NULL, cls, MRB_SYM(Class)); /* 15.2.3 */ mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class); /* 15.2.17 */ MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC); diff --git a/src/error.c b/src/error.c index 5d17209e5..30835e206 100644 --- a/src/error.c +++ b/src/error.c @@ -45,7 +45,7 @@ exc_initialize(mrb_state *mrb, mrb_value exc) mrb_value mesg; if (mrb_get_args(mrb, "|o", &mesg) == 1) { - mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), mesg); + mrb_iv_set(mrb, exc, MRB_SYM(mesg), mesg); } return exc; } @@ -74,7 +74,7 @@ exc_exception(mrb_state *mrb, mrb_value self) if (argc == 0) return self; if (mrb_obj_equal(mrb, self, a)) return self; exc = mrb_obj_clone(mrb, self); - mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), a); + mrb_iv_set(mrb, exc, MRB_SYM(mesg), a); return exc; } @@ -90,7 +90,7 @@ exc_exception(mrb_state *mrb, mrb_value self) mrb_value exc_to_s(mrb_state *mrb, mrb_value exc) { - mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg")); + mrb_value mesg = mrb_attr_get(mrb, exc, MRB_SYM(mesg)); struct RObject *p; if (!mrb_string_p(mesg)) { @@ -130,7 +130,7 @@ exc_message(mrb_state *mrb, mrb_value exc) mrb_value mrb_exc_inspect(mrb_state *mrb, mrb_value exc) { - mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg")); + mrb_value mesg = mrb_attr_get(mrb, exc, MRB_SYM(mesg)); mrb_value cname = mrb_mod_to_s(mrb, mrb_obj_value(mrb_obj_class(mrb, exc))); mesg = mrb_obj_as_string(mrb, mesg); return RSTRING_LEN(mesg) == 0 ? cname : mrb_format(mrb, "%v (%v)", mesg, cname); @@ -154,7 +154,7 @@ set_backtrace(mrb_state *mrb, mrb_value exc, mrb_value backtrace) p++; } } - mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "backtrace"), backtrace); + mrb_iv_set(mrb, exc, MRB_SYM(backtrace), backtrace); } static mrb_value @@ -474,7 +474,7 @@ mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv) n = 1; exception_call: { - mrb_sym exc = mrb_intern_lit(mrb, "exception"); + mrb_sym exc = MRB_SYM(exception); if (mrb_respond_to(mrb, argv[0], exc)) { mesg = mrb_funcall_argv(mrb, argv[0], exc, n, argv+1); } diff --git a/src/hash.c b/src/hash.c index c891e1b22..a9ac79226 100644 --- a/src/hash.c +++ b/src/hash.c @@ -683,7 +683,7 @@ mrb_hash_init_copy(mrb_state *mrb, mrb_value self) vret = mrb_obj_value(copy); ifnone = RHASH_IFNONE(self); if (!mrb_nil_p(ifnone)) { - mrb_iv_set(mrb, vret, mrb_intern_lit(mrb, "ifnone"), ifnone); + mrb_iv_set(mrb, vret, MRB_SYM(ifnone), ifnone); } return vret; } @@ -729,7 +729,7 @@ mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key) return val; } - mid = mrb_intern_lit(mrb, "default"); + mid = MRB_SYM(default); if (mrb_func_basic_p(mrb, hash, mid, mrb_hash_default)) { return hash_default(mrb, hash, key); } @@ -824,7 +824,7 @@ mrb_hash_init(mrb_state *mrb, mrb_value hash) } if (!mrb_nil_p(ifnone)) { RHASH(hash)->flags |= MRB_HASH_DEFAULT; - mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone); + mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone); } return hash; } @@ -933,7 +933,7 @@ mrb_hash_set_default(mrb_state *mrb, mrb_value hash) mrb_value ifnone = mrb_get_arg1(mrb); mrb_hash_modify(mrb, hash); - mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone); + mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone); RHASH(hash)->flags &= ~MRB_HASH_PROC_DEFAULT; if (!mrb_nil_p(ifnone)) { RHASH(hash)->flags |= MRB_HASH_DEFAULT; @@ -988,7 +988,7 @@ mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash) mrb_value ifnone = mrb_get_arg1(mrb); mrb_hash_modify(mrb, hash); - mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone); + mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone); if (!mrb_nil_p(ifnone)) { RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT; RHASH(hash)->flags |= MRB_HASH_DEFAULT; diff --git a/src/kernel.c b/src/kernel.c index 10ed9f88e..e192ed752 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -33,7 +33,7 @@ mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func) static mrb_bool mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj) { - return mrb_func_basic_p(mrb, obj, mrb_intern_lit(mrb, "to_s"), mrb_any_to_s); + return mrb_func_basic_p(mrb, obj, MRB_SYM(to_s), mrb_any_to_s); } /* 15.3.1.3.17 */ @@ -240,7 +240,7 @@ mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj) clone->super = klass->super; if (klass->iv) { mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass)); - mrb_obj_iv_set(mrb, (struct RObject*)clone, mrb_intern_lit(mrb, "__attached__"), obj); + mrb_obj_iv_set(mrb, (struct RObject*)clone, MRB_SYM(__attached__), obj); } if (klass->mt) { clone->mt = kh_copy(mt, mrb, klass->mt); @@ -294,7 +294,7 @@ init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj) case MRB_TT_MODULE: copy_class(mrb, dest, obj); mrb_iv_copy(mrb, dest, obj); - mrb_iv_remove(mrb, dest, mrb_intern_lit(mrb, "__classname__")); + mrb_iv_remove(mrb, dest, MRB_SYM(__classname__)); break; case MRB_TT_OBJECT: case MRB_TT_SCLASS: diff --git a/src/print.c b/src/print.c index a75814d81..6bf7da6a5 100644 --- a/src/print.c +++ b/src/print.c @@ -60,11 +60,11 @@ mrb_print_error(mrb_state *mrb) MRB_API void mrb_show_version(mrb_state *mrb) { - printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_DESCRIPTION")), stdout); + printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(MRUBY_DESCRIPTION)), stdout); } MRB_API void mrb_show_copyright(mrb_state *mrb) { - printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_COPYRIGHT")), stdout); + printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(MRUBY_COPYRIGHT)), stdout); } diff --git a/src/proc.c b/src/proc.c index c00b09acf..743e9610c 100644 --- a/src/proc.c +++ b/src/proc.c @@ -200,7 +200,7 @@ mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class) p = (struct RProc *)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb_class_ptr(proc_class)); mrb_proc_copy(p, mrb_proc_ptr(blk)); proc = mrb_obj_value(p); - mrb_funcall_with_block(mrb, proc, mrb_intern_lit(mrb, "initialize"), 0, NULL, proc); + mrb_funcall_with_block(mrb, proc, MRB_SYM(initialize), 0, NULL, proc); if (!MRB_PROC_STRICT_P(p) && mrb->c->ci > mrb->c->cibase && MRB_PROC_ENV(p) == mrb->c->ci[-1].env) { p->flags |= MRB_PROC_ORPHAN; @@ -325,7 +325,7 @@ mrb_init_proc(mrb_state *mrb) p = mrb_proc_new(mrb, call_irep); irep_obj->data = NULL; MRB_METHOD_FROM_PROC(m, p); - mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m); + mrb_define_method_raw(mrb, mrb->proc_class, MRB_SYM(call), m); mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m); mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.2.6 */ diff --git a/src/range.c b/src/range.c index 0b4e6dbca..868d3d397 100644 --- a/src/range.c +++ b/src/range.c @@ -78,7 +78,7 @@ range_ptr_init(mrb_state *mrb, struct RRange *r, mrb_value beg, mrb_value end, m if (r) { if (RANGE_INITIALIZED_P(r)) { /* Ranges are immutable, so that they should be initialized only once. */ - mrb_name_error(mrb, mrb_intern_lit(mrb, "initialize"), "'initialize' called twice"); + mrb_name_error(mrb, MRB_SYM(initialize), "'initialize' called twice"); } else { range_ptr_alloc_edges(mrb, r); diff --git a/src/symbol.c b/src/symbol.c index a78dd5f4c..a09298b23 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -13,6 +13,8 @@ #include #undef MRB_PRESYM_MAX +#undef MRB_PRESYM_CSYM +#undef MRB_PRESYM_SYM #define MRB_PRESYM_CSYM(sym, num) #sym, #define MRB_PRESYM_SYM(sym, num) #sym, diff --git a/src/variable.c b/src/variable.c index c36fea6e3..add1155c8 100644 --- a/src/variable.c +++ b/src/variable.c @@ -379,11 +379,11 @@ assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v) if (namespace_p(obj->tt) && namespace_p(mrb_type(v))) { struct RObject *c = mrb_obj_ptr(v); if (obj != c && ISUPPER(mrb_sym_name_len(mrb, sym, NULL)[0])) { - mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__"); + mrb_sym id_classname = MRB_SYM(__classname__); mrb_value o = mrb_obj_iv_get(mrb, c, id_classname); if (mrb_nil_p(o)) { - mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__"); + mrb_sym id_outer = MRB_SYM(__outer__); o = mrb_obj_iv_get(mrb, c, id_outer); if (mrb_nil_p(o)) { @@ -643,8 +643,7 @@ mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym) if (cls && cls->tt == MRB_TT_SCLASS) { mrb_value klass; - klass = mrb_obj_iv_get(mrb, (struct RObject *)cls, - mrb_intern_lit(mrb, "__attached__")); + klass = mrb_obj_iv_get(mrb, (struct RObject *)cls, MRB_SYM(__attached__)); c = mrb_class_ptr(klass); if (c->tt == MRB_TT_CLASS || c->tt == MRB_TT_MODULE) { given = FALSE; @@ -688,8 +687,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v) if (cls && cls->tt == MRB_TT_SCLASS) { mrb_value klass; - klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, - mrb_intern_lit(mrb, "__attached__")); + klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__)); switch (mrb_type(klass)) { case MRB_TT_CLASS: case MRB_TT_MODULE: @@ -803,7 +801,7 @@ L_RETRY: goto L_RETRY; } name = mrb_symbol_value(sym); - return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name); + return mrb_funcall_argv(mrb, mrb_obj_value(base), MRB_SYM(const_missing), 1, &name); } MRB_API mrb_value @@ -829,7 +827,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) while (c2 && c2->tt == MRB_TT_SCLASS) { mrb_value klass; - if (!iv_get(mrb, c2->iv, mrb_intern_lit(mrb, "__attached__"), &klass)) { + if (!iv_get(mrb, c2->iv, MRB_SYM(__attached__), &klass)) { c2 = NULL; break; } @@ -1070,7 +1068,7 @@ outer_class(mrb_state *mrb, struct RClass *c) { mrb_value ov; - ov = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__")); + ov = mrb_obj_iv_get(mrb, (struct RObject*)c, MRB_SYM(__outer__)); if (mrb_nil_p(ov)) return NULL; switch (mrb_type(ov)) { case MRB_TT_CLASS: @@ -1120,8 +1118,8 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c) str = mrb_sym_name_len(mrb, name, &len); mrb_str_cat(mrb, path, str, len); if (RSTRING_PTR(path)[0] != '#') { - iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL); - iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path); + iv_del(mrb, c->iv, MRB_SYM(__outer__), NULL); + iv_put(mrb, c->iv, MRB_SYM(__classname__), path); mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path); path = mrb_str_dup(mrb, path); } diff --git a/src/vm.c b/src/vm.c index cc9a187b7..d032f2794 100644 --- a/src/vm.c +++ b/src/vm.c @@ -467,7 +467,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc c = mrb_class(mrb, self); m = mrb_method_search_vm(mrb, &c, mid); if (MRB_METHOD_UNDEF_P(m)) { - mrb_sym missing = mrb_intern_lit(mrb, "method_missing"); + mrb_sym missing = MRB_SYM(method_missing); mrb_value args = mrb_ary_new_from_values(mrb, argc, argv); m = mrb_method_search_vm(mrb, &c, missing); if (MRB_METHOD_UNDEF_P(m)) { @@ -1364,7 +1364,7 @@ RETRY_TRY_BLOCK: cls = mrb_class(mrb, recv); m = mrb_method_search_vm(mrb, &cls, mid); if (MRB_METHOD_UNDEF_P(m)) { - mrb_sym missing = mrb_intern_lit(mrb, "method_missing"); + mrb_sym missing = MRB_SYM(method_missing); m = mrb_method_search_vm(mrb, &cls, missing); if (MRB_METHOD_UNDEF_P(m) || (missing == mrb->c->ci->mid && mrb_obj_eq(mrb, regs[0], recv))) { mrb_value args = (argc < 0) ? regs[a+1] : mrb_ary_new_from_values(mrb, c, regs+a+1); @@ -1547,7 +1547,7 @@ RETRY_TRY_BLOCK: cls = target_class->super; m = mrb_method_search_vm(mrb, &cls, mid); if (MRB_METHOD_UNDEF_P(m)) { - mrb_sym missing = mrb_intern_lit(mrb, "method_missing"); + mrb_sym missing = MRB_SYM(method_missing); if (mid != missing) { cls = mrb_class(mrb, recv); -- cgit v1.2.3