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(-) (limited to 'mrbgems') 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(-) (limited to 'mrbgems') 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 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(+) (limited to 'mrbgems') 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(-) (limited to 'mrbgems') 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(-) (limited to 'mrbgems') 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(-) (limited to 'mrbgems') 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 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 (limited to 'mrbgems') 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(-) (limited to 'mrbgems') 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 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 (limited to 'mrbgems') 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(+) (limited to 'mrbgems') 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(-) (limited to 'mrbgems') 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 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(-) (limited to 'mrbgems') 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(+) (limited to 'mrbgems') 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(+) (limited to 'mrbgems') 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(+) (limited to 'mrbgems') 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(+) (limited to 'mrbgems') 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 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(+) (limited to 'mrbgems') 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: 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(+) (limited to 'mrbgems') 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 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(-) (limited to 'mrbgems') 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(-) (limited to 'mrbgems') 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 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(-) (limited to 'mrbgems') 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 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(-) (limited to 'mrbgems') 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 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(-) (limited to 'mrbgems') 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: 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(+) (limited to 'mrbgems') 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(-) (limited to 'mrbgems') 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