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. --- src/vm.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src/vm.c') 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 e3e559696027b7c65fa27b26223c6aabd08faa76 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 15 May 2020 17:41:00 +0900 Subject: Use `MRB_OPSYM()` instead of `mrb_intern_lit()`. --- mrbgems/mruby-compiler/core/codegen.c | 8 ++-- mrbgems/mruby-compiler/core/parse.y | 74 +++++++++++++++++------------------ src/array.c | 4 +- src/kernel.c | 2 +- src/proc.c | 2 +- src/vm.c | 24 ++++++------ 6 files changed, 57 insertions(+), 57 deletions(-) (limited to 'src/vm.c') diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index c0d130182..eae1895a6 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1742,7 +1742,7 @@ codegen(codegen_scope *s, node *tree, int val) 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); + genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_OPSYM(eqq)), 1); } } else { @@ -2545,7 +2545,7 @@ codegen(codegen_scope *s, node *tree, int val) default: if (val) { - int sym = new_sym(s, mrb_intern_lit(s->mrb, "-@")); + int sym = new_sym(s, MRB_OPSYM(minus)); codegen(s, tree, VAL); pop(); genop_3(s, OP_SEND, cursp(), sym, 0); @@ -2637,7 +2637,7 @@ codegen(codegen_scope *s, node *tree, int val) } push(); /* for block */ pop_n(3); - sym = new_sym(s, mrb_intern_lit(s->mrb, "`")); + sym = new_sym(s, MRB_OPSYM(tick)); /* ` */ genop_3(s, OP_SEND, cursp(), sym, 1); if (val) push(); mrb_gc_arena_restore(s->mrb, ai); @@ -2657,7 +2657,7 @@ codegen(codegen_scope *s, node *tree, int val) genop_2(s, OP_STRING, cursp(), off); push(); push(); pop_n(3); - sym = new_sym(s, mrb_intern_lit(s->mrb, "`")); + sym = new_sym(s, MRB_OPSYM(tick)); /* ` */ genop_3(s, OP_SEND, cursp(), sym, 1); if (val) push(); mrb_gc_arena_restore(s->mrb, ai); diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 393d6b098..806032e22 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 : intern_lit("&")); + local_add_f(p, blk ? blk : MRB_OPSYM(and)); } static void local_add_kw(parser_state *p, mrb_sym kwd) { /* allocate register for keywords hash */ - local_add_f(p, kwd ? kwd : intern_lit("**")); + local_add_f(p, kwd ? kwd : MRB_OPSYM(pow)); } static node* @@ -1671,7 +1671,7 @@ command_asgn : lhs '=' command_rhs } | primary_value '[' opt_call_args ']' tOP_ASGN command_rhs { - $$ = new_op_asgn(p, new_call(p, $1, intern_lit("[]"), $3, '.'), $5, $6); + $$ = new_op_asgn(p, new_call(p, $1, MRB_OPSYM(aref), $3, '.'), $5, $6); } | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs { @@ -1902,7 +1902,7 @@ mlhs_node : variable } | primary_value '[' opt_call_args ']' { - $$ = new_call(p, $1, intern_lit("[]"), $3, '.'); + $$ = new_call(p, $1, MRB_OPSYM(aref), $3, '.'); } | primary_value call_op tIDENTIFIER { @@ -1941,7 +1941,7 @@ lhs : variable } | primary_value '[' opt_call_args ']' { - $$ = new_call(p, $1, intern_lit("[]"), $3, '.'); + $$ = new_call(p, $1, MRB_OPSYM(aref), $3, '.'); } | primary_value call_op tIDENTIFIER { @@ -2029,36 +2029,36 @@ undef_list : fsym } ; -op : '|' { $$ = intern_lit("|"); } - | '^' { $$ = intern_lit("^"); } - | '&' { $$ = intern_lit("&"); } - | tCMP { $$ = intern_lit("<=>"); } - | tEQ { $$ = intern_lit("=="); } - | tEQQ { $$ = intern_lit("==="); } - | tMATCH { $$ = intern_lit("=~"); } - | tNMATCH { $$ = intern_lit("!~"); } - | '>' { $$ = intern_lit(">"); } - | tGEQ { $$ = intern_lit(">="); } - | '<' { $$ = intern_lit("<"); } - | tLEQ { $$ = intern_lit("<="); } - | tNEQ { $$ = intern_lit("!="); } - | tLSHFT { $$ = intern_lit("<<"); } - | tRSHFT { $$ = intern_lit(">>"); } - | '+' { $$ = intern_lit("+"); } - | '-' { $$ = intern_lit("-"); } - | '*' { $$ = intern_lit("*"); } - | tSTAR { $$ = intern_lit("*"); } - | '/' { $$ = intern_lit("/"); } - | '%' { $$ = intern_lit("%"); } - | tPOW { $$ = intern_lit("**"); } - | tDSTAR { $$ = intern_lit("**"); } - | '!' { $$ = intern_lit("!"); } - | '~' { $$ = intern_lit("~"); } - | tUPLUS { $$ = intern_lit("+@"); } - | tUMINUS { $$ = intern_lit("-@"); } - | tAREF { $$ = intern_lit("[]"); } - | tASET { $$ = intern_lit("[]="); } - | '`' { $$ = intern_lit("`"); } +op : '|' { $$ = MRB_OPSYM(or); } + | '^' { $$ = MRB_OPSYM(xor); } + | '&' { $$ = MRB_OPSYM(and); } + | tCMP { $$ = MRB_OPSYM(cmp); } + | tEQ { $$ = MRB_OPSYM(eq); } + | tEQQ { $$ = MRB_OPSYM(eqq); } + | tMATCH { $$ = MRB_OPSYM(match); } + | tNMATCH { $$ = MRB_OPSYM(nmatch); } + | '>' { $$ = MRB_OPSYM(gt); } + | tGEQ { $$ = MRB_OPSYM(ge); } + | '<' { $$ = MRB_OPSYM(lt); } + | tLEQ { $$ = MRB_OPSYM(le); } + | tNEQ { $$ = MRB_OPSYM(neq); } + | tLSHFT { $$ = MRB_OPSYM(lshift); } + | tRSHFT { $$ = MRB_OPSYM(rshift); } + | '+' { $$ = MRB_OPSYM(add); } + | '-' { $$ = MRB_OPSYM(sub); } + | '*' { $$ = MRB_OPSYM(mul); } + | tSTAR { $$ = MRB_OPSYM(mul); } + | '/' { $$ = MRB_OPSYM(div); } + | '%' { $$ = MRB_OPSYM(mod); } + | tPOW { $$ = MRB_OPSYM(pow); } + | tDSTAR { $$ = MRB_OPSYM(pow); } + | '!' { $$ = MRB_OPSYM(not); } + | '~' { $$ = MRB_OPSYM(neg); } + | tUPLUS { $$ = MRB_OPSYM(plus); } + | tUMINUS { $$ = MRB_OPSYM(minus); } + | tAREF { $$ = MRB_OPSYM(aref); } + | tASET { $$ = MRB_OPSYM(aset); } + | '`' { $$ = MRB_OPSYM(tick); } ; reswords : keyword__LINE__ | keyword__FILE__ | keyword__ENCODING__ @@ -2288,8 +2288,8 @@ paren_args : '(' opt_call_args ')' | '(' tDOT3 rparen { #if 1 - mrb_sym r = mrb_intern_lit(p->mrb, "*"); - mrb_sym b = mrb_intern_lit(p->mrb, "&"); + mrb_sym r = MRB_OPSYM(mul); + mrb_sym b = MRB_OPSYM(and); if (local_var_p(p, r) && local_var_p(p, b)) { $$ = cons(list1(new_splat(p, new_lvar(p, r))), new_block_arg(p, new_lvar(p, b))); diff --git a/src/array.c b/src/array.c index 567ed7d8b..02d792657 100644 --- a/src/array.c +++ b/src/array.c @@ -1086,7 +1086,7 @@ mrb_ary_splat(mrb_state *mrb, mrb_value v) return mrb_obj_value(a); } - if (!mrb_respond_to(mrb, v, mrb_intern_lit(mrb, "to_a"))) { + if (!mrb_respond_to(mrb, v, MRB_SYM(to_a))) { return mrb_ary_new_from_values(mrb, 1, &v); } @@ -1314,7 +1314,7 @@ init_ary_each(mrb_state *mrb, struct RClass *ary) each_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5); 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[2] = MRB_OPSYM(aref); each_irep->syms[3] = MRB_SYM(call); each_irep->syms[4] = MRB_SYM(length); each_irep->slen = 5; diff --git a/src/kernel.c b/src/kernel.c index e192ed752..d2074c16b 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_intern_lit(mrb, "==="); + mrb_sym eqq = MRB_OPSYM(eqq); mrb_value ary; if (mrb_array_p(self)) { diff --git a/src/proc.c b/src/proc.c index 743e9610c..bb678558d 100644 --- a/src/proc.c +++ b/src/proc.c @@ -326,7 +326,7 @@ mrb_init_proc(mrb_state *mrb) irep_obj->data = NULL; MRB_METHOD_FROM_PROC(m, p); 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_method_raw(mrb, mrb->proc_class, MRB_OPSYM(aref), m); mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.2.6 */ mrb_define_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.3.27 */ diff --git a/src/vm.c b/src/vm.c index d032f2794..5c305908e 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2142,7 +2142,7 @@ RETRY_TRY_BLOCK: OP_MATH_CASE_STRING_##op_name(); \ default: \ c = 1; \ - mid = mrb_intern_lit(mrb, MRB_STRINGIZE(OP_MATH_OP_##op_name)); \ + mid = MRB_OPSYM(op_name); \ goto L_SEND_SYM; \ } \ NEXT; @@ -2229,7 +2229,7 @@ RETRY_TRY_BLOCK: #endif default: c = 1; - mid = mrb_intern_lit(mrb, "/"); + mid = MRB_OPSYM(div); goto L_SEND_SYM; } @@ -2255,7 +2255,7 @@ RETRY_TRY_BLOCK: default: \ SET_INT_VALUE(regs[a+1], b); \ c = 1; \ - mid = mrb_intern_lit(mrb, MRB_STRINGIZE(OP_MATH_OP_##op_name)); \ + mid = MRB_OPSYM(op_name); \ goto L_SEND_SYM; \ } \ NEXT; @@ -2292,7 +2292,7 @@ RETRY_TRY_BLOCK: #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1])) #ifdef MRB_WITHOUT_FLOAT -#define OP_CMP(op) do {\ +#define OP_CMP(op,sym) do {\ int result;\ /* need to check if - is overridden */\ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\ @@ -2301,7 +2301,7 @@ RETRY_TRY_BLOCK: break;\ default:\ c = 1;\ - mid = mrb_intern_lit(mrb, # op);\ + mid = MRB_OPSYM(sym);\ goto L_SEND_SYM;\ }\ if (result) {\ @@ -2312,7 +2312,7 @@ RETRY_TRY_BLOCK: }\ } while(0) #else -#define OP_CMP(op) do {\ +#define OP_CMP(op, sym) do {\ int result;\ /* need to check if - is overridden */\ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\ @@ -2330,7 +2330,7 @@ RETRY_TRY_BLOCK: break;\ default:\ c = 1;\ - mid = mrb_intern_lit(mrb, # op);\ + mid = MRB_OPSYM(sym);\ goto L_SEND_SYM;\ }\ if (result) {\ @@ -2347,28 +2347,28 @@ RETRY_TRY_BLOCK: SET_TRUE_VALUE(regs[a]); } else { - OP_CMP(==); + OP_CMP(==,eq); } NEXT; } CASE(OP_LT, B) { - OP_CMP(<); + OP_CMP(<,lt); NEXT; } CASE(OP_LE, B) { - OP_CMP(<=); + OP_CMP(<=,le); NEXT; } CASE(OP_GT, B) { - OP_CMP(>); + OP_CMP(>,gt); NEXT; } CASE(OP_GE, B) { - OP_CMP(>=); + OP_CMP(>=,ge); NEXT; } -- cgit v1.2.3 From 68f8d73308fce7acca3605858fa2755185844b76 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 15 May 2020 18:05:12 +0900 Subject: Use `MRB_QSYM()` instead of `MRB_OPSYM()`. --- mrbgems/mruby-compiler/core/codegen.c | 8 ++-- mrbgems/mruby-compiler/core/parse.y | 74 +++++++++++++++++------------------ src/array.c | 2 +- src/proc.c | 2 +- src/vm.c | 10 ++--- 5 files changed, 48 insertions(+), 48 deletions(-) (limited to 'src/vm.c') diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index eae1895a6..980906e38 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1742,7 +1742,7 @@ codegen(codegen_scope *s, node *tree, int val) 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_OPSYM(eqq)), 1); + genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_QSYM(eqq)), 1); } } else { @@ -2545,7 +2545,7 @@ codegen(codegen_scope *s, node *tree, int val) default: if (val) { - int sym = new_sym(s, MRB_OPSYM(minus)); + int sym = new_sym(s, MRB_QSYM(minus)); codegen(s, tree, VAL); pop(); genop_3(s, OP_SEND, cursp(), sym, 0); @@ -2637,7 +2637,7 @@ codegen(codegen_scope *s, node *tree, int val) } push(); /* for block */ pop_n(3); - sym = new_sym(s, MRB_OPSYM(tick)); /* ` */ + sym = new_sym(s, MRB_QSYM(tick)); /* ` */ genop_3(s, OP_SEND, cursp(), sym, 1); if (val) push(); mrb_gc_arena_restore(s->mrb, ai); @@ -2657,7 +2657,7 @@ codegen(codegen_scope *s, node *tree, int val) genop_2(s, OP_STRING, cursp(), off); push(); push(); pop_n(3); - sym = new_sym(s, MRB_OPSYM(tick)); /* ` */ + sym = new_sym(s, MRB_QSYM(tick)); /* ` */ genop_3(s, OP_SEND, cursp(), sym, 1); if (val) push(); mrb_gc_arena_restore(s->mrb, ai); diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 806032e22..e0adbfc4b 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_OPSYM(and)); + local_add_f(p, blk ? blk : MRB_QSYM(and)); } static void local_add_kw(parser_state *p, mrb_sym kwd) { /* allocate register for keywords hash */ - local_add_f(p, kwd ? kwd : MRB_OPSYM(pow)); + local_add_f(p, kwd ? kwd : MRB_QSYM(pow)); } static node* @@ -1671,7 +1671,7 @@ command_asgn : lhs '=' command_rhs } | primary_value '[' opt_call_args ']' tOP_ASGN command_rhs { - $$ = new_op_asgn(p, new_call(p, $1, MRB_OPSYM(aref), $3, '.'), $5, $6); + $$ = new_op_asgn(p, new_call(p, $1, MRB_QSYM(aref), $3, '.'), $5, $6); } | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs { @@ -1902,7 +1902,7 @@ mlhs_node : variable } | primary_value '[' opt_call_args ']' { - $$ = new_call(p, $1, MRB_OPSYM(aref), $3, '.'); + $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.'); } | primary_value call_op tIDENTIFIER { @@ -1941,7 +1941,7 @@ lhs : variable } | primary_value '[' opt_call_args ']' { - $$ = new_call(p, $1, MRB_OPSYM(aref), $3, '.'); + $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.'); } | primary_value call_op tIDENTIFIER { @@ -2029,36 +2029,36 @@ undef_list : fsym } ; -op : '|' { $$ = MRB_OPSYM(or); } - | '^' { $$ = MRB_OPSYM(xor); } - | '&' { $$ = MRB_OPSYM(and); } - | tCMP { $$ = MRB_OPSYM(cmp); } - | tEQ { $$ = MRB_OPSYM(eq); } - | tEQQ { $$ = MRB_OPSYM(eqq); } - | tMATCH { $$ = MRB_OPSYM(match); } - | tNMATCH { $$ = MRB_OPSYM(nmatch); } - | '>' { $$ = MRB_OPSYM(gt); } - | tGEQ { $$ = MRB_OPSYM(ge); } - | '<' { $$ = MRB_OPSYM(lt); } - | tLEQ { $$ = MRB_OPSYM(le); } - | tNEQ { $$ = MRB_OPSYM(neq); } - | tLSHFT { $$ = MRB_OPSYM(lshift); } - | tRSHFT { $$ = MRB_OPSYM(rshift); } - | '+' { $$ = MRB_OPSYM(add); } - | '-' { $$ = MRB_OPSYM(sub); } - | '*' { $$ = MRB_OPSYM(mul); } - | tSTAR { $$ = MRB_OPSYM(mul); } - | '/' { $$ = MRB_OPSYM(div); } - | '%' { $$ = MRB_OPSYM(mod); } - | tPOW { $$ = MRB_OPSYM(pow); } - | tDSTAR { $$ = MRB_OPSYM(pow); } - | '!' { $$ = MRB_OPSYM(not); } - | '~' { $$ = MRB_OPSYM(neg); } - | tUPLUS { $$ = MRB_OPSYM(plus); } - | tUMINUS { $$ = MRB_OPSYM(minus); } - | tAREF { $$ = MRB_OPSYM(aref); } - | tASET { $$ = MRB_OPSYM(aset); } - | '`' { $$ = MRB_OPSYM(tick); } +op : '|' { $$ = MRB_QSYM(or); } + | '^' { $$ = MRB_QSYM(xor); } + | '&' { $$ = MRB_QSYM(and); } + | tCMP { $$ = MRB_QSYM(cmp); } + | tEQ { $$ = MRB_QSYM(eq); } + | tEQQ { $$ = MRB_QSYM(eqq); } + | tMATCH { $$ = MRB_QSYM(match); } + | tNMATCH { $$ = MRB_QSYM(nmatch); } + | '>' { $$ = MRB_QSYM(gt); } + | tGEQ { $$ = MRB_QSYM(ge); } + | '<' { $$ = MRB_QSYM(lt); } + | tLEQ { $$ = MRB_QSYM(le); } + | tNEQ { $$ = MRB_QSYM(neq); } + | tLSHFT { $$ = MRB_QSYM(lshift); } + | tRSHFT { $$ = MRB_QSYM(rshift); } + | '+' { $$ = MRB_QSYM(add); } + | '-' { $$ = MRB_QSYM(sub); } + | '*' { $$ = MRB_QSYM(mul); } + | tSTAR { $$ = MRB_QSYM(mul); } + | '/' { $$ = MRB_QSYM(div); } + | '%' { $$ = MRB_QSYM(mod); } + | tPOW { $$ = MRB_QSYM(pow); } + | tDSTAR { $$ = MRB_QSYM(pow); } + | '!' { $$ = MRB_QSYM(not); } + | '~' { $$ = MRB_QSYM(neg); } + | tUPLUS { $$ = MRB_QSYM(plus); } + | tUMINUS { $$ = MRB_QSYM(minus); } + | tAREF { $$ = MRB_QSYM(aref); } + | tASET { $$ = MRB_QSYM(aset); } + | '`' { $$ = MRB_QSYM(tick); } ; reswords : keyword__LINE__ | keyword__FILE__ | keyword__ENCODING__ @@ -2288,8 +2288,8 @@ paren_args : '(' opt_call_args ')' | '(' tDOT3 rparen { #if 1 - mrb_sym r = MRB_OPSYM(mul); - mrb_sym b = MRB_OPSYM(and); + mrb_sym r = MRB_QSYM(mul); + mrb_sym b = MRB_QSYM(and); if (local_var_p(p, r) && local_var_p(p, b)) { $$ = cons(list1(new_splat(p, new_lvar(p, r))), new_block_arg(p, new_lvar(p, b))); diff --git a/src/array.c b/src/array.c index 02d792657..5a4639da7 100644 --- a/src/array.c +++ b/src/array.c @@ -1314,7 +1314,7 @@ init_ary_each(mrb_state *mrb, struct RClass *ary) each_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5); each_irep->syms[0] = MRB_SYM(each); each_irep->syms[1] = MRB_SYM(to_enum); - each_irep->syms[2] = MRB_OPSYM(aref); + each_irep->syms[2] = MRB_QSYM(aref); each_irep->syms[3] = MRB_SYM(call); each_irep->syms[4] = MRB_SYM(length); each_irep->slen = 5; diff --git a/src/proc.c b/src/proc.c index bb678558d..36e7a5652 100644 --- a/src/proc.c +++ b/src/proc.c @@ -326,7 +326,7 @@ mrb_init_proc(mrb_state *mrb) irep_obj->data = NULL; MRB_METHOD_FROM_PROC(m, p); mrb_define_method_raw(mrb, mrb->proc_class, MRB_SYM(call), m); - mrb_define_method_raw(mrb, mrb->proc_class, MRB_OPSYM(aref), m); + mrb_define_method_raw(mrb, mrb->proc_class, MRB_QSYM(aref), m); mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.2.6 */ mrb_define_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.3.27 */ diff --git a/src/vm.c b/src/vm.c index 5c305908e..2e96cd0dc 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2142,7 +2142,7 @@ RETRY_TRY_BLOCK: OP_MATH_CASE_STRING_##op_name(); \ default: \ c = 1; \ - mid = MRB_OPSYM(op_name); \ + mid = MRB_QSYM(op_name); \ goto L_SEND_SYM; \ } \ NEXT; @@ -2229,7 +2229,7 @@ RETRY_TRY_BLOCK: #endif default: c = 1; - mid = MRB_OPSYM(div); + mid = MRB_QSYM(div); goto L_SEND_SYM; } @@ -2255,7 +2255,7 @@ RETRY_TRY_BLOCK: default: \ SET_INT_VALUE(regs[a+1], b); \ c = 1; \ - mid = MRB_OPSYM(op_name); \ + mid = MRB_QSYM(op_name); \ goto L_SEND_SYM; \ } \ NEXT; @@ -2301,7 +2301,7 @@ RETRY_TRY_BLOCK: break;\ default:\ c = 1;\ - mid = MRB_OPSYM(sym);\ + mid = MRB_QSYM(sym);\ goto L_SEND_SYM;\ }\ if (result) {\ @@ -2330,7 +2330,7 @@ RETRY_TRY_BLOCK: break;\ default:\ c = 1;\ - mid = MRB_OPSYM(sym);\ + mid = MRB_QSYM(sym);\ goto L_SEND_SYM;\ }\ if (result) {\ -- cgit v1.2.3 From dcd3e5907ca830f118bf7b55bbf1b1210a67385d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 27 May 2020 23:22:28 +0900 Subject: Define a new function `mrb_funcall_id()`. `mrb_funcall_id()` takes `mrb_sym` instead of `char*` for a method name. You can use `MRB_SYM()`/`MRB_QSYM()` to specify the method to call. --- include/mruby.h | 41 ++++++++++++++++++++++++++++++++++++----- src/vm.c | 19 +++++++++++++++++++ 2 files changed, 55 insertions(+), 5 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby.h b/include/mruby.h index 148addf36..bbd6789c9 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1030,6 +1030,36 @@ MRB_API mrb_value mrb_get_arg1(mrb_state *mrb); * @return [mrb_value] mruby function value. */ MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc, ...); +/** + * Call existing ruby functions. + * + * Example: + * + * #include + * #include + * #include "mruby/compile.h" + * + * int + * main() + * { + * mrb_state *mrb = mrb_open(); + * + * if (!mrb) { } + * FILE *fp = fopen("test.rb","r"); + * mrb_value obj = mrb_load_file(mrb,fp); + * mrb_funcall_id(mrb, obj, MRB_SYM(method_name), 1, mrb_fixnum_value(i)); + * fclose(fp); + * mrb_close(mrb); + * } + * + * @param mrb The current mruby state. + * @param val A reference to an mruby value. + * @param name The symbol representing the method. + * @param argc The number of arguments the method has. + * @param ... Variadic values(not type safe!). + * @return [mrb_value] mruby function value. + */ +MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb_int argc, ...); /** * Call existing ruby functions. This is basically the type safe version of mrb_funcall. * @@ -1039,15 +1069,14 @@ MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, m * int * main() * { - * mrb_int i = 99; * mrb_state *mrb = mrb_open(); + * mrb_value obj = mrb_fixnum_value(1); * * if (!mrb) { } - * mrb_sym m_sym = mrb_intern_lit(mrb, "method_name"); // Symbol for method. * * FILE *fp = fopen("test.rb","r"); * mrb_value obj = mrb_load_file(mrb,fp); - * mrb_funcall_argv(mrb, obj, m_sym, 1, &obj); // Calling ruby function from test.rb. + * mrb_funcall_argv(mrb, obj, MRB_SYM(method_name), 1, &obj); // Calling ruby function from test.rb. * fclose(fp); * mrb_close(mrb); * } @@ -1065,7 +1094,7 @@ MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name, */ MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv, mrb_value block); /** - * Create a symbol + * Create a symbol from C string. But usually it's better to use MRB_SYM(sym) and MRB_QSYM(qsym). * * Example: * @@ -1073,7 +1102,9 @@ MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym * :pizza # => :pizza * * // C style: - * mrb_sym m_sym = mrb_intern_lit(mrb, "pizza"); // => :pizza + * mrb_sym sym1 = mrb_intern_lit(mrb, "pizza"); // => :pizza + * mrb_sym sym2 = MRB_SYM(pizza); // => :pizza + * mrb_sym sym3 = MRB_SYM(pizza_p); // => :pizza? * * @param mrb The current mruby state. * @param str The string to be symbolized diff --git a/src/vm.c b/src/vm.c index 2e96cd0dc..5543496c1 100644 --- a/src/vm.c +++ b/src/vm.c @@ -401,6 +401,25 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...) return mrb_funcall_argv(mrb, self, mid, argc, argv); } +MRB_API mrb_value +mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, ...) +{ + mrb_value argv[MRB_FUNCALL_ARGC_MAX]; + va_list ap; + mrb_int i; + + if (argc > MRB_FUNCALL_ARGC_MAX) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=" MRB_STRINGIZE(MRB_FUNCALL_ARGC_MAX) ")"); + } + + va_start(ap, argc); + for (i = 0; i < argc; i++) { + argv[i] = va_arg(ap, mrb_value); + } + va_end(ap); + return mrb_funcall_argv(mrb, self, mid, argc, argv); +} + static int ci_nregs(mrb_callinfo *ci) { -- cgit v1.2.3 From b67955b8caeff907e577005ffedc6553db5415cc Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 4 Jun 2020 10:04:08 +0900 Subject: Change the arguments of following implicit conversion functions: - `mrb_convert_type` - `mrb_check_convert_type` Those function no longer take `tname` string representation of desired type, and take method symbols instead of `const char*` names. This is incompatible change. I hope no third-party gems use those functions. --- include/mruby.h | 4 +- mrbgems/mruby-kernel-ext/src/kernel.c | 4 +- src/object.c | 149 ++++++++++++++++++---------------- src/string.c | 2 +- src/vm.c | 4 +- 5 files changed, 84 insertions(+), 79 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby.h b/include/mruby.h index 9411f9f00..769f9734c 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1252,12 +1252,12 @@ MRB_API void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic* } while (0) MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*); -MRB_API mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method); +MRB_API mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method); MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj); MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj); MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj); MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c); -MRB_API mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method); +MRB_API mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method); MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c); MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self); MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self); diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index 8d9a3fab7..70991c704 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -151,7 +151,7 @@ mrb_f_string(mrb_state *mrb, mrb_value self) mrb_value arg = mrb_get_arg1(mrb); mrb_value tmp; - tmp = mrb_convert_type(mrb, arg, MRB_TT_STRING, "String", "to_s"); + tmp = mrb_convert_type(mrb, arg, MRB_TT_STRING, MRB_SYM(to_s)); return tmp; } @@ -170,7 +170,7 @@ mrb_f_array(mrb_state *mrb, mrb_value self) mrb_value arg = mrb_get_arg1(mrb); mrb_value tmp; - tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, "Array", "to_a"); + tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, MRB_SYM(to_a)); if (mrb_nil_p(tmp)) { return mrb_ary_new_from_values(mrb, 1, &arg); } diff --git a/src/object.c b/src/object.c index 2ef6228e8..fd1f9e215 100644 --- a/src/object.c +++ b/src/object.c @@ -315,110 +315,115 @@ mrb_init_object(mrb_state *mrb) mrb_define_method(mrb, f, "inspect", false_to_s, MRB_ARGS_NONE()); } -static mrb_value -convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *method, mrb_bool raise) +static const struct types { + const enum mrb_vtype type; + const char *name; +} builtin_types[] = { +/* {MRB_TT_NIL, "nil"}, */ + {MRB_TT_FALSE, "false"}, + {MRB_TT_TRUE, "true"}, + {MRB_TT_FIXNUM, "Fixnum"}, + {MRB_TT_SYMBOL, "Symbol"}, /* :symbol */ + {MRB_TT_MODULE, "Module"}, + {MRB_TT_OBJECT, "Object"}, + {MRB_TT_CLASS, "Class"}, + {MRB_TT_ICLASS, "iClass"}, /* internal use: mixed-in module holder */ + {MRB_TT_SCLASS, "SClass"}, + {MRB_TT_PROC, "Proc"}, +#ifndef MRB_WITHOUT_FLOAT + {MRB_TT_FLOAT, "Float"}, +#endif + {MRB_TT_ARRAY, "Array"}, + {MRB_TT_HASH, "Hash"}, + {MRB_TT_STRING, "String"}, + {MRB_TT_RANGE, "Range"}, +/* {MRB_TT_BIGNUM, "Bignum"}, */ + {MRB_TT_DATA, "Data"}, /* internal use: wrapped C pointers */ +/* {MRB_TT_UNDEF, "undef"}, */ /* internal use: #undef; should not happen */ + {MRB_TT_MAXDEFINE, 0} +}; + +static const char* +type_name(enum mrb_vtype t) { - mrb_sym m = 0; + const struct types *type = builtin_types; + + while (type->type < MRB_TT_MAXDEFINE) { + if (type->type == t) return type->name; + type++; + } + return NULL; +} - m = mrb_intern_cstr(mrb, method); - if (!mrb_respond_to(mrb, val, m)) { +static mrb_value +convert_type(mrb_state *mrb, mrb_value val, const char *tname, mrb_sym method, mrb_bool raise) +{ + if (!mrb_respond_to(mrb, val, method)) { if (raise) { - mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into %s", val, tname); + if (tname) mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into %s", val, tname); + mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y", val); } return mrb_nil_value(); } - return mrb_funcall_argv(mrb, val, m, 0, 0); + return mrb_funcall_argv(mrb, val, method, 0, 0); } MRB_API mrb_value -mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method) +mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method) { mrb_value v; + const char *tname; if (mrb_type(val) == type) return val; + tname = type_name(type); v = convert_type(mrb, val, tname, method, TRUE); if (mrb_type(v) != type) { if (type == MRB_TT_STRING) return mrb_any_to_s(mrb, val); - mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%s", val, tname, method); + mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%n", val, tname, method); } return v; } MRB_API mrb_value -mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method) +mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method) { mrb_value v; if (mrb_type(val) == type && type != MRB_TT_DATA && type != MRB_TT_ISTRUCT) return val; - v = convert_type(mrb, val, tname, method, FALSE); + v = convert_type(mrb, val, type_name(type), method, FALSE); if (mrb_nil_p(v) || mrb_type(v) != type) return mrb_nil_value(); return v; } -static const struct types { - unsigned char type; - const char *name; -} builtin_types[] = { -/* {MRB_TT_NIL, "nil"}, */ - {MRB_TT_FALSE, "false"}, - {MRB_TT_TRUE, "true"}, - {MRB_TT_FIXNUM, "Fixnum"}, - {MRB_TT_SYMBOL, "Symbol"}, /* :symbol */ - {MRB_TT_MODULE, "Module"}, - {MRB_TT_OBJECT, "Object"}, - {MRB_TT_CLASS, "Class"}, - {MRB_TT_ICLASS, "iClass"}, /* internal use: mixed-in module holder */ - {MRB_TT_SCLASS, "SClass"}, - {MRB_TT_PROC, "Proc"}, -#ifndef MRB_WITHOUT_FLOAT - {MRB_TT_FLOAT, "Float"}, -#endif - {MRB_TT_ARRAY, "Array"}, - {MRB_TT_HASH, "Hash"}, - {MRB_TT_STRING, "String"}, - {MRB_TT_RANGE, "Range"}, -/* {MRB_TT_BIGNUM, "Bignum"}, */ - {MRB_TT_DATA, "Data"}, /* internal use: wrapped C pointers */ -/* {MRB_TT_VARMAP, "Varmap"}, */ /* internal use: dynamic variables */ -/* {MRB_TT_NODE, "Node"}, */ /* internal use: syntax tree node */ -/* {MRB_TT_UNDEF, "undef"}, */ /* internal use: #undef; should not happen */ - {MRB_TT_MAXDEFINE, 0} -}; - MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t) { - const struct types *type = builtin_types; - enum mrb_vtype xt; - - xt = mrb_type(x); - if ((xt != t) || (xt == MRB_TT_DATA) || (xt == MRB_TT_ISTRUCT)) { - while (type->type < MRB_TT_MAXDEFINE) { - if (type->type == t) { - const char *etype; - - if (mrb_nil_p(x)) { - etype = "nil"; - } - else if (mrb_fixnum_p(x)) { - etype = "Fixnum"; - } - else if (mrb_symbol_p(x)) { - etype = "Symbol"; - } - else if (mrb_immediate_p(x)) { - etype = RSTRING_PTR(mrb_obj_as_string(mrb, x)); - } - else { - etype = mrb_obj_classname(mrb, x); - } - mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)", - etype, type->name); - } - type++; - } - mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %d (%d given)", t, mrb_type(x)); + enum mrb_vtype xt = mrb_type(x); + const char *tname, *ename; + + if (t == xt) return; + + tname = type_name(t); + if (mrb_nil_p(x)) { + ename = "nil"; + } + else if (mrb_fixnum_p(x)) { + ename = "Fixnum"; + } + else if (mrb_symbol_p(x)) { + ename = "Symbol"; + } + else if (mrb_immediate_p(x)) { + ename = RSTRING_PTR(mrb_obj_as_string(mrb, x)); + } + else { + ename = mrb_obj_classname(mrb, x); + } + if (tname) { + mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)", + ename, tname); } + mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %d (%s given)", t, ename); } /* 15.3.1.3.46 */ @@ -579,7 +584,7 @@ mrb_Float(mrb_state *mrb, mrb_value val) return mrb_float_value(mrb, mrb_str_to_dbl(mrb, val, TRUE)); default: - return mrb_convert_type(mrb, val, MRB_TT_FLOAT, "Float", "to_f"); + return mrb_convert_type(mrb, val, MRB_TT_FLOAT, MRB_SYM(to_f)); } } #endif diff --git a/src/string.c b/src/string.c index c83e791b6..97795221c 100644 --- a/src/string.c +++ b/src/string.c @@ -1126,7 +1126,7 @@ mrb_str_to_str(mrb_state *mrb, mrb_value str) case MRB_TT_MODULE: return mrb_mod_to_s(mrb, str); default: - return mrb_convert_type(mrb, str, MRB_TT_STRING, "String", "to_s"); + return mrb_convert_type(mrb, str, MRB_TT_STRING, MRB_SYM(to_s)); } } diff --git a/src/vm.c b/src/vm.c index 5543496c1..689c5b85e 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1375,7 +1375,7 @@ RETRY_TRY_BLOCK: recv = regs[a]; blk = regs[bidx]; if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) { - blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, "Proc", "to_proc"); + blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); /* The stack might have been reallocated during mrb_convert_type(), see #3622 */ regs[bidx] = blk; @@ -1557,7 +1557,7 @@ RETRY_TRY_BLOCK: } blk = regs[bidx]; if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) { - blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, "Proc", "to_proc"); + blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); /* The stack or ci stack might have been reallocated during mrb_convert_type(), see #3622 and #3784 */ regs[bidx] = blk; -- cgit v1.2.3 From 5a3e014e4914dbd6421dbbd81e889cd6952e924b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 5 Jun 2020 07:43:40 +0900 Subject: Constify `irep` members. - `pool` - `syms` - `reps` --- include/mruby/debug.h | 2 +- include/mruby/dump.h | 6 +- include/mruby/irep.h | 9 +- include/mruby/proc.h | 6 +- mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c | 4 +- mrbgems/mruby-compiler/core/codegen.c | 159 +++++++++++++++++-------------- mrbgems/mruby-compiler/core/parse.y | 2 +- mrbgems/mruby-compiler/core/y.tab.c | 2 +- mrbgems/mruby-metaprog/src/metaprog.c | 2 +- mrbgems/mruby-proc-ext/src/proc.c | 4 +- src/array.c | 14 +-- src/backtrace.c | 2 +- src/class.c | 8 +- src/codedump.c | 12 +-- src/debug.c | 2 +- src/dump.c | 54 +++++------ src/gc.c | 2 +- src/load.c | 59 ++++++------ src/proc.c | 10 +- src/state.c | 21 ++-- src/vm.c | 12 +-- 21 files changed, 212 insertions(+), 180 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby/debug.h b/include/mruby/debug.h index 5c5d56924..f22c7c77b 100644 --- a/include/mruby/debug.h +++ b/include/mruby/debug.h @@ -46,7 +46,7 @@ typedef struct mrb_irep_debug_info { * get line from irep's debug info and program counter * @return returns NULL if not found */ -MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc); +MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t pc); /* * get line from irep's debug info and program counter diff --git a/include/mruby/dump.h b/include/mruby/dump.h index db3e287d3..2fa5e4d3c 100644 --- a/include/mruby/dump.h +++ b/include/mruby/dump.h @@ -18,10 +18,10 @@ MRB_BEGIN_DECL #define DUMP_DEBUG_INFO 1 -int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size); +int mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size); #ifndef MRB_DISABLE_STDIO -int mrb_dump_irep_binary(mrb_state*, mrb_irep*, uint8_t, FILE*); -int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, uint8_t flags, FILE *f, const char *initname); +int mrb_dump_irep_binary(mrb_state*, const mrb_irep*, uint8_t, FILE*); +int mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname); mrb_irep *mrb_read_irep_file(mrb_state*, FILE*); MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*); MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*); diff --git a/include/mruby/irep.h b/include/mruby/irep.h index 661ef2b48..6633bc73e 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -33,11 +33,11 @@ typedef struct mrb_irep { uint8_t flags; const mrb_code *iseq; - mrb_value *pool; - mrb_sym *syms; - struct mrb_irep **reps; + const mrb_value *pool; + const mrb_sym *syms; + const struct mrb_irep **reps; - struct mrb_locals *lv; + const struct mrb_locals *lv; /* debug info */ struct mrb_irep_debug_info* debug_info; @@ -46,6 +46,7 @@ typedef struct mrb_irep { } mrb_irep; #define MRB_ISEQ_NO_FREE 1 +#define MRB_IREP_NO_FREE 2 MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb); diff --git a/include/mruby/proc.h b/include/mruby/proc.h index 12013c3ae..2d06210ef 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -41,7 +41,7 @@ void mrb_env_unshare(mrb_state*, struct REnv*); struct RProc { MRB_OBJECT_HEADER; union { - mrb_irep *irep; + const mrb_irep *irep; mrb_func_t func; } body; struct RProc *upper; @@ -86,8 +86,8 @@ struct RProc { #define mrb_proc_ptr(v) ((struct RProc*)(mrb_ptr(v))) -struct RProc *mrb_proc_new(mrb_state*, mrb_irep*); -struct RProc *mrb_closure_new(mrb_state*, mrb_irep*); +struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*); +struct RProc *mrb_closure_new(mrb_state*, const mrb_irep*); MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t); MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals); void mrb_proc_copy(struct RProc *a, struct RProc *b); diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c index 4d984e773..5cd9a27fc 100644 --- a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c +++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c @@ -238,10 +238,10 @@ static int dump_file(mrb_state *mrb, FILE *wfp, const char *outfile, struct RProc *proc, struct mrbc_args *args) { int n = MRB_DUMP_OK; - mrb_irep *irep = proc->body.irep; + const mrb_irep *irep = proc->body.irep; if (args->remove_lv) { - mrb_irep_remove_lv(mrb, irep); + mrb_irep_remove_lv(mrb, (mrb_irep*)irep); } if (args->initname) { n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname); diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index b8dd55bd4..64dcff340 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -70,6 +70,9 @@ typedef struct scope { uint32_t icapa; mrb_irep *irep; + mrb_value *pool; + mrb_sym *syms; + mrb_irep **reps; uint32_t pcapa, scapa, rcapa; uint16_t nlocals; @@ -98,10 +101,22 @@ static void raise_error(codegen_scope *s, const char *msg); static void codegen_error(codegen_scope *s, const char *message) { + int i; + if (!s) return; while (s->prev) { codegen_scope *tmp = s->prev; mrb_free(s->mrb, s->iseq); + mrb_free(s->mrb, s->pool); + mrb_free(s->mrb, s->syms); + if (s->reps) { + /* copied from mrb_irep_free() in state.c */ + for (i=0; iirep->rlen; i++) { + if (s->reps[i]) + mrb_irep_decref(s->mrb, (mrb_irep*)s->reps[i]); + } + mrb_free(s->mrb, s->reps); + } mrb_free(s->mrb, s->lines); mrb_pool_close(s->mpool); s = tmp; @@ -545,7 +560,7 @@ new_lit(codegen_scope *s, mrb_value val) case MRB_TT_STRING: for (i=0; iirep->plen; i++) { mrb_int len; - pv = &s->irep->pool[i]; + pv = &s->pool[i]; if (!mrb_string_p(*pv)) continue; if ((len = RSTRING_LEN(*pv)) != RSTRING_LEN(val)) continue; @@ -557,7 +572,7 @@ new_lit(codegen_scope *s, mrb_value val) case MRB_TT_FLOAT: for (i=0; iirep->plen; i++) { mrb_float f1, f2; - pv = &s->irep->pool[i]; + pv = &s->pool[i]; if (!mrb_float_p(*pv)) continue; f1 = mrb_float(*pv); f2 = mrb_float(val); @@ -567,7 +582,7 @@ new_lit(codegen_scope *s, mrb_value val) #endif case MRB_TT_FIXNUM: for (i=0; iirep->plen; i++) { - pv = &s->irep->pool[i]; + pv = &s->pool[i]; if (!mrb_fixnum_p(*pv)) continue; if (mrb_fixnum(*pv) == mrb_fixnum(val)) return i; } @@ -579,10 +594,10 @@ new_lit(codegen_scope *s, mrb_value val) if (s->irep->plen == s->pcapa) { s->pcapa *= 2; - s->irep->pool = (mrb_value *)codegen_realloc(s, s->irep->pool, sizeof(mrb_value)*s->pcapa); + s->pool = (mrb_value *)codegen_realloc(s, s->pool, sizeof(mrb_value)*s->pcapa); } - pv = &s->irep->pool[s->irep->plen]; + pv = &s->pool[s->irep->plen]; i = s->irep->plen++; switch (mrb_type(val)) { @@ -620,13 +635,13 @@ new_sym(codegen_scope *s, mrb_sym sym) len = s->irep->slen; for (i=0; iirep->syms[i] == sym) return i; + if (s->syms[i] == sym) return i; } if (s->irep->slen >= s->scapa) { s->scapa *= 2; - s->irep->syms = (mrb_sym*)codegen_realloc(s, s->irep->syms, sizeof(mrb_sym)*s->scapa); + s->syms = (mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->scapa); } - s->irep->syms[s->irep->slen] = sym; + s->syms[s->irep->slen] = sym; return s->irep->slen++; } @@ -681,7 +696,7 @@ search_upvar(codegen_scope *s, mrb_sym id, int *idx) if (lv < 1) lv = 1; u = s->parser->upper; while (u && !MRB_PROC_CFUNC_P(u)) { - struct mrb_irep *ir = u->body.irep; + const struct mrb_irep *ir = u->body.irep; uint_fast16_t n = ir->nlocals; const struct mrb_locals *v = ir->lv; for (; n > 1; n --, v ++) { @@ -2993,91 +3008,92 @@ scope_add_irep(codegen_scope *s, mrb_irep *irep) } if (s->irep->rlen == s->rcapa) { s->rcapa *= 2; - s->irep->reps = (mrb_irep**)codegen_realloc(s, s->irep->reps, sizeof(mrb_irep*)*s->rcapa); + s->reps = (mrb_irep**)codegen_realloc(s, s->reps, sizeof(mrb_irep*)*s->rcapa); } - s->irep->reps[s->irep->rlen] = irep; + s->reps[s->irep->rlen] = irep; s->irep->rlen++; } static codegen_scope* -scope_new(mrb_state *mrb, codegen_scope *prev, node *lv) +scope_new(mrb_state *mrb, codegen_scope *prev, node *nlv) { static const codegen_scope codegen_scope_zero = { 0 }; mrb_pool *pool = mrb_pool_open(mrb); - codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope)); + codegen_scope *s = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope)); - if (!p) { + if (!s) { if (prev) codegen_error(prev, "unexpected scope"); return NULL; } - *p = codegen_scope_zero; - p->mrb = mrb; - p->mpool = pool; - if (!prev) return p; - p->prev = prev; - p->ainfo = -1; - p->mscope = 0; - - p->irep = mrb_add_irep(mrb); - scope_add_irep(prev, p->irep); - - p->rcapa = 8; - p->irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*p->rcapa); - - p->icapa = 1024; - p->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*p->icapa); - p->irep->iseq = NULL; - - p->pcapa = 32; - p->irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa); - p->irep->plen = 0; - - p->scapa = 256; - p->irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*p->scapa); - p->irep->slen = 0; - - p->lv = lv; - p->sp += node_len(lv)+1; /* add self */ - p->nlocals = p->sp; - if (lv) { - node *n = lv; + *s = codegen_scope_zero; + s->mrb = mrb; + s->mpool = pool; + if (!prev) return s; + s->prev = prev; + s->ainfo = -1; + s->mscope = 0; + + s->irep = mrb_add_irep(mrb); + scope_add_irep(prev, s->irep); + + s->rcapa = 8; + s->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*s->rcapa); + + s->icapa = 1024; + s->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*s->icapa); + s->irep->iseq = NULL; + + s->pcapa = 32; + s->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*s->pcapa); + s->irep->plen = 0; + + s->scapa = 256; + s->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*s->scapa); + s->irep->slen = 0; + + s->lv = nlv; + s->sp += node_len(nlv)+1; /* add self */ + s->nlocals = s->sp; + if (nlv) { + struct mrb_locals *lv; + node *n = nlv; size_t i = 0; - p->irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (p->nlocals - 1)); - for (i=0, n=lv; n; i++,n=n->cdr) { - p->irep->lv[i].name = lv_name(n); + s->irep->lv = lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals)*(s->nlocals-1)); + for (i=0, n=nlv; n; i++,n=n->cdr) { + lv[i].name = lv_name(n); if (lv_name(n)) { - p->irep->lv[i].r = lv_idx(p, lv_name(n)); + lv[i].r = lv_idx(s, lv_name(n)); } else { - p->irep->lv[i].r = 0; + lv[i].r = 0; } } - mrb_assert(i + 1 == p->nlocals); + mrb_assert(i + 1 == s->nlocals); } - p->ai = mrb_gc_arena_save(mrb); + s->ai = mrb_gc_arena_save(mrb); - p->filename_sym = prev->filename_sym; - if (p->filename_sym) { - p->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*p->icapa); + s->filename_sym = prev->filename_sym; + if (s->filename_sym) { + s->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*s->icapa); } - p->lineno = prev->lineno; + s->lineno = prev->lineno; /* debug setting */ - p->debug_start_pos = 0; - if (p->filename_sym) { - mrb_debug_info_alloc(mrb, p->irep); + s->debug_start_pos = 0; + if (s->filename_sym) { + mrb_debug_info_alloc(mrb, s->irep); } else { - p->irep->debug_info = NULL; + s->irep->debug_info = NULL; } - p->parser = prev->parser; - p->filename_index = prev->filename_index; + s->parser = prev->parser; + s->filename_index = prev->filename_index; - p->rlev = prev->rlev+1; + s->rlev = prev->rlev+1; - return p; + return s; } static void @@ -3091,12 +3107,12 @@ scope_finish(codegen_scope *s) } irep->flags = 0; if (s->iseq) { - irep->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc); + irep->iseq = (const mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc); irep->ilen = s->pc; } - irep->pool = (mrb_value*)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen); - irep->syms = (mrb_sym*)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen); - irep->reps = (mrb_irep**)codegen_realloc(s, irep->reps, sizeof(mrb_irep*)*irep->rlen); + irep->pool = (const mrb_value*)codegen_realloc(s, s->pool, sizeof(mrb_value)*irep->plen); + irep->syms = (const mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*irep->slen); + irep->reps = (const mrb_irep**)codegen_realloc(s, s->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_sym_name_len(s->mrb, fname, NULL); @@ -3242,13 +3258,14 @@ mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep) { int i; + if (irep->flags & MRB_IREP_NO_FREE) return; if (irep->lv) { - mrb_free(mrb, irep->lv); + mrb_free(mrb, (void*)irep->lv); irep->lv = NULL; } - + if (!irep->reps) return; for (i = 0; i < irep->rlen; ++i) { - mrb_irep_remove_lv(mrb, irep->reps[i]); + mrb_irep_remove_lv(mrb, (mrb_irep*)irep->reps[i]); } } diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 70988d13f..b758a259d 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -279,7 +279,7 @@ local_var_p(parser_state *p, mrb_sym sym) u = p->upper; while (u && !MRB_PROC_CFUNC_P(u)) { - struct mrb_irep *ir = u->body.irep; + const struct mrb_irep *ir = u->body.irep; uint_fast16_t n = ir->nlocals; const struct mrb_locals *v = ir->lv; for (; n > 1; n --, v ++) { diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 7df922575..5c66a18a6 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -342,7 +342,7 @@ local_var_p(parser_state *p, mrb_sym sym) u = p->upper; while (u && !MRB_PROC_CFUNC_P(u)) { - struct mrb_irep *ir = u->body.irep; + const struct mrb_irep *ir = u->body.irep; uint_fast16_t n = ir->nlocals; const struct mrb_locals *v = ir->lv; for (; n > 1; n --, v ++) { diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c index 01cf723fb..8a4a6dc69 100644 --- a/mrbgems/mruby-metaprog/src/metaprog.c +++ b/mrbgems/mruby-metaprog/src/metaprog.c @@ -133,7 +133,7 @@ static mrb_value mrb_local_variables(mrb_state *mrb, mrb_value self) { struct RProc *proc; - mrb_irep *irep; + const mrb_irep *irep; mrb_value vars; size_t i; diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c index 5343c478f..a2f3ad101 100644 --- a/mrbgems/mruby-proc-ext/src/proc.c +++ b/mrbgems/mruby-proc-ext/src/proc.c @@ -21,7 +21,7 @@ mrb_proc_source_location(mrb_state *mrb, mrb_value self) return mrb_nil_value(); } else { - mrb_irep *irep = p->body.irep; + const mrb_irep *irep = p->body.irep; int32_t line; const char *filename; @@ -41,7 +41,7 @@ mrb_proc_inspect(mrb_state *mrb, mrb_value self) mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self))); if (!MRB_PROC_CFUNC_P(p)) { - mrb_irep *irep = p->body.irep; + const mrb_irep *irep = p->body.irep; const char *filename; int32_t line; mrb_str_cat_lit(mrb, str, "@"); diff --git a/src/array.c b/src/array.c index 71a957c9e..1337736f4 100644 --- a/src/array.c +++ b/src/array.c @@ -1309,14 +1309,16 @@ init_ary_each(mrb_state *mrb, struct RClass *ary) mrb_method_t m; mrb_irep *each_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep)); static const mrb_irep mrb_irep_zero = { 0 }; + mrb_sym *syms; *each_irep = mrb_irep_zero; - each_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5); - each_irep->syms[0] = MRB_SYM(each); - each_irep->syms[1] = MRB_SYM(to_enum); - each_irep->syms[2] = MRB_QSYM(aref); - each_irep->syms[3] = MRB_SYM(call); - each_irep->syms[4] = MRB_SYM(length); + syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5); + syms[0] = MRB_SYM(each); + syms[1] = MRB_SYM(to_enum); + syms[2] = MRB_QSYM(aref); + syms[3] = MRB_SYM(call); + syms[4] = MRB_SYM(length); + each_irep->syms = syms; each_irep->slen = 5; each_irep->flags = MRB_ISEQ_NO_FREE; each_irep->iseq = each_iseq; diff --git a/src/backtrace.c b/src/backtrace.c index b614a04be..bcc188796 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -39,7 +39,7 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, const mrb_code *pc0, each_backtr for (i=ciidx; i >= 0; i--) { struct backtrace_location loc; mrb_callinfo *ci; - mrb_irep *irep; + const mrb_irep *irep; const mrb_code *pc; ci = &mrb->c->cibase[i]; diff --git a/src/class.c b/src/class.c index 2864fdda9..daba6f649 100644 --- a/src/class.c +++ b/src/class.c @@ -2315,12 +2315,14 @@ init_class_new(mrb_state *mrb, struct RClass *cls) struct RProc *p; mrb_method_t m; mrb_irep *new_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep)); + mrb_sym *syms; static const mrb_irep mrb_irep_zero = { 0 }; *new_irep = mrb_irep_zero; - new_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*2); - new_irep->syms[0] = MRB_SYM(allocate); - new_irep->syms[1] = MRB_SYM(initialize); + syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*2); + syms[0] = MRB_SYM(allocate); + syms[1] = MRB_SYM(initialize); + new_irep->syms = syms; new_irep->slen = 2; new_irep->flags = MRB_ISEQ_NO_FREE; new_irep->iseq = new_iseq; diff --git a/src/codedump.c b/src/codedump.c index 649be176b..14cca8553 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -7,7 +7,7 @@ #ifndef MRB_DISABLE_STDIO static void -print_r(mrb_state *mrb, mrb_irep *irep, size_t n) +print_r(mrb_state *mrb, const mrb_irep *irep, size_t n) { size_t i; @@ -23,7 +23,7 @@ print_r(mrb_state *mrb, mrb_irep *irep, size_t n) } static void -print_lv_a(mrb_state *mrb, mrb_irep *irep, uint16_t a) +print_lv_a(mrb_state *mrb, const mrb_irep *irep, uint16_t a) { if (!irep->lv || a >= irep->nlocals || a == 0) { printf("\n"); @@ -35,7 +35,7 @@ print_lv_a(mrb_state *mrb, mrb_irep *irep, uint16_t a) } static void -print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b) +print_lv_ab(mrb_state *mrb, const mrb_irep *irep, uint16_t a, uint16_t b) { if (!irep->lv || (a >= irep->nlocals && b >= irep->nlocals) || a+b == 0) { printf("\n"); @@ -48,7 +48,7 @@ print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b) } static void -print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i) +print_header(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t i) { int32_t line; @@ -66,7 +66,7 @@ print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i) #define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn static void -codedump(mrb_state *mrb, mrb_irep *irep) +codedump(mrb_state *mrb, const mrb_irep *irep) { int ai; const mrb_code *pc, *pcend; @@ -533,7 +533,7 @@ codedump(mrb_state *mrb, mrb_irep *irep) } static void -codedump_recur(mrb_state *mrb, mrb_irep *irep) +codedump_recur(mrb_state *mrb, const mrb_irep *irep) { int i; diff --git a/src/debug.c b/src/debug.c index 32add68ae..dabc5a56d 100644 --- a/src/debug.c +++ b/src/debug.c @@ -51,7 +51,7 @@ select_line_type(const uint16_t *lines, size_t lines_len) } MRB_API char const* -mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc) +mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t pc) { if (irep && pc >= 0 && pc < irep->ilen) { mrb_irep_debug_info_file* f = NULL; diff --git a/src/dump.c b/src/dump.c index a6bbe68f3..770c133fb 100644 --- a/src/dump.c +++ b/src/dump.c @@ -21,7 +21,7 @@ #endif #endif -static size_t get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep); +static size_t get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep); #if UINT32_MAX > SIZE_MAX # error This code cannot be built on your environment. @@ -50,7 +50,7 @@ get_irep_header_size(mrb_state *mrb) } static ptrdiff_t -write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) +write_irep_header(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) { uint8_t *cur = buf; @@ -64,7 +64,7 @@ write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) static size_t -get_iseq_block_size(mrb_state *mrb, mrb_irep *irep) +get_iseq_block_size(mrb_state *mrb, const mrb_irep *irep) { size_t size = 0; @@ -76,7 +76,7 @@ get_iseq_block_size(mrb_state *mrb, mrb_irep *irep) } static ptrdiff_t -write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags) +write_iseq_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf, uint8_t flags) { uint8_t *cur = buf; @@ -102,7 +102,7 @@ float_to_str(mrb_state *mrb, mrb_value flt) #endif static size_t -get_pool_block_size(mrb_state *mrb, mrb_irep *irep) +get_pool_block_size(mrb_state *mrb, const mrb_irep *irep) { int pool_no; size_t size = 0; @@ -153,7 +153,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep) } static ptrdiff_t -write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) +write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) { int pool_no; uint8_t *cur = buf; @@ -207,7 +207,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) static size_t -get_syms_block_size(mrb_state *mrb, mrb_irep *irep) +get_syms_block_size(mrb_state *mrb, const mrb_irep *irep) { size_t size = 0; int sym_no; @@ -226,7 +226,7 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep) } static ptrdiff_t -write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) +write_syms_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) { int sym_no; uint8_t *cur = buf; @@ -255,7 +255,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf) } static size_t -get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep) +get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep) { size_t size = 0; @@ -267,7 +267,7 @@ get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep) } static size_t -get_irep_record_size(mrb_state *mrb, mrb_irep *irep) +get_irep_record_size(mrb_state *mrb, const mrb_irep *irep) { size_t size = 0; int irep_no; @@ -280,7 +280,7 @@ get_irep_record_size(mrb_state *mrb, mrb_irep *irep) } static int -write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags) +write_irep_record(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags) { int i; uint8_t *src = bin; @@ -341,7 +341,7 @@ write_section_irep_header(mrb_state *mrb, size_t section_size, uint8_t *bin) } static int -write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags) +write_section_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags) { int result; size_t rsize = 0; @@ -364,7 +364,7 @@ write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p, } static size_t -get_debug_record_size(mrb_state *mrb, mrb_irep *irep) +get_debug_record_size(mrb_state *mrb, const mrb_irep *irep) { size_t ret = 0; uint16_t f_idx; @@ -413,11 +413,11 @@ find_filename_index(const mrb_sym *ary, int ary_len, mrb_sym s) } static size_t -get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *lp) +get_filename_table_size(mrb_state *mrb, const mrb_irep *irep, mrb_sym **fp, uint16_t *lp) { mrb_sym *filenames = *fp; size_t size = 0; - mrb_irep_debug_info *di = irep->debug_info; + const mrb_irep_debug_info *di = irep->debug_info; int i; mrb_assert(lp); @@ -444,7 +444,7 @@ get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t * } static size_t -write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len) +write_debug_record_1(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len) { uint8_t *cur; uint16_t f_idx; @@ -498,7 +498,7 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const } static size_t -write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len) +write_debug_record(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len) { size_t size, len; int irep_no; @@ -516,7 +516,7 @@ write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* } static int -write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len) +write_section_debug(mrb_state *mrb, const mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len) { size_t section_size = 0; const uint8_t *bin = cur; @@ -632,7 +632,7 @@ write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym c } static size_t -get_lv_record_size(mrb_state *mrb, mrb_irep *irep) +get_lv_record_size(mrb_state *mrb, const mrb_irep *irep) { size_t ret = 0; int i; @@ -647,7 +647,7 @@ get_lv_record_size(mrb_state *mrb, mrb_irep *irep) } static size_t -get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len) +get_lv_section_size(mrb_state *mrb, const mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len) { size_t ret = 0, i; @@ -665,7 +665,7 @@ get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_ } static int -write_section_lv(mrb_state *mrb, mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len) +write_section_lv(mrb_state *mrb, const mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len) { uint8_t *cur = start; struct rite_section_lv_header *header; @@ -721,7 +721,7 @@ write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8 } static mrb_bool -debug_info_defined_p(mrb_irep *irep) +debug_info_defined_p(const mrb_irep *irep) { int i; @@ -733,7 +733,7 @@ debug_info_defined_p(mrb_irep *irep) } static mrb_bool -lv_defined_p(mrb_irep *irep) +lv_defined_p(const mrb_irep *irep) { int i; @@ -747,7 +747,7 @@ lv_defined_p(mrb_irep *irep) } static int -dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size) +dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size) { int result = MRB_DUMP_GENERAL_FAILURE; size_t malloc_size; @@ -835,7 +835,7 @@ error_exit: } int -mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size) +mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size) { return dump_irep(mrb, irep, flags, bin, bin_size); } @@ -843,7 +843,7 @@ mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size #ifndef MRB_DISABLE_STDIO int -mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp) +mrb_dump_irep_binary(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE* fp) { uint8_t *bin = NULL; size_t bin_size = 0; @@ -865,7 +865,7 @@ mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp) } int -mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname) +mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname) { uint8_t *bin = NULL; size_t bin_size = 0, bin_idx = 0; diff --git a/src/gc.c b/src/gc.c index 5531207db..897fa256f 100644 --- a/src/gc.c +++ b/src/gc.c @@ -868,7 +868,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end) struct RProc *p = (struct RProc*)obj; if (!MRB_PROC_CFUNC_P(p) && p->body.irep) { - mrb_irep *irep = p->body.irep; + mrb_irep *irep = (mrb_irep*)p->body.irep; if (end) { mrb_irep_cutref(mrb, irep); } diff --git a/src/load.c b/src/load.c index 247d511df..b033d7ad1 100644 --- a/src/load.c +++ b/src/load.c @@ -73,6 +73,8 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag uint16_t tt, pool_data_len, snl; int plen; struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type); + mrb_value *pool; + mrb_sym *syms; mrb_irep *irep = mrb_add_irep(mrb); int ai = mrb_gc_arena_save(mrb); @@ -124,7 +126,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) { return NULL; } - irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen); + irep->pool = pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen); for (i = 0; i < plen; i++) { const char *s; @@ -139,26 +141,26 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag case IREP_TT_FIXNUM: { mrb_value num = mrb_str_len_to_inum(mrb, s, pool_data_len, 10, FALSE); #ifdef MRB_WITHOUT_FLOAT - irep->pool[i] = num; + pool[i] = num; #else - irep->pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num; + pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num; #endif } break; #ifndef MRB_WITHOUT_FLOAT case IREP_TT_FLOAT: - irep->pool[i] = mrb_float_pool(mrb, str_to_double(mrb, s, pool_data_len)); + pool[i] = mrb_float_pool(mrb, str_to_double(mrb, s, pool_data_len)); break; #endif case IREP_TT_STRING: - irep->pool[i] = mrb_str_pool(mrb, s, pool_data_len, st); + pool[i] = mrb_str_pool(mrb, s, pool_data_len, st); break; default: /* should not happen */ - irep->pool[i] = mrb_nil_value(); + pool[i] = mrb_nil_value(); break; } irep->plen++; @@ -173,22 +175,22 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) { return NULL; } - irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen); + irep->syms = syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen); for (i = 0; i < irep->slen; i++) { snl = bin_to_uint16(src); /* symbol name length */ src += sizeof(uint16_t); if (snl == MRB_DUMP_NULL_SYM_LEN) { - irep->syms[i] = 0; + syms[i] = 0; continue; } if (flags & FLAG_SRC_MALLOC) { - irep->syms[i] = mrb_intern(mrb, (char *)src, snl); + syms[i] = mrb_intern(mrb, (char *)src, snl); } else { - irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl); + syms[i] = mrb_intern_static(mrb, (char *)src, snl); } src += snl + 1; @@ -196,8 +198,6 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag } } - irep->reps = (mrb_irep**)mrb_calloc(mrb, irep->rlen, sizeof(mrb_irep*)); - diff = src - bin; mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX); *len = (size_t)diff; @@ -214,21 +214,24 @@ read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags) int ai = mrb_gc_arena_save(mrb); mrb_irep *irep = read_irep_record_1(mrb, bin, len, flags); int i; + mrb_irep **reps; mrb_gc_arena_restore(mrb, ai); if (irep == NULL) { return NULL; } + reps = (mrb_irep**)mrb_calloc(mrb, irep->rlen, sizeof(mrb_irep*)); + irep->reps = (const mrb_irep**)reps; irep_obj->data = irep; bin += *len; for (i=0; irlen; i++) { size_t rlen; - irep->reps[i] = read_irep_record(mrb, bin, &rlen, flags); + reps[i] = read_irep_record(mrb, bin, &rlen, flags); mrb_gc_arena_restore(mrb, ai); - if (irep->reps[i] == NULL) { + if (reps[i] == NULL) { return NULL; } bin += rlen; @@ -257,25 +260,26 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * size_t record_size; uint16_t f_idx; int i; + mrb_irep_debug_info *debug; if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; } - irep->debug_info = (mrb_irep_debug_info*)mrb_calloc(mrb, 1, sizeof(mrb_irep_debug_info)); - irep->debug_info->pc_count = (uint32_t)irep->ilen; + irep->debug_info = debug = (mrb_irep_debug_info*)mrb_calloc(mrb, 1, sizeof(mrb_irep_debug_info)); + debug->pc_count = (uint32_t)irep->ilen; record_size = (size_t)bin_to_uint32(bin); bin += sizeof(uint32_t); - irep->debug_info->flen = bin_to_uint16(bin); - irep->debug_info->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*)); + debug->flen = bin_to_uint16(bin); + debug->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*)); bin += sizeof(uint16_t); - for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { + for (f_idx = 0; f_idx < debug->flen; ++f_idx) { mrb_irep_debug_info_file *file; uint16_t filename_idx; file = (mrb_irep_debug_info_file *)mrb_calloc(mrb, 1, sizeof(*file)); - irep->debug_info->files[f_idx] = file; + debug->files[f_idx] = file; file->start_pos = bin_to_uint32(bin); bin += sizeof(uint32_t); @@ -329,7 +333,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * size_t len; int ret; - ret = read_debug_record(mrb, bin, irep->reps[i], &len, filenames, filenames_len); + ret = read_debug_record(mrb, bin, (mrb_irep*)irep->reps[i], &len, filenames, filenames_len); if (ret != MRB_DUMP_OK) return ret; bin += len; } @@ -393,25 +397,26 @@ static int read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *record_len, mrb_sym const *syms, uint32_t syms_len) { const uint8_t *bin = start; + struct mrb_locals *lv; ptrdiff_t diff; int i; - irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1)); + irep->lv = lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1)); for (i = 0; i + 1< irep->nlocals; ++i) { uint16_t const sym_idx = bin_to_uint16(bin); bin += sizeof(uint16_t); if (sym_idx == RITE_LV_NULL_MARK) { - irep->lv[i].name = 0; - irep->lv[i].r = 0; + lv[i].name = 0; + lv[i].r = 0; } else { if (sym_idx >= syms_len) { return MRB_DUMP_GENERAL_FAILURE; } - irep->lv[i].name = syms[sym_idx]; + lv[i].name = syms[sym_idx]; - irep->lv[i].r = bin_to_uint16(bin); + lv[i].r = bin_to_uint16(bin); } bin += sizeof(uint16_t); } @@ -420,7 +425,7 @@ read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *rec size_t len; int ret; - ret = read_lv_record(mrb, bin, irep->reps[i], &len, syms, syms_len); + ret = read_lv_record(mrb, bin, (mrb_irep*)irep->reps[i], &len, syms, syms_len); if (ret != MRB_DUMP_OK) return ret; bin += len; } diff --git a/src/proc.c b/src/proc.c index 36e7a5652..2a980620b 100644 --- a/src/proc.c +++ b/src/proc.c @@ -15,7 +15,7 @@ static const mrb_code call_iseq[] = { }; struct RProc* -mrb_proc_new(mrb_state *mrb, mrb_irep *irep) +mrb_proc_new(mrb_state *mrb, const mrb_irep *irep) { struct RProc *p; mrb_callinfo *ci = mrb->c->ci; @@ -34,7 +34,7 @@ mrb_proc_new(mrb_state *mrb, mrb_irep *irep) p->e.target_class = tc; } p->body.irep = irep; - mrb_irep_incref(mrb, irep); + mrb_irep_incref(mrb, (mrb_irep*)irep); return p; } @@ -90,7 +90,7 @@ closure_setup(mrb_state *mrb, struct RProc *p) } struct RProc* -mrb_closure_new(mrb_state *mrb, mrb_irep *irep) +mrb_closure_new(mrb_state *mrb, const mrb_irep *irep) { struct RProc *p = mrb_proc_new(mrb, irep); @@ -181,7 +181,7 @@ mrb_proc_copy(struct RProc *a, struct RProc *b) a->flags = b->flags; a->body = b->body; if (!MRB_PROC_CFUNC_P(a) && a->body.irep) { - a->body.irep->refcnt++; + mrb_irep_incref(NULL, (mrb_irep*)a->body.irep); } a->upper = b->upper; a->e.env = b->e.env; @@ -262,7 +262,7 @@ proc_lambda(mrb_state *mrb, mrb_value self) mrb_int mrb_proc_arity(const struct RProc *p) { - struct mrb_irep *irep; + const mrb_irep *irep; const mrb_code *pc; mrb_aspec aspec; int ma, op, ra, pa, arity; diff --git a/src/state.c b/src/state.c index 790f7ca13..323532363 100644 --- a/src/state.c +++ b/src/state.c @@ -107,12 +107,14 @@ void mrb_free_symtbl(mrb_state *mrb); void mrb_irep_incref(mrb_state *mrb, mrb_irep *irep) { + if (irep->flags & MRB_IREP_NO_FREE) return; irep->refcnt++; } void mrb_irep_decref(mrb_state *mrb, mrb_irep *irep) { + if (irep->flags & MRB_IREP_NO_FREE) return; irep->refcnt--; if (irep->refcnt == 0) { mrb_irep_free(mrb, irep); @@ -122,12 +124,14 @@ mrb_irep_decref(mrb_state *mrb, mrb_irep *irep) void mrb_irep_cutref(mrb_state *mrb, mrb_irep *irep) { - mrb_irep *tmp; + mrb_irep **reps; int i; + if (irep->flags & MRB_IREP_NO_FREE) return; + reps = (mrb_irep**)irep->reps; for (i=0; irlen; i++) { - tmp = irep->reps[i]; - irep->reps[i] = NULL; + mrb_irep *tmp = reps[i]; + reps[i] = NULL; if (tmp) mrb_irep_decref(mrb, tmp); } } @@ -137,6 +141,7 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep) { int i; + if (irep->flags & MRB_IREP_NO_FREE) return; if (!(irep->flags & MRB_ISEQ_NO_FREE)) mrb_free(mrb, (void*)irep->iseq); if (irep->pool) for (i=0; iplen; i++) { @@ -150,16 +155,16 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep) } #endif } - mrb_free(mrb, irep->pool); - mrb_free(mrb, irep->syms); + mrb_free(mrb, (void*)irep->pool); + mrb_free(mrb, (void*)irep->syms); if (irep->reps) { for (i=0; irlen; i++) { if (irep->reps[i]) - mrb_irep_decref(mrb, irep->reps[i]); + mrb_irep_decref(mrb, (mrb_irep*)irep->reps[i]); } + mrb_free(mrb, (void*)irep->reps); } - mrb_free(mrb, irep->reps); - mrb_free(mrb, irep->lv); + mrb_free(mrb, (void*)irep->lv); mrb_debug_info_free(mrb, irep->debug_info); mrb_free(mrb, irep); } diff --git a/src/vm.c b/src/vm.c index 689c5b85e..064086fb9 100644 --- a/src/vm.c +++ b/src/vm.c @@ -920,7 +920,7 @@ argnum_error(mrb_state *mrb, mrb_int num) MRB_API mrb_value mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep) { - mrb_irep *irep = proc->body.irep; + const mrb_irep *irep = proc->body.irep; mrb_value result; struct mrb_context *c = mrb->c; ptrdiff_t cioff = c->ci - c->cibase; @@ -965,9 +965,9 @@ mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *pc) { /* mrb_assert(MRB_PROC_CFUNC_P(proc)) */ const mrb_code *pc0 = pc; - mrb_irep *irep = proc->body.irep; - mrb_value *pool = irep->pool; - mrb_sym *syms = irep->syms; + const mrb_irep *irep = proc->body.irep; + const mrb_value *pool = irep->pool; + const mrb_sym *syms = irep->syms; mrb_code insn; int ai = mrb_gc_arena_save(mrb); struct mrb_jmpbuf *prev_jmp = mrb->jmp; @@ -2549,7 +2549,7 @@ RETRY_TRY_BLOCK: L_MAKE_LAMBDA: { struct RProc *p; - mrb_irep *nirep = irep->reps[b]; + const mrb_irep *nirep = irep->reps[b]; if (c & OP_L_CAPTURE) { p = mrb_closure_new(mrb, nirep); @@ -2627,7 +2627,7 @@ RETRY_TRY_BLOCK: CASE(OP_EXEC, BB) { mrb_value recv = regs[a]; struct RProc *p; - mrb_irep *nirep = irep->reps[b]; + const mrb_irep *nirep = irep->reps[b]; /* prepare closure */ p = mrb_proc_new(mrb, nirep); -- cgit v1.2.3 From d428fa0c4acfe4f70ab534d420052c193bd83281 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 9 Jun 2020 14:39:38 +0900 Subject: Replace entire `irep->pool`. Changes: - `pool format is completely replaced - supported types: `STR`, `INT32`, `INT64`, `FLOAT` - `FLOAT` may be replaced by binary representation in the future - insert `NUL` after string literals in `mrb` files - `irep->pool` no longer store values in `mrb_value` - instead it stores in `mrb_pool_value` - less allocation - `mrb_irep` can be stored in ROM --- include/mruby/boxing_nan.h | 2 - include/mruby/boxing_no.h | 4 -- include/mruby/boxing_word.h | 5 -- include/mruby/dump.h | 19 ------ include/mruby/irep.h | 26 +++++-- include/mruby/string.h | 10 +-- mrbgems/mruby-compiler/core/codegen.c | 62 ++++++++++++----- src/codedump.c | 37 ++++++---- src/dump.c | 123 ++++++++++++++++++++-------------- src/etc.c | 11 --- src/load.c | 77 ++++++++++++++------- src/state.c | 16 ++--- src/string.c | 26 ------- src/vm.c | 43 +++++++----- 14 files changed, 251 insertions(+), 210 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index fae3b7630..4b44bba8a 100644 --- a/include/mruby/boxing_nan.h +++ b/include/mruby/boxing_nan.h @@ -51,8 +51,6 @@ typedef struct mrb_value { }; } mrb_value; -#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f) - #define mrb_tt(o) ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14)-1) #define mrb_type(o) (enum mrb_vtype)((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT) #define mrb_ptr(o) ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2)) diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h index 7573428e6..23b48c6f8 100644 --- a/include/mruby/boxing_no.h +++ b/include/mruby/boxing_no.h @@ -24,10 +24,6 @@ typedef struct mrb_value { enum mrb_vtype tt; } mrb_value; -#ifndef MRB_WITHOUT_FLOAT -#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f) -#endif - #define mrb_ptr(o) (o).value.p #define mrb_cptr(o) mrb_ptr(o) #ifndef MRB_WITHOUT_FLOAT diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index 1b7815b7f..56202a420 100644 --- a/include/mruby/boxing_word.h +++ b/include/mruby/boxing_word.h @@ -90,11 +90,6 @@ typedef union mrb_value { MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*); #ifndef MRB_WITHOUT_FLOAT MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); -MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float); -#endif - -#ifndef MRB_WITHOUT_FLOAT -#define mrb_float_pool(mrb,f) mrb_word_boxing_float_pool(mrb,f) #endif #define mrb_ptr(o) (o).value.p diff --git a/include/mruby/dump.h b/include/mruby/dump.h index 384521c45..bad27fdf5 100644 --- a/include/mruby/dump.h +++ b/include/mruby/dump.h @@ -127,16 +127,6 @@ uint32_to_bin(uint32_t l, uint8_t *bin) return sizeof(uint32_t); } -static inline size_t -uint32l_to_bin(uint32_t l, uint8_t *bin) -{ - bin[3] = (l >> 24) & 0xff; - bin[2] = (l >> 16) & 0xff; - bin[1] = (l >> 8) & 0xff; - bin[0] = l & 0xff; - return sizeof(uint32_t); -} - static inline uint32_t bin_to_uint32(const uint8_t *bin) { @@ -146,15 +136,6 @@ bin_to_uint32(const uint8_t *bin) (uint32_t)bin[3]; } -static inline uint32_t -bin_to_uint32l(const uint8_t *bin) -{ - return (uint32_t)bin[3] << 24 | - (uint32_t)bin[2] << 16 | - (uint32_t)bin[1] << 8 | - (uint32_t)bin[0]; -} - static inline uint16_t bin_to_uint16(const uint8_t *bin) { diff --git a/include/mruby/irep.h b/include/mruby/irep.h index 9d30f2797..359fb6796 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -16,11 +16,29 @@ MRB_BEGIN_DECL enum irep_pool_type { - IREP_TT_STRING, - IREP_TT_FIXNUM, - IREP_TT_FLOAT, + IREP_TT_STR = 0, /* string (need free) */ + IREP_TT_SSTR = 2, /* string (static) */ + IREP_TT_INT32 = 1, /* 32bit integer */ + IREP_TT_INT64 = 3, /* 64bit integer */ + IREP_TT_FLOAT = 5, /* float (double/float) */ }; +#define IREP_TT_NFLAG 1 /* number (non string) flag */ +#define IREP_TT_SFLAG 2 /* static string flag */ +#define IREP_TT_SFLAG 2 /* static string flag */ + +typedef struct mrb_pool_value { + uint32_t tt; /* packed type and length (for string) */ + union { + const char *str; + int32_t i32; +#ifdef MRB_INT64 + int64_t i64; +#endif + mrb_float f; + } u; +} mrb_pool_value; + struct mrb_lvinfo { /* local variable info (name, idx) */ mrb_sym name; uint16_t r; @@ -33,7 +51,7 @@ typedef struct mrb_irep { uint8_t flags; const mrb_code *iseq; - const mrb_value *pool; + const mrb_pool_value *pool; const mrb_sym *syms; const struct mrb_irep **reps; diff --git a/include/mruby/string.h b/include/mruby/string.h index 93c94ef5d..0f1b762c1 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -92,9 +92,6 @@ struct RStringEmbed { # define RSTR_COPY_ASCII_FLAG(dst, src) (void)0 #endif -#define RSTR_POOL_P(s) ((s)->flags & MRB_STR_POOL) -#define RSTR_SET_POOL_FLAG(s) ((s)->flags |= MRB_STR_POOL) - /** * Returns a pointer from a Ruby string */ @@ -112,13 +109,11 @@ MRB_API mrb_int mrb_str_strlen(mrb_state*, struct RString*); #define MRB_STR_FSHARED 2 #define MRB_STR_NOFREE 4 #define MRB_STR_EMBED 8 /* type flags up to here */ -#define MRB_STR_POOL 16 /* status flags from here */ -#define MRB_STR_ASCII 32 +#define MRB_STR_ASCII 16 #define MRB_STR_EMBED_LEN_SHIFT 6 #define MRB_STR_EMBED_LEN_BIT 5 #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT) -#define MRB_STR_TYPE_MASK (MRB_STR_POOL - 1) - +#define MRB_STR_TYPE_MASK 15 void mrb_gc_free_str(mrb_state*, struct RString*); @@ -447,7 +442,6 @@ MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2); */ MRB_API char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str); -mrb_value mrb_str_pool(mrb_state *mrb, const char *s, mrb_int len, mrb_bool nofree); uint32_t mrb_str_hash(mrb_state *mrb, mrb_value str); mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str); diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index f8561c0e7..0000e6dbe 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -70,7 +70,7 @@ typedef struct scope { uint32_t icapa; mrb_irep *irep; - mrb_value *pool; + mrb_pool_value *pool; mrb_sym *syms; mrb_irep **reps; uint32_t pcapa, scapa, rcapa; @@ -554,17 +554,17 @@ static inline int new_lit(codegen_scope *s, mrb_value val) { int i; - mrb_value *pv; + mrb_pool_value *pv; switch (mrb_type(val)) { case MRB_TT_STRING: for (i=0; iirep->plen; i++) { mrb_int len; pv = &s->pool[i]; - - if (!mrb_string_p(*pv)) continue; - if ((len = RSTRING_LEN(*pv)) != RSTRING_LEN(val)) continue; - if (memcmp(RSTRING_PTR(*pv), RSTRING_PTR(val), len) == 0) + if (pv->tt & IREP_TT_NFLAG) continue; + len = pv->tt>>2; + if (RSTRING_LEN(val) != len) continue; + if (memcmp(pv->u.str, RSTRING_PTR(val), len) == 0) return i; } break; @@ -573,8 +573,9 @@ new_lit(codegen_scope *s, mrb_value val) for (i=0; iirep->plen; i++) { mrb_float f1, f2; pv = &s->pool[i]; - if (!mrb_float_p(*pv)) continue; - f1 = mrb_float(*pv); + if (pv->tt != IREP_TT_FLOAT) continue; + pv = &s->pool[i]; + f1 = pv->u.f; f2 = mrb_float(val); if (f1 == f2 && !signbit(f1) == !signbit(f2)) return i; } @@ -582,9 +583,17 @@ new_lit(codegen_scope *s, mrb_value val) #endif case MRB_TT_FIXNUM: for (i=0; iirep->plen; i++) { + mrb_int v = mrb_fixnum(val); pv = &s->pool[i]; - if (!mrb_fixnum_p(*pv)) continue; - if (mrb_fixnum(*pv) == mrb_fixnum(val)) return i; + if (pv->tt == IREP_TT_INT32) { + if (v == pv->u.i32) return i; + } +#ifdef MRB_INT64 + else if (pv->tt == IREP_TT_INT64) { + if (v == pv->u.i64) return i; + } + continue; +#endif } break; default: @@ -594,7 +603,7 @@ new_lit(codegen_scope *s, mrb_value val) if (s->irep->plen == s->pcapa) { s->pcapa *= 2; - s->pool = (mrb_value *)codegen_realloc(s, s->pool, sizeof(mrb_value)*s->pcapa); + s->pool = (mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*s->pcapa); } pv = &s->pool[s->irep->plen]; @@ -602,18 +611,35 @@ new_lit(codegen_scope *s, mrb_value val) switch (mrb_type(val)) { case MRB_TT_STRING: - *pv = mrb_str_pool(s->mrb, RSTRING_PTR(val), RSTRING_LEN(val), RSTR_NOFREE_P(RSTRING(val))); + if (RSTR_NOFREE_P(RSTRING(val))) { + pv->tt = (RSTRING_LEN(val)<<2) | IREP_TT_SSTR; + pv->u.str = RSTRING_PTR(val); + } + else { + char *p; + mrb_int len = RSTRING_LEN(val); + pv->tt = (len<<2) | IREP_TT_STR; + p = (char*)codegen_realloc(s, NULL, len+1); + memcpy(p, RSTRING_PTR(val), len); + p[len] = '\0'; + pv->u.str = p; + } break; #ifndef MRB_WITHOUT_FLOAT case MRB_TT_FLOAT: -#ifdef MRB_WORD_BOXING - *pv = mrb_float_pool(s->mrb, mrb_float(val)); + pv->tt = IREP_TT_FLOAT; + pv->u.f = mrb_float(val); break; -#endif #endif case MRB_TT_FIXNUM: - *pv = val; +#ifdef MRB_INT64 + pv->tt = IREP_TT_INT64; + pv->u.i64 = mrb_fixnum(val); +#else + pv->tt = IREP_TT_INT32; + pv->u.i32 = mrb_fixnum(val); +#endif break; default: @@ -3045,7 +3071,7 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *nlv) s->irep->iseq = NULL; s->pcapa = 32; - s->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*s->pcapa); + s->pool = (mrb_pool_value*)mrb_malloc(mrb, sizeof(mrb_pool_value)*s->pcapa); s->irep->plen = 0; s->scapa = 256; @@ -3110,7 +3136,7 @@ scope_finish(codegen_scope *s) irep->iseq = (const mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc); irep->ilen = s->pc; } - irep->pool = (const mrb_value*)codegen_realloc(s, s->pool, sizeof(mrb_value)*irep->plen); + irep->pool = (const mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*irep->plen); irep->syms = (const mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*irep->slen); irep->reps = (const mrb_irep**)codegen_realloc(s, s->reps, sizeof(mrb_irep*)*irep->rlen); if (s->filename_sym) { diff --git a/src/codedump.c b/src/codedump.c index 14cca8553..fd73f3104 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -115,10 +115,21 @@ codedump(mrb_state *mrb, const mrb_irep *irep) print_lv_ab(mrb, irep, a, b); break; CASE(OP_LOADL, BB): - { - mrb_value v = irep->pool[b]; - mrb_value s = mrb_inspect(mrb, v); - printf("OP_LOADL\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s)); + switch (irep->pool[b].tt) { + case IREP_TT_FLOAT: + printf("OP_LOADL\tR%d\tL(%d)\t; %f", a, b, (double)irep->pool[b].u.f); + break; + case IREP_TT_INT32: + printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId32, a, b, irep->pool[b].u.i32); + break; +#ifdef MRB_INT64 + case IREP_TT_INT64: + printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId64, a, b, irep->pool[b].u.i64); + break; +#endif + default: + printf("OP_LOADL\tR%d\tL(%d)\t", a, b); + break; } print_lv_a(mrb, irep, a); break; @@ -404,10 +415,11 @@ codedump(mrb_state *mrb, const mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_STRING, BB): - { - mrb_value v = irep->pool[b]; - mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v))); - printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s)); + if ((irep->pool[b].tt & IREP_TT_NFLAG) == 0) { + printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, irep->pool[b].u.str); + } + else { + printf("OP_STRING\tR%d\tL(%d)\t", a, b); } print_lv_a(mrb, irep, a); break; @@ -453,10 +465,11 @@ codedump(mrb_state *mrb, const mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_ERR, B): - { - mrb_value v = irep->pool[a]; - mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v))); - printf("OP_ERR\t%s\n", RSTRING_PTR(s)); + if ((irep->pool[a].tt & IREP_TT_NFLAG) == 0) { + printf("OP_ERR\t%s\n", irep->pool[a].u.str); + } + else { + printf("OP_ERR\tL(%d)\n", a); } break; CASE(OP_EPUSH, B): diff --git a/src/dump.c b/src/dump.c index 093e4c256..a1c539e50 100644 --- a/src/dump.c +++ b/src/dump.c @@ -90,14 +90,12 @@ write_iseq_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf, uint8_t fla #ifndef MRB_WITHOUT_FLOAT static mrb_value -float_to_str(mrb_state *mrb, mrb_value flt) +float_to_str(mrb_state *mrb, mrb_float f) { - mrb_float f = mrb_float(flt); - if (isinf(f)) { return f < 0 ? mrb_str_new_lit(mrb, "I") : mrb_str_new_lit(mrb, "i"); } - return mrb_float_to_str(mrb, flt, MRB_FLOAT_FMT); + return mrb_float_to_str(mrb, mrb_float_value(mrb, f), MRB_FLOAT_FMT); } #endif @@ -106,45 +104,50 @@ get_pool_block_size(mrb_state *mrb, const mrb_irep *irep) { int pool_no; size_t size = 0; - mrb_value str; - size += sizeof(uint32_t); /* plen */ - size += irep->plen * (sizeof(uint8_t) + sizeof(uint16_t)); /* len(n) */ + size += sizeof(uint16_t); /* plen */ + size += irep->plen * sizeof(uint8_t); /* len(n) */ for (pool_no = 0; pool_no < irep->plen; pool_no++) { int ai = mrb_gc_arena_save(mrb); - switch (mrb_type(irep->pool[pool_no])) { - case MRB_TT_FIXNUM: - str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10); + switch (irep->pool[pool_no].tt) { + case IREP_TT_INT64: +#ifdef MRB_INT64 { - mrb_int len = RSTRING_LEN(str); - mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX); - size += (size_t)len; + int64_t i = irep->pool[pool_no].u.i64; + + if (i < INT32_MIN || INT32_MAX < i) + size += 8; + else + size += 4; } break; +#else + /* fall through */ +#endif + case IREP_TT_INT32: + size += 4; /* 32bits = 4bytes */ + break; + case IREP_TT_FLOAT: #ifndef MRB_WITHOUT_FLOAT - case MRB_TT_FLOAT: - str = float_to_str(mrb, irep->pool[pool_no]); { + mrb_value str = float_to_str(mrb, irep->pool[pool_no].u.f); mrb_int len = RSTRING_LEN(str); mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX); size += (size_t)len; } - break; #endif + break; - case MRB_TT_STRING: + default: /* packed IREP_TT_STRING */ { - mrb_int len = RSTRING_LEN(irep->pool[pool_no]); + mrb_int len = irep->pool[pool_no].tt >> 1; /* unpack length */ mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX); - size += (size_t)len; + size += (size_t)len+1; } break; - - default: - break; } mrb_gc_arena_restore(mrb, ai); } @@ -157,48 +160,64 @@ write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) { int pool_no; uint8_t *cur = buf; - uint16_t len; - mrb_value str; - const char *char_ptr; + int len; + const char *ptr; - cur += uint32_to_bin(irep->plen, cur); /* number of pool */ + cur += uint16_to_bin(irep->plen, cur); /* number of pool */ for (pool_no = 0; pool_no < irep->plen; pool_no++) { int ai = mrb_gc_arena_save(mrb); - switch (mrb_type(irep->pool[pool_no])) { - case MRB_TT_FIXNUM: - cur += uint8_to_bin(IREP_TT_FIXNUM, cur); /* data type */ - str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10); + switch (irep->pool[pool_no].tt) { +#ifdef MRB_INT64 + case IREP_TT_INT64: + { + int64_t i = irep->pool[pool_no].u.i64; + if (i < INT32_MIN || INT32_MAX < i) { + cur += uint8_to_bin(IREP_TT_INT64, cur); /* data type */ + cur += uint32_to_bin((uint32_t)((i>>32) & 0xffffffff), cur); /* i64 hi */ + cur += uint32_to_bin((uint32_t)((i ) & 0xffffffff), cur); /* i64 lo */ + } + else { + cur += uint8_to_bin(IREP_TT_INT32, cur); /* data type */ + cur += uint32_to_bin(irep->pool[pool_no].u.i32, cur); /* i32 */ + } + } + break; +#endif + case IREP_TT_INT32: + cur += uint8_to_bin(IREP_TT_INT32, cur); /* data type */ + cur += uint32_to_bin(irep->pool[pool_no].u.i32, cur); /* i32 */ break; -#ifndef MRB_WITHOUT_FLOAT - case MRB_TT_FLOAT: + case IREP_TT_FLOAT: cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */ - str = float_to_str(mrb, irep->pool[pool_no]); - break; +#ifndef MRB_WITHOUT_FLOAT + { + mrb_value str = float_to_str(mrb, irep->pool[pool_no].u.f); + ptr = RSTRING_PTR(str); + len = RSTRING_LEN(str); + mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX); + cur += uint16_to_bin((uint16_t)len, cur); /* data length */ + memcpy(cur, ptr, (size_t)len); + cur += len; + } +#else + cur += uint16_to_bin(0, cur); /* zero length */ #endif - - case MRB_TT_STRING: - cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */ - str = irep->pool[pool_no]; break; - default: - continue; - } - - char_ptr = RSTRING_PTR(str); - { - mrb_int tlen = RSTRING_LEN(str); - mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX); - len = (uint16_t)tlen; + default: /* string */ + cur += uint8_to_bin(IREP_TT_STR, cur); /* data type */ + ptr = irep->pool[pool_no].u.str; + len = irep->pool[pool_no].tt>>2; + mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX); + cur += uint16_to_bin((uint16_t)len, cur); /* data length */ + memcpy(cur, ptr, (size_t)len); + cur += len; + *cur++ = '\0'; + break; } - - cur += uint16_to_bin(len, cur); /* data length */ - memcpy(cur, char_ptr, (size_t)len); - cur += len; - mrb_gc_arena_restore(mrb, ai); } diff --git a/src/etc.c b/src/etc.c index 74b9ab03b..99cdc0157 100644 --- a/src/etc.c +++ b/src/etc.c @@ -158,17 +158,6 @@ mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f) MRB_SET_FROZEN_FLAG(v.value.bp); return v; } - -MRB_API mrb_value -mrb_word_boxing_float_pool(mrb_state *mrb, mrb_float f) -{ - struct RFloat *nf = (struct RFloat *)mrb_malloc(mrb, sizeof(struct RFloat)); - nf->tt = MRB_TT_FLOAT; - nf->c = mrb->float_class; - nf->f = f; - MRB_SET_FROZEN_FLAG(nf); - return mrb_obj_value(nf); -} #endif /* MRB_WITHOUT_FLOAT */ #endif /* MRB_WORD_BOXING */ diff --git a/src/load.c b/src/load.c index d47027350..39644c34b 100644 --- a/src/load.c +++ b/src/load.c @@ -73,10 +73,10 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag uint16_t tt, pool_data_len, snl; int plen; struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type); - mrb_value *pool; + mrb_pool_value *pool; mrb_sym *syms; + mrb_int ai = mrb_gc_arena_save(mrb); mrb_irep *irep = mrb_add_irep(mrb); - int ai = mrb_gc_arena_save(mrb); irep_obj->data = irep; @@ -120,51 +120,81 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag } /* POOL BLOCK */ - plen = bin_to_uint32(src); /* number of pool */ - src += sizeof(uint32_t); + plen = bin_to_uint16(src); /* number of pool */ + src += sizeof(uint16_t); if (plen > 0) { if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) { return NULL; } - irep->pool = pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen); + irep->pool = pool = (mrb_pool_value*)mrb_calloc(mrb, sizeof(mrb_pool_value), plen); for (i = 0; i < plen; i++) { - const char *s; mrb_bool st = (flags & FLAG_SRC_MALLOC)==0; tt = *src++; /* pool TT */ - pool_data_len = bin_to_uint16(src); /* pool data length */ - src += sizeof(uint16_t); - s = (const char*)src; - src += pool_data_len; switch (tt) { /* pool data */ - case IREP_TT_FIXNUM: { - mrb_value num = mrb_str_len_to_inum(mrb, s, pool_data_len, 10, FALSE); -#ifdef MRB_WITHOUT_FLOAT - pool[i] = num; + case IREP_TT_INT32: + { + mrb_int v = (int32_t)bin_to_uint32(src); + src += sizeof(uint32_t); +#ifdef MRB_INT64 + pool[i].tt = IREP_TT_INT64; + pool[i].u.i64 = (int64_t)v; #else - pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num; + pool[i].tt = IREP_TT_INT32; + pool[i].u.i32 = v; #endif } break; + case IREP_TT_INT64: +#ifdef MRB_INT64 + { + uint64_t i = bin_to_uint32(src); + src += sizeof(uint32_t); + i <<= 32; + i |= bin_to_uint32(src); + src += sizeof(uint32_t); + pool[i].u.i64 = (int64_t)i; + } +#else + return NULL; /* INT64 not supported on MRB_INT32 */ +#endif + break; -#ifndef MRB_WITHOUT_FLOAT case IREP_TT_FLOAT: - pool[i] = mrb_float_pool(mrb, str_to_double(mrb, s, pool_data_len)); +#ifndef MRB_WITHOUT_FLOAT + pool[i].tt = tt; + pool_data_len = bin_to_uint16(src); /* pool data length */ + src += sizeof(uint16_t); + pool[i].u.f = str_to_double(mrb, (const char*)src, pool_data_len); + src += pool_data_len; break; +#else + return NULL; /* MRB_WITHOUT_FLOAT */ #endif - case IREP_TT_STRING: - pool[i] = mrb_str_pool(mrb, s, pool_data_len, st); + case IREP_TT_STR: + pool_data_len = bin_to_uint16(src); /* pool data length */ + src += sizeof(uint16_t); + if (st) { + pool[i].tt = (pool_data_len<<2) | IREP_TT_SSTR; + pool[i].u.str = (const char*)src; + } + else { + char *p; + pool[i].tt = (pool_data_len<<2) | IREP_TT_STR; + p = (char*)mrb_malloc(mrb, pool_data_len+1); + memcpy(p, src, pool_data_len+1); + pool[i].u.str = (const char*)p; + } + src += pool_data_len + 1; break; default: /* should not happen */ - pool[i] = mrb_nil_value(); - break; + return NULL; } - irep->plen++; - mrb_gc_arena_restore(mrb, ai); + irep->plen = i+1; } } @@ -193,7 +223,6 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag syms[i] = mrb_intern_static(mrb, (char *)src, snl); } src += snl + 1; - mrb_gc_arena_restore(mrb, ai); } } diff --git a/src/state.c b/src/state.c index 323532363..7a1283fa6 100644 --- a/src/state.c +++ b/src/state.c @@ -144,18 +144,14 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep) if (irep->flags & MRB_IREP_NO_FREE) return; if (!(irep->flags & MRB_ISEQ_NO_FREE)) mrb_free(mrb, (void*)irep->iseq); - if (irep->pool) for (i=0; iplen; i++) { - if (mrb_string_p(irep->pool[i])) { - mrb_gc_free_str(mrb, RSTRING(irep->pool[i])); - mrb_free(mrb, mrb_obj_ptr(irep->pool[i])); + if (irep->pool) { + for (i=0; iplen; i++) { + if ((irep->pool[i].tt & 3) == IREP_TT_STR) { + mrb_free(mrb, (void*)irep->pool[i].u.str); + } } -#if defined(MRB_WORD_BOXING) && !defined(MRB_WITHOUT_FLOAT) - else if (mrb_float_p(irep->pool[i])) { - mrb_free(mrb, mrb_obj_ptr(irep->pool[i])); - } -#endif + mrb_free(mrb, (void*)irep->pool); } - mrb_free(mrb, (void*)irep->pool); mrb_free(mrb, (void*)irep->syms); if (irep->reps) { for (i=0; irlen; i++) { diff --git a/src/string.c b/src/string.c index 97795221c..73e514f41 100644 --- a/src/string.c +++ b/src/string.c @@ -583,9 +583,6 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s) else if (RSTR_FSHARED_P(orig)) { str_init_fshared(orig, s, orig->as.heap.aux.fshared); } - else if (mrb_frozen_p(orig) && !RSTR_POOL_P(orig)) { - str_init_fshared(orig, s, orig); - } else { if (orig->as.heap.aux.capa > orig->as.heap.len) { orig->as.heap.ptr = (char *)mrb_realloc(mrb, orig->as.heap.ptr, len+1); @@ -596,29 +593,6 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s) } } -mrb_value -mrb_str_pool(mrb_state *mrb, const char *p, mrb_int len, mrb_bool nofree) -{ - struct RString *s = (struct RString *)mrb_malloc(mrb, sizeof(struct RString)); - - s->tt = MRB_TT_STRING; - s->c = mrb->string_class; - s->flags = 0; - - if (RSTR_EMBEDDABLE_P(len)) { - str_init_embed(s, p, len); - } - else if (nofree) { - str_init_nofree(s, p, len); - } - else { - str_init_normal(mrb, s, p, len); - } - RSTR_SET_POOL_FLAG(s); - MRB_SET_FROZEN_FLAG(s); - return mrb_obj_value(s); -} - mrb_value mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len) { diff --git a/src/vm.c b/src/vm.c index 064086fb9..c3fa12d3d 100644 --- a/src/vm.c +++ b/src/vm.c @@ -966,7 +966,7 @@ mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *pc) /* mrb_assert(MRB_PROC_CFUNC_P(proc)) */ const mrb_code *pc0 = pc; const mrb_irep *irep = proc->body.irep; - const mrb_value *pool = irep->pool; + const mrb_pool_value *pool = irep->pool; const mrb_sym *syms = irep->syms; mrb_code insn; int ai = mrb_gc_arena_save(mrb); @@ -1013,17 +1013,25 @@ RETRY_TRY_BLOCK: } CASE(OP_LOADL, BB) { -#ifdef MRB_WORD_BOXING - mrb_value val = pool[b]; -#ifndef MRB_WITHOUT_FLOAT - if (mrb_float_p(val)) { - val = mrb_float_value(mrb, mrb_float(val)); - } + switch (pool[b].tt) { /* number */ + case IREP_TT_INT32: + regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i32); + break; +#ifdef MRB_INT64 + case IREP_TT_INT64: + regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i64); + break; #endif - regs[a] = val; -#else - regs[a] = pool[b]; +#ifndef MRB_WITHOUT_FLOAT + case IREP_TT_FLOAT: + regs[a] = mrb_float_value(mrb, pool[b].u.f); + break; #endif + default: + /* should not happen (tt:string) */ + regs[a] = mrb_nil_value(); + break; + } NEXT; } @@ -2499,9 +2507,13 @@ RETRY_TRY_BLOCK: } CASE(OP_STRING, BB) { - mrb_value str = mrb_str_dup(mrb, pool[b]); - - regs[a] = str; + size_t len = pool[b].tt >> 2; + if (pool[b].tt & IREP_TT_SFLAG) { + regs[a] = mrb_str_new_static(mrb, pool[b].u.str, len); + } + else { + regs[a] = mrb_str_new(mrb, pool[b].u.str, len); + } mrb_gc_arena_restore(mrb, ai); NEXT; } @@ -2703,10 +2715,11 @@ RETRY_TRY_BLOCK: } CASE(OP_ERR, B) { - mrb_value msg = mrb_str_dup(mrb, pool[a]); + size_t len = pool[a].tt >> 2; mrb_value exc; - exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg); + mrb_assert((pool[a].tt&IREP_TT_NFLAG)==0); + exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, pool[a].u.str, len); ERR_PC_SET(mrb); mrb_exc_set(mrb, exc); goto L_RAISE; -- 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/vm.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 ee111dd175f3242649d87a4600e2bad62e8e0940 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 15 Jun 2020 08:55:48 +0900 Subject: Clarify the use of `MRB_64BIT` and `MRB_INT64` in `dump.c` and `load.c`. - `MRB_64BIT`: the size of a pointer is 64 bits - `MRB_INT64`: the size of `mrb_int` is 64 bits --- include/mruby/irep.h | 2 +- mrbgems/mruby-compiler/core/codegen.c | 2 +- src/codedump.c | 2 +- src/dump.c | 6 +++--- src/load.c | 8 ++++---- src/vm.c | 8 +++++++- 6 files changed, 17 insertions(+), 11 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby/irep.h b/include/mruby/irep.h index 64a38227c..ede6780e6 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -32,7 +32,7 @@ typedef struct mrb_pool_value { union { const char *str; int32_t i32; -#ifdef MRB_INT64 +#ifdef MRB_64BIT int64_t i64; #endif mrb_float f; diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 5d29dcb2d..25e157736 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -588,7 +588,7 @@ new_lit(codegen_scope *s, mrb_value val) if (pv->tt == IREP_TT_INT32) { if (v == pv->u.i32) return i; } -#ifdef MRB_INT64 +#ifdef MRB_64BIT else if (pv->tt == IREP_TT_INT64) { if (v == pv->u.i64) return i; } diff --git a/src/codedump.c b/src/codedump.c index fd73f3104..0e90f22db 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -122,7 +122,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) case IREP_TT_INT32: printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId32, a, b, irep->pool[b].u.i32); break; -#ifdef MRB_INT64 +#ifdef MRB_64BIT case IREP_TT_INT64: printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId64, a, b, irep->pool[b].u.i64); break; diff --git a/src/dump.c b/src/dump.c index c0c349d68..31dceb593 100644 --- a/src/dump.c +++ b/src/dump.c @@ -113,7 +113,7 @@ get_pool_block_size(mrb_state *mrb, const mrb_irep *irep) switch (irep->pool[pool_no].tt) { case IREP_TT_INT64: -#ifdef MRB_INT64 +#ifdef MRB_64BIT { int64_t i = irep->pool[pool_no].u.i64; @@ -169,7 +169,7 @@ write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) int ai = mrb_gc_arena_save(mrb); switch (irep->pool[pool_no].tt) { -#ifdef MRB_INT64 +#ifdef MRB_64BIT case IREP_TT_INT64: { int64_t i = irep->pool[pool_no].u.i64; @@ -938,7 +938,7 @@ dump_pool(mrb_state *mrb, const mrb_pool_value *p, FILE *fp) case IREP_TT_INT32: fprintf(fp, "{IREP_TT_INT32, {.i32=%"PRId32"}},\n", p->u.i32); break; -#ifdef MRB_INT64 +#ifdef MRB_64BIT case IREP_TT_INT64: fprintf(fp, "{IREP_TT_INT64, {.i64=%"PRId64"}},\n", p->u.i64); break; diff --git a/src/load.c b/src/load.c index 31059e833..766aa0648 100644 --- a/src/load.c +++ b/src/load.c @@ -137,7 +137,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag { mrb_int v = (int32_t)bin_to_uint32(src); src += sizeof(uint32_t); -#ifdef MRB_INT64 +#ifdef MRB_64BIT pool[i].tt = IREP_TT_INT64; pool[i].u.i64 = (int64_t)v; #else @@ -147,7 +147,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag } break; case IREP_TT_INT64: -#ifdef MRB_INT64 +#ifdef MRB_64BIT { uint64_t i = bin_to_uint32(src); src += sizeof(uint32_t); @@ -156,10 +156,10 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag src += sizeof(uint32_t); pool[i].u.i64 = (int64_t)i; } + break; #else - return NULL; /* INT64 not supported on MRB_INT32 */ + return NULL; /* INT64 not supported on MRB_32BIT */ #endif - break; case IREP_TT_FLOAT: #ifndef MRB_WITHOUT_FLOAT diff --git a/src/vm.c b/src/vm.c index 62805b7ed..98f17e287 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1017,10 +1017,16 @@ RETRY_TRY_BLOCK: case IREP_TT_INT32: regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i32); break; -#ifdef MRB_INT64 case IREP_TT_INT64: +#if defined(MRB_INT64) && defined(MRB_64BIT) regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i64); break; +#else + { + mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "integer overflow"); + mrb_exc_set(mrb, exc); + } + goto L_RAISE; #endif #ifndef MRB_WITHOUT_FLOAT case IREP_TT_FLOAT: -- cgit v1.2.3 From fd10c7231906ca48cb35892d2a86460004b62249 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 5 Jun 2020 19:17:33 +0900 Subject: Remove `OP_EXT[123]` from operands. --- doc/opcode.md | 11 -- include/mruby/opcode.h | 27 ---- include/mruby/ops.h | 3 - mrbgems/mruby-compiler/core/codegen.c | 88 +------------ src/codedump.c | 239 +++++++++++++++------------------- src/vm.c | 37 +----- 6 files changed, 112 insertions(+), 293 deletions(-) (limited to 'src/vm.c') diff --git a/doc/opcode.md b/doc/opcode.md index a79453e8a..d5b71d9f0 100644 --- a/doc/opcode.md +++ b/doc/opcode.md @@ -20,14 +20,6 @@ sign) of operands. * sS: signed 16bit * W: 24bit -First two byte operands may be extended to 16bit. When those byte -operands are bigger than 256, the instruction will be prefixed by -`OP_EXT1` (means 1st operand is 16bit) or `OP_EXT2` (means 2nd operand -is 16bit) or `OP_EXT3` (means 1st and 2nd operands are 16bit). - -For instructions marked by `'`, `OP_EXT1` can be prefixed. For those -with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed. - ## table.1 Instruction Table | Instruction Name | Operand type | Semantics | @@ -133,8 +125,5 @@ with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed. | OP_TCLASS' | B | R(a) = target_class | | OP_DEBUG" | BBB | print a,b,c | | OP_ERR' | B | raise(LocalJumpError, Lit(a)) | -| OP_EXT1 | - | make 1st operand 16bit | -| OP_EXT2 | - | make 2nd operand 16bit | -| OP_EXT3 | - | make 1st and 2nd operands 16bit | | OP_STOP | - | stop VM | |------------------|--------------|--------------------------------------------------------| diff --git a/include/mruby/opcode.h b/include/mruby/opcode.h index 95e6736a4..a6c636cf8 100644 --- a/include/mruby/opcode.h +++ b/include/mruby/opcode.h @@ -39,31 +39,4 @@ enum mrb_insn { #define FETCH_S() do {a=READ_S();} while (0) #define FETCH_W() do {a=READ_W();} while (0) -/* with OP_EXT1 (1st 16bit) */ -#define FETCH_Z_1() FETCH_Z() -#define FETCH_B_1() FETCH_S() -#define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0) -#define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0) -#define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0) -#define FETCH_S_1() FETCH_S() -#define FETCH_W_1() FETCH_W() - -/* with OP_EXT2 (2nd 16bit) */ -#define FETCH_Z_2() FETCH_Z() -#define FETCH_B_2() FETCH_B() -#define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0) -#define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0) -#define FETCH_BS_2() FETCH_BS() -#define FETCH_S_2() FETCH_S() -#define FETCH_W_2() FETCH_W() - -/* with OP_EXT3 (1st & 2nd 16bit) */ -#define FETCH_Z_3() FETCH_Z() -#define FETCH_B_3() FETCH_B() -#define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0) -#define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0) -#define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0) -#define FETCH_S_3() FETCH_S() -#define FETCH_W_3() FETCH_W() - #endif /* MRUBY_OPCODE_H */ diff --git a/include/mruby/ops.h b/include/mruby/ops.h index e85ee3133..de6106796 100644 --- a/include/mruby/ops.h +++ b/include/mruby/ops.h @@ -111,8 +111,5 @@ OPCODE(SCLASS, B) /* R(a) = R(a).singleton_class */ OPCODE(TCLASS, B) /* R(a) = target_class */ OPCODE(DEBUG, BBB) /* print a,b,c */ OPCODE(ERR, B) /* raise(LocalJumpError, Lit(a)) */ -OPCODE(EXT1, Z) /* make 1st operand 16bit */ -OPCODE(EXT2, Z) /* make 2nd operand 16bit */ -OPCODE(EXT3, Z) /* make 1st and 2nd operands 16bit */ OPCODE(STOP, Z) /* stop VM */ OPCODE(LOADI16, BS) /* R(a) = mrb_int(b) */ diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 189bb95b8..9da80536b 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -217,9 +217,7 @@ genop_1(codegen_scope *s, mrb_code i, uint16_t a) { s->lastpc = s->pc; if (a > 0xff) { - gen_B(s, OP_EXT1); - gen_B(s, i); - gen_S(s, a); + codegen_error(s, "too big operand"); } else { gen_B(s, i); @@ -231,23 +229,8 @@ static void genop_2(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b) { s->lastpc = s->pc; - if (a > 0xff && b > 0xff) { - gen_B(s, OP_EXT3); - gen_B(s, i); - gen_S(s, a); - gen_S(s, b); - } - else if (b > 0xff) { - gen_B(s, OP_EXT2); - gen_B(s, i); - gen_B(s, (uint8_t)a); - gen_S(s, b); - } - else if (a > 0xff) { - gen_B(s, OP_EXT1); - gen_B(s, i); - gen_S(s, a); - gen_B(s, (uint8_t)b); + if (a > 0xff || b > 0xff) { + codegen_error(s, "too big operand"); } else { gen_B(s, i); @@ -309,32 +292,6 @@ mrb_decode_insn(const mrb_code *pc) #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break; #include "mruby/ops.h" #undef OPCODE - } - switch (insn) { - case OP_EXT1: - insn = READ_B(); - switch (insn) { -#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break; -#include "mruby/ops.h" -#undef OPCODE - } - break; - case OP_EXT2: - insn = READ_B(); - switch (insn) { -#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break; -#include "mruby/ops.h" -#undef OPCODE - } - break; - case OP_EXT3: - insn = READ_B(); - switch (insn) { -#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break; -#include "mruby/ops.h" -#undef OPCODE - } - break; default: break; } @@ -391,11 +348,8 @@ genjmp2(codegen_scope *s, mrb_code i, uint16_t a, int pc, int val) s->lastpc = s->pc; if (a > 0xff) { - gen_B(s, OP_EXT1); - gen_B(s, i); - gen_S(s, a); - pos = s->pc; - gen_S(s, pc); + codegen_error(s, "too big operand"); + pos = 0; } else { gen_B(s, i); @@ -3314,35 +3268,3 @@ uint8_t mrb_insn_size[] = { #undef SB #undef BBB }; -/* EXT1 instruction sizes */ -uint8_t mrb_insn_size1[] = { -#define B 3 -#define BB 4 -#define BBB 5 -#define BS 5 -#define SB 5 -#define OPCODE(_,x) x, -#include "mruby/ops.h" -#undef OPCODE -#undef B -}; -/* EXT2 instruction sizes */ -uint8_t mrb_insn_size2[] = { -#define B 2 -#define OPCODE(_,x) x, -#include "mruby/ops.h" -#undef OPCODE -#undef BB -#undef BBB -#undef BS -#undef SB -}; -/* EXT3 instruction sizes */ -#define BB 5 -#define BBB 6 -#define BS 4 -#define SB 5 -uint8_t mrb_insn_size3[] = { -#define OPCODE(_,x) x, -#include "mruby/ops.h" -}; diff --git a/src/codedump.c b/src/codedump.c index 0e90f22db..67bd8754d 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -63,7 +63,7 @@ print_header(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t i) printf("%03d ", (int)i); } -#define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn +#define CASE(insn,ops) case insn: FETCH_ ## ops (); static void codedump(mrb_state *mrb, const mrb_irep *irep) @@ -107,14 +107,14 @@ codedump(mrb_state *mrb, const mrb_irep *irep) print_header(mrb, irep, i); ins = READ_B(); switch (ins) { - CASE(OP_NOP, Z): + CASE(OP_NOP, Z); printf("OP_NOP\n"); break; - CASE(OP_MOVE, BB): + CASE(OP_MOVE, BB); printf("OP_MOVE\tR%d\tR%d\t", a, b); print_lv_ab(mrb, irep, a, b); break; - CASE(OP_LOADL, BB): + CASE(OP_LOADL, BB); switch (irep->pool[b].tt) { case IREP_TT_FLOAT: printf("OP_LOADL\tR%d\tL(%d)\t; %f", a, b, (double)irep->pool[b].u.f); @@ -133,144 +133,144 @@ codedump(mrb_state *mrb, const mrb_irep *irep) } print_lv_a(mrb, irep, a); break; - CASE(OP_LOADI, BB): + CASE(OP_LOADI, BB); printf("OP_LOADI\tR%d\t%d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADINEG, BB): + CASE(OP_LOADINEG, BB); printf("OP_LOADI\tR%d\t-%d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADI16, BS): + CASE(OP_LOADI16, BS); printf("OP_LOADI16\tR%d\t%d\t", a, (int)(int16_t)b); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADI__1, B): + CASE(OP_LOADI__1, B); printf("OP_LOADI__1\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADI_0, B): goto L_LOADI; - CASE(OP_LOADI_1, B): goto L_LOADI; - CASE(OP_LOADI_2, B): goto L_LOADI; - CASE(OP_LOADI_3, B): goto L_LOADI; - CASE(OP_LOADI_4, B): goto L_LOADI; - CASE(OP_LOADI_5, B): goto L_LOADI; - CASE(OP_LOADI_6, B): goto L_LOADI; - CASE(OP_LOADI_7, B): + CASE(OP_LOADI_0, B); goto L_LOADI; + CASE(OP_LOADI_1, B); goto L_LOADI; + CASE(OP_LOADI_2, B); goto L_LOADI; + CASE(OP_LOADI_3, B); goto L_LOADI; + CASE(OP_LOADI_4, B); goto L_LOADI; + CASE(OP_LOADI_5, B); goto L_LOADI; + CASE(OP_LOADI_6, B); goto L_LOADI; + CASE(OP_LOADI_7, B); L_LOADI: printf("OP_LOADI_%d\tR%d\t\t", ins-(int)OP_LOADI_0, a); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADSYM, BB): + CASE(OP_LOADSYM, BB); 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): + CASE(OP_LOADNIL, B); printf("OP_LOADNIL\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADSELF, B): + CASE(OP_LOADSELF, B); printf("OP_LOADSELF\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADT, B): + CASE(OP_LOADT, B); printf("OP_LOADT\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADF, B): + CASE(OP_LOADF, B); printf("OP_LOADF\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_GETGV, BB): + CASE(OP_GETGV, BB); 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_dump(mrb, irep->syms[b]), a); + CASE(OP_SETGV, BB); + 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): + CASE(OP_GETSV, BB); 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): + CASE(OP_SETSV, BB); 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): + CASE(OP_GETCONST, BB); 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): + CASE(OP_SETCONST, BB); 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): + CASE(OP_GETMCNST, BB); 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): + CASE(OP_SETMCNST, BB); 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): + CASE(OP_GETIV, BB); 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): + CASE(OP_SETIV, BB); 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): + CASE(OP_GETUPVAR, BBB); printf("OP_GETUPVAR\tR%d\t%d\t%d", a, b, c); print_lv_a(mrb, irep, a); break; - CASE(OP_SETUPVAR, BBB): + CASE(OP_SETUPVAR, BBB); printf("OP_SETUPVAR\tR%d\t%d\t%d", a, b, c); print_lv_a(mrb, irep, a); break; - CASE(OP_GETCV, BB): + CASE(OP_GETCV, BB); 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): + CASE(OP_SETCV, BB); 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): + CASE(OP_JMP, S); printf("OP_JMP\t\t%03d\n", a); break; - CASE(OP_JMPIF, BS): + CASE(OP_JMPIF, BS); printf("OP_JMPIF\tR%d\t%03d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_JMPNOT, BS): + CASE(OP_JMPNOT, BS); printf("OP_JMPNOT\tR%d\t%03d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_JMPNIL, BS): + CASE(OP_JMPNIL, BS); printf("OP_JMPNIL\tR%d\t%03d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_SENDV, BB): + CASE(OP_SENDV, BB); printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b])); break; - CASE(OP_SENDVB, BB): + CASE(OP_SENDVB, BB); printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b])); break; - CASE(OP_SEND, BBB): + CASE(OP_SEND, BBB); printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c); break; - CASE(OP_SENDB, BBB): + CASE(OP_SENDB, BBB); printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c); break; - CASE(OP_CALL, Z): + CASE(OP_CALL, Z); printf("OP_CALL\n"); break; - CASE(OP_SUPER, BB): + CASE(OP_SUPER, BB); printf("OP_SUPER\tR%d\t%d\n", a, b); break; - CASE(OP_ARGARY, BS): + CASE(OP_ARGARY, BS); printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)", a, (b>>11)&0x3f, (b>>10)&0x1, @@ -279,7 +279,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) (b>>0)&0xf); print_lv_a(mrb, irep, a); break; - CASE(OP_ENTER, W): + CASE(OP_ENTER, W); printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n", MRB_ASPEC_REQ(a), MRB_ASPEC_OPT(a), @@ -289,30 +289,30 @@ codedump(mrb_state *mrb, const mrb_irep *irep) MRB_ASPEC_KDICT(a), MRB_ASPEC_BLOCK(a)); break; - CASE(OP_KEY_P, BB): + CASE(OP_KEY_P, BB); 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): + CASE(OP_KEYEND, Z); printf("OP_KEYEND\n"); break; - CASE(OP_KARG, BB): + CASE(OP_KARG, BB); 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): + CASE(OP_RETURN, B); printf("OP_RETURN\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_RETURN_BLK, B): + CASE(OP_RETURN_BLK, B); printf("OP_RETURN_BLK\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_BREAK, B): + CASE(OP_BREAK, B); printf("OP_BREAK\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_BLKPUSH, BS): + CASE(OP_BLKPUSH, BS); printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)", a, (b>>11)&0x3f, (b>>10)&0x1, @@ -321,100 +321,100 @@ codedump(mrb_state *mrb, const mrb_irep *irep) (b>>0)&0xf); print_lv_a(mrb, irep, a); break; - CASE(OP_LAMBDA, BB): + CASE(OP_LAMBDA, BB); printf("OP_LAMBDA\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]); break; - CASE(OP_BLOCK, BB): + CASE(OP_BLOCK, BB); printf("OP_BLOCK\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]); break; - CASE(OP_METHOD, BB): + CASE(OP_METHOD, BB); printf("OP_METHOD\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]); break; - CASE(OP_RANGE_INC, B): + CASE(OP_RANGE_INC, B); printf("OP_RANGE_INC\tR%d\n", a); break; - CASE(OP_RANGE_EXC, B): + CASE(OP_RANGE_EXC, B); printf("OP_RANGE_EXC\tR%d\n", a); break; - CASE(OP_DEF, BB): + CASE(OP_DEF, BB); printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b])); break; - CASE(OP_UNDEF, B): + CASE(OP_UNDEF, B); printf("OP_UNDEF\t:%s\n", mrb_sym_dump(mrb, irep->syms[a])); break; - CASE(OP_ALIAS, BB): + CASE(OP_ALIAS, BB); 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): + CASE(OP_ADD, B); printf("OP_ADD\tR%d\t\n", a); break; - CASE(OP_ADDI, BB): + CASE(OP_ADDI, BB); printf("OP_ADDI\tR%d\t%d\n", a, b); break; - CASE(OP_SUB, B): + CASE(OP_SUB, B); printf("OP_SUB\tR%d\t\n", a); break; - CASE(OP_SUBI, BB): + CASE(OP_SUBI, BB); printf("OP_SUBI\tR%d\t%d\n", a, b); break; - CASE(OP_MUL, B): + CASE(OP_MUL, B); printf("OP_MUL\tR%d\t\n", a); break; - CASE(OP_DIV, B): + CASE(OP_DIV, B); printf("OP_DIV\tR%d\t\n", a); break; - CASE(OP_LT, B): + CASE(OP_LT, B); printf("OP_LT\t\tR%d\t\n", a); break; - CASE(OP_LE, B): + CASE(OP_LE, B); printf("OP_LE\t\tR%d\t\n", a); break; - CASE(OP_GT, B): + CASE(OP_GT, B); printf("OP_GT\t\tR%d\t\n", a); break; - CASE(OP_GE, B): + CASE(OP_GE, B); printf("OP_GE\t\tR%d\t\n", a); break; - CASE(OP_EQ, B): + CASE(OP_EQ, B); printf("OP_EQ\t\tR%d\t\n", a); break; - CASE(OP_ARRAY, BB): + CASE(OP_ARRAY, BB); printf("OP_ARRAY\tR%d\t%d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_ARRAY2, BBB): + CASE(OP_ARRAY2, BBB); printf("OP_ARRAY\tR%d\tR%d\t%d\t", a, b, c); print_lv_ab(mrb, irep, a, b); break; - CASE(OP_ARYCAT, B): + CASE(OP_ARYCAT, B); printf("OP_ARYCAT\tR%d\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_ARYPUSH, B): + CASE(OP_ARYPUSH, B); printf("OP_ARYPUSH\tR%d\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_ARYDUP, B): + CASE(OP_ARYDUP, B); printf("OP_ARYDUP\tR%d\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_AREF, BBB): + CASE(OP_AREF, BBB); printf("OP_AREF\tR%d\tR%d\t%d", a, b, c); print_lv_ab(mrb, irep, a, b); break; - CASE(OP_ASET, BBB): + CASE(OP_ASET, BBB); printf("OP_ASET\tR%d\tR%d\t%d", a, b, c); print_lv_ab(mrb, irep, a, b); break; - CASE(OP_APOST, BBB): + CASE(OP_APOST, BBB); printf("OP_APOST\tR%d\t%d\t%d", a, b, c); print_lv_a(mrb, irep, a); break; - CASE(OP_INTERN, B): + CASE(OP_INTERN, B); printf("OP_INTERN\tR%d", a); print_lv_a(mrb, irep, a); break; - CASE(OP_STRING, BB): + CASE(OP_STRING, BB); if ((irep->pool[b].tt & IREP_TT_NFLAG) == 0) { printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, irep->pool[b].u.str); } @@ -423,48 +423,48 @@ codedump(mrb_state *mrb, const mrb_irep *irep) } print_lv_a(mrb, irep, a); break; - CASE(OP_STRCAT, B): + CASE(OP_STRCAT, B); printf("OP_STRCAT\tR%d\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_HASH, BB): + CASE(OP_HASH, BB); printf("OP_HASH\tR%d\t%d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_HASHADD, BB): + CASE(OP_HASHADD, BB); printf("OP_HASHADD\tR%d\t%d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_HASHCAT, B): + CASE(OP_HASHCAT, B); printf("OP_HASHCAT\tR%d\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_OCLASS, B): + CASE(OP_OCLASS, B); printf("OP_OCLASS\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_CLASS, BB): + CASE(OP_CLASS, BB); 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): + CASE(OP_MODULE, BB); 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): + CASE(OP_EXEC, BB); printf("OP_EXEC\tR%d\tI(%d:%p)", a, b, irep->reps[b]); print_lv_a(mrb, irep, a); break; - CASE(OP_SCLASS, B): + CASE(OP_SCLASS, B); printf("OP_SCLASS\tR%d\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_TCLASS, B): + CASE(OP_TCLASS, B); printf("OP_TCLASS\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_ERR, B): + CASE(OP_ERR, B); if ((irep->pool[a].tt & IREP_TT_NFLAG) == 0) { printf("OP_ERR\t%s\n", irep->pool[a].u.str); } @@ -472,70 +472,39 @@ codedump(mrb_state *mrb, const mrb_irep *irep) printf("OP_ERR\tL(%d)\n", a); } break; - CASE(OP_EPUSH, B): + CASE(OP_EPUSH, B); printf("OP_EPUSH\t\t:I(%d:%p)\n", a, irep->reps[a]); break; - CASE(OP_ONERR, S): + CASE(OP_ONERR, S); printf("OP_ONERR\t%03d\n", a); break; - CASE(OP_EXCEPT, B): + CASE(OP_EXCEPT, B); printf("OP_EXCEPT\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_RESCUE, BB): + CASE(OP_RESCUE, BB); printf("OP_RESCUE\tR%d\tR%d", a, b); print_lv_ab(mrb, irep, a, b); break; - CASE(OP_RAISE, B): + CASE(OP_RAISE, B); printf("OP_RAISE\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_POPERR, B): + CASE(OP_POPERR, B); printf("OP_POPERR\t%d\t\t\n", a); break; - CASE(OP_EPOP, B): + CASE(OP_EPOP, B); printf("OP_EPOP\t%d\n", a); break; - CASE(OP_DEBUG, BBB): + CASE(OP_DEBUG, BBB); printf("OP_DEBUG\t%d\t%d\t%d\n", a, b, c); break; - CASE(OP_STOP, Z): + CASE(OP_STOP, Z); printf("OP_STOP\n"); break; - CASE(OP_EXT1, Z): - ins = READ_B(); - printf("OP_EXT1\n"); - print_header(mrb, irep, pc-irep->iseq-2); - switch (ins) { -#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); goto L_OP_ ## i; -#include "mruby/ops.h" -#undef OPCODE - } - break; - CASE(OP_EXT2, Z): - ins = READ_B(); - printf("OP_EXT2\n"); - print_header(mrb, irep, pc-irep->iseq-2); - switch (ins) { -#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); goto L_OP_ ## i; -#include "mruby/ops.h" -#undef OPCODE - } - break; - CASE(OP_EXT3, Z): - ins = READ_B(); - printf("OP_EXT3\n"); - print_header(mrb, irep, pc-irep->iseq-2); - switch (ins) { -#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); goto L_OP_ ## i; -#include "mruby/ops.h" -#undef OPCODE - } - break; - default: printf("OP_unknown (0x%x)\n", ins); break; diff --git a/src/vm.c b/src/vm.c index 98f17e287..c97c9678c 100644 --- a/src/vm.c +++ b/src/vm.c @@ -901,7 +901,7 @@ argnum_error(mrb_state *mrb, mrb_int num) #ifndef DIRECT_THREADED #define INIT_DISPATCH for (;;) { insn = BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); switch (insn) { -#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops ();; L_ ## insn ## _BODY: +#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops (); #define NEXT break #define JUMP NEXT #define END_DISPATCH }} @@ -909,7 +909,7 @@ argnum_error(mrb_state *mrb, mrb_int num) #else #define INIT_DISPATCH JUMP; return mrb_nil_value(); -#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); L_ ## insn ## _BODY: +#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn] #define JUMP NEXT @@ -1512,7 +1512,7 @@ RETRY_TRY_BLOCK: mrb->c->stack[0] = mrb_nil_value(); a = 0; c = OP_R_NORMAL; - goto L_OP_RETURN_BODY; + goto L_RETURN; } pool = irep->pool; syms = irep->syms; @@ -2733,37 +2733,6 @@ RETRY_TRY_BLOCK: goto L_RAISE; } - CASE(OP_EXT1, Z) { - insn = READ_B(); - switch (insn) { -#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); goto L_OP_ ## insn ## _BODY; -#include "mruby/ops.h" -#undef OPCODE - } - pc--; - NEXT; - } - CASE(OP_EXT2, Z) { - insn = READ_B(); - switch (insn) { -#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); goto L_OP_ ## insn ## _BODY; -#include "mruby/ops.h" -#undef OPCODE - } - pc--; - NEXT; - } - CASE(OP_EXT3, Z) { - uint8_t insn = READ_B(); - switch (insn) { -#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); goto L_OP_ ## insn ## _BODY; -#include "mruby/ops.h" -#undef OPCODE - } - pc--; - NEXT; - } - CASE(OP_STOP, Z) { /* stop VM */ L_STOP: -- cgit v1.2.3 From 8b3f3c0bf3551c4808ce2e9ab58fcca480e0ab9c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 20 Jul 2020 13:33:13 +0900 Subject: Fix the bug by the combination with `MRB_64BIT` and `MRB_INT32`. Which is caused by `MRB_NAN_BOXING`. --- src/dump.c | 13 +++++++++---- src/vm.c | 8 +++++++- 2 files changed, 16 insertions(+), 5 deletions(-) (limited to 'src/vm.c') diff --git a/src/dump.c b/src/dump.c index aeb23d033..6acba12c2 100644 --- a/src/dump.c +++ b/src/dump.c @@ -934,14 +934,19 @@ dump_pool(mrb_state *mrb, const mrb_pool_value *p, FILE *fp) { if (p->tt & IREP_TT_NFLAG) { /* number */ switch (p->tt) { - case IREP_TT_INT32: - fprintf(fp, "{IREP_TT_INT32, {.i32=%" PRId32 "}},\n", p->u.i32); - break; #ifdef MRB_64BIT case IREP_TT_INT64: - fprintf(fp, "{IREP_TT_INT64, {.i64=%" PRId64 "}},\n", p->u.i64); + if (p->u.i64 < INT32_MIN || INT32_MAX < p->u.i64) { + fprintf(fp, "{IREP_TT_INT64, {.i64=%" PRId64 "}},\n", p->u.i64); + } + else { + fprintf(fp, "{IREP_TT_INT32, {.i64=%" PRId64 "}},\n", p->u.i64); + } break; #endif + case IREP_TT_INT32: + fprintf(fp, "{IREP_TT_INT32, {.i32=%" PRId32 "}},\n", p->u.i32); + break; case IREP_TT_FLOAT: if (p->u.f == 0) { fprintf(fp, "{IREP_TT_FLOAT, {.f=%#.1f}},\n", p->u.f); diff --git a/src/vm.c b/src/vm.c index c97c9678c..e184e7cc6 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1018,10 +1018,16 @@ RETRY_TRY_BLOCK: regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i32); break; case IREP_TT_INT64: -#if defined(MRB_INT64) && defined(MRB_64BIT) +#if defined(MRB_INT64) regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i64); break; #else +#if defined(MRB_64BIT) + if (INT32_MIN <= pool[b].u.i64 && pool[b].u.i64 <= INT32_MAX) { + regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i64); + break; + } +#endif { mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "integer overflow"); mrb_exc_set(mrb, exc); -- cgit v1.2.3 From 0e50ea90f388a21be1203cfde0372ebd7331285e Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 5 Aug 2020 17:41:31 +0900 Subject: Add `const` specifier to `cipush()`; ref #5052 --- src/vm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index e184e7cc6..46c3ce0f5 100644 --- a/src/vm.c +++ b/src/vm.c @@ -264,7 +264,7 @@ top_proc(mrb_state *mrb, const struct RProc *proc) static inline mrb_callinfo* cipush(mrb_state *mrb, const mrb_code *pc, int push_stacks, int acc, - struct RClass *target_class, struct RProc *proc, mrb_sym mid, int argc) + struct RClass *target_class, const struct RProc *proc, mrb_sym mid, int argc) { struct mrb_context *c = mrb->c; mrb_callinfo *ci = c->ci; -- cgit v1.2.3 From 690cafe2749e6a2b0e72785ee89fcb07bdab8b54 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 7 Aug 2020 22:53:37 +0900 Subject: Initialize `kdict` in `OP_ENTER` in `vm.c`. --- src/vm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 46c3ce0f5..3faecfaf2 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1732,7 +1732,7 @@ RETRY_TRY_BLOCK: int const len = m1 + o + r + m2; int const blk_pos = len + kd + 1; mrb_value *blk = &argv[argc < 0 ? 1 : argc]; - mrb_value kdict; + mrb_value kdict = mrb_nil_value(); int kargs = kd; /* arguments is passed with Array */ -- cgit v1.2.3 From f467b02d4598ab64d98727348e8a9c4f04fc9b83 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 24 May 2020 11:44:31 +0900 Subject: Extended `OP_EXCEPT` and `OP_RAISE` (`OP_RAISEIF`) instructions - `OP_EXCEPT` checks if `mrb->exc` is `NULL`, `MRB_TT_EXCEPTION` or `MRB_TT_BREAK`. If `mrb->exc` is `NULL`, it will be replaced with `nil`. - If `OP_RAISE` is `nil`, it does nothing and the immediately following instruction is executed (like `OP_NOP`). Also, in case of `RBreak` object, it moves to the processing for `break`. With this change, the instruction name is changed from `OP_RAISE` to `OP_RAISEIF`. --- doc/opcode.md | 2 +- include/mruby/ops.h | 2 +- mrbgems/mruby-compiler/core/codegen.c | 2 +- src/codedump.c | 4 ++-- src/vm.c | 34 +++++++++++++++++++++++++++++----- 5 files changed, 34 insertions(+), 10 deletions(-) (limited to 'src/vm.c') diff --git a/doc/opcode.md b/doc/opcode.md index 98d29cdc0..d7e620350 100644 --- a/doc/opcode.md +++ b/doc/opcode.md @@ -66,7 +66,7 @@ sign) of operands. | OP_EXCEPT | B | R(a) = exc | | OP_RESCUE | BB | R(b) = R(a).isa?(R(b)) | | OP_POPERR | B | a.times{rescue_pop()} | -| OP_RAISE | B | raise(R(a)) | +| OP_RAISEIF | B | raise(R(a)) if R(a) | | OP_EPUSH | B | ensure_push(SEQ[a]) | | OP_EPOP | B | A.times{ensure_pop().call} | | OP_SENDV | BB | R(a) = call(R(a),Syms(b),*R(a+1)) | diff --git a/include/mruby/ops.h b/include/mruby/ops.h index 7d20ac0ad..45397e2ed 100644 --- a/include/mruby/ops.h +++ b/include/mruby/ops.h @@ -53,7 +53,7 @@ OPCODE(ONERR, S) /* rescue_push(a) */ OPCODE(EXCEPT, B) /* R(a) = exc */ OPCODE(RESCUE, BB) /* R(b) = R(a).isa?(R(b)) */ OPCODE(POPERR, B) /* a.times{rescue_pop()} */ -OPCODE(RAISE, B) /* raise(R(a)) */ +OPCODE(RAISEIF, B) /* raise(R(a)) if R(a) */ OPCODE(EPUSH, B) /* ensure_push(SEQ[a]) */ OPCODE(EPOP, B) /* A.times{ensure_pop().call} */ OPCODE(SENDV, BB) /* R(a) = call(R(a),Syms(b),*R(a+1)) */ diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index e55b6791d..7911ecb36 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1533,7 +1533,7 @@ codegen(codegen_scope *s, node *tree, int val) } if (pos1) { dispatch(s, pos1); - genop_1(s, OP_RAISE, exc); + genop_1(s, OP_RAISEIF, exc); } } pop(); diff --git a/src/codedump.c b/src/codedump.c index a19d60708..2225da4ce 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -507,8 +507,8 @@ codedump(mrb_state *mrb, const mrb_irep *irep) printf("OP_RESCUE\tR%d\tR%d", a, b); print_lv_ab(mrb, irep, a, b); break; - CASE(OP_RAISE, B); - printf("OP_RAISE\tR%d\t\t", a); + CASE(OP_RAISEIF, B); + printf("OP_RAISEIF\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; CASE(OP_POPERR, B); diff --git a/src/vm.c b/src/vm.c index 3faecfaf2..2dbbe85f8 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1255,8 +1255,24 @@ RETRY_TRY_BLOCK: } CASE(OP_EXCEPT, B) { - mrb_value exc = mrb_obj_value(mrb->exc); - mrb->exc = 0; + mrb_value exc; + + if (mrb->exc == NULL) { + exc = mrb_nil_value(); + } + else { + switch (mrb->exc->tt) { + case MRB_TT_BREAK: + case MRB_TT_EXCEPTION: + exc = mrb_obj_value(mrb->exc); + break; + default: + mrb_assert(!"bad mrb_type"); + exc = mrb_nil_value(); + break; + } + mrb->exc = NULL; + } regs[a] = exc; NEXT; } @@ -1289,9 +1305,17 @@ RETRY_TRY_BLOCK: NEXT; } - CASE(OP_RAISE, B) { - mrb_exc_set(mrb, regs[a]); - goto L_RAISE; + CASE(OP_RAISEIF, B) { + mrb_value exc = regs[a]; + if (mrb_break_p(exc)) { + mrb->exc = mrb_obj_ptr(exc); + goto L_BREAK; + } + mrb_exc_set(mrb, exc); + if (mrb->exc) { + goto L_RAISE; + } + NEXT; } CASE(OP_EPUSH, B) { -- cgit v1.2.3 From 0d7b4deccf445e3edae9239bf40b91cc79e83634 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 24 May 2020 00:42:09 +0900 Subject: Removed push/pop instructions for rescue/ensure `OP_PUSHERR`, `OP_POPERR`, `OP_EPUSH` and `OP_EPOP` are removed. --- doc/opcode.md | 4 --- include/mruby/ops.h | 4 --- src/codedump.c | 12 -------- src/vm.c | 86 ----------------------------------------------------- 4 files changed, 106 deletions(-) (limited to 'src/vm.c') diff --git a/doc/opcode.md b/doc/opcode.md index d7e620350..385bf9468 100644 --- a/doc/opcode.md +++ b/doc/opcode.md @@ -62,13 +62,9 @@ sign) of operands. | OP_JMPIF | BS | if R(a) pc=b | | OP_JMPNOT | BS | if !R(a) pc=b | | OP_JMPNIL | BS | if R(a)==nil pc=b | -| OP_ONERR | S | rescue_push(a) | | OP_EXCEPT | B | R(a) = exc | | OP_RESCUE | BB | R(b) = R(a).isa?(R(b)) | -| OP_POPERR | B | a.times{rescue_pop()} | | OP_RAISEIF | B | raise(R(a)) if R(a) | -| OP_EPUSH | B | ensure_push(SEQ[a]) | -| OP_EPOP | B | A.times{ensure_pop().call} | | OP_SENDV | BB | R(a) = call(R(a),Syms(b),*R(a+1)) | | OP_SENDVB | BB | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) | | OP_SEND | BBB | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) | diff --git a/include/mruby/ops.h b/include/mruby/ops.h index 45397e2ed..8ff44088e 100644 --- a/include/mruby/ops.h +++ b/include/mruby/ops.h @@ -49,13 +49,9 @@ OPCODE(JMP, S) /* pc=a */ OPCODE(JMPIF, BS) /* if R(a) pc=b */ OPCODE(JMPNOT, BS) /* if !R(a) pc=b */ OPCODE(JMPNIL, BS) /* if R(a)==nil pc=b */ -OPCODE(ONERR, S) /* rescue_push(a) */ OPCODE(EXCEPT, B) /* R(a) = exc */ OPCODE(RESCUE, BB) /* R(b) = R(a).isa?(R(b)) */ -OPCODE(POPERR, B) /* a.times{rescue_pop()} */ OPCODE(RAISEIF, B) /* raise(R(a)) if R(a) */ -OPCODE(EPUSH, B) /* ensure_push(SEQ[a]) */ -OPCODE(EPOP, B) /* A.times{ensure_pop().call} */ OPCODE(SENDV, BB) /* R(a) = call(R(a),Syms(b),*R(a+1)) */ OPCODE(SENDVB, BB) /* R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) */ OPCODE(SEND, BBB) /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) */ diff --git a/src/codedump.c b/src/codedump.c index 2225da4ce..81212921d 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -493,12 +493,6 @@ codedump(mrb_state *mrb, const mrb_irep *irep) printf("OP_ERR\tL(%d)\n", a); } break; - CASE(OP_EPUSH, B); - printf("OP_EPUSH\t\t:I(%d:%p)\n", a, irep->reps[a]); - break; - CASE(OP_ONERR, S); - printf("OP_ONERR\t%03d\n", a); - break; CASE(OP_EXCEPT, B); printf("OP_EXCEPT\tR%d\t\t", a); print_lv_a(mrb, irep, a); @@ -511,12 +505,6 @@ codedump(mrb_state *mrb, const mrb_irep *irep) printf("OP_RAISEIF\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_POPERR, B); - printf("OP_POPERR\t%d\t\t\n", a); - break; - CASE(OP_EPOP, B); - printf("OP_EPOP\t%d\n", a); - break; CASE(OP_DEBUG, BBB); printf("OP_DEBUG\t%d\t%d\t%d\n", a, b, c); diff --git a/src/vm.c b/src/vm.c index 2dbbe85f8..d11caa5c7 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1231,29 +1231,6 @@ RETRY_TRY_BLOCK: NEXT; } - CASE(OP_ONERR, S) { - /* check rescue stack */ - if (mrb->c->ci->ridx == UINT16_MAX-1) { - mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "too many nested rescues"); - mrb_exc_set(mrb, exc); - goto L_RAISE; - } - /* expand rescue stack */ - if (mrb->c->rsize <= mrb->c->ci->ridx) { - if (mrb->c->rsize == 0) mrb->c->rsize = RESCUE_STACK_INIT_SIZE; - else { - mrb->c->rsize *= 2; - if (mrb->c->rsize <= mrb->c->ci->ridx) { - mrb->c->rsize = UINT16_MAX; - } - } - mrb->c->rescue = (uint16_t*)mrb_realloc(mrb, mrb->c->rescue, sizeof(uint16_t)*mrb->c->rsize); - } - /* push rescue stack */ - mrb->c->rescue[mrb->c->ci->ridx++] = a; - NEXT; - } - CASE(OP_EXCEPT, B) { mrb_value exc; @@ -1300,11 +1277,6 @@ RETRY_TRY_BLOCK: NEXT; } - CASE(OP_POPERR, B) { - mrb->c->ci->ridx -= a; - NEXT; - } - CASE(OP_RAISEIF, B) { mrb_value exc = regs[a]; if (mrb_break_p(exc)) { @@ -1318,64 +1290,6 @@ RETRY_TRY_BLOCK: NEXT; } - CASE(OP_EPUSH, B) { - struct RProc *p; - - p = mrb_closure_new(mrb, irep->reps[a]); - /* check ensure stack */ - if (mrb->c->eidx == UINT16_MAX-1) { - mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "too many nested ensures"); - mrb_exc_set(mrb, exc); - goto L_RAISE; - } - /* expand ensure stack */ - if (mrb->c->esize <= mrb->c->eidx+1) { - if (mrb->c->esize == 0) mrb->c->esize = ENSURE_STACK_INIT_SIZE; - else { - mrb->c->esize *= 2; - if (mrb->c->esize <= mrb->c->eidx) { - mrb->c->esize = UINT16_MAX; - } - } - mrb->c->ensure = (struct RProc**)mrb_realloc(mrb, mrb->c->ensure, sizeof(struct RProc*)*mrb->c->esize); - } - /* push ensure stack */ - mrb->c->ensure[mrb->c->eidx++] = p; - mrb->c->ensure[mrb->c->eidx] = NULL; - mrb_gc_arena_restore(mrb, ai); - NEXT; - } - - CASE(OP_EPOP, B) { - mrb_callinfo *ci = mrb->c->ci; - unsigned int n, epos = ci->epos; - mrb_value self = regs[0]; - struct RClass *target_class = ci->target_class; - - if (mrb->c->eidx <= epos) { - NEXT; - } - - if (a > (int)mrb->c->eidx - epos) - a = mrb->c->eidx - epos; - for (n=0; nnregs; - - proc = mrb->c->ensure[epos+n]; - mrb->c->ensure[epos+n] = NULL; - if (proc == NULL) continue; - irep = proc->body.irep; - ci = cipush(mrb, pc, nregs, nregs, target_class, proc, ci->mid, 0); - mrb_stack_extend(mrb, irep->nregs); - regs[0] = self; - pc = irep->iseq; - } - pool = irep->pool; - syms = irep->syms; - mrb->c->eidx = epos; - JUMP; - } - CASE(OP_SENDV, BB) { c = CALL_MAXARGS; goto L_SEND; -- cgit v1.2.3 From c1f112c49a597da8478516261f0812bc073f6cd8 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 18 Jul 2020 19:05:12 +0900 Subject: Replace global jump with catch handler implementation When a global jump occurs, look at the catch handler table to determine where to jump. In that case, `pc` already shows the following instruction, but since the table shows `begin_offset ... end_offset`, the comparison is done with `begin_offset < pc && pc <= end_offset`. If there is a corresponding handler, move `pc` to `handler.target_offset` and continue running the VM. When a global jump across `ensure` is made by `return`, `break`, `next`, `redo` and `retry`, the extended `RBreak` object saves and restores the C-level execution position. This extended `RBreak` can have tag information, which makes it a pseudo coroutine (the "tag" mimics CRuby). The implementation of pseudo coroutines by `RBreak` is summarized by `CHECKPOINT_RESTORE ... CHECKPOINT_MAIN ... CHECKPOINT_END` and `throw_tagged_break` / `unwind_ensure` macros. The restart of processing is branched by `RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)`. - Not only `rescue` blocks but also `ensure` blocks are now sandwiched between `OP_EXCEPT` and `OP_RAISEIF`. - Remove the function `ecall()`. It is no longer necessary to re-enter the VM to perform an "ensure block". This will resolves #1888. - Added instruction `OP_JUW` (Jump while UnWind). It jumps unconditionally like `OP_JMP`, but searches the catch handler table and executes the ensure block. Since it searches the catch handler table, it is much heavier than `OP_JMP`. --- doc/opcode.md | 1 + include/mruby.h | 8 - include/mruby/error.h | 33 ++++ include/mruby/ops.h | 1 + mrbgems/mruby-compiler/core/codegen.c | 91 ++++----- mrbgems/mruby-os-memsize/src/memsize.c | 2 - src/codedump.c | 3 + src/gc.c | 8 - src/state.c | 2 - src/vm.c | 339 +++++++++++++++++++++++---------- 10 files changed, 311 insertions(+), 177 deletions(-) (limited to 'src/vm.c') diff --git a/doc/opcode.md b/doc/opcode.md index 385bf9468..abdee704f 100644 --- a/doc/opcode.md +++ b/doc/opcode.md @@ -62,6 +62,7 @@ sign) of operands. | OP_JMPIF | BS | if R(a) pc=b | | OP_JMPNOT | BS | if !R(a) pc=b | | OP_JMPNIL | BS | if R(a)==nil pc=b | +| OP_JUW | S | unwind_and_jump_to(a) | | OP_EXCEPT | B | R(a) = exc | | OP_RESCUE | BB | R(b) = R(a).isa?(R(b)) | | OP_RAISEIF | B | raise(R(a)) if R(a) | diff --git a/include/mruby.h b/include/mruby.h index c9425e8a7..9f1d1aa30 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -149,8 +149,6 @@ typedef struct { mrb_sym mid; const struct RProc *proc; mrb_value *stackent; - uint16_t ridx; - uint16_t epos; struct REnv *env; const mrb_code *pc; /* return address */ const mrb_code *err; /* error position */ @@ -177,11 +175,6 @@ struct mrb_context { mrb_callinfo *ci; mrb_callinfo *cibase, *ciend; - uint16_t *rescue; /* exception handler stack */ - uint16_t rsize; - struct RProc **ensure; /* ensure handler stack */ - uint16_t esize, eidx; - enum mrb_fiber_state status : 4; mrb_bool vmexec : 1; struct RFiber *fib; @@ -301,7 +294,6 @@ typedef struct mrb_state { mrb_atexit_func *atexit_stack; #endif uint16_t atexit_stack_len; - uint16_t ecall_nest; /* prevent infinite recursive ecall() */ } mrb_state; /** diff --git a/include/mruby/error.h b/include/mruby/error.h index 72f6c5f3d..67a0a539e 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -66,6 +66,39 @@ mrb_break_value_set(struct RBreak *brk, mrb_value val) #define mrb_break_proc_get(brk) ((brk)->proc) #define mrb_break_proc_set(brk, p) ((brk)->proc = p) +#define RBREAK_TAG_FOREACH(f) \ + f(RBREAK_TAG_BREAK, 0) \ + f(RBREAK_TAG_BREAK_UPPER, 1) \ + f(RBREAK_TAG_BREAK_INTARGET, 2) \ + f(RBREAK_TAG_RETURN_BLOCK, 3) \ + f(RBREAK_TAG_RETURN, 4) \ + f(RBREAK_TAG_RETURN_TOPLEVEL, 5) \ + f(RBREAK_TAG_JUMP, 6) \ + f(RBREAK_TAG_STOP, 7) + +#define RBREAK_TAG_DEFINE(tag, i) tag = i, +enum { + RBREAK_TAG_FOREACH(RBREAK_TAG_DEFINE) +}; +#undef RBREAK_TAG_DEFINE + +#define RBREAK_TAG_BIT 3 +#define RBREAK_TAG_BIT_OFF 8 +#define RBREAK_TAG_MASK (~(~UINT32_C(0) << RBREAK_TAG_BIT)) + +static inline uint32_t +mrb_break_tag_get(struct RBreak *brk) +{ + return (brk->flags >> RBREAK_TAG_BIT_OFF) & RBREAK_TAG_MASK; +} + +static inline void +mrb_break_tag_set(struct RBreak *brk, uint32_t tag) +{ + brk->flags &= ~(RBREAK_TAG_MASK << RBREAK_TAG_BIT_OFF); + brk->flags |= (tag & RBREAK_TAG_MASK) << RBREAK_TAG_BIT_OFF; +} + /** * Protect * diff --git a/include/mruby/ops.h b/include/mruby/ops.h index 8ff44088e..770e54f3d 100644 --- a/include/mruby/ops.h +++ b/include/mruby/ops.h @@ -49,6 +49,7 @@ OPCODE(JMP, S) /* pc=a */ OPCODE(JMPIF, BS) /* if R(a) pc=b */ OPCODE(JMPNOT, BS) /* if !R(a) pc=b */ OPCODE(JMPNIL, BS) /* if R(a)==nil pc=b */ +OPCODE(JUW, S) /* unwind_and_jump_to(a) */ OPCODE(EXCEPT, B) /* R(a) = exc */ OPCODE(RESCUE, BB) /* R(b) = R(a).isa?(R(b)) */ OPCODE(RAISEIF, B) /* raise(R(a)) if R(a) */ diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 7911ecb36..b3ce388a9 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -40,7 +40,6 @@ enum looptype { struct loopinfo { enum looptype type; int pc0, pc1, pc2, pc3, acc; - int ensure_level; struct loopinfo *prev; }; @@ -61,7 +60,6 @@ typedef struct scope { mrb_bool mscope:1; struct loopinfo *loop; - int ensure_level; mrb_sym filename_sym; uint16_t lineno; @@ -1465,16 +1463,19 @@ codegen(codegen_scope *s, node *tree, int val) { int noexc, exend, pos1, pos2, tmp; struct loopinfo *lp; + int catch_entry, begin, end; if (tree->car == NULL) goto exit; lp = loop_push(s, LOOP_BEGIN); lp->pc0 = new_label(s); - lp->pc1 = genjmp(s, OP_ONERR, 0); + catch_entry = catch_hander_new(s); + begin = s->pc; codegen(s, tree->car, VAL); pop(); lp->type = LOOP_RESCUE; + end = s->pc; noexc = genjmp(s, OP_JMP, 0); - dispatch(s, lp->pc1); + catch_hander_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc); tree = tree->cdr; exend = 0; pos1 = 0; @@ -1539,7 +1540,6 @@ codegen(codegen_scope *s, node *tree, int val) pop(); tree = tree->cdr; dispatch(s, noexc); - genop_1(s, OP_POPERR, 1); if (tree->car) { codegen(s, tree->car, val); } @@ -1555,14 +1555,22 @@ codegen(codegen_scope *s, node *tree, int val) if (!tree->cdr || !tree->cdr->cdr || (nint(tree->cdr->cdr->car) == NODE_BEGIN && tree->cdr->cdr->cdr)) { + int catch_entry, begin, end, target; int idx; - s->ensure_level++; - idx = scope_body(s, tree->cdr, NOVAL); - genop_1(s, OP_EPUSH, idx); + catch_entry = catch_hander_new(s); + begin = s->pc; codegen(s, tree->car, val); - s->ensure_level--; - genop_1(s, OP_EPOP, 1); + end = target = s->pc; + push(); + idx = cursp(); + genop_1(s, OP_EXCEPT, idx); + push(); + codegen(s, tree->cdr->cdr, NOVAL); + pop(); + genop_1(s, OP_RAISEIF, idx); + pop(); + catch_hander_set(s, catch_entry, MRB_CATCH_ENSURE, begin, end, target); } else { /* empty ensure ignored */ codegen(s, tree->car, val); @@ -2024,18 +2032,20 @@ codegen(codegen_scope *s, node *tree, int val) if ((len == 2 && name[0] == '|' && name[1] == '|') && (nint(tree->car->car) == NODE_CONST || nint(tree->car->car) == NODE_CVAR)) { - int onerr, noexc, exc; + int catch_entry, begin, end; + int noexc, exc; struct loopinfo *lp; - onerr = genjmp(s, OP_ONERR, 0); lp = loop_push(s, LOOP_BEGIN); - lp->pc1 = onerr; + lp->pc0 = new_label(s); + catch_entry = catch_hander_new(s); + begin = s->pc; exc = cursp(); codegen(s, tree->car, VAL); - lp->type = LOOP_RESCUE; - genop_1(s, OP_POPERR, 1); + end = s->pc; noexc = genjmp(s, OP_JMP, 0); - dispatch(s, onerr); + lp->type = LOOP_RESCUE; + catch_hander_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc); genop_1(s, OP_EXCEPT, exc); genop_1(s, OP_LOADF, exc); dispatch(s, noexc); @@ -2288,11 +2298,8 @@ codegen(codegen_scope *s, node *tree, int val) raise_error(s, "unexpected next"); } else if (s->loop->type == LOOP_NORMAL) { - if (s->ensure_level > s->loop->ensure_level) { - genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level); - } codegen(s, tree, NOVAL); - genjmp(s, OP_JMP, s->loop->pc0); + genjmp(s, OP_JUW, s->loop->pc0); } else { if (tree) { @@ -2312,10 +2319,7 @@ codegen(codegen_scope *s, node *tree, int val) raise_error(s, "unexpected redo"); } else { - if (s->ensure_level > s->loop->ensure_level) { - genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level); - } - genjmp(s, OP_JMP, s->loop->pc2); + genjmp(s, OP_JUW, s->loop->pc2); } if (val) push(); break; @@ -2323,32 +2327,16 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_RETRY: { const char *msg = "unexpected retry"; + const struct loopinfo *lp = s->loop; - if (!s->loop) { + while (lp && lp->type != LOOP_RESCUE) { + lp = lp->prev; + } + if (!lp) { raise_error(s, msg); } else { - struct loopinfo *lp = s->loop; - int n = 0; - - while (lp && lp->type != LOOP_RESCUE) { - if (lp->type == LOOP_BEGIN) { - n++; - } - lp = lp->prev; - } - if (!lp) { - raise_error(s, msg); - } - else { - if (n > 0) { - genop_1(s, OP_POPERR, n); - } - if (s->ensure_level > lp->ensure_level) { - genop_1(s, OP_EPOP, s->ensure_level - lp->ensure_level); - } - genjmp(s, OP_JMP, lp->pc0); - } + genjmp(s, OP_JUW, lp->pc0); } if (val) push(); } @@ -3132,7 +3120,6 @@ loop_push(codegen_scope *s, enum looptype t) p->type = t; p->pc0 = p->pc1 = p->pc2 = p->pc3 = 0; p->prev = s->loop; - p->ensure_level = s->ensure_level; p->acc = cursp(); s->loop = p; @@ -3148,7 +3135,6 @@ loop_break(codegen_scope *s, node *tree) } else { struct loopinfo *loop; - int n = 0; if (tree) { gen_retval(s, tree); @@ -3157,7 +3143,6 @@ loop_break(codegen_scope *s, node *tree) loop = s->loop; while (loop) { if (loop->type == LOOP_BEGIN) { - n++; loop = loop->prev; } else if (loop->type == LOOP_RESCUE) { @@ -3171,20 +3156,14 @@ loop_break(codegen_scope *s, node *tree) raise_error(s, "unexpected break"); return; } - if (n > 0) { - genop_1(s, OP_POPERR, n); - } if (loop->type == LOOP_NORMAL) { int tmp; - if (s->ensure_level > s->loop->ensure_level) { - genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level); - } if (tree) { gen_move(s, loop->acc, cursp(), 0); } - tmp = genjmp(s, OP_JMP, loop->pc3); + tmp = genjmp(s, OP_JUW, loop->pc3); loop->pc3 = tmp; } else { diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c index 191ab062d..7030299f4 100644 --- a/mrbgems/mruby-os-memsize/src/memsize.c +++ b/mrbgems/mruby-os-memsize/src/memsize.c @@ -133,8 +133,6 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj) size += mrb_objspace_page_slot_size() + sizeof(struct RFiber) + sizeof(struct mrb_context) + - sizeof(struct RProc *) * f->cxt->esize + - sizeof(uint16_t *) * f->cxt->rsize + sizeof(mrb_value) * stack_size + sizeof(mrb_callinfo) * ci_size; break; diff --git a/src/codedump.c b/src/codedump.c index 81212921d..095028a39 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -261,6 +261,9 @@ codedump(mrb_state *mrb, const mrb_irep *irep) CASE(OP_JMP, S); printf("OP_JMP\t\t%03d\n", a); break; + CASE(OP_JUW, S); + printf("OP_JUW\t\t%03d\n", a); + break; CASE(OP_JMPIF, BS); printf("OP_JMPIF\tR%d\t%03d\t", a, b); print_lv_a(mrb, irep, a); diff --git a/src/gc.c b/src/gc.c index ab9779e1b..17f7e81e4 100644 --- a/src/gc.c +++ b/src/gc.c @@ -640,7 +640,6 @@ mark_context_stack(mrb_state *mrb, struct mrb_context *c) static void mark_context(mrb_state *mrb, struct mrb_context *c) { - int i; mrb_callinfo *ci; start: @@ -657,10 +656,6 @@ mark_context(mrb_state *mrb, struct mrb_context *c) mrb_gc_mark(mrb, (struct RBasic*)ci->target_class); } } - /* mark ensure stack */ - for (i=0; ieidx; i++) { - mrb_gc_mark(mrb, (struct RBasic*)c->ensure[i]); - } /* mark fibers */ mrb_gc_mark(mrb, (struct RBasic*)c->fib); if (c->prev) { @@ -1014,9 +1009,6 @@ gc_gray_counts(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) if (c->stbase + i > c->stend) i = c->stend - c->stbase; children += i; - /* mark ensure stack */ - children += c->eidx; - /* mark closure */ if (c->cibase) { for (i=0, ci = c->cibase; ci <= c->ci; i++, ci++) diff --git a/src/state.c b/src/state.c index 7a1283fa6..1f85448a1 100644 --- a/src/state.c +++ b/src/state.c @@ -171,8 +171,6 @@ mrb_free_context(mrb_state *mrb, struct mrb_context *c) if (!c) return; mrb_free(mrb, c->stbase); mrb_free(mrb, c->cibase); - mrb_free(mrb, c->rescue); - mrb_free(mrb, c->ensure); mrb_free(mrb, c); } diff --git a/src/vm.c b/src/vm.c index d11caa5c7..cc6f087f9 100644 --- a/src/vm.c +++ b/src/vm.c @@ -23,6 +23,7 @@ #include #include "value_array.h" #include +#include #ifdef MRB_DISABLE_STDIO #if defined(__cplusplus) @@ -280,8 +281,6 @@ cipush(mrb_state *mrb, const mrb_code *pc, int push_stacks, int acc, ci->mid = mid; ci->proc = proc; ci->stackent = c->stack; - ci->epos = c->eidx; - ci->ridx = ci[-1].ridx; ci->pc = pc; ci->argc = argc; ci->acc = acc; @@ -329,54 +328,6 @@ cipop(mrb_state *mrb) void mrb_exc_set(mrb_state *mrb, mrb_value exc); static mrb_value mrb_run(mrb_state *mrb, const struct RProc* proc, mrb_value self); -static void -ecall(mrb_state *mrb) -{ - struct RProc *p; - struct mrb_context *c = mrb->c; - mrb_callinfo *ci = c->ci; - struct RObject *exc; - struct REnv *env; - ptrdiff_t cioff; - int ai = mrb_gc_arena_save(mrb); - uint16_t i; - int nregs; - - if (c->eidx == 0) return; - i = --c->eidx; - - /* restrict total call depth of ecall() */ - if (++mrb->ecall_nest > MRB_ECALL_DEPTH_MAX) { - mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err)); - } - p = c->ensure[i]; - if (!p) return; - mrb_assert(!MRB_PROC_CFUNC_P(p)); - c->ensure[i] = NULL; - nregs = p->upper->body.irep->nregs; - if (ci->proc && !MRB_PROC_CFUNC_P(ci->proc) && - ci->proc->body.irep->nregs > nregs) { - nregs = ci->proc->body.irep->nregs; - } - cioff = ci - c->cibase; - ci = cipush(mrb, NULL, nregs, CI_ACC_SKIP, MRB_PROC_TARGET_CLASS(p), p, ci->mid, 0); - env = MRB_PROC_ENV(p); - mrb_assert(env); - exc = mrb->exc; mrb->exc = 0; - if (exc) { - mrb_gc_protect(mrb, mrb_obj_value(exc)); - } - if (mrb->c->fib) { - mrb_gc_protect(mrb, mrb_obj_value(mrb->c->fib)); - } - mrb_run(mrb, p, env->stack[0]); - mrb->c = c; - c->ci = c->cibase + cioff; - if (!mrb->exc) mrb->exc = exc; - mrb_gc_arena_restore(mrb, ai); - mrb->ecall_nest--; -} - #ifndef MRB_FUNCALL_ARGC_MAX #define MRB_FUNCALL_ARGC_MAX 16 #endif @@ -821,17 +772,56 @@ mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const } static struct RBreak* -break_new(mrb_state *mrb, const struct RProc *p, mrb_value val) +break_new(mrb_state *mrb, uint32_t tag, const struct RProc *p, mrb_value val) { struct RBreak *brk; brk = (struct RBreak*)mrb_obj_alloc(mrb, MRB_TT_BREAK, NULL); mrb_break_proc_set(brk, p); mrb_break_value_set(brk, val); + mrb_break_tag_set(brk, tag); return brk; } +#define MRB_CATCH_FILTER_RESCUE (UINT32_C(1) << MRB_CATCH_RESCUE) +#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE) +#define MRB_CATCH_FILTER_ALL (MRB_CATCH_FILTER_RESCUE | MRB_CATCH_FILTER_ENSURE) + +static const struct mrb_irep_catch_hander * +catch_handler_find(mrb_state *mrb, mrb_callinfo *ci, const mrb_code *pc, uint32_t filter) +{ + mrb_irep *irep; + ptrdiff_t xpc; + size_t cnt; + const struct mrb_irep_catch_hander *e; + +/* The comparison operators use `>` and `<=` because pc already points to the next instruction */ +#define catch_cover_p(pc, beg, end) ((pc) > (beg) && (pc) <= (end)) + + if (ci->proc == NULL || MRB_PROC_CFUNC_P(ci->proc)) return NULL; + irep = ci->proc->body.irep; + if (irep->clen < 1) return NULL; + xpc = pc - irep->iseq; + /* If it retry at the top level, pc will be 0, so check with -1 as the start position */ + mrb_assert(catch_cover_p(xpc, -1, irep->ilen)); + if (!catch_cover_p(xpc, -1, irep->ilen)) return NULL; + + /* Currently uses a simple linear search to avoid processing complexity. */ + cnt = irep->clen; + e = mrb_irep_catch_handler_table(irep) + cnt - 1; + for (; cnt > 0; cnt --, e --) { + if (((UINT32_C(1) << e->type) & filter) && + catch_cover_p(xpc, bin_to_uint16(e->begin), bin_to_uint16(e->end))) { + return e; + } + } + +#undef catch_cover_p + + return NULL; +} + typedef enum { LOCALJUMP_ERROR_RETURN = 0, LOCALJUMP_ERROR_BREAK = 1, @@ -878,6 +868,81 @@ argnum_error(mrb_state *mrb, mrb_int num) mrb_exc_set(mrb, exc); } +static mrb_bool +break_tag_p(struct RBreak *brk, uint32_t tag) +{ + return (brk != NULL && brk->tt == MRB_TT_BREAK) ? TRUE : FALSE; +} + +static void +prepare_tagged_break(mrb_state *mrb, uint32_t tag, struct RProc *proc, mrb_value val) +{ + if (break_tag_p((struct RBreak*)mrb->exc, tag)) { + mrb_break_tag_set((struct RBreak*)mrb->exc, tag); + } + else { + mrb->exc = (struct RObject*)break_new(mrb, tag, proc, val); + } +} + +#define THROW_TAGGED_BREAK(mrb, tag, proc, val) \ + do { \ + prepare_tagged_break(mrb, tag, proc, val); \ + goto L_CATCH_TAGGED_BREAK; \ + } while (0) + +#define UNWIND_ENSURE(mrb, ci, pc, tag, proc, val) \ + do { \ + ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \ + if (ch) { \ + THROW_TAGGED_BREAK(mrb, tag, proc, val); \ + } \ + } while (0) + +/* + * CHECKPOINT_RESTORE(tag) { + * This part is executed when jumping by the same "tag" of RBreak (it is not executed the first time). + * Write the code required (initialization of variables, etc.) for the subsequent processing. + * } + * CHECKPOINT_MAIN(tag) { + * This part is always executed. + * } + * CHECKPOINT_END(tag); + * + * ... + * + * // Jump to CHECKPOINT_RESTORE with the same "tag". + * goto CHECKPOINT_LABEL_MAKE(tag); + */ + +#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag + +#define CHECKPOINT_RESTORE(tag) \ + do { \ + DEBUG_ONLY_EXPR(int current_checkpoint_tag); \ + DEBUG_ONLY_EXPR(current_checkpoint_tag = (tag)); \ + if (FALSE) { \ + CHECKPOINT_LABEL_MAKE(tag): \ + DEBUG_ONLY_EXPR(current_checkpoint_tag = (tag)); \ + do { + +#define CHECKPOINT_MAIN(tag) \ + } while (0); \ + } \ + mrb_assert((tag) == current_checkpoint_tag); \ + do { + +#define CHECKPOINT_END(tag) \ + } while (0); \ + mrb_assert((tag) == current_checkpoint_tag); \ + } while (0) + +#ifdef MRB_DEBUG +#define DEBUG_ONLY_EXPR(e) e +#else +#define DEBUG_ONLY_EXPR(e) ((void)0) +#endif + #define ERR_PC_SET(mrb) mrb->c->ci->err = pc0; #define ERR_PC_CLR(mrb) mrb->c->ci->err = 0; #ifdef MRB_ENABLE_DEBUG_HOOK @@ -976,6 +1041,7 @@ mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *pc) uint16_t b; uint8_t c; mrb_sym mid; + const struct mrb_irep_catch_hander *ch; #ifdef DIRECT_THREADED static void *optable[] = { @@ -1231,6 +1297,30 @@ RETRY_TRY_BLOCK: NEXT; } + CASE(OP_JUW, S) { + CHECKPOINT_RESTORE(RBREAK_TAG_JUMP) { + struct RBreak *brk = (struct RBreak*)mrb->exc; + mrb_value target = mrb_break_value_get(brk); + mrb_assert(mrb_fixnum_p(target)); + a = mrb_fixnum(target); + mrb_assert(a >= 0 && a < irep->ilen); + } + CHECKPOINT_MAIN(RBREAK_TAG_JUMP) { + ch = catch_handler_find(mrb, mrb->c->ci, pc, MRB_CATCH_FILTER_ENSURE); + if (ch) { + /* avoiding a jump from a catch handler into the same handler */ + if (a < bin_to_uint16(ch->begin) || a >= bin_to_uint16(ch->end)) { + THROW_TAGGED_BREAK(mrb, RBREAK_TAG_JUMP, proc, mrb_fixnum_value(a)); + } + } + } + CHECKPOINT_END(RBREAK_TAG_JUMP); + + mrb->exc = NULL; /* clear break object */ + pc = irep->iseq + a; + JUMP; + } + CASE(OP_EXCEPT, B) { mrb_value exc; @@ -1563,6 +1653,7 @@ RETRY_TRY_BLOCK: mrb_gc_arena_restore(mrb, ai); if (mrb->exc) goto L_RAISE; ci = mrb->c->ci; + mrb_assert(!mrb_break_p(v)); if (!ci->target_class) { /* return from context modifying method (resume/yield) */ if (ci->acc == CI_ACC_RESUMED) { mrb->jmp = prev_jmp; @@ -1839,13 +1930,7 @@ RETRY_TRY_BLOCK: c = OP_R_NORMAL; L_RETURN: { - mrb_callinfo *ci; - -#define ecall_adjust() do {\ - ptrdiff_t cioff = ci - mrb->c->cibase;\ - ecall(mrb);\ - ci = mrb->c->cibase + cioff;\ -} while (0) + mrb_callinfo *ci; ci = mrb->c->ci; if (ci->mid) { @@ -1873,17 +1958,20 @@ RETRY_TRY_BLOCK: L_RAISE: ci0 = ci = mrb->c->ci; if (ci == mrb->c->cibase) { - if (ci->ridx == 0) goto L_FTOP; - goto L_RESCUE; + ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL); + if (ch == NULL) goto L_FTOP; + goto L_CATCH; } - while (ci[0].ridx == ci[-1].ridx) { + while ((ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL)) == NULL) { ci = cipop(mrb); if (ci[1].acc == CI_ACC_SKIP && prev_jmp) { mrb->jmp = prev_jmp; MRB_THROW(prev_jmp); } + pc = ci[1].pc; if (ci == mrb->c->cibase) { - if (ci->ridx == 0) { + ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL); + if (ch == NULL) { L_FTOP: /* fiber top */ if (mrb->c == mrb->root_c) { mrb->c->stack = mrb->c->stbase; @@ -1892,9 +1980,6 @@ RETRY_TRY_BLOCK: else { struct mrb_context *c = mrb->c; - while (c->eidx > ci->epos) { - ecall_adjust(); - } c->status = MRB_FIBER_TERMINATED; mrb->c = c->prev; c->prev = NULL; @@ -1903,15 +1988,13 @@ RETRY_TRY_BLOCK: } break; } - /* call ensure only when we skip this callinfo */ - if (ci[0].ridx == ci[-1].ridx) { - while (mrb->c->eidx > ci->epos) { - ecall_adjust(); - } - } } - L_RESCUE: - if (ci->ridx == 0) goto L_STOP; + L_CATCH: + if (ch == NULL) goto L_STOP; + if (FALSE) { + L_CATCH_TAGGED_BREAK: /* from THROW_TAGGED_BREAK() or UNWIND_ENSURE() */ + ci = ci0 = mrb->c->ci; + } proc = ci->proc; irep = proc->body.irep; pool = irep->pool; @@ -1920,7 +2003,7 @@ RETRY_TRY_BLOCK: mrb->c->stack = ci[1].stackent; } mrb_stack_extend(mrb, irep->nregs); - pc = irep->iseq+mrb->c->rescue[--ci->ridx]; + pc = irep->iseq + bin_to_uint16(ch->target); } else { int acc; @@ -1950,8 +2033,19 @@ RETRY_TRY_BLOCK: localjump_error(mrb, LOCALJUMP_ERROR_RETURN); goto L_RAISE; } - ci--; + CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_BLOCK) { + cibase = mrb->c->cibase; + dst = top_proc(mrb, proc); + } + CHECKPOINT_MAIN(RBREAK_TAG_RETURN_BLOCK) { + UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN_BLOCK, proc, v); + } + CHECKPOINT_END(RBREAK_TAG_RETURN_BLOCK); + pc = ci->pc; + ci = cipop(mrb); } + mrb->exc = NULL; /* clear break object */ + proc = ci->proc; if (ci <= cibase) { localjump_error(mrb, LOCALJUMP_ERROR_RETURN); goto L_RAISE; @@ -1966,16 +2060,20 @@ RETRY_TRY_BLOCK: if (!c->prev) { /* toplevel return */ regs[irep->nlocals] = v; - goto L_STOP; + goto CHECKPOINT_LABEL_MAKE(RBREAK_TAG_STOP); } if (c->prev->ci == c->prev->cibase) { mrb_value exc = mrb_exc_new_str_lit(mrb, E_FIBER_ERROR, "double resume"); mrb_exc_set(mrb, exc); goto L_RAISE; } - while (c->eidx > 0) { - ecall(mrb); + CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_TOPLEVEL) { + c = mrb->c; } + CHECKPOINT_MAIN(RBREAK_TAG_RETURN_TOPLEVEL) { + UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN_TOPLEVEL, proc, v); + } + CHECKPOINT_END(RBREAK_TAG_RETURN_TOPLEVEL); /* automatic yield at the end */ c->status = MRB_FIBER_TERMINATED; mrb->c = c->prev; @@ -1983,6 +2081,14 @@ RETRY_TRY_BLOCK: mrb->c->status = MRB_FIBER_RUNNING; ci = mrb->c->ci; } + CHECKPOINT_RESTORE(RBREAK_TAG_RETURN) { + /* do nothing */ + } + CHECKPOINT_MAIN(RBREAK_TAG_RETURN) { + UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN, proc, v); + } + CHECKPOINT_END(RBREAK_TAG_RETURN); + mrb->exc = NULL; /* clear break object */ break; case OP_R_BREAK: if (MRB_PROC_STRICT_P(proc)) goto NORMAL_RETURN; @@ -2005,9 +2111,13 @@ RETRY_TRY_BLOCK: goto L_BREAK_ERROR; } } - while (mrb->c->eidx > mrb->c->ci->epos) { - ecall_adjust(); + CHECKPOINT_RESTORE(RBREAK_TAG_BREAK) { + /* do nothing */ } + CHECKPOINT_MAIN(RBREAK_TAG_BREAK) { + UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK, proc, v); + } + CHECKPOINT_END(RBREAK_TAG_BREAK); /* break from fiber block */ if (ci == mrb->c->cibase && ci->pc) { struct mrb_context *c = mrb->c; @@ -2017,45 +2127,64 @@ RETRY_TRY_BLOCK: ci = mrb->c->ci; } if (ci->acc < 0) { + ci = cipop(mrb); mrb_gc_arena_restore(mrb, ai); mrb->c->vmexec = FALSE; - mrb->exc = (struct RObject*)break_new(mrb, proc, v); + mrb->exc = (struct RObject*)break_new(mrb, RBREAK_TAG_BREAK, proc, v); mrb->jmp = prev_jmp; MRB_THROW(prev_jmp); } if (FALSE) { + struct RBreak *brk; + L_BREAK: - v = mrb_break_value_get((struct RBreak*)mrb->exc); - proc = mrb_break_proc_get((struct RBreak*)mrb->exc); - mrb->exc = NULL; + brk = (struct RBreak*)mrb->exc; + proc = mrb_break_proc_get(brk); + v = mrb_break_value_get(brk); ci = mrb->c->ci; + + switch (mrb_break_tag_get(brk)) { +#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n); + RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS) +#undef DISPATCH_CHECKPOINTS + default: + mrb_assert(!"wrong break tag"); + } } mrb->c->stack = ci->stackent; - proc = proc->upper; - while (mrb->c->cibase < ci && ci[-1].proc != proc) { + while (mrb->c->cibase < ci && ci[-1].proc != proc->upper) { if (ci[-1].acc == CI_ACC_SKIP) { - while (ci < mrb->c->ci) { - cipop(mrb); - } goto L_BREAK_ERROR; } - ci--; + CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_UPPER) { + /* do nothing */ + } + CHECKPOINT_MAIN(RBREAK_TAG_BREAK_UPPER) { + UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK_UPPER, proc, v); + } + CHECKPOINT_END(RBREAK_TAG_BREAK_UPPER); + pc = ci->pc; + ci = cipop(mrb); } + CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_INTARGET) { + /* do nothing */ + } + CHECKPOINT_MAIN(RBREAK_TAG_BREAK_INTARGET) { + UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK_INTARGET, proc, v); + } + CHECKPOINT_END(RBREAK_TAG_BREAK_INTARGET); if (ci == mrb->c->cibase) { goto L_BREAK_ERROR; } + mrb->exc = NULL; /* clear break object */ break; default: /* cannot happen */ break; } - while (ci < mrb->c->ci) { - cipop(mrb); - } - ci[0].ridx = ci[-1].ridx; - while (mrb->c->eidx > ci->epos) { - ecall_adjust(); - } + mrb_assert(ci == mrb->c->ci); + mrb_assert(mrb->exc == NULL); + if (mrb->c->vmexec && !ci->target_class) { mrb_gc_arena_restore(mrb, ai); mrb->c->vmexec = FALSE; @@ -2679,14 +2808,18 @@ RETRY_TRY_BLOCK: CASE(OP_STOP, Z) { /* stop VM */ - L_STOP: - while (mrb->c->eidx > 0) { - ecall(mrb); + CHECKPOINT_RESTORE(RBREAK_TAG_STOP) { + /* do nothing */ + } + CHECKPOINT_MAIN(RBREAK_TAG_STOP) { + UNWIND_ENSURE(mrb, mrb->c->ci, pc, RBREAK_TAG_STOP, proc, mrb_nil_value()); } - mrb->c->cibase->ridx = 0; + CHECKPOINT_END(RBREAK_TAG_STOP); + L_STOP: ERR_PC_CLR(mrb); mrb->jmp = prev_jmp; if (mrb->exc) { + mrb_assert(mrb->exc->tt == MRB_TT_EXCEPTION); return mrb_obj_value(mrb->exc); } return regs[irep->nlocals]; @@ -2696,6 +2829,10 @@ RETRY_TRY_BLOCK: #undef regs } MRB_CATCH(&c_jmp) { + mrb_callinfo *ci = mrb->c->ci; + while (ci > mrb->c->cibase && ci->acc == CI_ACC_DIRECT) { + ci = cipop(mrb); + } exc_catched = TRUE; goto RETRY_TRY_BLOCK; } -- cgit v1.2.3 From bfb7b491cc13776cc4b44671d1605f8fb1da7514 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 26 Jul 2020 11:45:24 +0900 Subject: Restore the variable `pc` after `longjmp()` Changes made after `setjmp()` are destroyed and need reassignment. This problem is now caused by the addition of the `OP_JUW` instruction. When actually building on FreeBSD 12.1 with `clang10 -fsanitize=address`, mrbtest "NameError#name [15.2.31.2.1]" is failed. However, qualifying `pc` with `volatile` slows down significantly and increases the object code. Suppress them by qualifying only the variables that restore `pc`. --- src/vm.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index cc6f087f9..42280f0a1 100644 --- a/src/vm.c +++ b/src/vm.c @@ -966,7 +966,7 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, struct RProc *proc, mrb_value #ifndef DIRECT_THREADED #define INIT_DISPATCH for (;;) { insn = BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); switch (insn) { -#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops (); +#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops (); pc_save = pc; #define NEXT break #define JUMP NEXT #define END_DISPATCH }} @@ -974,7 +974,7 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, struct RProc *proc, mrb_value #else #define INIT_DISPATCH JUMP; return mrb_nil_value(); -#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); +#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); pc_save = pc; #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn] #define JUMP NEXT @@ -1030,6 +1030,7 @@ 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; + const mrb_code *volatile pc_save = pc; const mrb_irep *irep = proc->body.irep; const mrb_pool_value *pool = irep->pool; const mrb_sym *syms = irep->syms; @@ -2834,6 +2835,7 @@ RETRY_TRY_BLOCK: ci = cipop(mrb); } exc_catched = TRUE; + pc = pc_save; goto RETRY_TRY_BLOCK; } MRB_END_EXC(&c_jmp); -- cgit v1.2.3 From 6bc5857125029aa519371b10625f7384767d7138 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 26 Jul 2020 11:49:08 +0900 Subject: Suppress warnings for C++ Variables in jump destination block separate declaration and assignment. --- src/vm.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 42280f0a1..9b501808b 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2018,7 +2018,8 @@ RETRY_TRY_BLOCK: case OP_R_RETURN: /* Fall through to OP_R_NORMAL otherwise */ if (ci->acc >=0 && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) { - mrb_callinfo *cibase = mrb->c->cibase; + mrb_callinfo *cibase; + cibase = mrb->c->cibase; dst = top_proc(mrb, proc); if (MRB_PROC_ENV_P(dst)) { @@ -2057,7 +2058,8 @@ RETRY_TRY_BLOCK: case OP_R_NORMAL: NORMAL_RETURN: if (ci == mrb->c->cibase) { - struct mrb_context *c = mrb->c; + struct mrb_context *c; + c = mrb->c; if (!c->prev) { /* toplevel return */ regs[irep->nlocals] = v; -- cgit v1.2.3 From cb89e1f0d9d9f05e53705d228b69decbc428a650 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 8 Aug 2020 15:13:39 +0900 Subject: Adjust PR #5060 to the latest `mruby3` branch. --- src/array.c | 1 + src/class.c | 2 +- src/dump.c | 5 +++-- src/proc.c | 1 + src/vm.c | 2 +- 5 files changed, 7 insertions(+), 4 deletions(-) (limited to 'src/vm.c') diff --git a/src/array.c b/src/array.c index 4f2b5466c..f86743138 100644 --- a/src/array.c +++ b/src/array.c @@ -1315,6 +1315,7 @@ static const mrb_sym each_syms[] = { static const mrb_irep each_irep = { 3, /* nlocals */ 7, /* nregs */ + 0, /* clen */ MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE, /* flags */ each_iseq, /* iseq */ NULL, /* pool */ diff --git a/src/class.c b/src/class.c index 5ce32439a..0e443da90 100644 --- a/src/class.c +++ b/src/class.c @@ -2287,7 +2287,7 @@ static const mrb_code new_iseq[] = { const mrb_sym new_syms[] = { MRB_SYM(allocate), MRB_SYM(initialize) }; static const mrb_irep new_irep = { - 3, 6, MRB_IREP_STATIC, + 3, 6, 0, MRB_IREP_STATIC, new_iseq, NULL, new_syms, NULL, NULL, NULL, sizeof(new_iseq), 0, 2, 0, 0, }; diff --git a/src/dump.c b/src/dump.c index 884c44dc6..b14fc4a1f 100644 --- a/src/dump.c +++ b/src/dump.c @@ -291,6 +291,7 @@ write_catch_table_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) const struct mrb_irep_catch_hander *e = mrb_irep_catch_handler_table(irep); mrb_static_assert1(sizeof(*e) == 7); + if (e == NULL) return 0; /* irep->clen has already been written before iseq block */ memcpy(cur, (const void *)e, sizeof(*e) * irep->clen); cur += sizeof(*e) * irep->clen; @@ -1058,7 +1059,7 @@ dump_irep_struct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, fputs("};\n", fp); } /* dump iseq */ - len=irep->ilen; + len=irep->ilen+sizeof(struct mrb_irep_catch_handler)*irep->clen; fprintf(fp, "static const mrb_code %s_iseq_%d[%d] = {", name, n, len); for (i=0; inlocals, irep->nregs); + fprintf(fp, " %d,%d,%d,\n", irep->nlocals, irep->nregs, irep->clen); fprintf(fp, " MRB_IREP_STATIC,%s_iseq_%d,\n", name, n); if (irep->pool) { fprintf(fp, " %s_pool_%d,", name, n); diff --git a/src/proc.c b/src/proc.c index 14ba407d8..de463df3e 100644 --- a/src/proc.c +++ b/src/proc.c @@ -17,6 +17,7 @@ static const mrb_code call_iseq[] = { static const mrb_irep call_irep = { 0, /* nlocals */ 2, /* nregs */ + 0, /* clen */ MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE, /* flags */ call_iseq, /* iseq */ NULL, /* pool */ diff --git a/src/vm.c b/src/vm.c index 9b501808b..4d3ab720a 100644 --- a/src/vm.c +++ b/src/vm.c @@ -875,7 +875,7 @@ break_tag_p(struct RBreak *brk, uint32_t tag) } static void -prepare_tagged_break(mrb_state *mrb, uint32_t tag, struct RProc *proc, mrb_value val) +prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb_value val) { if (break_tag_p((struct RBreak*)mrb->exc, tag)) { mrb_break_tag_set((struct RBreak*)mrb->exc, tag); -- cgit v1.2.3 From 500f721f7080e79c2e41e306cc1d94471c10f173 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 8 Aug 2020 15:12:42 +0900 Subject: Fix typo `_hander` -> `_handler`. --- include/mruby/irep.h | 8 ++++---- mrbgems/mruby-compiler/core/codegen.c | 30 +++++++++++++++--------------- src/codedump.c | 2 +- src/dump.c | 4 ++-- src/load.c | 4 ++-- src/vm.c | 8 ++++---- 6 files changed, 28 insertions(+), 28 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby/irep.h b/include/mruby/irep.h index 430602279..b800403ce 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -44,7 +44,7 @@ enum mrb_catch_type { MRB_CATCH_ENSURE = 1, }; -struct mrb_irep_catch_hander { +struct mrb_irep_catch_handler { uint8_t type; /* enum mrb_catch_type */ uint8_t begin[2]; /* The starting address to match the hander. Includes this. */ uint8_t end[2]; /* The endpoint address that matches the hander. Not Includes this. */ @@ -125,14 +125,14 @@ struct mrb_insn_data { struct mrb_insn_data mrb_decode_insn(const mrb_code *pc); -static inline const struct mrb_irep_catch_hander * +static inline const struct mrb_irep_catch_handler * mrb_irep_catch_handler_table(const struct mrb_irep *irep) { if (irep->clen > 0) { - return (const struct mrb_irep_catch_hander *)(irep->iseq + irep->ilen); + return (const struct mrb_irep_catch_handler*)(irep->iseq + irep->ilen); } else { - return (const struct mrb_irep_catch_hander *)NULL; + return (const struct mrb_irep_catch_handler*)NULL; } } diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index b3ce388a9..2ede5b81e 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -71,7 +71,7 @@ typedef struct scope { mrb_pool_value *pool; mrb_sym *syms; mrb_irep **reps; - struct mrb_irep_catch_hander *catch_table; + struct mrb_irep_catch_handler *catch_table; uint32_t pcapa, scapa, rcapa; uint16_t nlocals; @@ -97,8 +97,8 @@ static void loop_pop(codegen_scope *s, int val); * - Larger start position * - Same start position but smaller end position */ -static int catch_hander_new(codegen_scope *s); -static void catch_hander_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target); +static int catch_handler_new(codegen_scope *s); +static void catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target); static void gen_assignment(codegen_scope *s, node *tree, int sp, int val); static void gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val); @@ -1468,14 +1468,14 @@ codegen(codegen_scope *s, node *tree, int val) if (tree->car == NULL) goto exit; lp = loop_push(s, LOOP_BEGIN); lp->pc0 = new_label(s); - catch_entry = catch_hander_new(s); + catch_entry = catch_handler_new(s); begin = s->pc; codegen(s, tree->car, VAL); pop(); lp->type = LOOP_RESCUE; end = s->pc; noexc = genjmp(s, OP_JMP, 0); - catch_hander_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc); + catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc); tree = tree->cdr; exend = 0; pos1 = 0; @@ -1558,7 +1558,7 @@ codegen(codegen_scope *s, node *tree, int val) int catch_entry, begin, end, target; int idx; - catch_entry = catch_hander_new(s); + catch_entry = catch_handler_new(s); begin = s->pc; codegen(s, tree->car, val); end = target = s->pc; @@ -1570,7 +1570,7 @@ codegen(codegen_scope *s, node *tree, int val) pop(); genop_1(s, OP_RAISEIF, idx); pop(); - catch_hander_set(s, catch_entry, MRB_CATCH_ENSURE, begin, end, target); + catch_handler_set(s, catch_entry, MRB_CATCH_ENSURE, begin, end, target); } else { /* empty ensure ignored */ codegen(s, tree->car, val); @@ -2038,14 +2038,14 @@ codegen(codegen_scope *s, node *tree, int val) lp = loop_push(s, LOOP_BEGIN); lp->pc0 = new_label(s); - catch_entry = catch_hander_new(s); + catch_entry = catch_handler_new(s); begin = s->pc; exc = cursp(); codegen(s, tree->car, VAL); end = s->pc; noexc = genjmp(s, OP_JMP, 0); lp->type = LOOP_RESCUE; - catch_hander_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc); + catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc); genop_1(s, OP_EXCEPT, exc); genop_1(s, OP_LOADF, exc); dispatch(s, noexc); @@ -3081,7 +3081,7 @@ scope_finish(codegen_scope *s) } irep->flags = 0; if (s->iseq) { - size_t catchsize = sizeof(struct mrb_irep_catch_hander) * irep->clen; + size_t catchsize = sizeof(struct mrb_irep_catch_handler) * irep->clen; irep->iseq = (const mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc + catchsize); irep->ilen = s->pc; if (irep->clen > 0) { @@ -3187,17 +3187,17 @@ loop_pop(codegen_scope *s, int val) } static int -catch_hander_new(codegen_scope *s) +catch_handler_new(codegen_scope *s) { - size_t newsize = sizeof(struct mrb_irep_catch_hander) * (s->irep->clen + 1); - s->catch_table = (struct mrb_irep_catch_hander *)codegen_realloc(s, (void *)s->catch_table, newsize); + size_t newsize = sizeof(struct mrb_irep_catch_handler) * (s->irep->clen + 1); + s->catch_table = (struct mrb_irep_catch_handler *)codegen_realloc(s, (void *)s->catch_table, newsize); return s->irep->clen ++; } static void -catch_hander_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target) +catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target) { - struct mrb_irep_catch_hander *e; + struct mrb_irep_catch_handler *e; mrb_assert(ent >= 0 && ent < s->irep->clen); mrb_assert(begin < MAXARG_S); diff --git a/src/codedump.c b/src/codedump.c index 095028a39..389ed3c8f 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -83,7 +83,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) if (irep->clen > 0) { int i = irep->clen; - const struct mrb_irep_catch_hander *e = mrb_irep_catch_handler_table(irep); + const struct mrb_irep_catch_handler *e = mrb_irep_catch_handler_table(irep); for (; i > 0; i --, e ++) { int begin = bin_to_uint16(e->begin); diff --git a/src/dump.c b/src/dump.c index b14fc4a1f..3bc95f629 100644 --- a/src/dump.c +++ b/src/dump.c @@ -279,7 +279,7 @@ get_catch_table_block_size(mrb_state *mrb, const mrb_irep *irep) size_t size = 0; size += sizeof(uint16_t); /* number of catch handler */ - size += (sizeof(struct mrb_irep_catch_hander)) * irep->clen; + size += (sizeof(struct mrb_irep_catch_handler)) * irep->clen; return size; } @@ -288,7 +288,7 @@ static ptrdiff_t write_catch_table_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) { uint8_t *cur = buf; - const struct mrb_irep_catch_hander *e = mrb_irep_catch_handler_table(irep); + const struct mrb_irep_catch_handler *e = mrb_irep_catch_handler_table(irep); mrb_static_assert1(sizeof(*e) == 7); if (e == NULL) return 0; diff --git a/src/load.c b/src/load.c index 59790bc17..67217b128 100644 --- a/src/load.c +++ b/src/load.c @@ -105,8 +105,8 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag if (irep->ilen > 0) { size_t data_len = sizeof(mrb_code) * irep->ilen + - sizeof(struct mrb_irep_catch_hander) * irep->clen; - mrb_static_assert1(sizeof(struct mrb_irep_catch_hander) == 7); + sizeof(struct mrb_irep_catch_handler) * irep->clen; + mrb_static_assert1(sizeof(struct mrb_irep_catch_handler) == 7); if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) { return NULL; } diff --git a/src/vm.c b/src/vm.c index 4d3ab720a..727c37d53 100644 --- a/src/vm.c +++ b/src/vm.c @@ -788,13 +788,13 @@ break_new(mrb_state *mrb, uint32_t tag, const struct RProc *p, mrb_value val) #define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE) #define MRB_CATCH_FILTER_ALL (MRB_CATCH_FILTER_RESCUE | MRB_CATCH_FILTER_ENSURE) -static const struct mrb_irep_catch_hander * +static const struct mrb_irep_catch_handler * catch_handler_find(mrb_state *mrb, mrb_callinfo *ci, const mrb_code *pc, uint32_t filter) { - mrb_irep *irep; + const mrb_irep *irep; ptrdiff_t xpc; size_t cnt; - const struct mrb_irep_catch_hander *e; + const struct mrb_irep_catch_handler *e; /* The comparison operators use `>` and `<=` because pc already points to the next instruction */ #define catch_cover_p(pc, beg, end) ((pc) > (beg) && (pc) <= (end)) @@ -1042,7 +1042,7 @@ mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *pc) uint16_t b; uint8_t c; mrb_sym mid; - const struct mrb_irep_catch_hander *ch; + const struct mrb_irep_catch_handler *ch; #ifdef DIRECT_THREADED static void *optable[] = { -- cgit v1.2.3 From 107c777341c4768f0208e590a9ec6c8b9a241060 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 8 Aug 2020 15:57:42 +0900 Subject: Rename `OP_JUW` instruction to `OP_JMPUW`. --- doc/opcode.md | 2 +- include/mruby/ops.h | 2 +- mrbgems/mruby-compiler/core/codegen.c | 8 ++++---- src/codedump.c | 4 ++-- src/vm.c | 2 +- 5 files changed, 9 insertions(+), 9 deletions(-) (limited to 'src/vm.c') diff --git a/doc/opcode.md b/doc/opcode.md index abdee704f..513b28302 100644 --- a/doc/opcode.md +++ b/doc/opcode.md @@ -62,7 +62,7 @@ sign) of operands. | OP_JMPIF | BS | if R(a) pc=b | | OP_JMPNOT | BS | if !R(a) pc=b | | OP_JMPNIL | BS | if R(a)==nil pc=b | -| OP_JUW | S | unwind_and_jump_to(a) | +| OP_JMPUW | S | unwind_and_jump_to(a) | | OP_EXCEPT | B | R(a) = exc | | OP_RESCUE | BB | R(b) = R(a).isa?(R(b)) | | OP_RAISEIF | B | raise(R(a)) if R(a) | diff --git a/include/mruby/ops.h b/include/mruby/ops.h index 770e54f3d..75936a791 100644 --- a/include/mruby/ops.h +++ b/include/mruby/ops.h @@ -49,7 +49,7 @@ OPCODE(JMP, S) /* pc=a */ OPCODE(JMPIF, BS) /* if R(a) pc=b */ OPCODE(JMPNOT, BS) /* if !R(a) pc=b */ OPCODE(JMPNIL, BS) /* if R(a)==nil pc=b */ -OPCODE(JUW, S) /* unwind_and_jump_to(a) */ +OPCODE(JMPUW, S) /* unwind_and_jump_to(a) */ OPCODE(EXCEPT, B) /* R(a) = exc */ OPCODE(RESCUE, BB) /* R(b) = R(a).isa?(R(b)) */ OPCODE(RAISEIF, B) /* raise(R(a)) if R(a) */ diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 2ede5b81e..f60f1f077 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2299,7 +2299,7 @@ codegen(codegen_scope *s, node *tree, int val) } else if (s->loop->type == LOOP_NORMAL) { codegen(s, tree, NOVAL); - genjmp(s, OP_JUW, s->loop->pc0); + genjmp(s, OP_JMPUW, s->loop->pc0); } else { if (tree) { @@ -2319,7 +2319,7 @@ codegen(codegen_scope *s, node *tree, int val) raise_error(s, "unexpected redo"); } else { - genjmp(s, OP_JUW, s->loop->pc2); + genjmp(s, OP_JMPUW, s->loop->pc2); } if (val) push(); break; @@ -2336,7 +2336,7 @@ codegen(codegen_scope *s, node *tree, int val) raise_error(s, msg); } else { - genjmp(s, OP_JUW, lp->pc0); + genjmp(s, OP_JMPUW, lp->pc0); } if (val) push(); } @@ -3163,7 +3163,7 @@ loop_break(codegen_scope *s, node *tree) if (tree) { gen_move(s, loop->acc, cursp(), 0); } - tmp = genjmp(s, OP_JUW, loop->pc3); + tmp = genjmp(s, OP_JMPUW, loop->pc3); loop->pc3 = tmp; } else { diff --git a/src/codedump.c b/src/codedump.c index 389ed3c8f..3f0801929 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -261,8 +261,8 @@ codedump(mrb_state *mrb, const mrb_irep *irep) CASE(OP_JMP, S); printf("OP_JMP\t\t%03d\n", a); break; - CASE(OP_JUW, S); - printf("OP_JUW\t\t%03d\n", a); + CASE(OP_JMPUW, S); + printf("OP_JMPUW\t\t%03d\n", a); break; CASE(OP_JMPIF, BS); printf("OP_JMPIF\tR%d\t%03d\t", a, b); diff --git a/src/vm.c b/src/vm.c index 727c37d53..82301aaf4 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1298,7 +1298,7 @@ RETRY_TRY_BLOCK: NEXT; } - CASE(OP_JUW, S) { + CASE(OP_JMPUW, S) { CHECKPOINT_RESTORE(RBREAK_TAG_JUMP) { struct RBreak *brk = (struct RBreak*)mrb->exc; mrb_value target = mrb_break_value_get(brk); -- cgit v1.2.3 From 8813ebec07b4da46bf21a06cd16987208a442991 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 12 Aug 2020 21:47:23 +0900 Subject: Skip array embedding if `MRB_NO_BOXING` and `MRB_32BIT`; fix #4382 On some platforms, `sizeof(mrb_value) > sizeof(void*)*3`, which makes `MRB_ARY_EMBED_LEN_MAX` zero. And zero sized array cause compile errors. --- include/mruby/array.h | 21 +++++++++++++++++++-- src/array.c | 10 ++++++++-- src/value_array.h | 1 + src/vm.c | 2 +- 4 files changed, 29 insertions(+), 5 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby/array.h b/include/mruby/array.h index 08cacaa1f..5164efa69 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -21,7 +21,14 @@ typedef struct mrb_shared_array { mrb_value *ptr; } mrb_shared_array; -#define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value))) +#if defined(MRB_32BIT) && defined(MRB_NO_BOXING) +# define MRB_ARY_NO_EMBED +# define MRB_ARY_EMBED_LEN_MAX 0 +#else +# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value))) +mrb_static_assert(MRB_ARY_EMBED_LEN_MAX > 0, "MRB_ARY_EMBED_LEN_MAX > 0"); +#endif + struct RArray { MRB_OBJECT_HEADER; union { @@ -33,7 +40,9 @@ struct RArray { } aux; mrb_value *ptr; } heap; +#ifndef MRB_ARY_NO_EMBED mrb_value ary[MRB_ARY_EMBED_LEN_MAX]; +#endif } as; }; @@ -41,13 +50,21 @@ struct RArray { #define mrb_ary_value(p) mrb_obj_value((void*)(p)) #define RARRAY(v) ((struct RArray*)(mrb_ptr(v))) +#ifdef MRB_ARY_NO_EMBED +#define ARY_EMBED_P(a) 0 +#define ARY_UNSET_EMBED_FLAG(a) (void)0 +#define ARY_EMBED_LEN(a) 0 +#define ARY_SET_EMBED_LEN(a,len) (void)0 +#define ARY_EMBED_PTR(a) 0 +#else #define MRB_ARY_EMBED_MASK 7 #define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK) #define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK)) #define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1)) #define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1)) #define ARY_EMBED_PTR(a) ((a)->as.ary) - +#endif + #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(a)->as.heap.len) #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr) #define RARRAY_LEN(a) ARY_LEN(RARRAY(a)) diff --git a/src/array.c b/src/array.c index f86743138..285600969 100644 --- a/src/array.c +++ b/src/array.c @@ -1123,8 +1123,14 @@ mrb_ary_clear(mrb_state *mrb, mrb_value self) else if (!ARY_EMBED_P(a)){ mrb_free(mrb, a->as.heap.ptr); } - ARY_SET_EMBED_LEN(a, 0); - + if (MRB_ARY_EMBED_LEN_MAX > 0) { + ARY_SET_EMBED_LEN(a, 0); + } + else { + a->as.heap.ptr = NULL; + a->as.heap.aux.capa = 0; + ARY_SET_LEN(a, 0); + } return self; } diff --git a/src/value_array.h b/src/value_array.h index bc5f28b06..6089b8aa0 100644 --- a/src/value_array.h +++ b/src/value_array.h @@ -6,6 +6,7 @@ static inline void value_move(mrb_value *s1, const mrb_value *s2, size_t n) { + if (n == 0) return; if (s1 > s2 && s1 < s2 + n) { s1 += n; diff --git a/src/vm.c b/src/vm.c index 82301aaf4..87606c1b4 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1823,7 +1823,7 @@ RETRY_TRY_BLOCK: if (kd) regs[len + 1] = kdict; /* copy mandatory and optional arguments */ - if (argv0 != argv) { + if (argv0 != argv && argv) { value_move(®s[1], argv, argc-mlen); /* m1 + o */ } if (argc < m1) { -- cgit v1.2.3 From 8a87549315d0c7fd984a8ad239ebe3dbab4d2855 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 14 Aug 2020 14:34:53 +0900 Subject: Rename float configuration option names. - `MRB_WITHOUT_FLOAT` => `MRB_NO_FLOAT` - `MRB_USE_FLOAT` => `MRB_USE_FLOAT32` The former is to use `USE_XXX` naming convention. The latter is to make sure `float` is 32bit float and not floating point number in general. --- doc/guides/mrbconf.md | 8 +-- doc/mruby3.md | 11 ++++ include/mrbconf.h | 22 ++++++-- include/mruby.h | 10 ++-- include/mruby/boxing_nan.h | 8 +-- include/mruby/boxing_no.h | 6 +- include/mruby/boxing_word.h | 12 ++-- include/mruby/class.h | 2 +- include/mruby/error.h | 4 +- include/mruby/numeric.h | 16 +++--- include/mruby/value.h | 10 ++-- mrbgems/mruby-compiler/core/codegen.c | 16 +++--- mrbgems/mruby-compiler/core/parse.y | 4 +- mrbgems/mruby-compiler/core/y.tab.c | 4 +- mrbgems/mruby-complex/src/complex.c | 8 +-- mrbgems/mruby-complex/test/complex.rb | 4 +- mrbgems/mruby-inline-struct/test/inline.c | 2 +- mrbgems/mruby-io/src/file.c | 4 +- mrbgems/mruby-io/src/io.c | 6 +- mrbgems/mruby-kernel-ext/src/kernel.c | 4 +- mrbgems/mruby-math/src/math.c | 4 +- mrbgems/mruby-numeric-ext/src/numeric_ext.c | 4 +- mrbgems/mruby-object-ext/src/object.c | 4 +- mrbgems/mruby-os-memsize/src/memsize.c | 2 +- mrbgems/mruby-pack/src/pack.c | 8 +-- mrbgems/mruby-random/src/random.c | 4 +- mrbgems/mruby-range-ext/src/range.c | 4 +- mrbgems/mruby-rational/src/rational.c | 6 +- mrbgems/mruby-sleep/src/mrb_sleep.c | 2 +- mrbgems/mruby-sprintf/src/sprintf.c | 10 ++-- mrbgems/mruby-string-ext/src/string.c | 2 +- mrbgems/mruby-test/driver.c | 4 +- mrbgems/mruby-test/vformat.c | 4 +- mrbgems/mruby-time/src/time.c | 20 +++---- src/array.c | 2 +- src/class.c | 4 +- src/dump.c | 10 ++-- src/error.c | 2 +- src/etc.c | 10 ++-- src/fmt_fp.c | 2 +- src/gc.c | 6 +- src/hash.c | 8 +-- src/load.c | 6 +- src/numeric.c | 88 ++++++++++++++--------------- src/object.c | 12 ++-- src/range.c | 2 +- src/string.c | 10 ++-- src/vm.c | 16 +++--- target/RX630.rb | 2 +- tasks/gitlab.rake | 4 +- test/t/float.rb | 2 +- 51 files changed, 223 insertions(+), 202 deletions(-) (limited to 'src/vm.c') diff --git a/doc/guides/mrbconf.md b/doc/guides/mrbconf.md index d662e05bf..c95634604 100644 --- a/doc/guides/mrbconf.md +++ b/doc/guides/mrbconf.md @@ -46,11 +46,11 @@ You can use mrbconfs with following ways: ## Primitive type configuration. -`MRB_USE_FLOAT` +`MRB_USE_FLOAT32` * When defined single precision floating point type(C type `float`) is used as `mrb_float`. -* Else double precision floating point type(C type `double`) is used as `mrb_float`. +* Otherwise double precision floating point type(C type `double`) is used as `mrb_float`. -`MRB_WITHOUT_FLOAT` +`MRB_NO_FLOAT` * When defined removes floating point numbers from mruby. * It makes mruby easier to handle in "Microcontroller without FPU" and "Kernel Space". @@ -117,7 +117,7 @@ largest value of required alignment. `MRB_NAN_BOXING` * If defined represent `mrb_value` in boxed `double`. -* Conflicts with `MRB_USE_FLOAT` and `MRB_WITHOUT_FLOAT`. +* Conflicts with `MRB_USE_FLOAT32` and `MRB_NO_FLOAT`. `MRB_WORD_BOXING` * If defined represent `mrb_value` as a word. diff --git a/doc/mruby3.md b/doc/mruby3.md index 29da25cbc..02884f51b 100644 --- a/doc/mruby3.md +++ b/doc/mruby3.md @@ -57,6 +57,17 @@ pull-request. Some configuration macro names are changed for consistency +== `MRB_NO_FLOAT` + +Changed from `MRB_WITHOUT_FLOAT` to conform `USE_XXX` naming +convention. + +== `MRB_USE_FLOAT32` + +Changed from `MRB_USE_FLOAT` to make sure `float` here means +using single precision float, and not the opposite of +`MRB_NO_FLOAT`. + == `MRB_USE_METHOD_T_STRUCT` Changed from `MRB_METHOD_T_STRUCT`. diff --git a/include/mrbconf.h b/include/mrbconf.h index 734ec98e7..159aee48f 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -25,14 +25,24 @@ #endif /* configuration options: */ -/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */ -//#define MRB_USE_FLOAT +/* add -DMRB_USE_FLOAT32 to use float instead of double for floating point numbers */ +//#define MRB_USE_FLOAT32 /* exclude floating point numbers */ -//#define MRB_WITHOUT_FLOAT +//#define MRB_NO_FLOAT -#if defined(MRB_USE_FLOAT) && defined(MRB_WITHOUT_FLOAT) -#error Cannot define MRB_USE_FLOAT and MRB_WITHOUT_FLOAT at the same time +/* obsolete configuration */ +#if defined(MRB_USE_FLOAT) +# define MRB_USE_FLOAT32 +#endif + +/* obsolete configuration */ +#if defined(MRB_WITHOUT_FLOAT) +# define MRB_NO_FLOAT +#endif + +#if defined(MRB_USE_FLOAT32) && defined(MRB_NO_FLOAT) +#error Cannot define MRB_USE_FLOAT32 and MRB_NO_FLOAT at the same time #endif /* stop inlining floating point numbers in mrb_value (effective only with MRB_WORD_BOXING)*/ @@ -65,7 +75,7 @@ # endif #endif -/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */ +/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT32 and MRB_NO_FLOAT */ //#define MRB_NAN_BOXING /* represent mrb_value as a word (natural unit of data for the processor) */ diff --git a/include/mruby.h b/include/mruby.h index dea0a9c88..485a94d70 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -92,7 +92,7 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #ifndef FLT_EPSILON #define FLT_EPSILON (1.19209290e-07f) @@ -104,7 +104,7 @@ #define LDBL_EPSILON (1.08420217248550443401e-19L) #endif -#ifdef MRB_USE_FLOAT +#ifdef MRB_USE_FLOAT32 #define MRB_FLOAT_EPSILON FLT_EPSILON #else #define MRB_FLOAT_EPSILON DBL_EPSILON @@ -245,7 +245,7 @@ typedef struct mrb_state { struct RClass *hash_class; struct RClass *range_class; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT struct RClass *float_class; #endif struct RClass *fixnum_class; @@ -1211,7 +1211,7 @@ MRB_API mrb_bool mrb_obj_equal(mrb_state *mrb, mrb_value a, mrb_value b); MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2); MRB_API mrb_value mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base); MRB_API mrb_value mrb_Integer(mrb_state *mrb, mrb_value val); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val); #endif MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj); @@ -1304,7 +1304,7 @@ MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap); #define E_FROZEN_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FrozenError))) #define E_NOTIMP_ERROR (mrb_exc_get_id(mrb, MRB_SYM(NotImplementedError))) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define E_FLOATDOMAIN_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FloatDomainError))) #endif diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index a8655ca19..eb89ac1f9 100644 --- a/include/mruby/boxing_nan.h +++ b/include/mruby/boxing_nan.h @@ -7,12 +7,12 @@ #ifndef MRUBY_BOXING_NAN_H #define MRUBY_BOXING_NAN_H -#ifdef MRB_USE_FLOAT -# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<---- +#ifdef MRB_USE_FLOAT32 +# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT32 conflict <<---- #endif -#ifdef MRB_WITHOUT_FLOAT -# error ---->> MRB_NAN_BOXING and MRB_WITHOUT_FLOAT conflict <<---- +#ifdef MRB_NO_FLOAT +# error ---->> MRB_NAN_BOXING and MRB_NO_FLOAT conflict <<---- #endif #ifdef MRB_INT64 diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h index 23b48c6f8..345f6b35b 100644 --- a/include/mruby/boxing_no.h +++ b/include/mruby/boxing_no.h @@ -11,7 +11,7 @@ #define MRB_SYMBOL_SHIFT 0 union mrb_value_union { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_float f; #endif void *p; @@ -26,7 +26,7 @@ typedef struct mrb_value { #define mrb_ptr(o) (o).value.p #define mrb_cptr(o) mrb_ptr(o) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define mrb_float(o) (o).value.f #endif #define mrb_fixnum(o) (o).value.i @@ -43,7 +43,7 @@ typedef struct mrb_value { #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1) #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1) #define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n)) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v)) #endif #define SET_SYM_VALUE(r,v) BOXNIX_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v)) diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index a91d10421..b9b6a3fe9 100644 --- a/include/mruby/boxing_word.h +++ b/include/mruby/boxing_word.h @@ -11,7 +11,7 @@ #error MRB_INT64 cannot be used with MRB_WORD_BOXING in 32-bit mode. #endif -#if !defined(MRB_WITHOUT_FLOAT) || defined(MRB_NO_FLOAT_INLINE) +#if !defined(MRB_NO_FLOAT) || defined(MRB_NO_FLOAT_INLINE) struct RFloat { MRB_OBJECT_HEADER; mrb_float f; @@ -80,7 +80,7 @@ union mrb_value_ { }; #endif struct RBasic *bp; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT struct RFloat *fp; #endif struct RCptr *vp; @@ -96,13 +96,13 @@ mrb_val_union(mrb_value v) } MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #endif #define mrb_ptr(o) mrb_val_union(o).p #define mrb_cptr(o) mrb_val_union(o).vp->p -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define mrb_float(o) mrb_val_union(o).fp->f #endif #define mrb_fixnum(o) BOXWORD_SHIFT_VALUE(o, FIXNUM, mrb_int) @@ -124,7 +124,7 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #define mrb_nil_p(o) ((o) == MRB_Qnil) #define mrb_false_p(o) ((o) == MRB_Qfalse) #define mrb_true_p(o) ((o) == MRB_Qtrue) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define mrb_float_p(o) BOXWORD_OBJ_TYPE_P(o, FLOAT) #endif #define mrb_array_p(o) BOXWORD_OBJ_TYPE_P(o, ARRAY) @@ -146,7 +146,7 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #define mrb_istruct_p(o) BOXWORD_OBJ_TYPE_P(o, ISTRUCT) #define mrb_break_p(o) BOXWORD_OBJ_TYPE_P(o, BREAK) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v)) #endif #define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_word_boxing_cptr_value(mrb, v)) diff --git a/include/mruby/class.h b/include/mruby/class.h index 88e5915e5..a02c4ef17 100644 --- a/include/mruby/class.h +++ b/include/mruby/class.h @@ -37,7 +37,7 @@ mrb_class(mrb_state *mrb, mrb_value v) return mrb->symbol_class; case MRB_TT_FIXNUM: return mrb->fixnum_class; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return mrb->float_class; #endif diff --git a/include/mruby/error.h b/include/mruby/error.h index 67a0a539e..b607dd957 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -32,7 +32,7 @@ MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_va /* declaration for `fail` method */ 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) +#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING) struct RBreak { MRB_OBJECT_HEADER; const struct RProc *proc; @@ -62,7 +62,7 @@ mrb_break_value_set(struct RBreak *brk, mrb_value val) brk->flags &= ~RBREAK_VALUE_TT_MASK; brk->flags |= val.tt; } -#endif /* MRB_64BIT || MRB_USE_FLOAT || MRB_NAN_BOXING || MRB_WORD_BOXING */ +#endif /* MRB_64BIT || MRB_USE_FLOAT32 || MRB_NAN_BOXING || MRB_WORD_BOXING */ #define mrb_break_proc_get(brk) ((brk)->proc) #define mrb_break_proc_set(brk, p) ((brk)->proc = p) diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index 06a33cc6f..10b242688 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -22,7 +22,7 @@ MRB_BEGIN_DECL #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int) #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int) #define FIXABLE(f) TYPED_FIXABLE(f,mrb_int) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #ifdef MRB_INT64 #define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0) #else @@ -30,12 +30,12 @@ MRB_BEGIN_DECL #endif #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val); #endif MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base); /* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt); MRB_API int mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float f); MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x); @@ -161,13 +161,13 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product) #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT # include # include # define MRB_FLT_RADIX FLT_RADIX -# ifdef MRB_USE_FLOAT +# ifdef MRB_USE_FLOAT32 # define MRB_FLT_MANT_DIG FLT_MANT_DIG # define MRB_FLT_EPSILON FLT_EPSILON # define MRB_FLT_DIG FLT_DIG @@ -178,7 +178,7 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product) # define MRB_FLT_MAX FLT_MAX # define MRB_FLT_MAX_10_EXP FLT_MAX_10_EXP -# else /* not MRB_USE_FLOAT */ +# else /* not MRB_USE_FLOAT32 */ # define MRB_FLT_MANT_DIG DBL_MANT_DIG # define MRB_FLT_EPSILON DBL_EPSILON # define MRB_FLT_DIG DBL_DIG @@ -188,8 +188,8 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product) # define MRB_FLT_MAX_EXP DBL_MAX_EXP # define MRB_FLT_MAX DBL_MAX # define MRB_FLT_MAX_10_EXP DBL_MAX_10_EXP -# endif /* MRB_USE_FLOAT */ -#endif /* MRB_WITHOUT_FLOAT */ +# endif /* MRB_USE_FLOAT32 */ +#endif /* MRB_NO_FLOAT */ MRB_END_DECL diff --git a/include/mruby/value.h b/include/mruby/value.h index 473774b00..88c8d4dba 100644 --- a/include/mruby/value.h +++ b/include/mruby/value.h @@ -75,9 +75,9 @@ struct mrb_state; # define MRB_ENDIAN_LOHI(a,b) b a #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API double mrb_float_read(const char*, char**); -#ifdef MRB_USE_FLOAT +#ifdef MRB_USE_FLOAT32 typedef float mrb_float; #else typedef double mrb_float; @@ -90,7 +90,7 @@ MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list ar MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...); # define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg) # define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__) -# if _MSC_VER < 1800 && !defined MRB_WITHOUT_FLOAT +# if _MSC_VER < 1800 && !defined MRB_NO_FLOAT # include # define isfinite(n) _finite(n) # define isnan _isnan @@ -195,7 +195,7 @@ struct RCptr { #ifndef mrb_true_p #define mrb_true_p(o) (mrb_type(o) == MRB_TT_TRUE) #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #ifndef mrb_float_p #define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT) #endif @@ -264,7 +264,7 @@ struct RCptr { * * Takes a float and boxes it into an mrb_value */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_INLINE mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f) { mrb_value v; diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index f60f1f077..372a2c5f7 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -530,7 +530,7 @@ new_lit(codegen_scope *s, mrb_value val) return i; } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: for (i=0; iirep->plen; i++) { mrb_float f1, f2; @@ -588,7 +588,7 @@ new_lit(codegen_scope *s, mrb_value val) } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: pv->tt = IREP_TT_FLOAT; pv->u.f = mrb_float(val); @@ -1330,7 +1330,7 @@ raise_error(codegen_scope *s, const char *msg) genop_1(s, OP_ERR, idx); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static double readint_float(codegen_scope *s, const char *p, int base) { @@ -2442,7 +2442,7 @@ codegen(codegen_scope *s, node *tree, int val) mrb_bool overflow; i = readint_mrb_int(s, p, base, FALSE, &overflow); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (overflow) { double f = readint_float(s, p, base); int off = new_lit(s, mrb_float_value(s->mrb, f)); @@ -2473,7 +2473,7 @@ codegen(codegen_scope *s, node *tree, int val) } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case NODE_FLOAT: if (val) { char *p = (char*)tree; @@ -2490,7 +2490,7 @@ codegen(codegen_scope *s, node *tree, int val) { nt = nint(tree->car); switch (nt) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case NODE_FLOAT: if (val) { char *p = (char*)tree->cdr; @@ -2511,7 +2511,7 @@ codegen(codegen_scope *s, node *tree, int val) mrb_bool overflow; i = readint_mrb_int(s, p, base, TRUE, &overflow); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (overflow) { double f = readint_float(s, p, base); int off = new_lit(s, mrb_float_value(s->mrb, -f)); @@ -2531,7 +2531,7 @@ codegen(codegen_scope *s, node *tree, int val) int off = new_lit(s, mrb_fixnum_value(i)); genop_2(s, OP_LOADL, cursp(), off); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT } #endif push(); diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index c67c694fe..8e3087a2a 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -981,7 +981,7 @@ new_int(parser_state *p, const char *s, int base, int suffix) return result; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* (:float . i) */ static node* new_float(parser_state *p, const char *s, int suffix) @@ -5661,7 +5661,7 @@ parser_yylex(parser_state *p) } tokfix(p); if (is_float) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT yywarning_s(p, "floating point numbers are not supported", tok(p)); pylval.nd = new_int(p, "0", 10, 0); return tINTEGER; diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 096543349..48173933f 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -1044,7 +1044,7 @@ new_int(parser_state *p, const char *s, int base, int suffix) return result; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* (:float . i) */ static node* new_float(parser_state *p, const char *s, int suffix) @@ -11553,7 +11553,7 @@ parser_yylex(parser_state *p) } tokfix(p); if (is_float) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT yywarning_s(p, "floating point numbers are not supported", tok(p)); pylval.nd = new_int(p, "0", 10, 0); return tINTEGER; diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 24dad4235..85735b704 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -3,8 +3,8 @@ #include #include -#ifdef MRB_WITHOUT_FLOAT -# error Complex conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb' +#ifdef MRB_NO_FLOAT +# error Complex conflicts with 'MRB_NO_FLOAT' configuration #endif struct mrb_complex { @@ -12,13 +12,13 @@ struct mrb_complex { mrb_float imaginary; }; -#ifdef MRB_USE_FLOAT +#ifdef MRB_USE_FLOAT32 #define F(x) x##f #else #define F(x) x #endif -#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT) +#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32) #define COMPLEX_USE_ISTRUCT /* use TT_ISTRUCT */ diff --git a/mrbgems/mruby-complex/test/complex.rb b/mrbgems/mruby-complex/test/complex.rb index d996e8277..14711ad73 100644 --- a/mrbgems/mruby-complex/test/complex.rb +++ b/mrbgems/mruby-complex/test/complex.rb @@ -60,7 +60,7 @@ assert 'Complex#/' do assert_complex Complex(9, 8) / 4 , ((9 / 4) + 2i) assert_complex Complex(20, 9) / 9.8 , (2.0408163265306123 + 0.9183673469387754i) if 1e39.infinite? then - # MRB_USE_FLOAT in effect + # MRB_USE_FLOAT32 in effect ten = 1e21 one = 1e20 else @@ -80,7 +80,7 @@ assert 'Complex#abs' do assert_float Complex(-1).abs, 1 assert_float Complex(3.0, -4.0).abs, 5.0 if 1e39.infinite? then - # MRB_USE_FLOAT in effect + # MRB_USE_FLOAT32 in effect exp = 125 else exp = 1021 diff --git a/mrbgems/mruby-inline-struct/test/inline.c b/mrbgems/mruby-inline-struct/test/inline.c index 5d307dcab..b4d9b1f1e 100644 --- a/mrbgems/mruby-inline-struct/test/inline.c +++ b/mrbgems/mruby-inline-struct/test/inline.c @@ -13,7 +13,7 @@ istruct_test_initialize(mrb_state *mrb, mrb_value self) if (mrb_fixnum_p(object)) { strncpy(string, "fixnum", size-1); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT else if (mrb_float_p(object)) { strncpy(string, "float", size-1); } diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c index 04dece910..a28360d81 100644 --- a/mrbgems/mruby-io/src/file.c +++ b/mrbgems/mruby-io/src/file.c @@ -448,8 +448,8 @@ mrb_file_size(mrb_state *mrb, mrb_value self) } if (st.st_size > MRB_INT_MAX) { -#ifdef MRB_WITHOUT_FLOAT - mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_WITHOUT_FLOAT"); +#ifdef MRB_NO_FLOAT + mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_NO_FLOAT"); #else return mrb_float_value(mrb, (mrb_float)st.st_size); #endif diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 988d19b02..587e195d9 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -973,10 +973,10 @@ mrb_io_sysseek(mrb_state *mrb, mrb_value io) mrb_sys_fail(mrb, "sysseek"); } if (pos > MRB_INT_MAX) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)pos); #else - mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_WITHOUT_FLOAT"); + mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_NO_FLOAT"); #endif } else { return mrb_fixnum_value(pos); @@ -1081,7 +1081,7 @@ time2timeval(mrb_state *mrb, mrb_value time) t.tv_usec = 0; break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: t.tv_sec = (ftime_t)mrb_float(time); t.tv_usec = (fsuseconds_t)((mrb_float(time) - t.tv_sec) * 1000000.0); diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index 70991c704..eaf8c6eb0 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -112,7 +112,7 @@ mrb_f_integer(mrb_state *mrb, mrb_value self) return mrb_convert_to_integer(mrb, arg, base); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* * call-seq: * Float(arg) -> float @@ -212,7 +212,7 @@ mrb_mruby_kernel_ext_gem_init(mrb_state *mrb) mrb_define_module_function(mrb, krn, "caller", mrb_f_caller, MRB_ARGS_OPT(2)); mrb_define_method(mrb, krn, "__method__", mrb_f_method, MRB_ARGS_NONE()); mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ARG(1,1)); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1)); #endif mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1)); diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c index ff1e84684..fcde7e700 100644 --- a/mrbgems/mruby-math/src/math.c +++ b/mrbgems/mruby-math/src/math.c @@ -4,8 +4,8 @@ ** See Copyright Notice in mruby.h */ -#ifdef MRB_WITHOUT_FLOAT -# error Math conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb' +#ifdef MRB_NO_FLOAT +# error Math conflicts with 'MRB_NO_FLOAT' configuration #endif #include diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index fd7072ccd..d00be4b5d 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -59,7 +59,7 @@ mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1)); mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1)); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX), mrb_fixnum_value(MRB_FLT_RADIX)); mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG), mrb_fixnum_value(MRB_FLT_MANT_DIG)); mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON), mrb_float_value(mrb, MRB_FLT_EPSILON)); @@ -70,7 +70,7 @@ mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP), mrb_fixnum_value(MRB_FLT_MAX_EXP)); mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX), mrb_float_value(mrb, MRB_FLT_MAX)); mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP), mrb_fixnum_value(MRB_FLT_MAX_10_EXP)); -#endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_NO_FLOAT */ } void diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c index 57361e8e2..2d99ce8c2 100644 --- a/mrbgems/mruby-object-ext/src/object.c +++ b/mrbgems/mruby-object-ext/src/object.c @@ -17,7 +17,7 @@ nil_to_a(mrb_state *mrb, mrb_value obj) return mrb_ary_new(mrb); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* * call-seq: * nil.to_f -> 0.0 @@ -115,7 +115,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb) struct RClass * n = mrb->nil_class; mrb_define_method(mrb, n, "to_a", nil_to_a, MRB_ARGS_NONE()); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, n, "to_f", nil_to_f, MRB_ARGS_NONE()); #endif mrb_define_method(mrb, n, "to_h", nil_to_h, MRB_ARGS_NONE()); diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c index 7030299f4..78ef1e4df 100644 --- a/mrbgems/mruby-os-memsize/src/memsize.c +++ b/mrbgems/mruby-os-memsize/src/memsize.c @@ -111,7 +111,7 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj) case MRB_TT_DATA: size += mrb_objspace_page_slot_size(); break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #ifdef MRB_WORD_BOXING size += mrb_objspace_page_slot_size() + diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index e222cd946..45427afa0 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -425,7 +425,7 @@ unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un return 8; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static int pack_double(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) { @@ -1248,7 +1248,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) if (type == PACK_TYPE_INTEGER) { o = mrb_to_int(mrb, o); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT else if (type == PACK_TYPE_FLOAT) { if (!mrb_float_p(o)) { mrb_float f = mrb_to_flo(mrb, o); @@ -1284,7 +1284,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) case PACK_DIR_STR: ridx += pack_a(mrb, o, result, ridx, count, flags); break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case PACK_DIR_DOUBLE: ridx += pack_double(mrb, o, result, ridx, flags); break; @@ -1381,7 +1381,7 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single) case PACK_DIR_QUAD: srcidx += unpack_q(mrb, sptr, srclen - srcidx, result, flags); break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case PACK_DIR_FLOAT: srcidx += unpack_float(mrb, sptr, srclen - srcidx, result, flags); break; diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index fdb28e012..3010b3db7 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -85,7 +85,7 @@ rand_uint32(rand_state *state) } #endif /* XORSHIFT96 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static double rand_real(rand_state *t) { @@ -100,7 +100,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max) mrb_value value; if (mrb_fixnum(max) == 0) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT value = mrb_float_value(mrb, rand_real(t)); #else mrb_raise(mrb, E_ARGUMENT_ERROR, "Float not supported"); diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c index 633894070..421e7d33a 100644 --- a/mrbgems/mruby-range-ext/src/range.c +++ b/mrbgems/mruby-range-ext/src/range.c @@ -96,7 +96,7 @@ range_last(mrb_state *mrb, mrb_value range) * ('a'..'z').size #=> nil */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value range_size(mrb_state *mrb, mrb_value range) { @@ -170,7 +170,7 @@ range_size(mrb_state *mrb, mrb_value range) } return mrb_nil_value(); } -#endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_NO_FLOAT */ void mrb_mruby_range_ext_gem_init(mrb_state* mrb) diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index 4a72a42f2..f9470de86 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -87,7 +87,7 @@ rational_s_new(mrb_state *mrb, mrb_value self) { mrb_int numerator, denominator; -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_get_args(mrb, "ii", &numerator, &denominator); #else @@ -136,7 +136,7 @@ rational_s_new(mrb_state *mrb, mrb_value self) return rational_new(mrb, numerator, denominator); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value rational_to_f(mrb_state *mrb, mrb_value self) { @@ -194,7 +194,7 @@ void mrb_mruby_rational_gem_init(mrb_state *mrb) mrb_define_class_method(mrb, rat, "_new", rational_s_new, MRB_ARGS_REQ(2)); mrb_define_method(mrb, rat, "numerator", rational_numerator, MRB_ARGS_NONE()); mrb_define_method(mrb, rat, "denominator", rational_denominator, MRB_ARGS_NONE()); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, rat, "to_f", rational_to_f, MRB_ARGS_NONE()); #endif mrb_define_method(mrb, rat, "to_i", rational_to_i, MRB_ARGS_NONE()); diff --git a/mrbgems/mruby-sleep/src/mrb_sleep.c b/mrbgems/mruby-sleep/src/mrb_sleep.c index a653242d1..7771db56b 100644 --- a/mrbgems/mruby-sleep/src/mrb_sleep.c +++ b/mrbgems/mruby-sleep/src/mrb_sleep.c @@ -44,7 +44,7 @@ mrb_f_sleep(mrb_state *mrb, mrb_value self) { time_t beg = time(0); time_t end; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_float sec; mrb_get_args(mrb, "f", &sec); diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 0cf462ef7..7f36616ec 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -10,7 +10,7 @@ #include #include #include -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #endif #include @@ -20,7 +20,7 @@ #define EXTENDSIGN(n, l) (((~0U << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0U << (n))) mrb_value mrb_str_format(mrb_state *, mrb_int, const mrb_value *, mrb_value); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static void fmt_setup(char*,size_t,int,int,mrb_int,mrb_int); #endif @@ -863,7 +863,7 @@ retry: bin_retry: switch (mrb_type(val)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: val = mrb_flo_to_fixnum(mrb, val); if (mrb_fixnum_p(val)) goto bin_retry; @@ -1030,7 +1030,7 @@ retry: } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case 'f': case 'g': case 'G': @@ -1131,7 +1131,7 @@ retry: return result; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static void fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec) { diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c index ded34a89e..71fb5bb65 100644 --- a/mrbgems/mruby-string-ext/src/string.c +++ b/mrbgems/mruby-string-ext/src/string.c @@ -12,7 +12,7 @@ #define ENC_COMP_P(enc, enc_lit) \ str_casecmp_p(RSTRING_PTR(enc), RSTRING_LEN(enc), enc_lit, sizeof(enc_lit"")-1) -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT # define mrb_float_p(o) FALSE #endif diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index fe1a475d5..4b82a9abc 100644 --- a/mrbgems/mruby-test/driver.c +++ b/mrbgems/mruby-test/driver.c @@ -224,8 +224,8 @@ mrb_init_test_driver(mrb_state *mrb, mrb_bool verbose) mrb_define_const(mrb, mrbtest, "FIXNUM_MIN", mrb_fixnum_value(MRB_INT_MIN)); mrb_define_const(mrb, mrbtest, "FIXNUM_BIT", mrb_fixnum_value(MRB_INT_BIT)); -#ifndef MRB_WITHOUT_FLOAT -#ifdef MRB_USE_FLOAT +#ifndef MRB_NO_FLOAT +#ifdef MRB_USE_FLOAT32 mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-6)); #else mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-12)); diff --git a/mrbgems/mruby-test/vformat.c b/mrbgems/mruby-test/vformat.c index e7ada02da..d73e52311 100644 --- a/mrbgems/mruby-test/vformat.c +++ b/mrbgems/mruby-test/vformat.c @@ -48,7 +48,7 @@ vf_s_format_d(mrb_state *mrb, mrb_value klass) return mrb_format(mrb, fmt, d); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* f float */ static mrb_value vf_s_format_f(mrb_state *mrb, mrb_value klass) @@ -167,7 +167,7 @@ mrb_init_test_vformat(mrb_state *mrb) VF_DEFINE_FORMAT_METHOD(c); VF_DEFINE_FORMAT_METHOD(d); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT VF_DEFINE_FORMAT_METHOD(f); #endif VF_DEFINE_FORMAT_METHOD(i); diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 3655695cf..3d5cdca2e 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -4,7 +4,7 @@ ** See Copyright Notice in mruby.h */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #endif @@ -30,7 +30,7 @@ double round(double x) { } #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT # if !defined(__MINGW64__) && defined(_WIN32) # define llround(x) round(x) # endif @@ -199,7 +199,7 @@ struct mrb_time { static const struct mrb_data_type mrb_time_type = { "Time", mrb_free }; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT void mrb_check_num_exact(mrb_state *mrb, mrb_float num); typedef mrb_float mrb_sec; #define mrb_sec_value(mrb, sec) mrb_float_value(mrb, sec) @@ -231,7 +231,7 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec) time_t t; switch (mrb_type(obj)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: { mrb_float f = mrb_float(obj); @@ -250,7 +250,7 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec) } } break; -#endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_NO_FLOAT */ default: case MRB_TT_FIXNUM: { @@ -572,7 +572,7 @@ mrb_time_minus(mrb_state *mrb, mrb_value self) tm = time_get_ptr(mrb, self); tm2 = DATA_CHECK_GET_PTR(mrb, other, &mrb_time_type, struct mrb_time); if (tm2) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_float f; f = (mrb_sec)(tm->sec - tm2->sec) + (mrb_sec)(tm->usec - tm2->usec) / 1.0e6; @@ -843,7 +843,7 @@ mrb_time_sec(mrb_state *mrb, mrb_value self) return mrb_fixnum_value(tm->datetime.tm_sec); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* 15.2.19.7.24 */ /* Returns a Float with the time since the epoch in seconds. */ static mrb_value @@ -864,7 +864,7 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self) struct mrb_time *tm; tm = time_get_ptr(mrb, self); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (!fixable_time_t_p(tm->sec)) { return mrb_float_value(mrb, (mrb_float)tm->sec); } @@ -880,7 +880,7 @@ mrb_time_usec(mrb_state *mrb, mrb_value self) struct mrb_time *tm; tm = time_get_ptr(mrb, self); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (!fixable_time_t_p(tm->usec)) { return mrb_float_value(mrb, (mrb_float)tm->usec); } @@ -995,7 +995,7 @@ mrb_mruby_time_gem_init(mrb_state* mrb) mrb_define_method(mrb, tc, "sec" , mrb_time_sec, MRB_ARGS_NONE()); /* 15.2.19.7.23 */ mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, MRB_ARGS_NONE()); /* 15.2.19.7.25 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, MRB_ARGS_NONE()); /* 15.2.19.7.24 */ #endif mrb_define_method(mrb, tc, "usec", mrb_time_usec, MRB_ARGS_NONE()); /* 15.2.19.7.26 */ diff --git a/src/array.c b/src/array.c index 285600969..432599bf7 100644 --- a/src/array.c +++ b/src/array.c @@ -825,7 +825,7 @@ aget_index(mrb_state *mrb, mrb_value index) if (mrb_fixnum_p(index)) { return mrb_fixnum(index); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT else if (mrb_float_p(index)) { return (mrb_int)mrb_float(index); } diff --git a/src/class.c b/src/class.c index 455a1b4e1..845246e97 100644 --- a/src/class.c +++ b/src/class.c @@ -899,7 +899,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case 'f': { mrb_float *p; @@ -1343,7 +1343,7 @@ mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v) return mrb->object_class; case MRB_TT_SYMBOL: case MRB_TT_FIXNUM: -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif return NULL; diff --git a/src/dump.c b/src/dump.c index 3bc95f629..489e70f8a 100644 --- a/src/dump.c +++ b/src/dump.c @@ -13,8 +13,8 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT -#ifdef MRB_USE_FLOAT +#ifndef MRB_NO_FLOAT +#ifdef MRB_USE_FLOAT32 #define MRB_FLOAT_FMT "%.9g" #else #define MRB_FLOAT_FMT "%.17g" @@ -88,7 +88,7 @@ write_iseq_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf, uint8_t fla return cur - buf; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value float_to_str(mrb_state *mrb, mrb_float f) { @@ -131,7 +131,7 @@ get_pool_block_size(mrb_state *mrb, const mrb_irep *irep) break; case IREP_TT_FLOAT: -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT { mrb_value str = float_to_str(mrb, irep->pool[pool_no].u.f); mrb_int len = RSTRING_LEN(str); @@ -192,7 +192,7 @@ write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) case IREP_TT_FLOAT: cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT { mrb_value str = float_to_str(mrb, irep->pool[pool_no].u.f); ptr = RSTRING_PTR(str); diff --git a/src/error.c b/src/error.c index 742049ace..b6a82f867 100644 --- a/src/error.c +++ b/src/error.c @@ -288,7 +288,7 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap) #endif obj = mrb_fixnum_value(i); goto L_cat_obj; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case 'f': obj = mrb_float_value(mrb, (mrb_float)va_arg(ap, double)); goto L_cat_obj; diff --git a/src/etc.c b/src/etc.c index a1e384717..b0019e6de 100644 --- a/src/etc.c +++ b/src/etc.c @@ -70,7 +70,7 @@ mrb_obj_to_sym(mrb_state *mrb, mrb_value name) } MRB_API mrb_int -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_fixnum_id(mrb_int f) #else mrb_float_id(mrb_float f) @@ -80,7 +80,7 @@ mrb_float_id(mrb_float f) int len = sizeof(f); uint32_t id = 0; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* normalize -0.0 to 0.0 */ if (f == 0) f = 0.0; #endif @@ -115,7 +115,7 @@ mrb_obj_id(mrb_value obj) case MRB_TT_SYMBOL: return MakeID(mrb_symbol(obj)); case MRB_TT_FIXNUM: -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return MakeID(mrb_fixnum_id(mrb_fixnum(obj))); #else return MakeID2(mrb_float_id((mrb_float)mrb_fixnum(obj)), MRB_TT_FLOAT); @@ -147,7 +147,7 @@ mrb_obj_id(mrb_value obj) #ifdef MRB_WORD_BOXING #define mrb_xxx_boxing_cptr_value mrb_word_boxing_cptr_value -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f) { @@ -158,7 +158,7 @@ mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f) MRB_SET_FROZEN_FLAG(v.bp); return v.w; } -#endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_NO_FLOAT */ #endif /* MRB_WORD_BOXING */ #if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT)) diff --git a/src/fmt_fp.c b/src/fmt_fp.c index 81ace6ec8..2c1e13c36 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -1,4 +1,4 @@ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #if defined(MRB_DISABLE_STDIO) || defined(_WIN32) || defined(_WIN64) /* diff --git a/src/gc.c b/src/gc.c index 17f7e81e4..50269f95c 100644 --- a/src/gc.c +++ b/src/gc.c @@ -122,7 +122,7 @@ typedef struct { struct RException exc; struct RBreak brk; #ifdef MRB_WORD_BOXING -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT struct RFloat floatv; #endif struct RCptr cptr; @@ -784,7 +784,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end) /* cannot happen */ return; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #ifdef MRB_WORD_BOXING break; @@ -929,7 +929,7 @@ root_scan_phase(mrb_state *mrb, mrb_gc *gc) mrb_gc_mark(mrb, (struct RBasic*)mrb->hash_class); mrb_gc_mark(mrb, (struct RBasic*)mrb->range_class); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_gc_mark(mrb, (struct RBasic*)mrb->float_class); #endif mrb_gc_mark(mrb, (struct RBasic*)mrb->fixnum_class); diff --git a/src/hash.c b/src/hash.c index 72ed3c731..2eef4afaf 100644 --- a/src/hash.c +++ b/src/hash.c @@ -11,7 +11,7 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* a function to get hash value of a float number */ mrb_int mrb_float_id(mrb_float f); #endif @@ -65,7 +65,7 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key) case MRB_TT_FALSE: case MRB_TT_SYMBOL: case MRB_TT_FIXNUM: -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif h = (size_t)mrb_obj_id(key); @@ -99,7 +99,7 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b) switch (mrb_type(b)) { case MRB_TT_FIXNUM: return mrb_fixnum(a) == mrb_fixnum(b); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return (mrb_float)mrb_fixnum(a) == mrb_float(b); #endif @@ -107,7 +107,7 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b) return FALSE; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: switch (mrb_type(b)) { case MRB_TT_FIXNUM: diff --git a/src/load.c b/src/load.c index 67217b128..b06b9ff37 100644 --- a/src/load.c +++ b/src/load.c @@ -39,7 +39,7 @@ offset_crc_body(void) return ((uint8_t *)header.binary_crc - (uint8_t *)&header) + sizeof(header.binary_crc); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck); static double @@ -165,7 +165,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag #endif case IREP_TT_FLOAT: -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT pool[i].tt = tt; pool_data_len = bin_to_uint16(src); /* pool data length */ src += sizeof(uint16_t); @@ -173,7 +173,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag src += pool_data_len; break; #else - return NULL; /* MRB_WITHOUT_FLOAT */ + return NULL; /* MRB_NO_FLOAT */ #endif case IREP_TT_STR: diff --git a/src/numeric.c b/src/numeric.c index 195bd40cf..f4ad116a4 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -4,7 +4,7 @@ ** See Copyright Notice in mruby.h */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #include #endif @@ -18,8 +18,8 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT -#ifdef MRB_USE_FLOAT +#ifndef MRB_NO_FLOAT +#ifdef MRB_USE_FLOAT32 #define trunc(f) truncf(f) #define floor(f) floorf(f) #define ceil(f) ceilf(f) @@ -30,7 +30,7 @@ #endif #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value val) { @@ -68,7 +68,7 @@ static mrb_value integral_pow(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_float d; #endif @@ -79,7 +79,7 @@ integral_pow(mrb_state *mrb, mrb_value x) mrb_int result = 1; if (exp < 0) -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_fixnum_value(0); #else goto float_pow; @@ -87,7 +87,7 @@ integral_pow(mrb_state *mrb, mrb_value x) for (;;) { if (exp & 1) { if (mrb_int_mul_overflow(result, base, &result)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT goto float_pow; #endif } @@ -95,14 +95,14 @@ integral_pow(mrb_state *mrb, mrb_value x) exp >>= 1; if (exp == 0) break; if (mrb_int_mul_overflow(base, base, &base)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT goto float_pow; #endif } } return mrb_fixnum_value(result); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else float_pow: @@ -114,7 +114,7 @@ integral_pow(mrb_state *mrb, mrb_value x) static mrb_value integral_idiv(mrb_state *mrb, mrb_value x) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_value y = mrb_get_arg1(mrb); if (!mrb_fixnum_p(y)) { @@ -151,7 +151,7 @@ integral_idiv(mrb_state *mrb, mrb_value x) static mrb_value integral_div(mrb_state *mrb, mrb_value xv) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_int y; mrb_get_args(mrb, "i", &y); @@ -184,7 +184,7 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "oo", &num, &step); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(self) || mrb_float_p(num) || mrb_float_p(step)) { return mrb_Float(mrb, self); } @@ -193,7 +193,7 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self) return self; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /******************************************************************** * * Document-class: Float @@ -386,7 +386,7 @@ fix_eql(mrb_state *mrb, mrb_value x) return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value flo_eql(mrb_state *mrb, mrb_value x) { @@ -803,13 +803,13 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y) if (a == 0) return x; b = mrb_fixnum(y); if (mrb_int_mul_overflow(a, b, &c)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b); #endif } return mrb_fixnum_value(c); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y)); @@ -822,7 +822,7 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) if (mrb_fixnum_p(x)) { return fixnum_mul(mrb, x, y); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { return mrb_float_value(mrb, mrb_float(x) * mrb_to_flo(mrb, y)); } @@ -898,7 +898,7 @@ fix_mod(mrb_state *mrb, mrb_value x) mrb_int mod; if (b == 0) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT /* ZeroDivisionError */ return mrb_fixnum_value(0); #else @@ -910,7 +910,7 @@ fix_mod(mrb_state *mrb, mrb_value x) fixdivmod(mrb, a, b, NULL, &mod); return mrb_fixnum_value(mod); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else else { @@ -937,7 +937,7 @@ fix_divmod(mrb_state *mrb, mrb_value x) mrb_int div, mod; if (mrb_fixnum(y) == 0) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_assoc_new(mrb, mrb_fixnum_value(0), mrb_fixnum_value(0)); #else return mrb_assoc_new(mrb, ((mrb_fixnum(x) == 0) ? @@ -949,7 +949,7 @@ fix_divmod(mrb_state *mrb, mrb_value x) fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod); return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else else { @@ -964,7 +964,7 @@ fix_divmod(mrb_state *mrb, mrb_value x) #endif } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value flo_divmod(mrb_state *mrb, mrb_value x) { @@ -999,7 +999,7 @@ fix_equal(mrb_state *mrb, mrb_value x) switch (mrb_type(y)) { case MRB_TT_FIXNUM: return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return mrb_bool_value((mrb_float)mrb_fixnum(x) == mrb_float(y)); #endif @@ -1027,7 +1027,7 @@ fix_rev(mrb_state *mrb, mrb_value num) return mrb_fixnum_value(~val); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT #define bit_op(x,y,op1,op2) do {\ return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\ } while(0) @@ -1095,7 +1095,7 @@ static mrb_value lshift(mrb_state *mrb, mrb_int val, mrb_int width) { if (width < 0) { /* mrb_int overflow */ -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_fixnum_value(0); #else return mrb_float_value(mrb, INFINITY); @@ -1104,7 +1104,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) if (val > 0) { if ((width > NUMERIC_SHIFT_WIDTH_MAX) || (val > (MRB_INT_MAX >> width))) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_fixnum_value(-1); #else goto bit_overflow; @@ -1115,7 +1115,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) else { if ((width > NUMERIC_SHIFT_WIDTH_MAX) || (val <= (MRB_INT_MIN >> width))) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_fixnum_value(0); #else goto bit_overflow; @@ -1124,7 +1124,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) return mrb_fixnum_value(val * ((mrb_int)1 << width)); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT bit_overflow: { mrb_float f = (mrb_float)val; @@ -1210,7 +1210,7 @@ fix_rshift(mrb_state *mrb, mrb_value x) * */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value fix_to_f(mrb_state *mrb, mrb_value num) { @@ -1267,13 +1267,13 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y) if (a == 0) return y; b = mrb_fixnum(y); if (mrb_int_add_overflow(a, b, &c)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b); #endif } return mrb_fixnum_value(c); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else return mrb_float_value(mrb, (mrb_float)a + mrb_to_flo(mrb, y)); @@ -1286,7 +1286,7 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) if (mrb_fixnum_p(x)) { return fixnum_plus(mrb, x, y); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { return mrb_float_value(mrb, mrb_float(x) + mrb_to_flo(mrb, y)); } @@ -1323,13 +1323,13 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y) b = mrb_fixnum(y); if (mrb_int_sub_overflow(a, b, &c)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b); #endif } return mrb_fixnum_value(c); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else return mrb_float_value(mrb, (mrb_float)a - mrb_to_flo(mrb, y)); @@ -1342,7 +1342,7 @@ mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) if (mrb_fixnum_p(x)) { return fixnum_minus(mrb, x, y); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { return mrb_float_value(mrb, mrb_float(x) - mrb_to_flo(mrb, y)); } @@ -1431,26 +1431,26 @@ fix_to_s(mrb_state *mrb, mrb_value self) static mrb_int cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_int x, y; #else mrb_float x, y; #endif -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT x = mrb_fixnum(v1); #else x = mrb_to_flo(mrb, v1); #endif switch (mrb_type(v2)) { case MRB_TT_FIXNUM: -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT y = mrb_fixnum(v2); #else y = (mrb_float)mrb_fixnum(v2); #endif break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: y = mrb_float(v2); break; @@ -1585,7 +1585,7 @@ num_infinite_p(mrb_state *mrb, mrb_value self) * Returns a new float which is the sum of float * and other. */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value flo_plus(mrb_state *mrb, mrb_value x) { @@ -1600,7 +1600,7 @@ void mrb_init_numeric(mrb_state *mrb) { struct RClass *numeric, *integer, *fixnum, *integral; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT struct RClass *fl; #endif @@ -1627,7 +1627,7 @@ mrb_init_numeric(mrb_state *mrb) mrb_undef_class_method(mrb, integer, "new"); mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.24 */ mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE()); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, integer, "ceil", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.8 (x) */ mrb_define_method(mrb, integer, "floor", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.10 (x) */ mrb_define_method(mrb, integer, "round", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.12 (x) */ @@ -1648,14 +1648,14 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, fixnum, "<<", fix_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */ mrb_define_method(mrb, fixnum, ">>", fix_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */ mrb_define_method(mrb, fixnum, "eql?", fix_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, fixnum, "to_f", fix_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */ #endif mrb_define_method(mrb, fixnum, "to_s", fix_to_s, MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */ mrb_define_method(mrb, fixnum, "inspect", fix_to_s, MRB_ARGS_OPT(1)); mrb_define_method(mrb, fixnum, "divmod", fix_divmod, MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* Float Class */ mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric); /* 15.2.9 */ MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT); diff --git a/src/object.c b/src/object.c index fd1f9e215..634f70830 100644 --- a/src/object.c +++ b/src/object.c @@ -24,7 +24,7 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2) case MRB_TT_SYMBOL: return (mrb_symbol(v1) == mrb_symbol(v2)); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return (mrb_float(v1) == mrb_float(v2)); #endif @@ -47,7 +47,7 @@ mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2) mrb_value result; if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* value mixing with integer and float */ if (mrb_fixnum_p(obj1)) { if (mrb_float_p(obj2) && (mrb_float)mrb_fixnum(obj1) == mrb_float(obj2)) @@ -330,7 +330,7 @@ static const struct types { {MRB_TT_ICLASS, "iClass"}, /* internal use: mixed-in module holder */ {MRB_TT_SCLASS, "SClass"}, {MRB_TT_PROC, "Proc"}, -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT {MRB_TT_FLOAT, "Float"}, #endif {MRB_TT_ARRAY, "Array"}, @@ -510,7 +510,7 @@ mrb_to_int(mrb_state *mrb, mrb_value val) { if (!mrb_fixnum_p(val)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(val)) { return mrb_flo_to_fixnum(mrb, val); } @@ -530,7 +530,7 @@ mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base) mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Integer"); } switch (mrb_type(val)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: if (base != 0) goto arg_error; return mrb_flo_to_fixnum(mrb, val); @@ -566,7 +566,7 @@ mrb_Integer(mrb_state *mrb, mrb_value val) return mrb_convert_to_integer(mrb, val, 0); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val) { diff --git a/src/range.c b/src/range.c index 868d3d397..8f09eda24 100644 --- a/src/range.c +++ b/src/range.c @@ -23,7 +23,7 @@ r_check(mrb_state *mrb, mrb_value a, mrb_value b) ta = mrb_type(a); tb = mrb_type(b); -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT if (ta == MRB_TT_FIXNUM && tb == MRB_TT_FIXNUM ) { #else if ((ta == MRB_TT_FIXNUM || ta == MRB_TT_FLOAT) && diff --git a/src/string.c b/src/string.c index 73e514f41..f15770403 100644 --- a/src/string.c +++ b/src/string.c @@ -8,7 +8,7 @@ # define _CRT_NONSTDC_NO_DEPRECATE #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #include #endif @@ -2365,7 +2365,7 @@ mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, mrb_int base, i n *= base; n += c; if (n > (uint64_t)MRB_INT_MAX + (sign ? 0 : 1)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (base == 10) { return mrb_float_value(mrb, mrb_str_to_dbl(mrb, mrb_str_new(mrb, str, len), badcheck)); } @@ -2476,7 +2476,7 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self) return mrb_str_to_inum(mrb, self, base, FALSE); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck) { @@ -2937,7 +2937,7 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "slice", mrb_str_aref_m, MRB_ARGS_ANY()); /* 15.2.10.5.34 */ mrb_define_method(mrb, s, "split", mrb_str_split_m, MRB_ARGS_ANY()); /* 15.2.10.5.35 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, s, "to_f", mrb_str_to_f, MRB_ARGS_NONE()); /* 15.2.10.5.38 */ #endif mrb_define_method(mrb, s, "to_i", mrb_str_to_i, MRB_ARGS_ANY()); /* 15.2.10.5.39 */ @@ -2954,7 +2954,7 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "byteslice", mrb_str_byteslice, MRB_ARGS_ARG(1,1)); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* * Source code for the "strtod" library procedure. * diff --git a/src/vm.c b/src/vm.c index 87606c1b4..48dea94fb 100644 --- a/src/vm.c +++ b/src/vm.c @@ -6,7 +6,7 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #endif #include @@ -1101,7 +1101,7 @@ RETRY_TRY_BLOCK: } goto L_RAISE; #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case IREP_TT_FLOAT: regs[a] = mrb_float_value(mrb, pool[b].u.f); break; @@ -2265,7 +2265,7 @@ RETRY_TRY_BLOCK: SET_INT_VALUE(regs[a], z); \ } \ break -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT #define OP_MATH_CASE_FLOAT(op_name, t1, t2) (void)0 #define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(regs[a], z) #else @@ -2305,14 +2305,14 @@ RETRY_TRY_BLOCK: } CASE(OP_DIV, B) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT double x, y, f; #endif /* need to check if op is overridden */ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) { case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM): -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT { mrb_int x = mrb_fixnum(regs[a]); mrb_int y = mrb_fixnum(regs[a+1]); @@ -2342,7 +2342,7 @@ RETRY_TRY_BLOCK: goto L_SEND_SYM; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (y == 0) { if (x > 0) f = INFINITY; else if (x < 0) f = -INFINITY; @@ -2378,7 +2378,7 @@ RETRY_TRY_BLOCK: SET_INT_VALUE(regs[a], z); \ } \ break -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT #define OP_MATHI_CASE_FLOAT(op_name) (void)0 #else #define OP_MATHI_CASE_FLOAT(op_name) \ @@ -2400,7 +2400,7 @@ RETRY_TRY_BLOCK: #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1])) -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT #define OP_CMP(op,sym) do {\ int result;\ /* need to check if - is overridden */\ diff --git a/target/RX630.rb b/target/RX630.rb index 8b1bbb42f..1b1f425c1 100644 --- a/target/RX630.rb +++ b/target/RX630.rb @@ -30,7 +30,7 @@ MRuby::CrossBuild.new("RX630") do |conf| cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"] #configuration for low memory environment - cc.defines << %w(MRB_USE_FLOAT) + cc.defines << %w(MRB_USE_FLOAT32) cc.defines << %w(MRB_HEAP_PAGE_SIZE=64) cc.defines << %w(KHASH_DEFAULT_SIZE=8) cc.defines << %w(MRB_STR_BUF_MIN_SIZE=20) diff --git a/tasks/gitlab.rake b/tasks/gitlab.rake index 377b1cc9d..5c7b3d8c5 100644 --- a/tasks/gitlab.rake +++ b/tasks/gitlab.rake @@ -62,10 +62,10 @@ task :gitlab_config do configs = [] [true, false].each do |mode_32| - ['', 'MRB_USE_FLOAT'].each do |float_conf| + ['', 'MRB_USE_FLOAT32'].each do |float_conf| ['', 'MRB_NAN_BOXING', 'MRB_WORD_BOXING'].each do |boxing_conf| ['', 'MRB_UTF8_STRING'].each do |utf8_conf| - next if (float_conf == 'MRB_USE_FLOAT') && (boxing_conf == 'MRB_NAN_BOXING') + next if (float_conf == 'MRB_USE_FLOAT32') && (boxing_conf == 'MRB_NAN_BOXING') next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_NAN_BOXING') next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_WORD_BOXING') && mode_32 env = [float_conf, int_conf, boxing_conf, utf8_conf].map do |conf| diff --git a/test/t/float.rb b/test/t/float.rb index dc989636f..1cbc90532 100644 --- a/test/t/float.rb +++ b/test/t/float.rb @@ -207,7 +207,7 @@ assert('Float#>>') do end assert('Float#to_s') do - uses_float = 4e38.infinite? # enable MRB_USE_FLOAT? + uses_float = 4e38.infinite? # enable MRB_USE_FLOAT32? assert_equal("Infinity", Float::INFINITY.to_s) assert_equal("-Infinity", (-Float::INFINITY).to_s) -- cgit v1.2.3 From 1835753f9f20220065346344ca39ae34e2e41270 Mon Sep 17 00:00:00 2001 From: Lanza <811266970@qq.com> Date: Wed, 6 May 2020 14:54:26 +0800 Subject: Update vm.c --- src/vm.c | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 48dea94fb..068d1a977 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2320,8 +2320,17 @@ RETRY_TRY_BLOCK: } break; #else + #ifdef MRB_INTEGER_DIVISION + { + mrb_int x = mrb_fixnum(regs[a]); + mrb_int y = mrb_fixnum(regs[a+1]); + SET_INT_VALUE(regs[a], y ? x / y : 0); + NEXT; + } + #else x = (mrb_float)mrb_fixnum(regs[a]); y = (mrb_float)mrb_fixnum(regs[a+1]); + #endif break; case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT): x = (mrb_float)mrb_fixnum(regs[a]); -- cgit v1.2.3 From c8cf9512cd80ad3b90cb33c29056f75db5fceb0f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 18 Aug 2020 13:14:59 +0900 Subject: Update the PR #4992 to enable integer division always. --- src/vm.c | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 068d1a977..edfce43c0 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2312,26 +2312,13 @@ RETRY_TRY_BLOCK: /* need to check if op is overridden */ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) { case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM): -#ifdef MRB_NO_FLOAT { mrb_int x = mrb_fixnum(regs[a]); mrb_int y = mrb_fixnum(regs[a+1]); SET_INT_VALUE(regs[a], y ? x / y : 0); } - break; -#else - #ifdef MRB_INTEGER_DIVISION - { - mrb_int x = mrb_fixnum(regs[a]); - mrb_int y = mrb_fixnum(regs[a+1]); - SET_INT_VALUE(regs[a], y ? x / y : 0); - NEXT; - } - #else - x = (mrb_float)mrb_fixnum(regs[a]); - y = (mrb_float)mrb_fixnum(regs[a+1]); - #endif - break; + NEXT; +#ifndef MRB_NO_FLOAT case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT): x = (mrb_float)mrb_fixnum(regs[a]); y = mrb_float(regs[a+1]); -- cgit v1.2.3 From ee544dc881453cdd1f18f87344627206834e1ab4 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 18 Aug 2020 13:22:28 +0900 Subject: Update the PR #4922 according to #3123. close #3123 --- src/vm.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index edfce43c0..401d52414 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2315,7 +2315,33 @@ RETRY_TRY_BLOCK: { mrb_int x = mrb_fixnum(regs[a]); mrb_int y = mrb_fixnum(regs[a+1]); - SET_INT_VALUE(regs[a], y ? x / y : 0); + if (y == 0 || (x == MRB_INT_MIN && y == -1)) { +#ifdef MRB_NO_FLOAT + SET_INT_VALUE(regs[a], y ? x / y : 0); +#else + SET_FLOAT_VALUE(mrb, regs[a], (mrb_float)x / (mrb_float)y); +#endif + } + else { + mrb_int div, mod; + if (y < 0) { + if (x < 0) + div = -x / -y; + else + div = - (x / -y); + } + else { + if (x < 0) + div = - (-x / y); + else + div = x / y; + } + mod = x - div*y; + if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { + div -= 1; + } + SET_INT_VALUE(regs[a], div); + } } NEXT; #ifndef MRB_NO_FLOAT -- cgit v1.2.3 From 55163a8a0a5737e9113f16d0f03b7ab4258706ba Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 18 Aug 2020 21:32:36 +0900 Subject: Rename `MRB_TT_FIXNUM` to `MRB_TT_INTEGER`. We still have `#define MRB_TT_FIXNUM MRB_TT_INTEGER` for compatibility. --- include/mruby/boxing_nan.h | 2 +- include/mruby/boxing_no.h | 2 +- include/mruby/boxing_word.h | 2 +- include/mruby/class.h | 2 +- include/mruby/value.h | 7 +++++-- mrbgems/mruby-array-ext/src/array.c | 2 +- mrbgems/mruby-compiler/core/codegen.c | 4 ++-- mrbgems/mruby-io/src/io.c | 4 ++-- mrbgems/mruby-objectspace/src/mruby_objectspace.c | 2 +- mrbgems/mruby-os-memsize/src/memsize.c | 2 +- mrbgems/mruby-sprintf/src/sprintf.c | 2 +- mrbgems/mruby-time/src/time.c | 2 +- src/array.c | 2 +- src/class.c | 2 +- src/etc.c | 2 +- src/gc.c | 2 +- src/hash.c | 4 ++-- src/numeric.c | 14 +++++++------- src/object.c | 8 ++++---- src/range.c | 6 +++--- src/string.c | 4 ++-- src/vm.c | 20 ++++++++++---------- 22 files changed, 50 insertions(+), 47 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index eb89ac1f9..f013ed7fa 100644 --- a/include/mruby/boxing_nan.h +++ b/include/mruby/boxing_nan.h @@ -104,7 +104,7 @@ mrb_val_union(mrb_value v) #define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 1) #define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, i, 1) #define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, i, 1) -#define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_FIXNUM, i, (uint32_t)(n)) +#define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n)) #define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, i, (uint32_t)(v)) #define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v)) #ifdef MRB_64BIT diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h index 345f6b35b..ff3d9f787 100644 --- a/include/mruby/boxing_no.h +++ b/include/mruby/boxing_no.h @@ -42,7 +42,7 @@ typedef struct mrb_value { #define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1) #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1) #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1) -#define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n)) +#define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n)) #ifndef MRB_NO_FLOAT #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v)) #endif diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index b9b6a3fe9..e68d8148b 100644 --- a/include/mruby/boxing_word.h +++ b/include/mruby/boxing_word.h @@ -173,7 +173,7 @@ mrb_type(mrb_value o) { return !mrb_bool(o) ? MRB_TT_FALSE : mrb_true_p(o) ? MRB_TT_TRUE : - mrb_fixnum_p(o) ? MRB_TT_FIXNUM : + mrb_fixnum_p(o) ? MRB_TT_INTEGER : mrb_symbol_p(o) ? MRB_TT_SYMBOL : mrb_undef_p(o) ? MRB_TT_UNDEF : mrb_val_union(o).bp->tt; diff --git a/include/mruby/class.h b/include/mruby/class.h index b4b5454d5..19c2e1b7b 100644 --- a/include/mruby/class.h +++ b/include/mruby/class.h @@ -35,7 +35,7 @@ mrb_class(mrb_state *mrb, mrb_value v) return mrb->true_class; case MRB_TT_SYMBOL: return mrb->symbol_class; - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb->integer_class; #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: diff --git a/include/mruby/value.h b/include/mruby/value.h index 88c8d4dba..933e5a3ec 100644 --- a/include/mruby/value.h +++ b/include/mruby/value.h @@ -106,7 +106,7 @@ enum mrb_vtype { MRB_TT_FALSE = 0, MRB_TT_TRUE, MRB_TT_FLOAT, - MRB_TT_FIXNUM, + MRB_TT_INTEGER, MRB_TT_SYMBOL, MRB_TT_UNDEF, MRB_TT_CPTR, @@ -130,6 +130,9 @@ enum mrb_vtype { MRB_TT_MAXDEFINE }; +/* for compatibility */ +#define MRB_TT_FIXNUM MRB_TT_INTEGER + #include #ifdef MRB_DOCUMENTATION_BLOCK @@ -178,7 +181,7 @@ struct RCptr { #define mrb_immediate_p(o) (mrb_type(o) < MRB_TT_FREE) #endif #ifndef mrb_fixnum_p -#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM) +#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_INTEGER) #endif #ifndef mrb_symbol_p #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL) diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c index 996679b6e..9d7f1b28a 100644 --- a/mrbgems/mruby-array-ext/src/array.c +++ b/mrbgems/mruby-array-ext/src/array.c @@ -148,7 +148,7 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self) else { return mrb_nil_value(); } - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index); return val; default: diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 372a2c5f7..72ae0a3a9 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -543,7 +543,7 @@ new_lit(codegen_scope *s, mrb_value val) } break; #endif - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: for (i=0; iirep->plen; i++) { mrb_int v = mrb_fixnum(val); pv = &s->pool[i]; @@ -594,7 +594,7 @@ new_lit(codegen_scope *s, mrb_value val) pv->u.f = mrb_float(val); break; #endif - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifdef MRB_INT64 pv->tt = IREP_TT_INT64; pv->u.i64 = mrb_fixnum(val); diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 587e195d9..712fea79c 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -338,7 +338,7 @@ option_to_fd(mrb_state *mrb, mrb_value hash, const char *key) switch (mrb_type(opt)) { case MRB_TT_DATA: /* IO */ return mrb_io_fileno(mrb, opt); - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return (int)mrb_fixnum(opt); default: mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action"); @@ -1076,7 +1076,7 @@ time2timeval(mrb_state *mrb, mrb_value time) struct timeval t = { 0, 0 }; switch (mrb_type(time)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: t.tv_sec = (ftime_t)mrb_fixnum(time); t.tv_usec = 0; break; diff --git a/mrbgems/mruby-objectspace/src/mruby_objectspace.c b/mrbgems/mruby-objectspace/src/mruby_objectspace.c index 16edafced..d8013c20f 100644 --- a/mrbgems/mruby-objectspace/src/mruby_objectspace.c +++ b/mrbgems/mruby-objectspace/src/mruby_objectspace.c @@ -81,7 +81,7 @@ os_count_objects(mrb_state *mrb, mrb_value self) COUNT_TYPE(T_FALSE); COUNT_TYPE(T_FREE); COUNT_TYPE(T_TRUE); - COUNT_TYPE(T_FIXNUM); + COUNT_TYPE(T_INTEGER); COUNT_TYPE(T_SYMBOL); COUNT_TYPE(T_UNDEF); COUNT_TYPE(T_FLOAT); diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c index 78ef1e4df..625ffb258 100644 --- a/mrbgems/mruby-os-memsize/src/memsize.c +++ b/mrbgems/mruby-os-memsize/src/memsize.c @@ -144,7 +144,7 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj) * immediate VM stack values, contained within mrb_state, or on C stack */ case MRB_TT_TRUE: case MRB_TT_FALSE: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: case MRB_TT_BREAK: case MRB_TT_CPTR: case MRB_TT_SYMBOL: diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 1f3ffc09a..362d16d1b 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -872,7 +872,7 @@ retry: case MRB_TT_STRING: val = mrb_str_to_inum(mrb, val, 0, TRUE); goto bin_retry; - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: v = mrb_fixnum(val); break; default: diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 3d5cdca2e..8a4f1d233 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -252,7 +252,7 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec) break; #endif /* MRB_NO_FLOAT */ default: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: { mrb_int i = mrb_int(mrb, obj); diff --git a/src/array.c b/src/array.c index 432599bf7..cd0b59ac2 100644 --- a/src/array.c +++ b/src/array.c @@ -885,7 +885,7 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self) else { return mrb_nil_value(); } - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_ary_ref(mrb, self, mrb_fixnum(index)); default: return mrb_ary_ref(mrb, self, aget_index(mrb, index)); diff --git a/src/class.c b/src/class.c index df33feffb..dd713ed7e 100644 --- a/src/class.c +++ b/src/class.c @@ -1342,7 +1342,7 @@ mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v) case MRB_TT_CPTR: return mrb->object_class; case MRB_TT_SYMBOL: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif diff --git a/src/etc.c b/src/etc.c index b0019e6de..e9990bec5 100644 --- a/src/etc.c +++ b/src/etc.c @@ -114,7 +114,7 @@ mrb_obj_id(mrb_value obj) return MakeID(2); case MRB_TT_SYMBOL: return MakeID(mrb_symbol(obj)); - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifdef MRB_NO_FLOAT return MakeID(mrb_fixnum_id(mrb_fixnum(obj))); #else diff --git a/src/gc.c b/src/gc.c index fd472217e..393f7f62c 100644 --- a/src/gc.c +++ b/src/gc.c @@ -779,7 +779,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end) switch (obj->tt) { /* immediate - no mark */ case MRB_TT_TRUE: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: case MRB_TT_SYMBOL: /* cannot happen */ return; diff --git a/src/hash.c b/src/hash.c index 84ed00001..79cec4b71 100644 --- a/src/hash.c +++ b/src/hash.c @@ -64,7 +64,7 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key) case MRB_TT_TRUE: case MRB_TT_FALSE: case MRB_TT_SYMBOL: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif @@ -95,7 +95,7 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b) if (!mrb_symbol_p(b)) return FALSE; return mrb_symbol(a) == mrb_symbol(b); - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: if (!mrb_fixnum_p(b)) return FALSE; return mrb_fixnum(a) == mrb_fixnum(b); diff --git a/src/numeric.c b/src/numeric.c index 617348254..99d32f919 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -35,7 +35,7 @@ MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value val) { switch (mrb_type(val)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return (mrb_float)mrb_fixnum(val); case MRB_TT_FLOAT: break; @@ -450,7 +450,7 @@ flo_eq(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); switch (mrb_type(y)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y)); case MRB_TT_FLOAT: return mrb_bool_value(mrb_float(x) == mrb_float(y)); @@ -463,7 +463,7 @@ static int64_t value_int64(mrb_state *mrb, mrb_value x) { switch (mrb_type(x)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return (int64_t)mrb_fixnum(x); case MRB_TT_FLOAT: return (int64_t)mrb_float(x); @@ -1031,7 +1031,7 @@ int_equal(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); switch (mrb_type(y)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: @@ -1477,7 +1477,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) x = mrb_to_flo(mrb, v1); #endif switch (mrb_type(v2)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifdef MRB_NO_FLOAT y = mrb_fixnum(v2); #else @@ -1584,7 +1584,7 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2) mrb_value v; switch (mrb_type(obj1)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: case MRB_TT_FLOAT: return cmpnum(mrb, obj1, obj2); case MRB_TT_STRING: @@ -1657,7 +1657,7 @@ mrb_init_numeric(mrb_state *mrb) /* Integer Class */ mrb->integer_class = integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */ - MRB_SET_INSTANCE_TT(integer, MRB_TT_FIXNUM); + MRB_SET_INSTANCE_TT(integer, MRB_TT_INTEGER); mrb_undef_class_method(mrb, integer, "new"); mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.24 */ mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE()); diff --git a/src/object.c b/src/object.c index 634f70830..a6357a6a8 100644 --- a/src/object.c +++ b/src/object.c @@ -19,7 +19,7 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2) return TRUE; case MRB_TT_FALSE: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return (mrb_fixnum(v1) == mrb_fixnum(v2)); case MRB_TT_SYMBOL: return (mrb_symbol(v1) == mrb_symbol(v2)); @@ -322,7 +322,7 @@ static const struct types { /* {MRB_TT_NIL, "nil"}, */ {MRB_TT_FALSE, "false"}, {MRB_TT_TRUE, "true"}, - {MRB_TT_FIXNUM, "Fixnum"}, + {MRB_TT_INTEGER,"Integer"}, {MRB_TT_SYMBOL, "Symbol"}, /* :symbol */ {MRB_TT_MODULE, "Module"}, {MRB_TT_OBJECT, "Object"}, @@ -536,7 +536,7 @@ mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base) return mrb_flo_to_fixnum(mrb, val); #endif - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: if (base != 0) goto arg_error; return val; @@ -574,7 +574,7 @@ mrb_Float(mrb_state *mrb, mrb_value val) mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Float"); } switch (mrb_type(val)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_float_value(mrb, (mrb_float)mrb_fixnum(val)); case MRB_TT_FLOAT: diff --git a/src/range.c b/src/range.c index 8f09eda24..0a76c9939 100644 --- a/src/range.c +++ b/src/range.c @@ -24,10 +24,10 @@ r_check(mrb_state *mrb, mrb_value a, mrb_value b) ta = mrb_type(a); tb = mrb_type(b); #ifdef MRB_NO_FLOAT - if (ta == MRB_TT_FIXNUM && tb == MRB_TT_FIXNUM ) { + if (ta == MRB_TT_INTEGER && tb == MRB_TT_INTEGER ) { #else - if ((ta == MRB_TT_FIXNUM || ta == MRB_TT_FLOAT) && - (tb == MRB_TT_FIXNUM || tb == MRB_TT_FLOAT)) { + if ((ta == MRB_TT_INTEGER || ta == MRB_TT_FLOAT) && + (tb == MRB_TT_INTEGER || tb == MRB_TT_FLOAT)) { #endif return; } diff --git a/src/string.c b/src/string.c index a8dfb5503..e88ba2be5 100644 --- a/src/string.c +++ b/src/string.c @@ -1093,7 +1093,7 @@ mrb_str_to_str(mrb_state *mrb, mrb_value str) return str; case MRB_TT_SYMBOL: return mrb_sym_str(mrb, mrb_symbol(str)); - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_fixnum_to_str(mrb, str, 10); case MRB_TT_SCLASS: case MRB_TT_CLASS: @@ -1154,7 +1154,7 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen, } else { switch (mrb_type(indx)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: *beg = mrb_fixnum(indx); *len = 1; return STR_CHAR_RANGE; diff --git a/src/vm.c b/src/vm.c index 401d52414..979c67424 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2256,7 +2256,7 @@ RETRY_TRY_BLOCK: } \ NEXT; #define OP_MATH_CASE_FIXNUM(op_name) \ - case TYPES2(MRB_TT_FIXNUM, MRB_TT_FIXNUM): \ + case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER): \ { \ mrb_int x = mrb_fixnum(regs[a]), y = mrb_fixnum(regs[a+1]), z; \ if (mrb_int_##op_name##_overflow(x, y, &z)) \ @@ -2289,7 +2289,7 @@ RETRY_TRY_BLOCK: #define OP_MATH_OP_add + #define OP_MATH_OP_sub - #define OP_MATH_OP_mul * -#define OP_MATH_TT_fixnum MRB_TT_FIXNUM +#define OP_MATH_TT_fixnum MRB_TT_INTEGER #define OP_MATH_TT_float MRB_TT_FLOAT CASE(OP_ADD, B) { @@ -2311,7 +2311,7 @@ RETRY_TRY_BLOCK: /* need to check if op is overridden */ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) { - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM): + case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER): { mrb_int x = mrb_fixnum(regs[a]); mrb_int y = mrb_fixnum(regs[a+1]); @@ -2345,11 +2345,11 @@ RETRY_TRY_BLOCK: } NEXT; #ifndef MRB_NO_FLOAT - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT): + case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT): x = (mrb_float)mrb_fixnum(regs[a]); y = mrb_float(regs[a+1]); break; - case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM): + case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER): x = mrb_float(regs[a]); y = (mrb_float)mrb_fixnum(regs[a+1]); break; @@ -2391,7 +2391,7 @@ RETRY_TRY_BLOCK: } \ NEXT; #define OP_MATHI_CASE_FIXNUM(op_name) \ - case MRB_TT_FIXNUM: \ + case MRB_TT_INTEGER: \ { \ mrb_int x = mrb_fixnum(regs[a]), y = (mrb_int)b, z; \ if (mrb_int_##op_name##_overflow(x, y, &z)) \ @@ -2427,7 +2427,7 @@ RETRY_TRY_BLOCK: int result;\ /* need to check if - is overridden */\ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\ - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\ + case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\ result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\ break;\ default:\ @@ -2447,13 +2447,13 @@ RETRY_TRY_BLOCK: int result;\ /* need to check if - is overridden */\ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\ - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\ + case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\ result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\ break;\ - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\ + case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\ result = OP_CMP_BODY(op,mrb_fixnum,mrb_float);\ break;\ - case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):\ + case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\ result = OP_CMP_BODY(op,mrb_float,mrb_fixnum);\ break;\ case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\ -- cgit v1.2.3 From 2a92fb2516251fb0ddfa2d1026930a2c7465e528 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 18 Aug 2020 22:12:28 +0900 Subject: Make division by zero cause `ZeroDivisionError`. As described in ISO 15.2.30. --- doc/limitations.md | 9 ++++++++- include/mruby.h | 1 + mrblib/10error.rb | 4 ++++ src/numeric.c | 20 +++----------------- src/vm.c | 13 +++++++------ test/t/superclass.rb | 2 +- 6 files changed, 24 insertions(+), 25 deletions(-) (limited to 'src/vm.c') diff --git a/doc/limitations.md b/doc/limitations.md index 7e58ca420..8ac959b98 100644 --- a/doc/limitations.md +++ b/doc/limitations.md @@ -63,8 +63,15 @@ end #### mruby [2.1.2 (2020-08-06)] -No exception is raised. +No exception is raised. Instead you have to do: +```ruby +begin + 1 / 0 +rescue => e + raise e +end +``` ## Fiber execution can't cross C function boundary mruby's `Fiber` is implemented in a similar way to Lua's co-routine. This diff --git a/include/mruby.h b/include/mruby.h index f07adbb13..959d1ac6d 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1292,6 +1292,7 @@ MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap); */ #define E_RUNTIME_ERROR (mrb_exc_get_id(mrb, MRB_SYM(RuntimeError))) #define E_TYPE_ERROR (mrb_exc_get_id(mrb, MRB_SYM(TypeError))) +#define E_ZERODIV_ERROR (mrb_exc_get_id(mrb, MRB_SYM(ZeroDivisionError))) #define E_ARGUMENT_ERROR (mrb_exc_get_id(mrb, MRB_SYM(ArgumentError))) #define E_INDEX_ERROR (mrb_exc_get_id(mrb, MRB_SYM(IndexError))) #define E_RANGE_ERROR (mrb_exc_get_id(mrb, MRB_SYM(RangeError))) diff --git a/mrblib/10error.rb b/mrblib/10error.rb index 0d9f38d58..054603514 100644 --- a/mrblib/10error.rb +++ b/mrblib/10error.rb @@ -21,6 +21,10 @@ end class TypeError < StandardError end +# ISO 15.2.30 +class ZeroDivisionError < StandardError +end + # ISO 15.2.31 class NameError < StandardError attr_accessor :name diff --git a/src/numeric.c b/src/numeric.c index 99d32f919..0cc7958e6 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -156,7 +156,7 @@ integral_div(mrb_state *mrb, mrb_value xv) mrb_get_args(mrb, "i", &y); if (y == 0) { - mrb_raise(mrb, E_RUNTIME_ERROR, "devided by zero"); + mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero"); } return mrb_fixnum_value(mrb_fixnum(xv) / y); #else @@ -932,14 +932,7 @@ int_mod(mrb_state *mrb, mrb_value x) mrb_int mod; if (b == 0) { -#ifdef MRB_NO_FLOAT - /* ZeroDivisionError */ - return mrb_fixnum_value(0); -#else - if (a > 0) return mrb_float_value(mrb, INFINITY); - if (a < 0) return mrb_float_value(mrb, INFINITY); - return mrb_float_value(mrb, NAN); -#endif + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); } fixdivmod(mrb, a, b, NULL, &mod); return mrb_fixnum_value(mod); @@ -971,14 +964,7 @@ int_divmod(mrb_state *mrb, mrb_value x) mrb_int div, mod; if (mrb_fixnum(y) == 0) { -#ifdef MRB_NO_FLOAT - return mrb_assoc_new(mrb, mrb_fixnum_value(0), mrb_fixnum_value(0)); -#else - return mrb_assoc_new(mrb, ((mrb_fixnum(x) == 0) ? - mrb_float_value(mrb, NAN): - mrb_float_value(mrb, INFINITY)), - mrb_float_value(mrb, NAN)); -#endif + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); } fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod); return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); diff --git a/src/vm.c b/src/vm.c index 979c67424..15a38c0e4 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2315,12 +2315,13 @@ RETRY_TRY_BLOCK: { mrb_int x = mrb_fixnum(regs[a]); mrb_int y = mrb_fixnum(regs[a+1]); - if (y == 0 || (x == MRB_INT_MIN && y == -1)) { -#ifdef MRB_NO_FLOAT - SET_INT_VALUE(regs[a], y ? x / y : 0); -#else - SET_FLOAT_VALUE(mrb, regs[a], (mrb_float)x / (mrb_float)y); -#endif + + + if (y == 0) { + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); + } + else if(x == MRB_INT_MIN && y == -1) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); } else { mrb_int div, mod; diff --git a/test/t/superclass.rb b/test/t/superclass.rb index 10b6438d3..70d5c24d9 100644 --- a/test/t/superclass.rb +++ b/test/t/superclass.rb @@ -29,7 +29,7 @@ [:RegexpError, :StandardError, '12.2.27.2'], [:RuntimeError, :StandardError, '12.2.28.2'], [:TypeError, :StandardError, '12.2.29.2'], -# [:ZeroDivisionError, :StandardError, '12.2.30.2'], # No ZeroDivisionError in mruby + [:ZeroDivisionError, :StandardError, '12.2.30.2'], [:NameError, :StandardError, '15.2.31.2'], [:NoMethodError, :NameError, '15.2.32.2'], [:IndexError, :StandardError, '15.2.33.2'], -- cgit v1.2.3 From 2b188ed8a191257f23ddf6f8a27bf1d3964587ed Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 26 Aug 2020 17:53:04 +0900 Subject: Reorganize `Integer` system. - Integrate `Fixnum` and `Integer` - Remove `Integral` - `int / int -> int` - Replace `mrb_fixnum()` to `mrb_int()` - Replace `mrb_fixnum_value()` to `mrb_int_value()`. - Use `mrb_integer_p()` instead of `mrb_fixnum_p()` --- include/mruby.h | 2 +- include/mruby/boxing_nan.h | 3 +- include/mruby/boxing_no.h | 4 +- include/mruby/boxing_word.h | 20 +- include/mruby/numeric.h | 5 +- include/mruby/value.h | 30 ++- mrbgems/mruby-compiler/core/codegen.c | 6 +- mrbgems/mruby-enumerator/test/enumerator.rb | 2 +- mrbgems/mruby-inline-struct/test/inline.c | 2 +- mrbgems/mruby-io/src/io.c | 4 +- mrbgems/mruby-numeric-ext/src/numeric_ext.c | 2 +- mrbgems/mruby-pack/src/pack.c | 10 +- mrbgems/mruby-random/src/random.c | 16 +- mrbgems/mruby-range-ext/src/range.c | 14 +- mrbgems/mruby-rational/mrblib/rational.rb | 17 +- mrbgems/mruby-rational/src/rational.c | 14 +- mrbgems/mruby-socket/src/socket.c | 30 +-- mrbgems/mruby-sprintf/src/sprintf.c | 10 +- mrbgems/mruby-string-ext/src/string.c | 4 +- mrbgems/mruby-struct/src/struct.c | 4 +- mrbgems/mruby-test/driver.c | 4 +- mrbgems/mruby-time/src/time.c | 11 +- mrblib/numeric.rb | 47 +++- src/array.c | 6 +- src/class.c | 2 +- src/etc.c | 49 +++-- src/hash.c | 6 +- src/numeric.c | 329 +++++++++++++++------------- src/object.c | 14 +- src/range.c | 4 +- src/string.c | 12 +- src/vm.c | 38 ++-- target/boxing.rb | 24 +- test/t/array.rb | 3 +- test/t/integer.rb | 38 +--- 35 files changed, 425 insertions(+), 361 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby.h b/include/mruby.h index 4ac26bfe9..dda0fad68 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1329,7 +1329,7 @@ MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj); MRB_API void mrb_gc_unregister(mrb_state *mrb, mrb_value obj); MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val); -#define mrb_int(mrb, val) mrb_fixnum(mrb_to_int(mrb, val)) +#define mrb_int(mrb, val) mrb_integer(mrb_to_int(mrb, val)) /* string type checking (contrary to the name, it doesn't convert) */ MRB_API mrb_value mrb_to_str(mrb_state *mrb, mrb_value val); MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t); diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index f013ed7fa..adbfb0f55 100644 --- a/include/mruby/boxing_nan.h +++ b/include/mruby/boxing_nan.h @@ -104,7 +104,8 @@ mrb_val_union(mrb_value v) #define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 1) #define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, i, 1) #define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, i, 1) -#define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n)) +#define SET_INT_VALUE(mrb, r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n)) +#define SET_FIXNUM_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n)) #define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, i, (uint32_t)(v)) #define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v)) #ifdef MRB_64BIT diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h index ff3d9f787..0b14590d9 100644 --- a/include/mruby/boxing_no.h +++ b/include/mruby/boxing_no.h @@ -30,6 +30,7 @@ typedef struct mrb_value { #define mrb_float(o) (o).value.f #endif #define mrb_fixnum(o) (o).value.i +#define mrb_integer(o) mrb_fixnum(o) #define mrb_symbol(o) (o).value.sym #define mrb_type(o) (o).tt @@ -42,7 +43,8 @@ typedef struct mrb_value { #define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1) #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1) #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1) -#define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n)) +#define SET_INT_VALUE(mrb,r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n)) +#define SET_FIXNUM_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n)) #ifndef MRB_NO_FLOAT #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v)) #endif diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index e43665e94..433fbd094 100644 --- a/include/mruby/boxing_word.h +++ b/include/mruby/boxing_word.h @@ -18,6 +18,11 @@ struct RFloat { }; #endif +struct RInteger { + MRB_OBJECT_HEADER; + mrb_int i; +}; + enum mrb_special_consts { MRB_Qnil = 0, MRB_Qfalse = 4, @@ -82,6 +87,7 @@ union mrb_value_ { #ifndef MRB_NO_FLOAT struct RFloat *fp; #endif + struct RInteger *ip; struct RCptr *vp; uintptr_t w; }; @@ -98,6 +104,9 @@ MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*); #ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #endif +MRB_API mrb_value mrb_word_boxing_int_value(struct mrb_state*, mrb_int); + +#define mrb_immediate_p(o) ((o) & BOXWORD_IMMEDIATE_MASK || (o) == MRB_Qnil) #define mrb_ptr(o) mrb_val_union(o).p #define mrb_cptr(o) mrb_val_union(o).vp->p @@ -105,6 +114,12 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #define mrb_float(o) mrb_val_union(o).fp->f #endif #define mrb_fixnum(o) BOXWORD_SHIFT_VALUE(o, FIXNUM, mrb_int) +MRB_INLINE mrb_int +mrb_integer_func(mrb_value o) { + if (mrb_immediate_p(o)) return mrb_fixnum(o); + return mrb_val_union(o).ip->i; +} +#define mrb_integer(o) mrb_integer_func(o) #ifdef MRB_64BIT #define mrb_symbol(o) mrb_val_union(o).sym #else @@ -112,8 +127,8 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #endif #define mrb_bool(o) (((o) & ~(unsigned long)MRB_Qfalse) != 0) -#define mrb_immediate_p(o) ((o) & BOXWORD_IMMEDIATE_MASK || (o) == MRB_Qnil) #define mrb_fixnum_p(o) BOXWORD_SHIFT_VALUE_P(o, FIXNUM) +#define mrb_integer_p(o) (BOXWORD_SHIFT_VALUE_P(o, FIXNUM)||BOXWORD_OBJ_TYPE_P(o, INTEGER)) #ifdef MRB_64BIT #define mrb_symbol_p(o) (mrb_val_union(o).sym_flag == BOXWORD_SYMBOL_FLAG) #else @@ -154,7 +169,8 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #define SET_FALSE_VALUE(r) ((r) = MRB_Qfalse) #define SET_TRUE_VALUE(r) ((r) = MRB_Qtrue) #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r)) -#define SET_INT_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n) +#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_word_boxing_int_value(mrb, n)) +#define SET_FIXNUM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n) #ifdef MRB_64BIT #define SET_SYM_VALUE(r,v) do {\ union mrb_value_ mrb_value_union_variable;\ diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index b8cc5b50f..f88868796 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -16,8 +16,8 @@ */ MRB_BEGIN_DECL -#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_INT_MAX) -#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_INT_MIN) +#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX) +#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN) #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t)) #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int) #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int) @@ -39,7 +39,6 @@ MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base); MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt); MRB_API int mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float f); MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x); -MRB_API mrb_value mrb_int_value(mrb_state *mrb, mrb_float f); #endif MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y); diff --git a/include/mruby/value.h b/include/mruby/value.h index 933e5a3ec..698c83300 100644 --- a/include/mruby/value.h +++ b/include/mruby/value.h @@ -54,16 +54,20 @@ struct mrb_state; #if defined(MRB_INT64) typedef int64_t mrb_int; # define MRB_INT_BIT 64 -# define MRB_INT_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT) -# define MRB_INT_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT) +# define MRB_INT_MIN INT64_MIN +# define MRB_INT_MAX INT64_MAX +# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT) +# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT) # define MRB_PRIo PRIo64 # define MRB_PRId PRId64 # define MRB_PRIx PRIx64 #else typedef int32_t mrb_int; # define MRB_INT_BIT 32 -# define MRB_INT_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT) -# define MRB_INT_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT) +# define MRB_INT_MIN INT32_MIN +# define MRB_INT_MAX INT32_MAX +# define MRB_FIXNUM_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT) +# define MRB_FIXNUM_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT) # define MRB_PRIo PRIo32 # define MRB_PRId PRId32 # define MRB_PRIx PRIx32 @@ -180,8 +184,11 @@ struct RCptr { #ifndef mrb_immediate_p #define mrb_immediate_p(o) (mrb_type(o) < MRB_TT_FREE) #endif +#ifndef mrb_integer_p +#define mrb_integer_p(o) (mrb_type(o) == MRB_TT_INTEGER) +#endif #ifndef mrb_fixnum_p -#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_INTEGER) +#define mrb_fixnum_p(o) mrb_integer_p(o) #endif #ifndef mrb_symbol_p #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL) @@ -287,14 +294,19 @@ mrb_cptr_value(struct mrb_state *mrb, void *p) } /** - * Returns a fixnum in Ruby. - * - * Takes an integer and boxes it into an mrb_value + * Returns an integer in Ruby. */ +MRB_INLINE mrb_value mrb_int_value(struct mrb_state *mrb, mrb_int i) +{ + mrb_value v; + SET_INT_VALUE(mrb, v, i); + return v; +} + MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i) { mrb_value v; - SET_INT_VALUE(v, i); + SET_FIXNUM_VALUE(v, i); return v; } diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 72ae0a3a9..2e39817ec 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -545,7 +545,7 @@ new_lit(codegen_scope *s, mrb_value val) #endif case MRB_TT_INTEGER: for (i=0; iirep->plen; i++) { - mrb_int v = mrb_fixnum(val); + mrb_int v = mrb_integer(val); pv = &s->pool[i]; if (pv->tt == IREP_TT_INT32) { if (v == pv->u.i32) return i; @@ -597,10 +597,10 @@ new_lit(codegen_scope *s, mrb_value val) case MRB_TT_INTEGER: #ifdef MRB_INT64 pv->tt = IREP_TT_INT64; - pv->u.i64 = mrb_fixnum(val); + pv->u.i64 = mrb_integer(val); #else pv->tt = IREP_TT_INT32; - pv->u.i32 = mrb_fixnum(val); + pv->u.i32 = mrb_integer(val); #endif break; diff --git a/mrbgems/mruby-enumerator/test/enumerator.rb b/mrbgems/mruby-enumerator/test/enumerator.rb index ecd6c4d65..26d5766fc 100644 --- a/mrbgems/mruby-enumerator/test/enumerator.rb +++ b/mrbgems/mruby-enumerator/test/enumerator.rb @@ -445,7 +445,7 @@ assert 'modifying existing methods' do } end -assert 'Integral#times' do +assert 'Integer#times' do a = 3 b = a.times c = [] diff --git a/mrbgems/mruby-inline-struct/test/inline.c b/mrbgems/mruby-inline-struct/test/inline.c index b4d9b1f1e..6764b1af4 100644 --- a/mrbgems/mruby-inline-struct/test/inline.c +++ b/mrbgems/mruby-inline-struct/test/inline.c @@ -10,7 +10,7 @@ istruct_test_initialize(mrb_state *mrb, mrb_value self) mrb_int size = mrb_istruct_size(); mrb_value object = mrb_get_arg1(mrb); - if (mrb_fixnum_p(object)) { + if (mrb_integer_p(object)) { strncpy(string, "fixnum", size-1); } #ifndef MRB_NO_FLOAT diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 712fea79c..97bff31b4 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -339,7 +339,7 @@ option_to_fd(mrb_state *mrb, mrb_value hash, const char *key) case MRB_TT_DATA: /* IO */ return mrb_io_fileno(mrb, opt); case MRB_TT_INTEGER: - return (int)mrb_fixnum(opt); + return (int)mrb_integer(opt); default: mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action"); break; @@ -1077,7 +1077,7 @@ time2timeval(mrb_state *mrb, mrb_value time) switch (mrb_type(time)) { case MRB_TT_INTEGER: - t.tv_sec = (ftime_t)mrb_fixnum(time); + t.tv_sec = (ftime_t)mrb_integer(time); t.tv_usec = 0; break; diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index d00be4b5d..e5ec90866 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -53,7 +53,7 @@ mrb_int_nobits(mrb_state *mrb, mrb_value self) void mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) { - struct RClass *i = mrb_module_get(mrb, "Integral"); + struct RClass *i = mrb_class_get(mrb, "Integer"); mrb_define_method(mrb, i, "allbits?", mrb_int_allbits, MRB_ARGS_REQ(1)); mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1)); diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index f797b599b..35e79d25d 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -143,7 +143,7 @@ static int pack_c(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) { str = str_len_ensure(mrb, str, sidx + 1); - RSTRING_PTR(str)[sidx] = (char)mrb_fixnum(o); + RSTRING_PTR(str)[sidx] = (char)mrb_integer(o); return 1; } @@ -163,7 +163,7 @@ pack_s(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl uint16_t n; str = str_len_ensure(mrb, str, sidx + 2); - n = (uint16_t)mrb_fixnum(o); + n = (uint16_t)mrb_integer(o); if (flags & PACK_FLAG_LITTLEENDIAN) { RSTRING_PTR(str)[sidx+0] = n % 256; RSTRING_PTR(str)[sidx+1] = n / 256; @@ -197,7 +197,7 @@ pack_l(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl uint32_t n; str = str_len_ensure(mrb, str, sidx + 4); - n = (uint32_t)mrb_fixnum(o); + n = (uint32_t)mrb_integer(o); if (flags & PACK_FLAG_LITTLEENDIAN) { RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff); RSTRING_PTR(str)[sidx+1] = (char)(n >> 8); @@ -313,7 +313,7 @@ pack_q(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl uint64_t n; str = str_len_ensure(mrb, str, sidx + 8); - n = (uint64_t)mrb_fixnum(o); + n = (uint64_t)mrb_integer(o); if (flags & PACK_FLAG_LITTLEENDIAN) { RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff); RSTRING_PTR(str)[sidx+1] = (char)(n >> 8); @@ -560,7 +560,7 @@ pack_utf8(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, long count, int len = 0; uint32_t c = 0; - c = (uint32_t)mrb_fixnum(o); + c = (uint32_t)mrb_integer(o); /* Unicode character */ /* from mruby-compiler gem */ diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index 39c72ac9e..5fa15c508 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -93,7 +93,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max) { mrb_value value; - if (mrb_fixnum(max) == 0) { + if (mrb_integer(max) == 0) { #ifndef MRB_NO_FLOAT value = mrb_float_value(mrb, rand_real(t)); #else @@ -101,7 +101,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max) #endif } else { - value = mrb_fixnum_value(rand_uint32(t) % mrb_fixnum(max)); + value = mrb_fixnum_value(rand_uint32(t) % mrb_integer(max)); } return value; @@ -119,7 +119,7 @@ get_opt(mrb_state* mrb) mrb_int i; arg = mrb_to_int(mrb, arg); - i = mrb_fixnum(arg); + i = mrb_integer(arg); if (i < 0) { arg = mrb_fixnum_value(0 - i); } @@ -161,7 +161,7 @@ random_m_init(mrb_state *mrb, mrb_value self) rand_init(t); } else { - rand_seed(t, (uint32_t)mrb_fixnum(seed)); + rand_seed(t, (uint32_t)mrb_integer(seed)); } return self; @@ -190,7 +190,7 @@ random_m_srand(mrb_state *mrb, mrb_value self) seed = (uint32_t)time(NULL) + rand_uint32(t); } else { - seed = (uint32_t)mrb_fixnum(sv); + seed = (uint32_t)mrb_integer(sv); } old_seed = rand_seed(t, seed); @@ -257,7 +257,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary) mrb_value *ptr = RARRAY_PTR(ary); mrb_value tmp; - j = mrb_fixnum(random_rand(mrb, random, max)); + j = mrb_integer(random_rand(mrb, random, max)); tmp = ptr[i]; ptr[i] = ptr[j]; @@ -342,7 +342,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary) r = (mrb_int)(rand_uint32(random) % len); for (j=0; j(rhs) - if rhs.is_a?(Integral) + case rhs + when Integer, Float return numerator <=> rhs if denominator == 1 rhs = Rational(rhs) end - case rhs when Rational (numerator * rhs.denominator - denominator * rhs.numerator) <=> 0 @@ -65,14 +65,13 @@ class Rational < Numeric def ==(rhs) return true if self.equal?(rhs) - if rhs.is_a?(Integral) && denominator == 1 - return numerator == rhs - end - if rhs.is_a?(Rational) - numerator * rhs.denominator == denominator * rhs.numerator - else - rhs == self + case rhs + when Integer, Float + return numerator == rhs if denominator == 1 + when Rational + return numerator * rhs.denominator == denominator * rhs.numerator end + rhs == self end end diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index fcaba3df5..5b1bec9e2 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -102,11 +102,11 @@ rational_s_new(mrb_state *mrb, mrb_value self) mrb_value numv, denomv; mrb_get_args(mrb, "oo", &numv, &denomv); - if (mrb_fixnum_p(numv)) { - numerator = mrb_fixnum(numv); + if (mrb_integer_p(numv)) { + numerator = mrb_integer(numv); - if (mrb_fixnum_p(denomv)) { - denominator = mrb_fixnum(denomv); + if (mrb_integer_p(denomv)) { + denominator = mrb_integer(denomv); } else { mrb_float denomf = mrb_to_flo(mrb, denomv); @@ -118,8 +118,8 @@ rational_s_new(mrb_state *mrb, mrb_value self) else { mrb_float numf = mrb_to_flo(mrb, numv); - if (mrb_fixnum_p(denomv)) { - denominator = mrb_fixnum(denomv); + if (mrb_integer_p(denomv)) { + denominator = mrb_integer(denomv); } else { mrb_float denomf = mrb_to_flo(mrb, denomv); @@ -176,7 +176,7 @@ rational_negative_p(mrb_state *mrb, mrb_value self) static mrb_value fix_to_r(mrb_state *mrb, mrb_value self) { - return rational_new(mrb, mrb_fixnum(self), 1); + return rational_new(mrb, mrb_integer(self), 1); } void mrb_mruby_rational_gem_init(mrb_state *mrb) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 6542c1603..d94573c96 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -140,7 +140,7 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass) if (mrb_string_p(service)) { servname = RSTRING_CSTR(mrb, service); - } else if (mrb_fixnum_p(service)) { + } else if (mrb_integer_p(service)) { servname = RSTRING_PTR(mrb_fixnum_to_str(mrb, service, 10)); } else if (mrb_nil_p(service)) { servname = NULL; @@ -151,16 +151,16 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass) memset(&hints, 0, sizeof(hints)); hints.ai_flags = (int)flags; - if (mrb_fixnum_p(family)) { - hints.ai_family = (int)mrb_fixnum(family); + if (mrb_integer_p(family)) { + hints.ai_family = (int)mrb_integer(family); } - if (mrb_fixnum_p(socktype)) { - hints.ai_socktype = (int)mrb_fixnum(socktype); + if (mrb_integer_p(socktype)) { + hints.ai_socktype = (int)mrb_integer(socktype); } - if (mrb_fixnum_p(protocol)) { - hints.ai_protocol = (int)mrb_fixnum(protocol); + if (mrb_integer_p(protocol)) { + hints.ai_protocol = (int)mrb_integer(protocol); } lastai = mrb_cv_get(mrb, klass, MRB_SYM(_lastai)); @@ -269,7 +269,7 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen) static int socket_fd(mrb_state *mrb, mrb_value sock) { - return (int)mrb_fixnum(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0)); + return (int)mrb_integer(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0)); } static int @@ -449,21 +449,21 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self) argc = mrb_get_args(mrb, "o|io", &so, &optname, &optval); if (argc == 3) { - if (!mrb_fixnum_p(so)) { + if (!mrb_integer_p(so)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "level is not an integer"); } - level = mrb_fixnum(so); + level = mrb_integer(so); if (mrb_string_p(optval)) { /* that's good */ } else if (mrb_true_p(optval) || mrb_false_p(optval)) { mrb_int i = mrb_test(optval) ? 1 : 0; optval = mrb_str_new(mrb, (char*)&i, sizeof(i)); - } else if (mrb_fixnum_p(optval)) { + } else if (mrb_integer_p(optval)) { if (optname == IP_MULTICAST_TTL || optname == IP_MULTICAST_LOOP) { - char uc = (char)mrb_fixnum(optval); + char uc = (char)mrb_integer(optval); optval = mrb_str_new(mrb, &uc, sizeof(uc)); } else { - mrb_int i = mrb_fixnum(optval); + mrb_int i = mrb_integer(optval); optval = mrb_str_new(mrb, (char*)&i, sizeof(i)); } } else { @@ -472,8 +472,8 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self) } else if (argc == 1) { if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option"); - level = mrb_fixnum(mrb_funcall_id(mrb, so, MRB_SYM(level), 0)); - optname = mrb_fixnum(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0)); + level = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(level), 0)); + optname = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0)); optval = mrb_funcall_id(mrb, so, MRB_SYM(data), 0); } else { mrb_argnum_error(mrb, argc, 3, 3); diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 4df3e3a17..9ac8a512d 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -74,7 +74,7 @@ static mrb_value mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) { char buf[66], *b = buf + sizeof buf; - mrb_int num = mrb_fixnum(x); + mrb_int num = mrb_integer(x); uint64_t val = (uint64_t)num; char d; @@ -764,8 +764,8 @@ retry: mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character"); } } - else if (mrb_fixnum_p(val)) { - mrb_int n = mrb_fixnum(val); + else if (mrb_integer_p(val)) { + mrb_int n = mrb_integer(val); #ifndef MRB_UTF8_STRING char buf[1]; @@ -882,14 +882,14 @@ retry: #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: val = mrb_flo_to_fixnum(mrb, val); - if (mrb_fixnum_p(val)) goto bin_retry; + if (mrb_integer_p(val)) goto bin_retry; break; #endif case MRB_TT_STRING: val = mrb_str_to_inum(mrb, val, 0, TRUE); goto bin_retry; case MRB_TT_INTEGER: - v = mrb_fixnum(val); + v = mrb_integer(val); break; default: val = mrb_Integer(mrb, val); diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c index 71fb5bb65..4b8f99597 100644 --- a/mrbgems/mruby-string-ext/src/string.c +++ b/mrbgems/mruby-string-ext/src/string.c @@ -166,7 +166,7 @@ mrb_str_concat_m(mrb_state *mrb, mrb_value self) { mrb_value str = mrb_get_arg1(mrb); - if (mrb_fixnum_p(str) || mrb_float_p(str)) + if (mrb_integer_p(str) || mrb_float_p(str)) #ifdef MRB_UTF8_STRING str = int_chr_utf8(mrb, str); #else @@ -1231,7 +1231,7 @@ mrb_mruby_string_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, s, "__lines", mrb_str_lines, MRB_ARGS_NONE()); - mrb_define_method(mrb, mrb_module_get(mrb, "Integral"), "chr", mrb_int_chr, MRB_ARGS_OPT(1)); + mrb_define_method(mrb, mrb_class_get(mrb, "Integer"), "chr", mrb_int_chr, MRB_ARGS_OPT(1)); } void diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index 1189381cb..7c6f50090 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -113,7 +113,7 @@ mrb_struct_members(mrb_state *mrb, mrb_value obj) static mrb_value mrb_struct_ref(mrb_state *mrb, mrb_value obj) { - mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0)); + mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0)); mrb_value *ptr = RSTRUCT_PTR(obj); if (!ptr) return mrb_nil_value(); @@ -152,7 +152,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id) static mrb_value mrb_struct_set_m(mrb_state *mrb, mrb_value obj) { - mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0)); + mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0)); mrb_value *ptr; mrb_value val = mrb_get_arg1(mrb); diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index 4b82a9abc..b22888ec5 100644 --- a/mrbgems/mruby-test/driver.c +++ b/mrbgems/mruby-test/driver.c @@ -252,9 +252,9 @@ mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src) #define TEST_COUNT_PASS(name) \ do { \ res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$" #name)); \ - if (mrb_fixnum_p(res_src)) { \ + if (mrb_integer_p(res_src)) { \ mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name)); \ - mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_fixnum(res_dst) + mrb_fixnum(res_src))); \ + mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_integer(res_dst) + mrb_integer(res_src))); \ } \ } while (FALSE) \ diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 8a4f1d233..2af86b14e 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -218,11 +218,15 @@ typedef mrb_int mrb_sec; (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX) \ ) +/* return true if time_t is fit in mrb_int */ static mrb_bool fixable_time_t_p(time_t v) { if (MRB_INT_MIN <= MRB_TIME_MIN && MRB_TIME_MAX <= MRB_INT_MAX) return TRUE; - return FIXABLE(v); + if (v > (time_t)MRB_INT_MAX) return FALSE; + if (MRB_TIME_T_UINT) return TRUE; + if (MRB_INT_MIN > (mrb_int)v) return FALSE; + return TRUE; } static time_t @@ -880,11 +884,6 @@ mrb_time_usec(mrb_state *mrb, mrb_value self) struct mrb_time *tm; tm = time_get_ptr(mrb, self); -#ifndef MRB_NO_FLOAT - if (!fixable_time_t_p(tm->usec)) { - return mrb_float_value(mrb, (mrb_float)tm->usec); - } -#endif return mrb_fixnum_value((mrb_int)tm->usec); } diff --git a/mrblib/numeric.rb b/mrblib/numeric.rb index 5926518d5..e28d63324 100644 --- a/mrblib/numeric.rb +++ b/mrblib/numeric.rb @@ -34,11 +34,11 @@ class Numeric end ## -# Integral +# Integer # -# mruby special - module to share methods between Floats and Integers -# to make them compatible -module Integral +# ISO 15.2.8 +## +class Integer ## # Calls the given block once for each Integer # from +self+ downto +num+. @@ -125,14 +125,7 @@ module Integral end self end -end -## -# Integer -# -# ISO 15.2.8 -class Integer - include Integral ## # Returns the receiver simply. # @@ -161,3 +154,35 @@ class Integer # ISO 15.2.8.3.26 alias truncate floor end + +class Float + ## + # Calls the given block from +self+ to +num+ + # incremented by +step+ (default 1). + # + def step(num=nil, step=1, &block) + raise ArgumentError, "step can't be 0" if step == 0 + return to_enum(:step, num, step) unless block + + i = self + if num == self || step.infinite? + block.call(i) if step > 0 && i <= (num||i) || step < 0 && i >= (num||-i) + elsif num == nil + while true + block.call(i) + i += step + end + elsif step > 0 + while i <= num + block.call(i) + i += step + end + else + while i >= num + block.call(i) + i += step + end + end + self + end +end diff --git a/src/array.c b/src/array.c index cd0b59ac2..c4bc554ef 100644 --- a/src/array.c +++ b/src/array.c @@ -822,8 +822,8 @@ mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len) static mrb_int aget_index(mrb_state *mrb, mrb_value index) { - if (mrb_fixnum_p(index)) { - return mrb_fixnum(index); + if (mrb_integer_p(index)) { + return mrb_integer(index); } #ifndef MRB_NO_FLOAT else if (mrb_float_p(index)) { @@ -886,7 +886,7 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self) return mrb_nil_value(); } case MRB_TT_INTEGER: - return mrb_ary_ref(mrb, self, mrb_fixnum(index)); + return mrb_ary_ref(mrb, self, mrb_integer(index)); default: return mrb_ary_ref(mrb, self, aget_index(mrb, index)); } diff --git a/src/class.c b/src/class.c index 500e7f953..779a02da9 100644 --- a/src/class.c +++ b/src/class.c @@ -913,7 +913,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) p = va_arg(ap, mrb_int*); if (i < argc) { - *p = mrb_fixnum(mrb_to_int(mrb, argv[i++])); + *p = mrb_integer(mrb_to_int(mrb, argv[i++])); } } break; diff --git a/src/etc.c b/src/etc.c index e9990bec5..96f95ad5f 100644 --- a/src/etc.c +++ b/src/etc.c @@ -8,6 +8,7 @@ #include #include #include +#include MRB_API struct RData* mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const mrb_data_type *type) @@ -69,21 +70,11 @@ mrb_obj_to_sym(mrb_state *mrb, mrb_value name) return 0; /* not reached */ } -MRB_API mrb_int -#ifdef MRB_NO_FLOAT -mrb_fixnum_id(mrb_int f) -#else -mrb_float_id(mrb_float f) -#endif +static mrb_int +make_num_id(const char *p, size_t len) { - const char *p = (const char*)&f; - int len = sizeof(f); uint32_t id = 0; -#ifndef MRB_NO_FLOAT - /* normalize -0.0 to 0.0 */ - if (f == 0) f = 0.0; -#endif while (len--) { id = id*65599 + *p; p++; @@ -93,6 +84,22 @@ mrb_float_id(mrb_float f) return (mrb_int)id; } +MRB_API mrb_int +mrb_int_id(mrb_int n) +{ + return make_num_id((const char*)&n, sizeof(n)); +} + +#ifndef MRB_NO_FLOAT +MRB_API mrb_int +mrb_float_id(mrb_float f) +{ + /* normalize -0.0 to 0.0 */ + if (f == 0) f = 0.0; + return make_num_id((const char*)&f, sizeof(f)); +} +#endif + MRB_API mrb_int mrb_obj_id(mrb_value obj) { @@ -115,10 +122,8 @@ mrb_obj_id(mrb_value obj) case MRB_TT_SYMBOL: return MakeID(mrb_symbol(obj)); case MRB_TT_INTEGER: + return MakeID(mrb_int_id(mrb_integer(obj))); #ifdef MRB_NO_FLOAT - return MakeID(mrb_fixnum_id(mrb_fixnum(obj))); -#else - return MakeID2(mrb_float_id((mrb_float)mrb_fixnum(obj)), MRB_TT_FLOAT); case MRB_TT_FLOAT: return MakeID(mrb_float_id(mrb_float(obj))); #endif @@ -159,6 +164,20 @@ mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f) return v.w; } #endif /* MRB_NO_FLOAT */ + +MRB_API mrb_value +mrb_word_boxing_int_value(mrb_state *mrb, mrb_int n) +{ + if (FIXABLE(n)) return mrb_fixnum_value(n); + else { + union mrb_value_ v; + + v.p = mrb_obj_alloc(mrb, MRB_TT_INTEGER, mrb->integer_class); + v.ip->i = n; + MRB_SET_FROZEN_FLAG(v.ip); + return v.w; + } +} #endif /* MRB_WORD_BOXING */ #if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT)) diff --git a/src/hash.c b/src/hash.c index 79cec4b71..d67fa6254 100644 --- a/src/hash.c +++ b/src/hash.c @@ -73,7 +73,7 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key) default: hv = mrb_funcall_id(mrb, key, MRB_SYM(hash), 0); - h = (size_t)tt ^ (size_t)mrb_fixnum(hv); + h = (size_t)tt ^ (size_t)mrb_integer(hv); break; } if (index && (index != t->index || capa != index->capa)) { @@ -96,8 +96,8 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b) return mrb_symbol(a) == mrb_symbol(b); case MRB_TT_INTEGER: - if (!mrb_fixnum_p(b)) return FALSE; - return mrb_fixnum(a) == mrb_fixnum(b); + if (!mrb_integer_p(b)) return FALSE; + return mrb_integer(a) == mrb_integer(b); #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: diff --git a/src/numeric.c b/src/numeric.c index 0cc7958e6..8fb144fae 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -36,7 +36,7 @@ mrb_to_flo(mrb_state *mrb, mrb_value val) { switch (mrb_type(val)) { case MRB_TT_INTEGER: - return (mrb_float)mrb_fixnum(val); + return (mrb_float)mrb_integer(val); case MRB_TT_FLOAT: break; default: @@ -44,15 +44,6 @@ mrb_to_flo(mrb_state *mrb, mrb_value val) } return mrb_float(val); } - -MRB_API mrb_value -mrb_int_value(mrb_state *mrb, mrb_float f) -{ - if (FIXABLE_FLOAT(f)) { - return mrb_fixnum_value((mrb_int)f); - } - return mrb_float_value(mrb, f); -} #endif /* @@ -65,67 +56,48 @@ mrb_int_value(mrb_state *mrb, mrb_float f) * 2.0**3 #=> 8.0 */ static mrb_value -integral_pow(mrb_state *mrb, mrb_value x) +int_pow(mrb_state *mrb, mrb_value x) { - mrb_value y = mrb_get_arg1(mrb); + mrb_int base = mrb_int(mrb, x); + mrb_int exp; #ifndef MRB_NO_FLOAT - mrb_float d; -#endif - - if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) { - /* try ipow() */ - mrb_int base = mrb_fixnum(x); - mrb_int exp = mrb_fixnum(y); - mrb_int result = 1; + mrb_value y; + mrb_float z; - if (exp < 0) -#ifdef MRB_NO_FLOAT - return mrb_fixnum_value(0); -#else - goto float_pow; -#endif - for (;;) { - if (exp & 1) { - if (mrb_int_mul_overflow(result, base, &result)) { -#ifndef MRB_NO_FLOAT - goto float_pow; -#endif - } - } - exp >>= 1; - if (exp == 0) break; - if (mrb_int_mul_overflow(base, base, &base)) { -#ifndef MRB_NO_FLOAT - goto float_pow; -#endif - } + mrb_get_args(mrb, "o", &y); + if (!mrb_integer_p(y)) { + mrb_get_args(mrb, "f", &z); + z = pow((mrb_float)base, z); + return mrb_float_value(mrb, z); + } + else { + mrb_get_args(mrb, "i", &exp); + z = pow((double)base, (double)exp); + if (exp < 0 || z < (mrb_float)MRB_INT_MIN || (mrb_float)MRB_INT_MAX < z) { + return mrb_float_value(mrb, z); } - return mrb_fixnum_value(result); } -#ifdef MRB_NO_FLOAT - mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); + return mrb_int_value(mrb, (mrb_int)z); #else - float_pow: - d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y)); - return mrb_float_value(mrb, d); -#endif -} - -static mrb_value -integral_idiv(mrb_state *mrb, mrb_value x) -{ -#ifdef MRB_NO_FLOAT - mrb_value y = mrb_get_arg1(mrb); + mrb_int result = 1; - if (!mrb_fixnum_p(y)) { - mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); + mrb_get_args(mrb, "i", &exp); + if (exp < 0) { + return mrb_fixnum_value(0); } - return mrb_fixnum_value(mrb_fixnum(x) / mrb_fixnum(y)); -#else - mrb_float y; - - mrb_get_args(mrb, "f", &y); - return mrb_int_value(mrb, mrb_to_flo(mrb, x) / y); + for (;;) { + if (exp & 1) { + if (mrb_int_mul_overflow(result, base, &result)) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); + } + } + exp >>= 1; + if (exp == 0) break; + if (mrb_int_mul_overflow(base, base, &base)) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); + } + } + return mrb_int_value(mrb, result); #endif } @@ -133,13 +105,36 @@ integral_idiv(mrb_state *mrb, mrb_value x) /* 15.2.9.3.4 */ /* * call-seq: - * num / other -> num + * int / other -> int * * Performs division: the class of the resulting object depends on * the class of num and on the magnitude of the * result. */ +static mrb_value +int_div(mrb_state *mrb, mrb_value xv) +{ +#ifndef MRB_NO_FLOAT + mrb_value yv; + + mrb_get_args(mrb, "o", &yv); + if (mrb_float_p(yv)) { + return mrb_fixnum_value((mrb_int)((mrb_float)mrb_integer(xv)/mrb_float(yv))); + } + else +#endif + { + mrb_int y; + + mrb_get_args(mrb, "i", &y); + if (y == 0) { + mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero"); + } + return mrb_fixnum_value(mrb_integer(xv) / y); + } +} + /* 15.2.9.3.19(x) */ /* * call-seq: @@ -149,7 +144,7 @@ integral_idiv(mrb_state *mrb, mrb_value x) */ static mrb_value -integral_div(mrb_state *mrb, mrb_value xv) +int_quo(mrb_state *mrb, mrb_value xv) { #ifdef MRB_NO_FLOAT mrb_int y; @@ -160,25 +155,15 @@ integral_div(mrb_state *mrb, mrb_value xv) } return mrb_fixnum_value(mrb_fixnum(xv) / y); #else - mrb_float x, y; + mrb_float y; mrb_get_args(mrb, "f", &y); - x = mrb_to_flo(mrb, xv); - if (y == 0) { - if (x < 0) - y = -INFINITY; - else if (x > 0) - y = INFINITY; - else /* if (x == 0) */ - y = NAN; - return mrb_float_value(mrb, y); - } - return mrb_float_value(mrb, x / y); + return mrb_float_value(mrb, (mrb_float)mrb_integer(xv) / y); #endif } static mrb_value -integral_coerce_step_counter(mrb_state *mrb, mrb_value self) +coerce_step_counter(mrb_state *mrb, mrb_value self) { mrb_value num, step; @@ -203,6 +188,42 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self) * representation. */ +static mrb_value +flo_pow(mrb_state *mrb, mrb_value x) +{ + mrb_value y = mrb_get_arg1(mrb); + mrb_float d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, d); +} + +static mrb_value +flo_idiv(mrb_state *mrb, mrb_value x) +{ + mrb_float y; + + mrb_get_args(mrb, "f", &y); + return mrb_int_value(mrb, (mrb_int)(mrb_to_flo(mrb, x) / y)); +} + +static mrb_value +flo_div(mrb_state *mrb, mrb_value xv) +{ + mrb_float x, y; + + mrb_get_args(mrb, "f", &y); + x = mrb_float(xv); + if (y == 0) { + if (x < 0) + y = -INFINITY; + else if (x > 0) + y = INFINITY; + else /* if (x == 0) */ + y = NAN; + return mrb_float_value(mrb, y); + } + return mrb_float_value(mrb, x / y); +} + static mrb_value flo_to_str(mrb_state *mrb, mrb_value flt, mrb_bool add_dot_zero) { @@ -417,8 +438,8 @@ int_eql(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); - if (!mrb_fixnum_p(y)) return mrb_false_value(); - return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); + if (!mrb_integer_p(y)) return mrb_false_value(); + return mrb_bool_value(mrb_integer(x) == mrb_integer(y)); } #ifndef MRB_NO_FLOAT @@ -451,7 +472,7 @@ flo_eq(mrb_state *mrb, mrb_value x) switch (mrb_type(y)) { case MRB_TT_INTEGER: - return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y)); + return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_integer(y)); case MRB_TT_FLOAT: return mrb_bool_value(mrb_float(x) == mrb_float(y)); default: @@ -464,7 +485,7 @@ value_int64(mrb_state *mrb, mrb_value x) { switch (mrb_type(x)) { case MRB_TT_INTEGER: - return (int64_t)mrb_fixnum(x); + return (int64_t)mrb_integer(x); case MRB_TT_FLOAT: return (int64_t)mrb_float(x); default: @@ -560,7 +581,7 @@ flo_shift(mrb_state *mrb, mrb_value x, mrb_int width) val *= 2; } } - return mrb_int_value(mrb, val); + return mrb_int_value(mrb, (mrb_int)val); } static mrb_value @@ -666,7 +687,7 @@ flo_floor(mrb_state *mrb, mrb_value num) mrb_float f = floor(mrb_float(num)); mrb_check_num_exact(mrb, f); - return mrb_int_value(mrb, f); + return mrb_int_value(mrb, (mrb_int)f); } /* 15.2.9.3.8 */ @@ -689,7 +710,7 @@ flo_ceil(mrb_state *mrb, mrb_value num) mrb_float f = ceil(mrb_float(num)); mrb_check_num_exact(mrb, f); - return mrb_int_value(mrb, f); + return mrb_int_value(mrb, (mrb_int)f); } /* 15.2.9.3.12 */ @@ -771,7 +792,7 @@ flo_round(mrb_state *mrb, mrb_value num) if (!isfinite(number)) return num; return mrb_float_value(mrb, number); } - return mrb_int_value(mrb, number); + return mrb_int_value(mrb, (mrb_int)number); } /* 15.2.9.3.14 */ @@ -793,7 +814,7 @@ flo_truncate(mrb_state *mrb, mrb_value num) if (f < 0.0) f = ceil(f); mrb_check_num_exact(mrb, f); - return mrb_int_value(mrb, f); + return mrb_int_value(mrb, (mrb_int)f); } static mrb_value @@ -830,12 +851,12 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y) { mrb_int a; - a = mrb_fixnum(x); - if (mrb_fixnum_p(y)) { + a = mrb_integer(x); + if (mrb_integer_p(y)) { mrb_int b, c; if (a == 0) return x; - b = mrb_fixnum(y); + b = mrb_integer(y); if (mrb_int_mul_overflow(a, b, &c)) { #ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b); @@ -853,7 +874,7 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y) MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) { - if (mrb_fixnum_p(x)) { + if (mrb_integer_p(x)) { return fixnum_mul(mrb, x, y); } #ifndef MRB_NO_FLOAT @@ -927,8 +948,8 @@ int_mod(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); mrb_int a, b; - a = mrb_fixnum(x); - if (mrb_fixnum_p(y) && a != MRB_INT_MIN && (b=mrb_fixnum(y)) != MRB_INT_MIN) { + a = mrb_integer(x); + if (mrb_integer_p(y) && a != MRB_INT_MIN && (b=mrb_integer(y)) != MRB_INT_MIN) { mrb_int mod; if (b == 0) { @@ -960,13 +981,13 @@ int_divmod(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); - if (mrb_fixnum_p(y)) { + if (mrb_integer_p(y)) { mrb_int div, mod; - if (mrb_fixnum(y) == 0) { + if (mrb_integer(y) == 0) { mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); } - fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod); + fixdivmod(mrb, mrb_integer(x), mrb_integer(y), &div, &mod); return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); } #ifdef MRB_NO_FLOAT @@ -976,8 +997,8 @@ int_divmod(mrb_state *mrb, mrb_value x) mrb_float div, mod; mrb_value a, b; - flodivmod(mrb, (mrb_float)mrb_fixnum(x), mrb_to_flo(mrb, y), &div, &mod); - a = mrb_int_value(mrb, div); + flodivmod(mrb, (mrb_float)mrb_integer(x), mrb_to_flo(mrb, y), &div, &mod); + a = mrb_int_value(mrb, (mrb_int)div); b = mrb_float_value(mrb, mod); return mrb_assoc_new(mrb, a, b); } @@ -993,7 +1014,7 @@ flo_divmod(mrb_state *mrb, mrb_value x) mrb_value a, b; flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod); - a = mrb_int_value(mrb, div); + a = mrb_int_value(mrb, (mrb_int)div); b = mrb_float_value(mrb, mod); return mrb_assoc_new(mrb, a, b); } @@ -1018,10 +1039,10 @@ int_equal(mrb_state *mrb, mrb_value x) switch (mrb_type(y)) { case MRB_TT_INTEGER: - return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); + return mrb_bool_value(mrb_integer(x) == mrb_integer(y)); #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: - return mrb_bool_value((mrb_float)mrb_fixnum(x) == mrb_float(y)); + return mrb_bool_value((mrb_float)mrb_integer(x) == mrb_float(y)); #endif default: return mrb_false_value(); @@ -1042,22 +1063,22 @@ int_equal(mrb_state *mrb, mrb_value x) static mrb_value int_rev(mrb_state *mrb, mrb_value num) { - mrb_int val = mrb_fixnum(num); + mrb_int val = mrb_integer(num); return mrb_fixnum_value(~val); } #ifdef MRB_NO_FLOAT #define bit_op(x,y,op1,op2) do {\ - return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\ + return mrb_fixnum_value(mrb_integer(x) op2 mrb_integer(y));\ } while(0) #else static mrb_value flo_and(mrb_state *mrb, mrb_value x); static mrb_value flo_or(mrb_state *mrb, mrb_value x); static mrb_value flo_xor(mrb_state *mrb, mrb_value x); #define bit_op(x,y,op1,op2) do {\ - if (mrb_fixnum_p(y)) return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\ - return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_fixnum(x)));\ + if (mrb_integer_p(y)) return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y))); \ + return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_integer(x)));\ } while(0) #endif @@ -1188,7 +1209,7 @@ int_lshift(mrb_state *mrb, mrb_value x) if (width == 0) { return x; } - val = mrb_fixnum(x); + val = mrb_integer(x); if (val == 0) return x; if (width < 0) { return rshift(val, -width); @@ -1213,7 +1234,7 @@ int_rshift(mrb_state *mrb, mrb_value x) if (width == 0) { return x; } - val = mrb_fixnum(x); + val = mrb_integer(x); if (val == 0) return x; if (width < 0) { return lshift(mrb, val, -width); @@ -1234,7 +1255,7 @@ int_rshift(mrb_state *mrb, mrb_value x) static mrb_value int_to_f(mrb_state *mrb, mrb_value num) { - return mrb_float_value(mrb, (mrb_float)mrb_fixnum(num)); + return mrb_float_value(mrb, (mrb_float)mrb_integer(num)); } /* @@ -1280,12 +1301,12 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y) { mrb_int a; - a = mrb_fixnum(x); - if (mrb_fixnum_p(y)) { + a = mrb_integer(x); + if (mrb_integer_p(y)) { mrb_int b, c; if (a == 0) return y; - b = mrb_fixnum(y); + b = mrb_integer(y); if (mrb_int_add_overflow(a, b, &c)) { #ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b); @@ -1303,7 +1324,7 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y) MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) { - if (mrb_fixnum_p(x)) { + if (mrb_integer_p(x)) { return fixnum_plus(mrb, x, y); } #ifndef MRB_NO_FLOAT @@ -1337,11 +1358,11 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y) { mrb_int a; - a = mrb_fixnum(x); - if (mrb_fixnum_p(y)) { + a = mrb_integer(x); + if (mrb_integer_p(y)) { mrb_int b, c; - b = mrb_fixnum(y); + b = mrb_integer(y); if (mrb_int_sub_overflow(a, b, &c)) { #ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b); @@ -1359,7 +1380,7 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y) MRB_API mrb_value mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) { - if (mrb_fixnum_p(x)) { + if (mrb_integer_p(x)) { return fixnum_minus(mrb, x, y); } #ifndef MRB_NO_FLOAT @@ -1395,7 +1416,7 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base) { char buf[MRB_INT_BIT+1]; char *b = buf + sizeof buf; - mrb_int val = mrb_fixnum(x); + mrb_int val = mrb_integer(x); mrb_value str; if (base < 2 || 36 < base) { @@ -1458,16 +1479,16 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) #endif #ifdef MRB_NO_FLOAT - x = mrb_fixnum(v1); + x = mrb_integer(v1); #else x = mrb_to_flo(mrb, v1); #endif switch (mrb_type(v2)) { case MRB_TT_INTEGER: #ifdef MRB_NO_FLOAT - y = mrb_fixnum(v2); + y = mrb_integer(v2); #else - y = (mrb_float)mrb_fixnum(v2); + y = (mrb_float)mrb_integer(v2); #endif break; #ifndef MRB_NO_FLOAT @@ -1500,7 +1521,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) * not comparable, it returns nil instead of raising an exception. */ static mrb_value -integral_cmp(mrb_state *mrb, mrb_value self) +num_cmp(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); mrb_int n; @@ -1517,7 +1538,7 @@ cmperr(mrb_state *mrb, mrb_value v1, mrb_value v2) } static mrb_value -integral_lt(mrb_state *mrb, mrb_value self) +num_lt(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); mrb_int n; @@ -1529,7 +1550,7 @@ integral_lt(mrb_state *mrb, mrb_value self) } static mrb_value -integral_le(mrb_state *mrb, mrb_value self) +num_le(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); mrb_int n; @@ -1541,7 +1562,7 @@ integral_le(mrb_state *mrb, mrb_value self) } static mrb_value -integral_gt(mrb_state *mrb, mrb_value self) +num_gt(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); mrb_int n; @@ -1553,7 +1574,7 @@ integral_gt(mrb_state *mrb, mrb_value self) } static mrb_value -integral_ge(mrb_state *mrb, mrb_value self) +num_ge(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); mrb_int n; @@ -1579,9 +1600,9 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2) return mrb_str_cmp(mrb, obj1, obj2); default: v = mrb_funcall_id(mrb, obj1, MRB_SYM(cmp), 1, obj2); - if (mrb_nil_p(v) || !mrb_fixnum_p(v)) + if (mrb_nil_p(v) || !mrb_integer_p(v)) return -2; - return mrb_fixnum(v); + return mrb_integer(v); } } @@ -1619,23 +1640,11 @@ flo_plus(mrb_state *mrb, mrb_value x) void mrb_init_numeric(mrb_state *mrb) { - struct RClass *numeric, *integer, *integral; + struct RClass *numeric, *integer; #ifndef MRB_NO_FLOAT struct RClass *fl; #endif - integral = mrb_define_module(mrb, "Integral"); - mrb_define_method(mrb, integral,"**", integral_pow, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, integral,"/", integral_div, MRB_ARGS_REQ(1)); /* 15.2.{8,9}.3.6 */ - mrb_define_method(mrb, integral,"quo", integral_div, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */ - mrb_define_method(mrb, integral,"div", integral_idiv, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, integral,"<=>", integral_cmp, MRB_ARGS_REQ(1)); /* 15.2.{8,9}.3.1 */ - mrb_define_method(mrb, integral,"<", integral_lt, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, integral,"<=", integral_le, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, integral,">", integral_gt, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, integral,">=", integral_ge, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, integral,"__coerce_step_counter", integral_coerce_step_counter, MRB_ARGS_REQ(2)); - /* Numeric Class */ numeric = mrb_define_class(mrb, "Numeric", mrb->object_class); /* 15.2.7 */ mrb_define_method(mrb, numeric, "finite?", num_finite_p, MRB_ARGS_NONE()); @@ -1645,13 +1654,23 @@ mrb_init_numeric(mrb_state *mrb) mrb->integer_class = integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */ MRB_SET_INSTANCE_TT(integer, MRB_TT_INTEGER); mrb_undef_class_method(mrb, integer, "new"); + mrb_define_method(mrb, integer, "**", int_pow, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, integer, "/", int_div, MRB_ARGS_REQ(1)); /* 15.2.8.3.6 */ + mrb_define_method(mrb, integer, "quo", int_quo, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */ + mrb_define_method(mrb, integer, "div", int_div, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, integer, "<=>", num_cmp, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */ + mrb_define_method(mrb, integer, "<", num_lt, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, integer, "<=", num_le, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, integer, ">", num_gt, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, integer, ">=", num_ge, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.24 */ mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE()); #ifndef MRB_NO_FLOAT - mrb_define_method(mrb, integer, "ceil", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.8 (x) */ - mrb_define_method(mrb, integer, "floor", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.10 (x) */ - mrb_define_method(mrb, integer, "round", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.12 (x) */ - mrb_define_method(mrb, integer, "truncate", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.15 (x) */ + mrb_define_method(mrb, integer, "ceil", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.14 */ + mrb_define_method(mrb, integer, "floor", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.17 */ + mrb_define_method(mrb, integer, "round", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.20 */ + mrb_define_method(mrb, integer, "truncate", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.26 */ #endif mrb_define_method(mrb, integer, "+", int_plus, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */ @@ -1672,6 +1691,7 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, integer, "to_s", int_to_s, MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */ mrb_define_method(mrb, integer, "inspect", int_to_s, MRB_ARGS_OPT(1)); mrb_define_method(mrb, integer, "divmod", int_divmod, MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */ + mrb_define_method(mrb, integer, "__coerce_step_counter", coerce_step_counter, MRB_ARGS_REQ(2)); /* Fixnum Class for compatibility */ mrb_define_const(mrb, mrb->object_class, "Fixnum", mrb_obj_value(integer)); @@ -1681,11 +1701,20 @@ mrb_init_numeric(mrb_state *mrb) mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric); /* 15.2.9 */ MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT); mrb_undef_class_method(mrb, fl, "new"); - mrb_define_method(mrb, fl, "+", flo_plus, MRB_ARGS_REQ(1)); /* 15.2.9.3.1 */ - mrb_define_method(mrb, fl, "-", flo_minus, MRB_ARGS_REQ(1)); /* 15.2.9.3.2 */ - mrb_define_method(mrb, fl, "*", flo_mul, MRB_ARGS_REQ(1)); /* 15.2.9.3.3 */ - mrb_define_method(mrb, fl, "%", flo_mod, MRB_ARGS_REQ(1)); /* 15.2.9.3.5 */ - mrb_define_method(mrb, fl, "==", flo_eq, MRB_ARGS_REQ(1)); /* 15.2.9.3.7 */ + mrb_define_method(mrb, fl, "**", flo_pow, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "/", flo_div, MRB_ARGS_REQ(1)); /* 15.2.9.3.6 */ + mrb_define_method(mrb, fl, "quo", flo_div, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */ + mrb_define_method(mrb, fl, "div", flo_idiv, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "+", flo_plus, MRB_ARGS_REQ(1)); /* 15.2.9.3.3 */ + mrb_define_method(mrb, fl, "-", flo_minus, MRB_ARGS_REQ(1)); /* 15.2.9.3.4 */ + mrb_define_method(mrb, fl, "*", flo_mul, MRB_ARGS_REQ(1)); /* 15.2.9.3.5 */ + mrb_define_method(mrb, fl, "%", flo_mod, MRB_ARGS_REQ(1)); /* 15.2.9.3.7 */ + mrb_define_method(mrb, fl, "<=>", num_cmp, MRB_ARGS_REQ(1)); /* 15.2.9.3.1 */ + mrb_define_method(mrb, fl, "<", num_lt, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "<=", num_le, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, ">", num_gt, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, ">=", num_ge, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "==", flo_eq, MRB_ARGS_REQ(1)); /* 15.2.9.3.2 */ mrb_define_method(mrb, fl, "~", flo_rev, MRB_ARGS_NONE()); mrb_define_method(mrb, fl, "&", flo_and, MRB_ARGS_REQ(1)); mrb_define_method(mrb, fl, "|", flo_or, MRB_ARGS_REQ(1)); @@ -1714,7 +1743,5 @@ mrb_init_numeric(mrb_state *mrb) #ifdef NAN mrb_define_const_id(mrb, fl, MRB_SYM(NAN), mrb_float_value(mrb, NAN)); #endif - - mrb_include_module(mrb, fl, integral); #endif } diff --git a/src/object.c b/src/object.c index a6357a6a8..95bd1c737 100644 --- a/src/object.c +++ b/src/object.c @@ -20,7 +20,7 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2) case MRB_TT_FALSE: case MRB_TT_INTEGER: - return (mrb_fixnum(v1) == mrb_fixnum(v2)); + return (mrb_integer(v1) == mrb_integer(v2)); case MRB_TT_SYMBOL: return (mrb_symbol(v1) == mrb_symbol(v2)); @@ -49,12 +49,12 @@ mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2) if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE; #ifndef MRB_NO_FLOAT /* value mixing with integer and float */ - if (mrb_fixnum_p(obj1)) { - if (mrb_float_p(obj2) && (mrb_float)mrb_fixnum(obj1) == mrb_float(obj2)) + if (mrb_integer_p(obj1)) { + if (mrb_float_p(obj2) && (mrb_float)mrb_integer(obj1) == mrb_float(obj2)) return TRUE; } else if (mrb_float_p(obj1)) { - if (mrb_fixnum_p(obj2) && mrb_float(obj1) == (mrb_float)mrb_fixnum(obj2)) + if (mrb_integer_p(obj2) && mrb_float(obj1) == (mrb_float)mrb_integer(obj2)) return TRUE; } #endif @@ -407,7 +407,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t) if (mrb_nil_p(x)) { ename = "nil"; } - else if (mrb_fixnum_p(x)) { + else if (mrb_integer_p(x)) { ename = "Fixnum"; } else if (mrb_symbol_p(x)) { @@ -509,7 +509,7 @@ MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val) { - if (!mrb_fixnum_p(val)) { + if (!mrb_integer_p(val)) { #ifndef MRB_NO_FLOAT if (mrb_float_p(val)) { return mrb_flo_to_fixnum(mrb, val); @@ -575,7 +575,7 @@ mrb_Float(mrb_state *mrb, mrb_value val) } switch (mrb_type(val)) { case MRB_TT_INTEGER: - return mrb_float_value(mrb, (mrb_float)mrb_fixnum(val)); + return mrb_float_value(mrb, (mrb_float)mrb_integer(val)); case MRB_TT_FLOAT: return val; diff --git a/src/range.c b/src/range.c index 0a76c9939..c06a8a00b 100644 --- a/src/range.c +++ b/src/range.c @@ -328,8 +328,8 @@ mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, con result = mrb_ary_new(mrb); for (i = 0; i < argc; ++i) { - if (mrb_fixnum_p(argv[i])) { - mrb_ary_push(mrb, result, func(mrb, obj, mrb_fixnum(argv[i]))); + if (mrb_integer_p(argv[i])) { + mrb_ary_push(mrb, result, func(mrb, obj, mrb_integer(argv[i]))); } else if (mrb_range_beg_len(mrb, argv[i], &beg, &len, olen, FALSE) == MRB_RANGE_OK) { mrb_int const end = olen < beg + len ? olen : beg + len; diff --git a/src/string.c b/src/string.c index e88ba2be5..a8072f7a7 100644 --- a/src/string.c +++ b/src/string.c @@ -1155,7 +1155,7 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen, else { switch (mrb_type(indx)) { case MRB_TT_INTEGER: - *beg = mrb_fixnum(indx); + *beg = mrb_integer(indx); *len = 1; return STR_CHAR_RANGE; @@ -1170,8 +1170,8 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen, default: indx = mrb_to_int(mrb, indx); - if (mrb_fixnum_p(indx)) { - *beg = mrb_fixnum(indx); + if (mrb_integer_p(indx)) { + *beg = mrb_integer(indx); *len = 1; return STR_CHAR_RANGE; } @@ -2498,8 +2498,8 @@ mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck) if (!badcheck) return 0.0; x = mrb_str_len_to_inum(mrb, p, pend-p, 0, badcheck); - if (mrb_fixnum_p(x)) - d = (double)mrb_fixnum(x); + if (mrb_integer_p(x)) + d = (double)mrb_integer(x); else /* if (mrb_float_p(x)) */ d = mrb_float(x); return d; @@ -2874,7 +2874,7 @@ mrb_str_byteslice(mrb_state *mrb, mrb_value str) } } else { - beg = mrb_fixnum(mrb_to_int(mrb, a1)); + beg = mrb_integer(mrb_to_int(mrb, a1)); len = 1; empty = FALSE; } diff --git a/src/vm.c b/src/vm.c index 15a38c0e4..540ba7681 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1115,12 +1115,12 @@ RETRY_TRY_BLOCK: } CASE(OP_LOADI, BB) { - SET_INT_VALUE(regs[a], b); + SET_FIXNUM_VALUE(regs[a], b); NEXT; } CASE(OP_LOADINEG, BB) { - SET_INT_VALUE(regs[a], -b); + SET_FIXNUM_VALUE(regs[a], -b); NEXT; } @@ -1134,12 +1134,12 @@ RETRY_TRY_BLOCK: CASE(OP_LOADI_6,B) goto L_LOADI; CASE(OP_LOADI_7, B) { L_LOADI: - SET_INT_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0); + SET_FIXNUM_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0); NEXT; } CASE(OP_LOADI16, BS) { - SET_INT_VALUE(regs[a], (mrb_int)(int16_t)b); + SET_FIXNUM_VALUE(regs[a], (mrb_int)(int16_t)b); NEXT; } @@ -1302,8 +1302,8 @@ RETRY_TRY_BLOCK: CHECKPOINT_RESTORE(RBREAK_TAG_JUMP) { struct RBreak *brk = (struct RBreak*)mrb->exc; mrb_value target = mrb_break_value_get(brk); - mrb_assert(mrb_fixnum_p(target)); - a = mrb_fixnum(target); + mrb_assert(mrb_integer_p(target)); + a = mrb_integer(target); mrb_assert(a >= 0 && a < irep->ilen); } CHECKPOINT_MAIN(RBREAK_TAG_JUMP) { @@ -2251,23 +2251,23 @@ RETRY_TRY_BLOCK: OP_MATH_CASE_STRING_##op_name(); \ default: \ c = 1; \ - mid = MRB_QSYM(op_name); \ + mid = MRB_QSYM(op_name); \ goto L_SEND_SYM; \ } \ NEXT; #define OP_MATH_CASE_FIXNUM(op_name) \ - case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER): \ + case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER): \ { \ - mrb_int x = mrb_fixnum(regs[a]), y = mrb_fixnum(regs[a+1]), z; \ + mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z; \ if (mrb_int_##op_name##_overflow(x, y, &z)) \ OP_MATH_OVERFLOW_INT(op_name, x, y, z); \ else \ - SET_INT_VALUE(regs[a], z); \ + SET_INT_VALUE(mrb,regs[a], z); \ } \ break #ifdef MRB_NO_FLOAT #define OP_MATH_CASE_FLOAT(op_name, t1, t2) (void)0 -#define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(regs[a], z) +#define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(mrb,regs[a], z) #else #define OP_MATH_CASE_FLOAT(op_name, t1, t2) \ case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2): \ @@ -2313,8 +2313,8 @@ RETRY_TRY_BLOCK: switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) { case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER): { - mrb_int x = mrb_fixnum(regs[a]); - mrb_int y = mrb_fixnum(regs[a+1]); + mrb_int x = mrb_integer(regs[a]); + mrb_int y = mrb_integer(regs[a+1]); if (y == 0) { @@ -2341,18 +2341,18 @@ RETRY_TRY_BLOCK: if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { div -= 1; } - SET_INT_VALUE(regs[a], div); + SET_INT_VALUE(mrb, regs[a], div); } } NEXT; #ifndef MRB_NO_FLOAT case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT): - x = (mrb_float)mrb_fixnum(regs[a]); + x = (mrb_float)mrb_integer(regs[a]); y = mrb_float(regs[a+1]); break; case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER): x = mrb_float(regs[a]); - y = (mrb_float)mrb_fixnum(regs[a+1]); + y = (mrb_float)mrb_integer(regs[a+1]); break; case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT): x = mrb_float(regs[a]); @@ -2385,7 +2385,7 @@ RETRY_TRY_BLOCK: OP_MATHI_CASE_FIXNUM(op_name); \ OP_MATHI_CASE_FLOAT(op_name); \ default: \ - SET_INT_VALUE(regs[a+1], b); \ + SET_INT_VALUE(mrb,regs[a+1], b); \ c = 1; \ mid = MRB_QSYM(op_name); \ goto L_SEND_SYM; \ @@ -2394,11 +2394,11 @@ RETRY_TRY_BLOCK: #define OP_MATHI_CASE_FIXNUM(op_name) \ case MRB_TT_INTEGER: \ { \ - mrb_int x = mrb_fixnum(regs[a]), y = (mrb_int)b, z; \ + mrb_int x = mrb_integer(regs[a]), y = (mrb_int)b, z; \ if (mrb_int_##op_name##_overflow(x, y, &z)) \ OP_MATH_OVERFLOW_INT(op_name, x, y, z); \ else \ - SET_INT_VALUE(regs[a], z); \ + SET_INT_VALUE(mrb,regs[a], z); \ } \ break #ifdef MRB_NO_FLOAT diff --git a/target/boxing.rb b/target/boxing.rb index 509c0d4b6..e3bf3425b 100644 --- a/target/boxing.rb +++ b/target/boxing.rb @@ -1,14 +1,10 @@ -MRuby::Build.new do |conf| - toolchain :gcc -end - -MRuby::Build.new('no_boxing') do |conf| +MRuby::Build.new('no-boxing') do |conf| toolchain :gcc + conf.gembox 'default' conf.compilers.each do |c| c.defines += %w(MRB_NO_BOXING) end - conf.gembox 'default' conf.enable_test end @@ -22,13 +18,13 @@ MRuby::Build.new('word_boxing') do |conf| conf.enable_test end -MRuby::Build.new('nan_boxing') do |conf| - toolchain :gcc +# MRuby::Build.new('nan_boxing') do |conf| +# toolchain :gcc - conf.gembox 'default' - conf.compilers.each do |c| - c.defines += %w(MRB_NAN_BOXING) - end - conf.enable_test -end +# conf.gembox 'default' +# conf.compilers.each do |c| +# c.defines += %w(MRB_NAN_BOXING) +# end +# conf.enable_test +# end diff --git a/test/t/array.rb b/test/t/array.rb index eec31d751..2982cab01 100644 --- a/test/t/array.rb +++ b/test/t/array.rb @@ -372,8 +372,7 @@ end assert('Array#hash', '15.2.12.5.35') do a = [ 1, 2, 3 ] - #assert_true(a.hash.is_a? Integer) - assert_true(a.hash.is_a? Integral) # mruby special + assert_true(a.hash.is_a? Integer) assert_equal([1,2].hash, [1,2].hash) end diff --git a/test/t/integer.rb b/test/t/integer.rb index 620ec94d3..5204eb91b 100644 --- a/test/t/integer.rb +++ b/test/t/integer.rb @@ -14,16 +14,6 @@ assert('Integer#+', '15.2.8.3.1') do assert_raise(TypeError){ 0+nil } assert_raise(TypeError){ 1+nil } - - c = Mrbtest::FIXNUM_MAX + 1 - d = Mrbtest::FIXNUM_MAX.__send__(:+, 1) - - skip unless Object.const_defined?(:Float) - e = Mrbtest::FIXNUM_MAX + 1.0 - assert_equal Float, c.class - assert_equal Float, d.class - assert_float e, c - assert_float e, d end assert('Integer#-', '15.2.8.3.2') do @@ -32,37 +22,17 @@ assert('Integer#-', '15.2.8.3.2') do assert_equal 1, a assert_equal 1.0, b if Object.const_defined?(:Float) - - c = Mrbtest::FIXNUM_MIN - 1 - d = Mrbtest::FIXNUM_MIN.__send__(:-, 1) - - skip unless Object.const_defined?(:Float) - e = Mrbtest::FIXNUM_MIN - 1.0 - assert_equal Float, c.class - assert_equal Float, d.class - assert_float e, c - assert_float e, d end assert('Integer#*', '15.2.8.3.3') do a = 1*1 - b = 1*1.0 if Object.const_defined?(:Float) - assert_equal 1, a - assert_equal 1.0, b if Object.const_defined?(:Float) - + if Object.const_defined?(:Float) + b = 1*1.0 + assert_equal 1.0, b + end assert_raise(TypeError){ 0*nil } assert_raise(TypeError){ 1*nil } - - c = Mrbtest::FIXNUM_MAX * 2 - d = Mrbtest::FIXNUM_MAX.__send__(:*, 2) - - skip unless Object.const_defined?(:Float) - e = Mrbtest::FIXNUM_MAX * 2.0 - assert_equal Float, c.class - assert_equal Float, d.class - assert_float e, c - assert_float e, d end assert('Integer#/', '15.2.8.3.4') do -- cgit v1.2.3 From 5134031e189e1cdde198e1c09f7b1d22bf2a1ce0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 27 Aug 2020 09:42:26 +0900 Subject: Use `mrb_int_value()` instead of `mrb_fixnum_value()`. Where fixnum overflow can happen. --- mrbgems/mruby-compiler/core/codegen.c | 4 ++-- mrbgems/mruby-io/src/file.c | 2 +- mrbgems/mruby-io/src/file_test.c | 4 ++-- mrbgems/mruby-random/src/random.c | 6 +++--- mrbgems/mruby-rational/src/rational.c | 6 +++--- mrbgems/mruby-socket/src/socket.c | 4 ++-- mrbgems/mruby-sprintf/src/sprintf.c | 4 ++-- mrbgems/mruby-test/driver.c | 2 +- mrbgems/mruby-time/src/time.c | 6 +++--- src/enum.c | 2 +- src/kernel.c | 4 ++-- src/numeric.c | 26 +++++++++++++------------- src/proc.c | 2 +- src/vm.c | 6 +++--- 14 files changed, 39 insertions(+), 39 deletions(-) (limited to 'src/vm.c') diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 2e39817ec..eb37cd701 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2465,7 +2465,7 @@ codegen(codegen_scope *s, node *tree, int val) int off; lit_int: - off = new_lit(s, mrb_fixnum_value(i)); + off = new_lit(s, mrb_int_value(s->mrb, i)); genop_2(s, OP_LOADL, cursp(), off); } } @@ -2528,7 +2528,7 @@ codegen(codegen_scope *s, node *tree, int val) genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i); } else { - int off = new_lit(s, mrb_fixnum_value(i)); + int off = new_lit(s, mrb_int_value(s->mrb, i)); genop_2(s, OP_LOADL, cursp(), off); } #ifndef MRB_NO_FLOAT diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c index a28360d81..d272cab7d 100644 --- a/mrbgems/mruby-io/src/file.c +++ b/mrbgems/mruby-io/src/file.c @@ -399,7 +399,7 @@ mrb_file_mtime(mrb_state *mrb, mrb_value self) if (mrb_fstat(fd, &st) == -1) return mrb_false_value(); - return mrb_fixnum_value((mrb_int)st.st_mtime); + return mrb_int_value(mrb, (mrb_int)st.st_mtime); } static mrb_value diff --git a/mrbgems/mruby-io/src/file_test.c b/mrbgems/mruby-io/src/file_test.c index 50402a681..f1762369a 100644 --- a/mrbgems/mruby-io/src/file_test.c +++ b/mrbgems/mruby-io/src/file_test.c @@ -304,7 +304,7 @@ mrb_filetest_s_size(mrb_state *mrb, mrb_value klass) if (mrb_stat(mrb, obj, &st) < 0) mrb_sys_fail(mrb, "mrb_stat"); - return mrb_fixnum_value(st.st_size); + return mrb_int_value(mrb, st.st_size); } /* @@ -326,7 +326,7 @@ mrb_filetest_s_size_p(mrb_state *mrb, mrb_value klass) if (st.st_size == 0) return mrb_nil_value(); - return mrb_fixnum_value(st.st_size); + return mrb_int_value(mrb, st.st_size); } void diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index 37b100084..0a5df6bd0 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -131,7 +131,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max) #endif } else { - value = mrb_fixnum_value(rand_uint32(t) % mrb_integer(max)); + value = mrb_int_value(mrb, rand_uint32(t) % mrb_integer(max)); } return value; @@ -224,7 +224,7 @@ random_m_srand(mrb_state *mrb, mrb_value self) } old_seed = rand_seed(t, seed); - return mrb_fixnum_value((mrb_int)old_seed); + return mrb_int_value(mrb, (mrb_int)old_seed); } /* @@ -378,7 +378,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary) } break; } - mrb_ary_push(mrb, result, mrb_fixnum_value(r)); + mrb_ary_push(mrb, result, mrb_int_value(mrb, r)); } for (i=0; inumerator); + return mrb_int_value(mrb, p->numerator); } static mrb_value rational_denominator(mrb_state *mrb, mrb_value self) { struct mrb_rational *p = rational_ptr(mrb, self); - return mrb_fixnum_value(p->denominator); + return mrb_int_value(mrb, p->denominator); } static mrb_value @@ -154,7 +154,7 @@ rational_to_i(mrb_state *mrb, mrb_value self) if (p->denominator == 0) { mrb_raise(mrb, mrb->eStandardError_class, "divided by 0"); } - return mrb_fixnum_value(p->numerator / p->denominator); + return mrb_int_value(mrb, p->numerator / p->denominator); } static mrb_value diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index d94573c96..0afbca521 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -842,7 +842,7 @@ mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self) n = send(sd, RSTRING_PTR(str), (int)RSTRING_LEN(str), 0); if (n == SOCKET_ERROR) mrb_sys_fail(mrb, "send"); - return mrb_fixnum_value(n); + return mrb_int_value(mrb, n); } #endif @@ -938,7 +938,7 @@ mrb_mruby_socket_gem_init(mrb_state* mrb) #define define_const(SYM) \ do { \ - mrb_define_const(mrb, constants, #SYM, mrb_fixnum_value(SYM)); \ + mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM)); \ } while (0) #include "const.cstub" diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 9ac8a512d..189b54b5c 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -938,10 +938,10 @@ retry: s = nbuf; if (v < 0) { dots = 1; - val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base); + val = mrb_fix2binstr(mrb, mrb_int_value(mrb, v), base); } else { - val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base); + val = mrb_fixnum_to_str(mrb, mrb_int_value(mrb, v), base); } strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-2); if (v < 0) { diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index b22888ec5..3bd52e175 100644 --- a/mrbgems/mruby-test/driver.c +++ b/mrbgems/mruby-test/driver.c @@ -254,7 +254,7 @@ mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src) res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$" #name)); \ if (mrb_integer_p(res_src)) { \ mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name)); \ - mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_integer(res_dst) + mrb_integer(res_src))); \ + mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_int_value(mrb_dst, mrb_integer(res_dst) + mrb_integer(res_src))); \ } \ } while (FALSE) \ diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 2af86b14e..f0347f54f 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -205,7 +205,7 @@ typedef mrb_float mrb_sec; #define mrb_sec_value(mrb, sec) mrb_float_value(mrb, sec) #else typedef mrb_int mrb_sec; -#define mrb_sec_value(mrb, sec) mrb_fixnum_value(sec) +#define mrb_sec_value(mrb, sec) mrb_int_value(mrb, sec) #endif #define MRB_TIME_T_UINT (~(time_t)0 > 0) @@ -585,7 +585,7 @@ mrb_time_minus(mrb_state *mrb, mrb_value self) mrb_int f; f = tm->sec - tm2->sec; if (tm->usec < tm2->usec) f--; - return mrb_fixnum_value(f); + return mrb_int_value(mrb, f); #endif } else { @@ -873,7 +873,7 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self) return mrb_float_value(mrb, (mrb_float)tm->sec); } #endif - return mrb_fixnum_value((mrb_int)tm->sec); + return mrb_int_value(mrb, (mrb_int)tm->sec); } /* 15.2.19.7.26 */ diff --git a/src/enum.c b/src/enum.c index d31370188..b95956715 100644 --- a/src/enum.c +++ b/src/enum.c @@ -18,7 +18,7 @@ enum_update_hash(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "iii", &hash, &index, &hv); hash ^= ((uint32_t)hv << (index % 16)); - return mrb_fixnum_value(hash); + return mrb_int_value(mrb, hash); } void diff --git a/src/kernel.c b/src/kernel.c index 699c681d7..a23eeea4e 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -96,7 +96,7 @@ mrb_equal_m(mrb_state *mrb, mrb_value self) mrb_value mrb_obj_id_m(mrb_state *mrb, mrb_value self) { - return mrb_fixnum_value(mrb_obj_id(self)); + return mrb_int_value(mrb, mrb_obj_id(self)); } static int @@ -489,7 +489,7 @@ mrb_obj_frozen(mrb_state *mrb, mrb_value self) static mrb_value mrb_obj_hash(mrb_state *mrb, mrb_value self) { - return mrb_fixnum_value(mrb_obj_id(self)); + return mrb_int_value(mrb, mrb_obj_id(self)); } /* 15.3.1.3.16 */ diff --git a/src/numeric.c b/src/numeric.c index 8fb144fae..a5fb87940 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -131,7 +131,7 @@ int_div(mrb_state *mrb, mrb_value xv) if (y == 0) { mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero"); } - return mrb_fixnum_value(mrb_integer(xv) / y); + return mrb_int_value(mrb, mrb_integer(xv) / y); } } @@ -988,7 +988,7 @@ int_divmod(mrb_state *mrb, mrb_value x) mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); } fixdivmod(mrb, mrb_integer(x), mrb_integer(y), &div, &mod); - return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); + return mrb_assoc_new(mrb, mrb_int_value(mrb, div), mrb_int_value(mrb, mod)); } #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); @@ -1065,12 +1065,12 @@ int_rev(mrb_state *mrb, mrb_value num) { mrb_int val = mrb_integer(num); - return mrb_fixnum_value(~val); + return mrb_int_value(mrb, ~val); } #ifdef MRB_NO_FLOAT #define bit_op(x,y,op1,op2) do {\ - return mrb_fixnum_value(mrb_integer(x) op2 mrb_integer(y));\ + return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y)));\ } while(0) #else static mrb_value flo_and(mrb_state *mrb, mrb_value x); @@ -1151,7 +1151,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) goto bit_overflow; #endif } - return mrb_fixnum_value(val << width); + return mrb_int_value(mrb, val << width); } else { if ((width > NUMERIC_SHIFT_WIDTH_MAX) || @@ -1162,7 +1162,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) goto bit_overflow; #endif } - return mrb_fixnum_value(val * ((mrb_int)1 << width)); + return mrb_int_value(mrb, (val * ((mrb_int)1 << width))); } #ifndef MRB_NO_FLOAT @@ -1178,7 +1178,7 @@ bit_overflow: } static mrb_value -rshift(mrb_int val, mrb_int width) +rshift(mrb_state *mrb, mrb_int val, mrb_int width) { if (width < 0) { /* mrb_int overflow */ return mrb_fixnum_value(0); @@ -1189,7 +1189,7 @@ rshift(mrb_int val, mrb_int width) } return mrb_fixnum_value(0); } - return mrb_fixnum_value(val >> width); + return mrb_int_value(mrb, val >> width); } /* 15.2.8.3.12 */ @@ -1212,7 +1212,7 @@ int_lshift(mrb_state *mrb, mrb_value x) val = mrb_integer(x); if (val == 0) return x; if (width < 0) { - return rshift(val, -width); + return rshift(mrb, val, -width); } return lshift(mrb, val, width); } @@ -1239,7 +1239,7 @@ int_rshift(mrb_state *mrb, mrb_value x) if (width < 0) { return lshift(mrb, val, -width); } - return rshift(val, width); + return rshift(mrb, val, width); } /* 15.2.8.3.23 */ @@ -1292,7 +1292,7 @@ mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x) mrb_raisef(mrb, E_RANGE_ERROR, "number (%v) too big for integer", x); } } - return mrb_fixnum_value(z); + return mrb_int_value(mrb, z); } #endif @@ -1312,7 +1312,7 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y) return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b); #endif } - return mrb_fixnum_value(c); + return mrb_int_value(mrb, c); } #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); @@ -1368,7 +1368,7 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y) return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b); #endif } - return mrb_fixnum_value(c); + return mrb_int_value(mrb, c); } #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); diff --git a/src/proc.c b/src/proc.c index de463df3e..d94044f72 100644 --- a/src/proc.c +++ b/src/proc.c @@ -242,7 +242,7 @@ mrb_proc_init_copy(mrb_state *mrb, mrb_value self) static mrb_value proc_arity(mrb_state *mrb, mrb_value self) { - return mrb_fixnum_value(mrb_proc_arity(mrb_proc_ptr(self))); + return mrb_int_value(mrb, mrb_proc_arity(mrb_proc_ptr(self))); } /* 15.3.1.2.6 */ diff --git a/src/vm.c b/src/vm.c index 540ba7681..52895bd28 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1082,16 +1082,16 @@ RETRY_TRY_BLOCK: CASE(OP_LOADL, BB) { switch (pool[b].tt) { /* number */ case IREP_TT_INT32: - regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i32); + regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i32); break; case IREP_TT_INT64: #if defined(MRB_INT64) - regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i64); + regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64); break; #else #if defined(MRB_64BIT) if (INT32_MIN <= pool[b].u.i64 && pool[b].u.i64 <= INT32_MAX) { - regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i64); + regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64); break; } #endif -- cgit v1.2.3 From 7e3d22f09569b920c8e3dd31d7a0d03e925a06cc Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 27 Aug 2020 10:23:50 +0900 Subject: Raname `mrb_exc_new_str_lit()` to `mrb_exc_new_lit()`. It uses `mrb_str_new_lit()` internally, but it doesn't need to express it in the name of the function (macro). --- include/mruby/error.h | 3 ++- mrbgems/mruby-compiler/core/parse.y | 4 ++-- mrbgems/mruby-compiler/core/y.tab.c | 4 ++-- src/error.c | 6 +++--- src/load.c | 2 +- src/vm.c | 18 +++++++++--------- 6 files changed, 19 insertions(+), 18 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby/error.h b/include/mruby/error.h index b607dd957..9ad115f4b 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -23,7 +23,8 @@ struct RException { MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg); MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str); -#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit)) +#define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit)) +#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str_lit(mrb, c, lit) MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv); MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc); MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb); diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index b2bf8263f..fe54afbbe 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -6575,7 +6575,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c) } else { if (mrb->exc == NULL) { - mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SYNTAX_ERROR, "syntax error")); + mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SYNTAX_ERROR, "syntax error")); } mrb_parser_free(p); return mrb_undef_value(); @@ -6585,7 +6585,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c) mrb_parser_free(p); if (proc == NULL) { if (mrb->exc == NULL) { - mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "codegen error")); + mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "codegen error")); } return mrb_undef_value(); } diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 28a06472f..18b102018 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -12467,7 +12467,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c) } else { if (mrb->exc == NULL) { - mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SYNTAX_ERROR, "syntax error")); + mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SYNTAX_ERROR, "syntax error")); } mrb_parser_free(p); return mrb_undef_value(); @@ -12477,7 +12477,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c) mrb_parser_free(p); if (proc == NULL) { if (mrb->exc == NULL) { - mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "codegen error")); + mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "codegen error")); } return mrb_undef_value(); } diff --git a/src/error.c b/src/error.c index b6a82f867..b19f0ea43 100644 --- a/src/error.c +++ b/src/error.c @@ -622,11 +622,11 @@ mrb_init_exception(mrb_state *mrb) script_error = mrb_define_class(mrb, "ScriptError", mrb->eException_class); /* 15.2.37 */ mrb_define_class(mrb, "SyntaxError", script_error); /* 15.2.38 */ stack_error = mrb_define_class(mrb, "SystemStackError", exception); - mrb->stack_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, stack_error, "stack level too deep")); + mrb->stack_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, stack_error, "stack level too deep")); nomem_error = mrb_define_class(mrb, "NoMemoryError", exception); - mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, nomem_error, "Out of memory")); + mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "Out of memory")); #ifdef MRB_GC_FIXED_ARENA - mrb->arena_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, nomem_error, "arena overflow error")); + mrb->arena_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "arena overflow error")); #endif } diff --git a/src/load.c b/src/load.c index b06b9ff37..2cc0f7557 100644 --- a/src/load.c +++ b/src/load.c @@ -625,7 +625,7 @@ void mrb_exc_set(mrb_state *mrb, mrb_value exc); static void irep_error(mrb_state *mrb) { - mrb_exc_set(mrb, mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error")); + mrb_exc_set(mrb, mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "irep load error")); } void mrb_codedump_all(mrb_state*, struct RProc*); diff --git a/src/vm.c b/src/vm.c index 52895bd28..7c14b40dd 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1016,7 +1016,7 @@ static mrb_bool check_target_class(mrb_state *mrb) { if (!mrb->c->ci->target_class) { - mrb_value exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR, "no target class or module"); + mrb_value exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR, "no target class or module"); mrb_exc_set(mrb, exc); return FALSE; } @@ -1096,7 +1096,7 @@ RETRY_TRY_BLOCK: } #endif { - mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "integer overflow"); + mrb_value exc = mrb_exc_new_lit(mrb, E_RUNTIME_ERROR, "integer overflow"); mrb_exc_set(mrb, exc); } goto L_RAISE; @@ -1357,7 +1357,7 @@ RETRY_TRY_BLOCK: { mrb_value exc; - exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR, + exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR, "class or module required for rescue clause"); mrb_exc_set(mrb, exc); goto L_RAISE; @@ -1585,21 +1585,21 @@ RETRY_TRY_BLOCK: mrb_assert(bidx < irep->nregs); if (mid == 0 || !target_class) { - mrb_value exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method"); + mrb_value exc = mrb_exc_new_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method"); mrb_exc_set(mrb, exc); goto L_RAISE; } if (target_class->tt == MRB_TT_MODULE) { target_class = ci->target_class; if (target_class->tt != MRB_TT_ICLASS) { - mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "superclass info lost [mruby limitations]"); + mrb_value exc = mrb_exc_new_lit(mrb, E_RUNTIME_ERROR, "superclass info lost [mruby limitations]"); mrb_exc_set(mrb, exc); goto L_RAISE; } } recv = regs[0]; if (!mrb_obj_is_kind_of(mrb, recv, target_class)) { - mrb_value exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR, + mrb_value exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR, "self has wrong type to call super in this context"); mrb_exc_set(mrb, exc); goto L_RAISE; @@ -1700,7 +1700,7 @@ RETRY_TRY_BLOCK: mrb_value exc; L_NOSUPER: - exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method"); + exc = mrb_exc_new_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method"); mrb_exc_set(mrb, exc); goto L_RAISE; } @@ -2066,7 +2066,7 @@ RETRY_TRY_BLOCK: goto CHECKPOINT_LABEL_MAKE(RBREAK_TAG_STOP); } if (c->prev->ci == c->prev->cibase) { - mrb_value exc = mrb_exc_new_str_lit(mrb, E_FIBER_ERROR, "double resume"); + mrb_value exc = mrb_exc_new_lit(mrb, E_FIBER_ERROR, "double resume"); mrb_exc_set(mrb, exc); goto L_RAISE; } @@ -2099,7 +2099,7 @@ RETRY_TRY_BLOCK: mrb_value exc; L_BREAK_ERROR: - exc = mrb_exc_new_str_lit(mrb, E_LOCALJUMP_ERROR, + exc = mrb_exc_new_lit(mrb, E_LOCALJUMP_ERROR, "break from proc-closure"); mrb_exc_set(mrb, exc); goto L_RAISE; -- cgit v1.2.3 From dd1ce5d53efa9a00cd9bdc7a7771bc6489da4469 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 29 Aug 2020 07:38:45 +0900 Subject: Silence warnings from implicit integer conversions. Caused from combination of `mrb_int`, `int` and `size_t`.. --- include/mruby.h | 8 ++++---- mrbgems/mruby-complex/src/complex.c | 2 +- mrbgems/mruby-print/src/print.c | 2 +- src/class.c | 4 ++-- src/vm.c | 12 ++++++------ 5 files changed, 14 insertions(+), 14 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby.h b/include/mruby.h index dda0fad68..e417dc840 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1040,8 +1040,8 @@ MRB_API mrb_value mrb_get_arg1(mrb_state *mrb); * @param ... Variadic values(not type safe!). * @return [mrb_value] mruby function value. */ -MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc, ...); -MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb_int argc, ...); +MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, int argc, ...); +MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, int argc, ...); /** * Call existing ruby functions. This is basically the type safe version of mrb_funcall. * @@ -1070,11 +1070,11 @@ MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb * @return [mrb_value] mrb_value mruby function value. * @see mrb_funcall */ -MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv); +MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name, int argc, const mrb_value *argv); /** * Call existing ruby functions with a block. */ -MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv, mrb_value block); +MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, int argc, const mrb_value *argv, mrb_value block); /** * Create a symbol from C string. But usually it's better to use MRB_SYM(sym) and MRB_QSYM(qsym). * diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 85735b704..6b7486ab0 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -122,7 +122,7 @@ complex_to_i(mrb_state *mrb, mrb_value self) if (p->imaginary != 0) { mrb_raisef(mrb, E_RANGE_ERROR, "can't convert %v into Float", self); } - return mrb_int_value(mrb, p->real); + return mrb_int_value(mrb, (mrb_int)p->real); } static mrb_value diff --git a/mrbgems/mruby-print/src/print.c b/mrbgems/mruby-print/src/print.c index df153d920..74d736397 100644 --- a/mrbgems/mruby-print/src/print.c +++ b/mrbgems/mruby-print/src/print.c @@ -22,7 +22,7 @@ printstr(mrb_state *mrb, const char *p, size_t len) #if defined(_WIN32) if (isatty(fileno(stdout))) { DWORD written; - int wlen = MultiByteToWideChar(CP_UTF8, 0, p, len, NULL, 0); + size_t wlen = MultiByteToWideChar(CP_UTF8, 0, p, len, NULL, 0); wchar_t* utf16 = (wchar_t*)mrb_malloc(mrb, (wlen+1) * sizeof(wchar_t)); if (MultiByteToWideChar(CP_UTF8, 0, p, len, utf16, wlen) > 0) { utf16[wlen] = 0; diff --git a/src/class.c b/src/class.c index ac5652e9a..668f9a6ce 100644 --- a/src/class.c +++ b/src/class.c @@ -50,7 +50,7 @@ mt_new(mrb_state *mrb) return t; } -static struct mt_elem *mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, int func_p, union mt_ptr ptr); +static struct mt_elem *mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, size_t func_p, union mt_ptr ptr); static void mt_rehash(mrb_state *mrb, mt_tbl *t) @@ -81,7 +81,7 @@ mt_rehash(mrb_state *mrb, mt_tbl *t) /* Set the value for the symbol in the method table. */ static struct mt_elem* -mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, int func_p, union mt_ptr ptr) +mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, size_t func_p, union mt_ptr ptr) { size_t hash, pos, start; struct mt_elem *dslot = NULL; diff --git a/src/vm.c b/src/vm.c index 7c14b40dd..5f781e8bb 100644 --- a/src/vm.c +++ b/src/vm.c @@ -333,7 +333,7 @@ static mrb_value mrb_run(mrb_state *mrb, const struct RProc* proc, mrb_value sel #endif MRB_API mrb_value -mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...) +mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) { mrb_value argv[MRB_FUNCALL_ARGC_MAX]; va_list ap; @@ -353,7 +353,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...) } MRB_API mrb_value -mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, ...) +mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, ...) { mrb_value argv[MRB_FUNCALL_ARGC_MAX]; va_list ap; @@ -396,7 +396,7 @@ ci_nregs(mrb_callinfo *ci) } MRB_API mrb_value -mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv, mrb_value blk) +mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, const mrb_value *argv, mrb_value blk) { mrb_value val; int ai = mrb_gc_arena_save(mrb); @@ -497,7 +497,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc } MRB_API mrb_value -mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv) +mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, const mrb_value *argv) { return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value()); } @@ -849,7 +849,7 @@ argnum_error(mrb_state *mrb, mrb_int num) { mrb_value exc; mrb_value str; - mrb_int argc = mrb->c->ci->argc; + int argc = mrb->c->ci->argc; if (argc < 0) { mrb_value args = mrb->c->stack[1]; @@ -1303,7 +1303,7 @@ RETRY_TRY_BLOCK: struct RBreak *brk = (struct RBreak*)mrb->exc; mrb_value target = mrb_break_value_get(brk); mrb_assert(mrb_integer_p(target)); - a = mrb_integer(target); + a = (uint32_t)mrb_integer(target); mrb_assert(a >= 0 && a < irep->ilen); } CHECKPOINT_MAIN(RBREAK_TAG_JUMP) { -- cgit v1.2.3 From c2444b84249a53175c5b720099f64ea580daf315 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 1 Sep 2020 18:01:49 +0900 Subject: Redefine `CHECKPOINT_*` macros. By definition `mrb_assert()` called only when `MRB_DEBUG` is defined too. But make I wanted to make clear that the local variable `current_checkpoint_tag` is only accessed when `MRB_DEBUG` is set by wrapping with `DEBUG_ONLY_EXPR()`. --- src/vm.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 5f781e8bb..68725798b 100644 --- a/src/vm.c +++ b/src/vm.c @@ -919,8 +919,7 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb #define CHECKPOINT_RESTORE(tag) \ do { \ - DEBUG_ONLY_EXPR(int current_checkpoint_tag); \ - DEBUG_ONLY_EXPR(current_checkpoint_tag = (tag)); \ + DEBUG_ONLY_EXPR(int current_checkpoint_tag = (tag)); \ if (FALSE) { \ CHECKPOINT_LABEL_MAKE(tag): \ DEBUG_ONLY_EXPR(current_checkpoint_tag = (tag)); \ @@ -929,12 +928,12 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb #define CHECKPOINT_MAIN(tag) \ } while (0); \ } \ - mrb_assert((tag) == current_checkpoint_tag); \ + DEBUG_ONLY_EXPR(mrb_assert((tag) == current_checkpoint_tag)); \ do { #define CHECKPOINT_END(tag) \ } while (0); \ - mrb_assert((tag) == current_checkpoint_tag); \ + DEBUG_ONLY_EXPR(mrb_assert((tag) == current_checkpoint_tag)); \ } while (0) #ifdef MRB_DEBUG -- cgit v1.2.3 From b01207ea94095bc855b8e6fef0dc65d7eae0d8ad Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 1 Sep 2020 18:05:47 +0900 Subject: Make the scope of `const struct RProc *dst` narrower. --- src/vm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 68725798b..bff13af10 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2008,7 +2008,6 @@ RETRY_TRY_BLOCK: else { int acc; mrb_value v; - const struct RProc *dst; ci = mrb->c->ci; v = regs[a]; @@ -2017,6 +2016,7 @@ RETRY_TRY_BLOCK: case OP_R_RETURN: /* Fall through to OP_R_NORMAL otherwise */ if (ci->acc >=0 && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) { + const struct RProc *dst; mrb_callinfo *cibase; cibase = mrb->c->cibase; dst = top_proc(mrb, proc); -- cgit v1.2.3 From 4cf1da9542d6554ec23de6324c5f2d5eebe138c9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 1 Sep 2020 18:06:49 +0900 Subject: Separate jump destination check in `OP_R_RETURN`. In the past code, the current `callinfo (ci)` was modified, thus it was possible to pop `ci` beyond the `cibase`, that could cause out of memory bound access for the code like the following: ```ruby def m2 lambda { Proc.new { return :return # return from the method } }.call.call :never_reached end p m2 ``` --- src/vm.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index bff13af10..b282af260 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2029,11 +2029,20 @@ RETRY_TRY_BLOCK: goto L_RAISE; } } + /* check jump destination */ while (cibase <= ci && ci->proc != dst) { - if (ci->acc < 0) { + if (ci->acc < 0) { /* jump cross C boudary */ localjump_error(mrb, LOCALJUMP_ERROR_RETURN); goto L_RAISE; } + ci--; + } + if (ci <= cibase) { /* no jump destination */ + localjump_error(mrb, LOCALJUMP_ERROR_RETURN); + goto L_RAISE; + } + ci = mrb->c->ci; + while (cibase <= ci && ci->proc != dst) { CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_BLOCK) { cibase = mrb->c->cibase; dst = top_proc(mrb, proc); @@ -2045,12 +2054,8 @@ RETRY_TRY_BLOCK: pc = ci->pc; ci = cipop(mrb); } - mrb->exc = NULL; /* clear break object */ proc = ci->proc; - if (ci <= cibase) { - localjump_error(mrb, LOCALJUMP_ERROR_RETURN); - goto L_RAISE; - } + mrb->exc = NULL; /* clear break object */ break; } /* fallthrough */ -- cgit v1.2.3 From d7986b449d508a3bbbddeea86968be50e7a95038 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Sep 2020 08:31:21 +0900 Subject: Change some `int` variables to `mrb_int`. To silence some warnings. This change cancels part of 7ef3604134. --- include/mruby.h | 12 ++++++------ src/vm.c | 30 +++++++++++++++--------------- 2 files changed, 21 insertions(+), 21 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby.h b/include/mruby.h index 72720496e..45f91b640 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -152,8 +152,8 @@ typedef struct { struct REnv *env; const mrb_code *pc; /* return address */ const mrb_code *err; /* error position */ - int argc; - int acc; + mrb_int argc; + mrb_int acc; struct RClass *target_class; } mrb_callinfo; @@ -1040,8 +1040,8 @@ MRB_API mrb_value mrb_get_arg1(mrb_state *mrb); * @param ... Variadic values(not type safe!). * @return [mrb_value] mruby function value. */ -MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, int argc, ...); -MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, int argc, ...); +MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc, ...); +MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb_int argc, ...); /** * Call existing ruby functions. This is basically the type safe version of mrb_funcall. * @@ -1070,11 +1070,11 @@ MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, int * @return [mrb_value] mrb_value mruby function value. * @see mrb_funcall */ -MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name, int argc, const mrb_value *argv); +MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv); /** * Call existing ruby functions with a block. */ -MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, int argc, const mrb_value *argv, mrb_value block); +MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv, mrb_value block); /** * Create a symbol from C string. But usually it's better to use MRB_SYM(sym) and MRB_QSYM(qsym). * diff --git a/src/vm.c b/src/vm.c index b282af260..8f136e394 100644 --- a/src/vm.c +++ b/src/vm.c @@ -333,7 +333,7 @@ static mrb_value mrb_run(mrb_state *mrb, const struct RProc* proc, mrb_value sel #endif MRB_API mrb_value -mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) +mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...) { mrb_value argv[MRB_FUNCALL_ARGC_MAX]; va_list ap; @@ -353,7 +353,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) } MRB_API mrb_value -mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, ...) +mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, ...) { mrb_value argv[MRB_FUNCALL_ARGC_MAX]; va_list ap; @@ -396,7 +396,7 @@ ci_nregs(mrb_callinfo *ci) } MRB_API mrb_value -mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, const mrb_value *argv, mrb_value blk) +mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv, mrb_value blk) { mrb_value val; int ai = mrb_gc_arena_save(mrb); @@ -497,7 +497,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, co } MRB_API mrb_value -mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, const mrb_value *argv) +mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv) { return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value()); } @@ -849,7 +849,7 @@ argnum_error(mrb_state *mrb, mrb_int num) { mrb_value exc; mrb_value str; - int argc = mrb->c->ci->argc; + mrb_int argc = mrb->c->ci->argc; if (argc < 0) { mrb_value args = mrb->c->stack[1]; @@ -1568,7 +1568,7 @@ RETRY_TRY_BLOCK: } CASE(OP_SUPER, BB) { - int argc = (b == CALL_MAXARGS) ? -1 : b; + mrb_int argc = (b == CALL_MAXARGS) ? -1 : b; int bidx = (argc < 0) ? a+2 : a+b+1; mrb_method_t m; struct RClass *cls; @@ -1747,22 +1747,22 @@ RETRY_TRY_BLOCK: } CASE(OP_ENTER, W) { - int m1 = MRB_ASPEC_REQ(a); - int o = MRB_ASPEC_OPT(a); - int r = MRB_ASPEC_REST(a); - int m2 = MRB_ASPEC_POST(a); - int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0; + mrb_int m1 = MRB_ASPEC_REQ(a); + mrb_int o = MRB_ASPEC_OPT(a); + mrb_int r = MRB_ASPEC_REST(a); + mrb_int m2 = MRB_ASPEC_POST(a); + mrb_int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0; /* unused int b = MRB_ASPEC_BLOCK(a); */ - int argc = mrb->c->ci->argc; + mrb_int argc = mrb->c->ci->argc; mrb_value *argv = regs+1; mrb_value * const argv0 = argv; - int const len = m1 + o + r + m2; - int const blk_pos = len + kd + 1; + mrb_int const len = m1 + o + r + m2; + mrb_int const blk_pos = len + kd + 1; mrb_value *blk = &argv[argc < 0 ? 1 : argc]; mrb_value kdict = mrb_nil_value(); - int kargs = kd; + mrb_int kargs = kd; /* arguments is passed with Array */ if (argc < 0) { -- cgit v1.2.3 From b81edb00354e7d13cd28c66f73a7643e37ebb482 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Sep 2020 17:45:49 +0900 Subject: Don't use `NEXT` within `switch` statement. On non-`gcc` compatible environment, `NEXT` is translated to `break`. --- src/vm.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 8f136e394..2e3024cd8 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2348,7 +2348,7 @@ RETRY_TRY_BLOCK: SET_INT_VALUE(mrb, regs[a], div); } } - NEXT; + goto L_DIV_OUT; #ifndef MRB_NO_FLOAT case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT): x = (mrb_float)mrb_integer(regs[a]); @@ -2380,6 +2380,7 @@ RETRY_TRY_BLOCK: } SET_FLOAT_VALUE(mrb, regs[a], f); #endif + L_DIV_OUT: NEXT; } -- cgit v1.2.3 From 9e842b3a75ced03488411e0e2a993dce40bd1e01 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Sep 2020 17:48:07 +0900 Subject: Extract `div` code in VM and make them shared by `div` methods. --- src/numeric.c | 66 ++++++++++++++++++++++++++++++++++++++++++++++++----------- src/vm.c | 43 ++++++-------------------------------- 2 files changed, 60 insertions(+), 49 deletions(-) (limited to 'src/vm.c') diff --git a/src/numeric.c b/src/numeric.c index 9fdaf2542..e1898301e 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -101,6 +101,41 @@ int_pow(mrb_state *mrb, mrb_value x) #endif } + +mrb_int +mrb_num_div_int(mrb_state *mrb, mrb_int x, mrb_int y) +{ + if (y == 0) { + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); + } + else if(x == MRB_INT_MIN && y == -1) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); + } + else { + mrb_int div, mod; + + if (y < 0) { + if (x < 0) + div = -x / -y; + else + div = - (x / -y); + } + else { + if (x < 0) + div = - (-x / y); + else + div = x / y; + } + mod = x - div * y; + if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { + div -= 1; + } + return div; + } + /* not reached */ + return 0; +} + /* 15.2.8.3.4 */ /* 15.2.9.3.4 */ /* @@ -111,7 +146,6 @@ int_pow(mrb_state *mrb, mrb_value x) * the class of num and on the magnitude of the * result. */ - static mrb_value int_div(mrb_state *mrb, mrb_value xv) { @@ -219,23 +253,31 @@ flo_idiv(mrb_state *mrb, mrb_value x) #endif } +mrb_float +mrb_num_div_flo(mrb_state *mrb, mrb_float x, mrb_float y) +{ + mrb_float f; + + if (y == 0) { + if (x > 0) f = INFINITY; + else if (x < 0) f = -INFINITY; + else /* if (x == 0) */ f = NAN; + } + else { + f = x / y; + } + return f; +} + static mrb_value flo_div(mrb_state *mrb, mrb_value xv) { mrb_float x, y; - mrb_get_args(mrb, "f", &y); x = mrb_float(xv); - if (y == 0) { - if (x < 0) - y = -INFINITY; - else if (x > 0) - y = INFINITY; - else /* if (x == 0) */ - y = NAN; - return mrb_float_value(mrb, y); - } - return mrb_float_value(mrb, x / y); + mrb_get_args(mrb, "f", &y); + x = mrb_num_div_flo(mrb, x, y); + return mrb_float_value(mrb, x); } static mrb_value diff --git a/src/vm.c b/src/vm.c index 2e3024cd8..7f79db32b 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2309,8 +2309,10 @@ RETRY_TRY_BLOCK: } CASE(OP_DIV, B) { + mrb_int mrb_num_div_int(mrb_state *mrb, mrb_int x, mrb_int y); #ifndef MRB_NO_FLOAT - double x, y, f; + mrb_float mrb_num_div_flo(mrb_state *mrb, mrb_float x, mrb_float y); + mrb_float x, y, f; #endif /* need to check if op is overridden */ @@ -2319,34 +2321,8 @@ RETRY_TRY_BLOCK: { mrb_int x = mrb_integer(regs[a]); mrb_int y = mrb_integer(regs[a+1]); - - - if (y == 0) { - mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); - } - else if(x == MRB_INT_MIN && y == -1) { - mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); - } - else { - mrb_int div, mod; - if (y < 0) { - if (x < 0) - div = -x / -y; - else - div = - (x / -y); - } - else { - if (x < 0) - div = - (-x / y); - else - div = x / y; - } - mod = x - div*y; - if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { - div -= 1; - } - SET_INT_VALUE(mrb, regs[a], div); - } + mrb_int div = mrb_num_div_int(mrb, x, y); + SET_INT_VALUE(mrb, regs[a], div); } goto L_DIV_OUT; #ifndef MRB_NO_FLOAT @@ -2370,14 +2346,7 @@ RETRY_TRY_BLOCK: } #ifndef MRB_NO_FLOAT - if (y == 0) { - if (x > 0) f = INFINITY; - else if (x < 0) f = -INFINITY; - else /* if (x == 0) */ f = NAN; - } - else { - f = x / y; - } + f = mrb_num_div_flo(mrb, x, y); SET_FLOAT_VALUE(mrb, regs[a], f); #endif L_DIV_OUT: -- cgit v1.2.3 From fe1ad37bfb90588a88dcfb009874b140036cbdb1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Sep 2020 19:22:30 +0900 Subject: Use `goto` to avoid problems with `DIRECT_THREADED`. You can now use `NEXT` within `switch` statement like 7c087eb. --- src/vm.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 7f79db32b..4e232c1fc 100644 --- a/src/vm.c +++ b/src/vm.c @@ -966,9 +966,9 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb #define INIT_DISPATCH for (;;) { insn = BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); switch (insn) { #define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops (); pc_save = pc; -#define NEXT break +#define NEXT goto L_END_DISPATCH #define JUMP NEXT -#define END_DISPATCH }} +#define END_DISPATCH L_END_DISPATCH:;}} #else @@ -2324,7 +2324,7 @@ RETRY_TRY_BLOCK: mrb_int div = mrb_num_div_int(mrb, x, y); SET_INT_VALUE(mrb, regs[a], div); } - goto L_DIV_OUT; + NEXT; #ifndef MRB_NO_FLOAT case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT): x = (mrb_float)mrb_integer(regs[a]); @@ -2349,7 +2349,6 @@ RETRY_TRY_BLOCK: f = mrb_num_div_flo(mrb, x, y); SET_FLOAT_VALUE(mrb, regs[a], f); #endif - L_DIV_OUT: NEXT; } -- cgit v1.2.3 From fc8885f2f4d0bb8e339c98d6e01e50279756aa5a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Sep 2020 20:57:41 +0900 Subject: Use `mrb_int` extensively instead of `int`. The mixture causes warnings on 64 bit Windows (VC). --- src/gc.c | 4 ++-- src/proc.c | 2 +- src/vm.c | 42 +++++++++++++++++++++--------------------- 3 files changed, 24 insertions(+), 24 deletions(-) (limited to 'src/vm.c') diff --git a/src/gc.c b/src/gc.c index 3fba68668..0f2c3bfab 100644 --- a/src/gc.c +++ b/src/gc.c @@ -591,11 +591,11 @@ add_gray_list(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) gc->gray_list = obj; } -static int +static mrb_int ci_nregs(mrb_callinfo *ci) { const struct RProc *p = ci->proc; - int n = 0; + mrb_int n = 0; if (!p) { if (ci->argc < 0) return 3; diff --git a/src/proc.c b/src/proc.c index d94044f72..b971b6520 100644 --- a/src/proc.c +++ b/src/proc.c @@ -62,7 +62,7 @@ env_new(mrb_state *mrb, mrb_int nlocals) { struct REnv *e; mrb_callinfo *ci = mrb->c->ci; - int bidx; + mrb_int bidx; e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, NULL); MRB_ENV_SET_LEN(e, nlocals); diff --git a/src/vm.c b/src/vm.c index 4e232c1fc..c627fd5dc 100644 --- a/src/vm.c +++ b/src/vm.c @@ -264,8 +264,8 @@ top_proc(mrb_state *mrb, const struct RProc *proc) #define CI_ACC_RESUMED -3 static inline mrb_callinfo* -cipush(mrb_state *mrb, const mrb_code *pc, int push_stacks, int acc, - struct RClass *target_class, const struct RProc *proc, mrb_sym mid, int argc) +cipush(mrb_state *mrb, const mrb_code *pc, mrb_int push_stacks, mrb_int acc, + struct RClass *target_class, const struct RProc *proc, mrb_sym mid, mrb_int argc) { struct mrb_context *c = mrb->c; mrb_callinfo *ci = c->ci; @@ -371,11 +371,11 @@ mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, ...) return mrb_funcall_argv(mrb, self, mid, argc, argv); } -static int +static mrb_int ci_nregs(mrb_callinfo *ci) { const struct RProc *p; - int n = 0; + mrb_int n = 0; if (!ci) return 3; p = ci->proc; @@ -425,7 +425,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc mrb_method_t m; struct RClass *c; mrb_callinfo *ci; - int n = ci_nregs(mrb->c->ci); + mrb_int n = ci_nregs(mrb->c->ci); ptrdiff_t voff = -1; if (!mrb->c->stack) { @@ -506,7 +506,7 @@ mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p) { mrb_callinfo *ci = mrb->c->ci; - int keep, nregs; + mrb_int keep, nregs; mrb->c->stack[0] = self; ci->proc = p; @@ -691,7 +691,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value mrb_sym mid = mrb->c->ci->mid; mrb_callinfo *ci; mrb_value val; - int n; + mrb_int n; if (mrb_nil_p(b)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given"); @@ -982,13 +982,13 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb #endif MRB_API mrb_value -mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, unsigned int stack_keep) +mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, unsigned mrb_int stack_keep) { const mrb_irep *irep = proc->body.irep; mrb_value result; struct mrb_context *c = mrb->c; ptrdiff_t cioff = c->ci - c->cibase; - unsigned int nregs = irep->nregs; + unsigned mrb_int nregs = irep->nregs; if (!c->stack) { stack_init(mrb); @@ -1411,8 +1411,8 @@ RETRY_TRY_BLOCK: mid = syms[b]; L_SENDB_SYM: { - int argc = (c == CALL_MAXARGS) ? -1 : c; - int bidx = (argc < 0) ? a+2 : a+c+1; + mrb_int argc = (c == CALL_MAXARGS) ? -1 : c; + mrb_int bidx = (argc < 0) ? a+2 : a+c+1; mrb_method_t m; struct RClass *cls; mrb_callinfo *ci = mrb->c->ci; @@ -1688,11 +1688,11 @@ RETRY_TRY_BLOCK: } CASE(OP_ARGARY, BS) { - int m1 = (b>>11)&0x3f; - int r = (b>>10)&0x1; - int m2 = (b>>5)&0x1f; - int kd = (b>>4)&0x1; - int lv = (b>>0)&0xf; + mrb_int m1 = (b>>11)&0x3f; + mrb_int r = (b>>10)&0x1; + mrb_int m2 = (b>>5)&0x1f; + mrb_int kd = (b>>4)&0x1; + mrb_int lv = (b>>0)&0xf; mrb_value *stack; if (mrb->c->ci->mid == 0 || mrb->c->ci->target_class == NULL) { @@ -1717,13 +1717,13 @@ RETRY_TRY_BLOCK: else { mrb_value *pp = NULL; struct RArray *rest; - int len = 0; + mrb_int len = 0; if (mrb_array_p(stack[m1])) { struct RArray *ary = mrb_ary_ptr(stack[m1]); pp = ARY_PTR(ary); - len = (int)ARY_LEN(ary); + len = ARY_LEN(ary); } regs[a] = mrb_ary_new_capa(mrb, m1+len+m2+kd); rest = mrb_ary_ptr(regs[a]); @@ -1814,7 +1814,7 @@ RETRY_TRY_BLOCK: /* no rest arguments */ if (argc-kargs < len) { - int mlen = m2; + mrb_int mlen = m2; if (argc < m1+m2) { mlen = m1 < argc ? argc - m1 : 0; } @@ -1844,7 +1844,7 @@ RETRY_TRY_BLOCK: pc += (argc - kargs - m1 - m2)*3; } else { - int rnum = 0; + mrb_int rnum = 0; if (argv0 != argv) { regs[blk_pos] = *blk; /* move block */ if (kd) regs[len + 1] = kdict; @@ -2006,7 +2006,7 @@ RETRY_TRY_BLOCK: pc = irep->iseq + bin_to_uint16(ch->target); } else { - int acc; + mrb_int acc; mrb_value v; ci = mrb->c->ci; -- cgit v1.2.3 From f9e781d83a5f50c70a238cbb2f06878c30490146 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Sep 2020 22:51:11 +0900 Subject: Avoid `unsigned int`; Use `mrb_int` instead. --- include/mruby.h | 4 ++-- mrbgems/mruby-compiler/core/parse.y | 2 +- mrbgems/mruby-compiler/core/y.tab.c | 2 +- src/vm.c | 6 +++--- 4 files changed, 7 insertions(+), 7 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby.h b/include/mruby.h index 45f91b640..5d862f37f 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1195,8 +1195,8 @@ 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, 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_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep); +MRB_API mrb_value mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_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)) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index fe54afbbe..3cd74971f 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -6555,7 +6555,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c) struct RClass *target = mrb->object_class; struct RProc *proc; mrb_value v; - unsigned int keep = 0; + mrb_int keep = 0; if (!p) { return mrb_undef_value(); diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 18b102018..b28509d81 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -12447,7 +12447,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c) struct RClass *target = mrb->object_class; struct RProc *proc; mrb_value v; - unsigned int keep = 0; + mrb_int keep = 0; if (!p) { return mrb_undef_value(); diff --git a/src/vm.c b/src/vm.c index c627fd5dc..331627caa 100644 --- a/src/vm.c +++ b/src/vm.c @@ -982,13 +982,13 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb #endif MRB_API mrb_value -mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, unsigned mrb_int stack_keep) +mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep) { const mrb_irep *irep = proc->body.irep; mrb_value result; struct mrb_context *c = mrb->c; ptrdiff_t cioff = c->ci - c->cibase; - unsigned mrb_int nregs = irep->nregs; + mrb_int nregs = irep->nregs; if (!c->stack) { stack_init(mrb); @@ -2851,7 +2851,7 @@ mrb_run(mrb_state *mrb, const struct RProc *proc, mrb_value self) } MRB_API mrb_value -mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, unsigned int stack_keep) +mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep) { mrb_value v; -- cgit v1.2.3 From a127ded486b173b1b805da2c39d656c77d98c6cc Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 4 Sep 2020 09:30:11 +0900 Subject: Fix warning from VC regarding implicit int conversion. --- mrbgems/mruby-eval/src/eval.c | 2 +- mrbgems/mruby-print/src/print.c | 8 ++++---- mrbgems/mruby-rational/src/rational.c | 2 +- src/vm.c | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) (limited to 'src/vm.c') diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c index 4271954e5..34a438060 100644 --- a/mrbgems/mruby-eval/src/eval.c +++ b/mrbgems/mruby-eval/src/eval.c @@ -20,7 +20,7 @@ create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value bi struct REnv *e; mrb_callinfo *ci; /* callinfo of eval caller */ struct RClass *target_class = NULL; - int bidx; + mrb_int bidx; if (!mrb_nil_p(binding)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "Binding of eval must be nil."); diff --git a/mrbgems/mruby-print/src/print.c b/mrbgems/mruby-print/src/print.c index 74d736397..665f2a926 100644 --- a/mrbgems/mruby-print/src/print.c +++ b/mrbgems/mruby-print/src/print.c @@ -17,22 +17,22 @@ #endif static void -printstr(mrb_state *mrb, const char *p, size_t len) +printstr(mrb_state *mrb, const char *p, mrb_int len) { #if defined(_WIN32) if (isatty(fileno(stdout))) { DWORD written; - size_t wlen = MultiByteToWideChar(CP_UTF8, 0, p, len, NULL, 0); + int wlen = MultiByteToWideChar(CP_UTF8, 0, p, (int)len, NULL, 0); wchar_t* utf16 = (wchar_t*)mrb_malloc(mrb, (wlen+1) * sizeof(wchar_t)); if (MultiByteToWideChar(CP_UTF8, 0, p, len, utf16, wlen) > 0) { utf16[wlen] = 0; WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), - utf16, wlen, &written, NULL); + utf16, (DWORD)wlen, &written, NULL); } mrb_free(mrb, utf16); } else #endif - fwrite(p, len, 1, stdout); + fwrite(p, (size_t)len, 1, stdout); fflush(stdout); } diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index 06f198c98..d5dd7adc4 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -115,7 +115,7 @@ rational_new_f(mrb_state *mrb, mrb_float f0) if (f < 0) { neg = 1; f = -f; } while (f != floor(f)) { n <<= 1; f *= 2; } - d = f; + d = (mrb_int)f; /* continued fraction and check denominator each step */ for (i = 0; i < 64; i++) { diff --git a/src/vm.c b/src/vm.c index 331627caa..a9c369d49 100644 --- a/src/vm.c +++ b/src/vm.c @@ -223,7 +223,7 @@ mrb_stack_extend(mrb_state *mrb, mrb_int room) } static inline struct REnv* -uvenv(mrb_state *mrb, int up) +uvenv(mrb_state *mrb, mrb_int up) { const struct RProc *proc = mrb->c->ci->proc; struct REnv *e; -- cgit v1.2.3 From 30424dfa7463370f2db200f49718d02d1b7a0c9b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 4 Sep 2020 20:56:43 +0900 Subject: Restore old function names for compatibility; fix #5070 Rename new functions: - `mrb_convert_type(mrb,val,type,tname,method)` => `mrb_type_convert(mrb,val,type,tname,method)` - `mrb_check_convert_type(mrb,val,type,tname,method)` => `mrb_type_convert_check(mrb,val,type,tname,method)` Old names are defined by macros (support `tname` drop and `char*` => `mrb_sym` conversion). --- include/mruby.h | 7 +++++-- mrbgems/mruby-kernel-ext/src/kernel.c | 4 ++-- mrbgems/mruby-print/src/print.c | 2 +- src/object.c | 6 +++--- src/string.c | 2 +- src/vm.c | 8 ++++---- 6 files changed, 16 insertions(+), 13 deletions(-) (limited to 'src/vm.c') diff --git a/include/mruby.h b/include/mruby.h index 5d862f37f..bc558b306 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1245,12 +1245,15 @@ MRB_API void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic* } while (0) MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*); -MRB_API mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method); +MRB_API mrb_value mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method); +#define mrb_convert_type(mrb, val, type, tname, method) mrb_type_convert(mrb, val, type, mrb_intern_lit(mrb, method)) +MRB_API mrb_value mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method); +#define mrb_check_convert_type(mrb, val, type, tname, method) mrb_type_convert_check(mrb, val, type, mrb_intern_lit(mrb, method)) + MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj); MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj); MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj); MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c); -MRB_API mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method); MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c); MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self); MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self); diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index e738287db..6e8679f47 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -151,7 +151,7 @@ mrb_f_string(mrb_state *mrb, mrb_value self) mrb_value arg = mrb_get_arg1(mrb); mrb_value tmp; - tmp = mrb_convert_type(mrb, arg, MRB_TT_STRING, MRB_SYM(to_s)); + tmp = mrb_type_convert(mrb, arg, MRB_TT_STRING, MRB_SYM(to_s)); return tmp; } @@ -170,7 +170,7 @@ mrb_f_array(mrb_state *mrb, mrb_value self) mrb_value arg = mrb_get_arg1(mrb); mrb_value tmp; - tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, MRB_SYM(to_a)); + tmp = mrb_type_convert_check(mrb, arg, MRB_TT_ARRAY, MRB_SYM(to_a)); if (mrb_nil_p(tmp)) { return mrb_ary_new_from_values(mrb, 1, &arg); } diff --git a/mrbgems/mruby-print/src/print.c b/mrbgems/mruby-print/src/print.c index 665f2a926..9dfdde346 100644 --- a/mrbgems/mruby-print/src/print.c +++ b/mrbgems/mruby-print/src/print.c @@ -24,7 +24,7 @@ printstr(mrb_state *mrb, const char *p, mrb_int len) DWORD written; int wlen = MultiByteToWideChar(CP_UTF8, 0, p, (int)len, NULL, 0); wchar_t* utf16 = (wchar_t*)mrb_malloc(mrb, (wlen+1) * sizeof(wchar_t)); - if (MultiByteToWideChar(CP_UTF8, 0, p, len, utf16, wlen) > 0) { + if (MultiByteToWideChar(CP_UTF8, 0, p, (int)len, utf16, wlen) > 0) { utf16[wlen] = 0; WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), utf16, (DWORD)wlen, &written, NULL); diff --git a/src/object.c b/src/object.c index 95bd1c737..e8bb52dca 100644 --- a/src/object.c +++ b/src/object.c @@ -369,7 +369,7 @@ convert_type(mrb_state *mrb, mrb_value val, const char *tname, mrb_sym method, m } MRB_API mrb_value -mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method) +mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method) { mrb_value v; const char *tname; @@ -385,7 +385,7 @@ mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym met } MRB_API mrb_value -mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method) +mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method) { mrb_value v; @@ -584,7 +584,7 @@ mrb_Float(mrb_state *mrb, mrb_value val) return mrb_float_value(mrb, mrb_str_to_dbl(mrb, val, TRUE)); default: - return mrb_convert_type(mrb, val, MRB_TT_FLOAT, MRB_SYM(to_f)); + return mrb_type_convert(mrb, val, MRB_TT_FLOAT, MRB_SYM(to_f)); } } #endif diff --git a/src/string.c b/src/string.c index a8072f7a7..706995354 100644 --- a/src/string.c +++ b/src/string.c @@ -1100,7 +1100,7 @@ mrb_str_to_str(mrb_state *mrb, mrb_value str) case MRB_TT_MODULE: return mrb_mod_to_s(mrb, str); default: - return mrb_convert_type(mrb, str, MRB_TT_STRING, MRB_SYM(to_s)); + return mrb_type_convert(mrb, str, MRB_TT_STRING, MRB_SYM(to_s)); } } diff --git a/src/vm.c b/src/vm.c index a9c369d49..9a0797912 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1423,8 +1423,8 @@ RETRY_TRY_BLOCK: recv = regs[a]; blk = regs[bidx]; if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) { - blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); - /* The stack might have been reallocated during mrb_convert_type(), + blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); + /* The stack might have been reallocated during mrb_type_convert(), see #3622 */ regs[bidx] = blk; } @@ -1605,9 +1605,9 @@ RETRY_TRY_BLOCK: } blk = regs[bidx]; if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) { - blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); + blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); /* The stack or ci stack might have been reallocated during - mrb_convert_type(), see #3622 and #3784 */ + mrb_type_convert(), see #3622 and #3784 */ regs[bidx] = blk; ci = mrb->c->ci; } -- cgit v1.2.3 From 356b719fef938f964eb7ba1aa93aadac9470fec1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 21 Sep 2020 23:38:50 +0900 Subject: Remove `DEBUG_ONLY_EXPR()` from `CHECKPOINT_*` macros; ref #5060 To allow C++ compilation. Fix suggested by @dearblue. --- src/vm.c | 10 ---------- 1 file changed, 10 deletions(-) (limited to 'src/vm.c') diff --git a/src/vm.c b/src/vm.c index 9a0797912..d1f4660be 100644 --- a/src/vm.c +++ b/src/vm.c @@ -919,29 +919,19 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb #define CHECKPOINT_RESTORE(tag) \ do { \ - DEBUG_ONLY_EXPR(int current_checkpoint_tag = (tag)); \ if (FALSE) { \ CHECKPOINT_LABEL_MAKE(tag): \ - DEBUG_ONLY_EXPR(current_checkpoint_tag = (tag)); \ do { #define CHECKPOINT_MAIN(tag) \ } while (0); \ } \ - DEBUG_ONLY_EXPR(mrb_assert((tag) == current_checkpoint_tag)); \ do { #define CHECKPOINT_END(tag) \ } while (0); \ - DEBUG_ONLY_EXPR(mrb_assert((tag) == current_checkpoint_tag)); \ } while (0) -#ifdef MRB_DEBUG -#define DEBUG_ONLY_EXPR(e) e -#else -#define DEBUG_ONLY_EXPR(e) ((void)0) -#endif - #define ERR_PC_SET(mrb) mrb->c->ci->err = pc0; #define ERR_PC_CLR(mrb) mrb->c->ci->err = 0; #ifdef MRB_ENABLE_DEBUG_HOOK -- cgit v1.2.3