From 0e6a93a9ca9b207ce26073597e2abe26bbbb2c0d Mon Sep 17 00:00:00 2001 From: KOBAYASHI Shuji Date: Mon, 22 Apr 2019 19:09:29 +0900 Subject: Use `MRB_ASPEC_XXX()` macro in `codedump()` --- src/codedump.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'src/codedump.c') diff --git a/src/codedump.c b/src/codedump.c index 5bffefddb..12d609075 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -266,13 +266,13 @@ codedump(mrb_state *mrb, mrb_irep *irep) break; CASE(OP_ENTER, W): printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n", - (a>>18)&0x1f, - (a>>13)&0x1f, - (a>>12)&0x1, - (a>>7)&0x1f, - (a>>2)&0x1f, - (a>>1)&0x1, - a & 0x1); + MRB_ASPEC_REQ(a), + MRB_ASPEC_OPT(a), + MRB_ASPEC_REST(a), + MRB_ASPEC_POST(a), + MRB_ASPEC_KEY(a), + MRB_ASPEC_KDICT(a), + MRB_ASPEC_BLOCK(a)); break; CASE(OP_KEY_P, BB): printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym2name(mrb, irep->syms[b])); -- cgit v1.2.3 From 279c21b816777b8b25457b27fd1994a9fe359a98 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 18 Aug 2019 14:45:35 +0900 Subject: Prohibit changes to iseq in principle --- include/mruby.h | 10 ++-- include/mruby/irep.h | 4 +- mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c | 2 +- mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c | 2 +- mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c | 4 +- mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h | 2 +- mrbgems/mruby-compiler/core/codegen.c | 2 +- mrbgems/mruby-eval/src/eval.c | 71 ++++++++++++------------ src/array.c | 2 +- src/backtrace.c | 4 +- src/class.c | 2 +- src/codedump.c | 2 +- src/error.c | 4 +- src/load.c | 5 +- src/proc.c | 4 +- src/state.c | 2 +- src/vm.c | 4 +- 17 files changed, 65 insertions(+), 61 deletions(-) (limited to 'src/codedump.c') diff --git a/include/mruby.h b/include/mruby.h index 55505a213..b1b983f52 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -127,8 +127,8 @@ typedef struct { uint16_t ridx; uint16_t epos; struct REnv *env; - mrb_code *pc; /* return address */ - mrb_code *err; /* error position */ + const mrb_code *pc; /* return address */ + const mrb_code *err; /* error position */ int argc; int acc; struct RClass *target_class; @@ -243,8 +243,8 @@ typedef struct mrb_state { #endif #ifdef MRB_ENABLE_DEBUG_HOOK - void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs); - void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs); + void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs); + void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs); #endif #ifdef MRB_BYTECODE_DECODE_OPTION @@ -1057,7 +1057,7 @@ MRB_API mrb_value mrb_top_self(mrb_state *); MRB_API mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value); MRB_API mrb_value mrb_top_run(mrb_state*, struct RProc*, mrb_value, unsigned int); MRB_API mrb_value mrb_vm_run(mrb_state*, struct RProc*, mrb_value, unsigned int); -MRB_API mrb_value mrb_vm_exec(mrb_state*, struct RProc*, mrb_code*); +MRB_API mrb_value mrb_vm_exec(mrb_state*, struct RProc*, const mrb_code*); /* 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/irep.h b/include/mruby/irep.h index d42fd0fb8..2989e0647 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -32,7 +32,7 @@ typedef struct mrb_irep { uint16_t nregs; /* Number of register variables */ uint8_t flags; - mrb_code *iseq; + const mrb_code *iseq; mrb_value *pool; mrb_sym *syms; struct mrb_irep **reps; @@ -80,7 +80,7 @@ struct mrb_insn_data { uint8_t c; }; -struct mrb_insn_data mrb_decode_insn(mrb_code *pc); +struct mrb_insn_data mrb_decode_insn(const mrb_code *pc); MRB_END_DECL diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c index 513db4ded..530d824eb 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c @@ -428,7 +428,7 @@ mrb_debug_disable_break_all(mrb_state *mrb, mrb_debug_context *dbg) } static mrb_bool -check_start_pc_for_line(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, uint16_t line) +check_start_pc_for_line(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, uint16_t line) { if (pc > irep->iseq) { if (line == mrb_debug_get_line(mrb, irep, pc - irep->iseq - 1)) { diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c index f888d1430..cdd7b6fa6 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c @@ -33,7 +33,7 @@ mrdb_check_syntax(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size mrb_value mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc, int direct_eval) { - void (*tmp)(struct mrb_state *, struct mrb_irep *, mrb_code *, mrb_value *); + void (*tmp)(struct mrb_state *, struct mrb_irep *, const mrb_code *, mrb_value *); mrb_value ruby_code; mrb_value s; mrb_value v; diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c index 003406172..d2fa4c856 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c @@ -505,7 +505,7 @@ get_and_parse_command(mrb_state *mrb, mrdb_state *mrdb) } static int32_t -check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *regs) +check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs) { struct RClass* c; mrb_sym sym; @@ -546,7 +546,7 @@ check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value } static void -mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *regs) +mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs) { const char *file; int32_t line; diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h index 7b14a899f..7c21de317 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h @@ -105,7 +105,7 @@ typedef struct mrb_debug_breakpoint { typedef struct mrb_debug_context { struct mrb_irep *root_irep; struct mrb_irep *irep; - mrb_code *pc; + const mrb_code *pc; mrb_value *regs; const char *prvfile; diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index f4dbe63a1..36367f656 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -291,7 +291,7 @@ on_eval(codegen_scope *s) } struct mrb_insn_data -mrb_decode_insn(mrb_code *pc) +mrb_decode_insn(const mrb_code *pc) { struct mrb_insn_data data = { 0 }; mrb_code insn = READ_B(); diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c index e8f1d3e95..e2388f026 100644 --- a/mrbgems/mruby-eval/src/eval.c +++ b/mrbgems/mruby-eval/src/eval.c @@ -102,25 +102,28 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top) uint8_t c; mrb_code insn; int argc = irep_argc(irep); + mrb_code *iseq = (mrb_code *)irep->iseq; + + mrb_assert((irep->flags & MRB_ISEQ_NO_FREE) == 0); for (i = 0; i < irep->ilen; ) { - insn = irep->iseq[i]; + insn = iseq[i]; switch(insn){ case OP_EPUSH: - b = PEEK_S(irep->iseq+i+1); + b = PEEK_S(iseq+i+1); patch_irep(mrb, irep->reps[b], bnest + 1, top); break; case OP_LAMBDA: case OP_BLOCK: - a = PEEK_B(irep->iseq+i+1); - b = PEEK_B(irep->iseq+i+2); + a = PEEK_B(iseq+i+1); + b = PEEK_B(iseq+i+2); patch_irep(mrb, irep->reps[b], bnest + 1, top); break; case OP_SEND: - b = PEEK_B(irep->iseq+i+2); - c = PEEK_B(irep->iseq+i+3); + b = PEEK_B(iseq+i+2); + c = PEEK_B(iseq+i+3); if (c != 0) { break; } @@ -128,24 +131,24 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top) uint16_t arg = search_variable(mrb, irep->syms[b], bnest); if (arg != 0) { /* must replace */ - irep->iseq[i] = OP_GETUPVAR; - irep->iseq[i+2] = arg >> 8; - irep->iseq[i+3] = arg & 0xff; + iseq[i] = OP_GETUPVAR; + iseq[i+2] = arg >> 8; + iseq[i+3] = arg & 0xff; } } break; case OP_MOVE: - a = PEEK_B(irep->iseq+i+1); - b = PEEK_B(irep->iseq+i+2); + a = PEEK_B(iseq+i+1); + b = PEEK_B(iseq+i+2); /* src part */ if (potential_upvar_p(irep->lv, b, argc, irep->nlocals)) { uint16_t arg = search_variable(mrb, irep->lv[b - 1].name, bnest); if (arg != 0) { /* must replace */ - irep->iseq[i] = insn = OP_GETUPVAR; - irep->iseq[i+2] = arg >> 8; - irep->iseq[i+3] = arg & 0xff; + iseq[i] = insn = OP_GETUPVAR; + iseq[i+2] = arg >> 8; + iseq[i+3] = arg & 0xff; } } /* dst part */ @@ -153,18 +156,18 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top) uint16_t arg = search_variable(mrb, irep->lv[a - 1].name, bnest); if (arg != 0) { /* must replace */ - irep->iseq[i] = insn = OP_SETUPVAR; - irep->iseq[i+1] = (mrb_code)b; - irep->iseq[i+2] = arg >> 8; - irep->iseq[i+3] = arg & 0xff; + iseq[i] = insn = OP_SETUPVAR; + iseq[i+1] = (mrb_code)b; + iseq[i+2] = arg >> 8; + iseq[i+3] = arg & 0xff; } } break; case OP_GETUPVAR: - a = PEEK_B(irep->iseq+i+1); - b = PEEK_B(irep->iseq+i+2); - c = PEEK_B(irep->iseq+i+3); + a = PEEK_B(iseq+i+1); + b = PEEK_B(iseq+i+2); + c = PEEK_B(iseq+i+3); { int lev = c+1; mrb_irep *tmp = search_irep(top, bnest, lev, irep); @@ -172,18 +175,18 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top) uint16_t arg = search_variable(mrb, tmp->lv[b-1].name, bnest); if (arg != 0) { /* must replace */ - irep->iseq[i] = OP_GETUPVAR; - irep->iseq[i+2] = arg >> 8; - irep->iseq[i+3] = arg & 0xff; + iseq[i] = OP_GETUPVAR; + iseq[i+2] = arg >> 8; + iseq[i+3] = arg & 0xff; } } } break; case OP_SETUPVAR: - a = PEEK_B(irep->iseq+i+1); - b = PEEK_B(irep->iseq+i+2); - c = PEEK_B(irep->iseq+i+3); + a = PEEK_B(iseq+i+1); + b = PEEK_B(iseq+i+2); + c = PEEK_B(iseq+i+3); { int lev = c+1; mrb_irep *tmp = search_irep(top, bnest, lev, irep); @@ -191,25 +194,25 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top) uint16_t arg = search_variable(mrb, tmp->lv[b-1].name, bnest); if (arg != 0) { /* must replace */ - irep->iseq[i] = OP_SETUPVAR; - irep->iseq[i+1] = a; - irep->iseq[i+2] = arg >> 8; - irep->iseq[i+3] = arg & 0xff; + iseq[i] = OP_SETUPVAR; + iseq[i+1] = a; + iseq[i+2] = arg >> 8; + iseq[i+3] = arg & 0xff; } } } break; case OP_EXT1: - insn = PEEK_B(irep->iseq+i+1); + insn = PEEK_B(iseq+i+1); i += mrb_insn_size1[insn]+1; continue; case OP_EXT2: - insn = PEEK_B(irep->iseq+i+1); + insn = PEEK_B(iseq+i+1); i += mrb_insn_size2[insn]+1; continue; case OP_EXT3: - insn = PEEK_B(irep->iseq+i+1); + insn = PEEK_B(iseq+i+1); i += mrb_insn_size3[insn]+1; continue; } diff --git a/src/array.c b/src/array.c index 70e2fcab7..33baceb9c 100644 --- a/src/array.c +++ b/src/array.c @@ -1259,7 +1259,7 @@ mrb_ary_svalue(mrb_state *mrb, mrb_value ary) } } -static mrb_code each_iseq[] = { +static const mrb_code each_iseq[] = { OP_ENTER, 0x0, 0x00, 0x1, /* OP_ENTER 0:0:0:0:0:0:1 */ OP_JMPIF, 0x1, 0x0, 19, /* OP_JMPIF R1 19 */ OP_LOADSELF, 0x3, /* OP_LOADSELF R3 */ diff --git a/src/backtrace.c b/src/backtrace.c index c9a223e07..8001849bc 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -26,7 +26,7 @@ typedef void (*each_backtrace_func)(mrb_state*, const struct backtrace_location* static const mrb_data_type bt_type = { "Backtrace", mrb_free }; static void -each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, mrb_code *pc0, each_backtrace_func func, void *data) +each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, const mrb_code *pc0, each_backtrace_func func, void *data) { ptrdiff_t i; @@ -37,7 +37,7 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, mrb_code *pc0, each_backtrace_fu struct backtrace_location loc; mrb_callinfo *ci; mrb_irep *irep; - mrb_code *pc; + const mrb_code *pc; ci = &mrb->c->cibase[i]; diff --git a/src/class.c b/src/class.c index 7e37973f6..43540dc3b 100644 --- a/src/class.c +++ b/src/class.c @@ -2123,7 +2123,7 @@ inspect_main(mrb_state *mrb, mrb_value mod) return mrb_str_new_lit(mrb, "main"); } -static mrb_code new_iseq[] = { +static const mrb_code new_iseq[] = { OP_ENTER, 0x0, 0x10, 0x1, /* OP_ENTER 0:0:1:0:0:0:1 */ OP_LOADSELF, 0x3, /* OP_LOADSELF R3 */ OP_SEND, 0x3, 0x0, 0x0, /* OP_SEND R3 :allocate 0 */ diff --git a/src/codedump.c b/src/codedump.c index 12d609075..b77a8adb4 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -69,7 +69,7 @@ static void codedump(mrb_state *mrb, mrb_irep *irep) { int ai; - mrb_code *pc, *pcend; + const mrb_code *pc, *pcend; mrb_code ins; const char *file = NULL, *next_file; diff --git a/src/error.c b/src/error.c index 664da3fd6..bb8a0ba98 100644 --- a/src/error.c +++ b/src/error.c @@ -198,11 +198,11 @@ static void exc_debug_info(mrb_state *mrb, struct RObject *exc) { mrb_callinfo *ci = mrb->c->ci; - mrb_code *pc = ci->pc; + const mrb_code *pc = ci->pc; if (mrb_obj_iv_defined(mrb, exc, mrb_intern_lit(mrb, "file"))) return; while (ci >= mrb->c->cibase) { - mrb_code *err = ci->err; + const mrb_code *err = ci->err; if (!err && pc) err = pc - 1; if (err && ci->proc && !MRB_PROC_CFUNC_P(ci->proc)) { diff --git a/src/load.c b/src/load.c index 97eafdbb5..2aa2c576f 100644 --- a/src/load.c +++ b/src/load.c @@ -102,8 +102,9 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag } else { size_t data_len = sizeof(mrb_code) * irep->ilen; - irep->iseq = (mrb_code *)mrb_malloc(mrb, data_len); - memcpy(irep->iseq, src, data_len); + void *buf = mrb_malloc(mrb, data_len); + irep->iseq = (mrb_code *)buf; + memcpy(buf, src, data_len); src += data_len; } } diff --git a/src/proc.c b/src/proc.c index a0edf22bc..ca398384f 100644 --- a/src/proc.c +++ b/src/proc.c @@ -9,7 +9,7 @@ #include #include -static mrb_code call_iseq[] = { +static const mrb_code call_iseq[] = { OP_CALL, }; @@ -256,7 +256,7 @@ mrb_int mrb_proc_arity(const struct RProc *p) { struct mrb_irep *irep; - mrb_code *pc; + const mrb_code *pc; mrb_aspec aspec; int ma, op, ra, pa, arity; diff --git a/src/state.c b/src/state.c index 69b069304..010a8d68a 100644 --- a/src/state.c +++ b/src/state.c @@ -117,7 +117,7 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep) int i; if (!(irep->flags & MRB_ISEQ_NO_FREE)) - mrb_free(mrb, irep->iseq); + mrb_free(mrb, (void*)irep->iseq); if (irep->pool) for (i=0; iplen; i++) { if (mrb_type(irep->pool[i]) == MRB_TT_STRING) { mrb_gc_free_str(mrb, RSTRING(irep->pool[i])); diff --git a/src/vm.c b/src/vm.c index 458b9249e..7ba49a32d 100644 --- a/src/vm.c +++ b/src/vm.c @@ -971,10 +971,10 @@ 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, mrb_code *pc) +mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *pc) { /* mrb_assert(MRB_PROC_CFUNC_P(proc)) */ - mrb_code *pc0 = pc; + const mrb_code *pc0 = pc; mrb_irep *irep = proc->body.irep; mrb_value *pool = irep->pool; mrb_sym *syms = irep->syms; -- cgit v1.2.3 From a365f9a67d4bf082ee9a414fe247bd18148d7081 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 25 Sep 2019 21:46:26 +0900 Subject: Rename symbol-to-string functions; close #4684 * mrb_sym2name -> mrb_sym_name * mrb_sym2name_len -> mrb_sym_name_len * mrb_sym2str -> mrb_sym_str --- include/mruby.h | 9 ++-- mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c | 4 +- mrbgems/mruby-compiler/core/codegen.c | 12 ++--- mrbgems/mruby-compiler/core/parse.y | 64 ++++++++++++------------ mrbgems/mruby-metaprog/src/metaprog.c | 4 +- mrbgems/mruby-proc-ext/src/proc.c | 2 +- mrbgems/mruby-struct/src/struct.c | 2 +- mrbgems/mruby-symbol-ext/src/symbol.c | 4 +- src/backtrace.c | 4 +- src/class.c | 8 +-- src/codedump.c | 52 +++++++++---------- src/debug.c | 4 +- src/dump.c | 12 ++--- src/string.c | 2 +- src/symbol.c | 16 +++--- src/variable.c | 14 +++--- src/vm.c | 2 +- 17 files changed, 109 insertions(+), 106 deletions(-) (limited to 'src/codedump.c') diff --git a/include/mruby.h b/include/mruby.h index e6371564e..451f39660 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -997,9 +997,12 @@ 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_API const char *mrb_sym2name(mrb_state*,mrb_sym); -MRB_API const char *mrb_sym2name_len(mrb_state*,mrb_sym,mrb_int*); -MRB_API mrb_value mrb_sym2str(mrb_state*,mrb_sym); +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 mrb_value mrb_sym_str(mrb_state*,mrb_sym); +#define mrb_sym2name(mrb,sym) mrb_sym_name(mrb,sym) +#define mrb_sym2name_len(mrb,sym,len) mrb_sym_name_len(mrb,sym,len) +#define mrb_sym2str(mrb,sym) mrb_sym_str(mrb,sym) MRB_API void *mrb_malloc(mrb_state*, size_t); /* raise RuntimeError if no mem */ MRB_API void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */ diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c index 530d824eb..ceeb27393 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c @@ -95,7 +95,7 @@ check_file_lineno(mrb_state *mrb, struct mrb_irep *irep, const char *file, uint1 for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { const char *filename; info_file = irep->debug_info->files[f_idx]; - filename = mrb_sym2name_len(mrb, info_file->filename_sym, NULL); + filename = mrb_sym_name_len(mrb, info_file->filename_sym, NULL); if (!strcmp(filename, file)) { result = MRB_DEBUG_BP_FILE_OK; @@ -126,7 +126,7 @@ compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *cl mrb_debug_methodpoint *method_p; mrb_bool is_defined; - method_name = mrb_sym2name(mrb, method_sym); + method_name = mrb_sym_name(mrb, method_sym); method_p = &bp->point.methodpoint; if (strcmp(method_p->method_name, method_name) == 0) { diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index c0986893c..1989c0cf1 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -108,7 +108,7 @@ codegen_error(codegen_scope *s, const char *message) } #ifndef MRB_DISABLE_STDIO if (s->filename_sym && s->lineno) { - const char *filename = mrb_sym2name_len(s->mrb, s->filename_sym, NULL); + const char *filename = mrb_sym_name_len(s->mrb, s->filename_sym, NULL); fprintf(stderr, "codegen error:%s:%d: %s\n", filename, s->lineno, message); } else { @@ -922,7 +922,7 @@ attrsym(codegen_scope *s, mrb_sym a) mrb_int len; char *name2; - name = mrb_sym2name_len(s->mrb, a, &len); + name = mrb_sym_name_len(s->mrb, a, &len); name2 = (char *)codegen_palloc(s, (size_t)len + 1 /* '=' */ @@ -1046,7 +1046,7 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe) pop_n(n+1); { mrb_int symlen; - const char *symname = mrb_sym2name_len(s->mrb, sym, &symlen); + const char *symname = mrb_sym_name_len(s->mrb, sym, &symlen); if (!noop && symlen == 1 && symname[0] == '+' && n == 1) { gen_addsub(s, OP_ADD, cursp()); @@ -1406,7 +1406,7 @@ codegen(codegen_scope *s, node *tree, int val) } if (s->irep && s->filename_index != tree->filename_index) { mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index); - const char *filename = mrb_sym2name_len(s->mrb, fname, NULL); + const char *filename = mrb_sym_name_len(s->mrb, fname, NULL); mrb_debug_info_append_file(s->mrb, s->irep->debug_info, filename, s->lines, s->debug_start_pos, s->pc); @@ -1987,7 +1987,7 @@ codegen(codegen_scope *s, node *tree, int val) { mrb_sym sym = nsym(tree->cdr->car); mrb_int len; - const char *name = mrb_sym2name_len(s->mrb, sym, &len); + const char *name = mrb_sym_name_len(s->mrb, sym, &len); int idx, callargs = -1, vsp = -1; if ((len == 2 && name[0] == '|' && name[1] == '|') && @@ -3065,7 +3065,7 @@ scope_finish(codegen_scope *s) irep->reps = (mrb_irep**)codegen_realloc(s, irep->reps, sizeof(mrb_irep*)*irep->rlen); if (s->filename_sym) { mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index); - const char *filename = mrb_sym2name_len(s->mrb, fname, NULL); + const char *filename = mrb_sym_name_len(s->mrb, fname, NULL); mrb_debug_info_append_file(s->mrb, s->irep->debug_info, filename, s->lines, s->debug_start_pos, s->pc); diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 6576ab702..5848e9ca3 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -3231,7 +3231,7 @@ var_ref : variable } | keyword__FILE__ { - const char *fn = mrb_sym2name_len(p->mrb, p->filename_sym, NULL); + const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL); if (!fn) { fn = "(null)"; } @@ -3741,7 +3741,7 @@ yyerror(parser_state *p, const char *s) if (! p->capture_errors) { #ifndef MRB_DISABLE_STDIO if (p->filename_sym) { - const char *filename = mrb_sym2name_len(p->mrb, p->filename_sym, NULL); + const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL); fprintf(stderr, "%s:%d:%d: %s\n", filename, p->lineno, p->column, s); } else { @@ -3780,7 +3780,7 @@ yywarn(parser_state *p, const char *s) if (! p->capture_errors) { #ifndef MRB_DISABLE_STDIO if (p->filename_sym) { - const char *filename = mrb_sym2name_len(p->mrb, p->filename_sym, NULL); + const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL); fprintf(stderr, "%s:%d:%d: warning: %s\n", filename, p->lineno, p->column, s); } else { @@ -6395,7 +6395,7 @@ dump_args(mrb_state *mrb, node *n, int offset) while (n2) { dump_prefix(n2, offset+2); - printf("%s=\n", mrb_sym2name(mrb, sym(n2->car->car))); + printf("%s=\n", mrb_sym_name(mrb, sym(n2->car->car))); mrb_parser_dump(mrb, n2->car->cdr, offset+3); n2 = n2->cdr; } @@ -6404,7 +6404,7 @@ dump_args(mrb_state *mrb, node *n, int offset) n = n->cdr; if (n->car) { dump_prefix(n, offset+1); - printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car))); + printf("rest=*%s\n", mrb_sym_name(mrb, sym(n->car))); } n = n->cdr; if (n->car) { @@ -6623,7 +6623,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) while (n2) { if (n2->car) { if (!first_lval) printf(", "); - printf("%s", mrb_sym2name(mrb, sym(n2->car))); + printf("%s", mrb_sym_name(mrb, sym(n2->car))); first_lval = FALSE; } n2 = n2->cdr; @@ -6651,7 +6651,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) mrb_parser_dump(mrb, tree->car, offset+1); dump_prefix(tree, offset+1); printf("method='%s' (%d)\n", - mrb_sym2name(mrb, sym(tree->cdr->car)), + mrb_sym_name(mrb, sym(tree->cdr->car)), intn(tree->cdr->car)); tree = tree->cdr->cdr->car; if (tree) { @@ -6682,11 +6682,11 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) printf("NODE_COLON2:\n"); mrb_parser_dump(mrb, tree->car, offset+1); dump_prefix(tree, offset+1); - printf("::%s\n", mrb_sym2name(mrb, sym(tree->cdr))); + printf("::%s\n", mrb_sym_name(mrb, sym(tree->cdr))); break; case NODE_COLON3: - printf("NODE_COLON3: ::%s\n", mrb_sym2name(mrb, sym(tree))); + printf("NODE_COLON3: ::%s\n", mrb_sym_name(mrb, sym(tree))); break; case NODE_ARRAY: @@ -6782,7 +6782,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) mrb_parser_dump(mrb, tree->car, offset+2); tree = tree->cdr; dump_prefix(tree, offset+1); - printf("op='%s' (%d)\n", mrb_sym2name(mrb, sym(tree->car)), intn(tree->car)); + printf("op='%s' (%d)\n", mrb_sym_name(mrb, sym(tree->car)), intn(tree->car)); tree = tree->cdr; mrb_parser_dump(mrb, tree->car, offset+1); break; @@ -6834,23 +6834,23 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) break; case NODE_LVAR: - printf("NODE_LVAR %s\n", mrb_sym2name(mrb, sym(tree))); + printf("NODE_LVAR %s\n", mrb_sym_name(mrb, sym(tree))); break; case NODE_GVAR: - printf("NODE_GVAR %s\n", mrb_sym2name(mrb, sym(tree))); + printf("NODE_GVAR %s\n", mrb_sym_name(mrb, sym(tree))); break; case NODE_IVAR: - printf("NODE_IVAR %s\n", mrb_sym2name(mrb, sym(tree))); + printf("NODE_IVAR %s\n", mrb_sym_name(mrb, sym(tree))); break; case NODE_CVAR: - printf("NODE_CVAR %s\n", mrb_sym2name(mrb, sym(tree))); + printf("NODE_CVAR %s\n", mrb_sym_name(mrb, sym(tree))); break; case NODE_CONST: - printf("NODE_CONST %s\n", mrb_sym2name(mrb, sym(tree))); + printf("NODE_CONST %s\n", mrb_sym_name(mrb, sym(tree))); break; case NODE_MATCH: @@ -6872,7 +6872,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) break; case NODE_ARG: - printf("NODE_ARG %s\n", mrb_sym2name(mrb, sym(tree))); + printf("NODE_ARG %s\n", mrb_sym_name(mrb, sym(tree))); break; case NODE_BLOCK_ARG: @@ -6931,7 +6931,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) break; case NODE_SYM: - printf("NODE_SYM :%s (%d)\n", mrb_sym2name(mrb, sym(tree)), + printf("NODE_SYM :%s (%d)\n", mrb_sym_name(mrb, sym(tree)), intn(tree)); break; @@ -6953,8 +6953,8 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) case NODE_ALIAS: printf("NODE_ALIAS %s %s:\n", - mrb_sym2name(mrb, sym(tree->car)), - mrb_sym2name(mrb, sym(tree->cdr))); + mrb_sym_name(mrb, sym(tree->car)), + mrb_sym_name(mrb, sym(tree->cdr))); break; case NODE_UNDEF: @@ -6962,7 +6962,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) { node *t = tree; while (t) { - printf(" %s", mrb_sym2name(mrb, sym(t->car))); + printf(" %s", mrb_sym_name(mrb, sym(t->car))); t = t->cdr; } } @@ -6973,16 +6973,16 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) printf("NODE_CLASS:\n"); if (tree->car->car == (node*)0) { dump_prefix(tree, offset+1); - printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + printf(":%s\n", mrb_sym_name(mrb, sym(tree->car->cdr))); } else if (tree->car->car == (node*)1) { dump_prefix(tree, offset+1); - printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr))); } else { mrb_parser_dump(mrb, tree->car->car, offset+1); dump_prefix(tree, offset+1); - printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr))); } if (tree->cdr->car) { dump_prefix(tree, offset+1); @@ -6998,16 +6998,16 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) printf("NODE_MODULE:\n"); if (tree->car->car == (node*)0) { dump_prefix(tree, offset+1); - printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + printf(":%s\n", mrb_sym_name(mrb, sym(tree->car->cdr))); } else if (tree->car->car == (node*)1) { dump_prefix(tree, offset+1); - printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr))); } else { mrb_parser_dump(mrb, tree->car->car, offset+1); dump_prefix(tree, offset+1); - printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr))); + printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr))); } dump_prefix(tree, offset+1); printf("body:\n"); @@ -7025,7 +7025,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) case NODE_DEF: printf("NODE_DEF:\n"); dump_prefix(tree, offset+1); - printf("%s\n", mrb_sym2name(mrb, sym(tree->car))); + printf("%s\n", mrb_sym_name(mrb, sym(tree->car))); tree = tree->cdr; { node *n2 = tree->car; @@ -7038,7 +7038,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) while (n2) { if (n2->car) { if (!first_lval) printf(", "); - printf("%s", mrb_sym2name(mrb, sym(n2->car))); + printf("%s", mrb_sym_name(mrb, sym(n2->car))); first_lval = FALSE; } n2 = n2->cdr; @@ -7058,7 +7058,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) mrb_parser_dump(mrb, tree->car, offset+1); tree = tree->cdr; dump_prefix(tree, offset+1); - printf(":%s\n", mrb_sym2name(mrb, sym(tree->car))); + printf(":%s\n", mrb_sym_name(mrb, sym(tree->car))); tree = tree->cdr->cdr; if (tree->car) { dump_args(mrb, tree->car, offset+1); @@ -7095,17 +7095,17 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) tree = tree->cdr; if (tree->car) { dump_prefix(tree, offset+1); - printf("block='%s'\n", mrb_sym2name(mrb, sym(tree->car))); + printf("block='%s'\n", mrb_sym_name(mrb, sym(tree->car))); } break; case NODE_KW_ARG: - printf("NODE_KW_ARG %s\n", mrb_sym2name(mrb, sym(tree->car))); + printf("NODE_KW_ARG %s\n", mrb_sym_name(mrb, sym(tree->car))); mrb_parser_dump(mrb, tree->cdr->car, offset + 1); break; case NODE_KW_REST_ARGS: - printf("NODE_KW_REST_ARGS %s\n", mrb_sym2name(mrb, sym(tree))); + printf("NODE_KW_REST_ARGS %s\n", mrb_sym_name(mrb, sym(tree))); break; default: diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c index 87f1d3280..3f22596eb 100644 --- a/mrbgems/mruby-metaprog/src/metaprog.c +++ b/mrbgems/mruby-metaprog/src/metaprog.c @@ -150,7 +150,7 @@ mrb_local_variables(mrb_state *mrb, mrb_value self) for (i = 0; i + 1 < irep->nlocals; ++i) { if (irep->lv[i].name) { mrb_sym sym = irep->lv[i].name; - const char *name = mrb_sym2name(mrb, sym); + const char *name = mrb_sym_name(mrb, sym); switch (name[0]) { case '*': case '&': break; @@ -409,7 +409,7 @@ static void check_cv_name_sym(mrb_state *mrb, mrb_sym id) { mrb_int len; - const char *name = mrb_sym2name_len(mrb, id, &len); + const char *name = mrb_sym_name_len(mrb, id, &len); if (!cv_name_p(mrb, name, len)) { mrb_name_error(mrb, id, "'%n' is not allowed as a class variable name", id); } diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c index 1627ee474..a7faeebea 100644 --- a/mrbgems/mruby-proc-ext/src/proc.c +++ b/mrbgems/mruby-proc-ext/src/proc.c @@ -150,7 +150,7 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self) mrb_ary_push(mrb, a, sname); if (i < max && irep->lv[i].name) { mrb_sym sym = irep->lv[i].name; - const char *name = mrb_sym2name(mrb, sym); + const char *name = mrb_sym_name(mrb, sym); switch (name[0]) { case '*': case '&': break; diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index ebe711ed3..2d82c2466 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -132,7 +132,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id) mrb_sym mid; char onstack[ONSTACK_ALLOC_MAX]; - name = mrb_sym2name_len(mrb, id, &len); + name = mrb_sym_name_len(mrb, id, &len); if (len > ONSTACK_STRLEN_MAX) { buf = (char *)mrb_malloc(mrb, (size_t)len+1); } diff --git a/mrbgems/mruby-symbol-ext/src/symbol.c b/mrbgems/mruby-symbol-ext/src/symbol.c index ccb2971dc..87f8381b1 100644 --- a/mrbgems/mruby-symbol-ext/src/symbol.c +++ b/mrbgems/mruby-symbol-ext/src/symbol.c @@ -46,10 +46,10 @@ mrb_sym_length(mrb_state *mrb, mrb_value self) mrb_int len; #ifdef MRB_UTF8_STRING mrb_int byte_len; - const char *name = mrb_sym2name_len(mrb, mrb_symbol(self), &byte_len); + const char *name = mrb_sym_name_len(mrb, mrb_symbol(self), &byte_len); len = mrb_utf8_len(name, byte_len); #else - mrb_sym2name_len(mrb, mrb_symbol(self), &len); + mrb_sym_name_len(mrb, mrb_symbol(self), &len); #endif return mrb_fixnum_value(len); } diff --git a/src/backtrace.c b/src/backtrace.c index 8001849bc..803c5e285 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -128,7 +128,7 @@ print_packed_backtrace(mrb_state *mrb, mrb_value packed) if (entry->method_id != 0) { const char *method_name; - method_name = mrb_sym2name(mrb, entry->method_id); + method_name = mrb_sym_name(mrb, entry->method_id); fprintf(stream, ":in %s", method_name); mrb_gc_arena_restore(mrb, ai); } @@ -249,7 +249,7 @@ mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace) btline = mrb_format(mrb, "%s:%d", entry->filename, entry->lineno); if (entry->method_id != 0) { mrb_str_cat_lit(mrb, btline, ":in "); - mrb_str_cat_cstr(mrb, btline, mrb_sym2name(mrb, entry->method_id)); + mrb_str_cat_cstr(mrb, btline, mrb_sym_name(mrb, entry->method_id)); } mrb_ary_push(mrb, backtrace, btline); mrb_gc_arena_restore(mrb, ai); diff --git a/src/class.c b/src/class.c index 1b0a37d05..adb8954cc 100644 --- a/src/class.c +++ b/src/class.c @@ -73,7 +73,7 @@ mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb return; } mrb_str_cat_cstr(mrb, name, "::"); - mrb_str_cat_cstr(mrb, name, mrb_sym2name(mrb, id)); + mrb_str_cat_cstr(mrb, name, mrb_sym_name(mrb, id)); } mrb_obj_iv_set_force(mrb, (struct RObject*)c, nsym, name); } @@ -1333,7 +1333,7 @@ prepare_name_common(mrb_state *mrb, mrb_sym sym, const char *prefix, const char { char onstack[ONSTACK_ALLOC_MAX]; mrb_int sym_len; - const char *sym_str = mrb_sym2name_len(mrb, sym, &sym_len); + const char *sym_str = mrb_sym_name_len(mrb, sym, &sym_len); size_t prefix_len = prefix ? strlen(prefix) : 0; size_t suffix_len = suffix ? strlen(suffix) : 0; size_t name_len = sym_len + prefix_len + suffix_len; @@ -1633,7 +1633,7 @@ mrb_class_path(mrb_state *mrb, struct RClass *c) } else if (mrb_symbol_p(path)) { /* toplevel class/module */ - return mrb_sym2str(mrb, mrb_symbol(path)); + return mrb_sym_str(mrb, mrb_symbol(path)); } return mrb_str_dup(mrb, path); } @@ -1866,7 +1866,7 @@ static void check_const_name_sym(mrb_state *mrb, mrb_sym id) { mrb_int len; - const char *name = mrb_sym2name_len(mrb, id, &len); + const char *name = mrb_sym_name_len(mrb, id, &len); if (!mrb_const_name_p(mrb, name, len)) { mrb_name_error(mrb, id, "wrong constant name %n", id); } diff --git a/src/codedump.c b/src/codedump.c index b77a8adb4..2a82e5d2e 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -16,7 +16,7 @@ print_r(mrb_state *mrb, mrb_irep *irep, size_t n) for (i=0; i+1nlocals; i++) { if (irep->lv[i].r == n) { mrb_sym sym = irep->lv[i].name; - printf(" R%d:%s", (int)n, mrb_sym2name(mrb, sym)); + printf(" R%d:%s", (int)n, mrb_sym_name(mrb, sym)); break; } } @@ -82,7 +82,7 @@ codedump(mrb_state *mrb, mrb_irep *irep) printf("local variable names:\n"); for (i = 1; i < irep->nlocals; ++i) { - char const *s = mrb_sym2name(mrb, irep->lv[i - 1].name); + char const *s = mrb_sym_name(mrb, irep->lv[i - 1].name); int n = irep->lv[i - 1].r ? irep->lv[i - 1].r : i; printf(" R%d:%s\n", n, s ? s : ""); } @@ -147,7 +147,7 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_LOADSYM, BB): - printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_LOADNIL, B): @@ -167,43 +167,43 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_GETGV, BB): - printf("OP_GETGV\tR%d\t:%s", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETGV, BB): - printf("OP_SETGV\t:%s\tR%d", mrb_sym2name(mrb, irep->syms[b]), a); + printf("OP_SETGV\t:%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETSV, BB): - printf("OP_GETSV\tR%d\t:%s", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETSV, BB): - printf("OP_SETSV\t:%s\tR%d", mrb_sym2name(mrb, irep->syms[b]), a); + printf("OP_SETSV\t:%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETCONST, BB): - printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETCONST, BB): - printf("OP_SETCONST\t:%s\tR%d", mrb_sym2name(mrb, irep->syms[b]), a); + printf("OP_SETCONST\t:%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETMCNST, BB): - printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETMCNST, BB): - printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym2name(mrb, irep->syms[b]), a); + printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_name(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETIV, BB): - printf("OP_GETIV\tR%d\t%s", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_GETIV\tR%d\t%s", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETIV, BB): - printf("OP_SETIV\t%s\tR%d", mrb_sym2name(mrb, irep->syms[b]), a); + printf("OP_SETIV\t%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETUPVAR, BBB): @@ -215,11 +215,11 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_GETCV, BB): - printf("OP_GETCV\tR%d\t%s", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_GETCV\tR%d\t%s", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETCV, BB): - printf("OP_SETCV\t%s\tR%d", mrb_sym2name(mrb, irep->syms[b]), a); + printf("OP_SETCV\t%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_JMP, S): @@ -238,16 +238,16 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_SENDV, BB): - printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_name(mrb, irep->syms[b])); break; CASE(OP_SENDVB, BB): - printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_name(mrb, irep->syms[b])); break; CASE(OP_SEND, BBB): - printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym2name(mrb, irep->syms[b]), c); + printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_name(mrb, irep->syms[b]), c); break; CASE(OP_SENDB, BBB): - printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym2name(mrb, irep->syms[b]), c); + printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_name(mrb, irep->syms[b]), c); break; CASE(OP_CALL, Z): printf("OP_CALL\n"); @@ -275,14 +275,14 @@ codedump(mrb_state *mrb, mrb_irep *irep) MRB_ASPEC_BLOCK(a)); break; CASE(OP_KEY_P, BB): - printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_KEYEND, Z): printf("OP_KEYEND\n"); break; CASE(OP_KARG, BB): - printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_RETURN, B): @@ -322,13 +322,13 @@ codedump(mrb_state *mrb, mrb_irep *irep) printf("OP_RANGE_EXC\tR%d\n", a); break; CASE(OP_DEF, BB): - printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_name(mrb, irep->syms[b])); break; CASE(OP_UNDEF, B): - printf("OP_UNDEF\t:%s\n", mrb_sym2name(mrb, irep->syms[a])); + printf("OP_UNDEF\t:%s\n", mrb_sym_name(mrb, irep->syms[a])); break; CASE(OP_ALIAS, BB): - printf("OP_ALIAS\t:%s\t%s\n", mrb_sym2name(mrb, irep->syms[a]), mrb_sym2name(mrb, irep->syms[b])); + printf("OP_ALIAS\t:%s\t%s\n", mrb_sym_name(mrb, irep->syms[a]), mrb_sym_name(mrb, irep->syms[b])); break; CASE(OP_ADD, B): printf("OP_ADD\tR%d\t\n", a); @@ -429,11 +429,11 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_CLASS, BB): - printf("OP_CLASS\tR%d\t:%s", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_CLASS\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_MODULE, BB): - printf("OP_MODULE\tR%d\t:%s", a, mrb_sym2name(mrb, irep->syms[b])); + printf("OP_MODULE\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_EXEC, BB): diff --git a/src/debug.c b/src/debug.c index 0dc02a1e3..b44c7d10e 100644 --- a/src/debug.c +++ b/src/debug.c @@ -57,7 +57,7 @@ mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc) mrb_irep_debug_info_file* f = NULL; if (!irep->debug_info) return NULL; else if ((f = get_file(irep->debug_info, (uint32_t)pc))) { - return mrb_sym2name_len(mrb, f->filename_sym, NULL); + return mrb_sym_name_len(mrb, f->filename_sym, NULL); } } return NULL; @@ -138,7 +138,7 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *d, mrb_assert(lines); if (d->flen > 0) { - const char *fn = mrb_sym2name_len(mrb, d->files[d->flen - 1]->filename_sym, NULL); + const char *fn = mrb_sym_name_len(mrb, d->files[d->flen - 1]->filename_sym, NULL); if (strcmp(filename, fn) == 0) return NULL; } diff --git a/src/dump.c b/src/dump.c index f1e167e35..5972c166d 100644 --- a/src/dump.c +++ b/src/dump.c @@ -220,7 +220,7 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep) for (sym_no = 0; sym_no < irep->slen; sym_no++) { size += sizeof(uint16_t); /* snl(n) */ if (irep->syms[sym_no] != 0) { - mrb_sym2name_len(mrb, irep->syms[sym_no], &len); + mrb_sym_name_len(mrb, irep->syms[sym_no], &len); size += len + 1; /* sn(n) + null char */ } } @@ -241,7 +241,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) if (irep->syms[sym_no] != 0) { mrb_int len; - name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len); + name = mrb_sym_name_len(mrb, irep->syms[sym_no], &len); mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX); cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */ @@ -436,7 +436,7 @@ get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t * filenames[*lp - 1] = file->filename_sym; /* filename */ - mrb_sym2name_len(mrb, file->filename_sym, &filename_len); + mrb_sym_name_len(mrb, file->filename_sym, &filename_len); size += sizeof(uint16_t) + (size_t)filename_len; } } @@ -540,7 +540,7 @@ write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const cur += uint16_to_bin(filenames_len, cur); section_size += sizeof(uint16_t); for (i = 0; i < filenames_len; ++i) { - sym = mrb_sym2name_len(mrb, filenames[i], &sym_len); + sym = mrb_sym_name_len(mrb, filenames[i], &sym_len); mrb_assert(sym); cur += uint16_to_bin((uint16_t)sym_len, cur); memcpy(cur, sym, sym_len); @@ -594,7 +594,7 @@ write_lv_sym_table(mrb_state *mrb, uint8_t **start, mrb_sym const *syms, uint32_ cur += uint32_to_bin(syms_len, cur); for (i = 0; i < syms_len; ++i) { - str = mrb_sym2name_len(mrb, syms[i], &str_len); + str = mrb_sym_name_len(mrb, syms[i], &str_len); cur += uint16_to_bin((uint16_t)str_len, cur); memcpy(cur, str, str_len); cur += str_len; @@ -658,7 +658,7 @@ get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_ ret += sizeof(uint16_t) * syms_len; /* symbol name lengths */ for (i = 0; i < syms_len; ++i) { mrb_int str_len; - mrb_sym2name_len(mrb, syms[i], &str_len); + mrb_sym_name_len(mrb, syms[i], &str_len); ret += str_len; } diff --git a/src/string.c b/src/string.c index 48df958ec..f53985ab9 100644 --- a/src/string.c +++ b/src/string.c @@ -1092,7 +1092,7 @@ mrb_str_to_str(mrb_state *mrb, mrb_value str) case MRB_TT_STRING: return str; case MRB_TT_SYMBOL: - return mrb_sym2str(mrb, mrb_symbol(str)); + return mrb_sym_str(mrb, mrb_symbol(str)); case MRB_TT_FIXNUM: return mrb_fixnum_to_str(mrb, str, 10); case MRB_TT_CLASS: diff --git a/src/symbol.c b/src/symbol.c index aad250f09..6ff1e54da 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -266,7 +266,7 @@ sym2name_len(mrb_state *mrb, mrb_sym sym, char *buf, mrb_int *lenp) } MRB_API const char* -mrb_sym2name_len(mrb_state *mrb, mrb_sym sym, mrb_int *lenp) +mrb_sym_name_len(mrb_state *mrb, mrb_sym sym, mrb_int *lenp) { return sym2name_len(mrb, sym, mrb->symbuf, lenp); } @@ -336,7 +336,7 @@ mrb_init_symtbl(mrb_state *mrb) static mrb_value sym_to_s(mrb_state *mrb, mrb_value sym) { - return mrb_sym2str(mrb, mrb_symbol(sym)); + return mrb_sym_str(mrb, mrb_symbol(sym)); } /* 15.2.11.3.4 */ @@ -491,7 +491,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym) mrb_sym id = mrb_symbol(sym); char *sp; - name = mrb_sym2name_len(mrb, id, &len); + name = mrb_sym_name_len(mrb, id, &len); str = mrb_str_new(mrb, 0, len+1); sp = RSTRING_PTR(str); sp[0] = ':'; @@ -510,10 +510,10 @@ sym_inspect(mrb_state *mrb, mrb_value sym) } MRB_API mrb_value -mrb_sym2str(mrb_state *mrb, mrb_sym sym) +mrb_sym_str(mrb_state *mrb, mrb_sym sym) { mrb_int len; - const char *name = mrb_sym2name_len(mrb, sym, &len); + const char *name = mrb_sym_name_len(mrb, sym, &len); if (!name) return mrb_undef_value(); /* can't happen */ if (SYMBOL_INLINE_P(sym)) { @@ -525,13 +525,13 @@ mrb_sym2str(mrb_state *mrb, mrb_sym sym) } MRB_API const char* -mrb_sym2name(mrb_state *mrb, mrb_sym sym) +mrb_sym_name(mrb_state *mrb, mrb_sym sym) { mrb_int len; - const char *name = mrb_sym2name_len(mrb, sym, &len); + const char *name = mrb_sym_name_len(mrb, sym, &len); if (!name) return NULL; - if (symname_p(name) && strlen(name) == (size_t)len) { + if (strlen(name) == (size_t)len) { return name; } else { diff --git a/src/variable.c b/src/variable.c index 62d6f35a5..d7a07d5be 100644 --- a/src/variable.c +++ b/src/variable.c @@ -378,7 +378,7 @@ 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_sym2name(mrb, sym)[0])) { + if (obj != c && ISUPPER(mrb_sym_name(mrb, sym)[0])) { mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__"); mrb_value o = mrb_obj_iv_get(mrb, c, id_classname); @@ -435,7 +435,7 @@ mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym iv_name) const char *s; mrb_int len; - s = mrb_sym2name_len(mrb, iv_name, &len); + s = mrb_sym_name_len(mrb, iv_name, &len); if (len < 2) return FALSE; if (s[0] != '@') return FALSE; if (ISDIGIT(s[1])) return FALSE; @@ -483,7 +483,7 @@ inspect_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p) else { mrb_str_cat_lit(mrb, str, ", "); } - s = mrb_sym2name_len(mrb, sym, &len); + s = mrb_sym_name_len(mrb, sym, &len); mrb_str_cat(mrb, str, s, len); mrb_str_cat_lit(mrb, str, "="); if (mrb_type(v) == MRB_TT_OBJECT) { @@ -541,7 +541,7 @@ iv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p) mrb_int len; ary = *(mrb_value*)p; - s = mrb_sym2name_len(mrb, sym, &len); + s = mrb_sym_name_len(mrb, sym, &len); if (len > 1 && s[0] == '@' && s[1] != '@') { mrb_ary_push(mrb, ary, mrb_symbol_value(sym)); } @@ -585,7 +585,7 @@ cv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p) mrb_int len; ary = *(mrb_value*)p; - s = mrb_sym2name_len(mrb, sym, &len); + s = mrb_sym_name_len(mrb, sym, &len); if (len > 2 && s[0] == '@' && s[1] == '@') { mrb_ary_push(mrb, ary, mrb_symbol_value(sym)); } @@ -894,7 +894,7 @@ const_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p) mrb_int len; ary = *(mrb_value*)p; - s = mrb_sym2name_len(mrb, sym, &len); + s = mrb_sym_name_len(mrb, sym, &len); if (len >= 1 && ISUPPER(s[0])) { mrb_int i, alen = RARRAY_LEN(ary); @@ -1117,7 +1117,7 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c) mrb_str_cat_cstr(mrb, path, str); mrb_str_cat_cstr(mrb, path, "::"); - str = mrb_sym2name_len(mrb, name, &len); + 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); diff --git a/src/vm.c b/src/vm.c index ec19d3eec..6d342a381 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2156,7 +2156,7 @@ RETRY_TRY_BLOCK: } pc = ci->pc; ci = mrb->c->ci; - DEBUG(fprintf(stderr, "from :%s\n", mrb_sym2name(mrb, ci->mid))); + DEBUG(fprintf(stderr, "from :%s\n", mrb_sym_name(mrb, ci->mid))); proc = mrb->c->ci->proc; irep = proc->body.irep; pool = irep->pool; -- cgit v1.2.3 From d4be545d54ad53e282637f66ef5b770b9effa918 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 26 Sep 2019 23:56:40 +0900 Subject: Fixed `codedump` for human readable symbol format; ref #4684 --- include/mruby.h | 1 + src/codedump.c | 52 ++++++++++++++++++++++++++-------------------------- src/symbol.c | 18 +++++++++++++++--- 3 files changed, 42 insertions(+), 29 deletions(-) (limited to 'src/codedump.c') diff --git a/include/mruby.h b/include/mruby.h index 451f39660..04b21bc35 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -999,6 +999,7 @@ 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); MRB_API mrb_value mrb_sym_str(mrb_state*,mrb_sym); #define mrb_sym2name(mrb,sym) mrb_sym_name(mrb,sym) #define mrb_sym2name_len(mrb,sym,len) mrb_sym_name_len(mrb,sym,len) diff --git a/src/codedump.c b/src/codedump.c index 2a82e5d2e..7faa39360 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -16,7 +16,7 @@ print_r(mrb_state *mrb, mrb_irep *irep, size_t n) for (i=0; i+1nlocals; i++) { if (irep->lv[i].r == n) { mrb_sym sym = irep->lv[i].name; - printf(" R%d:%s", (int)n, mrb_sym_name(mrb, sym)); + printf(" R%d:%s", (int)n, mrb_sym_dump(mrb, sym)); break; } } @@ -82,7 +82,7 @@ codedump(mrb_state *mrb, mrb_irep *irep) printf("local variable names:\n"); for (i = 1; i < irep->nlocals; ++i) { - char const *s = mrb_sym_name(mrb, irep->lv[i - 1].name); + char const *s = mrb_sym_dump(mrb, irep->lv[i - 1].name); int n = irep->lv[i - 1].r ? irep->lv[i - 1].r : i; printf(" R%d:%s\n", n, s ? s : ""); } @@ -147,7 +147,7 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_LOADSYM, BB): - printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_LOADNIL, B): @@ -167,43 +167,43 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_GETGV, BB): - printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETGV, BB): - printf("OP_SETGV\t:%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); + printf("OP_SETGV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETSV, BB): - printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETSV, BB): - printf("OP_SETSV\t:%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); + printf("OP_SETSV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETCONST, BB): - printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETCONST, BB): - printf("OP_SETCONST\t:%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); + printf("OP_SETCONST\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETMCNST, BB): - printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETMCNST, BB): - printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_name(mrb, irep->syms[b]), a); + printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETIV, BB): - printf("OP_GETIV\tR%d\t%s", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_GETIV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETIV, BB): - printf("OP_SETIV\t%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); + printf("OP_SETIV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_GETUPVAR, BBB): @@ -215,11 +215,11 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_GETCV, BB): - printf("OP_GETCV\tR%d\t%s", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_GETCV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_SETCV, BB): - printf("OP_SETCV\t%s\tR%d", mrb_sym_name(mrb, irep->syms[b]), a); + printf("OP_SETCV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; CASE(OP_JMP, S): @@ -238,16 +238,16 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_SENDV, BB): - printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b])); break; CASE(OP_SENDVB, BB): - printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b])); break; CASE(OP_SEND, BBB): - printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_name(mrb, irep->syms[b]), c); + printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c); break; CASE(OP_SENDB, BBB): - printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_name(mrb, irep->syms[b]), c); + printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c); break; CASE(OP_CALL, Z): printf("OP_CALL\n"); @@ -275,14 +275,14 @@ codedump(mrb_state *mrb, mrb_irep *irep) MRB_ASPEC_BLOCK(a)); break; CASE(OP_KEY_P, BB): - printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_KEYEND, Z): printf("OP_KEYEND\n"); break; CASE(OP_KARG, BB): - printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_RETURN, B): @@ -322,13 +322,13 @@ codedump(mrb_state *mrb, mrb_irep *irep) printf("OP_RANGE_EXC\tR%d\n", a); break; CASE(OP_DEF, BB): - printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b])); break; CASE(OP_UNDEF, B): - printf("OP_UNDEF\t:%s\n", mrb_sym_name(mrb, irep->syms[a])); + printf("OP_UNDEF\t:%s\n", mrb_sym_dump(mrb, irep->syms[a])); break; CASE(OP_ALIAS, BB): - printf("OP_ALIAS\t:%s\t%s\n", mrb_sym_name(mrb, irep->syms[a]), mrb_sym_name(mrb, irep->syms[b])); + printf("OP_ALIAS\t:%s\t%s\n", mrb_sym_dump(mrb, irep->syms[a]), mrb_sym_dump(mrb, irep->syms[b])); break; CASE(OP_ADD, B): printf("OP_ADD\tR%d\t\n", a); @@ -429,11 +429,11 @@ codedump(mrb_state *mrb, mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_CLASS, BB): - printf("OP_CLASS\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_CLASS\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_MODULE, BB): - printf("OP_MODULE\tR%d\t:%s", a, mrb_sym_name(mrb, irep->syms[b])); + printf("OP_MODULE\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; CASE(OP_EXEC, BB): diff --git a/src/symbol.c b/src/symbol.c index 6ff1e54da..d7718c63e 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -524,14 +524,14 @@ mrb_sym_str(mrb_state *mrb, mrb_sym sym) return mrb_str_new_static(mrb, name, len); } -MRB_API const char* -mrb_sym_name(mrb_state *mrb, mrb_sym sym) +static const char* +sym_name(mrb_state *mrb, mrb_sym sym, mrb_bool dump) { mrb_int len; const char *name = mrb_sym_name_len(mrb, sym, &len); if (!name) return NULL; - if (strlen(name) == (size_t)len) { + if (strlen(name) == (size_t)len && (!dump || symname_p(name))) { return name; } else { @@ -542,6 +542,18 @@ mrb_sym_name(mrb_state *mrb, mrb_sym sym) } } +MRB_API const char* +mrb_sym_name(mrb_state *mrb, mrb_sym sym) +{ + return sym_name(mrb, sym, FALSE); +} + +MRB_API const char* +mrb_sym_dump(mrb_state *mrb, mrb_sym sym) +{ + return sym_name(mrb, sym, TRUE); +} + #define lesser(a,b) (((a)>(b))?(b):(a)) static mrb_value -- cgit v1.2.3