From be86d8b45fa5d83f1d1caba9c4c0893c6281f720 Mon Sep 17 00:00:00 2001 From: Tomasz Dąbrowski Date: Tue, 10 Oct 2017 18:40:38 +0200 Subject: correctly handle *splat arguments in mrb_get_argc, also add mrb_vm_get_argc and mrb_get_argv Fixes #3825 --- include/mruby.h | 12 +++++++++++- src/class.c | 41 ++++++++++++++++++++++++++++++----------- 2 files changed, 41 insertions(+), 12 deletions(-) diff --git a/include/mruby.h b/include/mruby.h index 316707909..54ba0ead4 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -858,12 +858,22 @@ mrb_get_mid(mrb_state *mrb) /* get method symbol */ return mrb->c->ci->mid; } +/* returns -1 for *splat arguments */ static inline mrb_int -mrb_get_argc(mrb_state *mrb) /* get argc */ +mrb_vm_get_argc(mrb_state *mrb) /* get argc */ { return mrb->c->ci->argc; } +/** + * Retrieve number of arguments from mrb_state. + * + * Correctly handles *splat arguments. + */ +MRB_API mrb_int mrb_get_argc(mrb_state *mrb); + +MRB_API mrb_value* mrb_get_argv(mrb_state *mrb); + /* `strlen` for character string literals (use with caution or `strlen` instead) Adjacent string literals are concatenated in C/C++ in translation phase 6. If `lit` is not one, the compiler will report a syntax error: diff --git a/src/class.c b/src/class.c index f220106cd..506f540af 100644 --- a/src/class.c +++ b/src/class.c @@ -532,6 +532,34 @@ to_sym(mrb_state *mrb, mrb_value ss) } } +MRB_API mrb_int +mrb_get_argc(mrb_state *mrb) +{ + mrb_int argc = mrb_vm_get_argc(mrb); + if (argc < 0) { + struct RArray *a = mrb_ary_ptr(mrb->c->stack[1]); + + argc = ARY_LEN(a); + } + return argc; +} + +MRB_API mrb_value* +mrb_get_argv(mrb_state *mrb) +{ + mrb_int argc = mrb_vm_get_argc(mrb); + mrb_value *array_argv; + if (argc < 0) { + struct RArray *a = mrb_ary_ptr(mrb->c->stack[1]); + + array_argv = ARY_PTR(a); + } + else { + array_argv = NULL; + } + return array_argv; +} + /* retrieve arguments from mrb_state. @@ -569,23 +597,14 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) char c; mrb_int i = 0; va_list ap; - mrb_int argc = mrb->c->ci->argc; + mrb_int argc = mrb_get_argc(mrb); mrb_int arg_i = 0; - mrb_value *array_argv; + mrb_value *array_argv = mrb_get_argv(mrb); mrb_bool opt = FALSE; mrb_bool opt_skip = TRUE; mrb_bool given = TRUE; va_start(ap, format); - if (argc < 0) { - struct RArray *a = mrb_ary_ptr(mrb->c->stack[1]); - - argc = ARY_LEN(a); - array_argv = ARY_PTR(a); - } - else { - array_argv = NULL; - } #define ARGV \ (array_argv ? array_argv : (mrb->c->stack + 1)) -- cgit v1.2.3 From af3d5d6c8aab08d5366c1da57dba375a8b2bfa5c Mon Sep 17 00:00:00 2001 From: Carlo Prelz Date: Thu, 12 Oct 2017 09:54:02 +0200 Subject: Correct a small error in parse.y, which causes the reading of unassigned memory (triggers an error when address sanitizer is active) --- mrbgems/mruby-compiler/core/parse.y | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 82e4c7bdd..243d4ce4a 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -5723,7 +5723,7 @@ mrb_parser_set_filename(struct mrb_parser_state *p, const char *f) new_table = (mrb_sym*)parser_palloc(p, sizeof(mrb_sym) * p->filename_table_length); if (p->filename_table) { - memmove(new_table, p->filename_table, sizeof(mrb_sym) * p->filename_table_length); + memmove(new_table, p->filename_table, sizeof(mrb_sym) * p->current_filename_index); } p->filename_table = new_table; p->filename_table[p->filename_table_length - 1] = sym; -- cgit v1.2.3 From 44e2c971522f506659667d5d6dbd0275b3eea82c Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 15 Oct 2017 23:43:55 +0900 Subject: fix alias for Struct accessors --- mrbgems/mruby-struct/src/struct.c | 29 +++++++++++------------------ 1 file changed, 11 insertions(+), 18 deletions(-) diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index 67762a948..bfc3d39f9 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -12,6 +12,7 @@ #include #include #include +#include #define RSTRUCT_LEN(st) RARRAY_LEN(st) #define RSTRUCT_PTR(st) RARRAY_PTR(st) @@ -113,12 +114,11 @@ mrb_struct_members(mrb_state *mrb, mrb_value obj) return mrb_struct_s_members_m(mrb, mrb_obj_value(mrb_obj_class(mrb, obj))); } -static mrb_value struct_aref_sym(mrb_state *mrb, mrb_value obj, mrb_sym id); - static mrb_value mrb_struct_ref(mrb_state *mrb, mrb_value obj) { - return struct_aref_sym(mrb, obj, mrb->c->ci->mid); + mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0)); + return RSTRUCT_PTR(obj)[i]; } static mrb_sym @@ -140,24 +140,14 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id) return mid; } -static mrb_value mrb_struct_aset_sym(mrb_state *mrb, mrb_value s, mrb_sym id, mrb_value val); - 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_value val; - - const char *name; - mrb_int slen; - mrb_sym mid; - mrb_get_args(mrb, "o", &val); - - /* get base id */ - name = mrb_sym2name_len(mrb, mrb->c->ci->mid, &slen); - mid = mrb_intern(mrb, name, slen-1); /* omit last "=" */ - - return mrb_struct_aset_sym(mrb, obj, mid, val); + mrb_struct_modify(mrb, obj); + return RSTRUCT_PTR(obj)[i] = val; } static mrb_bool @@ -187,8 +177,11 @@ make_struct_define_accessors(mrb_state *mrb, mrb_value members, struct RClass *c const char *name = mrb_sym2name_len(mrb, id, NULL); if (is_local_id(mrb, name) || is_const_id(mrb, name)) { - mrb_define_method_id(mrb, c, id, mrb_struct_ref, MRB_ARGS_NONE()); - mrb_define_method_id(mrb, c, mrb_id_attrset(mrb, id), mrb_struct_set_m, MRB_ARGS_REQ(1)); + mrb_value at = mrb_fixnum_value(i); + struct RProc *aref = mrb_proc_new_cfunc_with_env(mrb, mrb_struct_ref, 1, &at); + struct RProc *aset = mrb_proc_new_cfunc_with_env(mrb, mrb_struct_set_m, 1, &at); + mrb_define_method_raw(mrb, c, id, aref); + mrb_define_method_raw(mrb, c, mrb_id_attrset(mrb, id), aset); mrb_gc_arena_restore(mrb, ai); } } -- cgit v1.2.3 From c3710dbb969948928f01c17a480e14a86b30fe5a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 16 Oct 2017 10:51:55 +0900 Subject: Fix a compile error on zero mrbgem case. --- tasks/mrbgems.rake | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/tasks/mrbgems.rake b/tasks/mrbgems.rake index 65368c303..1b964524c 100644 --- a/tasks/mrbgems.rake +++ b/tasks/mrbgems.rake @@ -34,11 +34,13 @@ MRuby.each_target do f.puts %Q[#include ] f.puts %Q[] f.write gem_func_decls + unless gem_final_calls.empty? f.puts %Q[] - f.puts %Q[static void] - f.puts %Q[mrb_final_mrbgems(mrb_state *mrb) {] - f.write gem_final_calls - f.puts %Q[}] + f.puts %Q[static void] + f.puts %Q[mrb_final_mrbgems(mrb_state *mrb) {] + f.write gem_final_calls + f.puts %Q[}] + end f.puts %Q[] f.puts %Q[void] f.puts %Q[mrb_init_mrbgems(mrb_state *mrb) {] -- cgit v1.2.3 From 1988bec23e4a0eb3dbabea19a02dd6cdb91158c3 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 16 Oct 2017 22:35:25 +0900 Subject: Need to adjust the stack length of the top-level environment; fix #3819 --- mrbgems/mruby-bin-mirb/tools/mirb/mirb.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c index fe311d830..891259a3f 100644 --- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c +++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c @@ -544,6 +544,13 @@ done: if (args.verbose) { mrb_codedump_all(mrb, proc); } + /* adjest stack length of toplevel environment */ + if (mrb->c->cibase->env) { + struct REnv *e = mrb->c->cibase->env; + if (MRB_ENV_STACK_LEN(e) < proc->body.irep->nlocals) { + MRB_SET_ENV_STACK_LEN(e, proc->body.irep->nlocals); + } + } /* pass a proc for evaluation */ /* evaluate the bytecode */ result = mrb_vm_run(mrb, -- cgit v1.2.3 From be2c1592ed93bded66c461f236107b4fec6dca7c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 16 Oct 2017 22:53:36 +0900 Subject: Check struct-array pointer before accessing; fix #3831 --- mrbgems/mruby-struct/src/struct.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index bfc3d39f9..f9127c6fb 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -118,7 +118,10 @@ static mrb_value mrb_struct_ref(mrb_state *mrb, mrb_value obj) { mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0)); - return RSTRUCT_PTR(obj)[i]; + mrb_value *ptr = RSTRUCT_PTR(obj); + + if (!ptr) return mrb_nil_value(); + return ptr[i]; } static mrb_sym @@ -144,10 +147,17 @@ 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_value *ptr = RSTRUCT_PTR(obj); mrb_value val; mrb_get_args(mrb, "o", &val); mrb_struct_modify(mrb, obj); - return RSTRUCT_PTR(obj)[i] = val; + if (i >= RSTRUCT_LEN(obj)) { + mrb_ary_set(mrb, obj, i, val); + } + else { + ptr[i] = val; + } + return val; } static mrb_bool -- cgit v1.2.3 From fb85855fa136d215533cac3714ddb99a61531fb8 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 07:43:35 +0900 Subject: Add more checks before accessing struct pointer; ref #3831 --- mrbgems/mruby-struct/src/struct.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index f9127c6fb..fed9e8105 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -147,11 +147,13 @@ 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_value *ptr = RSTRUCT_PTR(obj); + mrb_value *ptr; mrb_value val; + mrb_get_args(mrb, "o", &val); mrb_struct_modify(mrb, obj); - if (i >= RSTRUCT_LEN(obj)) { + ptr = RSTRUCT_PTR(obj); + if (ptr == NULL || i >= RSTRUCT_LEN(obj)) { mrb_ary_set(mrb, obj, i, val); } else { -- cgit v1.2.3 From e59ad60327e9ebf554782609c5da2c0440ec8413 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 08:17:31 +0900 Subject: `do/end` blocks to work with `rescue/ensure/else`; CRuby2.5 --- mrbgems/mruby-compiler/core/parse.y | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 243d4ce4a..bf9d3fe85 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -2577,7 +2577,7 @@ do_block : keyword_do_block local_nest(p); } opt_block_param - compstmt + bodystmt keyword_end { $$ = new_block(p,$3,$4); @@ -2667,7 +2667,7 @@ brace_block : '{' $$ = p->lineno; } opt_block_param - compstmt keyword_end + bodystmt keyword_end { $$ = new_block(p,$3,$4); SET_LINENO($$, $2); -- cgit v1.2.3 From c96def7c96c50f3b8e22e47ce31a6c5a37939dfd Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 08:45:06 +0900 Subject: Remove top-level constant lookup; CRuby2.5 --- src/variable.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/variable.c b/src/variable.c index 50fc70682..4fbe82dd9 100644 --- a/src/variable.c +++ b/src/variable.c @@ -663,17 +663,18 @@ mod_const_check(mrb_state *mrb, mrb_value mod) } static mrb_value -const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym) +const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym, mrb_bool top) { struct RClass *c = base; mrb_value v; iv_tbl *t; mrb_bool retry = FALSE; mrb_value name; + struct RClass *oclass = mrb->object_class; L_RETRY: while (c) { - if (c->iv) { + if (c->iv && (top || c != oclass || base == oclass)) { t = c->iv; if (iv_get(mrb, t, sym, &v)) return v; @@ -693,7 +694,7 @@ MRB_API mrb_value mrb_const_get(mrb_state *mrb, mrb_value mod, mrb_sym sym) { mod_const_check(mrb, mod); - return const_get(mrb, mrb_class_ptr(mod), sym); + return const_get(mrb, mrb_class_ptr(mod), sym, FALSE); } mrb_value @@ -729,7 +730,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) } irep = irep->outer; } - return const_get(mrb, c, sym); + return const_get(mrb, c, sym, TRUE); } MRB_API void -- cgit v1.2.3 From 1519616ecb12fe9a121b83c32f74109cf2a5b533 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 09:10:13 +0900 Subject: Add `Kernel#yield_self`; CRuby2.5 --- mrbgems/mruby-kernel-ext/mrblib/kernel.rb | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 mrbgems/mruby-kernel-ext/mrblib/kernel.rb diff --git a/mrbgems/mruby-kernel-ext/mrblib/kernel.rb b/mrbgems/mruby-kernel-ext/mrblib/kernel.rb new file mode 100644 index 000000000..25a4d4ed4 --- /dev/null +++ b/mrbgems/mruby-kernel-ext/mrblib/kernel.rb @@ -0,0 +1,13 @@ +module Kernel + # call-seq: + # obj.yield_self {|_obj|...} -> an_object + # + # Yields obj and returns the result. + # + # 'my string'.yield_self {|s|s.upcase} #=> "MY STRING" + # + def yield_self(&block) + return to_enum :yield_self unless block + block.call(self) + end +end -- cgit v1.2.3 From 332d8d2a1c12b098b28f8d06d2ed4bce42b09696 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 09:59:47 +0900 Subject: Add `String#delete_{prefix,suffix}`; CRuby2.5 --- mrbgems/mruby-string-ext/src/string.c | 120 +++++++++++++++++++++++++++++++- mrbgems/mruby-string-ext/test/string.rb | 15 ++++ 2 files changed, 133 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c index 63f181749..612fc5335 100644 --- a/mrbgems/mruby-string-ext/src/string.c +++ b/mrbgems/mruby-string-ext/src/string.c @@ -650,6 +650,118 @@ mrb_str_upto(mrb_state *mrb, mrb_value beg) return beg; } +/* + * call-seq: + * str.delete_prefix!(prefix) -> self or nil + * + * Deletes leading prefix from str, returning + * nil if no change was made. + * + * "hello".delete_prefix!("hel") #=> "lo" + * "hello".delete_prefix!("llo") #=> nil + */ +static mrb_value +mrb_str_del_prefix_bang(mrb_state *mrb, mrb_value self) +{ + mrb_int plen, slen; + char *ptr, *s; + struct RString *str = RSTRING(self); + + mrb_get_args(mrb, "s", &ptr, &plen); + slen = RSTR_LEN(str); + if (plen > slen) return mrb_nil_value(); + s = RSTR_PTR(str); + if (memcmp(s, ptr, plen) != 0) return mrb_nil_value(); + if (!MRB_FROZEN_P(str) && (RSTR_SHARED_P(str) || RSTR_FSHARED_P(str))) { + str->as.heap.ptr += plen; + } + else { + mrb_str_modify(mrb, str); + s = RSTR_PTR(str); + memmove(s, s+plen, slen-plen); + } + RSTR_SET_LEN(str, slen-plen); + return self; +} + +/* + * call-seq: + * str.delete_prefix(prefix) -> new_str + * + * Returns a copy of str with leading prefix deleted. + * + * "hello".delete_prefix("hel") #=> "lo" + * "hello".delete_prefix("llo") #=> "hello" + */ +static mrb_value +mrb_str_del_prefix(mrb_state *mrb, mrb_value self) +{ + mrb_int plen, slen; + char *ptr; + + mrb_get_args(mrb, "s", &ptr, &plen); + slen = RSTRING_LEN(self); + if (plen > slen) return mrb_str_dup(mrb, self); + if (memcmp(RSTRING_PTR(self), ptr, plen) != 0) + return mrb_str_dup(mrb, self); + return mrb_str_substr(mrb, self, plen, slen-plen); +} + +/* + * call-seq: + * str.delete_suffix!(suffix) -> self or nil + * + * Deletes trailing suffix from str, returning + * nil if no change was made. + * + * "hello".delete_suffix!("llo") #=> "he" + * "hello".delete_suffix!("hel") #=> nil + */ +static mrb_value +mrb_str_del_suffix_bang(mrb_state *mrb, mrb_value self) +{ + mrb_int plen, slen; + char *ptr, *s; + struct RString *str = RSTRING(self); + + mrb_get_args(mrb, "s", &ptr, &plen); + slen = RSTR_LEN(str); + if (plen > slen) return mrb_nil_value(); + s = RSTR_PTR(str); + if (memcmp(s+slen-plen, ptr, plen) != 0) return mrb_nil_value(); + if (!MRB_FROZEN_P(str) && (RSTR_SHARED_P(str) || RSTR_FSHARED_P(str))) { + /* no need to modify string */ + } + else { + mrb_str_modify(mrb, str); + } + RSTR_SET_LEN(str, slen-plen); + return self; +} + +/* + * call-seq: + * str.delete_suffix(suffix) -> new_str + * + * Returns a copy of str with leading suffix deleted. + * + * "hello".delete_suffix("hel") #=> "lo" + * "hello".delete_suffix("llo") #=> "hello" + */ +static mrb_value +mrb_str_del_suffix(mrb_state *mrb, mrb_value self) +{ + mrb_int plen, slen; + char *ptr; + + mrb_get_args(mrb, "s", &ptr, &plen); + slen = RSTRING_LEN(self); + if (plen > slen) return mrb_str_dup(mrb, self); + if (memcmp(RSTRING_PTR(self)+slen-plen, ptr, plen) != 0) + return mrb_str_dup(mrb, self); + return mrb_str_substr(mrb, self, 0, slen-plen); +} + void mrb_mruby_string_ext_gem_init(mrb_state* mrb) { @@ -673,8 +785,12 @@ mrb_mruby_string_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, s, "succ!", mrb_str_succ_bang, MRB_ARGS_NONE()); mrb_alias_method(mrb, s, mrb_intern_lit(mrb, "next"), mrb_intern_lit(mrb, "succ")); mrb_alias_method(mrb, s, mrb_intern_lit(mrb, "next!"), mrb_intern_lit(mrb, "succ!")); - mrb_define_method(mrb, s, "ord", mrb_str_ord, MRB_ARGS_NONE()); - mrb_define_method(mrb, s, "upto", mrb_str_upto, MRB_ARGS_ANY()); + mrb_define_method(mrb, s, "ord", mrb_str_ord, MRB_ARGS_NONE()); + mrb_define_method(mrb, s, "upto", mrb_str_upto, MRB_ARGS_ANY()); + mrb_define_method(mrb, s, "delete_prefix!", mrb_str_del_prefix_bang, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, s, "delete_prefix", mrb_str_del_prefix, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, s, "delete_suffix!", mrb_str_del_suffix_bang, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, s, "delete_suffix", mrb_str_del_suffix, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb->fixnum_class, "chr", mrb_fixnum_chr, MRB_ARGS_NONE()); } diff --git a/mrbgems/mruby-string-ext/test/string.rb b/mrbgems/mruby-string-ext/test/string.rb index 2a568c7d6..b6146fb90 100644 --- a/mrbgems/mruby-string-ext/test/string.rb +++ b/mrbgems/mruby-string-ext/test/string.rb @@ -1,3 +1,4 @@ +# coding: utf-8 ## # String(Ext) Test @@ -665,3 +666,17 @@ assert('String#each_codepoint(UTF-8)') do end assert_equal expect, cp end if UTF8STRING + +assert('String#delete_prefix') do + assert_equal "llo", "hello".delete_prefix("he") + assert_equal "hello", "hello".delete_prefix("llo") + assert_equal "llo", "hello".delete_prefix!("he") + assert_nil "hello".delete_prefix!("llo") +end + +assert('String#delete_suffix') do + assert_equal "he", "hello".delete_suffix("llo") + assert_equal "hello", "hello".delete_suffix("he") + assert_equal "he", "hello".delete_suffix!("llo") + assert_nil "hello".delete_suffix!("he") +end -- cgit v1.2.3 From 061d804a5906118e505c7fc3ae5051733e1c825e Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 10:53:44 +0900 Subject: Add `Numeric#{finite?,infinite?}`; CRuby2.4 --- src/numeric.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/numeric.c b/src/numeric.c index 8c7d448bd..b381bd206 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1254,6 +1254,20 @@ num_cmp(mrb_state *mrb, mrb_value self) } } +static mrb_value +num_finite_p(mrb_state *mrb, mrb_value self) +{ + mrb_get_args(mrb, ""); + return mrb_true_value(); +} + +static mrb_value +num_infinite_p(mrb_state *mrb, mrb_value self) +{ + mrb_get_args(mrb, ""); + return mrb_false_value(); +} + /* 15.2.9.3.1 */ /* * call-seq: @@ -1284,6 +1298,8 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, numeric, "/", num_div, MRB_ARGS_REQ(1)); /* 15.2.8.3.4 */ mrb_define_method(mrb, numeric, "quo", num_div, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */ mrb_define_method(mrb, numeric, "<=>", num_cmp, MRB_ARGS_REQ(1)); /* 15.2.9.3.6 */ + mrb_define_method(mrb, numeric, "finite?", num_finite_p, MRB_ARGS_NONE()); + mrb_define_method(mrb, numeric, "infinite?",num_infinite_p, MRB_ARGS_NONE()); /* Integer Class */ integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */ -- cgit v1.2.3 From 4e365156d130e94a9c7937f498b438183efca954 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 11:18:54 +0900 Subject: Add `Comparable#clamp`; CRuby2.4 --- mrbgems/default.gembox | 3 +++ mrbgems/mruby-compar-ext/mrbgem.rake | 5 +++++ mrbgems/mruby-compar-ext/mrblib/compar.rb | 31 +++++++++++++++++++++++++++++++ 3 files changed, 39 insertions(+) create mode 100644 mrbgems/mruby-compar-ext/mrbgem.rake create mode 100644 mrbgems/mruby-compar-ext/mrblib/compar.rb diff --git a/mrbgems/default.gembox b/mrbgems/default.gembox index 64f05de10..65584681d 100644 --- a/mrbgems/default.gembox +++ b/mrbgems/default.gembox @@ -14,6 +14,9 @@ MRuby::GemBox.new do |conf| # Use standard Struct class conf.gem :core => "mruby-struct" + # Use Comparable module extension + conf.gem :core => "mruby-compar-ext" + # Use Enumerable module extension conf.gem :core => "mruby-enum-ext" diff --git a/mrbgems/mruby-compar-ext/mrbgem.rake b/mrbgems/mruby-compar-ext/mrbgem.rake new file mode 100644 index 000000000..dcf584339 --- /dev/null +++ b/mrbgems/mruby-compar-ext/mrbgem.rake @@ -0,0 +1,5 @@ +MRuby::Gem::Specification.new('mruby-compar-ext') do |spec| + spec.license = 'MIT' + spec.author = 'mruby developers' + spec.summary = 'Enumerable module extension' +end diff --git a/mrbgems/mruby-compar-ext/mrblib/compar.rb b/mrbgems/mruby-compar-ext/mrblib/compar.rb new file mode 100644 index 000000000..d66f816ef --- /dev/null +++ b/mrbgems/mruby-compar-ext/mrblib/compar.rb @@ -0,0 +1,31 @@ +module Comparable + ## + # Returns min if obj <=> min is less + # than zero, max if obj <=> max is + # greater than zero and obj otherwise. + # + # 12.clamp(0, 100) #=> 12 + # 523.clamp(0, 100) #=> 100 + # -3.123.clamp(0, 100) #=> 0 + # + # 'd'.clamp('a', 'f') #=> 'd' + # 'z'.clamp('a', 'f') #=> 'f' + # + def clamp(min, max) + if (min <=> max) > 0 + raise ArgumentError, "min argument must be smaller than max argument" + end + c = self <=> min + if c == 0 + return self + elsif c < 0 + return min + end + c = self <=> max + if c > 0 + return max + else + return self + end + end +end -- cgit v1.2.3 From db8265f428175ac19885e14c5b1beb3e8f6c5af4 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 12:46:51 +0900 Subject: Add `Comparable#uniq`; CRuby2.4 --- mrbgems/mruby-enum-ext/mrblib/enum.rb | 16 ++++++++++++++++ mrbgems/mruby-enum-lazy/mrblib/lazy.rb | 15 +++++++++++++++ 2 files changed, 31 insertions(+) diff --git a/mrbgems/mruby-enum-ext/mrblib/enum.rb b/mrbgems/mruby-enum-ext/mrblib/enum.rb index 7741e515d..327b573d4 100644 --- a/mrbgems/mruby-enum-ext/mrblib/enum.rb +++ b/mrbgems/mruby-enum-ext/mrblib/enum.rb @@ -708,4 +708,20 @@ module Enumerable def nil.to_h {} end + + def uniq(&block) + hash = {} + if block + self.each do|*v| + v = v.__svalue + hash[block.call(v)] ||= v + end + else + self.each do|*v| + v = v.__svalue + hash[v] ||= v + end + end + hash.values + end end diff --git a/mrbgems/mruby-enum-lazy/mrblib/lazy.rb b/mrbgems/mruby-enum-lazy/mrblib/lazy.rb index c98681edf..9227abe8a 100644 --- a/mrbgems/mruby-enum-lazy/mrblib/lazy.rb +++ b/mrbgems/mruby-enum-lazy/mrblib/lazy.rb @@ -158,6 +158,21 @@ class Enumerator } end + def uniq(&block) + hash = {} + Lazy.new(self){|yielder, val| + if block + v = block.call(val) + else + v = val + end + unless hash.include?(v) + yielder << val + hash[v] = val + end + } + end + alias force to_a end end -- cgit v1.2.3 From 4122c320bb8a81ff66eae72e25eda8af6c768683 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 13:26:37 +0900 Subject: Add `{String,Symbol}#casecmp?`; CRuby2.4 --- mrbgems/mruby-string-ext/mrblib/string.rb | 15 ++++++++++++++- mrbgems/mruby-symbol-ext/mrblib/symbol.rb | 15 ++++++++++++++- 2 files changed, 28 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-string-ext/mrblib/string.rb b/mrbgems/mruby-string-ext/mrblib/string.rb index c3a7eb380..cb36d9a48 100644 --- a/mrbgems/mruby-string-ext/mrblib/string.rb +++ b/mrbgems/mruby-string-ext/mrblib/string.rb @@ -144,7 +144,20 @@ class String def casecmp(str) self.downcase <=> str.to_str.downcase rescue NoMethodError - raise TypeError, "no implicit conversion of #{str.class} into String" + nil + end + + ## + # call-seq: + # str.casecmp?(other) -> true, false, or nil + # + # Returns true if str and other_str are equal after case folding, + # false if they are not equal, and nil if other_str is not a string. + + def casecmp?(str) + c = self.casecmp(str) + return nil if c.nil? + return c == 0 end def partition(sep) diff --git a/mrbgems/mruby-symbol-ext/mrblib/symbol.rb b/mrbgems/mruby-symbol-ext/mrblib/symbol.rb index 1e3d24b80..28cce3156 100644 --- a/mrbgems/mruby-symbol-ext/mrblib/symbol.rb +++ b/mrbgems/mruby-symbol-ext/mrblib/symbol.rb @@ -48,10 +48,23 @@ class Symbol def casecmp(other) return nil unless other.kind_of?(Symbol) lhs = self.to_s; lhs.upcase! - rhs = other.to_s; rhs.upcase! + rhs = other.to_s.upcase lhs <=> rhs end + ## + # call-seq: + # sym.casecmp?(other) -> true, false, or nil + # + # Returns true if sym and other_sym are equal after case folding, + # false if they are not equal, and nil if other_sym is not a string. + + def casecmp?(sym) + c = self.casecmp(sym) + return nil if c.nil? + return c == 0 + end + # # call-seq: # sym.empty? -> true or false -- cgit v1.2.3 From b890528a183caf2f4161983a147508f65af8c700 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 15:22:45 +0900 Subject: Remove `mrb_vm_get_argc`; ref #3826 --- include/mruby.h | 7 ------- src/class.c | 5 +++-- 2 files changed, 3 insertions(+), 9 deletions(-) diff --git a/include/mruby.h b/include/mruby.h index 54ba0ead4..5c5a631e2 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -858,13 +858,6 @@ mrb_get_mid(mrb_state *mrb) /* get method symbol */ return mrb->c->ci->mid; } -/* returns -1 for *splat arguments */ -static inline mrb_int -mrb_vm_get_argc(mrb_state *mrb) /* get argc */ -{ - return mrb->c->ci->argc; -} - /** * Retrieve number of arguments from mrb_state. * diff --git a/src/class.c b/src/class.c index 506f540af..df645792c 100644 --- a/src/class.c +++ b/src/class.c @@ -535,7 +535,8 @@ to_sym(mrb_state *mrb, mrb_value ss) MRB_API mrb_int mrb_get_argc(mrb_state *mrb) { - mrb_int argc = mrb_vm_get_argc(mrb); + mrb_int argc = mrb->c->ci->argc; + if (argc < 0) { struct RArray *a = mrb_ary_ptr(mrb->c->stack[1]); @@ -547,7 +548,7 @@ mrb_get_argc(mrb_state *mrb) MRB_API mrb_value* mrb_get_argv(mrb_state *mrb) { - mrb_int argc = mrb_vm_get_argc(mrb); + mrb_int argc = mrb->c->ci->argc; mrb_value *array_argv; if (argc < 0) { struct RArray *a = mrb_ary_ptr(mrb->c->stack[1]); -- cgit v1.2.3 From 3c20c96f840d40950f4da61bd93f773a83767aef Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 17 Oct 2017 15:23:32 +0900 Subject: Use a new function: `mrb_get_argc()`; ref #3826 --- mrbgems/mruby-array-ext/src/array.c | 8 +++++--- mrbgems/mruby-string-ext/src/string.c | 7 ++++--- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c index e99599b09..169f968f9 100644 --- a/mrbgems/mruby-array-ext/src/array.c +++ b/mrbgems/mruby-array-ext/src/array.c @@ -176,14 +176,16 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self) { struct RArray *a = mrb_ary_ptr(self); mrb_int i, j, k, len, alen = ARY_LEN(a); - mrb_value index; mrb_value val; mrb_value *ptr; mrb_value ary; mrb_ary_modify(mrb, a); - if (mrb_get_args(mrb, "o|i", &index, &len) == 1) { + if (mrb_get_argc(mrb) == 1) { + mrb_value index; + + mrb_get_args(mrb, "o|i", &index, &len); switch (mrb_type(index)) { case MRB_TT_RANGE: if (mrb_range_beg_len(mrb, index, &i, &len, alen, TRUE) == 1) { @@ -201,7 +203,7 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self) } } - i = mrb_fixnum(index); + mrb_get_args(mrb, "ii", &i, &len); delete_pos_len: if (i < 0) i += alen; if (i < 0 || alen < i) return mrb_nil_value(); diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c index 612fc5335..5195a7ba0 100644 --- a/mrbgems/mruby-string-ext/src/string.c +++ b/mrbgems/mruby-string-ext/src/string.c @@ -44,12 +44,13 @@ mrb_str_byteslice(mrb_state *mrb, mrb_value str) { mrb_value a1; mrb_int len; - mrb_int argc; - argc = mrb_get_args(mrb, "o|i", &a1, &len); - if (argc == 2) { + if (mrb_get_argc(mrb) == 2) { + mrb_int pos; + mrb_get_args(mrb, "ii", &pos, &len); return mrb_str_substr(mrb, str, mrb_fixnum(a1), len); } + mrb_get_args(mrb, "o|i", &a1, &len); switch (mrb_type(a1)) { case MRB_TT_RANGE: { -- cgit v1.2.3 From 44f07045d186b2065103c4095b3a2fe56e3964b5 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 18 Oct 2017 10:05:39 +0900 Subject: Add `Hash#fetch_values`; CRuby2.3 --- mrbgems/mruby-hash-ext/mrblib/hash.rb | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/mrbgems/mruby-hash-ext/mrblib/hash.rb b/mrbgems/mruby-hash-ext/mrblib/hash.rb index 73d1fbe6d..7bf06a0ad 100644 --- a/mrbgems/mruby-hash-ext/mrblib/hash.rb +++ b/mrbgems/mruby-hash-ext/mrblib/hash.rb @@ -474,4 +474,25 @@ class Hash end self end + + ## + # call-seq: + # hsh.fetch_values(key, ...) -> array + # hsh.fetch_values(key, ...) { |key| block } -> array + # + # Returns an array containing the values associated with the given keys + # but also raises KeyError when one of keys can't be found. + # Also see Hash#values_at and Hash#fetch. + # + # h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" } + # + # h.fetch_values("cow", "cat") #=> ["bovine", "feline"] + # h.fetch_values("cow", "bird") # raises KeyError + # h.fetch_values("cow", "bird") { |k| k.upcase } #=> ["bovine", "BIRD"] + # + def fetch_values(*keys, &block) + keys.map do |k| + self.fetch(k, &block) + end + end end -- cgit v1.2.3 From b5dfbce76702e8ef6891d8a995de405a14b4ee03 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 18 Oct 2017 10:10:37 +0900 Subject: Add `Numeric#{positive?,negative?}`; CRuby2.3 --- mrbgems/mruby-numeric-ext/mrblib/numeric_ext.rb | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/mrbgems/mruby-numeric-ext/mrblib/numeric_ext.rb b/mrbgems/mruby-numeric-ext/mrblib/numeric_ext.rb index 0bf3c6ab6..f250538fe 100644 --- a/mrbgems/mruby-numeric-ext/mrblib/numeric_ext.rb +++ b/mrbgems/mruby-numeric-ext/mrblib/numeric_ext.rb @@ -14,4 +14,12 @@ module Integral self end end + + def positive? + self > 0 + end + + def negative? + self < 0 + end end -- cgit v1.2.3 From ce916b99b81fedf6561f8d3303320b31aa27d51c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 18 Oct 2017 10:18:43 +0900 Subject: Add `Hash#to_proc`; CRuby2.3 --- mrbgems/mruby-hash-ext/mrblib/hash.rb | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/mrbgems/mruby-hash-ext/mrblib/hash.rb b/mrbgems/mruby-hash-ext/mrblib/hash.rb index 7bf06a0ad..d1a709325 100644 --- a/mrbgems/mruby-hash-ext/mrblib/hash.rb +++ b/mrbgems/mruby-hash-ext/mrblib/hash.rb @@ -475,6 +475,10 @@ class Hash self end + def to_proc + ->x{self[x]} + end + ## # call-seq: # hsh.fetch_values(key, ...) -> array -- cgit v1.2.3 From fc930700b723ea2905deafb4dace5218b87d5a73 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 18 Oct 2017 10:21:54 +0900 Subject: Add `Kernel#itself`; CRuby2.2 --- mrbgems/mruby-kernel-ext/src/kernel.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index 7e6fa28bd..94a8ac320 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -222,6 +222,22 @@ mrb_f_hash(mrb_state *mrb, mrb_value self) return tmp; } +/* + * call-seq: + * obj.itself -> an_object + * + * Returns obj. + * + * string = 'my string' #=> "my string" + * string.itself.object_id == string.object_id #=> true + * + */ +static mrb_value +mrb_f_itself(mrb_state *mrb, mrb_value self) +{ + return self; +} + void mrb_mruby_kernel_ext_gem_init(mrb_state *mrb) { @@ -235,6 +251,7 @@ mrb_mruby_kernel_ext_gem_init(mrb_state *mrb) mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1)); mrb_define_module_function(mrb, krn, "Array", mrb_f_array, MRB_ARGS_REQ(1)); mrb_define_module_function(mrb, krn, "Hash", mrb_f_hash, MRB_ARGS_REQ(1)); + mrb_define_module_function(mrb, krn, "itself", mrb_f_itself, MRB_ARGS_NONE()); } void -- cgit v1.2.3 From f2394859e37a3db4ca4a44510a34436a7ade635a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 19 Oct 2017 10:39:06 +0900 Subject: Add `main.define_method` --- src/class.c | 17 +++++++++++++++++ src/state.c | 11 ----------- 2 files changed, 17 insertions(+), 11 deletions(-) diff --git a/src/class.c b/src/class.c index df645792c..a35eb4c92 100644 --- a/src/class.c +++ b/src/class.c @@ -1993,6 +1993,12 @@ mod_define_method(mrb_state *mrb, mrb_value self) return mrb_symbol_value(mid); } +static mrb_value +top_define_method(mrb_state *mrb, mrb_value self) +{ + return mod_define_method(mrb, mrb_obj_value(mrb->object_class)); +} + static void check_cv_name_str(mrb_state *mrb, mrb_value str) { @@ -2402,6 +2408,12 @@ mrb_value mrb_obj_instance_eval(mrb_state*, mrb_value); /* implementation of Module.nesting */ mrb_value mrb_mod_s_nesting(mrb_state*, mrb_value); +static mrb_value +inspect_main(mrb_state *mrb, mrb_value mod) +{ + return mrb_str_new_lit(mrb, "main"); +} + void mrb_init_class(mrb_state *mrb) { @@ -2498,4 +2510,9 @@ mrb_init_class(mrb_state *mrb) mrb_undef_method(mrb, cls, "append_features"); mrb_undef_method(mrb, cls, "extend_object"); + + mrb->top_self = (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mrb->object_class); + mrb_define_singleton_method(mrb, mrb->top_self, "inspect", inspect_main, MRB_ARGS_NONE()); + mrb_define_singleton_method(mrb, mrb->top_self, "to_s", inspect_main, MRB_ARGS_NONE()); + mrb_define_singleton_method(mrb, mrb->top_self, "define_method", top_define_method, MRB_ARGS_ARG(1,1)); } diff --git a/src/state.c b/src/state.c index 2f66e494b..596eecafa 100644 --- a/src/state.c +++ b/src/state.c @@ -18,12 +18,6 @@ void mrb_init_mrbgems(mrb_state*); void mrb_gc_init(mrb_state*, mrb_gc *gc); void mrb_gc_destroy(mrb_state*, mrb_gc *gc); -static mrb_value -inspect_main(mrb_state *mrb, mrb_value mod) -{ - return mrb_str_new_lit(mrb, "main"); -} - MRB_API mrb_state* mrb_open_core(mrb_allocf f, void *ud) { @@ -294,11 +288,6 @@ mrb_add_irep(mrb_state *mrb) MRB_API mrb_value mrb_top_self(mrb_state *mrb) { - if (!mrb->top_self) { - mrb->top_self = (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mrb->object_class); - mrb_define_singleton_method(mrb, mrb->top_self, "inspect", inspect_main, MRB_ARGS_NONE()); - mrb_define_singleton_method(mrb, mrb->top_self, "to_s", inspect_main, MRB_ARGS_NONE()); - } return mrb_obj_value(mrb->top_self); } -- cgit v1.2.3 From 0c3ee0ba66e4e7e0be6d652236240d74304f5e54 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 20 Oct 2017 10:29:39 +0900 Subject: Add `Array#{permutation,combination}. --- mrbgems/mruby-array-ext/mrbgem.rake | 1 + mrbgems/mruby-array-ext/mrblib/array.rb | 96 +++++++++++++++++++++++++++++++++ mrbgems/mruby-array-ext/test/array.rb | 28 ++++++++++ 3 files changed, 125 insertions(+) diff --git a/mrbgems/mruby-array-ext/mrbgem.rake b/mrbgems/mruby-array-ext/mrbgem.rake index 882caf1ab..58d4428d4 100644 --- a/mrbgems/mruby-array-ext/mrbgem.rake +++ b/mrbgems/mruby-array-ext/mrbgem.rake @@ -2,4 +2,5 @@ MRuby::Gem::Specification.new('mruby-array-ext') do |spec| spec.license = 'MIT' spec.author = 'mruby developers' spec.summary = 'Array class extension' + spec.add_test_dependency 'mruby-enumerator', core: 'mruby-enumerator' end diff --git a/mrbgems/mruby-array-ext/mrblib/array.rb b/mrbgems/mruby-array-ext/mrblib/array.rb index e28e5238d..b525d3006 100644 --- a/mrbgems/mruby-array-ext/mrblib/array.rb +++ b/mrbgems/mruby-array-ext/mrblib/array.rb @@ -808,4 +808,100 @@ class Array n end end + + ## + # call-seq: + # ary.permutation { |p| block } -> ary + # ary.permutation -> Enumerator + # ary.permutation(n) { |p| block } -> ary + # ary.permutation(n) -> Enumerator + # + # When invoked with a block, yield all permutations of length +n+ of the + # elements of the array, then return the array itself. + # + # If +n+ is not specified, yield all permutations of all elements. + # + # The implementation makes no guarantees about the order in which the + # permutations are yielded. + # + # If no block is given, an Enumerator is returned instead. + # + # Examples: + # + # a = [1, 2, 3] + # a.permutation.to_a #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] + # a.permutation(1).to_a #=> [[1],[2],[3]] + # a.permutation(2).to_a #=> [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]] + # a.permutation(3).to_a #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] + # a.permutation(0).to_a #=> [[]] # one permutation of length 0 + # a.permutation(4).to_a #=> [] # no permutations of length 4 + def permutation(n=self.size, &block) + size = self.size + return to_enum(:permutation, n) unless block + return if n > size + if n == 0 + yield [] + else + i = 0 + while i 0 + ary = self[0...i] + self[i+1..-1] + ary.permutation(n-1) do |c| + yield result + c + end + else + yield result + end + i += 1 + end + end + end + + ## + # call-seq: + # ary.combination(n) { |c| block } -> ary + # ary.combination(n) -> Enumerator + # + # When invoked with a block, yields all combinations of length +n+ of elements + # from the array and then returns the array itself. + # + # The implementation makes no guarantees about the order in which the + # combinations are yielded. + # + # If no block is given, an Enumerator is returned instead. + # + # Examples: + # + # a = [1, 2, 3, 4] + # a.combination(1).to_a #=> [[1],[2],[3],[4]] + # a.combination(2).to_a #=> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]] + # a.combination(3).to_a #=> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]] + # a.combination(4).to_a #=> [[1,2,3,4]] + # a.combination(0).to_a #=> [[]] # one combination of length 0 + # a.combination(5).to_a #=> [] # no combinations of length 5 + + def combination(n, &block) + size = self.size + return to_enum(:combination, n) unless block + return if n > size + if n == 0 + yield [] + elsif n == 1 + i = 0 + while i Date: Tue, 24 Oct 2017 21:31:37 +0900 Subject: Use win_bison instead of Cygwin's bison. Use YACC environment variable instead of global PATH --- appveyor.yml | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index c62b13573..a9464faca 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -5,6 +5,10 @@ os: Visual Studio 2015 clone_depth: 50 +cache: + - win_flex_bison-2.5.10.zip + + environment: matrix: # Visual Studio 2015 64bit @@ -18,10 +22,14 @@ environment: init: - call "%visualcpp%" %machine% - # For using bison.exe - - set PATH=%PATH%;C:\cygwin\bin; + + +install: + - if not exist win_flex_bison-2.5.10.zip appveyor DownloadFile "https://github.com/lexxmark/winflexbison/releases/download/v.2.5.10/win_flex_bison-2.5.10.zip" + - 7z x -y -owin_flex_bison win_flex_bison-2.5.10.zip > nul build_script: + - set YACC=.\win_flex_bison\win_bison.exe - set MRUBY_CONFIG=appveyor_config.rb - - ruby .\minirake test + - ruby .\minirake test all -- cgit v1.2.3 From 7a13e895090399cf185df071b600895f2ba3c313 Mon Sep 17 00:00:00 2001 From: bggd Date: Tue, 24 Oct 2017 21:37:36 +0900 Subject: Use Ruby 2.4 instead of AppVeyor's Default(Ruby 1.9) --- appveyor.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/appveyor.yml b/appveyor.yml index a9464faca..b4514ec27 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -22,6 +22,9 @@ environment: init: - call "%visualcpp%" %machine% + # For using Rubyinstaller's Ruby 2.4 64bit + - set PATH=C:\Ruby24-x64\bin;%PATH% + - ruby --version install: -- cgit v1.2.3 From 7f4cc0de51d87d0a3559fd03c27ec6d48b2ee655 Mon Sep 17 00:00:00 2001 From: bggd Date: Tue, 24 Oct 2017 21:39:05 +0900 Subject: Turn on method cache for AppVeyor CI --- appveyor_config.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/appveyor_config.rb b/appveyor_config.rb index 57e103307..2555b2f62 100644 --- a/appveyor_config.rb +++ b/appveyor_config.rb @@ -5,7 +5,7 @@ MRuby::Build.new('debug') do |conf| # include all core GEMs conf.gembox 'full-core' conf.compilers.each do |c| - c.defines += %w(MRB_GC_STRESS MRB_GC_FIXED_ARENA) + c.defines += %w(MRB_GC_STRESS MRB_GC_FIXED_ARENA MRB_METHOD_CACHE) end build_mrbc_exec -- cgit v1.2.3 From 71eeb86a9947f73d9dffa870fe329479b306d332 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 23 Oct 2017 08:59:57 +0900 Subject: Format codedump for OP_{LE,LT,GE,GT}. --- src/codedump.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/codedump.c b/src/codedump.c index 1133446a8..7a14a393a 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -314,22 +314,22 @@ codedump(mrb_state *mrb, mrb_irep *irep) GETARG_C(c)); break; case OP_LT: - printf("OP_LT\tR%d\t:%s\t%d\n", GETARG_A(c), + printf("OP_LT\t\tR%d\t:%s\t%d\n", GETARG_A(c), mrb_sym2name(mrb, irep->syms[GETARG_B(c)]), GETARG_C(c)); break; case OP_LE: - printf("OP_LE\tR%d\t:%s\t%d\n", GETARG_A(c), + printf("OP_LE\t\tR%d\t:%s\t%d\n", GETARG_A(c), mrb_sym2name(mrb, irep->syms[GETARG_B(c)]), GETARG_C(c)); break; case OP_GT: - printf("OP_GT\tR%d\t:%s\t%d\n", GETARG_A(c), + printf("OP_GT\t\tR%d\t:%s\t%d\n", GETARG_A(c), mrb_sym2name(mrb, irep->syms[GETARG_B(c)]), GETARG_C(c)); break; case OP_GE: - printf("OP_GE\tR%d\t:%s\t%d\n", GETARG_A(c), + printf("OP_GE\t\tR%d\t:%s\t%d\n", GETARG_A(c), mrb_sym2name(mrb, irep->syms[GETARG_B(c)]), GETARG_C(c)); break; -- cgit v1.2.3 From fda64be996eb0bedd442e26953d9c96c73b343e0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 23 Oct 2017 11:01:36 +0900 Subject: Flush stdout after every print from tests --- mrbgems/mruby-test/driver.c | 1 + 1 file changed, 1 insertion(+) diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index da0d721d4..df9df9e42 100644 --- a/mrbgems/mruby-test/driver.c +++ b/mrbgems/mruby-test/driver.c @@ -66,6 +66,7 @@ t_printstr(mrb_state *mrb, mrb_value obj) s = RSTRING_PTR(obj); len = RSTRING_LEN(obj); fwrite(s, len, 1, stdout); + fflush(stdout); } } -- cgit v1.2.3 From 0cf5a0ee37e7579238246f2471bfdd991c48f861 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 25 Oct 2017 01:13:10 +0900 Subject: Use alias to implement `attr` method --- mrblib/00class.rb | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/mrblib/00class.rb b/mrblib/00class.rb index 1a2d833c8..1811236f0 100644 --- a/mrblib/00class.rb +++ b/mrblib/00class.rb @@ -5,9 +5,10 @@ class Module attr_writer(*names) end # 15.2.2.4.11 - def attr(name) - attr_reader(name) - end + alias attr attr_reader + #def attr(name) + # attr_reader(name) + #end # 15.2.2.4.27 def include(*args) -- cgit v1.2.3 From 6c966a1f86705c4c8eb5fc8593401b748a9579f2 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 25 Oct 2017 01:14:04 +0900 Subject: Change the order of "expected" and "actual" in test --- mrbgems/mruby-enumerator/test/enumerator.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-enumerator/test/enumerator.rb b/mrbgems/mruby-enumerator/test/enumerator.rb index 763cd36e2..37169ade9 100644 --- a/mrbgems/mruby-enumerator/test/enumerator.rb +++ b/mrbgems/mruby-enumerator/test/enumerator.rb @@ -33,7 +33,7 @@ assert 'Enumerator.new' do a, b = b, a + b end end - assert_equal fib.take(10), [1,1,2,3,5,8,13,21,34,55] + assert_equal [1,1,2,3,5,8,13,21,34,55], fib.take(10) end assert 'Enumerator#initialize_copy' do -- cgit v1.2.3 From 07cf7b16f3d3bf76858804c939ab953648b128e2 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 25 Oct 2017 01:16:43 +0900 Subject: Add some peephole optimizations --- mrbgems/mruby-compiler/core/codegen.c | 31 ++++++++++++++++++++++++++----- 1 file changed, 26 insertions(+), 5 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 8f15a9b18..d9902a02e 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -278,6 +278,19 @@ genop_peep(codegen_scope *s, mrb_code i, int val) } } break; + case OP_GETUPVAR: + if (c0 == OP_SETUPVAR) { + if (GETARG_B(i) == GETARG_B(i0) && GETARG_C(i) == GETARG_C(i0)) { + if (GETARG_A(i) == GETARG_A(i0)) { + /* just skip OP_SETUPVAR */ + return 0; + } + else { + return genop(s, MKOP_AB(OP_MOVE, GETARG_A(i), GETARG_A(i0))); + } + } + } + break; case OP_EPOP: if (c0 == OP_EPOP) { s->iseq[s->pc-1] = MKOP_A(OP_EPOP, GETARG_A(i0)+GETARG_A(i)); @@ -335,6 +348,14 @@ genop_peep(codegen_scope *s, mrb_code i, int val) s->iseq[s->pc-1] = MKOP_ABC(OP_SUBI, GETARG_A(i), GETARG_B(i), -c); return 0; } + break; + case OP_ARYCAT: + case OP_ARYPUSH: + if (c0 == OP_MOVE && GETARG_A(i0) >= s->nlocals) { + s->iseq[s->pc-1] = MKOP_AB(c1, GETARG_A(i), GETARG_B(i0)); + return 0; + } + break; case OP_STRCAT: if (c0 == OP_STRING) { mrb_value v = s->irep->pool[GETARG_Bx(i0)]; @@ -822,10 +843,10 @@ gen_values(codegen_scope *s, node *t, int val, int extra) codegen(s, t->car, VAL); pop(); pop(); if (is_splat) { - genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1)); + genop_peep(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1), NOVAL); } else { - genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1)); + genop_peep(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1), NOVAL); } } t = t->cdr; @@ -834,10 +855,10 @@ gen_values(codegen_scope *s, node *t, int val, int extra) codegen(s, t->car, VAL); pop(); pop(); if (nint(t->car->car) == NODE_SPLAT) { - genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1)); + genop_peep(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1), NOVAL); } else { - genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1)); + genop_peep(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1), NOVAL); } t = t->cdr; } @@ -2140,7 +2161,7 @@ codegen(codegen_scope *s, node *tree, int val) while (up) { idx = lv_idx(up, nsym(tree)); if (idx > 0) { - genop(s, MKOP_ABC(OP_GETUPVAR, cursp(), idx, lv)); + genop_peep(s, MKOP_ABC(OP_GETUPVAR, cursp(), idx, lv), VAL); break; } lv++; -- cgit v1.2.3 From 14877469d12c4d77e863b320d2d6867f09c31d0a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 25 Oct 2017 01:33:07 +0900 Subject: Remove MRB_API from `mrb_env_unshare()` --- include/mruby/proc.h | 2 +- src/vm.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/mruby/proc.h b/include/mruby/proc.h index 9c2666289..5a6741610 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -30,7 +30,7 @@ struct REnv { #define MRB_ENV_UNSHARE_STACK(e) ((e)->cioff = -1) #define MRB_ENV_STACK_SHARED_P(e) ((e)->cioff >= 0) -MRB_API void mrb_env_unshare(mrb_state*, struct REnv*); +void mrb_env_unshare(mrb_state*, struct REnv*); struct RProc { MRB_OBJECT_HEADER; diff --git a/src/vm.c b/src/vm.c index b5a2aa7bf..196b2934e 100644 --- a/src/vm.c +++ b/src/vm.c @@ -273,7 +273,7 @@ cipush(mrb_state *mrb) return ci; } -MRB_API void +void mrb_env_unshare(mrb_state *mrb, struct REnv *e) { if (e == NULL) return; -- cgit v1.2.3 From 5405b47f41b73e8eff821ea8e68a052d8e156086 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 26 Oct 2017 01:11:04 +0900 Subject: Update test for `Kernel#local_variables` --- test/t/kernel.rb | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/test/t/kernel.rb b/test/t/kernel.rb index e9bd24dc3..4bd102392 100644 --- a/test/t/kernel.rb +++ b/test/t/kernel.rb @@ -52,11 +52,6 @@ assert('Kernel.lambda', '15.3.1.2.6') do assert_equal Proc, m.class end -# Not implemented at the moment -#assert('Kernel.local_variables', '15.3.1.2.7') do -# Kernel.local_variables.class == Array -#end - assert('Kernel.loop', '15.3.1.2.8') do i = 0 @@ -334,11 +329,6 @@ assert('Kernel#lambda', '15.3.1.3.27') do assert_equal Proc, m.class end -# Not implemented yet -#assert('Kernel#local_variables', '15.3.1.3.28') do -# local_variables.class == Array -#end - assert('Kernel#loop', '15.3.1.3.29') do i = 0 @@ -571,7 +561,8 @@ assert('Kernel.local_variables', '15.3.1.2.7') do assert_equal [:a, :b, :c, :vars], Proc.new { |a, b| c = 2 - Kernel.local_variables.sort + # Kernel#local_variables: 15.3.1.3.28 + local_variables.sort }.call(-1, -2) end -- cgit v1.2.3 From 4614b9d63204fec50684cfd755f462b82c022a02 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 27 Oct 2017 20:45:37 +0900 Subject: remove `inline` from replacement `memcpy`&`memset` --- include/mruby.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/mruby.h b/include/mruby.h index 5c5a631e2..1dc2eaf10 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1233,7 +1233,7 @@ MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...); /* use naive memcpy and memset instead */ #undef memcpy #undef memset -static inline void* +static void* mrbmemcpy(void *dst, const void *src, size_t n) { char *d = (char*)dst; @@ -1244,7 +1244,7 @@ mrbmemcpy(void *dst, const void *src, size_t n) } #define memcpy(a,b,c) mrbmemcpy(a,b,c) -static inline void* +static void* mrbmemset(void *s, int c, size_t n) { char *t = (char*)s; -- cgit v1.2.3 From 3f9d00ded3ce987927d975f7ce70637a973de1fc Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 28 Oct 2017 00:11:52 +0900 Subject: comment out `bench` build from standard `build_config.rb` --- build_config.rb | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/build_config.rb b/build_config.rb index 8293092ab..1429837be 100644 --- a/build_config.rb +++ b/build_config.rb @@ -124,17 +124,17 @@ MRuby::Build.new('test') do |conf| conf.gembox 'default' end -MRuby::Build.new('bench') do |conf| - # Gets set by the VS command prompts. - if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR'] - toolchain :visualcpp - else - toolchain :gcc - conf.cc.flags << '-O3' - end - - conf.gembox 'default' -end +#MRuby::Build.new('bench') do |conf| +# # Gets set by the VS command prompts. +# if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR'] +# toolchain :visualcpp +# else +# toolchain :gcc +# conf.cc.flags << '-O3' +# end +# +# conf.gembox 'default' +#end # Define cross build settings # MRuby::CrossBuild.new('32bit') do |conf| @@ -148,5 +148,4 @@ end # conf.gem 'examples/mrbgems/c_and_ruby_extension_example' # # conf.test_runner.command = 'env' -# # end -- cgit v1.2.3 From 93f5f225772c398be6e409da3d3ef0f07ffbe1cf Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 26 Oct 2017 01:13:57 +0900 Subject: Heavily refactored how lexical scope links are implemented; fix #3821 Instead of `irep` links, we added a `upper` link to `struct RProc`. To make a space for the `upper` link, we moved `target_class` reference. If a `Proc` does not have `env`, `target_class` is saved in an `union` shared with `env` (if a `Proc` has env, you can tell it by `MRB_PROC_ENV_P()). Otherwise `target_class` is referenced from `env->c`. We removed links in `env` as well. This change removes 2 members from `mrb_irep` struct, thus saving 2 words per method/proc/block. This also fixes potential memory leaks due to the circular references caused by a link from `mrb_irep`. --- include/mruby/irep.h | 3 - include/mruby/proc.h | 43 ++++-- mrbgems/mruby-bin-mirb/tools/mirb/mirb.c | 6 +- mrbgems/mruby-compiler/core/codegen.c | 3 + mrbgems/mruby-compiler/core/parse.y | 2 +- mrbgems/mruby-eval/src/eval.c | 48 +++--- mrbgems/mruby-fiber/src/fiber.c | 4 +- src/class.c | 7 +- src/gc.c | 13 +- src/kernel.c | 42 +++--- src/proc.c | 74 +++++---- src/state.c | 9 -- src/variable.c | 30 ++-- src/vm.c | 250 ++++++++++++++----------------- 14 files changed, 264 insertions(+), 270 deletions(-) diff --git a/include/mruby/irep.h b/include/mruby/irep.h index 91ca8b54d..efd226793 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -45,9 +45,6 @@ typedef struct mrb_irep { struct mrb_irep_debug_info* debug_info; int ilen, plen, slen, rlen, refcnt; - - struct mrb_irep *outer; /* Refers outer scope */ - struct RClass *target_class; } mrb_irep; #define MRB_ISEQ_NO_FREE 1 diff --git a/include/mruby/proc.h b/include/mruby/proc.h index 5a6741610..24c9b0c21 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -18,17 +18,19 @@ MRB_BEGIN_DECL struct REnv { MRB_OBJECT_HEADER; mrb_value *stack; - ptrdiff_t cioff; - union { - mrb_sym mid; - struct mrb_context *c; - } cxt; + struct mrb_context *cxt; + // struct RProc *proc; + mrb_sym mid; }; -#define MRB_SET_ENV_STACK_LEN(e,len) (e)->flags = (unsigned int)(len) -#define MRB_ENV_STACK_LEN(e) ((mrb_int)(e)->flags) -#define MRB_ENV_UNSHARE_STACK(e) ((e)->cioff = -1) -#define MRB_ENV_STACK_SHARED_P(e) ((e)->cioff >= 0) +/* flags (21bits): 1(shared flag):10(cioff/bidx):10(stack_len) */ +#define MRB_ENV_SET_STACK_LEN(e,len) (e)->flags = (((e)->flags & ~0x3ff)|(unsigned int)(len) & 0x3ff) +#define MRB_ENV_STACK_LEN(e) ((mrb_int)((e)->flags & 0x3ff)) +#define MRB_ENV_STACK_UNSHARED (1<<20) +#define MRB_ENV_UNSHARE_STACK(e) (e)->flags |= MRB_ENV_STACK_UNSHARED +#define MRB_ENV_STACK_SHARED_P(e) (((e)->flags & MRB_ENV_STACK_UNSHARED) == 0) +#define MRB_ENV_BIDX(e) (((e)->flags >> 10) & 0x3ff) +#define MRB_ENV_SET_BIDX(e,idx) (e)->flags = (((e)->flags & ~(0x3ff<<10))|((unsigned int)(idx) & 0x3ff)<<10) void mrb_env_unshare(mrb_state*, struct REnv*); @@ -38,8 +40,11 @@ struct RProc { mrb_irep *irep; mrb_func_t func; } body; - struct RClass *target_class; - struct REnv *env; + struct RProc *upper; + union { + struct RClass *target_class; + struct REnv *env; + } e; }; /* aspec access */ @@ -57,6 +62,22 @@ struct RProc { #define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0) #define MRB_PROC_ORPHAN 512 #define MRB_PROC_ORPHAN_P(p) (((p)->flags & MRB_PROC_ORPHAN) != 0) +#define MRB_PROC_ENVSET 1024 +#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0) +#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL) +#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class ) +#define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\ + if (MRB_PROC_ENV_P(p)) {\ + (p)->e.env->c = (tc);\ + mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)tc);\ + }\ + else {\ + (p)->e.target_class = (tc);\ + mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)tc);\ + }\ +} while (0) +#define MRB_PROC_SCOPE 2048 +#define MRB_PROC_SCOPE_P(p) (((p)->flags & MRB_PROC_SCOPE) != 0) #define mrb_proc_ptr(v) ((struct RProc*)(mrb_ptr(v))) diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c index 891259a3f..3feb4270a 100644 --- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c +++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c @@ -544,11 +544,11 @@ done: if (args.verbose) { mrb_codedump_all(mrb, proc); } - /* adjest stack length of toplevel environment */ + /* adjust stack length of toplevel environment */ if (mrb->c->cibase->env) { struct REnv *e = mrb->c->cibase->env; - if (MRB_ENV_STACK_LEN(e) < proc->body.irep->nlocals) { - MRB_SET_ENV_STACK_LEN(e, proc->body.irep->nlocals); + if (e && MRB_ENV_STACK_LEN(e) < proc->body.irep->nlocals) { + MRB_ENV_SET_STACK_LEN(e, proc->body.irep->nlocals); } } /* pass a proc for evaluation */ diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index d9902a02e..da29077b0 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -3034,6 +3034,9 @@ mrb_generate_code(mrb_state *mrb, parser_state *p) mrb_irep_decref(mrb, scope->irep); mrb_pool_close(scope->mpool); proc->c = NULL; + if (mrb->c->cibase && mrb->c->cibase->proc == proc->upper) { + proc->upper = NULL; + } mrb->jmp = prev_jmp; return proc; } diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index bf9d3fe85..e5017b677 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -5825,7 +5825,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c) c->keep_lv = TRUE; } } - proc->target_class = target; + MRB_PROC_SET_TARGET_CLASS(proc, target); if (mrb->c->ci) { mrb->c->ci->target_class = target; } diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c index 7fd4f1437..7061565ea 100644 --- a/mrbgems/mruby-eval/src/eval.c +++ b/mrbgems/mruby-eval/src/eval.c @@ -13,11 +13,9 @@ static struct mrb_irep * get_closure_irep(mrb_state *mrb, int level) { struct mrb_context *c = mrb->c; - struct REnv *e = c->ci[-1].proc->env; - struct RProc *proc; + struct RProc *proc = c->ci[-1].proc; if (level == 0) { - proc = c->ci[-1].proc; if (MRB_PROC_CFUNC_P(proc)) { return NULL; } @@ -25,16 +23,11 @@ get_closure_irep(mrb_state *mrb, int level) } while (--level) { - e = (struct REnv*)e->c; - if (!e) return NULL; + proc = proc->upper; + if (!proc) return NULL; } - if (!e) return NULL; - if (!MRB_ENV_STACK_SHARED_P(e)) return NULL; - c = e->cxt.c; - proc = c->cibase[e->cioff].proc; - - if (!proc || MRB_PROC_CFUNC_P(proc)) { + if (MRB_PROC_CFUNC_P(proc)) { return NULL; } return proc->body.irep; @@ -204,7 +197,9 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding, struct mrb_parser_state *p; struct RProc *proc; struct REnv *e; - struct mrb_context *c = mrb->c; + mrb_callinfo *ci = mrb->c->ci; + struct RClass *target_class = NULL; + int bidx; if (!mrb_nil_p(binding)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "Binding of eval must be nil."); @@ -251,19 +246,19 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding, mrbc_context_free(mrb, cxt); mrb_raise(mrb, E_SCRIPT_ERROR, "codegen error"); } - if (c->ci[-1].proc->target_class) { - proc->target_class = c->ci[-1].proc->target_class; - } - e = c->ci[-1].proc->env; - if (!e) e = c->ci[-1].env; - e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, (struct RClass*)e); - e->cxt.c = c; - e->cioff = c->ci - c->cibase; - e->stack = c->ci->stackent; - MRB_SET_ENV_STACK_LEN(e, c->ci->proc->body.irep->nlocals); - c->ci->target_class = proc->target_class; - c->ci->env = 0; - proc->env = e; + target_class = MRB_PROC_TARGET_CLASS(ci[-1].proc); + e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, + (struct RClass*)target_class); + e->mid = ci->mid; + e->stack = ci->stackent; + MRB_ENV_SET_STACK_LEN(e, ci->proc->body.irep->nlocals); + bidx = ci->argc; + if (ci->argc < 0) bidx = 2; + else bidx += 1; + MRB_ENV_SET_BIDX(e, bidx); + proc->e.env = e; + proc->flags |= MRB_PROC_ENVSET; + ci->target_class = target_class; patch_irep(mrb, proc->body.irep, 0, proc->body.irep); /* mrb_codedump_all(mrb, proc); */ @@ -322,8 +317,7 @@ f_instance_eval(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "s|zi", &s, &len, &file, &line); cv = mrb_singleton_class(mrb, self); proc = create_proc_from_string(mrb, s, len, mrb_nil_value(), file, line); - proc->target_class = mrb_class_ptr(cv); - mrb->c->ci->env = NULL; + MRB_PROC_SET_TARGET_CLASS(proc, mrb_class_ptr(cv)); mrb_assert(!MRB_PROC_CFUNC_P(proc)); return exec_irep(mrb, self, proc); } diff --git a/mrbgems/mruby-fiber/src/fiber.c b/mrbgems/mruby-fiber/src/fiber.c index 57fe9401c..be9033063 100644 --- a/mrbgems/mruby-fiber/src/fiber.c +++ b/mrbgems/mruby-fiber/src/fiber.c @@ -123,7 +123,7 @@ fiber_init(mrb_state *mrb, mrb_value self) /* adjust return callinfo */ ci = c->ci; - ci->target_class = p->target_class; + ci->target_class = MRB_PROC_TARGET_CLASS(p); ci->proc = p; mrb_field_write_barrier(mrb, (struct RBasic*)mrb_obj_ptr(self), (struct RBasic*)p); ci->pc = p->body.irep->iseq; @@ -213,7 +213,7 @@ fiber_switch(mrb_state *mrb, mrb_value self, mrb_int len, const mrb_value *a, mr *b++ = *a++; } c->cibase->argc = (int)len; - value = c->stack[0] = c->ci->proc->env->stack[0]; + value = c->stack[0] = MRB_PROC_ENV(c->ci->proc)->stack[0]; } else { value = fiber_result(mrb, a, len); diff --git a/src/class.c b/src/class.c index a35eb4c92..77a7050da 100644 --- a/src/class.c +++ b/src/class.c @@ -436,8 +436,11 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, struct RPro k = kh_put(mt, mrb, h, mid); kh_value(h, k) = p; if (p) { + p->flags |= MRB_PROC_SCOPE; p->c = NULL; - mrb_field_write_barrier(mrb, (struct RBasic *)c, (struct RBasic *)p); + mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p); + MRB_PROC_SET_TARGET_CLASS(p, c); + mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)c); } mc_clear_by_id(mrb, c, mid); } @@ -449,7 +452,7 @@ mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t f int ai = mrb_gc_arena_save(mrb); p = mrb_proc_new_cfunc(mrb, func); - p->target_class = c; + MRB_PROC_SET_TARGET_CLASS(p, c); mrb_define_method_raw(mrb, c, mid, p); mrb_gc_arena_restore(mrb, ai); } diff --git a/src/gc.c b/src/gc.c index 0f95d25ef..a3a638ae3 100644 --- a/src/gc.c +++ b/src/gc.c @@ -647,11 +647,8 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) { struct RProc *p = (struct RProc*)obj; - mrb_gc_mark(mrb, (struct RBasic*)p->env); - mrb_gc_mark(mrb, (struct RBasic*)p->target_class); - if (!MRB_PROC_CFUNC_P(p) && p->body.irep) { - mrb_gc_mark(mrb, (struct RBasic*)p->body.irep->target_class); - } + mrb_gc_mark(mrb, (struct RBasic*)p->upper); + mrb_gc_mark(mrb, (struct RBasic*)p->e.env); } break; @@ -660,12 +657,6 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) struct REnv *e = (struct REnv*)obj; mrb_int i, len; - if (MRB_ENV_STACK_SHARED_P(e)) { - if (e->cxt.c->fib) { - mrb_gc_mark(mrb, (struct RBasic*)e->cxt.c->fib); - } - break; - } len = MRB_ENV_STACK_LEN(e); for (i=0; istack[i]); diff --git a/src/kernel.c b/src/kernel.c index 33d142184..1e5a74222 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -136,6 +136,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self) { mrb_callinfo *ci = mrb->c->ci; mrb_value *bp; + struct RProc *p; bp = ci->stackent + 1; ci--; @@ -143,24 +144,20 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self) return mrb_false_value(); } /* block_given? called within block; check upper scope */ - if (ci->proc->env) { - struct REnv *e = ci->proc->env; - - while (e->c) { - e = (struct REnv*)e->c; - } + p = ci->proc; + while (p) { + if (MRB_PROC_SCOPE_P(p)) break; + p = p->upper; + } + /* top-level does not have block slot (always false) */ + if (p == NULL) return mrb_false_value(); + if (MRB_PROC_ENV_P(p)) { + struct REnv *e = MRB_PROC_ENV(p); /* top-level does not have block slot (always false) */ if (e->stack == mrb->c->stbase) return mrb_false_value(); - if (e->stack && e->cioff < 0) { - /* use saved block arg position */ - bp = &e->stack[-e->cioff]; - ci = 0; /* no callinfo available */ - } - else { - ci = e->cxt.c->cibase + e->cioff; - bp = ci[1].stackent + 1; - } + /* use saved block arg position */ + bp = &e->stack[MRB_ENV_BIDX(e)]; } if (ci && ci->argc > 0) { bp += ci->argc; @@ -655,7 +652,7 @@ method_entry_loop(mrb_state *mrb, struct RClass* klass, khash_t(st)* set) khint_t i; khash_t(mt) *h = klass->mt; - if (!h) return; + if (!h || kh_size(h) == 0) return; for (i=0;isuper; } - ary = mrb_ary_new(mrb); + ary = mrb_ary_new_capa(mrb, kh_size(set)); for (i=0;ibody.irep; - while (irep) { + while (proc) { + if (MRB_PROC_CFUNC_P(proc)) break; + irep = proc->body.irep; if (!irep->lv) break; for (i = 0; i + 1 < irep->nlocals; ++i) { if (irep->lv[i].name) { mrb_hash_set(mrb, vars, mrb_symbol_value(irep->lv[i].name), mrb_true_value()); } } - if (!proc->env) break; - irep = irep->outer; + if (!MRB_PROC_ENV_P(proc)) break; + proc = proc->upper; + // if (MRB_PROC_SCOPE_P(proc)) break; + if (!proc->c) break; } return mrb_hash_keys(mrb, vars); diff --git a/src/proc.c b/src/proc.c index a6214f1fc..69a9c0299 100644 --- a/src/proc.c +++ b/src/proc.c @@ -20,15 +20,19 @@ mrb_proc_new(mrb_state *mrb, mrb_irep *irep) mrb_callinfo *ci = mrb->c->ci; p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class); - p->target_class = 0; if (ci) { - if (ci->proc) - p->target_class = ci->proc->target_class; - if (!p->target_class) - p->target_class = ci->target_class; + struct RClass *tc = NULL; + + if (ci->proc) { + tc = MRB_PROC_TARGET_CLASS(ci->proc); + } + if (tc == NULL) { + tc = ci->target_class; + } + p->upper = ci->proc; + p->e.target_class = tc; } p->body.irep = irep; - p->env = 0; mrb_irep_incref(mrb, irep); return p; @@ -38,30 +42,45 @@ static struct REnv* env_new(mrb_state *mrb, mrb_int nlocals) { struct REnv *e; - - e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, (struct RClass*)mrb->c->ci->proc->env); - MRB_SET_ENV_STACK_LEN(e, nlocals); - e->cxt.c = mrb->c; - e->cioff = mrb->c->ci - mrb->c->cibase; + mrb_callinfo *ci = mrb->c->ci; + int bidx; + + e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, NULL); + MRB_ENV_SET_STACK_LEN(e, nlocals); + bidx = ci->argc; + if (ci->argc < 0) bidx = 2; + else bidx += 1; + MRB_ENV_SET_BIDX(e, bidx); + e->mid = ci->mid; e->stack = mrb->c->stack; + e->cxt = mrb->c; return e; } static void -closure_setup(mrb_state *mrb, struct RProc *p, int nlocals) +closure_setup(mrb_state *mrb, struct RProc *p) { + mrb_callinfo *ci = mrb->c->ci; + struct RProc *up = p->upper; struct REnv *e; - if (!mrb->c->ci->env) { - e = env_new(mrb, nlocals); - mrb->c->ci->env = e; + if (ci->env) { + e = ci->env; } else { - e = mrb->c->ci->env; + struct RClass *tc = MRB_PROC_TARGET_CLASS(up); + + e = env_new(mrb, up->body.irep->nlocals); + ci->env = e; + if (tc) { + e->c = tc; + mrb_field_write_barrier(mrb, (struct RBasic*)e, (struct RBasic*)tc); + } } - p->env = e; - mrb_field_write_barrier(mrb, (struct RBasic *)p, (struct RBasic *)p->env); + p->e.env = e; + p->flags |= MRB_PROC_ENVSET; + mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e); } struct RProc* @@ -69,7 +88,7 @@ mrb_closure_new(mrb_state *mrb, mrb_irep *irep) { struct RProc *p = mrb_proc_new(mrb, irep); - closure_setup(mrb, p, mrb->c->ci->proc->body.irep->nlocals); + closure_setup(mrb, p); return p; } @@ -81,7 +100,8 @@ mrb_proc_new_cfunc(mrb_state *mrb, mrb_func_t func) p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class); p->body.func = func; p->flags |= MRB_PROC_CFUNC; - p->env = 0; + p->upper = 0; + p->e.target_class = 0; return p; } @@ -93,8 +113,9 @@ mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const struct REnv *e; int i; - p->env = e = env_new(mrb, argc); - mrb_field_write_barrier(mrb, (struct RBasic *)p, (struct RBasic *)p->env); + p->e.env = e = env_new(mrb, argc); + p->flags |= MRB_PROC_ENVSET; + mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e); MRB_ENV_UNSHARE_STACK(e); e->stack = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * argc); if (argv) { @@ -120,7 +141,7 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx) { struct RProc *p = mrb->c->ci->proc; - struct REnv *e = p->env; + struct REnv *e = MRB_PROC_ENV(p); if (!MRB_PROC_CFUNC_P(p)) { mrb_raise(mrb, E_TYPE_ERROR, "Can't get cfunc env from non-cfunc proc."); @@ -148,8 +169,9 @@ mrb_proc_copy(struct RProc *a, struct RProc *b) if (!MRB_PROC_CFUNC_P(a) && a->body.irep) { a->body.irep->refcnt++; } - a->target_class = b->target_class; - a->env = b->env; + a->upper = b->upper; + a->e.env = b->e.env; + /* a->e.target_class = a->e.target_class; */ } static mrb_value @@ -169,7 +191,7 @@ mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class) proc = mrb_obj_value(p); mrb_funcall_with_block(mrb, proc, mrb_intern_lit(mrb, "initialize"), 0, NULL, proc); if (!MRB_PROC_STRICT_P(p) && - mrb->c->ci > mrb->c->cibase && p->env == mrb->c->ci[-1].env) { + mrb->c->ci > mrb->c->cibase && MRB_PROC_ENV(p) == mrb->c->ci[-1].env) { p->flags |= MRB_PROC_ORPHAN; } return proc; diff --git a/src/state.c b/src/state.c index 596eecafa..44bcc0656 100644 --- a/src/state.c +++ b/src/state.c @@ -139,11 +139,6 @@ mrb_irep_cutref(mrb_state *mrb, mrb_irep *irep) irep->reps[i] = NULL; if (tmp) mrb_irep_decref(mrb, tmp); } - if (irep->outer) { - tmp = irep->outer; - irep->outer = NULL; - if (tmp) mrb_irep_decref(mrb, tmp); - } } void @@ -170,10 +165,6 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep) if (irep->reps[i]) mrb_irep_decref(mrb, irep->reps[i]); } - if (irep->outer) { - if (irep->outer) - mrb_irep_decref(mrb, irep->outer); - } mrb_free(mrb, irep->reps); mrb_free(mrb, irep->lv); if (irep->own_filename) { diff --git a/src/variable.c b/src/variable.c index 4fbe82dd9..3e84c573c 100644 --- a/src/variable.c +++ b/src/variable.c @@ -632,18 +632,19 @@ mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym) mrb_value mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym) { - struct RClass *c = mrb->c->ci->proc->target_class; + struct RClass *c; + c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); if (!c) c = mrb->c->ci->target_class; - return mrb_mod_cv_get(mrb, c, sym); } void mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v) { - struct RClass *c = mrb->c->ci->proc->target_class; + struct RClass *c; + c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); if (!c) c = mrb->c->ci->target_class; mrb_mod_cv_set(mrb, c, sym, v); } @@ -700,11 +701,12 @@ mrb_const_get(mrb_state *mrb, mrb_value mod, mrb_sym sym) mrb_value mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) { - struct RClass *c = mrb->c->ci->proc->target_class; + struct RClass *c; struct RClass *c2; mrb_value v; - mrb_irep *irep; + struct RProc *proc; + c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); if (!c) c = mrb->c->ci->target_class; mrb_assert(c != NULL); @@ -720,15 +722,13 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) } if (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE) c = c2; mrb_assert(!MRB_PROC_CFUNC_P(mrb->c->ci->proc)); - irep = mrb->c->ci->proc->body.irep; - while (irep) { - if (irep->target_class) { - c2 = irep->target_class; - if (c2->iv && iv_get(mrb, c2->iv, sym, &v)) { - return v; - } + proc = mrb->c->ci->proc; + while (proc) { + c2 = MRB_PROC_TARGET_CLASS(proc); + if (c2 && c2->iv && iv_get(mrb, c2->iv, sym, &v)) { + return v; } - irep = irep->outer; + proc = proc->upper; } return const_get(mrb, c, sym, TRUE); } @@ -746,9 +746,7 @@ mrb_const_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v) void mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v) { - struct RClass *c = mrb->c->ci->proc->target_class; - - if (!c) c = mrb->c->ci->target_class; + struct RClass *c = mrb->c->ci->target_class; mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v); } diff --git a/src/vm.c b/src/vm.c index 196b2934e..734d225ba 100644 --- a/src/vm.c +++ b/src/vm.c @@ -151,6 +151,9 @@ envadjust(mrb_state *mrb, mrb_value *oldbase, mrb_value *newbase, size_t size) e->stack = newbase + off; } + else if (e && MRB_ENV_STACK_SHARED_P(e)) { + fprintf(stderr, "bingo! %p\n", e); + } ci->stackent = newbase + (ci->stackent - oldbase); ci++; } @@ -208,41 +211,33 @@ stack_extend(mrb_state *mrb, int room) } } +static int nenv = 0; + static inline struct REnv* uvenv(mrb_state *mrb, int up) { - struct REnv *e = mrb->c->ci->proc->env; + struct RProc *proc = mrb->c->ci->proc; + struct REnv *e; - while (up--) { + nenv++; + do { + e = MRB_PROC_ENV(proc); if (!e) return NULL; - e = (struct REnv*)e->c; - } + proc = proc->upper; + if (!proc) return NULL; + } while (up--); return e; } -static inline mrb_bool -is_strict(mrb_state *mrb, struct REnv *e) +static inline struct RProc* +top_proc(mrb_state *mrb, struct RProc *proc) { - ptrdiff_t cioff = e->cioff; - - if (MRB_ENV_STACK_SHARED_P(e) && e->cxt.c->cibase[cioff].proc && - MRB_PROC_STRICT_P(e->cxt.c->cibase[cioff].proc)) { - return TRUE; + while (proc->upper) { + if (MRB_PROC_SCOPE_P(proc) || MRB_PROC_STRICT_P(proc)) + return proc; + proc = proc->upper; } - return FALSE; -} - -static inline struct REnv* -top_env(mrb_state *mrb, struct RProc *proc) -{ - struct REnv *e = proc->env; - - if (is_strict(mrb, e)) return e; - while (e->c) { - e = (struct REnv*)e->c; - if (is_strict(mrb, e)) return e; - } - return e; + return proc; } #define CI_ACC_SKIP -1 @@ -279,19 +274,11 @@ mrb_env_unshare(mrb_state *mrb, struct REnv *e) if (e == NULL) return; else { size_t len = (size_t)MRB_ENV_STACK_LEN(e); - ptrdiff_t cioff = e->cioff; mrb_value *p; if (!MRB_ENV_STACK_SHARED_P(e)) return; - if (e->cxt.c != mrb->c) return; - if (e->cioff == 0 && e->cxt.c == mrb->root_c) return; + if (e->cxt != mrb->c) return; MRB_ENV_UNSHARE_STACK(e); - if (!e->c) { - /* save block argument position (negated) */ - e->cioff = -e->cxt.c->cibase[cioff].argc-1; - if (e->cioff == 0) e->cioff = -2; /* blkarg position for vararg (1:args, 2:blk) */ - } - e->cxt.mid = e->cxt.c->cibase[cioff].mid; p = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*len); if (len > 0) { stack_copy(p, e->stack, len); @@ -317,20 +304,22 @@ static void ecall(mrb_state *mrb, int i) { struct RProc *p; - mrb_callinfo *ci = mrb->c->ci; - mrb_value *self = mrb->c->stack; + 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); if (i<0) return; - if (ci - mrb->c->cibase > MRB_FUNCALL_DEPTH_MAX) { + if (ci - c->cibase > MRB_FUNCALL_DEPTH_MAX) { mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err)); } - p = mrb->c->ensure[i]; + p = c->ensure[i]; if (!p) return; - mrb->c->ensure[i] = NULL; - cioff = ci - mrb->c->cibase; + mrb_assert(!MRB_PROC_CFUNC_P(p)); + c->ensure[i] = NULL; + cioff = ci - c->cibase; ci = cipush(mrb); ci->stackent = mrb->c->stack; ci->mid = ci[-1].mid; @@ -338,14 +327,17 @@ ecall(mrb_state *mrb, int i) ci->argc = 0; ci->proc = p; ci->nregs = p->body.irep->nregs; - ci->target_class = p->target_class; - mrb->c->stack = mrb->c->stack + ci[-1].nregs; + ci->target_class = MRB_PROC_TARGET_CLASS(p); + env = MRB_PROC_ENV(p); + mrb_assert(env); + c->stack = c->stack + p->body.irep->nregs; exc = mrb->exc; mrb->exc = 0; if (exc) { mrb_gc_protect(mrb, mrb_obj_value(exc)); } - mrb_run(mrb, p, *self); - mrb->c->ci = mrb->c->cibase + cioff; + mrb_run(mrb, p, env->stack[0]); + c = mrb->c; + c->ci = c->cibase + cioff; if (!mrb->exc) mrb->exc = exc; mrb_gc_arena_restore(mrb, ai); } @@ -497,7 +489,7 @@ mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p) mrb->c->stack[0] = self; ci->proc = p; - ci->target_class = p->target_class; + ci->target_class = MRB_PROC_TARGET_CLASS(p); if (MRB_PROC_CFUNC_P(p)) { return p->body.func(mrb, self); } @@ -732,7 +724,7 @@ mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv) { struct RProc *p = mrb_proc_ptr(b); - return mrb_yield_with_class(mrb, b, argc, argv, p->env->stack[0], p->target_class); + return mrb_yield_with_class(mrb, b, argc, argv, MRB_PROC_ENV(p)->stack[0], MRB_PROC_TARGET_CLASS(p)); } MRB_API mrb_value @@ -740,7 +732,7 @@ mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg) { struct RProc *p = mrb_proc_ptr(b); - return mrb_yield_with_class(mrb, b, 1, &arg, p->env->stack[0], p->target_class); + return mrb_yield_with_class(mrb, b, 1, &arg, MRB_PROC_ENV(p)->stack[0], MRB_PROC_TARGET_CLASS(p)); } mrb_value @@ -770,23 +762,23 @@ mrb_value mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod) { struct RProc *proc; - mrb_irep *irep; mrb_value ary; - struct RClass *c; + struct RClass *c = NULL; mrb_get_args(mrb, ""); ary = mrb_ary_new(mrb); proc = mrb->c->ci[-1].proc; /* callee proc */ - c = proc->target_class; - mrb_ary_push(mrb, ary, mrb_obj_value(c)); mrb_assert(!MRB_PROC_CFUNC_P(proc)); - irep = proc->body.irep; - while (irep) { - if (irep->target_class && irep->target_class != c) { - c = irep->target_class; - mrb_ary_push(mrb, ary, mrb_obj_value(c)); + while (proc) { + if (MRB_PROC_SCOPE_P(proc)) { + struct RClass *c2 = MRB_PROC_TARGET_CLASS(proc); + + if (c2 != c) { + c = c2; + mrb_ary_push(mrb, ary, mrb_obj_value(c)); + } } - irep = irep->outer; + proc = proc->upper; } return ary; } @@ -852,18 +844,6 @@ argnum_error(mrb_state *mrb, mrb_int num) mrb_exc_set(mrb, exc); } -void -irep_uplink(mrb_state *mrb, mrb_irep *outer, mrb_irep *irep) -{ - if (irep->outer != outer) { - if (irep->outer) { - mrb_irep_decref(mrb, irep->outer); - } - irep->outer = outer; - mrb_irep_incref(mrb, outer); - } -} - #define ERR_PC_SET(mrb, pc) mrb->c->ci->err = pc; #define ERR_PC_CLR(mrb) mrb->c->ci->err = 0; #ifdef MRB_ENABLE_DEBUG_HOOK @@ -1319,9 +1299,10 @@ RETRY_TRY_BLOCK: CASE(OP_EPOP) { /* A A.times{ensure_pop().call} */ int a = GETARG_A(i); - int n, epos = mrb->c->ci->epos; - mrb_callinfo *ci; + mrb_callinfo *ci = mrb->c->ci; + int n, epos = ci->epos; mrb_value self = regs[0]; + struct RClass *target_class = ci->target_class; if (mrb->c->eidx == epos) { NEXT; @@ -1339,7 +1320,7 @@ RETRY_TRY_BLOCK: ci->proc = proc; ci->stackent = mrb->c->stack; ci->nregs = irep->nregs; - ci->target_class = proc->target_class; + ci->target_class = target_class; ci->pc = pc; ci->acc = ci[-1].nregs; mrb->c->stack += ci->acc; @@ -1441,7 +1422,7 @@ RETRY_TRY_BLOCK: if (GET_OPCODE(i) == OP_SENDB) { if (mrb_type(blk) == MRB_TT_PROC) { struct RProc *p = mrb_proc_ptr(blk); - if (p && !MRB_PROC_STRICT_P(p) && p->env == ci[-1].env) { + if (p && !MRB_PROC_STRICT_P(p) && MRB_PROC_ENV(p) == ci[-1].env) { p->flags |= MRB_PROC_ORPHAN; } } @@ -1493,20 +1474,16 @@ RETRY_TRY_BLOCK: /* replace callinfo */ ci = mrb->c->ci; - ci->target_class = m->target_class; + ci->target_class = MRB_PROC_TARGET_CLASS(m); ci->proc = m; - if (m->env) { + if (MRB_PROC_ENV_P(m)) { mrb_sym mid; + struct REnv *e = MRB_PROC_ENV(m); - if (MRB_ENV_STACK_SHARED_P(m->env)) { - mid = m->env->cxt.c->cibase[m->env->cioff].mid; - } - else { - mid = m->env->cxt.mid; - } + mid = e->mid; if (mid) ci->mid = mid; - if (!m->env->stack) { - m->env->stack = mrb->c->stack; + if (!e->stack) { + e->stack = mrb->c->stack; } } @@ -1547,8 +1524,8 @@ RETRY_TRY_BLOCK: else if (ci->argc+2 < irep->nregs) { stack_clear(regs+ci->argc+2, irep->nregs-ci->argc-2); } - if (m->env) { - regs[0] = m->env->stack[0]; + if (MRB_PROC_ENV_P(m)) { + regs[0] = MRB_PROC_ENV(m)->stack[0]; } pc = irep->iseq; JUMP; @@ -1833,6 +1810,12 @@ RETRY_TRY_BLOCK: /* A B return R(A) (B=normal,in-block return/break) */ mrb_callinfo *ci; +#define ecall_adjust() do {\ + ptrdiff_t cioff = ci - mrb->c->cibase;\ + ecall(mrb, --mrb->c->eidx);\ + ci = mrb->c->cibase + cioff;\ +} while (0) + ci = mrb->c->ci; if (ci->mid) { mrb_value blk; @@ -1847,18 +1830,17 @@ RETRY_TRY_BLOCK: struct RProc *p = mrb_proc_ptr(blk); if (!MRB_PROC_STRICT_P(p) && - ci > mrb->c->cibase && p->env == ci[-1].env) { + ci > mrb->c->cibase && MRB_PROC_ENV(p) == ci[-1].env) { p->flags |= MRB_PROC_ORPHAN; } } } if (mrb->exc) { - mrb_callinfo *ci0; mrb_value *stk; L_RAISE: - ci0 = ci = mrb->c->ci; + ci = mrb->c->ci; if (ci == mrb->c->cibase) { if (ci->ridx == 0) goto L_FTOP; goto L_RESCUE; @@ -1897,8 +1879,7 @@ RETRY_TRY_BLOCK: if (ci[0].ridx == ci[-1].ridx) { mrb_value *org_stbase = mrb->c->stbase; while (mrb->c->eidx > ci->epos) { - ecall(mrb, --mrb->c->eidx); - ci = mrb->c->ci; + ecall_adjust(); if (org_stbase != mrb->c->stbase) { stk = mrb->c->stack; } @@ -1911,46 +1892,43 @@ RETRY_TRY_BLOCK: irep = proc->body.irep; pool = irep->pool; syms = irep->syms; - if (ci != ci0) { - mrb->c->stack = ci[1].stackent; - } + mrb->c->stack = ci[1].stackent; stack_extend(mrb, irep->nregs); pc = mrb->c->rescue[--ci->ridx]; } else { int acc; mrb_value v; + struct RProc *dst; + ci = mrb->c->ci; v = regs[GETARG_A(i)]; mrb_gc_protect(mrb, v); switch (GETARG_B(i)) { case OP_R_RETURN: /* Fall through to OP_R_NORMAL otherwise */ - if (ci->acc >=0 && proc->env && !MRB_PROC_STRICT_P(proc)) { - struct REnv *e = top_env(mrb, proc); - mrb_callinfo *ce; + if (ci->acc >=0 && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) { + dst = top_proc(mrb, proc); - if (!MRB_ENV_STACK_SHARED_P(e) || e->cxt.c != mrb->c) { - localjump_error(mrb, LOCALJUMP_ERROR_RETURN); - goto L_RAISE; + if (MRB_PROC_ENV_P(dst)) { + struct REnv *e = MRB_PROC_ENV(dst); + + if (!MRB_ENV_STACK_SHARED_P(e) || e->cxt != mrb->c) { + localjump_error(mrb, LOCALJUMP_ERROR_RETURN); + goto L_RAISE; + } } - - ce = mrb->c->cibase + e->cioff; - while (ci > ce) { - mrb_env_unshare(mrb, ci->env); + while (ci->proc != dst) { if (ci->acc < 0) { localjump_error(mrb, LOCALJUMP_ERROR_RETURN); goto L_RAISE; } ci--; } - mrb_env_unshare(mrb, ci->env); - if (ce == mrb->c->cibase) { + if (ci == mrb->c->cibase) { localjump_error(mrb, LOCALJUMP_ERROR_RETURN); goto L_RAISE; } - mrb->c->stack = mrb->c->ci->stackent; - mrb->c->ci = ce; break; } case OP_R_NORMAL: @@ -1966,14 +1944,14 @@ RETRY_TRY_BLOCK: goto L_RAISE; } while (mrb->c->eidx > 0) { - ecall(mrb, --mrb->c->eidx); + ecall_adjust(); } /* automatic yield at the end */ mrb->c->status = MRB_FIBER_TERMINATED; mrb->c = mrb->c->prev; mrb->c->status = MRB_FIBER_RUNNING; + ci = mrb->c->ci; } - ci = mrb->c->ci; break; case OP_R_BREAK: if (MRB_PROC_STRICT_P(proc)) goto NORMAL_RETURN; @@ -1986,23 +1964,23 @@ RETRY_TRY_BLOCK: mrb_exc_set(mrb, exc); goto L_RAISE; } - if (!proc->env || !MRB_ENV_STACK_SHARED_P(proc->env)) { + if (!MRB_PROC_ENV_P(proc) || !MRB_ENV_STACK_SHARED_P(MRB_PROC_ENV(proc))) { goto L_BREAK_ERROR; } - if (proc->env->cxt.c != mrb->c) { + if (MRB_PROC_ENV(proc)->cxt != mrb->c) { goto L_BREAK_ERROR; } - while (mrb->c->eidx > mrb->c->ci->epos) { - ecall(mrb, --mrb->c->eidx); - } /* break from fiber block */ - if (mrb->c->ci == mrb->c->cibase && mrb->c->ci->pc) { + if (ci == mrb->c->cibase && ci->pc) { struct mrb_context *c = mrb->c; + while (c->eidx > c->ci->epos) { + ecall_adjust(); + } mrb->c = c->prev; c->prev = NULL; + ci = mrb->c->ci; } - ci = mrb->c->ci; if (ci->acc < 0) { mrb_gc_arena_restore(mrb, ai); mrb->c->vmexec = FALSE; @@ -2018,31 +1996,32 @@ RETRY_TRY_BLOCK: ci = mrb->c->ci; } mrb->c->stack = ci->stackent; - mrb->c->ci = mrb->c->cibase + proc->env->cioff + 1; - while (ci > mrb->c->ci) { - mrb_env_unshare(mrb, ci->env); + proc = proc->upper; + while (mrb->c->cibase < ci && ci[-1].proc != proc) { if (ci[-1].acc == CI_ACC_SKIP) { mrb->c->ci = ci; goto L_BREAK_ERROR; } ci--; } - mrb_env_unshare(mrb, ci->env); break; default: /* cannot happen */ break; } - while (mrb->c->eidx > mrb->c->ci->epos) { - ecall(mrb, --mrb->c->eidx); + while (mrb->c->eidx > ci->epos) { + ecall_adjust(); } - if (mrb->c->vmexec && !mrb->c->ci->target_class) { + if (mrb->c->vmexec && !ci->target_class) { mrb_gc_arena_restore(mrb, ai); mrb->c->vmexec = FALSE; mrb->jmp = prev_jmp; return v; } - ci = mrb->c->ci; + while (ci < mrb->c->ci) { + mrb_env_unshare(mrb, mrb->c->ci->env); + mrb->c->ci--; + } acc = ci->acc; mrb->c->stack = ci->stackent; cipop(mrb); @@ -2052,6 +2031,7 @@ RETRY_TRY_BLOCK: return v; } pc = ci->pc; + ci = mrb->c->ci; DEBUG(fprintf(stderr, "from :%s\n", mrb_sym2name(mrb, ci->mid))); proc = mrb->c->ci->proc; irep = proc->body.irep; @@ -2152,8 +2132,7 @@ RETRY_TRY_BLOCK: if (lv == 0) stack = regs + 1; else { struct REnv *e = uvenv(mrb, lv-1); - if (!e || e->cioff == 0 || - (!MRB_ENV_STACK_SHARED_P(e) && e->cxt.mid == 0) || + if (!e || (!MRB_ENV_STACK_SHARED_P(e) && e->mid == 0) || MRB_ENV_STACK_LEN(e) <= m1+r+m2+1) { localjump_error(mrb, LOCALJUMP_ERROR_YIELD); goto L_RAISE; @@ -2689,7 +2668,6 @@ RETRY_TRY_BLOCK: int c = GETARG_c(i); mrb_irep *nirep = irep->reps[b]; - irep_uplink(mrb, irep, nirep); if (c & OP_L_CAPTURE) { p = mrb_closure_new(mrb, nirep); } @@ -2718,9 +2696,7 @@ RETRY_TRY_BLOCK: base = regs[a]; super = regs[a+1]; if (mrb_nil_p(base)) { - baseclass = mrb->c->ci->proc->target_class; - if (!baseclass) baseclass = mrb->c->ci->target_class; - + baseclass = mrb->c->ci->target_class; base = mrb_obj_value(baseclass); } c = mrb_vm_define_class(mrb, base, super, id); @@ -2738,9 +2714,7 @@ RETRY_TRY_BLOCK: base = regs[a]; if (mrb_nil_p(base)) { - baseclass = mrb->c->ci->proc->target_class; - if (!baseclass) baseclass = mrb->c->ci->target_class; - + baseclass = mrb->c->ci->target_class; base = mrb_obj_value(baseclass); } c = mrb_vm_define_module(mrb, base, id); @@ -2758,11 +2732,12 @@ RETRY_TRY_BLOCK: struct RProc *p; mrb_irep *nirep = irep->reps[bx]; - irep_uplink(mrb, irep, nirep); - nirep->target_class = mrb_class_ptr(recv); /* prepare closure */ - p = mrb_closure_new(mrb, nirep); + p = mrb_proc_new(mrb, nirep); p->c = NULL; + mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)proc); + MRB_PROC_SET_TARGET_CLASS(p, mrb_class_ptr(recv)); + p->flags |= MRB_PROC_SCOPE; /* prepare stack */ ci = cipush(mrb); @@ -2777,7 +2752,7 @@ RETRY_TRY_BLOCK: mrb->c->stack += a; /* setup closure */ - p->target_class = ci->target_class; + MRB_PROC_SET_TARGET_CLASS(p, ci->target_class); ci->proc = p; irep = p->body.irep; @@ -2908,7 +2883,6 @@ mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int sta return mrb_vm_run(mrb, proc, self, stack_keep); } if (mrb->c->ci == mrb->c->cibase) { - mrb->c->ci->env = NULL; return mrb_vm_run(mrb, proc, self, stack_keep); } ci = cipush(mrb); -- cgit v1.2.3 From 23d18bbd62fabc13b11ddafd05bb4365996c9986 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 28 Oct 2017 01:32:25 +0900 Subject: Add parentheses to pacify a warning. --- include/mruby/proc.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mruby/proc.h b/include/mruby/proc.h index 24c9b0c21..17290950c 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -24,7 +24,7 @@ struct REnv { }; /* flags (21bits): 1(shared flag):10(cioff/bidx):10(stack_len) */ -#define MRB_ENV_SET_STACK_LEN(e,len) (e)->flags = (((e)->flags & ~0x3ff)|(unsigned int)(len) & 0x3ff) +#define MRB_ENV_SET_STACK_LEN(e,len) (e)->flags = (((e)->flags & ~0x3ff)|((unsigned int)(len) & 0x3ff)) #define MRB_ENV_STACK_LEN(e) ((mrb_int)((e)->flags & 0x3ff)) #define MRB_ENV_STACK_UNSHARED (1<<20) #define MRB_ENV_UNSHARE_STACK(e) (e)->flags |= MRB_ENV_STACK_UNSHARED -- cgit v1.2.3 From 57dad6e3fd1a670702bd252be07d2999b6b5735d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 28 Oct 2017 01:37:51 +0900 Subject: Remove a debug variable --- src/vm.c | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/vm.c b/src/vm.c index 734d225ba..9758ccf1e 100644 --- a/src/vm.c +++ b/src/vm.c @@ -211,15 +211,12 @@ stack_extend(mrb_state *mrb, int room) } } -static int nenv = 0; - static inline struct REnv* uvenv(mrb_state *mrb, int up) { struct RProc *proc = mrb->c->ci->proc; struct REnv *e; - nenv++; do { e = MRB_PROC_ENV(proc); if (!e) return NULL; -- cgit v1.2.3 From c7c9543bed57db12fd8aa57391e0b652ee27cb23 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 28 Oct 2017 21:09:25 +0900 Subject: Fixed UPVAR gotchas; fix #3835 Both `uvenv` function and `env` generation in `create_proc_from_string` function have bugs to handling enclosed environment objects. --- mrbgems/mruby-eval/src/eval.c | 58 ++++++++++++++++++++++--------------------- src/vm.c | 21 ++++++++++++---- 2 files changed, 46 insertions(+), 33 deletions(-) diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c index 7061565ea..997b69e25 100644 --- a/mrbgems/mruby-eval/src/eval.c +++ b/mrbgems/mruby-eval/src/eval.c @@ -12,21 +12,13 @@ mrb_value mrb_obj_instance_eval(mrb_state *mrb, mrb_value self); static struct mrb_irep * get_closure_irep(mrb_state *mrb, int level) { - struct mrb_context *c = mrb->c; - struct RProc *proc = c->ci[-1].proc; + struct RProc *proc = mrb->c->ci[-1].proc; - if (level == 0) { - if (MRB_PROC_CFUNC_P(proc)) { - return NULL; - } - return proc->body.irep; - } - - while (--level) { - proc = proc->upper; + while (level--) { if (!proc) return NULL; + proc = proc->upper; } - + if (!proc) return NULL; if (MRB_PROC_CFUNC_P(proc)) { return NULL; } @@ -60,7 +52,7 @@ search_variable(mrb_state *mrb, mrb_sym vsym, int bnest) int pos; for (level = 0; (virep = get_closure_irep(mrb, level)); level++) { - if (!virep || virep->lv == NULL) { + if (virep->lv == NULL) { continue; } for (pos = 0; pos < virep->nlocals - 1; pos++) { @@ -123,7 +115,7 @@ patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top) if (GETARG_C(c) != 0) { break; } - { + else { mrb_code arg = search_variable(mrb, irep->syms[GETARG_B(c)], bnest); if (arg != 0) { /* must replace */ @@ -197,7 +189,7 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding, struct mrb_parser_state *p; struct RProc *proc; struct REnv *e; - mrb_callinfo *ci = mrb->c->ci; + mrb_callinfo *ci = &mrb->c->ci[-1]; /* callinfo of eval caller */ struct RClass *target_class = NULL; int bidx; @@ -246,19 +238,29 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding, mrbc_context_free(mrb, cxt); mrb_raise(mrb, E_SCRIPT_ERROR, "codegen error"); } - target_class = MRB_PROC_TARGET_CLASS(ci[-1].proc); - e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, - (struct RClass*)target_class); - e->mid = ci->mid; - e->stack = ci->stackent; - MRB_ENV_SET_STACK_LEN(e, ci->proc->body.irep->nlocals); - bidx = ci->argc; - if (ci->argc < 0) bidx = 2; - else bidx += 1; - MRB_ENV_SET_BIDX(e, bidx); - proc->e.env = e; - proc->flags |= MRB_PROC_ENVSET; - ci->target_class = target_class; + target_class = MRB_PROC_TARGET_CLASS(ci->proc); + if (!MRB_PROC_CFUNC_P(ci->proc)) { + if (ci->env) { + e = ci->env; + } + else { + e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, + (struct RClass*)target_class); + e->mid = ci->mid; + e->stack = ci[1].stackent; + e->cxt = mrb->c; + MRB_ENV_SET_STACK_LEN(e, ci->proc->body.irep->nlocals); + bidx = ci->argc; + if (ci->argc < 0) bidx = 2; + else bidx += 1; + MRB_ENV_SET_BIDX(e, bidx); + } + proc->e.env = e; + proc->flags |= MRB_PROC_ENVSET; + mrb_field_write_barrier(mrb, (struct RBasic*)proc, (struct RBasic*)e); + } + proc->upper = ci->proc; + mrb->c->ci->target_class = target_class; patch_irep(mrb, proc->body.irep, 0, proc->body.irep); /* mrb_codedump_all(mrb, proc); */ diff --git a/src/vm.c b/src/vm.c index 9758ccf1e..b1e2b624b 100644 --- a/src/vm.c +++ b/src/vm.c @@ -217,13 +217,24 @@ uvenv(mrb_state *mrb, int up) struct RProc *proc = mrb->c->ci->proc; struct REnv *e; - do { - e = MRB_PROC_ENV(proc); - if (!e) return NULL; + while (up--) { proc = proc->upper; if (!proc) return NULL; - } while (up--); - return e; + } + e = MRB_PROC_ENV(proc); + if (e) return e; /* proc has enclosed env */ + else { + mrb_callinfo *ci = mrb->c->ci; + mrb_callinfo *cb = mrb->c->cibase; + + while (cb <= ci) { + if (ci->proc == proc) { + return ci->env; + } + ci--; + } + } + return NULL; } static inline struct RProc* -- cgit v1.2.3 From 92e24f809b75d4b077fcde302b1f7d5cf9bac6bb Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 28 Oct 2017 21:44:56 +0900 Subject: Should check if `callinfo` stack is popped before updating the stack. This is a resurrection of 75c374c, which is accidentally removed by 93f5f22; Fix #3507 #3512 #3518 #3521 --- src/vm.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/vm.c b/src/vm.c index b1e2b624b..b050dfbeb 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1845,10 +1845,11 @@ RETRY_TRY_BLOCK: } if (mrb->exc) { + mrb_callinfo *ci0; mrb_value *stk; L_RAISE: - ci = mrb->c->ci; + ci0 = ci = mrb->c->ci; if (ci == mrb->c->cibase) { if (ci->ridx == 0) goto L_FTOP; goto L_RESCUE; @@ -1900,7 +1901,9 @@ RETRY_TRY_BLOCK: irep = proc->body.irep; pool = irep->pool; syms = irep->syms; - mrb->c->stack = ci[1].stackent; + if (ci < ci0) { + mrb->c->stack = ci[1].stackent; + } stack_extend(mrb, irep->nregs); pc = mrb->c->rescue[--ci->ridx]; } -- cgit v1.2.3 From 6316e0c75dc4762a4df0a3ed4f273fc3a039b277 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 28 Oct 2017 23:27:07 +0900 Subject: Should clear ensure stack at `OP_RETURN break`; #3715 This is a resurrection of d0a7e01, which is accidentally removed by 93f5f22; Fix #3715 --- src/vm.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/vm.c b/src/vm.c index b050dfbeb..b9cd86b67 100644 --- a/src/vm.c +++ b/src/vm.c @@ -338,13 +338,13 @@ ecall(mrb_state *mrb, int i) ci->target_class = MRB_PROC_TARGET_CLASS(p); env = MRB_PROC_ENV(p); mrb_assert(env); - c->stack = c->stack + p->body.irep->nregs; + c->stack += p->body.irep->nregs; exc = mrb->exc; mrb->exc = 0; if (exc) { mrb_gc_protect(mrb, mrb_obj_value(exc)); } mrb_run(mrb, p, env->stack[0]); - c = mrb->c; + mrb->c = c; c->ci = c->cibase + cioff; if (!mrb->exc) mrb->exc = exc; mrb_gc_arena_restore(mrb, ai); @@ -1981,13 +1981,13 @@ RETRY_TRY_BLOCK: if (MRB_PROC_ENV(proc)->cxt != mrb->c) { goto L_BREAK_ERROR; } + while (mrb->c->eidx > mrb->c->ci->epos) { + ecall_adjust(); + } /* break from fiber block */ if (ci == mrb->c->cibase && ci->pc) { struct mrb_context *c = mrb->c; - while (c->eidx > c->ci->epos) { - ecall_adjust(); - } mrb->c = c->prev; c->prev = NULL; ci = mrb->c->ci; -- cgit v1.2.3 From 1b45e034ba95b00981e626935ec46488c0cfadb0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 28 Oct 2017 23:35:01 +0900 Subject: Remove one of the lines that did the same thing; fix #3836 The change is suggested by `ukrainskiysergey` in #3836. I deleted the other line for clarity. I also updated comment lines. --- src/vm.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/vm.c b/src/vm.c index b9cd86b67..d4940561b 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2750,7 +2750,7 @@ RETRY_TRY_BLOCK: MRB_PROC_SET_TARGET_CLASS(p, mrb_class_ptr(recv)); p->flags |= MRB_PROC_SCOPE; - /* prepare stack */ + /* prepare call stack */ ci = cipush(mrb); ci->pc = pc + 1; ci->acc = a; @@ -2762,8 +2762,7 @@ RETRY_TRY_BLOCK: /* prepare stack */ mrb->c->stack += a; - /* setup closure */ - MRB_PROC_SET_TARGET_CLASS(p, ci->target_class); + /* setup block to call */ ci->proc = p; irep = p->body.irep; -- cgit v1.2.3 From 59dc7d07636a37da3c38dd6293b40b019cc3cdc8 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 28 Oct 2017 23:39:21 +0900 Subject: Removed a debug printf; fix #3834 --- src/vm.c | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/vm.c b/src/vm.c index d4940561b..a400190cc 100644 --- a/src/vm.c +++ b/src/vm.c @@ -151,9 +151,6 @@ envadjust(mrb_state *mrb, mrb_value *oldbase, mrb_value *newbase, size_t size) e->stack = newbase + off; } - else if (e && MRB_ENV_STACK_SHARED_P(e)) { - fprintf(stderr, "bingo! %p\n", e); - } ci->stackent = newbase + (ci->stackent - oldbase); ci++; } -- cgit v1.2.3 From 77edafb04c4bc15e3c348acb0d1e7f873b7a66f0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 29 Oct 2017 00:25:45 +0900 Subject: Need to check number of argument of `Struct#new`; fix #3823 --- mrbgems/mruby-struct/src/struct.c | 22 +++++++++++++--------- mrbgems/mruby-struct/test/struct.rb | 9 +-------- 2 files changed, 14 insertions(+), 17 deletions(-) diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index fed9e8105..019f99f22 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -283,17 +283,21 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass) name = mrb_nil_value(); mrb_get_args(mrb, "*&", &argv, &argc, &b); if (argc == 0) { /* special case to avoid crash */ - rest = mrb_ary_new(mrb); + mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments"); } else { - if (argc > 0) name = argv[0]; - pargv = &argv[1]; - argcnt = argc-1; - if (!mrb_nil_p(name) && mrb_symbol_p(name)) { - /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ - name = mrb_nil_value(); - pargv = &argv[0]; - argcnt++; + pargv = argv; + argcnt = argc; + if (argc > 0) { + name = argv[0]; + if (mrb_symbol_p(name)) { + /* 1stArgument:symbol -> name=nil rest=argv[0..n] */ + name = mrb_nil_value(); + } + else { + pargv++; + argcnt--; + } } rest = mrb_ary_new_from_values(mrb, argcnt, pargv); for (i=0; i Date: Tue, 31 Oct 2017 09:06:04 +0900 Subject: Need to mark fibers referenced from `env`; fix #3837 The issue #3837 is a regression of #3819. I was mistakenly removed a important code to mark fibers from `env`. --- include/mruby/proc.h | 1 - src/gc.c | 3 +++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/include/mruby/proc.h b/include/mruby/proc.h index 17290950c..b33e9e1a2 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -19,7 +19,6 @@ struct REnv { MRB_OBJECT_HEADER; mrb_value *stack; struct mrb_context *cxt; - // struct RProc *proc; mrb_sym mid; }; diff --git a/src/gc.c b/src/gc.c index a3a638ae3..4b83f454b 100644 --- a/src/gc.c +++ b/src/gc.c @@ -657,6 +657,9 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) struct REnv *e = (struct REnv*)obj; mrb_int i, len; + if (MRB_ENV_STACK_SHARED_P(e) && e->cxt->fib) { + mrb_gc_mark(mrb, (struct RBasic*)e->cxt->fib); + } len = MRB_ENV_STACK_LEN(e); for (i=0; istack[i]); -- cgit v1.2.3 From 022570ab8d3de0dd8e0acfb1d927a5e3547ea34e Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 31 Oct 2017 08:58:17 +0900 Subject: Call stack may not reference the destination `proc`; fix #3838 The destination `proc` may be an orphan. --- src/vm.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/vm.c b/src/vm.c index a400190cc..bb884f4a0 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1916,6 +1916,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)) { + mrb_callinfo *cibase = mrb->c->cibase; dst = top_proc(mrb, proc); if (MRB_PROC_ENV_P(dst)) { @@ -1926,14 +1927,14 @@ RETRY_TRY_BLOCK: goto L_RAISE; } } - while (ci->proc != dst) { + while (cibase <= ci && ci->proc != dst) { if (ci->acc < 0) { localjump_error(mrb, LOCALJUMP_ERROR_RETURN); goto L_RAISE; } ci--; } - if (ci == mrb->c->cibase) { + if (ci <= cibase) { localjump_error(mrb, LOCALJUMP_ERROR_RETURN); goto L_RAISE; } -- cgit v1.2.3 From ddfb24908c701b742edbad171da395e16c8cda1a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 31 Oct 2017 08:40:22 +0900 Subject: Fixed constant (and class variable) reference bug; fix #3839 Unlike method definition, constant reference should start from `MRB_PROC_TARGET_CLASS(ci->proc)`, not `ci->target_class`. In addition, `MRB_PROC_TARGET_CLASS(ci->proc)` is always set. --- src/variable.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/variable.c b/src/variable.c index 3e84c573c..c82f2a822 100644 --- a/src/variable.c +++ b/src/variable.c @@ -635,7 +635,6 @@ mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym) struct RClass *c; c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); - if (!c) c = mrb->c->ci->target_class; return mrb_mod_cv_get(mrb, c, sym); } @@ -645,7 +644,6 @@ mrb_vm_cv_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->c->ci->target_class; mrb_mod_cv_set(mrb, c, sym, v); } @@ -707,9 +705,6 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) struct RProc *proc; c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); - if (!c) c = mrb->c->ci->target_class; - mrb_assert(c != NULL); - if (c->iv && iv_get(mrb, c->iv, sym, &v)) { return v; } @@ -746,7 +741,9 @@ mrb_const_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v) void mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v) { - struct RClass *c = mrb->c->ci->target_class; + struct RClass *c; + + c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v); } -- cgit v1.2.3 From f6896751b454451fe05636d9d8b4f80eb191fd9c Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Thu, 2 Nov 2017 15:44:05 +0900 Subject: don't overwrite backtrace info. --- src/backtrace.c | 7 +++++-- src/error.c | 1 + 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/backtrace.c b/src/backtrace.c index 232d1c2f4..ddeb2a3ca 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -215,11 +215,14 @@ packed_backtrace(mrb_state *mrb) void mrb_keep_backtrace(mrb_state *mrb, mrb_value exc) { + mrb_sym sym = mrb_intern_lit(mrb, "backtrace"); mrb_value backtrace; - int ai = mrb_gc_arena_save(mrb); + int ai; + if (mrb_iv_defined(mrb, exc, sym)) return; + ai = mrb_gc_arena_save(mrb); backtrace = packed_backtrace(mrb); - mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "backtrace"), backtrace); + mrb_iv_set(mrb, exc, sym, backtrace); mrb_gc_arena_restore(mrb, ai); } diff --git a/src/error.c b/src/error.c index fd4182eb2..a9b6db07a 100644 --- a/src/error.c +++ b/src/error.c @@ -200,6 +200,7 @@ exc_debug_info(mrb_state *mrb, struct RObject *exc) mrb_callinfo *ci = mrb->c->ci; mrb_code *pc = ci->pc; + if (mrb_obj_iv_defined(mrb, exc, mrb_intern_lit(mrb, "file"))) return; while (ci >= mrb->c->cibase) { mrb_code *err = ci->err; -- cgit v1.2.3 From e4662d77e75de4cc6d8e98e56bb0395cbbedbaf7 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 3 Nov 2017 01:59:08 +0900 Subject: Should not use `FSHARED` state for string from `irep` pools; fix #3829 This strings in `irep` pools may be freed forcefully in `mrb_irep_free`. This commit probably fixes #3817 as well. --- include/mruby/string.h | 12 ++-- src/state.c | 2 + src/string.c | 150 ++++++++++++++++++++----------------------------- 3 files changed, 71 insertions(+), 93 deletions(-) diff --git a/include/mruby/string.h b/include/mruby/string.h index 9e499b58b..975b1fe0d 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -68,6 +68,9 @@ struct RString { #define RSTR_SET_NOFREE_FLAG(s) ((s)->flags |= MRB_STR_NOFREE) #define RSTR_UNSET_NOFREE_FLAG(s) ((s)->flags &= ~MRB_STR_NOFREE) +#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 */ @@ -83,10 +86,11 @@ MRB_API mrb_int mrb_str_strlen(mrb_state*, struct RString*); #define MRB_STR_SHARED 1 #define MRB_STR_FSHARED 2 #define MRB_STR_NOFREE 4 -#define MRB_STR_NO_UTF 8 -#define MRB_STR_EMBED 16 -#define MRB_STR_EMBED_LEN_MASK 0x3e0 -#define MRB_STR_EMBED_LEN_SHIFT 5 +#define MRB_STR_POOL 8 +#define MRB_STR_NO_UTF 16 +#define MRB_STR_EMBED 32 +#define MRB_STR_EMBED_LEN_MASK 0x7c0 +#define MRB_STR_EMBED_LEN_SHIFT 6 void mrb_gc_free_str(mrb_state*, struct RString*); MRB_API void mrb_str_modify(mrb_state*, struct RString*); diff --git a/src/state.c b/src/state.c index 44bcc0656..f4e63ab84 100644 --- a/src/state.c +++ b/src/state.c @@ -11,6 +11,7 @@ #include #include #include +#include void mrb_init_core(mrb_state*); void mrb_init_mrbgems(mrb_state*); @@ -222,6 +223,7 @@ mrb_str_pool(mrb_state *mrb, mrb_value str) ns->as.heap.ptr[len] = '\0'; } } + RSTR_SET_POOL_FLAG(ns); MRB_SET_FROZEN_FLAG(ns); return mrb_obj_value(ns); } diff --git a/src/string.c b/src/string.c index 2616d0e72..c1e248dd9 100644 --- a/src/string.c +++ b/src/string.c @@ -57,7 +57,7 @@ str_new(mrb_state *mrb, const char *p, size_t len) return str_new_static(mrb, p, len); } s = mrb_obj_alloc_string(mrb); - if (len < RSTRING_EMBED_LEN_MAX) { + if (len <= RSTRING_EMBED_LEN_MAX) { RSTR_SET_EMBED_FLAG(s); RSTR_SET_EMBED_LEN(s, len); if (p) { @@ -341,48 +341,59 @@ mrb_memsearch(const void *x0, mrb_int m, const void *y0, mrb_int n) return mrb_memsearch_qs((const unsigned char *)x0, m, (const unsigned char *)y0, n); } -static mrb_bool -str_make_shared(mrb_state *mrb, struct RString *s) +static void +str_make_shared(mrb_state *mrb, struct RString *orig, struct RString *s) { - if (!RSTR_SHARED_P(s)) { - if (MRB_FROZEN_P(s) || RSTR_FSHARED_P(s)) { - return FALSE; + mrb_shared_string *shared; + mrb_int len = RSTR_LEN(orig); + + mrb_assert(!RSTR_EMBED_P(orig)); + if (RSTR_SHARED_P(orig)) { + shared = orig->as.heap.aux.shared; + shared->refcnt++; + s->as.heap.ptr = orig->as.heap.ptr; + s->as.heap.len = len; + s->as.heap.aux.shared = shared; + RSTR_SET_SHARED_FLAG(s); + RSTR_UNSET_EMBED_FLAG(s); + } + else if (RSTR_FSHARED_P(orig)) { + struct RString *fs; + + fs = orig->as.heap.aux.fshared; + s->as.heap.ptr = orig->as.heap.ptr; + s->as.heap.len = len; + s->as.heap.aux.fshared = fs; + RSTR_SET_FSHARED_FLAG(s); + RSTR_UNSET_EMBED_FLAG(s); + } + else if (MRB_FROZEN_P(orig) && !RSTR_POOL_P(orig)) { + s->as.heap.ptr = orig->as.heap.ptr; + s->as.heap.len = len; + s->as.heap.aux.fshared = orig; + RSTR_SET_FSHARED_FLAG(s); + RSTR_UNSET_EMBED_FLAG(s); + } + else { + shared = (mrb_shared_string *)mrb_malloc(mrb, sizeof(mrb_shared_string)); + shared->refcnt = 2; + shared->nofree = !!RSTR_NOFREE_P(orig); + if (!shared->nofree && orig->as.heap.aux.capa > orig->as.heap.len) { + shared->ptr = (char *)mrb_realloc(mrb, orig->as.heap.ptr, len+1); + orig->as.heap.ptr = shared->ptr; } else { - mrb_shared_string *shared = (mrb_shared_string *)mrb_malloc(mrb, sizeof(mrb_shared_string)); - - shared->refcnt = 1; - if (RSTR_EMBED_P(s)) { - const mrb_int len = RSTR_EMBED_LEN(s); - char *const tmp = (char *)mrb_malloc(mrb, len+1); - memcpy(tmp, s->as.ary, len); - tmp[len] = '\0'; - RSTR_UNSET_EMBED_FLAG(s); - s->as.heap.ptr = tmp; - s->as.heap.len = len; - shared->nofree = FALSE; - shared->ptr = s->as.heap.ptr; - } - else if (RSTR_NOFREE_P(s)) { - shared->nofree = TRUE; - shared->ptr = s->as.heap.ptr; - RSTR_UNSET_NOFREE_FLAG(s); - } - else { - shared->nofree = FALSE; - if (s->as.heap.aux.capa > s->as.heap.len) { - s->as.heap.ptr = shared->ptr = (char *)mrb_realloc(mrb, s->as.heap.ptr, s->as.heap.len+1); - } - else { - shared->ptr = s->as.heap.ptr; - } - } - shared->len = s->as.heap.len; - s->as.heap.aux.shared = shared; - RSTR_SET_SHARED_FLAG(s); + shared->ptr = orig->as.heap.ptr; } + orig->as.heap.aux.shared = shared; + RSTR_SET_SHARED_FLAG(orig); + shared->len = len; + s->as.heap.aux.shared = shared; + s->as.heap.ptr = shared->ptr; + s->as.heap.len = len; + RSTR_SET_SHARED_FLAG(s); + RSTR_UNSET_EMBED_FLAG(s); } - return TRUE; } static mrb_value @@ -391,32 +402,15 @@ byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len) struct RString *orig, *s; orig = mrb_str_ptr(str); - if (RSTR_EMBED_P(orig) || RSTR_LEN(orig) == 0) { - s = str_new(mrb, orig->as.ary+beg, len); - } - else if (str_make_shared(mrb, orig)) { - mrb_shared_string *shared = orig->as.heap.aux.shared; - - s = mrb_obj_alloc_string(mrb); - s->as.heap.ptr = orig->as.heap.ptr + beg; - s->as.heap.len = len; - s->as.heap.aux.shared = shared; - RSTR_SET_SHARED_FLAG(s); - shared->refcnt++; + if (RSTR_EMBED_P(orig) || RSTR_LEN(orig) == 0 || len <= RSTRING_EMBED_LEN_MAX) { + s = str_new(mrb, RSTR_PTR(orig)+beg, len); } else { s = mrb_obj_alloc_string(mrb); - s->as.heap.ptr = orig->as.heap.ptr + beg; + str_make_shared(mrb, orig, s); + s->as.heap.ptr += beg; s->as.heap.len = len; - if (MRB_FROZEN_P(orig)) { - s->as.heap.aux.fshared = orig; - } - else { - s->as.heap.aux.fshared = orig->as.heap.aux.fshared; - } - RSTR_SET_FSHARED_FLAG(s); } - return mrb_obj_value(s); } #ifdef MRB_UTF8_STRING @@ -523,38 +517,15 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2) RSTR_UNSET_FSHARED_FLAG(s1); RSTR_UNSET_NOFREE_FLAG(s1); - RSTR_UNSET_EMBED_FLAG(s1); - - if (MRB_FROZEN_P(s2)) { - RSTR_SET_FSHARED_FLAG(s1); - s1->as.heap.ptr = RSTR_PTR(s2); - s1->as.heap.len = len; - s1->as.heap.aux.fshared = s2; - } - else if (RSTR_FSHARED_P(s2)) { - RSTR_SET_FSHARED_FLAG(s1); - s1->as.heap.ptr = s2->as.heap.ptr; - s1->as.heap.len = len; - s1->as.heap.aux.fshared = s2->as.heap.aux.fshared; - } - else if (RSTR_SHARED_P(s2)) { -L_SHARE: - RSTR_SET_SHARED_FLAG(s1); - s1->as.heap.ptr = s2->as.heap.ptr; - s1->as.heap.len = len; - s1->as.heap.aux.shared = s2->as.heap.aux.shared; - s1->as.heap.aux.shared->refcnt++; + if (len <= RSTRING_EMBED_LEN_MAX) { + RSTR_UNSET_SHARED_FLAG(s1); + RSTR_UNSET_FSHARED_FLAG(s1); + RSTR_SET_EMBED_FLAG(s1); + memcpy(s1->as.ary, RSTR_PTR(s2), len); + RSTR_SET_EMBED_LEN(s1, len); } else { - if (len <= RSTRING_EMBED_LEN_MAX) { - RSTR_SET_EMBED_FLAG(s1); - memcpy(s1->as.ary, RSTR_PTR(s2), len); - RSTR_SET_EMBED_LEN(s1, len); - } - else { - str_make_shared(mrb, s2); - goto L_SHARE; - } + str_make_shared(mrb, s2, s1); } return mrb_obj_value(s1); @@ -710,6 +681,7 @@ mrb_str_modify(mrb_state *mrb, struct RString *s) char *p = s->as.heap.ptr; mrb_int len = s->as.heap.len; + RSTR_UNSET_FSHARED_FLAG(s); RSTR_UNSET_NOFREE_FLAG(s); RSTR_UNSET_FSHARED_FLAG(s); if (len < RSTRING_EMBED_LEN_MAX) { -- cgit v1.2.3 From d489b41c31361844ee4715c1aac54f3f0b353995 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 3 Nov 2017 02:15:18 +0900 Subject: Reduce memory leaks from `mirb`. --- mrbgems/mruby-bin-mirb/tools/mirb/mirb.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c index 3feb4270a..7e5fd392f 100644 --- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c +++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c @@ -584,6 +584,8 @@ done: mrb_free(mrb, history_path); #endif + if (args.rfp) fclose(args.rfp); + mrb_free(mrb, args.argv); mrbc_context_free(mrb, cxt); mrb_close(mrb); -- cgit v1.2.3 From 12e38597c84f12e1064119d6b929c193eb1805e9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 3 Nov 2017 09:35:55 +0900 Subject: Always check division-by-zero to avoid undefined behavior; fix #3816 Also removed the code to normalize NaN value for `MRB_NAN_BOXING`. Tha code was added to fix #1712 but no longer required after 249f05e7d. --- mrbgems/mruby-struct/src/struct.c | 2 +- src/vm.c | 67 +++++++++++---------------------------- 2 files changed, 19 insertions(+), 50 deletions(-) diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index 019f99f22..1d2e62583 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -200,7 +200,7 @@ make_struct_define_accessors(mrb_state *mrb, mrb_value members, struct RClass *c } static mrb_value -make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass) +make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass *klass) { mrb_value nstr; mrb_sym id; diff --git a/src/vm.c b/src/vm.c index bb884f4a0..e5b7de0da 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2331,70 +2331,39 @@ RETRY_TRY_BLOCK: CASE(OP_DIV) { /* A B C R(A) := R(A)/R(A+1) (Syms[B]=:/,C=1)*/ int a = GETARG_A(i); + double x, y, f; /* 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): - { - mrb_int x = mrb_fixnum(regs[a]); - mrb_int y = mrb_fixnum(regs[a+1]); - double f; - if (y == 0) { - if (x > 0) f = INFINITY; - else if (x < 0) f = -INFINITY; - else /* if (x == 0) */ f = NAN; - } - else { - f = (mrb_float)x / (mrb_float)y; - } - SET_FLOAT_VALUE(mrb, regs[a], f); - } + x = (mrb_float)mrb_fixnum(regs[a]); + y = (mrb_float)mrb_fixnum(regs[a+1]); break; case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT): - { - mrb_int x = mrb_fixnum(regs[a]); - mrb_float y = mrb_float(regs[a+1]); - SET_FLOAT_VALUE(mrb, regs[a], (mrb_float)x / y); - } + x = (mrb_float)mrb_fixnum(regs[a]); + y = mrb_float(regs[a+1]); break; case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM): -#ifdef MRB_WORD_BOXING - { - mrb_float x = mrb_float(regs[a]); - mrb_int y = mrb_fixnum(regs[a+1]); - double f; - if (y == 0) { - f = INFINITY; - } - else { - f = x / y; - } - SET_FLOAT_VALUE(mrb, regs[a], f); - } -#else - OP_MATH_BODY(/,mrb_float,mrb_fixnum); -#endif + x = mrb_float(regs[a]); + y = (mrb_float)mrb_fixnum(regs[a+1]); break; case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT): -#ifdef MRB_WORD_BOXING - { - mrb_float x = mrb_float(regs[a]); - mrb_float y = mrb_float(regs[a+1]); - SET_FLOAT_VALUE(mrb, regs[a], x / y); - } -#else - OP_MATH_BODY(/,mrb_float,mrb_float); -#endif + x = mrb_float(regs[a]); + y = mrb_float(regs[a+1]); break; default: goto L_SEND; } -#ifdef MRB_NAN_BOXING - if (isnan(mrb_float(regs[a]))) { - mrb_value v = mrb_float_value(mrb, mrb_float(regs[a])); - regs[a] = v; + + if (y == 0) { + if (x > 0) f = INFINITY; + else if (x < 0) f = -INFINITY; + else /* if (x == 0) */ f = NAN; } -#endif + else { + f = x / y; + } + SET_FLOAT_VALUE(mrb, regs[a], f); NEXT; } -- cgit v1.2.3 From e7fe6ee2638dee438c1d79ab16a0403aebec0a60 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 4 Nov 2017 00:35:50 +0900 Subject: Avoid pointer arithmetic in backtrace.c; #3816 --- src/backtrace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backtrace.c b/src/backtrace.c index ddeb2a3ca..f2cf2cd0f 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -51,7 +51,7 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, mrb_code *pc0, each_backtrace_fu pc = mrb->c->cibase[i].err; } else if (i+1 <= ciidx) { - pc = mrb->c->cibase[i+1].pc - 1; + pc = &mrb->c->cibase[i+1].pc[-1]; } else { pc = pc0; -- cgit v1.2.3