From a476d7114334b926d676faefb43a01ca617b552e Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 24 Apr 2020 10:53:27 +0900 Subject: Support `presym` in `symbol.c`. --- src/symbol.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 46 insertions(+), 2 deletions(-) (limited to 'src/symbol.c') diff --git a/src/symbol.c b/src/symbol.c index 992848797..a78dd5f4c 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -12,6 +12,36 @@ #include #include +#undef MRB_PRESYM_MAX +#define MRB_PRESYM_CSYM(sym, num) #sym, +#define MRB_PRESYM_SYM(sym, num) #sym, + +static const char *presym_table[] = { +#include <../build/presym.inc> + NULL +}; + +static mrb_sym +presym_find(const char *name) +{ + /* use linear search for now */ + /* binary search should work better */ + int i; + + for (i=0; presym_table[i]; i++) { + if (strcmp(presym_table[i], name)==0) + return i+1; + } + return 0; +} + +static const char* +presym_sym2name(mrb_sym sym) +{ + if (sym > MRB_PRESYM_MAX) return NULL; + return presym_table[sym-1]; +} + /* ------------------------------------------------------ */ typedef struct symbol_name { mrb_bool lit : 1; @@ -130,6 +160,11 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp) symbol_name *sname; uint8_t hash; + /* presym */ + if (strlen(name) == len) { + i = presym_find(name); + if (i > 0) return i< 0) return i; @@ -142,7 +177,7 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp) do { sname = &mrb->symtbl[i]; if (sname->len == len && memcmp(sname->name, name, len) == 0) { - return i<prev == 0xff) { i -= 0xff; @@ -205,7 +240,7 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit) } mrb->symhash[hash] = mrb->symidx = sym; - return sym<>= SYMBOL_NORMAL_SHIFT; + { + const char *name = presym_sym2name(sym); + if (name) { + if (lenp) *lenp = strlen(name); + return name; + } + } + sym -= MRB_PRESYM_MAX; + if (sym == 0 || mrb->symidx < sym) { if (lenp) *lenp = 0; return NULL; -- cgit v1.2.3 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 (limited to 'src/symbol.c') 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 From d2cab16301ecabbe67886051d4c777a73de6d327 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 27 Apr 2020 07:58:33 +0900 Subject: Update `presym_find` to use more efficient binary search. --- src/symbol.c | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) (limited to 'src/symbol.c') diff --git a/src/symbol.c b/src/symbol.c index a09298b23..8a98e9e2e 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -26,13 +26,20 @@ static const char *presym_table[] = { static mrb_sym presym_find(const char *name) { - /* use linear search for now */ - /* binary search should work better */ - int i; - - for (i=0; presym_table[i]; i++) { - if (strcmp(presym_table[i], name)==0) - return i+1; + int start = 0; + int end = MRB_PRESYM_MAX-1; + + while (start<=end) { + int mid = (start+end)/2; + int cmp = strcmp(name, presym_table[mid]); + + if (cmp == 0) { + return mid+1; + } else if (cmp < 0) { + end = mid-1; + } else { + start = mid+1; + } } return 0; } -- cgit v1.2.3 From 76d752c03b3a681685ab4d0f7b7dcfc854a02e0c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 28 Apr 2020 22:18:06 +0900 Subject: Fix `presym_find` for strings without `NUL` terminators. --- src/symbol.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) (limited to 'src/symbol.c') diff --git a/src/symbol.c b/src/symbol.c index 8a98e9e2e..35c3c3015 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -24,21 +24,21 @@ static const char *presym_table[] = { }; static mrb_sym -presym_find(const char *name) +presym_find(const char *name, size_t len) { int start = 0; int end = MRB_PRESYM_MAX-1; while (start<=end) { int mid = (start+end)/2; - int cmp = strcmp(name, presym_table[mid]); + int cmp = strncmp(name, presym_table[mid], len); - if (cmp == 0) { + if (cmp == 0 && presym_table[mid][len] == '\0') { return mid+1; - } else if (cmp < 0) { - end = mid-1; - } else { + } else if (cmp > 0) { start = mid+1; + } else { + end = mid-1; } } return 0; @@ -170,10 +170,9 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp) uint8_t hash; /* presym */ - if (strlen(name) == len) { - i = presym_find(name); - if (i > 0) return i< 0) return i< 0) return i; -- cgit v1.2.3 From 1bcf6d9f3cacf6a5c54ee0c74d0dad0f0e9ed436 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 15 May 2020 16:44:36 +0900 Subject: Create `MRB_OPSYM()` macro to refer symbols corresponding operators. For example, `MRB_OPSYM(add)` refers a symbol for `+`. --- Rakefile | 35 +++++++++++++++++++++++++++++++++++ include/mruby/presym.h | 5 ++++- src/symbol.c | 2 ++ 3 files changed, 41 insertions(+), 1 deletion(-) (limited to 'src/symbol.c') diff --git a/Rakefile b/Rakefile index 8c7533b43..2aa96fc1a 100644 --- a/Rakefile +++ b/Rakefile @@ -146,11 +146,46 @@ file presym_inc => presym_file do presyms = File.readlines(presym_file, chomp: true) rm_f presym_inc File.open(presym_inc, "w") do |f| + op_table = { + "!" => "not", + "!=" => "neq", + "!~" => "nmatch", + "%" => "mod", + "&" => "and", + "&&" => "andand", + "*" => "mul", + "**" => "pow", + "+" => "add", + "+@" => "plus", + "-" => "sub", + "-@" => "minus", + "/" => "div", + "<" => "lt", + "<=" => "le", + "<<" => "lshift", + "<=>" => "cmp", + "==" => "eq", + "===" => "eqq", + "=~" => "match", + ">" => "gt", + ">=" => "ge", + ">>" => "rshift", + "[]" => "aref", + "[]=" => "aset", + "^" => "xor", + "`" => "tick", + "|" => "or", + "||" => "oror", + "~" => "neg", + } f.print "/* MRB_PRESYM_CSYM(sym, num) - symbol which is valid C id name */\n" + f.print "/* MRB_PRESYM_OPSYM(op, sym, num) - symbol which is an operator id */\n" f.print "/* MRB_PRESYM_SYM(sym, num) - symbol which is not valid C id */\n\n" presyms.each.with_index do |sym,i| if /\A\w+\Z/ =~ sym f.print "MRB_PRESYM_CSYM(#{sym}, #{i+1})\n" + elsif op_table.key?(sym) + f.print "MRB_PRESYM_OPSYM(#{sym}, #{op_table[sym]}, #{i+1})\n" else f.print "MRB_PRESYM_SYM(#{sym}, #{i+1})\n" end diff --git a/include/mruby/presym.h b/include/mruby/presym.h index ff3cc7ac5..bd3918c52 100644 --- a/include/mruby/presym.h +++ b/include/mruby/presym.h @@ -9,14 +9,17 @@ #undef MRB_PRESYM_MAX #define MRB_PRESYM_CSYM(sym, num) MRB_PRESYM__##sym = (num<<1), -#define MRB_PRESYM_SYM(sym, num) +#define MRB_PRESYM_OPSYM(op, sym, num) MRB_PRESYM_op_##sym = (num<<1), +#define MRB_PRESYM_SYM(sym, num) enum mruby_presym { #include <../build/presym.inc> }; #undef MRB_PRESYM_CSYM +#undef MRB_PRESYM_OPSYM #undef MRB_PRESYM_SYM #define MRB_SYM(sym) MRB_PRESYM__##sym +#define MRB_OPSYM(sym) MRB_PRESYM_op_##sym #endif /* MRUBY_PRESYM_H */ diff --git a/src/symbol.c b/src/symbol.c index 35c3c3015..5f30ccb39 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -14,8 +14,10 @@ #undef MRB_PRESYM_MAX #undef MRB_PRESYM_CSYM +#undef MRB_PRESYM_OPSYM #undef MRB_PRESYM_SYM #define MRB_PRESYM_CSYM(sym, num) #sym, +#define MRB_PRESYM_OPSYM(op, sym, num) #op, #define MRB_PRESYM_SYM(sym, num) #sym, static const char *presym_table[] = { -- cgit v1.2.3 From 246c76e261ee033210527cfcd37c8eb4bfe680c7 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 15 May 2020 18:04:57 +0900 Subject: Rename `MRB_OPSYM()` to `MRB_QSYM()`. Where `QSYM` means quoted symbols, which cannot be represented C symbols, so specify aliases instead. - operators: name of the operation, e.g. add for `+` - predicates: add `_p` suffix instead of `?` - bang methods: add `_b` suffix instead of `!` - instance variables: add `a_` prefix instead of `@` - global variables: add `d_` prefix instead of `@` - class variables: unsupported; don't use them --- Rakefile | 16 ++++++++++++++-- include/mruby/presym.h | 6 +++--- src/kernel.c | 2 +- src/symbol.c | 4 ++-- 4 files changed, 20 insertions(+), 8 deletions(-) (limited to 'src/symbol.c') diff --git a/Rakefile b/Rakefile index f4a5c7573..9de12fb57 100644 --- a/Rakefile +++ b/Rakefile @@ -173,13 +173,25 @@ file presym_inc => presym_file do "~" => "neg", } f.print "/* MRB_PRESYM_CSYM(sym, num) - symbol which is valid C id name */\n" - f.print "/* MRB_PRESYM_OPSYM(op, sym, num) - symbol which is an operator id */\n" + f.print "/* MRB_PRESYM_QSYM(sym, name, num) - symbol with alias name */\n" f.print "/* MRB_PRESYM_SYM(sym, num) - symbol which is not valid C id */\n\n" presyms.each.with_index do |sym,i| if /\A\w+\Z/ =~ sym f.print "MRB_PRESYM_CSYM(#{sym}, #{i+1})\n" elsif op_table.key?(sym) - f.print "MRB_PRESYM_OPSYM(#{sym}, #{op_table[sym]}, #{i+1})\n" + f.print "MRB_PRESYM_QSYM(#{sym}, #{op_table[sym]}, #{i+1})\n" + elsif /\?\Z/ =~ sym + s = sym.dup; s[-1] = "_p" + f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" + elsif /\!\Z/ =~ sym + s = sym.dup; s[-1] = "_b" + f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" + elsif /\A@/ =~ sym + s = sym.dup; s[0] = "a_" + f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" + elsif /\A$/ =~ sym + s = sym.dup; s[0] = "d_" + f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" else f.print "MRB_PRESYM_SYM(#{sym}, #{i+1})\n" end diff --git a/include/mruby/presym.h b/include/mruby/presym.h index bd3918c52..33e51fe18 100644 --- a/include/mruby/presym.h +++ b/include/mruby/presym.h @@ -9,7 +9,7 @@ #undef MRB_PRESYM_MAX #define MRB_PRESYM_CSYM(sym, num) MRB_PRESYM__##sym = (num<<1), -#define MRB_PRESYM_OPSYM(op, sym, num) MRB_PRESYM_op_##sym = (num<<1), +#define MRB_PRESYM_QSYM(src, sym, num) MRB_PRESYM_q_##sym = (num<<1), #define MRB_PRESYM_SYM(sym, num) enum mruby_presym { @@ -17,9 +17,9 @@ enum mruby_presym { }; #undef MRB_PRESYM_CSYM -#undef MRB_PRESYM_OPSYM +#undef MRB_PRESYM_QSYM #undef MRB_PRESYM_SYM #define MRB_SYM(sym) MRB_PRESYM__##sym -#define MRB_OPSYM(sym) MRB_PRESYM_op_##sym +#define MRB_QSYM(sym) MRB_PRESYM_q_##sym #endif /* MRUBY_PRESYM_H */ diff --git a/src/kernel.c b/src/kernel.c index d2074c16b..bc42a75d7 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -766,7 +766,7 @@ mrb_obj_ceqq(mrb_state *mrb, mrb_value self) { mrb_value v = mrb_get_arg1(mrb); mrb_int i, len; - mrb_sym eqq = MRB_OPSYM(eqq); + mrb_sym eqq = MRB_QSYM(eqq); mrb_value ary; if (mrb_array_p(self)) { diff --git a/src/symbol.c b/src/symbol.c index 5f30ccb39..6a72a83c6 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -14,10 +14,10 @@ #undef MRB_PRESYM_MAX #undef MRB_PRESYM_CSYM -#undef MRB_PRESYM_OPSYM +#undef MRB_PRESYM_QSYM #undef MRB_PRESYM_SYM #define MRB_PRESYM_CSYM(sym, num) #sym, -#define MRB_PRESYM_OPSYM(op, sym, num) #op, +#define MRB_PRESYM_QSYM(sym, name, num) #sym, #define MRB_PRESYM_SYM(sym, num) #sym, static const char *presym_table[] = { -- cgit v1.2.3 From 7ab7cadbbb012d9431928d9cfae09451eab86613 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 5 Jun 2020 09:53:48 +0900 Subject: Stringify non C identifier symbols to stop macro errors by old gcc. --- Rakefile | 14 +++++++------- include/mruby/presym.h | 2 +- src/symbol.c | 4 ++-- 3 files changed, 10 insertions(+), 10 deletions(-) (limited to 'src/symbol.c') diff --git a/Rakefile b/Rakefile index 7b50eeffe..1452d7903 100644 --- a/Rakefile +++ b/Rakefile @@ -181,24 +181,24 @@ file presym_inc => presym_file do if /\A\w+\Z/ =~ sym f.print "MRB_PRESYM_CSYM(#{sym}, #{i+1})\n" elsif op_table.key?(sym) - f.print "MRB_PRESYM_QSYM(#{sym}, #{op_table[sym]}, #{i+1})\n" + f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{op_table[sym]}, #{i+1})\n" elsif /\?\Z/ =~ sym s = sym.dup; s[-1] = "_p" - f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" + f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n" elsif /\!\Z/ =~ sym s = sym.dup; s[-1] = "_b" - f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" + f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n" elsif /\=\Z/ =~ sym s = sym.dup; s[-1] = "_e" - f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" + f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n" elsif /\A@/ =~ sym s = sym.dup; s[0] = "a_" - f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" + f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n" elsif /\A$/ =~ sym s = sym.dup; s[0] = "d_" - f.print "MRB_PRESYM_QSYM(#{sym}, #{s}, #{i+1})\n" + f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n" else - f.print "MRB_PRESYM_SYM(#{sym}, #{i+1})\n" + f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n" end end f.print "#define MRB_PRESYM_MAX #{presyms.size}" diff --git a/include/mruby/presym.h b/include/mruby/presym.h index 33e51fe18..3cc12e8fb 100644 --- a/include/mruby/presym.h +++ b/include/mruby/presym.h @@ -9,7 +9,7 @@ #undef MRB_PRESYM_MAX #define MRB_PRESYM_CSYM(sym, num) MRB_PRESYM__##sym = (num<<1), -#define MRB_PRESYM_QSYM(src, sym, num) MRB_PRESYM_q_##sym = (num<<1), +#define MRB_PRESYM_QSYM(str, sym, num) MRB_PRESYM_q_##sym = (num<<1), #define MRB_PRESYM_SYM(sym, num) enum mruby_presym { diff --git a/src/symbol.c b/src/symbol.c index 6a72a83c6..9981bad7c 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -17,8 +17,8 @@ #undef MRB_PRESYM_QSYM #undef MRB_PRESYM_SYM #define MRB_PRESYM_CSYM(sym, num) #sym, -#define MRB_PRESYM_QSYM(sym, name, num) #sym, -#define MRB_PRESYM_SYM(sym, num) #sym, +#define MRB_PRESYM_QSYM(str, name, num) str, +#define MRB_PRESYM_SYM(str, num) str, static const char *presym_table[] = { #include <../build/presym.inc> -- cgit v1.2.3 From 52507b1083ba1c562ae506d63a07a51a26815c21 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 11 Jun 2020 15:37:49 +0900 Subject: Generate C struct from `irep` instead of binary dump. --- Rakefile | 58 ++++++++---- include/mruby.h | 8 +- include/mruby/compile.h | 4 +- include/mruby/error.h | 4 +- include/mruby/proc.h | 7 +- lib/mruby/build/command.rb | 2 +- lib/mruby/gem.rb | 17 ++-- mrbgems/mruby-compiler/core/codegen.c | 2 +- mrbgems/mruby-compiler/core/parse.y | 4 +- mrbgems/mruby-compiler/core/y.tab.c | 4 +- mrbgems/mruby-enumerator/mrblib/enumerator.rb | 1 + mrbgems/mruby-metaprog/src/metaprog.c | 7 +- mrbgems/mruby-socket/src/socket.c | 4 +- mrbgems/mruby-symbol-ext/test/symbol.rb | 6 +- mrbgems/mruby-test/driver.c | 4 +- mrbgems/mruby-test/mrbgem.rake | 14 +-- mrblib/init_mrblib.c | 11 --- mrblib/mrblib.rake | 17 +++- src/class.c | 3 + src/dump.c | 123 +++++++++----------------- src/gc.c | 11 ++- src/kernel.c | 4 +- src/load.c | 6 ++ src/proc.c | 4 +- src/symbol.c | 9 ++ src/variable.c | 12 +-- src/vm.c | 26 +++--- test/presym | 4 + 28 files changed, 201 insertions(+), 175 deletions(-) create mode 100644 test/presym (limited to 'src/symbol.c') diff --git a/Rakefile b/Rakefile index 75ed5c905..2198b27fd 100644 --- a/Rakefile +++ b/Rakefile @@ -106,11 +106,17 @@ end mkdir_p "#{MRUBY_ROOT}/build" cfiles = (Dir.glob("#{MRUBY_ROOT}/src/*.c")+ - Dir.glob("#{MRUBY_ROOT}/mrbgems/*/{core,src}/*.c")+ - Dir.glob("#{MRUBY_ROOT}/build/*/mrbgems/**/{src,core}/*.c")).uniq -rbfiles = (Dir.glob("#{MRUBY_ROOT}/mrblib/*.rb")+ - Dir.glob("#{MRUBY_ROOT}/mrbgems/*/mrblib/*.rb")+ - Dir.glob("#{MRUBY_ROOT}/build/*/mrbgems/**/mrblib/*.rb")).uniq + Dir.glob("#{MRUBY_ROOT}/mrbgems/**/*.c")+ + Dir.glob("#{MRUBY_ROOT}/build/*/mrbgems/**/{src,test,core}/*.c")).uniq +rbfiles = (Dir.glob("#{MRUBY_ROOT}/{mrblib,test,test/t}/*.rb")+ + Dir.glob("#{MRUBY_ROOT}/mrbgems/*/{mrblib,test}/*.rb")+ + Dir.glob("#{MRUBY_ROOT}/build/*/mrbgems/**/{mrblib,test}/*.rb")).uniq +psfiles = Dir.glob("#{MRUBY_ROOT}/{mrblib,mrbgems,test}/**/presym") +symbols = [] +psfiles.each do |file| + symbols += File.readlines(file).grep_v(/^# /) +end +symbols.each{|x| x.chomp!} presym_file="#{MRUBY_ROOT}/build/presym" op_table = { "!" => "not", @@ -145,30 +151,42 @@ op_table = { "~" => "neg", } -file presym_file => cfiles+rbfiles+[__FILE__] do +file presym_file => cfiles+rbfiles+psfiles+[__FILE__] do csymbols = cfiles.map do |f| src = File.read(f) [src.scan(/intern_lit\([^\n"]*"([^\n "]*)"/), src.scan(/mrb_define_method\([^\n"]*"([^\n"]*)"/), + src.scan(/mrb_define_class_method\([^\n"]*"([^\n"]*)"/), src.scan(/mrb_define_class\([^\n"]*"([^\n"]*)"/), src.scan(/mrb_define_module\([^\n"]*"([^\n"]*)"/), src.scan(/mrb_define_module_function\([^\n"]*"([^\n"]*)"/), + src.scan(/mrb_define_const\([^\n"]*"([^\n"]*)"/), + src.scan(/mrb_define_global_const\([^\n"]*"([^\n"]*)"/), src.scan(/MRB_SYM\((\w+)\)/), src.scan(/MRB_QSYM\((\w+)\)/).map{|x,| - x.sub!(/_p$/, "?") || x.sub!(/_b$/, "!") || x.sub!(/_e$/, "=") || x.sub!(/^a_/, "@") || x.sub!(/^d_/, "$") + x.sub!(/_p$/, "?") || x.sub!(/_b$/, "!") || x.sub!(/_e$/, "=") || x.sub!(/^0_/, "@") || x.sub!(/^00_/, "@@") }.compact] end rbsymbols = rbfiles.map do |f| src = File.read(f) + src.force_encoding(Encoding::BINARY) [src.scan(/\bclass +([A-Z]\w*)/), src.scan(/\bmodule +([A-Z]\w*)/), - src.scan(/\bdef +(\w+[!?]?)/), + src.scan(/\bdef +(\w+[!?=]?)/), src.scan(/\balias +(\w+[!?]?)/), - src.scan(/\b([A-Z]\w+) *=/), - src.scan(/(@\w+)/), - src.scan(/:(\w+)/)] + src.scan(/\b([A-Z]\w*) *=[^=]/), + src.scan(/(\$[a-zA-Z_]\w*)/), + src.scan(/(\$[$!?]\w*)/), + src.scan(/(@@?[a-zA-Z_]\w*)/), + src.scan(/[^.]\.([a-zA-Z_]\w*[!?]?)/), + src.scan(/\.([a-zA-Z_]\w* *=)/).map{|x|x.map{|s|s.gsub(' ', '')}}, + src.scan(/\b([a-zA-Z_]\w*):/), + src.scan(/:([a-zA-Z_]\w*[!?=]?)/), + src.scan(/[\(\[\{ ]:"([^"]+)"/).map{|x|x.map{|s|s.gsub('\#', '#')}}, + src.scan(/[ \(\[\{]:'([^']+)'/) + ] end - symbols = (csymbols+rbsymbols+op_table.keys).flatten.compact.uniq.sort + symbols = (symbols+csymbols+rbsymbols+op_table.keys).flatten.compact.uniq.sort.map{|x| x.gsub("\n", '\n')} presyms = File.readlines(presym_file) rescue [] presyms.each{|x| x.chomp!} if presyms != symbols @@ -182,10 +200,12 @@ file presym_inc => presym_file do presyms.each{|x| x.chomp!} File.open(presym_inc, "w") do |f| f.print "/* MRB_PRESYM_CSYM(sym, num) - symbol which is valid C id name */\n" - f.print "/* MRB_PRESYM_QSYM(sym, name, num) - symbol with alias name */\n" - f.print "/* MRB_PRESYM_SYM(sym, num) - symbol which is not valid C id */\n\n" + f.print "/* MRB_PRESYM_QSYM(name, sym, num) - symbol with alias name */\n" + f.print "/* MRB_PRESYM_SYM(name, num) - symbol which is not valid C id */\n" presyms.each.with_index do |sym,i| - if /\A\w+\Z/ =~ sym + if sym.bytes.detect{|x|x>0x80} || /\A\$/ =~ sym + f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n" + elsif /\A\w+\Z/ =~ sym f.print "MRB_PRESYM_CSYM(#{sym}, #{i+1})\n" elsif op_table.key?(sym) f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{op_table[sym]}, #{i+1})\n" @@ -198,11 +218,11 @@ file presym_inc => presym_file do elsif /\=\Z/ =~ sym s = sym.dup; s[-1] = "_e" f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n" - elsif /\A@/ =~ sym - s = sym.dup; s[0] = "a_" + elsif /\A@@/ =~ sym + s = sym.dup; s[0,2] = "00_" f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n" - elsif /\A$/ =~ sym - s = sym.dup; s[0] = "d_" + elsif /\A@/ =~ sym + s = sym.dup; s[0] = "0_" f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n" else f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n" diff --git a/include/mruby.h b/include/mruby.h index 59188e6b5..27c428e85 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -147,7 +147,7 @@ typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud); typedef struct { mrb_sym mid; - struct RProc *proc; + const struct RProc *proc; mrb_value *stackent; uint16_t ridx; uint16_t epos; @@ -1202,9 +1202,9 @@ MRB_API void mrb_close(mrb_state *mrb); MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*); MRB_API mrb_value mrb_top_self(mrb_state *mrb); -MRB_API mrb_value mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep); -MRB_API mrb_value mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep); -MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *iseq); +MRB_API mrb_value mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, unsigned int stack_keep); +MRB_API mrb_value mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, unsigned int stack_keep); +MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *iseq); /* compatibility macros */ #define mrb_toplevel_run_keep(m,p,k) mrb_top_run((m),(p),mrb_top_self(m),(k)) #define mrb_toplevel_run(m,p) mrb_toplevel_run_keep((m),(p),0) diff --git a/include/mruby/compile.h b/include/mruby/compile.h index e8ab91eb9..36adf5a32 100644 --- a/include/mruby/compile.h +++ b/include/mruby/compile.h @@ -33,7 +33,7 @@ typedef struct mrbc_context { mrb_bool no_exec:1; mrb_bool keep_lv:1; mrb_bool no_optimize:1; - struct RProc *upper; + const struct RProc *upper; size_t parser_nerr; } mrbc_context; @@ -153,7 +153,7 @@ struct mrb_parser_state { mrb_bool no_optimize:1; mrb_bool capture_errors:1; - struct RProc *upper; + const struct RProc *upper; struct mrb_parser_message error_buffer[10]; struct mrb_parser_message warn_buffer[10]; diff --git a/include/mruby/error.h b/include/mruby/error.h index d24b5b0c3..72f6c5f3d 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -35,7 +35,7 @@ MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value); #if defined(MRB_64BIT) || defined(MRB_USE_FLOAT) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING) struct RBreak { MRB_OBJECT_HEADER; - struct RProc *proc; + const struct RProc *proc; mrb_value val; }; #define mrb_break_value_get(brk) ((brk)->val) @@ -43,7 +43,7 @@ struct RBreak { #else struct RBreak { MRB_OBJECT_HEADER; - struct RProc *proc; + const struct RProc *proc; union mrb_value_union value; }; #define RBREAK_VALUE_TT_MASK ((1 << 8) - 1) diff --git a/include/mruby/proc.h b/include/mruby/proc.h index 2d06210ef..fe0cf2eb0 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -44,7 +44,7 @@ struct RProc { const mrb_irep *irep; mrb_func_t func; } body; - struct RProc *upper; + const struct RProc *upper; union { struct RClass *target_class; struct REnv *env; @@ -93,9 +93,6 @@ MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int void mrb_proc_copy(struct RProc *a, struct RProc *b); mrb_int mrb_proc_arity(const struct RProc *p); -/* implementation of #send method */ -mrb_value mrb_f_send(mrb_state *mrb, mrb_value self); - /* following functions are defined in mruby-proc-ext so please include it when using */ MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv); MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx); @@ -137,6 +134,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx); #include KHASH_DECLARE(mt, mrb_sym, mrb_method_t, TRUE) +MRB_API mrb_value mrb_load_proc(mrb_state *mrb, const struct RProc *proc); + MRB_END_DECL #endif /* MRUBY_PROC_H */ diff --git a/lib/mruby/build/command.rb b/lib/mruby/build/command.rb index 84ce78cb9..39981cc32 100644 --- a/lib/mruby/build/command.rb +++ b/lib/mruby/build/command.rb @@ -310,7 +310,7 @@ module MRuby def initialize(build) super @command = nil - @compile_options = "-B%{funcname} -o-" + @compile_options = "-S -B%{funcname} -o-" end def run(out, infiles, funcname) diff --git a/lib/mruby/gem.rb b/lib/mruby/gem.rb index 6fcaad9c1..d6b1a6851 100644 --- a/lib/mruby/gem.rb +++ b/lib/mruby/gem.rb @@ -174,7 +174,7 @@ module MRuby def generate_gem_init(fname) open(fname, 'w') do |f| print_gem_init_header f - build.mrbc.run f, rbfiles, "gem_mrblib_irep_#{funcname}" unless rbfiles.empty? + build.mrbc.run f, rbfiles, "gem_mrblib_#{funcname}_proc" unless rbfiles.empty? f.puts %Q[void mrb_#{funcname}_gem_init(mrb_state *mrb);] f.puts %Q[void mrb_#{funcname}_gem_final(mrb_state *mrb);] f.puts %Q[] @@ -183,7 +183,7 @@ module MRuby f.puts %Q[ struct REnv *e;] unless rbfiles.empty? f.puts %Q[ mrb_#{funcname}_gem_init(mrb);] if objs != [objfile("#{build_dir}/gem_init")] unless rbfiles.empty? - f.puts %Q[ mrb_load_irep(mrb, gem_mrblib_irep_#{funcname});] + f.puts %Q[ mrb_load_proc(mrb, gem_mrblib_#{funcname}_proc);] f.puts %Q[ if (mrb->exc) {] f.puts %Q[ mrb_print_error(mrb);] f.puts %Q[ mrb_close(mrb);] @@ -215,10 +215,13 @@ module MRuby def print_gem_init_header(f) print_gem_comment(f) - f.puts %Q[#include ] unless rbfiles.empty? - f.puts %Q[#include ] - f.puts %Q[#include ] unless rbfiles.empty? - f.puts %Q[#include ] unless rbfiles.empty? + unless rbfiles.empty? + f.puts %Q[#include ] + f.puts %Q[#include ] + f.puts %Q[#include ] + else + f.puts %Q[#include ] + end end def print_gem_test_header(f) @@ -226,7 +229,7 @@ module MRuby f.puts %Q[#include ] f.puts %Q[#include ] f.puts %Q[#include ] - f.puts %Q[#include ] + f.puts %Q[#include ] f.puts %Q[#include ] f.puts %Q[#include ] unless test_args.empty? end diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 0000e6dbe..5d29dcb2d 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -706,7 +706,7 @@ lv_idx(codegen_scope *s, mrb_sym id) static int search_upvar(codegen_scope *s, mrb_sym id, int *idx) { - struct RProc *u; + const struct RProc *u; int lv = 0; codegen_scope *up = s->prev; diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index cb4126713..c7c3d2a2f 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -265,7 +265,7 @@ local_unnest(parser_state *p) static mrb_bool local_var_p(parser_state *p, mrb_sym sym) { - struct RProc *u; + const struct RProc *u; node *l = p->locals; while (l) { @@ -282,7 +282,7 @@ local_var_p(parser_state *p, mrb_sym sym) const struct mrb_irep *ir = u->body.irep; uint_fast16_t n = ir->nlocals; const struct mrb_lvinfo *v = ir->lv; - for (; n > 1; n --, v ++) { + for (; v && n > 1; n--, v++) { if (v->name == sym) return TRUE; } if (MRB_PROC_SCOPE_P(u)) break; diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 504ec6d04..dbcc6a5bd 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -328,7 +328,7 @@ local_unnest(parser_state *p) static mrb_bool local_var_p(parser_state *p, mrb_sym sym) { - struct RProc *u; + const struct RProc *u; node *l = p->locals; while (l) { @@ -345,7 +345,7 @@ local_var_p(parser_state *p, mrb_sym sym) const struct mrb_irep *ir = u->body.irep; uint_fast16_t n = ir->nlocals; const struct mrb_lvinfo *v = ir->lv; - for (; n > 1; n --, v ++) { + for (; v && n > 1; n--, v++) { if (v->name == sym) return TRUE; } if (MRB_PROC_SCOPE_P(u)) break; diff --git a/mrbgems/mruby-enumerator/mrblib/enumerator.rb b/mrbgems/mruby-enumerator/mrblib/enumerator.rb index 5a98dc964..f007b8553 100644 --- a/mrbgems/mruby-enumerator/mrblib/enumerator.rb +++ b/mrbgems/mruby-enumerator/mrblib/enumerator.rb @@ -130,6 +130,7 @@ class Enumerator @feedvalue = nil @stop_exc = false end + attr_accessor :obj, :meth, :args attr_reader :fib diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c index 8a4a6dc69..7a7639410 100644 --- a/mrbgems/mruby-metaprog/src/metaprog.c +++ b/mrbgems/mruby-metaprog/src/metaprog.c @@ -132,7 +132,7 @@ mrb_obj_ivar_set(mrb_state *mrb, mrb_value self) static mrb_value mrb_local_variables(mrb_state *mrb, mrb_value self) { - struct RProc *proc; + const struct RProc *proc; const mrb_irep *irep; mrb_value vars; size_t i; @@ -664,7 +664,7 @@ mrb_mod_s_constants(mrb_state *mrb, mrb_value mod) static mrb_value mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod) { - struct RProc *proc; + const struct RProc *proc; mrb_value ary; struct RClass *c = NULL; @@ -684,6 +684,9 @@ mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod) return ary; } +/* implementation of #send method */ +mrb_value mrb_f_send(mrb_state *mrb, mrb_value self); + void mrb_mruby_metaprog_gem_init(mrb_state* mrb) { diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index f158959a7..001021b81 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -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_QSYM(a_sockaddr)); + sastr = mrb_iv_get(mrb, self, MRB_QSYM(0_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_QSYM(a_sockaddr)); + sastr = mrb_iv_get(mrb, self, MRB_QSYM(0_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) { diff --git a/mrbgems/mruby-symbol-ext/test/symbol.rb b/mrbgems/mruby-symbol-ext/test/symbol.rb index db686e5f4..34c3c6ba5 100644 --- a/mrbgems/mruby-symbol-ext/test/symbol.rb +++ b/mrbgems/mruby-symbol-ext/test/symbol.rb @@ -13,13 +13,13 @@ end %w[size length].each do |n| assert("Symbol##{n}") do assert_equal 5, :hello.__send__(n) - assert_equal 4, :"aA\0b".__send__(n) + assert_equal 4, :"aA b".__send__(n) if __ENCODING__ == "UTF-8" assert_equal 8, :"こんにちは世界!".__send__(n) - assert_equal 4, :"aあ\0b".__send__(n) + assert_equal 4, :"aあ b".__send__(n) else assert_equal 22, :"こんにちは世界!".__send__(n) - assert_equal 6, :"aあ\0b".__send__(n) + assert_equal 6, :"aあ b".__send__(n) end end end diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index a5f723927..fe1a475d5 100644 --- a/mrbgems/mruby-test/driver.c +++ b/mrbgems/mruby-test/driver.c @@ -18,7 +18,7 @@ #include #include -extern const uint8_t mrbtest_assert_irep[]; +extern const struct RProc mrbtest_assert_proc[]; void mrbgemtest_init(mrb_state* mrb); void mrb_init_test_vformat(mrb_state* mrb); @@ -300,7 +300,7 @@ main(int argc, char **argv) } mrb_init_test_driver(mrb, verbose); - mrb_load_irep(mrb, mrbtest_assert_irep); + mrb_load_proc(mrb, mrbtest_assert_proc); mrbgemtest_init(mrb); ret = eval_test(mrb); mrb_close(mrb); diff --git a/mrbgems/mruby-test/mrbgem.rake b/mrbgems/mruby-test/mrbgem.rake index ced252ae6..9e8e4041f 100644 --- a/mrbgems/mruby-test/mrbgem.rake +++ b/mrbgems/mruby-test/mrbgem.rake @@ -28,7 +28,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec| file assert_c => [assert_rb, build.mrbcfile] do |t| mkdir_p File.dirname(t.name) open(t.name, 'w') do |f| - mrbc.run f, assert_rb, 'mrbtest_assert_irep' + mrbc.run f, assert_rb, 'mrbtest_assert_proc' end end @@ -56,12 +56,12 @@ MRuby::Gem::Specification.new('mruby-test') do |spec| f.puts %Q[ * All manual changes will get lost.] f.puts %Q[ */] if test_preload.nil? - f.puts %Q[extern const uint8_t mrbtest_assert_irep[];] + f.puts %Q[extern const struct RProc mrbtest_assert_proc[];] else - g.build.mrbc.run f, test_preload, "gem_test_irep_#{g.funcname}_preload" + g.build.mrbc.run f, test_preload, "gem_test_#{g.funcname}_preload" end g.test_rbfiles.flatten.each_with_index do |rbfile, i| - g.build.mrbc.run f, rbfile, "gem_test_irep_#{g.funcname}_#{i}" + g.build.mrbc.run f, rbfile, "gem_test_#{g.funcname}_#{i}_proc" end f.puts %Q[void mrb_#{g.funcname}_gem_test(mrb_state *mrb);] unless g.test_objs.empty? dep_list.each do |d| @@ -90,9 +90,9 @@ MRuby::Gem::Specification.new('mruby-test') do |spec| end f.puts %Q[ mrb_init_test_driver(mrb2, mrb_test(mrb_gv_get(mrb, mrb_intern_lit(mrb, "$mrbtest_verbose"))));] if test_preload.nil? - f.puts %Q[ mrb_load_irep(mrb2, mrbtest_assert_irep);] + f.puts %Q[ mrb_load_proc(mrb2, mrbtest_assert_proc);] else - f.puts %Q[ mrb_load_irep(mrb2, gem_test_irep_#{g.funcname}_preload);] + f.puts %Q[ mrb_load_proc(mrb2, gem_test_#{g.funcname}_preload);] end f.puts %Q[ if (mrb2->exc) {] f.puts %Q[ mrb_print_error(mrb2);] @@ -113,7 +113,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec| f.puts %Q[ mrb_#{g.funcname}_gem_test(mrb2);] if g.custom_test_init? - f.puts %Q[ mrb_load_irep(mrb2, gem_test_irep_#{g.funcname}_#{i});] + f.puts %Q[ mrb_load_proc(mrb2, gem_test_#{g.funcname}_#{i}_proc);] f.puts %Q[ ] f.puts %Q[ mrb_t_pass_result(mrb, mrb2);] diff --git a/mrblib/init_mrblib.c b/mrblib/init_mrblib.c index 4d4bcd25a..e69de29bb 100644 --- a/mrblib/init_mrblib.c +++ b/mrblib/init_mrblib.c @@ -1,11 +0,0 @@ -#include -#include - -extern const uint8_t mrblib_irep[]; - -void -mrb_init_mrblib(mrb_state *mrb) -{ - mrb_load_irep(mrb, mrblib_irep); -} - diff --git a/mrblib/mrblib.rake b/mrblib/mrblib.rake index 6fba0adc1..724d328fa 100644 --- a/mrblib/mrblib.rake +++ b/mrblib/mrblib.rake @@ -11,8 +11,21 @@ MRuby.each_target do mkdir_p File.dirname(t.name) open(t.name, 'w') do |f| _pp "GEN", "*.rb", "#{t.name.relative_path}" - f.puts File.read("#{current_dir}/init_mrblib.c") - mrbc.run f, rbfiles, 'mrblib_irep' + f.puts %Q[/*] + f.puts %Q[ * This file is loading the mrblib] + f.puts %Q[ *] + f.puts %Q[ * IMPORTANT:] + f.puts %Q[ * This file was generated!] + f.puts %Q[ * All manual changes will get lost.] + f.puts %Q[ */] + mrbc.run f, rbfiles, 'mrblib_proc' + f.puts <u.i64); break; case IREP_TT_FLOAT: - fprintf(fp, "{IREP_TT_FLOAT, {.f="MRB_FLOAT_FMT"}},\n", p->u.f); + if (p->u.f == 0) { + fprintf(fp, "{IREP_TT_FLOAT, {.f=%#.1f}},\n", p->u.f); + } + else { + fprintf(fp, "{IREP_TT_FLOAT, {.f="MRB_FLOAT_FMT"}},\n", p->u.f); + } break; } } @@ -951,83 +956,28 @@ dump_pool(mrb_state *mrb, const mrb_pool_value *p, FILE *fp) const char *s = p->u.str; fprintf(fp, "{IREP_TT_STR|(%d<<2), {.str=\"", len); for (i=0; i", "cmp"}, - {"==", "eq"}, - {"===", "eqq"}, - {"=~", "match"}, - {">", "gt"}, - {">=", "ge"}, - {">>", "rshift"}, - {"[]", "aref"}, - {"[]=", "aset"}, - {"^", "xor"}, - {"`", "tick"}, - {"|", "or"}, - {"||", "oror"}, - {"~", "neg"}, - {0}, -}; - +mrb_bool mrb_sym_static_p(mrb_state *mrb, mrb_sym sym); + static int dump_sym(mrb_state *mrb, mrb_sym sym, FILE *fp) { - mrb_int len; - const char *name = mrb_sym_name_len(mrb, sym, &len); - int i; - - if (len == 0 || len != strlen(name)) - return MRB_DUMP_INVALID_ARGUMENT; - for (i=0; op_table[i].op; i++) { - if (strcmp(name, op_table[i].op) == 0) { - fprintf(fp, "MRB_QSYM(%s),", op_table[i].name); - return MRB_DUMP_OK; - } - } - if (name[0] == '@') { - fprintf(fp, "MRB_QSYM(a_%s),", name+1); - } - else if (name[0] == '$') { - fprintf(fp, "MRB_QSYM(d_%s),", name+1); - } - else if (name[len-1] == '!') { - fprintf(fp, "MRB_QSYM(%.*s_b),", (int)len-1, name); - } - else if (name[len-1] == '?') { - fprintf(fp, "MRB_QSYM(%.*s_p),", (int)len-1, name); - } - else if (name[len-1] == '=') { - fprintf(fp, "MRB_QSYM(%.*s_e),", (int)len-1, name); + const char *name; + if (sym == 0) return MRB_DUMP_INVALID_ARGUMENT; + name = mrb_sym_name(mrb, sym); + if (!name) { + fprintf(stderr, "undefined symbol (%d) - define presym\n", sym); } - else { - fprintf(fp, "MRB_SYM(%s),", name); + if (!mrb_sym_static_p(mrb, sym)) { + fprintf(stderr, "no static symbol (%s) - define presym\n", name); } + fprintf(fp, "%d /* %s */,", sym, name); return MRB_DUMP_OK; } @@ -1065,8 +1015,7 @@ dump_irep_struct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, len=irep->slen; fprintf(fp, "static const mrb_sym %s_syms_%d[%d] = {", name, n, len); for (i=0; isyms[i], fp) != MRB_DUMP_OK) - return MRB_DUMP_INVALID_ARGUMENT; + dump_sym(mrb, irep->syms[i], fp); } fputs("};\n", fp); } @@ -1078,13 +1027,17 @@ dump_irep_struct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, fprintf(fp, "0x%02x,", irep->iseq[i]); } fputs("};\n", fp); - /* dump irep */ - if (n == 0) { /* topleve irep */ - fprintf(fp, "static const mrb_irep %s = {\n", name); - } - else { - fprintf(fp, "static const mrb_irep %s_irep_%d = {\n", name, n); + /* dump lv */ + if (irep->lv) { + len=irep->nlocals; + fprintf(fp, "static const struct mrb_lvinfo %s_lv_%d[%d] = {", name, n, len); + for (i=0; i+1lv[i].name, irep->lv[i].r); + } + fputs("};\n", fp); } + /* dump irep */ + fprintf(fp, "static const mrb_irep %s_irep_%d = {\n", name, n); fprintf(fp, " %d,%d,\n", irep->nlocals, irep->nregs); fprintf(fp, " MRB_IREP_STATIC,%s_iseq_%d,\n", name, n); if (irep->pool) { @@ -1105,9 +1058,14 @@ dump_irep_struct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, else { fputs( "NULL,\n", fp); } - fputs( " NULL,\t\t\t\t\t/* lv */\n", fp); + if (irep->lv) { + fprintf(fp, "%s_lv_%d,\n", name, n); + } + else { + fputs( " NULL,\t\t\t\t\t/* lv */\n", fp); + } fputs( " NULL,\t\t\t\t\t/* debug_info */\n", fp); - fprintf(fp, " %d,%d,%d,%d,0\n};", irep->ilen, irep->plen, irep->slen, irep->rlen); + fprintf(fp, " %d,%d,%d,%d,0\n};\n", irep->ilen, irep->plen, irep->slen, irep->rlen); return MRB_DUMP_OK; } @@ -1116,13 +1074,20 @@ int mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname) { int max = 1; + int n; + if (fp == NULL || initname == NULL || initname[0] == '\0') { return MRB_DUMP_INVALID_ARGUMENT; } - if (fprintf(fp, "#include \n" "#include \n\n") < 0) { + if (fprintf(fp, "#include \n" "#include \n\n") < 0) { return MRB_DUMP_WRITE_FAULT; } - return dump_irep_struct(mrb, irep, flags, fp, initname, 0, &max); + n = dump_irep_struct(mrb, irep, flags, fp, initname, 0, &max); + if (n != MRB_DUMP_OK) return n; + fprintf(fp, "#ifdef __cplusplus\nextern struct RProc %s[];\n#endif\n", initname); + fprintf(fp, "struct RProc %s[] = {{\n", initname); + fprintf(fp, "NULL,NULL,MRB_TT_PROC,7,0,{&%s_irep_0},NULL,{NULL},\n}};\n", initname); + return MRB_DUMP_OK; } #endif /* MRB_DISABLE_STDIO */ diff --git a/src/gc.c b/src/gc.c index 897fa256f..4bee82364 100644 --- a/src/gc.c +++ b/src/gc.c @@ -35,6 +35,11 @@ * Gray - Marked, But the child objects are unmarked. * Black - Marked, the child objects are also marked. + Extra color + + * Red - Static (ROM object) no need to be collected. + - All child objects should be Red as well. + == Two White Types There're two white color types in a flip-flop fashion: White-A and White-B, @@ -185,6 +190,7 @@ gettimeofday_time(void) #define GC_WHITE_A 1 #define GC_WHITE_B (1 << 1) #define GC_BLACK (1 << 2) +#define GC_RED 7 #define GC_WHITES (GC_WHITE_A | GC_WHITE_B) #define GC_COLOR_MASK 7 @@ -194,7 +200,8 @@ gettimeofday_time(void) #define paint_partial_white(s, o) ((o)->color = (s)->current_white_part) #define is_gray(o) ((o)->color == GC_GRAY) #define is_white(o) ((o)->color & GC_WHITES) -#define is_black(o) ((o)->color & GC_BLACK) +#define is_black(o) ((o)->color == GC_BLACK) +#define is_red(o) ((o)->color == GC_RED) #define flip_white_part(s) ((s)->current_white_part = other_white_part(s)) #define other_white_part(s) ((s)->current_white_part ^ GC_WHITES) #define is_dead(s, o) (((o)->color & other_white_part(s) & GC_WHITES) || (o)->tt == MRB_TT_FREE) @@ -584,7 +591,7 @@ add_gray_list(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) static int ci_nregs(mrb_callinfo *ci) { - struct RProc *p = ci->proc; + const struct RProc *p = ci->proc; int n = 0; if (!p) { diff --git a/src/kernel.c b/src/kernel.c index 519052f4b..e4948143d 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -19,7 +19,7 @@ mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func) { struct RClass *c = mrb_class(mrb, obj); mrb_method_t m = mrb_method_search_vm(mrb, &c, mid); - struct RProc *p; + const struct RProc *p; if (MRB_METHOD_UNDEF_P(m)) return FALSE; if (MRB_METHOD_FUNC_P(m)) @@ -143,7 +143,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self) mrb_value *bp; int bidx; struct REnv *e = NULL; - struct RProc *p; + const struct RProc *p; if (ci <= cibase) { /* toplevel does not have block */ diff --git a/src/load.c b/src/load.c index 39644c34b..31059e833 100644 --- a/src/load.c +++ b/src/load.c @@ -676,6 +676,12 @@ mrb_load_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize) return mrb_load_irep_buf_cxt(mrb, buf, bufsize, NULL); } +MRB_API mrb_value +mrb_load_proc(mrb_state *mrb, const struct RProc *proc) +{ + return mrb_vm_run(mrb, proc, mrb_top_self(mrb), 0); +} + #ifndef MRB_DISABLE_STDIO mrb_irep* diff --git a/src/proc.c b/src/proc.c index 2da2ec77e..14ba407d8 100644 --- a/src/proc.c +++ b/src/proc.c @@ -80,7 +80,7 @@ static void closure_setup(mrb_state *mrb, struct RProc *p) { mrb_callinfo *ci = mrb->c->ci; - struct RProc *up = p->upper; + const struct RProc *up = p->upper; struct REnv *e = NULL; if (ci && ci->env) { @@ -170,7 +170,7 @@ mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals) MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx) { - struct RProc *p = mrb->c->ci->proc; + const struct RProc *p = mrb->c->ci->proc; struct REnv *e; if (!p || !MRB_PROC_CFUNC_P(p)) { diff --git a/src/symbol.c b/src/symbol.c index 9981bad7c..3723335cd 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -330,6 +330,15 @@ mrb_sym_name_len(mrb_state *mrb, mrb_sym sym, mrb_int *lenp) return sym2name_len(mrb, sym, mrb->symbuf, lenp); } +mrb_bool +mrb_sym_static_p(mrb_state *mrb, mrb_sym sym) +{ + if (SYMBOL_INLINE_P(sym)) return TRUE; + sym >>= SYMBOL_NORMAL_SHIFT; + if (sym > MRB_PRESYM_MAX) return FALSE; + return TRUE; +} + void mrb_free_symtbl(mrb_state *mrb) { diff --git a/src/variable.c b/src/variable.c index 8fcbd6427..526d88c80 100644 --- a/src/variable.c +++ b/src/variable.c @@ -741,11 +741,11 @@ mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym) { struct RClass *c; - struct RProc *p = mrb->c->ci->proc; + const struct RProc *p = mrb->c->ci->proc; for (;;) { c = MRB_PROC_TARGET_CLASS(p); - if (c->tt != MRB_TT_SCLASS) break; + if (c && c->tt != MRB_TT_SCLASS) break; p = p->upper; } return mrb_mod_cv_get(mrb, c, sym); @@ -755,11 +755,11 @@ void mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v) { struct RClass *c; - struct RProc *p = mrb->c->ci->proc; + const struct RProc *p = mrb->c->ci->proc; for (;;) { c = MRB_PROC_TARGET_CLASS(p); - if (c->tt != MRB_TT_SCLASS) break; + if (c && c->tt != MRB_TT_SCLASS) break; p = p->upper; } mrb_mod_cv_set(mrb, c, sym, v); @@ -817,9 +817,10 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) struct RClass *c; struct RClass *c2; mrb_value v; - struct RProc *proc; + const struct RProc *proc; c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); + if (!c) c = mrb->object_class; if (iv_get(mrb, c->iv, sym, &v)) { return v; } @@ -862,6 +863,7 @@ mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v) struct RClass *c; c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); + if (!c) c = mrb->object_class; mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v); } diff --git a/src/vm.c b/src/vm.c index c3fa12d3d..62805b7ed 100644 --- a/src/vm.c +++ b/src/vm.c @@ -224,7 +224,7 @@ mrb_stack_extend(mrb_state *mrb, mrb_int room) static inline struct REnv* uvenv(mrb_state *mrb, int up) { - struct RProc *proc = mrb->c->ci->proc; + const struct RProc *proc = mrb->c->ci->proc; struct REnv *e; while (up--) { @@ -247,8 +247,8 @@ uvenv(mrb_state *mrb, int up) return NULL; } -static inline struct RProc* -top_proc(mrb_state *mrb, struct RProc *proc) +static inline const struct RProc* +top_proc(mrb_state *mrb, const struct RProc *proc) { while (proc->upper) { if (MRB_PROC_SCOPE_P(proc) || MRB_PROC_STRICT_P(proc)) @@ -327,7 +327,7 @@ cipop(mrb_state *mrb) } void mrb_exc_set(mrb_state *mrb, mrb_value exc); -static mrb_value mrb_run(mrb_state *mrb, struct RProc* proc, mrb_value self); +static mrb_value mrb_run(mrb_state *mrb, const struct RProc* proc, mrb_value self); static void ecall(mrb_state *mrb) @@ -423,7 +423,7 @@ mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, ...) static int ci_nregs(mrb_callinfo *ci) { - struct RProc *p; + const struct RProc *p; int n = 0; if (!ci) return 3; @@ -821,7 +821,7 @@ mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const } static struct RBreak* -break_new(mrb_state *mrb, struct RProc *p, mrb_value val) +break_new(mrb_state *mrb, const struct RProc *p, mrb_value val) { struct RBreak *brk; @@ -918,7 +918,7 @@ argnum_error(mrb_state *mrb, mrb_int num) #endif MRB_API mrb_value -mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep) +mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, unsigned int stack_keep) { const mrb_irep *irep = proc->body.irep; mrb_value result; @@ -961,7 +961,7 @@ check_target_class(mrb_state *mrb) void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self); MRB_API mrb_value -mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *pc) +mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *pc) { /* mrb_assert(MRB_PROC_CFUNC_P(proc)) */ const mrb_code *pc0 = pc; @@ -1534,7 +1534,7 @@ RETRY_TRY_BLOCK: struct RClass *cls; mrb_callinfo *ci = mrb->c->ci; mrb_value recv, blk; - struct RProc *p = ci->proc; + const struct RProc *p = ci->proc; mrb_sym mid = ci->mid; struct RClass* target_class = MRB_PROC_TARGET_CLASS(p); @@ -1975,7 +1975,7 @@ RETRY_TRY_BLOCK: else { int acc; mrb_value v; - struct RProc *dst; + const struct RProc *dst; ci = mrb->c->ci; v = regs[a]; @@ -2612,6 +2612,7 @@ RETRY_TRY_BLOCK: super = regs[a+1]; if (mrb_nil_p(base)) { baseclass = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); + if (!baseclass) baseclass = mrb->object_class; base = mrb_obj_value(baseclass); } c = mrb_vm_define_class(mrb, base, super, id); @@ -2628,6 +2629,7 @@ RETRY_TRY_BLOCK: base = regs[a]; if (mrb_nil_p(base)) { baseclass = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); + if (!baseclass) baseclass = mrb->object_class; base = mrb_obj_value(baseclass); } cls = mrb_vm_define_module(mrb, base, id); @@ -2782,7 +2784,7 @@ RETRY_TRY_BLOCK: } static mrb_value -mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) +mrb_run(mrb_state *mrb, const struct RProc *proc, mrb_value self) { if (mrb->c->ci->argc < 0) { return mrb_vm_run(mrb, proc, self, 3); /* receiver, args and block) */ @@ -2793,7 +2795,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) } MRB_API mrb_value -mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep) +mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, unsigned int stack_keep) { mrb_value v; diff --git a/test/presym b/test/presym new file mode 100644 index 000000000..1e551143b --- /dev/null +++ b/test/presym @@ -0,0 +1,4 @@ +# List of symbols that cannot be detected by Rakefile +# Those symbols are not defined (to cause exceptions) +doesNotExistAsAMethodNameForVerySure +UnknownConstant -- cgit v1.2.3 From b7031e8bc8fdc250d82480c0cb9fdb6341fa4cae Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 12 Jun 2020 11:23:39 +0900 Subject: Enable NUL (`\0`) again. --- mrbgems/mruby-symbol-ext/test/symbol.rb | 6 +++--- src/symbol.c | 37 ++++++++++++++++++++------------- 2 files changed, 26 insertions(+), 17 deletions(-) (limited to 'src/symbol.c') diff --git a/mrbgems/mruby-symbol-ext/test/symbol.rb b/mrbgems/mruby-symbol-ext/test/symbol.rb index 34c3c6ba5..db686e5f4 100644 --- a/mrbgems/mruby-symbol-ext/test/symbol.rb +++ b/mrbgems/mruby-symbol-ext/test/symbol.rb @@ -13,13 +13,13 @@ end %w[size length].each do |n| assert("Symbol##{n}") do assert_equal 5, :hello.__send__(n) - assert_equal 4, :"aA b".__send__(n) + assert_equal 4, :"aA\0b".__send__(n) if __ENCODING__ == "UTF-8" assert_equal 8, :"こんにちは世界!".__send__(n) - assert_equal 4, :"aあ b".__send__(n) + assert_equal 4, :"aあ\0b".__send__(n) else assert_equal 22, :"こんにちは世界!".__send__(n) - assert_equal 6, :"aあ b".__send__(n) + assert_equal 6, :"aあ\0b".__send__(n) end end end diff --git a/src/symbol.c b/src/symbol.c index 3723335cd..ed2fe7cee 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -16,13 +16,16 @@ #undef MRB_PRESYM_CSYM #undef MRB_PRESYM_QSYM #undef MRB_PRESYM_SYM -#define MRB_PRESYM_CSYM(sym, num) #sym, -#define MRB_PRESYM_QSYM(str, name, num) str, -#define MRB_PRESYM_SYM(str, num) str, +#define MRB_PRESYM_CSYM(sym, num) {#sym,sizeof(#sym)-1}, +#define MRB_PRESYM_QSYM(str, name, num) {str,sizeof(str)-1}, +#define MRB_PRESYM_SYM(str, num) {str,sizeof(str)-1}, -static const char *presym_table[] = { +static const struct { + const char *name; + uint16_t len; +} presym_table[] = { #include <../build/presym.inc> - NULL + {0,0} }; static mrb_sym @@ -33,9 +36,17 @@ presym_find(const char *name, size_t len) while (start<=end) { int mid = (start+end)/2; - int cmp = strncmp(name, presym_table[mid], len); + size_t plen = presym_table[mid].len; + size_t tlen = (plen > len) ? len : plen; + int cmp; + + cmp = memcmp(name, presym_table[mid].name, tlen); + if (cmp == 0) { + if (len > plen) cmp = 1; + else if (len < plen) cmp = -1; + } - if (cmp == 0 && presym_table[mid][len] == '\0') { + if (cmp == 0) { return mid+1; } else if (cmp > 0) { start = mid+1; @@ -47,10 +58,11 @@ presym_find(const char *name, size_t len) } static const char* -presym_sym2name(mrb_sym sym) +presym_sym2name(mrb_sym sym, mrb_int *lenp) { if (sym > MRB_PRESYM_MAX) return NULL; - return presym_table[sym-1]; + if (lenp) *lenp = presym_table[sym-1].len; + return presym_table[sym-1].name; } /* ------------------------------------------------------ */ @@ -307,11 +319,8 @@ sym2name_len(mrb_state *mrb, mrb_sym sym, char *buf, mrb_int *lenp) sym >>= SYMBOL_NORMAL_SHIFT; { - const char *name = presym_sym2name(sym); - if (name) { - if (lenp) *lenp = strlen(name); - return name; - } + const char *name = presym_sym2name(sym, lenp); + if (name) return name; } sym -= MRB_PRESYM_MAX; -- cgit v1.2.3 From caee1f68a200d9df1831c4cf0e1954482c317474 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 19 Aug 2020 10:38:30 +0900 Subject: Change the return type of `mrb_check_intern()` and friends. They used to return `mrb_value` but now return `mrb_sym` for consistency with other `intern` functions. If symbols are not defined, `check` functions return `0`, instead of `nil` in the past. It causes API incompatibility but I believe few people use those functions out of the core, and those changes are very easy to handle, hopefully. --- include/mruby.h | 7 ++++--- mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c | 2 +- src/class.c | 16 ++++++---------- src/symbol.c | 10 +++++----- 4 files changed, 16 insertions(+), 19 deletions(-) (limited to 'src/symbol.c') diff --git a/include/mruby.h b/include/mruby.h index 959d1ac6d..4ac26bfe9 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1097,9 +1097,10 @@ MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t); MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t); #define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit)) MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value); -MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*); -MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t); -MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value); +/* mrb_check_intern series functions returns 0 if the symbol is not defined */ +MRB_API mrb_sym mrb_check_intern_cstr(mrb_state*,const char*); +MRB_API mrb_sym mrb_check_intern(mrb_state*,const char*,size_t); +MRB_API mrb_sym mrb_check_intern_str(mrb_state*,mrb_value); MRB_API const char *mrb_sym_name(mrb_state*,mrb_sym); MRB_API const char *mrb_sym_name_len(mrb_state*,mrb_sym,mrb_int*); MRB_API const char *mrb_sym_dump(mrb_state*,mrb_sym); diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c index ceeb27393..859f42bbd 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c @@ -151,7 +151,7 @@ compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *cl } sc = mrb_class_get(mrb, method_p->class_name); - ssym = mrb_symbol(mrb_check_intern_cstr(mrb, method_p->method_name)); + ssym = mrb_check_intern_cstr(mrb, method_p->method_name); m = mrb_method_search_vm(mrb, &sc, ssym); if (MRB_METHOD_UNDEF_P(m)) { return MRB_DEBUG_OK; diff --git a/src/class.c b/src/class.c index dd713ed7e..500e7f953 100644 --- a/src/class.c +++ b/src/class.c @@ -356,11 +356,9 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name) { - mrb_value sym = mrb_check_intern_cstr(mrb, name); - if (mrb_nil_p(sym)) { - return FALSE; - } - return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_symbol(sym)); + mrb_sym sym = mrb_check_intern_cstr(mrb, name); + if (!sym) return FALSE; + return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), sym); } MRB_API mrb_bool @@ -372,11 +370,9 @@ mrb_class_defined_id(mrb_state *mrb, mrb_sym name) MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name) { - mrb_value sym = mrb_check_intern_cstr(mrb, name); - if (mrb_nil_p(sym)) { - return FALSE; - } - return mrb_const_defined_at(mrb, mrb_obj_value(outer), mrb_symbol(sym)); + mrb_sym sym = mrb_check_intern_cstr(mrb, name); + if (!sym) return FALSE; + return mrb_const_defined_at(mrb, mrb_obj_value(outer), sym); } MRB_API mrb_bool diff --git a/src/symbol.c b/src/symbol.c index ed2fe7cee..704e1d9e0 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -289,24 +289,24 @@ mrb_intern_str(mrb_state *mrb, mrb_value str) return mrb_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str)); } -MRB_API mrb_value +MRB_API mrb_sym mrb_check_intern(mrb_state *mrb, const char *name, size_t len) { mrb_sym sym; sym_validate_len(mrb, len); sym = find_symbol(mrb, name, len, NULL); - if (sym > 0) return mrb_symbol_value(sym); - return mrb_nil_value(); + if (sym > 0) return sym; + return 0; } -MRB_API mrb_value +MRB_API mrb_sym mrb_check_intern_cstr(mrb_state *mrb, const char *name) { return mrb_check_intern(mrb, name, strlen(name)); } -MRB_API mrb_value +MRB_API mrb_sym mrb_check_intern_str(mrb_state *mrb, mrb_value str) { return mrb_check_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str)); -- cgit v1.2.3 From 260db0f5fbf5b3708684e156bc0a1e77e7e1c9d6 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 31 Aug 2020 23:21:45 +0900 Subject: Abandon packing all lower case symbols with 6 characters. To make packed inline symbols within 31 bits, because the new method hash tables allows only 31 bits of symbols. They use top 1 bit to maek unused slots. --- src/symbol.c | 52 +++++++++++++++------------------------------------- 1 file changed, 15 insertions(+), 37 deletions(-) (limited to 'src/symbol.c') diff --git a/src/symbol.c b/src/symbol.c index 704e1d9e0..9683d2f72 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -73,20 +73,15 @@ typedef struct symbol_name { const char *name; } symbol_name; -#define SYMBOL_INLINE_BIT_POS 1 -#define SYMBOL_INLINE_LOWER_BIT_POS 2 -#define SYMBOL_INLINE (1 << (SYMBOL_INLINE_BIT_POS - 1)) -#define SYMBOL_INLINE_LOWER (1 << (SYMBOL_INLINE_LOWER_BIT_POS - 1)) -#define SYMBOL_NORMAL_SHIFT SYMBOL_INLINE_BIT_POS -#define SYMBOL_INLINE_SHIFT SYMBOL_INLINE_LOWER_BIT_POS #ifdef MRB_ENABLE_ALL_SYMBOLS +#define SYMBOL_SHIFT 0 # define SYMBOL_INLINE_P(sym) FALSE -# define SYMBOL_INLINE_LOWER_P(sym) FALSE # define sym_inline_pack(name, len) 0 # define sym_inline_unpack(sym, buf, lenp) NULL #else +#define SYMBOL_INLINE 1 +#define SYMBOL_SHIFT 1 # define SYMBOL_INLINE_P(sym) ((sym) & SYMBOL_INLINE) -# define SYMBOL_INLINE_LOWER_P(sym) ((sym) & SYMBOL_INLINE_LOWER) #endif static void @@ -103,16 +98,14 @@ static const char pack_table[] = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRS static mrb_sym sym_inline_pack(const char *name, size_t len) { - const size_t lower_length_max = (MRB_SYMBOL_BIT - 2) / 5; - const size_t mix_length_max = (MRB_SYMBOL_BIT - 2) / 6; + const size_t pack_length_max = (MRB_SYMBOL_BIT - 2) / 6; char c; const char *p; size_t i; mrb_sym sym = 0; - mrb_bool lower = TRUE; - if (len > lower_length_max) return 0; /* too long */ + if (len > pack_length_max) return 0; /* too long */ for (i=0; i 27) lower = FALSE; - if (i >= mix_length_max) break; - sym |= bits<<(i*6+SYMBOL_INLINE_SHIFT); + if (i >= pack_length_max) break; + sym |= bits<<(i*6+SYMBOL_SHIFT); } - if (lower) { - sym = 0; - for (i=0; i mix_length_max) return 0; return sym | SYMBOL_INLINE; } static const char* sym_inline_unpack(mrb_sym sym, char *buf, mrb_int *lenp) { - int bit_per_char = SYMBOL_INLINE_LOWER_P(sym) ? 5 : 6; int i; mrb_assert(SYMBOL_INLINE_P(sym)); - for (i=0; i<30/bit_per_char; i++) { - uint32_t bits = sym>>(i*bit_per_char+SYMBOL_INLINE_SHIFT) & ((1<>(i*6+SYMBOL_SHIFT) & ((1<<6)-1); if (bits == 0) break; buf[i] = pack_table[bits-1];; } @@ -185,7 +163,7 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp) /* presym */ i = presym_find(name, len); - if (i > 0) return i< 0) return i<symtbl[i]; if (sname->len == len && memcmp(sname->name, name, len) == 0) { - return (i+MRB_PRESYM_MAX)<prev == 0xff) { i -= 0xff; sname = &mrb->symtbl[i]; while (mrb->symtbl < sname) { if (sname->len == len && memcmp(sname->name, name, len) == 0) { - return (mrb_sym)(sname - mrb->symtbl)<symtbl)<symhash[hash] = mrb->symidx = sym; - return (sym+MRB_PRESYM_MAX)<>= SYMBOL_NORMAL_SHIFT; + sym >>= SYMBOL_SHIFT; { const char *name = presym_sym2name(sym, lenp); if (name) return name; @@ -343,7 +321,7 @@ mrb_bool mrb_sym_static_p(mrb_state *mrb, mrb_sym sym) { if (SYMBOL_INLINE_P(sym)) return TRUE; - sym >>= SYMBOL_NORMAL_SHIFT; + sym >>= SYMBOL_SHIFT; if (sym > MRB_PRESYM_MAX) return FALSE; return TRUE; } -- cgit v1.2.3 From a4c5824e59c66a1132f38e1faf21926ddef58ca6 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 5 Sep 2020 10:54:06 +0900 Subject: Restore old function names for compatibility; ref #5070 - `mrb_check_intern()` to return `mrb_value` - `mrb_intern_check()` to return `mrb_sym` [NEW] Other new functions: - `mrb_intern_check_cstr()` - `mrb_intern_check_str()` --- include/mruby.h | 13 ++++++---- mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c | 2 +- mrbgems/mruby-sprintf/src/sprintf.c | 2 +- src/class.c | 4 ++-- src/symbol.c | 30 +++++++++++++++++++++--- 5 files changed, 40 insertions(+), 11 deletions(-) (limited to 'src/symbol.c') diff --git a/include/mruby.h b/include/mruby.h index bc558b306..61356ffb3 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1097,10 +1097,15 @@ MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t); MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t); #define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit)) MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value); -/* mrb_check_intern series functions returns 0 if the symbol is not defined */ -MRB_API mrb_sym mrb_check_intern_cstr(mrb_state*,const char*); -MRB_API mrb_sym mrb_check_intern(mrb_state*,const char*,size_t); -MRB_API mrb_sym mrb_check_intern_str(mrb_state*,mrb_value); +/* mrb_intern_check series functions returns 0 if the symbol is not defined */ +MRB_API mrb_sym mrb_intern_check_cstr(mrb_state*,const char*); +MRB_API mrb_sym mrb_intern_check(mrb_state*,const char*,size_t); +MRB_API mrb_sym mrb_intern_check_str(mrb_state*,mrb_value); +/* mrb_check_intern series functions returns nil if the symbol is not defined */ +/* otherwise returns mrb_value */ +MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*); +MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t); +MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value); MRB_API const char *mrb_sym_name(mrb_state*,mrb_sym); MRB_API const char *mrb_sym_name_len(mrb_state*,mrb_sym,mrb_int*); MRB_API const char *mrb_sym_dump(mrb_state*,mrb_sym); diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c index 859f42bbd..fbc5a5ee4 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c @@ -151,7 +151,7 @@ compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *cl } sc = mrb_class_get(mrb, method_p->class_name); - ssym = mrb_check_intern_cstr(mrb, method_p->method_name); + ssym = mrb_intern_check_cstr(mrb, method_p->method_name); m = mrb_method_search_vm(mrb, &sc, ssym); if (MRB_METHOD_UNDEF_P(m)) { return MRB_DEBUG_OK; diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 189b54b5c..6396096b1 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -699,7 +699,7 @@ retry: } CHECKNAMEARG(start, p - start + 1); get_hash(mrb, &hash, argc, argv); - id = mrb_check_intern(mrb, start + 1, p - start - 1); + id = mrb_intern_check(mrb, start + 1, p - start - 1); if (id) { nextvalue = mrb_hash_fetch(mrb, hash, mrb_symbol_value(id), mrb_undef_value()); } diff --git a/src/class.c b/src/class.c index e8f9b7638..bbf64e8ea 100644 --- a/src/class.c +++ b/src/class.c @@ -575,7 +575,7 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name) { - mrb_sym sym = mrb_check_intern_cstr(mrb, name); + mrb_sym sym = mrb_intern_check_cstr(mrb, name); if (!sym) return FALSE; return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), sym); } @@ -589,7 +589,7 @@ mrb_class_defined_id(mrb_state *mrb, mrb_sym name) MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name) { - mrb_sym sym = mrb_check_intern_cstr(mrb, name); + mrb_sym sym = mrb_intern_check_cstr(mrb, name); if (!sym) return FALSE; return mrb_const_defined_at(mrb, mrb_obj_value(outer), sym); } diff --git a/src/symbol.c b/src/symbol.c index 9683d2f72..18ea49da5 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -268,7 +268,7 @@ mrb_intern_str(mrb_state *mrb, mrb_value str) } MRB_API mrb_sym -mrb_check_intern(mrb_state *mrb, const char *name, size_t len) +mrb_intern_check(mrb_state *mrb, const char *name, size_t len) { mrb_sym sym; @@ -278,16 +278,40 @@ mrb_check_intern(mrb_state *mrb, const char *name, size_t len) return 0; } +MRB_API mrb_value +mrb_check_intern(mrb_state *mrb, const char *name, size_t len) +{ + mrb_sym sym = mrb_intern_check(mrb, name, len); + if (sym == 0) return mrb_nil_value(); + return mrb_symbol_value(sym); +} + MRB_API mrb_sym +mrb_intern_check_cstr(mrb_state *mrb, const char *name) +{ + return mrb_intern_check(mrb, name, strlen(name)); +} + +MRB_API mrb_value mrb_check_intern_cstr(mrb_state *mrb, const char *name) { - return mrb_check_intern(mrb, name, strlen(name)); + mrb_sym sym = mrb_intern_check_cstr(mrb, name); + if (sym == 0) return mrb_nil_value(); + return mrb_symbol_value(sym); } MRB_API mrb_sym +mrb_intern_check_str(mrb_state *mrb, mrb_value str) +{ + return mrb_intern_check(mrb, RSTRING_PTR(str), RSTRING_LEN(str)); +} + +MRB_API mrb_value mrb_check_intern_str(mrb_state *mrb, mrb_value str) { - return mrb_check_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str)); + mrb_sym sym = mrb_intern_check_str(mrb, str); + if (sym == 0) return mrb_nil_value(); + return mrb_symbol_value(sym); } static const char* -- cgit v1.2.3 From 12881ccb05bb60bc99634b183f4f118da5fbd77b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 7 Sep 2020 16:39:03 +0900 Subject: Use `NULL` instead of `0`; close #2467 The PR was from @cubicdaiya. --- src/object.c | 2 +- src/symbol.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'src/symbol.c') diff --git a/src/object.c b/src/object.c index e8bb52dca..aaab4022d 100644 --- a/src/object.c +++ b/src/object.c @@ -94,7 +94,7 @@ mrb_true(mrb_state *mrb, mrb_value obj) static mrb_value nil_to_s(mrb_state *mrb, mrb_value obj) { - mrb_value str = mrb_str_new_frozen(mrb, 0, 0); + mrb_value str = mrb_str_new_frozen(mrb, NULL, 0); RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); return str; } diff --git a/src/symbol.c b/src/symbol.c index 18ea49da5..add093d14 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -571,7 +571,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym) char *sp; name = mrb_sym_name_len(mrb, id, &len); - str = mrb_str_new(mrb, 0, len+1); + str = mrb_str_new(mrb, NULL, len+1); sp = RSTRING_PTR(str); sp[0] = ':'; memcpy(sp+1, name, len); -- cgit v1.2.3