From b6c71e4c68e336574e4bb29954545f31e8702df7 Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Tue, 12 Mar 2013 00:21:04 -0700 Subject: [PATCH 001/292] Initial commit --- README.md | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 000000000..e76cddb82 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +mruby-errno +=========== + +Errno module for mruby \ No newline at end of file From e56d53e354b6eda96427f13563199e7a076d7983 Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Wed, 13 Mar 2013 10:00:22 +0900 Subject: [PATCH 002/292] Errno module for mruby. --- README.md | 25 +- mrbgem.rake | 6 + src/errno.c | 163 +++++++++ src/gen.rb | 25 ++ src/known_errors.def | 145 ++++++++ src/known_errors_def.cstub | 725 +++++++++++++++++++++++++++++++++++++ src/known_errors_e2c.cstub | 435 ++++++++++++++++++++++ test/errno.rb | 60 +++ 8 files changed, 1583 insertions(+), 1 deletion(-) create mode 100644 mrbgem.rake create mode 100644 src/errno.c create mode 100755 src/gen.rb create mode 100644 src/known_errors.def create mode 100644 src/known_errors_def.cstub create mode 100644 src/known_errors_e2c.cstub create mode 100644 test/errno.rb diff --git a/README.md b/README.md index e76cddb82..e3c594cb5 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,27 @@ mruby-errno =========== -Errno module for mruby \ No newline at end of file +Errno module for mruby + + +## License + +Copyright (c) 2013 Internet Initiative Japan Inc. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/mrbgem.rake b/mrbgem.rake new file mode 100644 index 000000000..ba3d60dae --- /dev/null +++ b/mrbgem.rake @@ -0,0 +1,6 @@ +MRuby::Gem::Specification.new('mruby-errno') do |spec| + spec.license = 'MIT' + spec.authors = 'Internet Initiative Japan Inc.' + + spec.cc.include_paths << "#{build.root}/src" +end diff --git a/src/errno.c b/src/errno.c new file mode 100644 index 000000000..3c7d06693 --- /dev/null +++ b/src/errno.c @@ -0,0 +1,163 @@ +#include "mruby.h" +#include "mruby/array.h" +#include "mruby/class.h" +#include "mruby/hash.h" +#include "mruby/numeric.h" +#include "mruby/string.h" +#include "mruby/variable.h" +#include +#include +#include + +static mrb_value +mrb_sce_init(mrb_state *mrb, mrb_value self) +{ + mrb_value c, e2c, m, str; + mrb_int n; + int argc, no_errno = 0; + char buf[20]; + + argc = mrb_get_args(mrb, "o|i", &m, &n); + if (argc == 1) { + if (mrb_type(m) == MRB_TT_FIXNUM) { + n = mrb_fixnum(m); + m = mrb_nil_value(); + } else { + no_errno = 1; + } + } + if (!no_errno) { + e2c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Errno")), mrb_intern(mrb, "Errno2class")); + c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value()); + if (!mrb_nil_p(c)) { + mrb_basic(self)->c = mrb_class_ptr(c); + str = mrb_str_new2(mrb, strerror(n)); + } else { + mrb_iv_set(mrb, self, mrb_intern(mrb, "errno"), mrb_fixnum_value(n)); + str = mrb_str_new2(mrb, "Unknown error: "); + snprintf(buf, sizeof(buf), "%d", n); + mrb_str_cat2(mrb, str, buf); + } + } else { + str = mrb_str_new2(mrb, "unknown error"); + } + if (!mrb_nil_p(m)) { + mrb_str_cat2(mrb, str, " - "); + mrb_str_append(mrb, str, m); + } + mrb_iv_set(mrb, self, mrb_intern(mrb, "mesg"), str); + return self; +} + +static mrb_value +mrb_sce_errno(mrb_state *mrb, mrb_value self) +{ + mrb_sym sym; + mrb_value klass; + + klass = mrb_obj_value(mrb_class(mrb, self)); + sym = mrb_intern(mrb, "Errno"); + if (mrb_const_defined(mrb, klass, sym)) + return mrb_const_get(mrb, klass, sym); + else { + sym = mrb_intern(mrb, "errno"); + return mrb_attr_get(mrb, self, sym); + } +} + +static mrb_value +mrb_sce_to_s(mrb_state *mrb, mrb_value self) +{ + return mrb_attr_get(mrb, self, mrb_intern(mrb, "mesg")); +} + +static mrb_value +mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) +{ + struct RClass *cl, *sce; + mrb_value e, msg; + mrb_int no; + int argc; + char name[8]; + + sce = mrb_class_obj_get(mrb, "SystemCallError"); + argc = mrb_get_args(mrb, "i|S", &no, &msg); + if (argc == 1) { + e = mrb_funcall(mrb, mrb_obj_value(sce), "new", 1, mrb_fixnum_value(no)); + } else { + e = mrb_funcall(mrb, mrb_obj_value(sce), "new", 2, msg, mrb_fixnum_value(no)); + } + if (mrb_obj_class(mrb, e) == sce) { + snprintf(name, sizeof(name), "E%03ld", (long)no); + cl = mrb_define_class_under(mrb, mrb_class_get(mrb, "Errno"), name, sce); + mrb_define_const(mrb, cl, "Errno", mrb_fixnum_value(no)); + mrb_basic(e)->c = cl; + } + mrb_exc_raise(mrb, e); + return mrb_nil_value(); /* NOTREACHED */ +} + +static mrb_value +mrb_exxx_init(mrb_state *mrb, mrb_value self) +{ + mrb_value m, no, str; + + no = mrb_const_get(mrb, mrb_obj_value(mrb_class(mrb, self)), mrb_intern(mrb, "Errno")); + str = mrb_str_new2(mrb, strerror(mrb_fixnum(no))); + + m = mrb_nil_value(); + mrb_get_args(mrb, "|S", &m); + if (!mrb_nil_p(m)) { + mrb_str_cat2(mrb, str, " - "); + mrb_str_append(mrb, str, m); + } + mrb_iv_set(mrb, self, mrb_intern(mrb, "mesg"), str); + return self; +} + +void +mrb_mruby_errno_gem_init(mrb_state *mrb) +{ + struct RClass *e, *eno, *sce, *ste; + mrb_value h, noerror; + + ste = mrb_class_obj_get(mrb, "StandardError"); + + sce = mrb_define_class(mrb, "SystemCallError", ste); + mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, ARGS_REQ(1)); + mrb_define_method(mrb, sce, "errno", mrb_sce_errno, ARGS_NONE()); + mrb_define_method(mrb, sce, "to_s", mrb_sce_to_s, ARGS_NONE()); + mrb_define_method(mrb, sce, "initialize", mrb_sce_init, ARGS_REQ(1)|ARGS_OPT(1)); + + eno = mrb_define_module(mrb, "Errno"); + h = mrb_hash_new(mrb); + mrb_define_const(mrb, eno, "Errno2class", h); + + e = mrb_define_class_under(mrb, eno, "NOERROR", sce); + mrb_define_const(mrb, e, "Errno", mrb_fixnum_value(0)); + mrb_define_method(mrb, e, "initialize", mrb_exxx_init, ARGS_OPT(1)); + //mrb_define_method(mrb, e, "===", mrb_exxx_cmp, ARGS_REQ(1)); + noerror = mrb_obj_value(e); + +#define itsdefined(SYM) \ + do { \ + int ai = mrb_gc_arena_save(mrb); \ + e = mrb_define_class_under(mrb, eno, #SYM, sce); \ + mrb_define_const(mrb, e, "Errno", mrb_fixnum_value(SYM)); \ + mrb_define_method(mrb, e, "initialize", mrb_exxx_init, ARGS_OPT(1)); \ + mrb_hash_set(mrb, h, mrb_fixnum_value(SYM), mrb_obj_value(e)); \ + mrb_gc_arena_restore(mrb, ai); \ + } while (0) + +#define itsnotdefined(SYM) \ + do { \ + mrb_define_const(mrb, eno, #SYM, noerror); \ + } while (0) + +#include "known_errors_def.cstub" +} + +void +mrb_mruby_errno_gem_final(mrb_state *mrb) +{ +} diff --git a/src/gen.rb b/src/gen.rb new file mode 100755 index 000000000..12e6b302e --- /dev/null +++ b/src/gen.rb @@ -0,0 +1,25 @@ +#!/usr/bin/env ruby + +Dir.chdir(File.dirname($0)) + +e = File.open("known_errors_e2c.cstub", "w") +d = File.open("known_errors_def.cstub", "w") + +IO.readlines("known_errors.def").each { |name| + next if name =~ /^#/ + name.strip! + + e.write < Date: Tue, 9 Apr 2013 15:47:12 +0900 Subject: [PATCH 003/292] mrb_str_new2 -> mrb_str_new_cstr --- src/errno.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/errno.c b/src/errno.c index 3c7d06693..4fcfb2b29 100644 --- a/src/errno.c +++ b/src/errno.c @@ -31,15 +31,15 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value()); if (!mrb_nil_p(c)) { mrb_basic(self)->c = mrb_class_ptr(c); - str = mrb_str_new2(mrb, strerror(n)); + str = mrb_str_new_cstr(mrb, strerror(n)); } else { mrb_iv_set(mrb, self, mrb_intern(mrb, "errno"), mrb_fixnum_value(n)); - str = mrb_str_new2(mrb, "Unknown error: "); + str = mrb_str_new_cstr(mrb, "Unknown error: "); snprintf(buf, sizeof(buf), "%d", n); mrb_str_cat2(mrb, str, buf); } } else { - str = mrb_str_new2(mrb, "unknown error"); + str = mrb_str_new_cstr(mrb, "unknown error"); } if (!mrb_nil_p(m)) { mrb_str_cat2(mrb, str, " - "); @@ -103,7 +103,7 @@ mrb_exxx_init(mrb_state *mrb, mrb_value self) mrb_value m, no, str; no = mrb_const_get(mrb, mrb_obj_value(mrb_class(mrb, self)), mrb_intern(mrb, "Errno")); - str = mrb_str_new2(mrb, strerror(mrb_fixnum(no))); + str = mrb_str_new_cstr(mrb, strerror(mrb_fixnum(no))); m = mrb_nil_value(); mrb_get_args(mrb, "|S", &m); From 5903e2f3bff6900ec5a0b295d605dcc1e4c95812 Mon Sep 17 00:00:00 2001 From: Akira Yumiyama Date: Thu, 2 May 2013 23:56:52 +0900 Subject: [PATCH 004/292] rename mrb_class_obj_get -> mrb_class_get --- src/errno.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/errno.c b/src/errno.c index 4fcfb2b29..aea5db47d 100644 --- a/src/errno.c +++ b/src/errno.c @@ -80,7 +80,7 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) int argc; char name[8]; - sce = mrb_class_obj_get(mrb, "SystemCallError"); + sce = mrb_class_get(mrb, "SystemCallError"); argc = mrb_get_args(mrb, "i|S", &no, &msg); if (argc == 1) { e = mrb_funcall(mrb, mrb_obj_value(sce), "new", 1, mrb_fixnum_value(no)); @@ -121,7 +121,7 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) struct RClass *e, *eno, *sce, *ste; mrb_value h, noerror; - ste = mrb_class_obj_get(mrb, "StandardError"); + ste = mrb_class_get(mrb, "StandardError"); sce = mrb_define_class(mrb, "SystemCallError", ste); mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, ARGS_REQ(1)); From 838e4f975dea38a1493cba601be7bba83e64da15 Mon Sep 17 00:00:00 2001 From: Akira Yumiyama Date: Thu, 2 May 2013 23:57:20 +0900 Subject: [PATCH 005/292] add run_test.rb, .gitignore --- .gitignore | 1 + run_test.rb | 26 ++++++++++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 .gitignore create mode 100644 run_test.rb diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..ceeb05b41 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/tmp diff --git a/run_test.rb b/run_test.rb new file mode 100644 index 000000000..d9566a2a6 --- /dev/null +++ b/run_test.rb @@ -0,0 +1,26 @@ +#!/usr/bin/env ruby +# +# mrbgems test runner +# + +gemname = File.basename(File.dirname(File.expand_path __FILE__)) + +if __FILE__ == $0 + repository, dir = 'https://github.com/mruby/mruby.git', 'tmp/mruby' + build_args = ARGV + build_args = ['all', 'test'] if build_args.nil? or build_args.empty? + + Dir.mkdir 'tmp' unless File.exist?('tmp') + unless File.exist?(dir) + system "git clone #{repository} #{dir}" + end + + exit system(%Q[cd #{dir}; MRUBY_CONFIG=#{File.expand_path __FILE__} ruby minirake #{build_args.join(' ')}]) +end + +MRuby::Build.new do |conf| + toolchain :gcc + conf.gembox 'default' + + conf.gem File.expand_path(File.dirname(__FILE__)) +end From 487ab66ea0e88d8156ee57eee8f6738db8d529a6 Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Wed, 21 Aug 2013 09:23:56 +0900 Subject: [PATCH 006/292] ARGS_XXX macros was renamed to MRG_ARGS_XXX. --- src/errno.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/errno.c b/src/errno.c index aea5db47d..17bb460c9 100644 --- a/src/errno.c +++ b/src/errno.c @@ -124,10 +124,10 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) ste = mrb_class_get(mrb, "StandardError"); sce = mrb_define_class(mrb, "SystemCallError", ste); - mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, ARGS_REQ(1)); - mrb_define_method(mrb, sce, "errno", mrb_sce_errno, ARGS_NONE()); - mrb_define_method(mrb, sce, "to_s", mrb_sce_to_s, ARGS_NONE()); - mrb_define_method(mrb, sce, "initialize", mrb_sce_init, ARGS_REQ(1)|ARGS_OPT(1)); + mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, sce, "errno", mrb_sce_errno, MRB_ARGS_NONE()); + mrb_define_method(mrb, sce, "to_s", mrb_sce_to_s, MRB_ARGS_NONE()); + mrb_define_method(mrb, sce, "initialize", mrb_sce_init, MRB_ARGS_ARG(1, 1)); eno = mrb_define_module(mrb, "Errno"); h = mrb_hash_new(mrb); @@ -135,8 +135,8 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) e = mrb_define_class_under(mrb, eno, "NOERROR", sce); mrb_define_const(mrb, e, "Errno", mrb_fixnum_value(0)); - mrb_define_method(mrb, e, "initialize", mrb_exxx_init, ARGS_OPT(1)); - //mrb_define_method(mrb, e, "===", mrb_exxx_cmp, ARGS_REQ(1)); + mrb_define_method(mrb, e, "initialize", mrb_exxx_init, MRB_ARGS_OPT(1)); + //mrb_define_method(mrb, e, "===", mrb_exxx_cmp, MRB_ARGS_REQ(1)); noerror = mrb_obj_value(e); #define itsdefined(SYM) \ @@ -144,7 +144,7 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) int ai = mrb_gc_arena_save(mrb); \ e = mrb_define_class_under(mrb, eno, #SYM, sce); \ mrb_define_const(mrb, e, "Errno", mrb_fixnum_value(SYM)); \ - mrb_define_method(mrb, e, "initialize", mrb_exxx_init, ARGS_OPT(1)); \ + mrb_define_method(mrb, e, "initialize", mrb_exxx_init, MRB_ARGS_OPT(1)); \ mrb_hash_set(mrb, h, mrb_fixnum_value(SYM), mrb_obj_value(e)); \ mrb_gc_arena_restore(mrb, ai); \ } while (0) From 09d51f46a7a73a8f8de57453363ad6d2f1c3b2a0 Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Tue, 3 Dec 2013 10:06:32 +0900 Subject: [PATCH 007/292] mrb_intern API change. --- src/errno.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/errno.c b/src/errno.c index 17bb460c9..56bd20333 100644 --- a/src/errno.c +++ b/src/errno.c @@ -27,13 +27,13 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) } } if (!no_errno) { - e2c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Errno")), mrb_intern(mrb, "Errno2class")); + e2c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Errno")), mrb_intern_lit(mrb, "Errno2class")); c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value()); if (!mrb_nil_p(c)) { mrb_basic(self)->c = mrb_class_ptr(c); str = mrb_str_new_cstr(mrb, strerror(n)); } else { - mrb_iv_set(mrb, self, mrb_intern(mrb, "errno"), mrb_fixnum_value(n)); + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "errno"), mrb_fixnum_value(n)); str = mrb_str_new_cstr(mrb, "Unknown error: "); snprintf(buf, sizeof(buf), "%d", n); mrb_str_cat2(mrb, str, buf); @@ -45,7 +45,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) mrb_str_cat2(mrb, str, " - "); mrb_str_append(mrb, str, m); } - mrb_iv_set(mrb, self, mrb_intern(mrb, "mesg"), str); + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "mesg"), str); return self; } @@ -56,11 +56,11 @@ mrb_sce_errno(mrb_state *mrb, mrb_value self) mrb_value klass; klass = mrb_obj_value(mrb_class(mrb, self)); - sym = mrb_intern(mrb, "Errno"); + sym = mrb_intern_lit(mrb, "Errno"); if (mrb_const_defined(mrb, klass, sym)) return mrb_const_get(mrb, klass, sym); else { - sym = mrb_intern(mrb, "errno"); + sym = mrb_intern_lit(mrb, "errno"); return mrb_attr_get(mrb, self, sym); } } @@ -68,7 +68,7 @@ mrb_sce_errno(mrb_state *mrb, mrb_value self) static mrb_value mrb_sce_to_s(mrb_state *mrb, mrb_value self) { - return mrb_attr_get(mrb, self, mrb_intern(mrb, "mesg")); + return mrb_attr_get(mrb, self, mrb_intern_lit(mrb, "mesg")); } static mrb_value @@ -102,7 +102,7 @@ mrb_exxx_init(mrb_state *mrb, mrb_value self) { mrb_value m, no, str; - no = mrb_const_get(mrb, mrb_obj_value(mrb_class(mrb, self)), mrb_intern(mrb, "Errno")); + no = mrb_const_get(mrb, mrb_obj_value(mrb_class(mrb, self)), mrb_intern_lit(mrb, "Errno")); str = mrb_str_new_cstr(mrb, strerror(mrb_fixnum(no))); m = mrb_nil_value(); @@ -111,7 +111,7 @@ mrb_exxx_init(mrb_state *mrb, mrb_value self) mrb_str_cat2(mrb, str, " - "); mrb_str_append(mrb, str, m); } - mrb_iv_set(mrb, self, mrb_intern(mrb, "mesg"), str); + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "mesg"), str); return self; } From c0abfaf69d91abcb798311ea490dec7109603a46 Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Thu, 13 Feb 2014 16:32:52 +0900 Subject: [PATCH 008/292] catch up with mrb_class_get API change. --- src/errno.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/errno.c b/src/errno.c index 56bd20333..bdaedf2dc 100644 --- a/src/errno.c +++ b/src/errno.c @@ -9,6 +9,14 @@ #include #include +#if MRUBY_RELEASE_NO < 10000 +static struct RClass * +mrb_module_get(mrb_state *mrb, const char *name) +{ + return mrb_class_get(mrb, name); +} +#endif + static mrb_value mrb_sce_init(mrb_state *mrb, mrb_value self) { @@ -27,7 +35,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) } } if (!no_errno) { - e2c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Errno")), mrb_intern_lit(mrb, "Errno2class")); + e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get(mrb, "Errno")), mrb_intern_lit(mrb, "Errno2class")); c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value()); if (!mrb_nil_p(c)) { mrb_basic(self)->c = mrb_class_ptr(c); @@ -89,7 +97,7 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) } if (mrb_obj_class(mrb, e) == sce) { snprintf(name, sizeof(name), "E%03ld", (long)no); - cl = mrb_define_class_under(mrb, mrb_class_get(mrb, "Errno"), name, sce); + cl = mrb_define_class_under(mrb, mrb_module_get(mrb, "Errno"), name, sce); mrb_define_const(mrb, cl, "Errno", mrb_fixnum_value(no)); mrb_basic(e)->c = cl; } From 06b4dd56a4f35d4f78a4d244b53da18851d53e05 Mon Sep 17 00:00:00 2001 From: Akira Yumiyama Date: Fri, 4 Apr 2014 11:24:52 +0900 Subject: [PATCH 009/292] Create .travis.yml --- .travis.yml | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .travis.yml diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 000000000..09fa3368f --- /dev/null +++ b/.travis.yml @@ -0,0 +1,2 @@ +script: + - "ruby run_test.rb" From 536e83614dd250024572e2cea8bbb48a67d62717 Mon Sep 17 00:00:00 2001 From: Akira Yumiyama Date: Fri, 4 Apr 2014 11:31:28 +0900 Subject: [PATCH 010/292] Update .travis.yml --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 09fa3368f..ffe227284 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,2 +1,2 @@ script: - - "ruby run_test.rb" + - "ruby run_test.rb all test" From baba54fb4950252d04f4ab7d6169f21b104261ef Mon Sep 17 00:00:00 2001 From: cremno Date: Fri, 29 Aug 2014 16:41:11 +0200 Subject: [PATCH 011/292] use mrb_basic_ptr instead of obsolete mrb_basic --- src/errno.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/errno.c b/src/errno.c index bdaedf2dc..9524bb52f 100644 --- a/src/errno.c +++ b/src/errno.c @@ -38,7 +38,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get(mrb, "Errno")), mrb_intern_lit(mrb, "Errno2class")); c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value()); if (!mrb_nil_p(c)) { - mrb_basic(self)->c = mrb_class_ptr(c); + mrb_basic_ptr(self)->c = mrb_class_ptr(c); str = mrb_str_new_cstr(mrb, strerror(n)); } else { mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "errno"), mrb_fixnum_value(n)); @@ -99,7 +99,7 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) snprintf(name, sizeof(name), "E%03ld", (long)no); cl = mrb_define_class_under(mrb, mrb_module_get(mrb, "Errno"), name, sce); mrb_define_const(mrb, cl, "Errno", mrb_fixnum_value(no)); - mrb_basic(e)->c = cl; + mrb_basic_ptr(e)->c = cl; } mrb_exc_raise(mrb, e); return mrb_nil_value(); /* NOTREACHED */ From f7a0946452dd5c65aa2dae01999c1dd349dabf1d Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Fri, 19 Sep 2014 13:22:56 +0900 Subject: [PATCH 012/292] mrb_const_defined returns true if it is defined on a super class. --- src/errno.c | 10 +++++----- test/errno.rb | 8 ++++---- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/errno.c b/src/errno.c index 9524bb52f..06737ac03 100644 --- a/src/errno.c +++ b/src/errno.c @@ -60,14 +60,14 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) static mrb_value mrb_sce_errno(mrb_state *mrb, mrb_value self) { + struct RClass *c; mrb_sym sym; - mrb_value klass; - klass = mrb_obj_value(mrb_class(mrb, self)); + c = mrb_class(mrb, self); sym = mrb_intern_lit(mrb, "Errno"); - if (mrb_const_defined(mrb, klass, sym)) - return mrb_const_get(mrb, klass, sym); - else { + if (mrb_const_defined_at(mrb, c, sym)) { + return mrb_const_get(mrb, mrb_obj_value(c), sym); + } else { sym = mrb_intern_lit(mrb, "errno"); return mrb_attr_get(mrb, self, sym); } diff --git a/test/errno.rb b/test/errno.rb index 29def4d52..790311566 100644 --- a/test/errno.rb +++ b/test/errno.rb @@ -17,10 +17,10 @@ assert('SystemCallError#initialize') do end assert('SystemCallError#errno') do - SystemCallError.new("a", 1).errno == 1 and - SystemCallError.new(1).errno == 1 and - SystemCallError.new("a", 12345).errno == 12345 and - SystemCallError.new(23456).errno == 23456 + assert_equal 1, SystemCallError.new("a", 1).errno + assert_equal 1, SystemCallError.new(1).errno + assert_equal 12345, SystemCallError.new("a", 12345).errno + assert_equal 23456, SystemCallError.new(23456).errno end assert('SystemCallError#inspect') do From dfb471b40b9b5ef2e799813d1df2b4342c62d247 Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Fri, 19 Sep 2014 13:49:39 +0900 Subject: [PATCH 013/292] type of 2nd argument was changed. --- src/errno.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/errno.c b/src/errno.c index 06737ac03..ffea51162 100644 --- a/src/errno.c +++ b/src/errno.c @@ -65,7 +65,11 @@ mrb_sce_errno(mrb_state *mrb, mrb_value self) c = mrb_class(mrb, self); sym = mrb_intern_lit(mrb, "Errno"); +#if MRUBY_RELEASE_NO < 10000 if (mrb_const_defined_at(mrb, c, sym)) { +#else + if (mrb_const_defined_at(mrb, mrb_obj_value(c), sym)) { +#endif return mrb_const_get(mrb, mrb_obj_value(c), sym); } else { sym = mrb_intern_lit(mrb, "errno"); From b14df08be689cf8b94a046fd6f4154566523b19a Mon Sep 17 00:00:00 2001 From: Kazuho Oku Date: Wed, 6 Jan 2016 12:10:21 +0900 Subject: [PATCH 014/292] cast `mrb_int` to `int` before applying sprintf "%d" --- src/errno.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/errno.c b/src/errno.c index ffea51162..3617efd45 100644 --- a/src/errno.c +++ b/src/errno.c @@ -43,7 +43,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) } else { mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "errno"), mrb_fixnum_value(n)); str = mrb_str_new_cstr(mrb, "Unknown error: "); - snprintf(buf, sizeof(buf), "%d", n); + snprintf(buf, sizeof(buf), "%d", (int)n); mrb_str_cat2(mrb, str, buf); } } else { From 9f012724fbfdf4f579947ff50ab0dd11f90f4f2f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 12 Jan 2022 12:44:23 +0900 Subject: [PATCH 015/292] vm.c: need to adjust argument after packing keyword args; fix #5632 It was caused by #5628. --- src/vm.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/vm.c b/src/vm.c index 698f59d0e..b0cd9428d 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1729,6 +1729,7 @@ RETRY_TRY_BLOCK: } mrb_assert(bidx < irep->nregs); + blk = regs[bidx]; uint8_t nk = (b >> 4) & 0x0f; if (nk > 0 && nk < CALL_MAXARGS) { /* pack keyword arguments */ uint8_t n = b & 0x0f; @@ -1737,6 +1738,8 @@ RETRY_TRY_BLOCK: regs[kidx] = kdict; nk = 15; b = n | (nk<<4); + bidx = kidx + 1; + regs[bidx] = blk; } if (mid == 0 || !target_class) { @@ -1761,7 +1764,6 @@ RETRY_TRY_BLOCK: mrb_exc_set(mrb, exc); goto L_RAISE; } - blk = regs[bidx]; if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) { blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); /* The stack or ci stack might have been reallocated during From 8f09d8feb4e0f5813a6d9d03cf69839e3db39f7b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 13 Jan 2022 15:40:09 +0900 Subject: [PATCH 016/292] time.c: check year range before creating Time object. --- mrbgems/mruby-time/src/time.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 6b9762acf..aa80150b4 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -459,7 +459,7 @@ time_mktime(mrb_state *mrb, mrb_int ayear, mrb_int amonth, mrb_int aday, #define OUTINT(x) 0 #endif - if (OUTINT(ayear-1900) || + if (ayear < 1900 || OUTINT(ayear-1900) || amonth < 1 || amonth > 12 || aday < 1 || aday > 31 || ahour < 0 || ahour > 24 || From 171d32c0071d776207174a40a8fa26def3dbb931 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 14 Jan 2022 11:40:51 +0900 Subject: [PATCH 017/292] time.c: `1969-12-31 23:59:59` is a valid time. But `mktime(3)` for the date returns `-1` which happen to be the error value. --- mrbgems/mruby-time/src/time.c | 12 +++++++++++- mrbgems/mruby-time/test/time.rb | 4 ---- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index aa80150b4..7e568d572 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -483,7 +483,17 @@ time_mktime(mrb_state *mrb, mrb_int ayear, mrb_int amonth, mrb_int aday, nowsecs = mktime(&nowtime); } if (nowsecs == (time_t)-1) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "Not a valid time"); + nowtime.tm_sec += 1; + if (timezone == MRB_TIMEZONE_UTC) { + nowsecs = timegm(&nowtime); + } + else { + nowsecs = mktime(&nowtime); + } + if (nowsecs != 0) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "Not a valid time"); + } + nowsecs = (time_t)-1; } return time_alloc_time(mrb, nowsecs, ausec, timezone); diff --git a/mrbgems/mruby-time/test/time.rb b/mrbgems/mruby-time/test/time.rb index e239dec28..2c3a354f4 100644 --- a/mrbgems/mruby-time/test/time.rb +++ b/mrbgems/mruby-time/test/time.rb @@ -267,7 +267,3 @@ assert('2000 times 500us make a second') do end assert_equal(0, t.usec) end - -assert('Time.gm with Dec 31 23:59:59 1969 raise ArgumentError') do - assert_raise(ArgumentError) {Time.gm(1969, 12, 31, 23, 59, 59)} -end From 475b868b7236fd8e8824618e8724b587f08fbe9d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 15 Jan 2022 18:24:39 +0900 Subject: [PATCH 018/292] time.c: remove duplicated UTC condition check. --- mrbgems/mruby-time/src/time.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 7e568d572..664ee8ed5 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -476,24 +476,21 @@ time_mktime(mrb_state *mrb, mrb_int ayear, mrb_int amonth, mrb_int aday, nowtime.tm_sec = (int)asec; nowtime.tm_isdst = -1; + time_t (*mk)(struct tm*); if (timezone == MRB_TIMEZONE_UTC) { - nowsecs = timegm(&nowtime); + mk = timegm; } else { - nowsecs = mktime(&nowtime); + mk = mktime; } + nowsecs = (*mk)(&nowtime); if (nowsecs == (time_t)-1) { - nowtime.tm_sec += 1; - if (timezone == MRB_TIMEZONE_UTC) { - nowsecs = timegm(&nowtime); - } - else { - nowsecs = mktime(&nowtime); - } - if (nowsecs != 0) { + nowtime.tm_sec += 1; /* maybe Epoch-1 sec */ + nowsecs = (*mk)(&nowtime); + if (nowsecs != 0) { /* check if Epoch */ mrb_raise(mrb, E_ARGUMENT_ERROR, "Not a valid time"); } - nowsecs = (time_t)-1; + nowsecs = (time_t)-1; /* valid Epoch-1 */ } return time_alloc_time(mrb, nowsecs, ausec, timezone); From 31fa3304049fc406a201a72293cce140f0557dca Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 16 Jan 2022 22:22:46 +0900 Subject: [PATCH 019/292] class.c: add `obj->c` check before `prepare_singleton_class()`. --- src/class.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/class.c b/src/class.c index ec9c648e5..8751dcaf0 100644 --- a/src/class.c +++ b/src/class.c @@ -357,6 +357,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o) { struct RClass *sc, *c; + mrb_assert(o->c); if (o->c->tt == MRB_TT_SCLASS) return; sc = MRB_OBJ_ALLOC(mrb, MRB_TT_SCLASS, mrb->class_class); sc->flags |= MRB_FL_CLASS_IS_INHERITED; @@ -1682,6 +1683,7 @@ mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v) break; } obj = mrb_basic_ptr(v); + if (obj->c == NULL) return NULL; prepare_singleton_class(mrb, obj); return obj->c; } From fb9bba34fbdcff1a471e0fa2b6994d044a4e2fef Mon Sep 17 00:00:00 2001 From: HASUMI Hitoshi Date: Mon, 17 Jan 2022 22:36:41 +0900 Subject: [PATCH 020/292] Fix tree of mruby-bin-example --- doc/guides/mrbgems.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/guides/mrbgems.md b/doc/guides/mrbgems.md index 03f8829e1..7649f40d2 100644 --- a/doc/guides/mrbgems.md +++ b/doc/guides/mrbgems.md @@ -397,21 +397,21 @@ binary gems, to separate normal gems and binary gems. ``` +- mruby-bin-example/ | - +- README.md (Optional) + +- README.md (Optional) | +- bintest/ | | - | +- example.rb <- Test code for binary gem + | +- example.rb <- Test code for binary gem | - +- mrbgem.rake <- Gem specification + +- mrbgem.rake <- Gem specification | - +- mrblib/ <- Source for Ruby extension (Optional) + +- mrblib/ <- Source for Ruby extension (Optional) | - +- src/ <- Source for C extension (Optional) + +- src/ <- Source for C extension (Optional) | +- tools/ | - +- example/ <- Executable name directory - | - +- example.c <- Source for Executable (includes main) + +- example/ <- Executable name directory + | + +- example.c <- Source for Executable (includes main) ``` From ef98eb2c29650b786dd2a25f0bb6345b947c26eb Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 18 Jan 2022 23:42:06 +0900 Subject: [PATCH 021/292] codegen.c: fix evaluation order of constant initialization. `a::B = c` should evaluate `a` then `c`. It used to be `c` then `a`. The `OP_SETMCNST` instruction operands are designed for older order in mind. Should we changed the operand order? --- mrbgems/mruby-compiler/core/codegen.c | 79 +++++++++++++++++++-------- 1 file changed, 55 insertions(+), 24 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 3504e6062..7b8e55bb8 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -101,8 +101,8 @@ static void loop_pop(codegen_scope *s, int val); static int catch_handler_new(codegen_scope *s); static void catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target); -static void gen_assignment(codegen_scope *s, node *tree, int sp, int val); -static void gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val); +static void gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val); +static void gen_vmassignment(codegen_scope *s, node *tree, int sp, int val); static void codegen(codegen_scope *s, node *tree, int val); static void raise_error(codegen_scope *s, const char *msg); @@ -1275,7 +1275,7 @@ for_body(codegen_scope *s, node *tree) n2 = tree->car; genop_W(s, OP_ENTER, 0x40000); if (n2->car && !n2->car->cdr && !n2->cdr) { - gen_assignment(s, n2->car->car, 1, NOVAL); + gen_assignment(s, n2->car->car, NULL, 1, NOVAL); } else { gen_vmassignment(s, n2, 1, VAL); @@ -1774,11 +1774,42 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe) } static void -gen_assignment(codegen_scope *s, node *tree, int sp, int val) +gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) { int idx; int type = nint(tree->car); + switch (type) { + case NODE_GVAR: + case NODE_ARG: + case NODE_LVAR: + case NODE_IVAR: + case NODE_CVAR: + case NODE_CONST: + case NODE_NIL: + case NODE_MASGN: + case NODE_SCALL: + case NODE_CALL: + if (rhs) { + codegen(s, rhs, VAL); + pop(); + sp = cursp(); + } + break; + + case NODE_COLON2: + /* keep evaluation order */ + break; + + case NODE_NVAR: + codegen_error(s, "Can't assign to numbered parameter"); + break; + + default: + codegen_error(s, "unknown lhs"); + break; + } + tree = tree->cdr; switch (type) { case NODE_GVAR: @@ -1797,10 +1828,6 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val) gen_setupvar(s, sp, nsym(tree)); } break; - case NODE_NVAR: - idx = nint(tree); - codegen_error(s, "Can't assign to numbered parameter"); - break; case NODE_IVAR: gen_setxv(s, OP_SETIV, sp, nsym(tree), val); break; @@ -1811,9 +1838,16 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val) gen_setxv(s, OP_SETCONST, sp, nsym(tree), val); break; case NODE_COLON2: - gen_move(s, cursp(), sp, 0); + if (sp) { + gen_move(s, cursp(), sp, 0); + } + sp = cursp(); push(); codegen(s, tree->car, VAL); + if (rhs) { + codegen(s, rhs, VAL); pop(); + gen_move(s, sp, cursp(), 0); + } pop_n(2); idx = new_sym(s, nsym(tree->cdr)); genop_2(s, OP_SETMCNST, sp, idx); @@ -1822,8 +1856,7 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val) case NODE_CALL: case NODE_SCALL: push(); - gen_call(s, tree, attrsym(s, nsym(tree->cdr->car)), sp, NOVAL, - type == NODE_SCALL); + gen_call(s, tree, attrsym(s, nsym(tree->cdr->car)), sp, NOVAL, type == NODE_SCALL); pop(); if (val && cursp() != sp) { gen_move(s, cursp(), sp, 0); @@ -1859,7 +1892,7 @@ gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val) genop_3(s, OP_AREF, sp, rhs, n); push(); - gen_assignment(s, t->car, sp, NOVAL); + gen_assignment(s, t->car, NULL, sp, NOVAL); pop(); n++; t = t->cdr; @@ -1880,12 +1913,12 @@ gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val) genop_3(s, OP_APOST, cursp(), n, post); n = 1; if (t->car && t->car != (node*)-1) { /* rest */ - gen_assignment(s, t->car, cursp(), NOVAL); + gen_assignment(s, t->car, NULL, cursp(), NOVAL); } if (t->cdr && t->cdr->car) { t = t->cdr->car; while (t) { - gen_assignment(s, t->car, cursp()+n, NOVAL); + gen_assignment(s, t->car, NULL, cursp()+n, NOVAL); t = t->cdr; n++; } @@ -2205,7 +2238,7 @@ codegen(codegen_scope *s, node *tree, int val) pop(); if (n3->cdr->car) { - gen_assignment(s, n3->cdr->car, exc, NOVAL); + gen_assignment(s, n3->cdr->car, NULL, exc, NOVAL); } if (n3->cdr->cdr->car) { codegen(s, n3->cdr->cdr->car, val); @@ -2589,9 +2622,7 @@ codegen(codegen_scope *s, node *tree, int val) break; case NODE_ASGN: - codegen(s, tree->cdr, VAL); - pop(); - gen_assignment(s, tree->car, cursp(), val); + gen_assignment(s, tree->car, tree->cdr, 0, val); break; case NODE_MASGN: @@ -2614,12 +2645,12 @@ codegen(codegen_scope *s, node *tree, int val) n = 0; while (t) { if (n < len) { - gen_assignment(s, t->car, rhs+n, NOVAL); + gen_assignment(s, t->car, NULL, rhs+n, NOVAL); n++; } else { genop_1(s, OP_LOADNIL, rhs+n); - gen_assignment(s, t->car, rhs+n, NOVAL); + gen_assignment(s, t->car, NULL, rhs+n, NOVAL); } t = t->cdr; } @@ -2643,13 +2674,13 @@ codegen(codegen_scope *s, node *tree, int val) rn = len - post - n; } genop_3(s, OP_ARRAY2, cursp(), rhs+n, rn); - gen_assignment(s, t->car, cursp(), NOVAL); + gen_assignment(s, t->car, NULL, cursp(), NOVAL); n += rn; } if (t->cdr && t->cdr->car) { t = t->cdr->car; while (ncar, rhs+n, NOVAL); + gen_assignment(s, t->car, NULL, rhs+n, NOVAL); t = t->cdr; n++; } @@ -2770,7 +2801,7 @@ codegen(codegen_scope *s, node *tree, int val) genop_3(s, OP_SEND, cursp(), idx, callargs); } else { - gen_assignment(s, tree->car, cursp(), val); + gen_assignment(s, tree->car, NULL, cursp(), val); } dispatch(s, pos); goto exit; @@ -2808,7 +2839,7 @@ codegen(codegen_scope *s, node *tree, int val) genop_3(s, OP_SEND, cursp(), idx, 1); } if (callargs < 0) { - gen_assignment(s, tree->car, cursp(), val); + gen_assignment(s, tree->car, NULL, cursp(), val); } else { if (val && vsp >= 0) { From f8944792be9e9739cbd8286ccd8814bbe93ed582 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 19 Jan 2022 22:52:38 +0900 Subject: [PATCH 022/292] parse.y: consistent argument `pass` for `new_call()`. --- mrbgems/mruby-compiler/core/parse.y | 8 ++++---- mrbgems/mruby-compiler/core/y.tab.c | 27 ++++++++++++++------------- 2 files changed, 18 insertions(+), 17 deletions(-) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 71cdddf68..7c063609e 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -994,13 +994,13 @@ static node* new_imaginary(parser_state *p, node *imaginary) { return new_call(p, new_const(p, MRB_SYM_2(p->mrb, Kernel)), MRB_SYM_2(p->mrb, Complex), - new_callargs(p, list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary), 0, 0), 1); + new_callargs(p, list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary), 0, 0), '.'); } static node* new_rational(parser_state *p, node *rational) { - return new_call(p, new_const(p, MRB_SYM_2(p->mrb, Kernel)), MRB_SYM_2(p->mrb, Rational), new_callargs(p, list1(rational), 0, 0), 1); + return new_call(p, new_const(p, MRB_SYM_2(p->mrb, Kernel)), MRB_SYM_2(p->mrb, Rational), new_callargs(p, list1(rational), 0, 0), '.'); } /* (:int . i) */ @@ -1216,14 +1216,14 @@ static node* call_uni_op(parser_state *p, node *recv, const char *m) { void_expr_error(p, recv); - return new_call(p, recv, intern_cstr(m), 0, 1); + return new_call(p, recv, intern_cstr(m), 0, '.'); } /* (:call a op b) */ static node* call_bin_op(parser_state *p, node *recv, const char *m, node *arg1) { - return new_call(p, recv, intern_cstr(m), new_callargs(p, list1(arg1), 0, 0), 1); + return new_call(p, recv, intern_cstr(m), new_callargs(p, list1(arg1), 0, 0), '.'); } static void diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index d4ef4b618..d4a6b6363 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -1057,13 +1057,13 @@ static node* new_imaginary(parser_state *p, node *imaginary) { return new_call(p, new_const(p, MRB_SYM_2(p->mrb, Kernel)), MRB_SYM_2(p->mrb, Complex), - new_callargs(p, list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary), 0, 0), 1); + new_callargs(p, list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary), 0, 0), '.'); } static node* new_rational(parser_state *p, node *rational) { - return new_call(p, new_const(p, MRB_SYM_2(p->mrb, Kernel)), MRB_SYM_2(p->mrb, Rational), new_callargs(p, list1(rational), 0, 0), 1); + return new_call(p, new_const(p, MRB_SYM_2(p->mrb, Kernel)), MRB_SYM_2(p->mrb, Rational), new_callargs(p, list1(rational), 0, 0), '.'); } /* (:int . i) */ @@ -1279,14 +1279,14 @@ static node* call_uni_op(parser_state *p, node *recv, const char *m) { void_expr_error(p, recv); - return new_call(p, recv, intern_cstr(m), 0, 1); + return new_call(p, recv, intern_cstr(m), 0, '.'); } /* (:call a op b) */ static node* call_bin_op(parser_state *p, node *recv, const char *m, node *arg1) { - return new_call(p, recv, intern_cstr(m), new_callargs(p, list1(arg1), 0, 0), 1); + return new_call(p, recv, intern_cstr(m), new_callargs(p, list1(arg1), 0, 0), '.'); } static void @@ -12649,16 +12649,17 @@ parser_yylex(parser_state *p) nvars = nvars->cdr; } nvar = intn(p->nvars->car); - if (nvar == -1) { - yywarning(p, "numbered parameter used in inner block"); + if (nvar != -2) { /* numbered parameters never appear on toplevel */ + if (nvar == -1) { + yywarning(p, "numbered parameter used in inner block"); + } + else { + p->nvars->car = nint(nvar > n ? nvar : n); + } + pylval.num = n; + p->lstate = EXPR_END; + return tNUMPARAM; } - else { - int nvars = intn(p->nvars->car); - p->nvars->car = nint(nvars > n ? nvars : n); - } - pylval.num = n; - p->lstate = EXPR_END; - return tNUMPARAM; } } /* fall through */ From b53cd3ce255f43164cae87f2abbd4f573676cbab Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 20 Jan 2022 20:09:36 +0900 Subject: [PATCH 023/292] codegen.c: fix evaluation order of attribute assignment. --- mrbgems/mruby-compiler/core/codegen.c | 74 ++++++++++++++++++++++++--- 1 file changed, 67 insertions(+), 7 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 7b8e55bb8..c36178c8b 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1788,8 +1788,6 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) case NODE_CONST: case NODE_NIL: case NODE_MASGN: - case NODE_SCALL: - case NODE_CALL: if (rhs) { codegen(s, rhs, VAL); pop(); @@ -1798,6 +1796,8 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) break; case NODE_COLON2: + case NODE_CALL: + case NODE_SCALL: /* keep evaluation order */ break; @@ -1855,11 +1855,71 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) case NODE_CALL: case NODE_SCALL: - push(); - gen_call(s, tree, attrsym(s, nsym(tree->cdr->car)), sp, NOVAL, type == NODE_SCALL); - pop(); - if (val && cursp() != sp) { - gen_move(s, cursp(), sp, 0); + { + int noself = 0, safe = (type == NODE_SCALL), skip = 0, top, call, n = 0; + mrb_sym mid = nsym(tree->cdr->car); + + top = cursp(); + if (val || sp == cursp()) { + push(); /* room for retval */ + } + call = cursp(); + if (!tree->car) { + noself = 1; + push(); + } + else { + codegen(s, tree->car, VAL); /* receiver */ + } + if (safe) { + int recv = cursp()-1; + gen_move(s, cursp(), recv, 1); + skip = genjmp2_0(s, OP_JMPNIL, cursp(), val); + } + tree = tree->cdr->cdr->car; + if (tree) { + if (tree->car) { /* positional arguments */ + n = gen_values(s, tree->car, VAL, 0, (tree->cdr->car)?13:14); + if (n < 0) { /* variable length */ + n = 15; + push(); + } + } + if (tree->cdr->car) { /* keyword arguments */ + gen_hash(s, tree->cdr->car->cdr, VAL, 0); + if (n < 14) { + n++; + push(); + } + else { + pop(); + genop_2(s, OP_ARYPUSH, cursp(), 1); + } + } + } + if (rhs) { + codegen(s, rhs, VAL); + pop(); + } + else { + gen_move(s, cursp(), sp, 0); + } + if (val) { + gen_move(s, top, cursp(), 1); + } + if (n < 14) { + n++; + } + else { + pop(); + genop_2(s, OP_ARYPUSH, cursp(), 1); + } + s->sp = call; + genop_3(s, noself ? OP_SSEND : OP_SEND, cursp(), new_sym(s, attrsym(s, mid)), n); + if (safe) { + dispatch(s, skip); + } + s->sp = top; } break; From ebb5287e29796e53d5eb9dac3153940e7e8f3237 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 21 Jan 2022 10:39:37 +0900 Subject: [PATCH 024/292] codedump.c: omit raw `c` operand for `OP_SEND` etc. --- src/codedump.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/codedump.c b/src/codedump.c index 5d763fa37..62b2fbd63 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -78,7 +78,7 @@ print_args(uint8_t i) printf("nk=%d", nk); } } - printf(" (0x%02x)\n", i); + printf("\n"); } #define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn From adb16fc6dfc27a39b783782e3a12d877e71c78ac Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 21 Jan 2022 10:51:07 +0900 Subject: [PATCH 025/292] codegen.c: adjust indentation after `OP_STRCAT`. --- src/codedump.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/codedump.c b/src/codedump.c index 62b2fbd63..20397907e 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -503,7 +503,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_STRCAT, B): - printf("STRCAT\tR%d\tR%d", a, a+1); + printf("STRCAT\tR%d\tR%d\t", a, a+1); print_lv_a(mrb, irep, a); break; CASE(OP_HASH, BB): From b611c43a5de061ec21b343967e1b64c45c373d7e Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 21 Jan 2022 15:42:51 +0900 Subject: [PATCH 026/292] codegen.c: no `OP_HASHADD` required when `val` is false. --- mrbgems/mruby-compiler/core/codegen.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index c36178c8b..3996824a2 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1644,14 +1644,13 @@ gen_hash(codegen_scope *s, node *tree, int val, int limit) } } if (update) { - if (len > 0) { + if (val && len > 0) { pop_n(len*2+1); genop_2(s, OP_HASHADD, cursp(), len); push(); } return -1; /* variable length */ } - if (update) return -1; return len; } From cda4d9bcb43632da0451f2a7e1883255de9293df Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 22 Jan 2022 16:40:21 +0900 Subject: [PATCH 027/292] codegen.c: refactor `gen_call` and `gen_values`. Remove no longer used arguments from the functions. --- mrbgems/mruby-compiler/core/codegen.c | 50 +++++++-------------------- 1 file changed, 12 insertions(+), 38 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 3996824a2..1bea0149c 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1530,7 +1530,7 @@ attrsym(codegen_scope *s, mrb_sym a) #define GEN_VAL_STACK_MAX 99 static int -gen_values(codegen_scope *s, node *t, int val, int extra, int limit) +gen_values(codegen_scope *s, node *t, int val, int limit) { int n = 0; int first = 1; @@ -1551,7 +1551,7 @@ gen_values(codegen_scope *s, node *t, int val, int extra, int limit) while (t) { int is_splat = nint(t->car->car) == NODE_SPLAT; - if (is_splat || n+extra >= limit-1 || cursp() >= slimit) { /* flush stack */ + if (is_splat || n >= limit-1 || cursp() >= slimit) { /* flush stack */ pop_n(n); if (first) { if (n == 0) { @@ -1655,9 +1655,9 @@ gen_hash(codegen_scope *s, node *tree, int val, int limit) } static void -gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe) +gen_call(codegen_scope *s, node *tree, int val, int safe) { - mrb_sym sym = name ? name : nsym(tree->cdr->car); + mrb_sym sym = nsym(tree->cdr->car); int skip = 0, n = 0, nk = 0, noop = 0, noself = 0, blk = 0, sp_save = cursp(); if (!tree->car) { @@ -1675,7 +1675,7 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe) tree = tree->cdr->cdr->car; if (tree) { if (tree->car) { /* positional arguments */ - n = gen_values(s, tree->car, VAL, sp?1:0, 14); + n = gen_values(s, tree->car, VAL, 14); if (n < 0) { /* variable length */ noop = 1; /* not operator */ n = 15; @@ -1688,32 +1688,6 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe) if (nk < 0) nk = 15; } } - if (sp) { /* last argument pushed (attr=, []=) */ - /* pack keyword arguments */ - if (nk > 0 && nk < 15) { - pop_n(nk*2); - genop_2(s, OP_HASH, cursp(), nk); - push(); - } - if (n == CALL_MAXARGS) { - if (nk > 0) { - pop(); pop(); - genop_2(s, OP_ARYPUSH, cursp(), 1); - push(); - } - gen_move(s, cursp(), sp, 0); - pop(); - genop_2(s, OP_ARYPUSH, cursp(), 1); - push(); - } - else { - gen_move(s, cursp(), sp, 0); - push(); - if (nk > 0) n++; - n++; - } - nk = 0; - } if (tree && tree->cdr && tree->cdr->cdr) { codegen(s, tree->cdr->cdr, VAL); pop(); @@ -1878,7 +1852,7 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) tree = tree->cdr->cdr->car; if (tree) { if (tree->car) { /* positional arguments */ - n = gen_values(s, tree->car, VAL, 0, (tree->cdr->car)?13:14); + n = gen_values(s, tree->car, VAL, (tree->cdr->car)?13:14); if (n < 0) { /* variable length */ n = 15; push(); @@ -2602,10 +2576,10 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_FCALL: case NODE_CALL: - gen_call(s, tree, 0, 0, val, 0); + gen_call(s, tree, val, 0); break; case NODE_SCALL: - gen_call(s, tree, 0, 0, val, 1); + gen_call(s, tree, val, 1); break; case NODE_DOT2: @@ -2653,7 +2627,7 @@ codegen(codegen_scope *s, node *tree, int val) { int n; - n = gen_values(s, tree, val, 0, 0); + n = gen_values(s, tree, val, 0); if (val) { if (n >= 0) { pop_n(n); @@ -2804,7 +2778,7 @@ codegen(codegen_scope *s, node *tree, int val) idx = new_sym(s, nsym(n->cdr->car)); base = cursp()-1; if (n->cdr->cdr->car) { - nargs = gen_values(s, n->cdr->cdr->car->car, VAL, 1, 14); + nargs = gen_values(s, n->cdr->cdr->car->car, VAL, 13); if (nargs >= 0) { callargs = nargs; } @@ -2934,7 +2908,7 @@ codegen(codegen_scope *s, node *tree, int val) if (tree) { node *args = tree->car; if (args) { - st = n = gen_values(s, args, VAL, 0, 14); + st = n = gen_values(s, args, VAL, 14); if (n < 0) { st = 1; n = 15; push(); @@ -3051,7 +3025,7 @@ codegen(codegen_scope *s, node *tree, int val) if (ainfo < 0) codegen_error(s, "invalid yield (SyntaxError)"); push(); if (tree) { - n = gen_values(s, tree, VAL, 0, 14); + n = gen_values(s, tree, VAL, 14); if (n < 0) { n = sendv = 1; push(); From 7bedd5e05db1a41dcb65b4b5b6a2261eeff2e9b0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 23 Jan 2022 23:56:01 +0900 Subject: [PATCH 028/292] codegen.c: generate `OP_SETIDX` from attribute assignments. --- mrbgems/mruby-compiler/core/codegen.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 1bea0149c..8c906fa21 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1888,7 +1888,12 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) genop_2(s, OP_ARYPUSH, cursp(), 1); } s->sp = call; - genop_3(s, noself ? OP_SSEND : OP_SEND, cursp(), new_sym(s, attrsym(s, mid)), n); + if (mid == MRB_OPSYM_2(s->mrb, aref) && n == 2) { + genop_1(s, OP_SETIDX, cursp()); + } + else { + genop_3(s, noself ? OP_SSEND : OP_SEND, cursp(), new_sym(s, attrsym(s, mid)), n); + } if (safe) { dispatch(s, skip); } From 2adf32a3f452ee7e204dc8c156a9c1ee395e4b10 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 24 Jan 2022 16:42:36 +0900 Subject: [PATCH 029/292] add mruby-errno directory --- mrbgems/mruby-errno/.gitkeep | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 mrbgems/mruby-errno/.gitkeep diff --git a/mrbgems/mruby-errno/.gitkeep b/mrbgems/mruby-errno/.gitkeep new file mode 100644 index 000000000..e69de29bb From a60073d7b998ea9adb9a338c94f3fa77f7684e15 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 24 Jan 2022 18:07:59 +0900 Subject: [PATCH 030/292] mruby-errno: remove `.gitkeep`. --- mrbgems/mruby-errno/.gitkeep | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 mrbgems/mruby-errno/.gitkeep diff --git a/mrbgems/mruby-errno/.gitkeep b/mrbgems/mruby-errno/.gitkeep deleted file mode 100644 index e69de29bb..000000000 From c8d96ed7825b3c870d6da537c8b270724453c875 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 24 Jan 2022 18:13:28 +0900 Subject: [PATCH 031/292] stdlib.gembox: add `mruby-errno` --- mrbgems/stdlib.gembox | 3 +++ 1 file changed, 3 insertions(+) diff --git a/mrbgems/stdlib.gembox b/mrbgems/stdlib.gembox index 72fb9e343..2b2f45334 100644 --- a/mrbgems/stdlib.gembox +++ b/mrbgems/stdlib.gembox @@ -51,4 +51,7 @@ MRuby::GemBox.new do |conf| # Use class/module extension conf.gem :core => "mruby-class-ext" + + # Use errno extension + conf.gem :core => "mruby-errno" end From 3a15d18ebbe31e4f48e84125820a6a2bec8fb547 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 24 Jan 2022 18:14:28 +0900 Subject: [PATCH 032/292] errno.c: hide internal `_sys_fail` from backtrace. --- mrbgems/mruby-errno/src/errno.c | 1 + 1 file changed, 1 insertion(+) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 3617efd45..e6f91d211 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -92,6 +92,7 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) int argc; char name[8]; + mrb->c->ci->mid = 0; sce = mrb_class_get(mrb, "SystemCallError"); argc = mrb_get_args(mrb, "i|S", &no, &msg); if (argc == 1) { From 3b5486e3ae2a2652f6581937c4ec41d097d3687f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 25 Jan 2022 10:22:28 +0900 Subject: [PATCH 033/292] mruby-errno/test: update test suites not to report warnings. --- mrbgems/mruby-errno/test/errno.rb | 34 +++++++++++++++---------------- 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/mrbgems/mruby-errno/test/errno.rb b/mrbgems/mruby-errno/test/errno.rb index 790311566..a19f8abaf 100644 --- a/mrbgems/mruby-errno/test/errno.rb +++ b/mrbgems/mruby-errno/test/errno.rb @@ -1,19 +1,19 @@ assert('Errno') do - Errno.class == Module + assert_equal(Module, Errno.class) end assert('SystemCallError') do - SystemCallError.class == Class + assert_equal(Class, SystemCallError.class) end assert('SystemCallError superclass') do - SystemCallError.superclass == StandardError + assert_equal(StandardError, SystemCallError.superclass) end assert('SystemCallError#initialize') do - SystemCallError.new("a").message == "unknown error - a" and - SystemCallError.new("a", 12345).message == "Unknown error: 12345 - a" and - SystemCallError.new(12345).message == "Unknown error: 12345" + assert_equal("unknown error - a", SystemCallError.new("a").message) + assert_equal("Unknown error: 12345 - a", SystemCallError.new("a", 12345).message) + assert_equal("Unknown error: 12345", SystemCallError.new(12345).message) end assert('SystemCallError#errno') do @@ -24,37 +24,35 @@ assert('SystemCallError#errno') do end assert('SystemCallError#inspect') do - SystemCallError.new("a").inspect == "SystemCallError: unknown error - a" - end + assert_equal("unknown error - a (SystemCallError)", SystemCallError.new("a").inspect) +end assert('Errno::NOERROR') do - Errno::NOERROR.class == Class + assert_equal(Class, Errno::NOERROR.class) end # Is there any platform does not have EPERM? assert('Errno::EPERM') do - Errno::EPERM.class == Class + assert_equal(Class, Errno::EPERM.class) end assert('Errno::EPERM superclass') do - Errno::EPERM.superclass == SystemCallError + assert_equal(SystemCallError, Errno::EPERM.superclass) end assert('Errno::EPERM::Errno') do - Errno::EPERM::Errno.is_a? Fixnum + assert_true(Errno::EPERM::Errno.is_a?(Fixnum)) end assert('Errno::EPERM#message') do msg = Errno::EPERM.new.message - Errno::EPERM.new("a").message == "#{msg} - a" + assert_equal("#{msg} - a", Errno::EPERM.new("a").message) end -assert('Errno::EPERM#inspect 1') do +assert('Errno::EPERM#inspect') do msg = Errno::EPERM.new.message - Errno::EPERM.new.inspect == "Errno::EPERM: #{msg}" -end + assert_equal("#{msg} (Errno::EPERM)", Errno::EPERM.new.inspect) -assert('Errno::EPERM#inspect 2') do msg = Errno::EPERM.new.message - Errno::EPERM.new("a").inspect == "Errno::EPERM: #{msg} - a" + assert_equal("#{msg} - a (Errno::EPERM)", Errno::EPERM.new("a").inspect) end From 0f5829795ee1b387b3d8a2699c4239f636a74ae9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 25 Jan 2022 10:26:34 +0900 Subject: [PATCH 034/292] errno.c: use `MRB_SYM()` instead of `mrb_intern_lit()`. --- mrbgems/mruby-errno/src/errno.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index e6f91d211..527619ba5 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -8,6 +8,7 @@ #include #include #include +#include #if MRUBY_RELEASE_NO < 10000 static struct RClass * @@ -35,13 +36,13 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) } } if (!no_errno) { - e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get(mrb, "Errno")), mrb_intern_lit(mrb, "Errno2class")); + e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get(mrb, "Errno")), MRB_SYM(Errno2class)); c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value()); if (!mrb_nil_p(c)) { mrb_basic_ptr(self)->c = mrb_class_ptr(c); str = mrb_str_new_cstr(mrb, strerror(n)); } else { - mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "errno"), mrb_fixnum_value(n)); + mrb_iv_set(mrb, self, MRB_SYM(errno), mrb_fixnum_value(n)); str = mrb_str_new_cstr(mrb, "Unknown error: "); snprintf(buf, sizeof(buf), "%d", (int)n); mrb_str_cat2(mrb, str, buf); @@ -53,7 +54,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) mrb_str_cat2(mrb, str, " - "); mrb_str_append(mrb, str, m); } - mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "mesg"), str); + mrb_iv_set(mrb, self, MRB_SYM(mesg), str); return self; } @@ -64,7 +65,7 @@ mrb_sce_errno(mrb_state *mrb, mrb_value self) mrb_sym sym; c = mrb_class(mrb, self); - sym = mrb_intern_lit(mrb, "Errno"); + sym = MRB_SYM(Errno); #if MRUBY_RELEASE_NO < 10000 if (mrb_const_defined_at(mrb, c, sym)) { #else @@ -72,7 +73,7 @@ mrb_sce_errno(mrb_state *mrb, mrb_value self) #endif return mrb_const_get(mrb, mrb_obj_value(c), sym); } else { - sym = mrb_intern_lit(mrb, "errno"); + sym = MRB_SYM(errno); return mrb_attr_get(mrb, self, sym); } } @@ -80,7 +81,7 @@ mrb_sce_errno(mrb_state *mrb, mrb_value self) static mrb_value mrb_sce_to_s(mrb_state *mrb, mrb_value self) { - return mrb_attr_get(mrb, self, mrb_intern_lit(mrb, "mesg")); + return mrb_attr_get(mrb, self, MRB_SYM(mesg)); } static mrb_value @@ -115,7 +116,7 @@ mrb_exxx_init(mrb_state *mrb, mrb_value self) { mrb_value m, no, str; - no = mrb_const_get(mrb, mrb_obj_value(mrb_class(mrb, self)), mrb_intern_lit(mrb, "Errno")); + no = mrb_const_get(mrb, mrb_obj_value(mrb_class(mrb, self)), MRB_SYM(Errno)); str = mrb_str_new_cstr(mrb, strerror(mrb_fixnum(no))); m = mrb_nil_value(); @@ -124,7 +125,7 @@ mrb_exxx_init(mrb_state *mrb, mrb_value self) mrb_str_cat2(mrb, str, " - "); mrb_str_append(mrb, str, m); } - mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "mesg"), str); + mrb_iv_set(mrb, self, MRB_SYM(mesg), str); return self; } From 1e866dffc4003cdd515024a2711d9a3a62dd77f7 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 25 Jan 2022 10:28:50 +0900 Subject: [PATCH 035/292] errno.c: bundled mrbgem need not to support mruby 1.x. --- mrbgems/mruby-errno/src/errno.c | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 527619ba5..e3a5e64e7 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -10,14 +10,6 @@ #include #include -#if MRUBY_RELEASE_NO < 10000 -static struct RClass * -mrb_module_get(mrb_state *mrb, const char *name) -{ - return mrb_class_get(mrb, name); -} -#endif - static mrb_value mrb_sce_init(mrb_state *mrb, mrb_value self) { @@ -66,11 +58,7 @@ mrb_sce_errno(mrb_state *mrb, mrb_value self) c = mrb_class(mrb, self); sym = MRB_SYM(Errno); -#if MRUBY_RELEASE_NO < 10000 - if (mrb_const_defined_at(mrb, c, sym)) { -#else if (mrb_const_defined_at(mrb, mrb_obj_value(c), sym)) { -#endif return mrb_const_get(mrb, mrb_obj_value(c), sym); } else { sym = MRB_SYM(errno); From 6744d69d3dec705307d80e28c05eec6ab8782b24 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 25 Jan 2022 10:36:28 +0900 Subject: [PATCH 036/292] errno.c: replace string literals by `MRB_SYM()`. --- mrbgems/mruby-errno/src/errno.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index e3a5e64e7..8143f3e44 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -28,7 +28,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) } } if (!no_errno) { - e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get(mrb, "Errno")), MRB_SYM(Errno2class)); + e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get_id(mrb, MRB_SYM(Errno))), MRB_SYM(Errno2class)); c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value()); if (!mrb_nil_p(c)) { mrb_basic_ptr(self)->c = mrb_class_ptr(c); @@ -82,7 +82,7 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) char name[8]; mrb->c->ci->mid = 0; - sce = mrb_class_get(mrb, "SystemCallError"); + sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError)); argc = mrb_get_args(mrb, "i|S", &no, &msg); if (argc == 1) { e = mrb_funcall(mrb, mrb_obj_value(sce), "new", 1, mrb_fixnum_value(no)); @@ -91,8 +91,8 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) } if (mrb_obj_class(mrb, e) == sce) { snprintf(name, sizeof(name), "E%03ld", (long)no); - cl = mrb_define_class_under(mrb, mrb_module_get(mrb, "Errno"), name, sce); - mrb_define_const(mrb, cl, "Errno", mrb_fixnum_value(no)); + cl = mrb_define_class_under(mrb, mrb_module_get_id(mrb, MRB_SYM(Errno)), name, sce); + mrb_define_const_id(mrb, cl, MRB_SYM(Errno), mrb_fixnum_value(no)); mrb_basic_ptr(e)->c = cl; } mrb_exc_raise(mrb, e); @@ -123,7 +123,7 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) struct RClass *e, *eno, *sce, *ste; mrb_value h, noerror; - ste = mrb_class_get(mrb, "StandardError"); + ste = mrb_class_get_id(mrb, MRB_SYM(StandardError)); sce = mrb_define_class(mrb, "SystemCallError", ste); mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, MRB_ARGS_REQ(1)); @@ -131,12 +131,12 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) mrb_define_method(mrb, sce, "to_s", mrb_sce_to_s, MRB_ARGS_NONE()); mrb_define_method(mrb, sce, "initialize", mrb_sce_init, MRB_ARGS_ARG(1, 1)); - eno = mrb_define_module(mrb, "Errno"); + eno = mrb_define_module_id(mrb, MRB_SYM(Errno)); h = mrb_hash_new(mrb); - mrb_define_const(mrb, eno, "Errno2class", h); + mrb_define_const_id(mrb, eno, MRB_SYM(Errno2class), h); - e = mrb_define_class_under(mrb, eno, "NOERROR", sce); - mrb_define_const(mrb, e, "Errno", mrb_fixnum_value(0)); + e = mrb_define_class_under_id(mrb, eno, MRB_SYM(NOERROR), sce); + mrb_define_const_id(mrb, e, MRB_SYM(Errno), mrb_fixnum_value(0)); mrb_define_method(mrb, e, "initialize", mrb_exxx_init, MRB_ARGS_OPT(1)); //mrb_define_method(mrb, e, "===", mrb_exxx_cmp, MRB_ARGS_REQ(1)); noerror = mrb_obj_value(e); @@ -145,7 +145,7 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) do { \ int ai = mrb_gc_arena_save(mrb); \ e = mrb_define_class_under(mrb, eno, #SYM, sce); \ - mrb_define_const(mrb, e, "Errno", mrb_fixnum_value(SYM)); \ + mrb_define_const_id(mrb, e, MRB_SYM(Errno), mrb_fixnum_value(SYM)); \ mrb_define_method(mrb, e, "initialize", mrb_exxx_init, MRB_ARGS_OPT(1)); \ mrb_hash_set(mrb, h, mrb_fixnum_value(SYM), mrb_obj_value(e)); \ mrb_gc_arena_restore(mrb, ai); \ From 5c7338491ca28ab75406e8e84ceca3f6308b4f97 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 25 Jan 2022 10:37:39 +0900 Subject: [PATCH 037/292] errno.c: use `mrb_fixnum_p()` instead of `mrb_type()`. --- mrbgems/mruby-errno/src/errno.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 8143f3e44..4840c1399 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -20,7 +20,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) argc = mrb_get_args(mrb, "o|i", &m, &n); if (argc == 1) { - if (mrb_type(m) == MRB_TT_FIXNUM) { + if (mrb_fixnum_p(m)) { n = mrb_fixnum(m); m = mrb_nil_value(); } else { From 4176e8e88faf6eadfe0702664880241079ca2c88 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 25 Jan 2022 11:08:05 +0900 Subject: [PATCH 038/292] error.c: use `MRB_SYM()` in `mrb_sys_fail`. --- src/error.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/error.c b/src/error.c index 5fa872c9b..e651e3ad8 100644 --- a/src/error.c +++ b/src/error.c @@ -541,8 +541,8 @@ mrb_sys_fail(mrb_state *mrb, const char *mesg) mrb_int no; no = (mrb_int)errno; - if (mrb_class_defined(mrb, "SystemCallError")) { - sce = mrb_class_get(mrb, "SystemCallError"); + if (mrb_class_defined_id(mrb, MRB_SYM(SystemCallError))) { + sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError)); if (mesg != NULL) { mrb_funcall(mrb, mrb_obj_value(sce), "_sys_fail", 2, mrb_fixnum_value(no), mrb_str_new_cstr(mrb, mesg)); } From 194d0c6f464dcbd451c5d216c6c1dc0b0441648c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 25 Jan 2022 11:08:52 +0900 Subject: [PATCH 039/292] mruby-errno: change the format of `known_errors_e2c.cstub`. --- mrbgems/mruby-errno/src/gen.rb | 2 +- .../mruby-errno/src/known_errors_e2c.cstub | 290 +++++++++--------- 2 files changed, 146 insertions(+), 146 deletions(-) diff --git a/mrbgems/mruby-errno/src/gen.rb b/mrbgems/mruby-errno/src/gen.rb index 12e6b302e..6a0327dd3 100755 --- a/mrbgems/mruby-errno/src/gen.rb +++ b/mrbgems/mruby-errno/src/gen.rb @@ -11,7 +11,7 @@ IO.readlines("known_errors.def").each { |name| e.write < Date: Tue, 25 Jan 2022 11:15:34 +0900 Subject: [PATCH 040/292] errno.c: use C array instead of a hash table to lookup a errno class. To reduce memory consumption by avoiding allocating Ruby objects. --- mrbgems/mruby-errno/src/errno.c | 34 +++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 4840c1399..55bcea9d5 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -10,10 +10,18 @@ #include #include +static struct { + mrb_sym sym; + int eno; +} e2c[] = { +#include "known_errors_e2c.cstub" + {0, 0}, +}; + static mrb_value mrb_sce_init(mrb_state *mrb, mrb_value self) { - mrb_value c, e2c, m, str; + mrb_value m, str; mrb_int n; int argc, no_errno = 0; char buf[20]; @@ -28,18 +36,23 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) } } if (!no_errno) { - e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get_id(mrb, MRB_SYM(Errno))), MRB_SYM(Errno2class)); - c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value()); - if (!mrb_nil_p(c)) { - mrb_basic_ptr(self)->c = mrb_class_ptr(c); - str = mrb_str_new_cstr(mrb, strerror(n)); - } else { + int i; + + for (i=0; e2c[i].sym != 0; i++) { + if (e2c[i].eno == n) { + mrb_basic_ptr(self)->c = mrb_class_get_under_id(mrb, mrb_module_get_id(mrb, MRB_SYM(Errno)), e2c[i].sym); + str = mrb_str_new_cstr(mrb, strerror(n)); + break; + } + } + if (e2c[i].sym == 0) { mrb_iv_set(mrb, self, MRB_SYM(errno), mrb_fixnum_value(n)); str = mrb_str_new_cstr(mrb, "Unknown error: "); snprintf(buf, sizeof(buf), "%d", (int)n); mrb_str_cat2(mrb, str, buf); } - } else { + } + else { str = mrb_str_new_cstr(mrb, "unknown error"); } if (!mrb_nil_p(m)) { @@ -121,7 +134,7 @@ void mrb_mruby_errno_gem_init(mrb_state *mrb) { struct RClass *e, *eno, *sce, *ste; - mrb_value h, noerror; + mrb_value noerror; ste = mrb_class_get_id(mrb, MRB_SYM(StandardError)); @@ -132,8 +145,6 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) mrb_define_method(mrb, sce, "initialize", mrb_sce_init, MRB_ARGS_ARG(1, 1)); eno = mrb_define_module_id(mrb, MRB_SYM(Errno)); - h = mrb_hash_new(mrb); - mrb_define_const_id(mrb, eno, MRB_SYM(Errno2class), h); e = mrb_define_class_under_id(mrb, eno, MRB_SYM(NOERROR), sce); mrb_define_const_id(mrb, e, MRB_SYM(Errno), mrb_fixnum_value(0)); @@ -147,7 +158,6 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) e = mrb_define_class_under(mrb, eno, #SYM, sce); \ mrb_define_const_id(mrb, e, MRB_SYM(Errno), mrb_fixnum_value(SYM)); \ mrb_define_method(mrb, e, "initialize", mrb_exxx_init, MRB_ARGS_OPT(1)); \ - mrb_hash_set(mrb, h, mrb_fixnum_value(SYM), mrb_obj_value(e)); \ mrb_gc_arena_restore(mrb, ai); \ } while (0) From dd93dd741920ca195f5f91ff32e0c21aef0819c3 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 25 Jan 2022 16:01:33 +0900 Subject: [PATCH 041/292] errno.c: refactor `_sys_fail` to avoid `mrb_funcall`. --- mrbgems/mruby-errno/src/errno.c | 79 +++++++++++++++++++++------------ 1 file changed, 51 insertions(+), 28 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 55bcea9d5..f700cb225 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -18,29 +18,21 @@ static struct { {0, 0}, }; -static mrb_value -mrb_sce_init(mrb_state *mrb, mrb_value self) +static void +mrb_sce_init(mrb_state *mrb, mrb_value self, mrb_value m, mrb_int n) { - mrb_value m, str; - mrb_int n; - int argc, no_errno = 0; + mrb_value str; + struct RClass *m_errno; + int no_errno = (n < 0); char buf[20]; - argc = mrb_get_args(mrb, "o|i", &m, &n); - if (argc == 1) { - if (mrb_fixnum_p(m)) { - n = mrb_fixnum(m); - m = mrb_nil_value(); - } else { - no_errno = 1; - } - } + m_errno = mrb_module_get_id(mrb, MRB_SYM(Errno)); if (!no_errno) { int i; for (i=0; e2c[i].sym != 0; i++) { if (e2c[i].eno == n) { - mrb_basic_ptr(self)->c = mrb_class_get_under_id(mrb, mrb_module_get_id(mrb, MRB_SYM(Errno)), e2c[i].sym); + mrb_basic_ptr(self)->c = mrb_class_get_under_id(mrb, m_errno, e2c[i].sym); str = mrb_str_new_cstr(mrb, strerror(n)); break; } @@ -60,6 +52,24 @@ mrb_sce_init(mrb_state *mrb, mrb_value self) mrb_str_append(mrb, str, m); } mrb_iv_set(mrb, self, MRB_SYM(mesg), str); +} + +static mrb_value +mrb_sce_init_m(mrb_state *mrb, mrb_value self) +{ + mrb_value m; + mrb_int n; + + if (mrb_get_args(mrb, "o|i", &m, &n) == 1) { + if (mrb_fixnum_p(m)) { + n = mrb_fixnum(m); + m = mrb_nil_value(); + } + else { + n = -1; + } + } + mrb_sce_init(mrb, self, m, n); return self; } @@ -88,27 +98,40 @@ mrb_sce_to_s(mrb_state *mrb, mrb_value self) static mrb_value mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) { - struct RClass *cl, *sce; - mrb_value e, msg; - mrb_int no; + struct RClass *sce; + mrb_value msg; + mrb_int no = -1; int argc; char name[8]; mrb->c->ci->mid = 0; sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError)); argc = mrb_get_args(mrb, "i|S", &no, &msg); + + struct RBasic* e = mrb_obj_alloc(mrb, MRB_TT_EXCEPTION, sce); + mrb_value exc = mrb_obj_value(e); if (argc == 1) { - e = mrb_funcall(mrb, mrb_obj_value(sce), "new", 1, mrb_fixnum_value(no)); - } else { - e = mrb_funcall(mrb, mrb_obj_value(sce), "new", 2, msg, mrb_fixnum_value(no)); + msg = mrb_nil_value(); } - if (mrb_obj_class(mrb, e) == sce) { - snprintf(name, sizeof(name), "E%03ld", (long)no); - cl = mrb_define_class_under(mrb, mrb_module_get_id(mrb, MRB_SYM(Errno)), name, sce); - mrb_define_const_id(mrb, cl, MRB_SYM(Errno), mrb_fixnum_value(no)); - mrb_basic_ptr(e)->c = cl; + exc = mrb_obj_value(e); + mrb_sce_init(mrb, exc, msg, no); + if (mrb_obj_class(mrb, exc) == sce && no > 0) { + struct RClass *m_errno = mrb_module_get_id(mrb, MRB_SYM(Errno)); + struct RClass *cl; + + snprintf(name, sizeof(name), "E%03d", (int)no); + mrb_sym esym = mrb_intern_cstr(mrb, name); + + if (!mrb_const_defined_at(mrb, mrb_obj_value(m_errno), esym)) { + struct RClass *sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError)); + cl = mrb_define_class_under_id(mrb, m_errno, esym, sce); + } + else { + cl = mrb_class_get_under_id(mrb, m_errno, esym); + } + e->c = cl; } - mrb_exc_raise(mrb, e); + mrb_exc_raise(mrb, exc); return mrb_nil_value(); /* NOTREACHED */ } @@ -142,7 +165,7 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sce, "errno", mrb_sce_errno, MRB_ARGS_NONE()); mrb_define_method(mrb, sce, "to_s", mrb_sce_to_s, MRB_ARGS_NONE()); - mrb_define_method(mrb, sce, "initialize", mrb_sce_init, MRB_ARGS_ARG(1, 1)); + mrb_define_method(mrb, sce, "initialize", mrb_sce_init_m, MRB_ARGS_ARG(1, 1)); eno = mrb_define_module_id(mrb, MRB_SYM(Errno)); From b7cdb59f26195db4848860d4915ad6f5cacb5b76 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 26 Jan 2022 12:29:19 +0900 Subject: [PATCH 042/292] errno.c: stop generating `Errno::Exxx` error classes on the fly. --- mrbgems/mruby-errno/src/errno.c | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index f700cb225..74df5d0fc 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -102,7 +102,6 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) mrb_value msg; mrb_int no = -1; int argc; - char name[8]; mrb->c->ci->mid = 0; sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError)); @@ -115,22 +114,6 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) } exc = mrb_obj_value(e); mrb_sce_init(mrb, exc, msg, no); - if (mrb_obj_class(mrb, exc) == sce && no > 0) { - struct RClass *m_errno = mrb_module_get_id(mrb, MRB_SYM(Errno)); - struct RClass *cl; - - snprintf(name, sizeof(name), "E%03d", (int)no); - mrb_sym esym = mrb_intern_cstr(mrb, name); - - if (!mrb_const_defined_at(mrb, mrb_obj_value(m_errno), esym)) { - struct RClass *sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError)); - cl = mrb_define_class_under_id(mrb, m_errno, esym, sce); - } - else { - cl = mrb_class_get_under_id(mrb, m_errno, esym); - } - e->c = cl; - } mrb_exc_raise(mrb, exc); return mrb_nil_value(); /* NOTREACHED */ } From c5bdfe1bd48174a4e8b1b81d517803c4784cdb21 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 26 Jan 2022 12:30:31 +0900 Subject: [PATCH 043/292] mruby-errno: add errno constants to `known_errors.def`. Add unlisted errno constants found in macOS and FreeBSD. If you see unlisted errno, please report. --- mrbgems/mruby-errno/src/known_errors.def | 11 ++++ .../mruby-errno/src/known_errors_def.cstub | 55 +++++++++++++++++++ .../mruby-errno/src/known_errors_e2c.cstub | 33 +++++++++++ 3 files changed, 99 insertions(+) diff --git a/mrbgems/mruby-errno/src/known_errors.def b/mrbgems/mruby-errno/src/known_errors.def index 3cebe90a8..bb5ddd504 100644 --- a/mrbgems/mruby-errno/src/known_errors.def +++ b/mrbgems/mruby-errno/src/known_errors.def @@ -69,10 +69,18 @@ EADV ESRMNT ECOMM EPROTO +ENOTCAPABLE +ECAPMODE EMULTIHOP EDOTDOT EBADMSG +EPWROFF +EDEVERR EOVERFLOW +EBADEXEC +EBADARCH +EBADMACHO +ESHLIBVERS ENOTUNIQ EBADFD EREMCHG @@ -129,6 +137,7 @@ ENOKEY ENOMEDIUM ENOTRECOVERABLE EOWNERDEAD +EINTEGRITY ERFKILL EAUTH EBADRPC @@ -143,3 +152,5 @@ EPROGMISMATCH EPROGUNAVAIL ERPCMISMATCH EIPSEC +ENOPOLICY +EQFULL diff --git a/mrbgems/mruby-errno/src/known_errors_def.cstub b/mrbgems/mruby-errno/src/known_errors_def.cstub index 83d8670ba..3c7fefb12 100644 --- a/mrbgems/mruby-errno/src/known_errors_def.cstub +++ b/mrbgems/mruby-errno/src/known_errors_def.cstub @@ -353,6 +353,16 @@ #else itsnotdefined(EPROTO); #endif +#ifdef ENOTCAPABLE + itsdefined(ENOTCAPABLE); +#else + itsnotdefined(ENOTCAPABLE); +#endif +#ifdef ECAPMODE + itsdefined(ECAPMODE); +#else + itsnotdefined(ECAPMODE); +#endif #ifdef EMULTIHOP itsdefined(EMULTIHOP); #else @@ -368,11 +378,41 @@ #else itsnotdefined(EBADMSG); #endif +#ifdef EPWROFF + itsdefined(EPWROFF); +#else + itsnotdefined(EPWROFF); +#endif +#ifdef EDEVERR + itsdefined(EDEVERR); +#else + itsnotdefined(EDEVERR); +#endif #ifdef EOVERFLOW itsdefined(EOVERFLOW); #else itsnotdefined(EOVERFLOW); #endif +#ifdef EBADEXEC + itsdefined(EBADEXEC); +#else + itsnotdefined(EBADEXEC); +#endif +#ifdef EBADARCH + itsdefined(EBADARCH); +#else + itsnotdefined(EBADARCH); +#endif +#ifdef EBADMACHO + itsdefined(EBADMACHO); +#else + itsnotdefined(EBADMACHO); +#endif +#ifdef ESHLIBVERS + itsdefined(ESHLIBVERS); +#else + itsnotdefined(ESHLIBVERS); +#endif #ifdef ENOTUNIQ itsdefined(ENOTUNIQ); #else @@ -653,6 +693,11 @@ #else itsnotdefined(EOWNERDEAD); #endif +#ifdef EINTEGRITY + itsdefined(EINTEGRITY); +#else + itsnotdefined(EINTEGRITY); +#endif #ifdef ERFKILL itsdefined(ERFKILL); #else @@ -723,3 +768,13 @@ #else itsnotdefined(EIPSEC); #endif +#ifdef ENOPOLICY + itsdefined(ENOPOLICY); +#else + itsnotdefined(ENOPOLICY); +#endif +#ifdef EQFULL + itsdefined(EQFULL); +#else + itsnotdefined(EQFULL); +#endif diff --git a/mrbgems/mruby-errno/src/known_errors_e2c.cstub b/mrbgems/mruby-errno/src/known_errors_e2c.cstub index bd8d7e055..db0183363 100644 --- a/mrbgems/mruby-errno/src/known_errors_e2c.cstub +++ b/mrbgems/mruby-errno/src/known_errors_e2c.cstub @@ -211,6 +211,12 @@ #ifdef EPROTO { MRB_SYM(EPROTO), EPROTO }, #endif +#ifdef ENOTCAPABLE + { MRB_SYM(ENOTCAPABLE), ENOTCAPABLE }, +#endif +#ifdef ECAPMODE + { MRB_SYM(ECAPMODE), ECAPMODE }, +#endif #ifdef EMULTIHOP { MRB_SYM(EMULTIHOP), EMULTIHOP }, #endif @@ -220,9 +226,27 @@ #ifdef EBADMSG { MRB_SYM(EBADMSG), EBADMSG }, #endif +#ifdef EPWROFF + { MRB_SYM(EPWROFF), EPWROFF }, +#endif +#ifdef EDEVERR + { MRB_SYM(EDEVERR), EDEVERR }, +#endif #ifdef EOVERFLOW { MRB_SYM(EOVERFLOW), EOVERFLOW }, #endif +#ifdef EBADEXEC + { MRB_SYM(EBADEXEC), EBADEXEC }, +#endif +#ifdef EBADARCH + { MRB_SYM(EBADARCH), EBADARCH }, +#endif +#ifdef EBADMACHO + { MRB_SYM(EBADMACHO), EBADMACHO }, +#endif +#ifdef ESHLIBVERS + { MRB_SYM(ESHLIBVERS), ESHLIBVERS }, +#endif #ifdef ENOTUNIQ { MRB_SYM(ENOTUNIQ), ENOTUNIQ }, #endif @@ -391,6 +415,9 @@ #ifdef EOWNERDEAD { MRB_SYM(EOWNERDEAD), EOWNERDEAD }, #endif +#ifdef EINTEGRITY + { MRB_SYM(EINTEGRITY), EINTEGRITY }, +#endif #ifdef ERFKILL { MRB_SYM(ERFKILL), ERFKILL }, #endif @@ -433,3 +460,9 @@ #ifdef EIPSEC { MRB_SYM(EIPSEC), EIPSEC }, #endif +#ifdef ENOPOLICY + { MRB_SYM(ENOPOLICY), ENOPOLICY }, +#endif +#ifdef EQFULL + { MRB_SYM(EQFULL), EQFULL }, +#endif From 912925eab759d8f9e824af32a3db47de41569b03 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 27 Jan 2022 14:09:18 +0000 Subject: [PATCH 044/292] build(deps): bump github/super-linter from 4.8.5 to 4.8.6 Bumps [github/super-linter](https://github.com/github/super-linter) from 4.8.5 to 4.8.6. - [Release notes](https://github.com/github/super-linter/releases) - [Changelog](https://github.com/github/super-linter/blob/main/docs/release-process.md) - [Commits](https://github.com/github/super-linter/compare/v4.8.5...v4.8.6) --- updated-dependencies: - dependency-name: github/super-linter dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- .github/workflows/super-linter.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/super-linter.yml b/.github/workflows/super-linter.yml index f7a7a6fb4..c506b6962 100644 --- a/.github/workflows/super-linter.yml +++ b/.github/workflows/super-linter.yml @@ -13,7 +13,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2.4.0 - - uses: github/super-linter@v4.8.5 + - uses: github/super-linter@v4.8.6 env: ERROR_ON_MISSING_EXEC_BIT: true VALIDATE_BASH: true From 319340f3094f5811770935186947a730b559b4bd Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 28 Jan 2022 14:06:26 +0000 Subject: [PATCH 045/292] build(deps): bump github/super-linter from 4.8.6 to 4.8.7 Bumps [github/super-linter](https://github.com/github/super-linter) from 4.8.6 to 4.8.7. - [Release notes](https://github.com/github/super-linter/releases) - [Changelog](https://github.com/github/super-linter/blob/main/docs/release-process.md) - [Commits](https://github.com/github/super-linter/compare/v4.8.6...v4.8.7) --- updated-dependencies: - dependency-name: github/super-linter dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- .github/workflows/super-linter.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/super-linter.yml b/.github/workflows/super-linter.yml index c506b6962..39e0772fd 100644 --- a/.github/workflows/super-linter.yml +++ b/.github/workflows/super-linter.yml @@ -13,7 +13,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2.4.0 - - uses: github/super-linter@v4.8.6 + - uses: github/super-linter@v4.8.7 env: ERROR_ON_MISSING_EXEC_BIT: true VALIDATE_BASH: true From 198e10473b3b20269c0f3c44869b62a9fc7b3a1f Mon Sep 17 00:00:00 2001 From: Chris Reuter Date: Sat, 29 Jan 2022 18:40:05 -0500 Subject: [PATCH 046/292] Updated mruby-errno/README.md to pass the lint checks. --- mrbgems/mruby-errno/README.md | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/mrbgems/mruby-errno/README.md b/mrbgems/mruby-errno/README.md index e3c594cb5..aa9a782b5 100644 --- a/mrbgems/mruby-errno/README.md +++ b/mrbgems/mruby-errno/README.md @@ -1,27 +1,25 @@ -mruby-errno -=========== +# mruby-errno Errno module for mruby - ## License Copyright (c) 2013 Internet Initiative Japan Inc. -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and associated documentation files (the "Software"), -to deal in the Software without restriction, including without limitation -the rights to use, copy, modify, merge, publish, distribute, sublicense, -and/or sell copies of the Software, and to permit persons to whom the +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. From 8252352d7be244a3175db1aabdf3d80d7832593a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 28 Jan 2022 15:31:22 +0900 Subject: [PATCH 047/292] parse.y: fix buffer overflow with tweaked mruby binary. --- mrbgems/mruby-compiler/core/parse.y | 11 ++++++----- mrbgems/mruby-compiler/core/y.tab.c | 11 ++++++----- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 7c063609e..a144617d7 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -6934,11 +6934,12 @@ mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrbc_context *c) binsize = bin_to_uint32(leading.h.binary_size); bin_obj = mrb_str_new(mrb, NULL, binsize); bin = (uint8_t *)RSTRING_PTR(bin_obj); - memcpy(bin, leading.b, bufsize); - if (binsize > bufsize && - fread(bin + bufsize, binsize - bufsize, 1, fp) == 0) { - binsize = bufsize; - /* The error is reported by mrb_load_irep_buf_cxt() */ + if (binsize > bufsize) { + memcpy(bin, leading.b, bufsize); + if (fread(bin + bufsize, binsize - bufsize, 1, fp) == 0) { + binsize = bufsize; + /* The error is reported by mrb_load_irep_buf_cxt() */ + } } result = mrb_load_irep_buf_cxt(mrb, bin, binsize, c); diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index d4a6b6363..046f02e55 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -13161,11 +13161,12 @@ mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrbc_context *c) binsize = bin_to_uint32(leading.h.binary_size); bin_obj = mrb_str_new(mrb, NULL, binsize); bin = (uint8_t *)RSTRING_PTR(bin_obj); - memcpy(bin, leading.b, bufsize); - if (binsize > bufsize && - fread(bin + bufsize, binsize - bufsize, 1, fp) == 0) { - binsize = bufsize; - /* The error is reported by mrb_load_irep_buf_cxt() */ + if (binsize > bufsize) { + memcpy(bin, leading.b, bufsize); + if (fread(bin + bufsize, binsize - bufsize, 1, fp) == 0) { + binsize = bufsize; + /* The error is reported by mrb_load_irep_buf_cxt() */ + } } result = mrb_load_irep_buf_cxt(mrb, bin, binsize, c); From 00f2b74ab2c1f03084908c815dcd0934f9fc702a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 30 Jan 2022 20:18:46 +0900 Subject: [PATCH 048/292] kernel.c, binding.c: use `MRB_SYM()` instead of `mrb_intern_lit()`. --- mrbgems/mruby-binding/test/binding.c | 3 ++- src/kernel.c | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-binding/test/binding.c b/mrbgems/mruby-binding/test/binding.c index 5a37ca043..efc982a75 100644 --- a/mrbgems/mruby-binding/test/binding.c +++ b/mrbgems/mruby-binding/test/binding.c @@ -1,9 +1,10 @@ #include +#include static mrb_value binding_in_c(mrb_state *mrb, mrb_value self) { - return mrb_funcall_argv(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "binding"), 0, NULL); + return mrb_funcall_argv(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(binding), 0, NULL); } void diff --git a/src/kernel.c b/src/kernel.c index 7a261560f..dff627b8c 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -589,7 +589,7 @@ mrb_obj_ceqq(mrb_state *mrb, mrb_value self) else if (mrb_nil_p(self)) { return mrb_false_value(); } - else if (!mrb_respond_to(mrb, self, mrb_intern_lit(mrb, "to_a"))) { + else if (!mrb_respond_to(mrb, self, MRB_SYM(to_a))) { mrb_value c = mrb_funcall_argv(mrb, self, eqq, 1, &v); if (mrb_test(c)) return mrb_true_value(); return mrb_false_value(); From d9bf7982e9c3e2bdcda66bf2acc90180448f90ee Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 1 Feb 2022 22:36:42 +0900 Subject: [PATCH 049/292] class.c: set `MRB_FL_CLASS_IS_INHERITED` flag for bootstrapped classes. --- src/class.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/class.c b/src/class.c index 8751dcaf0..0c15fbf42 100644 --- a/src/class.c +++ b/src/class.c @@ -1376,6 +1376,7 @@ boot_defclass(mrb_state *mrb, struct RClass *super) if (super) { c->super = super; mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)super); + c->flags |= MRB_FL_CLASS_IS_INHERITED; } else { c->super = mrb->object_class; From f0af96c130737f8ed07eeed73691428cd55a346f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 1 Feb 2022 22:37:49 +0900 Subject: [PATCH 050/292] mruby-class-ext: add `Class#subclasses` method. --- mrbgems/mruby-class-ext/src/class.c | 55 +++++++++++++++++++++++++++ mrbgems/mruby-class-ext/test/class.rb | 13 +++++++ 2 files changed, 68 insertions(+) create mode 100644 mrbgems/mruby-class-ext/test/class.rb diff --git a/mrbgems/mruby-class-ext/src/class.c b/mrbgems/mruby-class-ext/src/class.c index 290ddf4b3..373af8312 100644 --- a/mrbgems/mruby-class-ext/src/class.c +++ b/mrbgems/mruby-class-ext/src/class.c @@ -1,6 +1,7 @@ #include "mruby.h" #include "mruby/class.h" #include "mruby/string.h" +#include "mruby/array.h" #include "mruby/proc.h" static mrb_value @@ -56,6 +57,57 @@ mrb_mod_module_exec(mrb_state *mrb, mrb_value self) return mrb_yield_cont(mrb, blk, self, argc, argv); } +struct subclass_args { + struct RClass *c; + mrb_value ary; +}; + +static int +add_subclasses(mrb_state *mrb, struct RBasic *obj, void *data) +{ + struct subclass_args *args = (struct subclass_args*)data; + if (obj->tt == MRB_TT_CLASS) { + struct RClass *c = (struct RClass*)obj; + if (mrb_class_real(c->super) == args->c) { + mrb_ary_push(mrb, args->ary, mrb_obj_value(obj)); + } + } + return MRB_EACH_OBJ_OK; +} + +/* + * call-seq: + * subclasses -> array + * + * Returns an array of classes where the receiver is the + * direct superclass of the class, excluding singleton classes. + * The order of the returned array is not defined. + * + * class A; end + * class B < A; end + * class C < B; end + * class D < A; end + * + * A.subclasses #=> [D, B] + * B.subclasses #=> [C] + * C.subclasses #=> [] + */ +static mrb_value +mrb_class_subclasses(mrb_state *mrb, mrb_value self) +{ + struct RClass *c; + mrb_value ary; + + c = mrb_class_ptr(self); + ary = mrb_ary_new(mrb); + + if (c->flags & MRB_FL_CLASS_IS_INHERITED) { + struct subclass_args arg = {c, ary}; + mrb_objspace_each_objects(mrb, add_subclasses, &arg); + } + return ary; +} + void mrb_mruby_class_ext_gem_init(mrb_state *mrb) { @@ -65,6 +117,9 @@ mrb_mruby_class_ext_gem_init(mrb_state *mrb) mrb_define_method(mrb, mod, "singleton_class?", mrb_mod_singleton_class_p, MRB_ARGS_NONE()); mrb_define_method(mrb, mod, "module_exec", mrb_mod_module_exec, MRB_ARGS_ANY()|MRB_ARGS_BLOCK()); mrb_define_method(mrb, mod, "class_exec", mrb_mod_module_exec, MRB_ARGS_ANY()|MRB_ARGS_BLOCK()); + + struct RClass *cls = mrb->module_class; + mrb_define_method(mrb, cls, "subclasses", mrb_class_subclasses, MRB_ARGS_NONE()); } void diff --git a/mrbgems/mruby-class-ext/test/class.rb b/mrbgems/mruby-class-ext/test/class.rb new file mode 100644 index 000000000..2043b39cb --- /dev/null +++ b/mrbgems/mruby-class-ext/test/class.rb @@ -0,0 +1,13 @@ +assert 'Class#subclasses' do + a = Class.new + b = Class.new(a) + c = Class.new(b) + d = Class.new(a) + + a_sub = a.subclasses + assert_equal(2, a_sub.size) + assert_true(a_sub.include?(b)) + assert_true(a_sub.include?(d)) + assert_equal([c], b.subclasses) + assert_equal([], c.subclasses) +end From f9f2d4c4e37b1a3a3a9af4783945e5678e7bfbb1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Feb 2022 20:51:37 +0900 Subject: [PATCH 051/292] codedump.c: adjust OP_HASHCAT variable label position. --- src/codedump.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/codedump.c b/src/codedump.c index 20397907e..343f51018 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -515,7 +515,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_HASHCAT, B): - printf("HASHCAT\tR%d\t", a); + printf("HASHCAT\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; From 8d06e79c578a3b24c45ae4881c5122b73b3bff59 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Feb 2022 20:57:43 +0900 Subject: [PATCH 052/292] codedump.c: remove unnecessary condition. `(irep->pool[b].tt & IREP_TT_NFLAG) == 0` is always true ensured by the assertion. --- src/codedump.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/codedump.c b/src/codedump.c index 343f51018..f8de26eec 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -494,12 +494,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) break; CASE(OP_STRING, BB): mrb_assert((irep->pool[b].tt&IREP_TT_NFLAG)==0); - if ((irep->pool[b].tt & IREP_TT_NFLAG) == 0) { - printf("STRING\tR%d\tL(%d)\t; %s", a, b, irep->pool[b].u.str); - } - else { - printf("STRING\tR%d\tL(%d)\t", a, b); - } + printf("STRING\tR%d\tL(%d)\t; %s", a, b, irep->pool[b].u.str); print_lv_a(mrb, irep, a); break; CASE(OP_STRCAT, B): From ae3c99767a27f5c6c584162e2adc6a5d0eb2c54e Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Feb 2022 10:40:05 +0900 Subject: [PATCH 053/292] codegen.c: fixed a bug in hash code generation with `!val`. --- mrbgems/mruby-compiler/core/codegen.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 8c906fa21..a7420a62b 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1603,7 +1603,7 @@ gen_hash(codegen_scope *s, node *tree, int val, int limit) while (tree) { if (nint(tree->car->car->car) == NODE_KW_REST_ARGS) { - if (len > 0) { + if (val && len > 0) { pop_n(len*2); if (!update) { genop_2(s, OP_HASH, cursp(), len); @@ -1615,7 +1615,7 @@ gen_hash(codegen_scope *s, node *tree, int val, int limit) push(); } codegen(s, tree->car->cdr, val); - if (len > 0 || update) { + if (val && (len > 0 || update)) { pop(); pop(); genop_1(s, OP_HASHCAT, cursp()); push(); From 903c5f978a2966465d8d5c6dfac55a977d134287 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Feb 2022 10:41:09 +0900 Subject: [PATCH 054/292] vm.c: check object type before concatenating strings. --- src/vm.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/vm.c b/src/vm.c index b0cd9428d..cc53c0bb5 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2756,6 +2756,7 @@ RETRY_TRY_BLOCK: } CASE(OP_STRCAT, B) { + mrb_ensure_string_type(mrb, regs[a]); mrb_str_concat(mrb, regs[a], regs[a+1]); NEXT; } From d0e8637e30aad2887f213e8f1b7c7da087081a4b Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 5 Feb 2022 17:36:23 +0900 Subject: [PATCH 055/292] Integrate argument normalization for `OP_SEND` and `OP_SUPER` --- src/vm.c | 85 +++++++++++++++++++++++--------------------------------- 1 file changed, 34 insertions(+), 51 deletions(-) diff --git a/src/vm.c b/src/vm.c index cc53c0bb5..a0d09e608 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1163,6 +1163,35 @@ hash_new_from_values(mrb_state *mrb, mrb_int argc, mrb_value *regs) void mrb_method_added(mrb_state *mrb, struct RClass *c, mrb_sym mid); mrb_value mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value idx, mrb_value len); +#define ARGUMENT_NORMALIZE(arg_base, arg_info, insn) do { \ + int n = *(arg_info)&0xf; \ + int nk = (*(arg_info)>>4)&0xf; \ + mrb_int bidx = (arg_base) + mrb_bidx(*(arg_info)); \ + if (0 < nk && nk < CALL_MAXARGS) { /* pack keyword arguments */ \ + mrb_int kidx = (arg_base)+(n==CALL_MAXARGS?1:n)+1; \ + mrb_value kdict = hash_new_from_values(mrb, nk, regs+kidx); \ + regs[kidx] = kdict; \ + nk = CALL_MAXARGS; \ + *(arg_info) = n | (nk<<4); \ + } \ + \ + mrb_assert(bidx < irep->nregs+(arg_base)); \ + mrb_int new_bidx = (arg_base)+mrb_bidx(*(arg_info)); \ + if ((insn) == OP_SEND) { \ + /* clear block argument */ \ + SET_NIL_VALUE(regs[new_bidx]); \ + SET_NIL_VALUE(blk); \ + } \ + else { \ + blk = regs[bidx]; \ + if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) { \ + blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); \ + /* The stack might have been reallocated during mrb_type_convert(), see #3622 */ \ + } \ + regs[new_bidx] = blk; \ + } \ +} while (0) + MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *pc) { @@ -1569,39 +1598,12 @@ RETRY_TRY_BLOCK: mid = syms[b]; L_SENDB_SYM: { - int n = c&0xf; - int nk = (c>>4)&0xf; mrb_callinfo *ci = mrb->c->ci; - mrb_int bidx = a + mrb_bidx(c); mrb_method_t m; struct RClass *cls; - mrb_value recv; + mrb_value recv, blk; - if (0 < nk && nk < 15) { /* pack keyword arguments */ - mrb_int kidx = a+(n==15?1:n)+1; - mrb_value kdict = hash_new_from_values(mrb, nk, regs+kidx); - regs[kidx] = kdict; - nk = 15; - c = n | (nk<<4); - } - - mrb_assert(bidx < irep->nregs+a); - mrb_value blk; - mrb_int new_bidx = a+mrb_bidx(c); - if (insn == OP_SEND) { - /* clear block argument */ - SET_NIL_VALUE(regs[new_bidx]); - SET_NIL_VALUE(blk); - } - else { - blk = regs[bidx]; - if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) { - blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); - /* The stack might have been reallocated during mrb_type_convert(), - see #3622 */ - } - regs[new_bidx] = blk; - } + ARGUMENT_NORMALIZE(a, &c, insn); recv = regs[a]; cls = mrb_class(mrb, recv); @@ -1718,7 +1720,6 @@ RETRY_TRY_BLOCK: mrb_method_t m; struct RClass *cls; mrb_callinfo *ci = mrb->c->ci; - mrb_int bidx = mrb_bidx(b)+a; mrb_value recv, blk; const struct RProc *p = ci->proc; mrb_sym mid = ci->mid; @@ -1727,20 +1728,6 @@ RETRY_TRY_BLOCK: if (MRB_PROC_ENV_P(p) && p->e.env->mid && p->e.env->mid != mid) { /* alias support */ mid = p->e.env->mid; /* restore old mid */ } - mrb_assert(bidx < irep->nregs); - - blk = regs[bidx]; - uint8_t nk = (b >> 4) & 0x0f; - if (nk > 0 && nk < CALL_MAXARGS) { /* pack keyword arguments */ - uint8_t n = b & 0x0f; - mrb_int kidx = a+(n==15?1:n)+1; - mrb_value kdict = hash_new_from_values(mrb, nk, regs+kidx); - regs[kidx] = kdict; - nk = 15; - b = n | (nk<<4); - bidx = kidx + 1; - regs[bidx] = blk; - } if (mid == 0 || !target_class) { mrb_value exc = mrb_exc_new_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method"); @@ -1764,13 +1751,9 @@ RETRY_TRY_BLOCK: mrb_exc_set(mrb, exc); goto L_RAISE; } - if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) { - blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc)); - /* The stack or ci stack might have been reallocated during - mrb_type_convert(), see #3622 and #3784 */ - regs[bidx] = blk; - ci = mrb->c->ci; - } + + ARGUMENT_NORMALIZE(a, &b, OP_SUPER); + cls = target_class->super; m = mrb_method_search_vm(mrb, &cls, mid); if (MRB_METHOD_UNDEF_P(m)) { From 6dfc47f5d408b947c63f60bce88901bb9b76331e Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 5 Feb 2022 17:41:01 +0900 Subject: [PATCH 056/292] Check the type of the keyword rest argument If a non-hash object is passed in `OP_SEND` and `OP_SUPER`, an error should occur. ```ruby kwd = "string" p(**kwd) # => expect raised TypeError ``` --- src/vm.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/vm.c b/src/vm.c index a0d09e608..a4b2442d3 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1167,7 +1167,10 @@ mrb_value mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value idx, mrb_value l int n = *(arg_info)&0xf; \ int nk = (*(arg_info)>>4)&0xf; \ mrb_int bidx = (arg_base) + mrb_bidx(*(arg_info)); \ - if (0 < nk && nk < CALL_MAXARGS) { /* pack keyword arguments */ \ + if (nk == CALL_MAXARGS) { \ + mrb_ensure_hash_type(mrb, regs[(arg_base)+(n==CALL_MAXARGS?1:n)+1]); \ + } \ + else if (nk > 0) { /* pack keyword arguments */ \ mrb_int kidx = (arg_base)+(n==CALL_MAXARGS?1:n)+1; \ mrb_value kdict = hash_new_from_values(mrb, nk, regs+kidx); \ regs[kidx] = kdict; \ From faffc0c4d3ab1c04790887b0c1852d6e6557ecb4 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 5 Feb 2022 21:42:54 +0900 Subject: [PATCH 057/292] Pinning the Visual Studio version in GitHub Actions Until now, `windows-latest` meant `windows-2019`, but now it seems that it is being replaced by `windows-2022` in stages. At the same time, Visual Studio 2019 will be replaced by Visual Studio 2022. Since mruby's CI is configured to assume Visual Studio 2019, we'll update this and explicitly specify `windows-2022`. --- .github/workflows/build.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index bf963ff0b..3a1ef5e2a 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -140,7 +140,7 @@ jobs: run: echo '::set-env name=PATH::C:\windows\System32' Windows-VC: - runs-on: windows-latest + runs-on: windows-2022 timeout-minutes: 10 env: MRUBY_CONFIG: ci/msvc @@ -151,5 +151,5 @@ jobs: - name: Build and test shell: cmd run: | - call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat" + call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" rake -m test:build && rake test:run From d6773cbd71d87a683dc58c5d3d30d384b93502b8 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Feb 2022 15:45:13 +0900 Subject: [PATCH 058/292] Avoid direct access to error messages as instance variables ref. #2485 The `SystemCallError#to_s` method also needed to be modified, but since it has no functional difference from the `Exception#to_s` method, it will be removed. --- include/mruby/error.h | 2 ++ mrbgems/mruby-errno/src/errno.c | 12 +++--------- src/error.c | 20 ++++++++++---------- 3 files changed, 15 insertions(+), 19 deletions(-) diff --git a/include/mruby/error.h b/include/mruby/error.h index 80c21434f..b53b1bacf 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -30,6 +30,8 @@ MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value st MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv); mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc); mrb_value mrb_get_backtrace(mrb_state *mrb); +void mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg); +mrb_value mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc); MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...); diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 74df5d0fc..8346dfbc3 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -1,6 +1,7 @@ #include "mruby.h" #include "mruby/array.h" #include "mruby/class.h" +#include "mruby/error.h" #include "mruby/hash.h" #include "mruby/numeric.h" #include "mruby/string.h" @@ -51,7 +52,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self, mrb_value m, mrb_int n) mrb_str_cat2(mrb, str, " - "); mrb_str_append(mrb, str, m); } - mrb_iv_set(mrb, self, MRB_SYM(mesg), str); + mrb_exc_mesg_set(mrb, mrb_exc_ptr(self), str); } static mrb_value @@ -89,12 +90,6 @@ mrb_sce_errno(mrb_state *mrb, mrb_value self) } } -static mrb_value -mrb_sce_to_s(mrb_state *mrb, mrb_value self) -{ - return mrb_attr_get(mrb, self, MRB_SYM(mesg)); -} - static mrb_value mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) { @@ -132,7 +127,7 @@ mrb_exxx_init(mrb_state *mrb, mrb_value self) mrb_str_cat2(mrb, str, " - "); mrb_str_append(mrb, str, m); } - mrb_iv_set(mrb, self, MRB_SYM(mesg), str); + mrb_exc_mesg_set(mrb, mrb_exc_ptr(self), str); return self; } @@ -147,7 +142,6 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) sce = mrb_define_class(mrb, "SystemCallError", ste); mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sce, "errno", mrb_sce_errno, MRB_ARGS_NONE()); - mrb_define_method(mrb, sce, "to_s", mrb_sce_to_s, MRB_ARGS_NONE()); mrb_define_method(mrb, sce, "initialize", mrb_sce_init_m, MRB_ARGS_ARG(1, 1)); eno = mrb_define_module_id(mrb, MRB_SYM(Errno)); diff --git a/src/error.c b/src/error.c index e651e3ad8..faea9616d 100644 --- a/src/error.c +++ b/src/error.c @@ -17,8 +17,8 @@ #include #include -static void -exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg) +void +mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg) { if (mrb_string_p(mesg)) { exc->flags |= MRB_EXC_MESG_STRING_FLAG; @@ -36,8 +36,8 @@ exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg) } } -static mrb_value -exc_mesg_get(mrb_state *mrb, struct RException *exc) +mrb_value +mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc) { if ((exc->flags & MRB_EXC_MESG_STRING_FLAG) != 0) { return mrb_obj_value(exc->mesg); @@ -52,9 +52,9 @@ mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str) { mrb_ensure_string_type(mrb, str); - struct RBasic* e = mrb_obj_alloc(mrb, MRB_TT_EXCEPTION, c); + struct RException *e = MRB_OBJ_ALLOC(mrb, MRB_TT_EXCEPTION, c); mrb_value exc = mrb_obj_value(e); - mrb_iv_set(mrb, exc, MRB_SYM(mesg), str); + mrb_exc_mesg_set(mrb, e, str); return exc; } @@ -78,7 +78,7 @@ exc_initialize(mrb_state *mrb, mrb_value exc) mrb_value mesg; if (mrb_get_args(mrb, "|o", &mesg) == 1) { - exc_mesg_set(mrb, mrb_exc_ptr(exc), mesg); + mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), mesg); } return exc; } @@ -107,7 +107,7 @@ exc_exception(mrb_state *mrb, mrb_value self) if (argc == 0) return self; if (mrb_obj_equal(mrb, self, a)) return self; exc = mrb_obj_clone(mrb, self); - exc_mesg_set(mrb, mrb_exc_ptr(exc), a); + mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), a); return exc; } @@ -123,7 +123,7 @@ exc_exception(mrb_state *mrb, mrb_value self) static mrb_value exc_to_s(mrb_state *mrb, mrb_value exc) { - mrb_value mesg = exc_mesg_get(mrb, mrb_exc_ptr(exc)); + mrb_value mesg = mrb_exc_mesg_get(mrb, mrb_exc_ptr(exc)); struct RObject *p; if (!mrb_string_p(mesg)) { @@ -163,7 +163,7 @@ exc_message(mrb_state *mrb, mrb_value exc) mrb_value mrb_exc_inspect(mrb_state *mrb, mrb_value exc) { - mrb_value mesg = exc_mesg_get(mrb, mrb_exc_ptr(exc)); + mrb_value mesg = mrb_exc_mesg_get(mrb, mrb_exc_ptr(exc)); mrb_value cname = mrb_mod_to_s(mrb, mrb_obj_value(mrb_obj_class(mrb, exc))); mesg = mrb_obj_as_string(mrb, mesg); return RSTRING_LEN(mesg) == 0 ? cname : mrb_format(mrb, "%v (%v)", mesg, cname); From a82220211ddb700cf9e3dc82c6e736eefe83e4b8 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Feb 2022 16:12:41 +0900 Subject: [PATCH 059/292] Support `MRB_NO_STDIO` for `mrbgems/mruby-errno` --- mrbgems/mruby-errno/src/errno.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 74df5d0fc..0fb952b2b 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -6,7 +6,6 @@ #include "mruby/string.h" #include "mruby/variable.h" #include -#include #include #include @@ -40,8 +39,8 @@ mrb_sce_init(mrb_state *mrb, mrb_value self, mrb_value m, mrb_int n) if (e2c[i].sym == 0) { mrb_iv_set(mrb, self, MRB_SYM(errno), mrb_fixnum_value(n)); str = mrb_str_new_cstr(mrb, "Unknown error: "); - snprintf(buf, sizeof(buf), "%d", (int)n); - mrb_str_cat2(mrb, str, buf); + char *bp = mrb_int_to_cstr(buf, sizeof(buf), n, 10); + mrb_str_cat2(mrb, str, bp); } } else { From 0a4f21c60f02e462c42f2822e4a526ca73a5eb19 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Feb 2022 18:39:46 +0900 Subject: [PATCH 060/292] Support `disable_presym` for `mrbgems/mruby-errno` The `mrbgems/mruby-errno/src/known_errors_def.cstub` file has been extended, so the `mrbgems/mruby-errno/src/known_errors_e2c.cstub` file is no longer needed. --- mrbgems/mruby-errno/src/errno.c | 42 +- mrbgems/mruby-errno/src/gen.rb | 11 +- .../mruby-errno/src/known_errors_def.cstub | 624 +++++++++--------- .../mruby-errno/src/known_errors_e2c.cstub | 468 ------------- 4 files changed, 343 insertions(+), 802 deletions(-) delete mode 100644 mrbgems/mruby-errno/src/known_errors_e2c.cstub diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 74df5d0fc..480f3bdda 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -10,14 +10,30 @@ #include #include -static struct { +static const struct { +#ifdef MRB_NO_PRESYM +#define itsdefined(name, sym) { #name, name }, + const char *name; +#else +#define itsdefined(name, sym) { sym, name }, mrb_sym sym; +#endif int eno; } e2c[] = { -#include "known_errors_e2c.cstub" - {0, 0}, +#define itsnotdefined(name, sym) +#include "known_errors_def.cstub" +#undef itsdefined +#undef itsnotdefined }; +#ifdef MRB_NO_PRESYM +#define ENTRY_SYM(e) mrb_intern_static(mrb, (e).name, strlen((e).name)) +#else +#define ENTRY_SYM(e) (e).sym +#endif + +#define E2C_LEN (sizeof(e2c) / sizeof(e2c[0])) + static void mrb_sce_init(mrb_state *mrb, mrb_value self, mrb_value m, mrb_int n) { @@ -30,14 +46,14 @@ mrb_sce_init(mrb_state *mrb, mrb_value self, mrb_value m, mrb_int n) if (!no_errno) { int i; - for (i=0; e2c[i].sym != 0; i++) { + for (i=0; i < E2C_LEN; i++) { if (e2c[i].eno == n) { - mrb_basic_ptr(self)->c = mrb_class_get_under_id(mrb, m_errno, e2c[i].sym); + mrb_basic_ptr(self)->c = mrb_class_get_under_id(mrb, m_errno, ENTRY_SYM(e2c[i])); str = mrb_str_new_cstr(mrb, strerror(n)); break; } } - if (e2c[i].sym == 0) { + if (i == E2C_LEN) { mrb_iv_set(mrb, self, MRB_SYM(errno), mrb_fixnum_value(n)); str = mrb_str_new_cstr(mrb, "Unknown error: "); snprintf(buf, sizeof(buf), "%d", (int)n); @@ -158,19 +174,19 @@ mrb_mruby_errno_gem_init(mrb_state *mrb) //mrb_define_method(mrb, e, "===", mrb_exxx_cmp, MRB_ARGS_REQ(1)); noerror = mrb_obj_value(e); -#define itsdefined(SYM) \ +#define itsdefined(name, sym) \ do { \ int ai = mrb_gc_arena_save(mrb); \ - e = mrb_define_class_under(mrb, eno, #SYM, sce); \ - mrb_define_const_id(mrb, e, MRB_SYM(Errno), mrb_fixnum_value(SYM)); \ + e = mrb_define_class_under_id(mrb, eno, sym, sce); \ + mrb_define_const_id(mrb, e, MRB_SYM(Errno), mrb_fixnum_value(name)); \ mrb_define_method(mrb, e, "initialize", mrb_exxx_init, MRB_ARGS_OPT(1)); \ mrb_gc_arena_restore(mrb, ai); \ - } while (0) + } while (0); -#define itsnotdefined(SYM) \ +#define itsnotdefined(name, sym) \ do { \ - mrb_define_const(mrb, eno, #SYM, noerror); \ - } while (0) + mrb_define_const_id(mrb, eno, sym, noerror); \ + } while (0); #include "known_errors_def.cstub" } diff --git a/mrbgems/mruby-errno/src/gen.rb b/mrbgems/mruby-errno/src/gen.rb index 6a0327dd3..a9a6c8ee0 100755 --- a/mrbgems/mruby-errno/src/gen.rb +++ b/mrbgems/mruby-errno/src/gen.rb @@ -2,24 +2,17 @@ Dir.chdir(File.dirname($0)) -e = File.open("known_errors_e2c.cstub", "w") d = File.open("known_errors_def.cstub", "w") IO.readlines("known_errors.def").each { |name| next if name =~ /^#/ name.strip! - e.write < Date: Fri, 4 Feb 2022 16:05:02 +0900 Subject: [PATCH 061/292] mruby.c: `-b` option should only affects the script. Not the libraries loaded by `-r`. Instead, `.mrb` extension in the path should determine whether they are compiled binary. --- mrbgems/mruby-bin-mruby/tools/mruby/mruby.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c b/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c index b189aca69..ed6240dbf 100644 --- a/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c +++ b/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c @@ -63,6 +63,16 @@ usage(const char *name) printf(" %s\n", *p++); } +static mrb_bool +mrb_extension_p(const char *path) +{ + const char *e = rindex(path, '.'); + if (e && e[1] == 'm' && e[2] == 'r' && e[3] == 'b' && e[4] == '\0') { + return TRUE; + } + return FALSE; +} + static void options_init(struct options *opts, int argc, char **argv) { @@ -323,7 +333,7 @@ main(int argc, char **argv) return EXIT_FAILURE; } mrbc_filename(mrb, c, args.libv[i]); - if (args.mrbfile) { + if (mrb_extension_p(args.libv[i])) { v = mrb_load_irep_file_cxt(mrb, lfp, c); } else { @@ -340,7 +350,7 @@ main(int argc, char **argv) mrbc_filename(mrb, c, cmdline); /* Load program */ - if (args.mrbfile) { + if (args.mrbfile || mrb_extension_p(cmdline)) { v = mrb_load_irep_file_cxt(mrb, args.rfp, c); } else if (args.rfp) { From d42a64eadfc060f147163aef48e068ca371d90dd Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 6 Feb 2022 22:17:53 +0900 Subject: [PATCH 062/292] vm.c: add assertion for type of register values. We used to check them by `mrb_ensure_xxx_type()` functions, but type errors there should not occur if there's no bug in code generations. So we use assertion rather than dynamic type checks. --- src/vm.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/vm.c b/src/vm.c index a4b2442d3..61464de5f 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2618,7 +2618,7 @@ RETRY_TRY_BLOCK: regs[a] = splat; } else { - mrb_assert(mrb_type(regs[a]) == MRB_TT_ARRAY); + mrb_assert(mrb_array_p(regs[a])); mrb_ary_concat(mrb, regs[a], splat); } mrb_gc_arena_restore(mrb, ai); @@ -2626,7 +2626,7 @@ RETRY_TRY_BLOCK: } CASE(OP_ARYPUSH, BB) { - mrb_assert(mrb_type(regs[a]) == MRB_TT_ARRAY); + mrb_assert(mrb_array_p(regs[a])); for (mrb_int i=0; i Date: Sun, 6 Feb 2022 22:44:02 +0900 Subject: [PATCH 063/292] mruby.c: `rindex()` is not supported by VC. --- mrbgems/mruby-bin-mruby/tools/mruby/mruby.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c b/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c index ed6240dbf..1822a585d 100644 --- a/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c +++ b/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c @@ -66,7 +66,7 @@ usage(const char *name) static mrb_bool mrb_extension_p(const char *path) { - const char *e = rindex(path, '.'); + const char *e = strrchr(path, '.'); if (e && e[1] == 'm' && e[2] == 'r' && e[3] == 'b' && e[4] == '\0') { return TRUE; } From 4f986060c002eb5702f7b783befedca1c18f1864 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Mon, 7 Feb 2022 19:52:08 +1000 Subject: [PATCH 064/292] pre-commit autoupdate https://pre-commit.com/#pre-commit-autoupdate --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 266f88c83..a39da4e08 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -39,7 +39,7 @@ repos: description: Check spelling with codespell entry: codespell --ignore-words=codespell.txt - repo: https://github.com/igorshubovych/markdownlint-cli - rev: v0.30.0 + rev: v0.31.0 hooks: - id: markdownlint name: Run markdownlint From 182096d8c0d01121ed36baa3c4e2223b201ba22b Mon Sep 17 00:00:00 2001 From: Koichi ITO Date: Tue, 8 Feb 2022 09:03:07 +0900 Subject: [PATCH 065/292] Make `Array#*` the CRuby compatible behavior when giving a string argument ## Summary This following is a behavior from CRuby 1.8.7 to 3.1.0. ```console % ruby -ve "p ['a', 'b', 'c']*''" ruby 1.8.7 (2013-12-22 patchlevel 375) [i686-darwin13.0.2] "abc" % ruby -ve "p ['a', 'b', 'c']*''" ruby 3.1.0p0 (2021-12-25 revision fb4df44d16) [x86_64-darwin19] "abc" ``` ### Before (mruby 3.0.0) mruby unexpectedly gives the TypeError. ```ruby ['a', 'b', 'c']*'' #=> String cannot be converted to Integer (TypeError) ``` ### After This PR makes mruby behave compatible with CRuby. ```ruby ['a', 'b', 'c']*'' #=> 'abc' ``` As far as I checked, the behavior is unspecified when `Array#*`'s argument is not an instance of Integer class in X 3017 : 2013 (ISO/IEC 30170 : 2012). ## Additional Information I noticed this difference by the following idiom when writing ASCII art code using Ruby. ```ruby %w(foo bar baz)*'' ``` e.g. TRICK (https://github.com/tric) --- src/array.c | 8 +++++++- test/t/array.rb | 2 ++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/src/array.c b/src/array.c index 1a95b75c9..07ceefb7e 100644 --- a/src/array.c +++ b/src/array.c @@ -425,9 +425,15 @@ mrb_ary_times(mrb_state *mrb, mrb_value self) { struct RArray *a1 = mrb_ary_ptr(self); struct RArray *a2; - mrb_value *ptr; + mrb_value *ptr, sep, tmp; mrb_int times, len1; + mrb_get_args(mrb, "o", &sep); + tmp = mrb_check_string_type(mrb, sep); + if (!mrb_nil_p(tmp)) { + return mrb_ary_join(mrb, self, tmp); + } + mrb_get_args(mrb, "i", ×); if (times < 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argument"); diff --git a/test/t/array.rb b/test/t/array.rb index 5f26259f2..eccb435ef 100644 --- a/test/t/array.rb +++ b/test/t/array.rb @@ -32,6 +32,8 @@ assert('Array#*', '15.2.12.5.2') do end assert_equal([1, 1, 1], [1].*(3)) assert_equal([], [1].*(0)) + assert_equal('abc', ['a', 'b', 'c'].*('')) + assert_equal('0, 0, 1, {:foo=>0}', [0, [0, 1], {foo: 0}].*(', ')) end assert('Array#<<', '15.2.12.5.3') do From 6f5e74f576f0ae59d584bbbc4c8e8f4c91e2649e Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 7 Feb 2022 15:42:15 +0900 Subject: [PATCH 066/292] codegen.c: change `size_t` to `uint16_t` To remove type conversion warnings. --- mrbgems/mruby-compiler/core/codegen.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index a7420a62b..70b7d3703 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -57,7 +57,7 @@ typedef struct scope { uint32_t pc; uint32_t lastpc; uint32_t lastlabel; - size_t ainfo:15; + uint16_t ainfo:15; mrb_bool mscope:1; struct loopinfo *loop; @@ -2953,7 +2953,7 @@ codegen(codegen_scope *s, node *tree, int val) { codegen_scope *s2 = s; int lv = 0; - size_t ainfo = 0; + uint16_t ainfo = 0; int n = CALL_MAXARGS; int sp = cursp(); From 4c13188ea6cb0a74f43542c1b485a4aaf1d1a5be Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Feb 2022 12:44:50 +0900 Subject: [PATCH 067/292] codegen.c: generate `OP_HASH` in `gen_hash()` if `limit` exceeds. That means when `limit` is `0` it should always generate a hash. --- mrbgems/mruby-compiler/core/codegen.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 70b7d3703..4a9fb9aeb 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1643,6 +1643,12 @@ gen_hash(codegen_scope *s, node *tree, int val, int limit) len = 0; } } + if (val && len > limit) { + pop_n(len*2); + genop_2(s, OP_HASH, cursp(), len); + push(); + return -1; + } if (update) { if (val && len > 0) { pop_n(len*2+1); From 0849a2885f81cfd82134992c06df3ccd59052ac7 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Feb 2022 12:46:36 +0900 Subject: [PATCH 068/292] codegen.c: stack position may be wrong on assignments. When `[]=` access includes keyword arguments. --- mrbgems/mruby-compiler/core/codegen.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 4a9fb9aeb..86f88b6e6 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1865,15 +1865,21 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) } } if (tree->cdr->car) { /* keyword arguments */ + if (n == 14) { + pop_n(n); + genop_2(s, OP_ARRAY, cursp(), n); + push(); + n = 15; + } gen_hash(s, tree->cdr->car->cdr, VAL, 0); if (n < 14) { n++; - push(); } else { - pop(); + pop_n(2); genop_2(s, OP_ARYPUSH, cursp(), 1); } + push(); } } if (rhs) { From 4562ba14c0f716b6dfd56b83844100747ba6c85c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Feb 2022 12:47:50 +0900 Subject: [PATCH 069/292] codegen.c: `limit` check was too restrictive in `gen_values()`. That can create unnecessary arrays when more than 12 arguments are given to a method. --- mrbgems/mruby-compiler/core/codegen.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 86f88b6e6..c49ea7514 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1551,7 +1551,7 @@ gen_values(codegen_scope *s, node *t, int val, int limit) while (t) { int is_splat = nint(t->car->car) == NODE_SPLAT; - if (is_splat || n >= limit-1 || cursp() >= slimit) { /* flush stack */ + if (is_splat || n > limit || cursp() >= slimit) { /* flush stack */ pop_n(n); if (first) { if (n == 0) { From 9037e447a536133559cf5ba2bab9952ac594b723 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Feb 2022 13:02:24 +0900 Subject: [PATCH 070/292] numeric.c: avoid implicit cast from integer to double. --- src/numeric.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/numeric.c b/src/numeric.c index fb3c0e48f..7a6f8d765 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -733,12 +733,12 @@ flo_ceil_floor(mrb_state *mrb, mrb_value num, double (*func)(double)) } if (ndigits > 0) { if (ndigits > fprec) return num; - mrb_float d = pow(10, ndigits); + mrb_float d = pow(10, (double)ndigits); f = func(f * d) / d; return mrb_float_value(mrb, f); } if (ndigits < 0) { - mrb_float d = pow(10, -ndigits); + mrb_float d = pow(10, (double)-ndigits); f = func(f / d) * d; } else { /* ndigits == 0 */ From 4e8ab145da52c3cfb0bd4b823df8041dcc52f454 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Feb 2022 13:03:51 +0900 Subject: [PATCH 071/292] vm.c: adjust integer types. --- src/vm.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/vm.c b/src/vm.c index 61464de5f..6133cbcca 100644 --- a/src/vm.c +++ b/src/vm.c @@ -422,7 +422,7 @@ mrb_ci_nregs(mrb_callinfo *ci) const struct RProc *p; if (!ci) return 4; - uint8_t nregs = mrb_ci_bidx(ci) + 1; /* self + args + kargs + blk */ + mrb_int nregs = mrb_ci_bidx(ci) + 1; /* self + args + kargs + blk */ p = ci->proc; if (p && !MRB_PROC_CFUNC_P(p) && p->body.irep && p->body.irep->nregs > nregs) { return p->body.irep->nregs; @@ -471,7 +471,7 @@ prepare_missing(mrb_state *mrb, mrb_value recv, mrb_sym mid, struct RClass **cls argv[1] = argv[n]; argv[2] = blk; } - *c = 15 | (nk<<4); + *c = 15 | (uint16_t)(nk<<4); mrb_ary_unshift(mrb, args, mrb_symbol_value(mid)); return m; } From d912b864df3199f2108601a0451532c587a5e830 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 9 Feb 2022 13:32:20 +0900 Subject: [PATCH 072/292] mruby-range-ext/range.c: `cover?` should work with begin-less ranges. --- mrbgems/mruby-range-ext/src/range.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c index 633c97b73..9a88ef542 100644 --- a/mrbgems/mruby-range-ext/src/range.c +++ b/mrbgems/mruby-range-ext/src/range.c @@ -40,7 +40,7 @@ range_cover(mrb_state *mrb, mrb_value range) beg = RANGE_BEG(r); end = RANGE_END(r); - if (r_le(mrb, beg, val)) { + if (mrb_nil_p(beg) || r_le(mrb, beg, val)) { if (mrb_nil_p(end)) { return mrb_true_value(); } From fb82108acbbbb53f5f7fb9f76c6c3418f48cb896 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 10 Feb 2022 11:25:45 +0900 Subject: [PATCH 073/292] load.c: should check if length of irep sections are valid. --- src/load.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/load.c b/src/load.c index 9b8ffa384..263c958db 100644 --- a/src/load.c +++ b/src/load.c @@ -577,7 +577,8 @@ read_irep(mrb_state *mrb, const uint8_t *bin, size_t bufsize, uint8_t flags) } bin += sizeof(struct rite_binary_header); - do { + bin_size -= sizeof(struct rite_binary_header); + while (bin_size > sizeof(struct rite_section_header)) { section_header = (const struct rite_section_header *)bin; if (memcmp(section_header->section_ident, RITE_SECTION_IREP_IDENT, sizeof(section_header->section_ident)) == 0) { irep = read_section_irep(mrb, bin, flags, &proc); @@ -597,8 +598,14 @@ read_irep(mrb_state *mrb, const uint8_t *bin, size_t bufsize, uint8_t flags) return NULL; } } - bin += bin_to_uint32(section_header->section_size); - } while (memcmp(section_header->section_ident, RITE_BINARY_EOF, sizeof(section_header->section_ident)) != 0); + else if (memcmp(section_header->section_ident, RITE_BINARY_EOF, sizeof(section_header->section_ident)) != 0) { + break; + } + + uint32_t section_size = bin_to_uint32(section_header->section_size); + bin += section_size; + bin_size -= section_size; + } return proc; } From 38b164ace7d6ae1c367883a3d67d7f559783faad Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Feb 2022 12:39:35 +0900 Subject: [PATCH 074/292] codegen.c: fix a bug in `gen_values()`. - Fix limit handling that fails 15 arguments method calls. - Fix too early argument packing in arrays. --- mrbgems/mruby-compiler/core/codegen.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index c49ea7514..b90eae3e8 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1551,7 +1551,7 @@ gen_values(codegen_scope *s, node *t, int val, int limit) while (t) { int is_splat = nint(t->car->car) == NODE_SPLAT; - if (is_splat || n > limit || cursp() >= slimit) { /* flush stack */ + if (is_splat || cursp() >= slimit) { /* flush stack */ pop_n(n); if (first) { if (n == 0) { @@ -1590,6 +1590,11 @@ gen_values(codegen_scope *s, node *t, int val, int limit) } return -1; /* variable length */ } + else if (n > limit) { + pop_n(n); + genop_2(s, OP_ARRAY, cursp(), n); + return -1; + } return n; } From e884236e1cf347b4930e1a80367a6977b64a20e4 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 14 Feb 2022 10:52:36 +0900 Subject: [PATCH 075/292] dump.h, irep.h: update comments not to omit buffer length for loading. [ci skip] --- include/mruby/dump.h | 1 + include/mruby/irep.h | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/include/mruby/dump.h b/include/mruby/dump.h index fea0ac2b1..20400714c 100644 --- a/include/mruby/dump.h +++ b/include/mruby/dump.h @@ -30,6 +30,7 @@ mrb_irep *mrb_read_irep_file(mrb_state*, FILE*); MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*); MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*); #endif +/* avoid mrb_read_irep(); use mrb_read_irep_buf() instead (may cause buffer overflow) */ MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*); MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t); diff --git a/include/mruby/irep.h b/include/mruby/irep.h index 8382c3b18..ff78c1857 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -99,7 +99,7 @@ MRB_API mrb_value mrb_load_irep(mrb_state*, const uint8_t*); /* * @param [const void*] irep code - * @param [size_t] size of irep buffer. If -1 is given, it is considered unrestricted. + * @param [size_t] size of irep buffer. */ MRB_API mrb_value mrb_load_irep_buf(mrb_state*, const void*, size_t); @@ -108,7 +108,7 @@ MRB_API mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*); /* * @param [const void*] irep code - * @param [size_t] size of irep buffer. If -1 is given, it is considered unrestricted. + * @param [size_t] size of irep buffer. */ MRB_API mrb_value mrb_load_irep_buf_cxt(mrb_state*, const void*, size_t, mrbc_context*); From aba3d427c78e20965d99e6843bf4bf67b98cd8c1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 14 Feb 2022 16:04:44 +0900 Subject: [PATCH 076/292] state.c: `reps` may be NULL if a broken compiled binary given. --- src/state.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/state.c b/src/state.c index 4dafc964a..4045a0fed 100644 --- a/src/state.c +++ b/src/state.c @@ -137,6 +137,7 @@ mrb_irep_cutref(mrb_state *mrb, mrb_irep *irep) if (irep->flags & MRB_IREP_NO_FREE) return; reps = (mrb_irep**)irep->reps; + if (!reps) return; for (i=0; irlen; i++) { mrb_irep *tmp = reps[i]; reps[i] = NULL; From ecb28f4bf463483cf914c799d086b0cfff997aee Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 14 Feb 2022 16:05:54 +0900 Subject: [PATCH 077/292] load.c: add data boundary check for broken compiled binary. --- src/load.c | 80 ++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 53 insertions(+), 27 deletions(-) diff --git a/src/load.c b/src/load.c index 263c958db..bb22a6130 100644 --- a/src/load.c +++ b/src/load.c @@ -59,7 +59,7 @@ str_to_double(mrb_state *mrb, const char *p) #endif static mrb_bool -read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags, mrb_irep **irepp) +read_irep_record_1(mrb_state *mrb, const uint8_t *bin, const uint8_t *end, size_t *len, uint8_t flags, mrb_irep **irepp) { int i; const uint8_t *src = bin; @@ -102,6 +102,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) { return FALSE; } + if (src + data_len > end) return FALSE; if ((flags & FLAG_SRC_MALLOC) == 0) { irep->iseq = (mrb_code*)src; irep->flags |= MRB_ISEQ_NO_FREE; @@ -117,6 +118,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag /* POOL BLOCK */ plen = bin_to_uint16(src); /* number of pool */ src += sizeof(uint16_t); + if (src > end) return FALSE; if (plen > 0) { if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) { return FALSE; @@ -130,6 +132,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag switch (tt) { /* pool data */ case IREP_TT_INT32: { + if (src + sizeof(uint32_t) > end) return FALSE; mrb_int v = (int32_t)bin_to_uint32(src); src += sizeof(uint32_t); #ifdef MRB_64BIT @@ -144,6 +147,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag case IREP_TT_INT64: #ifdef MRB_INT64 { + if (src + sizeof(uint32_t)*2 > end) return FALSE; uint64_t i64 = bin_to_uint32(src); src += sizeof(uint32_t); i64 <<= 32; @@ -160,6 +164,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag case IREP_TT_BIGINT: pool_data_len = bin_to_uint8(src); /* pool data length */ src += sizeof(uint8_t); + if (src + pool_data_len > end) return FALSE; { char *p; pool[i].tt = IREP_TT_BIGINT; @@ -172,6 +177,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag case IREP_TT_FLOAT: #ifndef MRB_NO_FLOAT + if (src + sizeof(double) > end) return FALSE; pool[i].tt = tt; pool[i].u.f = str_to_double(mrb, (const char*)src); src += sizeof(double); @@ -183,6 +189,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag case IREP_TT_STR: pool_data_len = bin_to_uint16(src); /* pool data length */ src += sizeof(uint16_t); + if (src + pool_data_len > end) return FALSE; if (st) { pool[i].tt = (pool_data_len<<2) | IREP_TT_SSTR; pool[i].u.str = (const char*)src; @@ -208,6 +215,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag /* SYMS BLOCK */ irep->slen = bin_to_uint16(src); /* syms length */ src += sizeof(uint16_t); + if (src > end) return FALSE; if (irep->slen > 0) { if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) { return FALSE; @@ -223,6 +231,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag continue; } + if (src + snl > end) return FALSE; if (flags & FLAG_SRC_MALLOC) { syms[i] = mrb_intern(mrb, (char *)src, snl); } @@ -242,10 +251,10 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag } static mrb_bool -read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags, mrb_irep **irepp) +read_irep_record(mrb_state *mrb, const uint8_t *bin, const uint8_t *end, size_t *len, uint8_t flags, mrb_irep **irepp) { int ai = mrb_gc_arena_save(mrb); - mrb_bool readsuccess = read_irep_record_1(mrb, bin, len, flags, irepp); + mrb_bool readsuccess = read_irep_record_1(mrb, bin, end, len, flags, irepp); mrb_irep **reps; int i; @@ -261,7 +270,7 @@ read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags, for (i=0; i<(*irepp)->rlen; i++) { size_t rlen; - readsuccess = read_irep_record(mrb, bin, &rlen, flags, &reps[i]); + readsuccess = read_irep_record(mrb, bin, end, &rlen, flags, &reps[i]); mrb_gc_arena_restore(mrb, ai); if (!readsuccess) { return FALSE; @@ -274,10 +283,9 @@ read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags, } static mrb_irep* -read_section_irep(mrb_state *mrb, const uint8_t *bin, uint8_t flags, struct RProc **proc) +read_section_irep(mrb_state *mrb, const uint8_t *bin, size_t size, uint8_t flags, struct RProc **proc) { - size_t len; - + if (size < sizeof(struct rite_section_irep_header)) return NULL; /* * This proc object keeps all the data in progress to avoid memory leaks * if something goes wrong while reading irep. @@ -285,8 +293,9 @@ read_section_irep(mrb_state *mrb, const uint8_t *bin, uint8_t flags, struct RPro *proc = mrb_proc_new(mrb, NULL); mrb_irep **irepp = (mrb_irep**)&(*proc)->body.irep; + size_t len; bin += sizeof(struct rite_section_irep_header); - if (read_irep_record(mrb, bin, &len, flags, irepp)) { + if (read_irep_record(mrb, bin, bin+size, &len, flags, irepp)) { return *irepp; } else { @@ -295,7 +304,7 @@ read_section_irep(mrb_state *mrb, const uint8_t *bin, uint8_t flags, struct RPro } static int -read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *record_len, const mrb_sym *filenames, size_t filenames_len) +read_debug_record(mrb_state *mrb, const uint8_t *start, const uint8_t *end, mrb_irep* irep, size_t *record_len, const mrb_sym *filenames, size_t filenames_len) { const uint8_t *bin = start; ptrdiff_t diff; @@ -313,13 +322,15 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * bin += sizeof(uint32_t); debug->flen = bin_to_uint16(bin); - debug->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*)); bin += sizeof(uint16_t); + if (bin > end) return MRB_DUMP_GENERAL_FAILURE; + debug->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*)); for (f_idx = 0; f_idx < debug->flen; ++f_idx) { mrb_irep_debug_info_file *file; uint16_t filename_idx; + if (bin > end) return MRB_DUMP_GENERAL_FAILURE; file = (mrb_irep_debug_info_file *)mrb_calloc(mrb, 1, sizeof(*file)); debug->files[f_idx] = file; @@ -338,9 +349,10 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * bin += sizeof(uint8_t); switch (file->line_type) { case mrb_debug_line_ary: { - uint32_t l; + size_t l = sizeof(uint16_t) * (size_t)file->line_entry_count; - file->lines.ary = (uint16_t *)mrb_malloc(mrb, sizeof(uint16_t) * (size_t)(file->line_entry_count)); + if (bin + l > end) return MRB_DUMP_GENERAL_FAILURE; + file->lines.ary = (uint16_t *)mrb_malloc(mrb, l); for (l = 0; l < file->line_entry_count; ++l) { file->lines.ary[l] = bin_to_uint16(bin); bin += sizeof(uint16_t); @@ -348,11 +360,12 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * } break; case mrb_debug_line_flat_map: { - uint32_t l; + size_t c = (size_t)file->line_entry_count; + size_t n = sizeof(mrb_irep_debug_info_line); - file->lines.flat_map = (mrb_irep_debug_info_line*)mrb_calloc( - mrb, (size_t)(file->line_entry_count), sizeof(mrb_irep_debug_info_line)); - for (l = 0; l < file->line_entry_count; ++l) { + if (bin + c*n > end) return MRB_DUMP_GENERAL_FAILURE; + file->lines.flat_map = (mrb_irep_debug_info_line*)mrb_calloc(mrb, c, n); + for (size_t l = 0; l < file->line_entry_count; ++l) { file->lines.flat_map[l].start_pos = bin_to_uint32(bin); bin += sizeof(uint32_t); file->lines.flat_map[l].line = bin_to_uint16(bin); @@ -361,7 +374,10 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * } break; case mrb_debug_line_packed_map: { - file->lines.packed_map = (uint8_t*)mrb_calloc(mrb, 1, (size_t)file->line_entry_count); + size_t l = (size_t)file->line_entry_count; + + if (bin + l > end) return MRB_DUMP_GENERAL_FAILURE; + file->lines.packed_map = (uint8_t*)mrb_calloc(mrb, 1, l); memcpy(file->lines.packed_map, bin, file->line_entry_count); bin += file->line_entry_count; } break; @@ -381,7 +397,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * size_t len; int ret; - ret = read_debug_record(mrb, bin, (mrb_irep*)irep->reps[i], &len, filenames, filenames_len); + ret = read_debug_record(mrb, bin, end, (mrb_irep*)irep->reps[i], &len, filenames, filenames_len); if (ret != MRB_DUMP_OK) return ret; bin += len; } @@ -394,9 +410,10 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * } static int -read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t flags) +read_section_debug(mrb_state *mrb, const uint8_t *start, size_t size, mrb_irep *irep, uint8_t flags) { const uint8_t *bin; + const uint8_t *end = start + size; ptrdiff_t diff; struct rite_section_debug_header *header; uint16_t i; @@ -412,11 +429,16 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t filenames_len = bin_to_uint16(bin); bin += sizeof(uint16_t); + if (bin > end) return MRB_DUMP_GENERAL_FAILURE; filenames_obj = mrb_str_new(mrb, NULL, sizeof(mrb_sym) * (size_t)filenames_len); filenames = (mrb_sym*)RSTRING_PTR(filenames_obj); for (i = 0; i < filenames_len; ++i) { uint16_t f_len = bin_to_uint16(bin); bin += sizeof(uint16_t); + if (bin + f_len > end) { + result = MRB_DUMP_GENERAL_FAILURE; + goto debug_exit; + } if (flags & FLAG_SRC_MALLOC) { filenames[i] = mrb_intern(mrb, (const char *)bin, (size_t)f_len); } @@ -426,7 +448,7 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t bin += f_len; } - result = read_debug_record(mrb, bin, irep, &len, filenames, filenames_len); + result = read_debug_record(mrb, bin, end, irep, &len, filenames, filenames_len); if (result != MRB_DUMP_OK) goto debug_exit; bin += len; @@ -449,6 +471,7 @@ read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *rec ptrdiff_t diff; int i; + if (irep->nlocals == 0) return MRB_DUMP_GENERAL_FAILURE; irep->lv = lv = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (irep->nlocals - 1)); for (i = 0; i + 1 < irep->nlocals; ++i) { @@ -482,9 +505,10 @@ read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *rec } static int -read_section_lv(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t flags) +read_section_lv(mrb_state *mrb, const uint8_t *start, size_t size, mrb_irep *irep, uint8_t flags) { const uint8_t *bin; + const uint8_t *end = start + size; ptrdiff_t diff; struct rite_section_lv_header const *header; uint32_t i; @@ -502,12 +526,13 @@ read_section_lv(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t fl syms_len = bin_to_uint32(bin); bin += sizeof(uint32_t); + if (bin > end) return MRB_DUMP_READ_FAULT; syms_obj = mrb_str_new(mrb, NULL, sizeof(mrb_sym) * (size_t)syms_len); syms = (mrb_sym*)RSTRING_PTR(syms_obj); for (i = 0; i < syms_len; ++i) { uint16_t const str_len = bin_to_uint16(bin); bin += sizeof(uint16_t); - + if (bin > end) return MRB_DUMP_READ_FAULT; syms[i] = intern_func(mrb, (const char*)bin, str_len); bin += str_len; } @@ -580,20 +605,22 @@ read_irep(mrb_state *mrb, const uint8_t *bin, size_t bufsize, uint8_t flags) bin_size -= sizeof(struct rite_binary_header); while (bin_size > sizeof(struct rite_section_header)) { section_header = (const struct rite_section_header *)bin; + uint32_t section_size = bin_to_uint32(section_header->section_size); + if (bin_size < section_size) return NULL; if (memcmp(section_header->section_ident, RITE_SECTION_IREP_IDENT, sizeof(section_header->section_ident)) == 0) { - irep = read_section_irep(mrb, bin, flags, &proc); + irep = read_section_irep(mrb, bin, bin_size, flags, &proc); if (!irep) return NULL; } else if (memcmp(section_header->section_ident, RITE_SECTION_DEBUG_IDENT, sizeof(section_header->section_ident)) == 0) { if (!irep) return NULL; /* corrupted data */ - result = read_section_debug(mrb, bin, irep, flags); + result = read_section_debug(mrb, bin, bin_size, irep, flags); if (result < MRB_DUMP_OK) { return NULL; } } else if (memcmp(section_header->section_ident, RITE_SECTION_LV_IDENT, sizeof(section_header->section_ident)) == 0) { if (!irep) return NULL; - result = read_section_lv(mrb, bin, irep, flags); + result = read_section_lv(mrb, bin, bin_size, irep, flags); if (result < MRB_DUMP_OK) { return NULL; } @@ -602,7 +629,6 @@ read_irep(mrb_state *mrb, const uint8_t *bin, size_t bufsize, uint8_t flags) break; } - uint32_t section_size = bin_to_uint32(section_header->section_size); bin += section_size; bin_size -= section_size; } @@ -615,7 +641,7 @@ mrb_proc_read_irep(mrb_state *mrb, const uint8_t *bin) { uint8_t flags = mrb_ro_data_p((char*)bin) ? FLAG_SRC_STATIC : FLAG_SRC_MALLOC; - return read_irep(mrb, bin, (size_t)-1, flags); + return read_irep(mrb, bin, (size_t)UINT32_MAX, flags); } DEFINE_READ_IREP_FUNC( From ff3a5ebed6ffbe3e70481531cfb969b497aa73ad Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 15 Feb 2022 18:36:38 +0900 Subject: [PATCH 078/292] vm.c: should check type before hash access. Since the operand of double splat (`**`) may not be a hash, simple assertion (previous code since d42a64e) was not enough for this case. --- src/vm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/vm.c b/src/vm.c index 6133cbcca..9cb50847f 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2766,7 +2766,7 @@ RETRY_TRY_BLOCK: int lim = a+b*2+1; hash = regs[a]; - mrb_assert(mrb_hash_p(hash)); + mrb_ensure_hash_type(mrb, hash); for (i=a+1; i Date: Wed, 16 Feb 2022 07:40:42 +0900 Subject: [PATCH 079/292] codedump.c: print implicit operand of `OP_HASHCAT`. Just like `OP_ARYCAT` and `OP_STRCAT`. --- src/codedump.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/codedump.c b/src/codedump.c index f8de26eec..003a20394 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -510,7 +510,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) print_lv_a(mrb, irep, a); break; CASE(OP_HASHCAT, B): - printf("HASHCAT\tR%d\t\t", a); + printf("HASHCAT\tR%d\tR%d\t", a, a+1); print_lv_a(mrb, irep, a); break; From a8f0e7910707194feee1d41db1a6915fb7cf26f4 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 16 Feb 2022 13:54:19 +0900 Subject: [PATCH 080/292] parse.y: revert 9e064f2; fix #5647 Need to declare unnamed parameter when argument decomposition used. --- mrbgems/mruby-compiler/core/parse.y | 11 +- mrbgems/mruby-compiler/core/y.tab.c | 3229 ++++++++++++++------------- 2 files changed, 1629 insertions(+), 1611 deletions(-) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index a144617d7..a2ae02d8f 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -2962,6 +2962,7 @@ f_margs : f_arg } | f_arg ',' tSTAR { + local_add_f(p, intern_op(mul)); $$ = list3($1, nint(-1), 0); } | f_arg ',' tSTAR ',' f_arg @@ -2978,11 +2979,16 @@ f_margs : f_arg } | tSTAR { + local_add_f(p, intern_op(mul)); $$ = list3(0, nint(-1), 0); } - | tSTAR ',' f_arg + | tSTAR ',' { - $$ = list3(0, nint(-1), $3); + local_add_f(p, intern_op(mul)); + } + f_arg + { + $$ = list3(0, nint(-1), $4); } ; @@ -3864,6 +3870,7 @@ f_arg_item : f_norm_arg { $$ = new_masgn_param(p, $3, p->locals->car); local_resume(p, $2); + local_add_f(p, 0); } ; diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 046f02e55..f692dfff0 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -2000,11 +2000,11 @@ union yyalloc /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 149 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 175 +#define YYNNTS 176 /* YYNRULES -- Number of rules. */ -#define YYNRULES 612 +#define YYNRULES 613 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 1077 +#define YYNSTATES 1078 #define YYUNDEFTOK 2 #define YYMAXUTOK 377 @@ -2098,33 +2098,33 @@ static const yytype_int16 yyrline[] = 2792, 2792, 2792, 2799, 2805, 2810, 2812, 2809, 2821, 2819, 2837, 2842, 2835, 2859, 2857, 2873, 2883, 2894, 2898, 2902, 2906, 2912, 2919, 2920, 2921, 2924, 2925, 2928, 2929, 2937, - 2938, 2944, 2948, 2951, 2955, 2959, 2963, 2967, 2971, 2975, - 2979, 2983, 2989, 2993, 2997, 3001, 3007, 3012, 3017, 3021, - 3025, 3029, 3033, 3037, 3041, 3045, 3049, 3053, 3057, 3061, - 3065, 3069, 3073, 3079, 3084, 3091, 3091, 3095, 3100, 3107, - 3111, 3117, 3118, 3121, 3126, 3129, 3133, 3139, 3143, 3150, - 3149, 3164, 3174, 3178, 3183, 3190, 3194, 3198, 3202, 3206, - 3210, 3214, 3218, 3222, 3229, 3228, 3243, 3242, 3258, 3266, - 3275, 3278, 3285, 3288, 3292, 3293, 3296, 3300, 3303, 3307, - 3310, 3311, 3312, 3313, 3316, 3317, 3323, 3324, 3325, 3329, - 3342, 3343, 3349, 3354, 3353, 3364, 3368, 3374, 3378, 3391, - 3395, 3401, 3404, 3405, 3408, 3414, 3420, 3421, 3424, 3431, - 3430, 3444, 3448, 3462, 3467, 3481, 3487, 3488, 3489, 3490, - 3491, 3495, 3501, 3505, 3515, 3516, 3517, 3521, 3527, 3531, - 3535, 3539, 3543, 3549, 3553, 3559, 3563, 3567, 3571, 3575, - 3579, 3587, 3594, 3600, 3601, 3605, 3609, 3608, 3625, 3626, - 3629, 3635, 3639, 3645, 3646, 3650, 3654, 3660, 3666, 3672, - 3679, 3685, 3692, 3696, 3702, 3706, 3712, 3713, 3716, 3720, - 3726, 3730, 3734, 3738, 3744, 3749, 3754, 3758, 3762, 3766, - 3770, 3774, 3778, 3782, 3786, 3790, 3794, 3798, 3802, 3806, - 3811, 3817, 3822, 3827, 3832, 3837, 3844, 3848, 3855, 3860, - 3859, 3870, 3874, 3880, 3888, 3896, 3904, 3908, 3914, 3918, - 3924, 3925, 3928, 3933, 3940, 3941, 3944, 3948, 3954, 3958, - 3964, 3969, 3969, 3994, 3995, 4001, 4006, 4012, 4018, 4023, - 4027, 4037, 4044, 4045, 4046, 4049, 4050, 4051, 4052, 4055, - 4056, 4057, 4060, 4061, 4064, 4068, 4074, 4075, 4081, 4082, - 4085, 4086, 4089, 4092, 4093, 4094, 4097, 4098, 4101, 4106, - 4109, 4110, 4114 + 2938, 2944, 2948, 2951, 2955, 2959, 2963, 2968, 2972, 2976, + 2980, 2986, 2985, 2995, 2999, 3003, 3007, 3013, 3018, 3023, + 3027, 3031, 3035, 3039, 3043, 3047, 3051, 3055, 3059, 3063, + 3067, 3071, 3075, 3079, 3085, 3090, 3097, 3097, 3101, 3106, + 3113, 3117, 3123, 3124, 3127, 3132, 3135, 3139, 3145, 3149, + 3156, 3155, 3170, 3180, 3184, 3189, 3196, 3200, 3204, 3208, + 3212, 3216, 3220, 3224, 3228, 3235, 3234, 3249, 3248, 3264, + 3272, 3281, 3284, 3291, 3294, 3298, 3299, 3302, 3306, 3309, + 3313, 3316, 3317, 3318, 3319, 3322, 3323, 3329, 3330, 3331, + 3335, 3348, 3349, 3355, 3360, 3359, 3370, 3374, 3380, 3384, + 3397, 3401, 3407, 3410, 3411, 3414, 3420, 3426, 3427, 3430, + 3437, 3436, 3450, 3454, 3468, 3473, 3487, 3493, 3494, 3495, + 3496, 3497, 3501, 3507, 3511, 3521, 3522, 3523, 3527, 3533, + 3537, 3541, 3545, 3549, 3555, 3559, 3565, 3569, 3573, 3577, + 3581, 3585, 3593, 3600, 3606, 3607, 3611, 3615, 3614, 3631, + 3632, 3635, 3641, 3645, 3651, 3652, 3656, 3660, 3666, 3672, + 3678, 3685, 3691, 3698, 3702, 3708, 3712, 3718, 3719, 3722, + 3726, 3732, 3736, 3740, 3744, 3750, 3755, 3760, 3764, 3768, + 3772, 3776, 3780, 3784, 3788, 3792, 3796, 3800, 3804, 3808, + 3812, 3817, 3823, 3828, 3833, 3838, 3843, 3850, 3854, 3861, + 3866, 3865, 3877, 3881, 3887, 3895, 3903, 3911, 3915, 3921, + 3925, 3931, 3932, 3935, 3940, 3947, 3948, 3951, 3955, 3961, + 3965, 3971, 3976, 3976, 4001, 4002, 4008, 4013, 4019, 4025, + 4030, 4034, 4044, 4051, 4052, 4053, 4056, 4057, 4058, 4059, + 4062, 4063, 4064, 4067, 4068, 4071, 4075, 4081, 4082, 4088, + 4089, 4092, 4093, 4096, 4099, 4100, 4101, 4104, 4105, 4108, + 4113, 4116, 4117, 4121 }; #endif @@ -2175,25 +2175,25 @@ static const char *const yytname[] = "mrhs", "primary", "@8", "@9", "$@10", "$@11", "@12", "@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "@20", "@21", "@22", "@23", "primary_value", "then", "do", "if_tail", "opt_else", "for_var", - "f_margs", "block_args_tail", "opt_block_args_tail", "block_param", - "opt_block_param", "block_param_def", "$@24", "opt_bv_decl", "bv_decls", - "bvar", "f_larglist", "lambda_body", "do_block", "$@25", "block_call", - "method_call", "brace_block", "@26", "@27", "case_body", "cases", - "opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", "string", - "string_fragment", "string_rep", "string_interp", "@28", "xstring", - "regexp", "heredoc", "heredoc_bodies", "heredoc_body", - "heredoc_string_rep", "heredoc_string_interp", "@29", "words", "symbol", - "basic_symbol", "sym", "symbols", "numeric", "variable", "var_lhs", - "var_ref", "backref", "superclass", "$@30", "f_opt_arglist_paren", - "f_arglist_paren", "f_arglist", "f_label", "f_kw", "f_block_kw", - "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest", "args_tail", - "opt_args_tail", "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", - "@31", "f_arg", "f_opt_asgn", "f_opt", "f_block_opt", "f_block_optarg", - "f_optarg", "restarg_mark", "f_rest_arg", "blkarg_mark", "f_block_arg", - "opt_f_block_arg", "singleton", "$@32", "assoc_list", "assocs", "assoc", - "operation", "operation2", "operation3", "dot_or_colon", "call_op", - "call_op2", "opt_terms", "opt_nl", "rparen", "trailer", "term", "nl", - "terms", "none", YY_NULLPTR + "f_margs", "$@24", "block_args_tail", "opt_block_args_tail", + "block_param", "opt_block_param", "block_param_def", "$@25", + "opt_bv_decl", "bv_decls", "bvar", "f_larglist", "lambda_body", + "do_block", "$@26", "block_call", "method_call", "brace_block", "@27", + "@28", "case_body", "cases", "opt_rescue", "exc_list", "exc_var", + "opt_ensure", "literal", "string", "string_fragment", "string_rep", + "string_interp", "@29", "xstring", "regexp", "heredoc", "heredoc_bodies", + "heredoc_body", "heredoc_string_rep", "heredoc_string_interp", "@30", + "words", "symbol", "basic_symbol", "sym", "symbols", "numeric", + "variable", "var_lhs", "var_ref", "backref", "superclass", "$@31", + "f_opt_arglist_paren", "f_arglist_paren", "f_arglist", "f_label", "f_kw", + "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest", + "args_tail", "opt_args_tail", "f_args", "f_bad_arg", "f_norm_arg", + "f_arg_item", "@32", "f_arg", "f_opt_asgn", "f_opt", "f_block_opt", + "f_block_optarg", "f_optarg", "restarg_mark", "f_rest_arg", + "blkarg_mark", "f_block_arg", "opt_f_block_arg", "singleton", "$@33", + "assoc_list", "assocs", "assoc", "operation", "operation2", "operation3", + "dot_or_colon", "call_op", "call_op2", "opt_terms", "opt_nl", "rparen", + "trailer", "term", "nl", "terms", "none", YY_NULLPTR }; #endif @@ -2220,12 +2220,12 @@ static const yytype_int16 yytoknum[] = }; # endif -#define YYPACT_NINF (-865) +#define YYPACT_NINF (-873) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-613) +#define YYTABLE_NINF (-614) #define yytable_value_is_error(Yyn) \ ((Yyn) == YYTABLE_NINF) @@ -2234,114 +2234,114 @@ static const yytype_int16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - -865, 141, 3686, -865, 8674, 10798, 11140, 6982, -865, 10444, - 10444, -865, -865, 10912, 8164, 6598, 8910, 8910, -865, -865, - 8910, 4343, 3935, -865, -865, -865, -865, 96, 8164, -865, - 39, -865, -865, -865, 7124, 3799, -865, -865, 7266, -865, - -865, -865, -865, -865, -865, -865, 145, 10562, 10562, 10562, - 10562, 140, 5857, 1267, 9382, 9736, 8446, -865, 7882, 904, - 335, 393, 1098, 1184, -865, 287, 10680, 10562, -865, 1179, - -865, 1356, -865, 382, 1301, 1301, -865, -865, 221, 89, - -865, 117, 11026, -865, 186, 13068, 124, 134, 56, 100, - -865, 314, -865, -865, -865, -865, -865, -865, -865, -865, - -865, 51, 248, -865, 251, 36, -865, -865, -865, -865, - -865, 207, 207, 96, 623, 946, -865, 10444, 239, 5976, - 415, 1435, 1435, -865, 258, -865, 323, -865, -865, 36, - -865, -865, -865, -865, -865, -865, -865, -865, -865, -865, - -865, -865, -865, -865, -865, -865, -865, -865, -865, -865, - -865, -865, -865, -865, -865, -865, -865, -865, 23, 44, - 52, 57, -865, -865, -865, -865, -865, -865, 72, 76, - 157, 182, -865, 190, -865, -865, -865, -865, -865, -865, - -865, -865, -865, -865, -865, -865, -865, -865, -865, -865, - -865, -865, -865, -865, -865, -865, -865, -865, -865, -865, - -865, -865, -865, -865, -865, -865, -865, -865, -865, 203, - 5035, 321, 382, 1301, 1301, 102, 268, 13192, 497, 233, - 305, 316, 102, 10444, 10444, 669, 360, -865, -865, 712, - 378, 58, 74, -865, -865, -865, -865, -865, -865, -865, - -865, -865, 8023, -865, -865, 299, -865, -865, -865, -865, - -865, -865, 1179, -865, 213, -865, 427, -865, -865, 1179, - 4071, 10562, 10562, 10562, 10562, -865, 13130, -865, -865, 337, - 399, 337, -865, -865, -865, 9028, -865, -865, -865, 8910, - -865, -865, -865, 6598, 6836, -865, 355, 6095, -865, 785, - 410, 13254, 13254, 461, 8792, 5857, 370, 1179, 1356, 1179, - 416, -865, 8792, 1179, 414, 1324, 1324, -865, 13130, 422, - 1324, -865, 526, 11254, 441, 813, 924, 941, 1610, -865, - -865, -865, -865, 1212, -865, -865, -865, -865, -865, -865, - 315, 1247, -865, -865, 776, -865, 553, -865, 1252, -865, - 1255, 491, 492, -865, -865, -865, -865, 6360, 10444, 10444, - 10444, 10444, 8792, 10444, 10444, 47, -865, -865, -865, -865, - -865, 1179, -865, -865, -865, -865, -865, -865, -865, 1963, - 473, 477, 5035, 10562, -865, 462, 561, 479, -865, 1179, - -865, -865, -865, 484, 10562, -865, 485, 568, 494, 583, - -865, -865, 487, 5035, -865, -865, 9854, -865, 5857, 8560, - 498, 9854, 10562, 10562, 10562, 10562, 10562, 10562, 10562, 10562, - 10562, 10562, 10562, 10562, 10562, 10562, 592, 10562, 10562, 10562, + -873, 124, 3686, -873, 8674, 10798, 11140, 6982, -873, 10444, + 10444, -873, -873, 10912, 8164, 6598, 8910, 8910, -873, -873, + 8910, 4343, 3935, -873, -873, -873, -873, -13, 8164, -873, + -4, -873, -873, -873, 7124, 3799, -873, -873, 7266, -873, + -873, -873, -873, -873, -873, -873, 45, 10562, 10562, 10562, + 10562, 89, 5857, 585, 9382, 9736, 8446, -873, 7882, 681, + 776, 904, 1227, 1252, -873, 288, 10680, 10562, -873, 448, + -873, 1256, -873, 328, 1307, 1307, -873, -873, 152, 44, + -873, 98, 11026, -873, 87, 13068, 318, 487, 56, 117, + -873, 466, -873, -873, -873, -873, -873, -873, -873, -873, + -873, 212, 123, -873, 291, 92, -873, -873, -873, -873, + -873, 106, 106, -13, 623, 777, -873, 10444, 364, 5976, + 355, 1435, 1435, -873, 139, -873, 669, -873, -873, 92, + -873, -873, -873, -873, -873, -873, -873, -873, -873, -873, + -873, -873, -873, -873, -873, -873, -873, -873, -873, -873, + -873, -873, -873, -873, -873, -873, -873, -873, 23, 46, + 60, 82, -873, -873, -873, -873, -873, -873, 127, 191, + 203, 204, -873, 229, -873, -873, -873, -873, -873, -873, + -873, -873, -873, -873, -873, -873, -873, -873, -873, -873, + -873, -873, -873, -873, -873, -873, -873, -873, -873, -873, + -873, -873, -873, -873, -873, -873, -873, -873, -873, 253, + 5035, 211, 328, 1307, 1307, 160, 193, 13192, 712, 118, + 248, 207, 160, 10444, 10444, 887, 312, -873, -873, 908, + 347, 58, 86, -873, -873, -873, -873, -873, -873, -873, + -873, -873, 8023, -873, -873, 240, -873, -873, -873, -873, + -873, -873, 448, -873, 632, -873, 369, -873, -873, 448, + 4071, 10562, 10562, 10562, 10562, -873, 13130, -873, -873, 292, + 373, 292, -873, -873, -873, 9028, -873, -873, -873, 8910, + -873, -873, -873, 6598, 6836, -873, 309, 6095, -873, 955, + 350, 13254, 13254, 299, 8792, 5857, 325, 448, 1256, 448, + 353, -873, 8792, 448, 352, 1511, 1511, -873, 13130, 344, + 1511, -873, 434, 11254, 358, 1013, 1040, 1057, 1610, -873, + -873, -873, -873, 1255, -873, -873, -873, -873, -873, -873, + 653, 1276, -873, -873, 825, -873, 1003, -873, 1314, -873, + 1348, 396, 414, -873, -873, -873, -873, 6360, 10444, 10444, + 10444, 10444, 8792, 10444, 10444, 48, -873, -873, -873, -873, + -873, 448, -873, -873, -873, -873, -873, -873, -873, 1963, + 399, 410, 5035, 10562, -873, 392, 486, 413, -873, 448, + -873, -873, -873, 419, 10562, -873, 430, 490, 441, 530, + -873, -873, 464, 5035, -873, -873, 9854, -873, 5857, 8560, + 458, 9854, 10562, 10562, 10562, 10562, 10562, 10562, 10562, 10562, + 10562, 10562, 10562, 10562, 10562, 10562, 553, 10562, 10562, 10562, 10562, 10562, 10562, 10562, 10562, 10562, 10562, 10562, 10562, 2428, - -865, 8910, -865, 3143, -865, -865, 12650, -865, -865, -865, - -865, 10680, 10680, -865, 562, -865, 382, -865, 999, -865, - -865, -865, -865, -865, -865, 11532, 8910, 11618, 5035, 10444, - -865, -865, -865, 641, 655, 344, 558, 566, -865, 5181, - 682, 10562, 11704, 8910, 11790, 10562, 10562, 5473, 167, 167, - 103, 11876, 8910, 11962, -865, 636, -865, 6095, 427, -865, - -865, 9972, 685, -865, 10562, 13192, 13192, 13192, 10562, -865, - -865, 9146, -865, 10562, -865, 9500, 6717, 559, 1179, 337, - 337, -865, -865, 759, 564, -865, -865, -865, 8164, 5592, - 563, 11704, 11790, 10562, 1356, 1179, -865, -865, 6479, 569, - 1356, -865, -865, 9618, -865, 1179, 9736, -865, -865, -865, - 999, 117, 11254, -865, 11254, 12048, 8910, 12134, 2259, -865, - -865, 570, -865, 1259, 6095, 315, -865, -865, -865, -865, - -865, -865, -865, 10562, 10562, -865, -865, -865, -865, -865, - -865, -865, -865, -865, -865, -865, 1236, 1179, 1179, 576, - 10680, 688, 13192, 54, -865, -865, -865, 198, -865, -865, - 2093, -865, 13192, 2259, -865, -865, 1289, -865, -865, 10680, - 704, 43, 10562, -865, 12784, 337, -865, 1179, 11254, 581, - -865, -865, -865, 680, 614, 2039, -865, -865, 1018, 348, + -873, 8910, -873, 3143, -873, -873, 12650, -873, -873, -873, + -873, 10680, 10680, -873, 516, -873, 328, -873, 1068, -873, + -873, -873, -873, -873, -873, 11532, 8910, 11618, 5035, 10444, + -873, -873, -873, 606, 615, 215, 509, 510, -873, 5181, + 617, 10562, 11704, 8910, 11790, 10562, 10562, 5473, 101, 101, + 115, 11876, 8910, 11962, -873, 573, -873, 6095, 369, -873, + -873, 9972, 625, -873, 10562, 13192, 13192, 13192, 10562, -873, + -873, 9146, -873, 10562, -873, 9500, 6717, 506, 448, 292, + 292, -873, -873, 838, 511, -873, -873, -873, 8164, 5592, + 522, 11704, 11790, 10562, 1256, 448, -873, -873, 6479, 500, + 1256, -873, -873, 9618, -873, 448, 9736, -873, -873, -873, + 1068, 98, 11254, -873, 11254, 12048, 8910, 12134, 2259, -873, + -873, 526, -873, 1353, 6095, 653, -873, -873, -873, -873, + -873, -873, -873, 10562, 10562, -873, -873, -873, -873, -873, + -873, -873, -873, -873, -873, -873, 1454, 448, 448, 537, + 10680, 666, 13192, 335, -873, -873, -873, 54, -873, -873, + 2093, -873, 13192, 2259, -873, -873, 1038, -873, -873, 10680, + 672, 47, 10562, -873, 12784, 292, -873, 448, 11254, 559, + -873, -873, -873, 655, 581, 2039, -873, -873, 1078, 220, 3042, 3042, 3042, 3042, 1617, 1617, 3376, 2927, 3042, 3042, - 13254, 13254, 1153, 1153, -865, 410, 13192, 1617, 1617, 1278, - 1278, 1426, 234, 234, 410, 410, 410, 4479, 7622, 4751, - 7740, -865, 207, -865, 597, 337, 509, -865, 589, -865, - -865, 4207, -865, -865, 1791, 43, 43, -865, 2539, -865, - -865, -865, -865, -865, 1179, 10444, 5035, 963, 777, -865, - 207, 599, 207, 729, 759, 8305, -865, 10090, 732, -865, - 10562, 10562, 466, -865, 7384, 7503, 606, 397, 405, 732, - -865, -865, -865, -865, 71, 86, 615, 111, 112, 10444, - 8164, 621, 747, 13192, 639, -865, 13192, 13192, 1089, 10562, - 13130, -865, 337, 13192, -865, -865, -865, -865, 9264, 9500, - -865, -865, -865, 632, -865, -865, 33, 1356, 1179, 1324, - 498, -865, 963, 777, 631, 1051, 1134, -865, 95, 2259, - -865, 637, -865, 410, 410, -865, 901, 1179, 635, -865, - -865, 2153, 734, 3255, -865, 722, -865, 479, -865, 1179, - -865, -865, 644, 646, 647, -865, 649, 722, 647, 749, - 12722, -865, -865, 2259, 5035, -865, -865, 12855, 10208, -865, - -865, 11254, 8792, 10680, 10562, 12220, 8910, 12306, 869, 10680, - 10680, -865, 562, 609, 9146, 10680, 10680, -865, 562, 100, - 221, 5035, 6095, 43, -865, 1179, 780, -865, -865, -865, - -865, 12784, -865, 705, -865, 5738, 789, -865, 10444, 795, - -865, 10562, 10562, 408, 10562, 10562, 800, 6241, 6241, 115, - 167, -865, -865, -865, 10326, 5327, 13192, -865, 6717, 337, - -865, -865, -865, 495, 673, 1380, 5035, 6095, -865, -865, - 1579, 681, -865, 1454, 1179, 10562, 10562, -865, -865, 2259, - -865, 1289, -865, 1289, -865, 1289, -865, -865, 10562, 10562, - -865, -865, -865, 11368, -865, 683, 479, 689, 11368, -865, - 693, 696, -865, 807, 10562, 12926, -865, -865, 13192, 4615, - 4887, 708, 412, 442, 10562, 10562, -865, -865, -865, -865, - -865, 10680, -865, -865, -865, -865, -865, -865, -865, 835, - 718, 6095, 5035, -865, -865, 11482, 102, -865, -865, 6241, - -865, -865, 102, -865, 10562, -865, 843, 846, -865, 13192, - 294, -865, 9500, -865, 1517, 848, 730, 731, 1579, 1118, - -865, 13192, 13192, 647, 739, 647, 647, 13192, 13192, 750, - 760, 832, 1019, 54, -865, -865, 1746, -865, 1019, 2259, - -865, 1289, -865, -865, 12997, 475, 13192, 13192, -865, -865, - -865, -865, 755, 880, 842, -865, 1046, 924, 941, 5035, - -865, 5181, -865, -865, 6241, -865, -865, -865, -865, 770, - -865, -865, -865, -865, 1579, 731, 1579, 774, -865, 1289, - -865, -865, -865, -865, -865, -865, 12392, -865, 479, 54, - -865, -865, 778, 781, 792, -865, 794, 792, -865, -865, - 999, 12478, 8910, 12564, 655, 466, 887, 1517, 1089, 731, - 1579, 647, 783, 797, -865, 2259, -865, 1289, -865, 1289, - -865, 1289, -865, -865, 963, 777, 801, 160, 753, -865, - -865, -865, -865, 731, -865, 792, 804, 792, 792, 495, - -865, 1289, -865, -865, -865, 792, -865 + 13254, 13254, 1146, 1146, -873, 350, 13192, 1617, 1617, 1427, + 1427, 1442, 378, 378, 350, 350, 350, 4479, 7622, 4751, + 7740, -873, 106, -873, 568, 292, 461, -873, 501, -873, + -873, 4207, -873, -873, 1791, 47, 47, -873, 2539, -873, + -873, -873, -873, -873, 448, 10444, 5035, 906, 51, -873, + 106, 571, 106, 703, 838, 8305, -873, 10090, 706, -873, + 10562, 10562, 439, -873, 7384, 7503, 594, 256, 282, 706, + -873, -873, -873, -873, 55, 79, 598, 126, 129, 10444, + 8164, 621, 741, 13192, 639, -873, 13192, 13192, 852, 10562, + 13130, -873, 292, 13192, -873, -873, -873, -873, 9264, 9500, + -873, -873, -873, 637, -873, -873, 138, 1256, 448, 1511, + 458, -873, 906, 51, 636, 933, 934, -873, 91, 2259, + -873, 640, -873, 350, 350, -873, 276, 448, 620, -873, + -873, 2153, 720, 3255, -873, 721, -873, 413, -873, 448, + -873, -873, 644, 646, 647, -873, 651, 721, 647, 752, + 12722, -873, -873, 2259, 5035, -873, -873, 12855, 10208, -873, + -873, 11254, 8792, 10680, 10562, 12220, 8910, 12306, 167, 10680, + 10680, -873, 516, 577, 9146, 10680, 10680, -873, 516, 117, + 152, 5035, 6095, 47, -873, 448, 795, -873, -873, -873, + -873, 12784, -873, 719, -873, 5738, 801, -873, 10444, 803, + -873, 10562, 10562, 307, 10562, 10562, 807, 6241, 6241, 130, + 101, -873, -873, -873, 10326, 5327, 13192, -873, 6717, 292, + -873, -873, -873, 497, 678, 1326, 5035, 6095, -873, -873, + -873, 683, -873, 1671, 448, 10562, 10562, -873, -873, 2259, + -873, 1038, -873, 1038, -873, 1038, -873, -873, 10562, 10562, + -873, -873, -873, 11368, -873, 689, 413, 693, 11368, -873, + 696, 708, -873, 836, 10562, 12926, -873, -873, 13192, 4615, + 4887, 716, 324, 348, 10562, 10562, -873, -873, -873, -873, + -873, 10680, -873, -873, -873, -873, -873, -873, -873, 843, + 722, 6095, 5035, -873, -873, 11482, 160, -873, -873, 6241, + -873, -873, 160, -873, 10562, -873, 848, 854, -873, 13192, + 157, -873, 9500, -873, 849, 858, 735, 1330, 1330, 342, + -873, 13192, 13192, 647, 736, 647, 647, 13192, 13192, 755, + 761, 840, 1091, 335, -873, -873, 1746, -873, 1091, 2259, + -873, 1038, -873, -873, 12997, 412, 13192, 13192, -873, -873, + -873, -873, 759, 892, 857, -873, 1117, 1040, 1057, 5035, + -873, 5181, -873, -873, 6241, -873, -873, -873, -873, 778, + -873, -873, -873, -873, 780, 780, 1330, 781, -873, 1038, + -873, -873, -873, -873, -873, -873, 12392, -873, 413, 335, + -873, -873, 784, 785, 792, -873, 794, 792, -873, -873, + 1068, 12478, 8910, 12564, 615, 439, 931, 849, 852, 1330, + 780, 1330, 647, 804, 808, -873, 2259, -873, 1038, -873, + 1038, -873, 1038, -873, -873, 906, 51, 806, 592, 753, + -873, -873, -873, -873, 780, -873, 792, 812, 792, 792, + 497, -873, 1038, -873, -873, -873, 792, -873 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -2350,18 +2350,18 @@ static const yytype_int16 yypact[] = static const yytype_int16 yydefact[] = { 2, 0, 0, 1, 0, 0, 0, 0, 293, 0, - 0, 317, 320, 0, 0, 598, 337, 338, 339, 340, - 305, 270, 270, 487, 486, 488, 489, 600, 0, 10, - 0, 491, 490, 492, 478, 584, 480, 479, 482, 481, - 474, 475, 436, 437, 493, 494, 291, 0, 0, 0, - 0, 0, 0, 295, 612, 612, 88, 312, 0, 0, - 0, 0, 0, 0, 451, 0, 0, 0, 3, 598, - 6, 9, 27, 33, 540, 540, 49, 60, 59, 0, + 0, 317, 320, 0, 0, 599, 337, 338, 339, 340, + 305, 270, 270, 488, 487, 489, 490, 601, 0, 10, + 0, 492, 491, 493, 479, 585, 481, 480, 483, 482, + 475, 476, 437, 438, 494, 495, 291, 0, 0, 0, + 0, 0, 0, 295, 613, 613, 88, 312, 0, 0, + 0, 0, 0, 0, 452, 0, 0, 0, 3, 599, + 6, 9, 27, 33, 541, 541, 49, 60, 59, 0, 76, 0, 80, 90, 0, 54, 248, 0, 61, 310, - 284, 285, 434, 286, 287, 288, 432, 431, 463, 433, - 430, 485, 0, 289, 290, 270, 5, 8, 337, 338, - 305, 612, 412, 0, 113, 114, 291, 0, 0, 0, - 0, 540, 540, 116, 495, 341, 0, 485, 290, 0, + 284, 285, 435, 286, 287, 288, 433, 432, 464, 434, + 431, 486, 0, 289, 290, 270, 5, 8, 337, 338, + 305, 613, 413, 0, 113, 114, 291, 0, 0, 0, + 0, 541, 541, 116, 496, 341, 0, 486, 290, 0, 333, 168, 178, 169, 165, 194, 195, 196, 197, 176, 191, 184, 174, 173, 189, 172, 171, 167, 192, 166, 179, 183, 185, 177, 170, 186, 193, 188, 187, 180, @@ -2369,117 +2369,117 @@ static const yytype_int16 yydefact[] = 160, 118, 120, 119, 153, 154, 131, 132, 133, 140, 137, 139, 134, 135, 155, 156, 141, 142, 146, 149, 150, 136, 138, 128, 129, 130, 143, 144, 145, 147, - 148, 151, 152, 157, 571, 55, 121, 122, 570, 0, - 0, 0, 58, 540, 540, 0, 0, 54, 0, 485, + 148, 151, 152, 157, 572, 55, 121, 122, 571, 0, + 0, 0, 58, 541, 541, 0, 0, 54, 0, 486, 0, 290, 0, 0, 0, 112, 0, 352, 351, 0, - 0, 485, 290, 187, 180, 190, 175, 158, 159, 160, - 118, 119, 0, 123, 125, 20, 124, 454, 459, 458, - 606, 608, 598, 609, 0, 456, 0, 610, 607, 599, - 582, 0, 0, 273, 0, 265, 277, 74, 269, 612, - 434, 612, 575, 75, 73, 612, 259, 306, 72, 0, - 258, 411, 71, 598, 0, 18, 0, 0, 221, 0, - 222, 209, 212, 302, 0, 0, 0, 598, 15, 598, - 78, 14, 0, 598, 0, 603, 603, 249, 0, 0, - 603, 573, 0, 0, 86, 0, 96, 103, 540, 468, - 467, 469, 470, 0, 466, 465, 438, 443, 442, 445, - 0, 0, 440, 447, 0, 449, 0, 461, 0, 472, - 0, 476, 477, 53, 236, 237, 4, 599, 0, 0, - 0, 0, 0, 0, 0, 547, 543, 542, 541, 544, - 545, 0, 549, 561, 516, 517, 565, 564, 560, 540, - 0, 503, 0, 509, 514, 612, 519, 612, 539, 0, - 546, 548, 551, 525, 0, 558, 525, 563, 525, 567, - 523, 499, 0, 0, 399, 401, 0, 92, 0, 84, + 0, 486, 290, 187, 180, 190, 175, 158, 159, 160, + 118, 119, 0, 123, 125, 20, 124, 455, 460, 459, + 607, 609, 599, 610, 0, 457, 0, 611, 608, 600, + 583, 0, 0, 273, 0, 265, 277, 74, 269, 613, + 435, 613, 576, 75, 73, 613, 259, 306, 72, 0, + 258, 412, 71, 599, 0, 18, 0, 0, 221, 0, + 222, 209, 212, 302, 0, 0, 0, 599, 15, 599, + 78, 14, 0, 599, 0, 604, 604, 249, 0, 0, + 604, 574, 0, 0, 86, 0, 96, 103, 541, 469, + 468, 470, 471, 0, 467, 466, 439, 444, 443, 446, + 0, 0, 441, 448, 0, 450, 0, 462, 0, 473, + 0, 477, 478, 53, 236, 237, 4, 600, 0, 0, + 0, 0, 0, 0, 0, 548, 544, 543, 542, 545, + 546, 0, 550, 562, 517, 518, 566, 565, 561, 541, + 0, 504, 0, 510, 515, 613, 520, 613, 540, 0, + 547, 549, 552, 526, 0, 559, 526, 564, 526, 568, + 524, 500, 0, 0, 400, 402, 0, 92, 0, 84, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 208, 211, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 595, 612, 594, 0, 597, 596, 0, 416, 414, 311, - 435, 0, 0, 405, 65, 309, 330, 113, 114, 115, - 476, 477, 503, 496, 328, 0, 612, 0, 0, 0, - 593, 592, 56, 0, 612, 302, 0, 0, 343, 0, - 342, 0, 0, 612, 0, 0, 0, 0, 0, 0, - 302, 0, 612, 0, 325, 0, 126, 0, 0, 455, - 457, 0, 0, 611, 579, 278, 581, 272, 0, 600, - 266, 0, 275, 0, 267, 0, 598, 0, 598, 612, - 612, 260, 271, 598, 0, 308, 52, 601, 0, 0, - 0, 0, 0, 0, 17, 598, 300, 13, 599, 77, - 296, 299, 303, 605, 250, 604, 605, 252, 304, 574, - 102, 94, 0, 89, 0, 0, 612, 0, 540, 313, - 396, 525, 471, 0, 0, 446, 452, 439, 441, 448, - 450, 462, 473, 0, 0, 7, 21, 22, 23, 24, - 25, 50, 51, 507, 553, 506, 0, 598, 598, 525, - 0, 0, 508, 0, 521, 569, 518, 0, 522, 504, - 0, 532, 554, 0, 535, 562, 0, 537, 566, 0, - 0, 612, 0, 28, 30, 0, 31, 598, 0, 82, + 596, 613, 595, 0, 598, 597, 0, 417, 415, 311, + 436, 0, 0, 406, 65, 309, 330, 113, 114, 115, + 477, 478, 504, 497, 328, 0, 613, 0, 0, 0, + 594, 593, 56, 0, 613, 302, 0, 0, 343, 0, + 342, 0, 0, 613, 0, 0, 0, 0, 0, 0, + 302, 0, 613, 0, 325, 0, 126, 0, 0, 456, + 458, 0, 0, 612, 580, 278, 582, 272, 0, 601, + 266, 0, 275, 0, 267, 0, 599, 0, 599, 613, + 613, 260, 271, 599, 0, 308, 52, 602, 0, 0, + 0, 0, 0, 0, 17, 599, 300, 13, 600, 77, + 296, 299, 303, 606, 250, 605, 606, 252, 304, 575, + 102, 94, 0, 89, 0, 0, 613, 0, 541, 313, + 397, 526, 472, 0, 0, 447, 453, 440, 442, 449, + 451, 463, 474, 0, 0, 7, 21, 22, 23, 24, + 25, 50, 51, 508, 554, 507, 0, 599, 599, 526, + 0, 0, 509, 0, 522, 570, 519, 0, 523, 505, + 0, 533, 555, 0, 536, 563, 0, 538, 567, 0, + 0, 613, 0, 28, 30, 0, 31, 599, 0, 82, 93, 48, 34, 46, 0, 253, 198, 29, 0, 290, 226, 231, 232, 233, 228, 230, 240, 241, 234, 235, - 207, 210, 238, 239, 32, 218, 600, 227, 229, 223, - 224, 225, 213, 214, 215, 216, 217, 585, 590, 586, - 591, 410, 270, 408, 0, 612, 585, 587, 586, 588, - 409, 270, 585, 586, 270, 612, 612, 35, 253, 199, + 207, 210, 238, 239, 32, 218, 601, 227, 229, 223, + 224, 225, 213, 214, 215, 216, 217, 586, 591, 587, + 592, 411, 270, 409, 0, 613, 586, 588, 587, 589, + 410, 270, 586, 587, 270, 613, 613, 35, 253, 199, 45, 206, 63, 66, 0, 0, 0, 113, 114, 117, - 0, 0, 612, 0, 598, 0, 294, 612, 612, 422, - 0, 0, 612, 344, 589, 301, 0, 585, 586, 612, - 346, 318, 345, 321, 589, 301, 0, 585, 586, 0, - 0, 0, 0, 277, 0, 324, 578, 577, 276, 0, - 279, 274, 612, 580, 576, 257, 255, 261, 262, 264, - 307, 602, 19, 0, 26, 205, 79, 16, 598, 603, - 95, 87, 99, 101, 0, 98, 100, 600, 0, 0, - 464, 0, 453, 219, 220, 547, 360, 598, 353, 502, - 500, 0, 41, 244, 335, 0, 515, 612, 568, 0, - 524, 552, 525, 525, 525, 559, 525, 547, 525, 43, - 246, 336, 387, 385, 0, 384, 383, 283, 0, 91, - 85, 0, 0, 0, 0, 0, 612, 0, 0, 0, - 0, 407, 69, 413, 262, 0, 0, 406, 67, 402, - 62, 0, 0, 612, 331, 0, 0, 413, 334, 572, - 57, 423, 424, 612, 425, 0, 612, 349, 0, 0, - 347, 0, 0, 413, 0, 0, 0, 0, 0, 413, - 0, 127, 460, 323, 0, 0, 280, 268, 598, 612, - 11, 297, 251, 97, 0, 389, 0, 0, 314, 444, - 0, 358, 550, 0, 598, 0, 0, 520, 505, 0, - 528, 0, 530, 0, 536, 0, 533, 538, 0, 0, - 382, 600, 600, 511, 512, 612, 612, 367, 0, 556, - 367, 367, 365, 0, 0, 281, 83, 47, 254, 585, - 586, 0, 585, 586, 0, 0, 40, 203, 39, 204, - 70, 0, 37, 201, 38, 202, 68, 403, 404, 0, - 0, 0, 0, 497, 329, 0, 0, 427, 350, 0, - 12, 429, 0, 315, 0, 316, 0, 0, 326, 279, - 612, 256, 263, 395, 0, 0, 0, 361, 0, 356, - 501, 42, 245, 525, 525, 525, 525, 44, 247, 0, - 0, 0, 510, 0, 363, 364, 367, 375, 555, 0, - 378, 0, 380, 400, 282, 413, 243, 242, 36, 200, - 417, 415, 0, 0, 0, 426, 0, 104, 111, 0, - 428, 0, 319, 322, 0, 419, 420, 418, 393, 600, - 391, 394, 398, 397, 0, 359, 0, 354, 529, 0, - 526, 531, 534, 388, 386, 302, 0, 513, 612, 0, - 366, 373, 367, 367, 367, 557, 367, 367, 64, 332, - 110, 0, 612, 0, 612, 612, 0, 0, 390, 357, - 0, 525, 589, 301, 362, 0, 370, 0, 372, 0, - 379, 0, 376, 381, 107, 109, 0, 585, 586, 421, - 348, 327, 392, 355, 527, 367, 367, 367, 367, 105, - 371, 0, 368, 374, 377, 367, 369 + 0, 0, 613, 0, 599, 0, 294, 613, 613, 423, + 0, 0, 613, 344, 590, 301, 0, 586, 587, 613, + 346, 318, 345, 321, 590, 301, 0, 586, 587, 0, + 0, 0, 0, 277, 0, 324, 579, 578, 276, 0, + 279, 274, 613, 581, 577, 257, 255, 261, 262, 264, + 307, 603, 19, 0, 26, 205, 79, 16, 599, 604, + 95, 87, 99, 101, 0, 98, 100, 601, 0, 0, + 465, 0, 454, 219, 220, 548, 360, 599, 353, 503, + 501, 0, 41, 244, 335, 0, 516, 613, 569, 0, + 525, 553, 526, 526, 526, 560, 526, 548, 526, 43, + 246, 336, 388, 386, 0, 385, 384, 283, 0, 91, + 85, 0, 0, 0, 0, 0, 613, 0, 0, 0, + 0, 408, 69, 414, 262, 0, 0, 407, 67, 403, + 62, 0, 0, 613, 331, 0, 0, 414, 334, 573, + 57, 424, 425, 613, 426, 0, 613, 349, 0, 0, + 347, 0, 0, 414, 0, 0, 0, 0, 0, 414, + 0, 127, 461, 323, 0, 0, 280, 268, 599, 613, + 11, 297, 251, 97, 0, 390, 0, 0, 314, 445, + 361, 358, 551, 0, 599, 0, 0, 521, 506, 0, + 529, 0, 531, 0, 537, 0, 534, 539, 0, 0, + 383, 601, 601, 512, 513, 613, 613, 368, 0, 557, + 368, 368, 366, 0, 0, 281, 83, 47, 254, 586, + 587, 0, 586, 587, 0, 0, 40, 203, 39, 204, + 70, 0, 37, 201, 38, 202, 68, 404, 405, 0, + 0, 0, 0, 498, 329, 0, 0, 428, 350, 0, + 12, 430, 0, 315, 0, 316, 0, 0, 326, 279, + 613, 256, 263, 396, 0, 0, 0, 0, 0, 356, + 502, 42, 245, 526, 526, 526, 526, 44, 247, 0, + 0, 0, 511, 0, 364, 365, 368, 376, 556, 0, + 379, 0, 381, 401, 282, 414, 243, 242, 36, 200, + 418, 416, 0, 0, 0, 427, 0, 104, 111, 0, + 429, 0, 319, 322, 0, 420, 421, 419, 394, 601, + 392, 395, 399, 398, 362, 359, 0, 354, 530, 0, + 527, 532, 535, 389, 387, 302, 0, 514, 613, 0, + 367, 374, 368, 368, 368, 558, 368, 368, 64, 332, + 110, 0, 613, 0, 613, 613, 0, 0, 391, 0, + 357, 0, 526, 590, 301, 363, 0, 371, 0, 373, + 0, 380, 0, 377, 382, 107, 109, 0, 586, 587, + 422, 348, 327, 393, 355, 528, 368, 368, 368, 368, + 105, 372, 0, 369, 375, 378, 368, 370 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -865, -865, -865, 403, -865, 41, -865, -233, 137, -865, - 40, -865, -60, -215, 560, 1421, 1889, -865, 20, -57, - -865, -657, -865, 30, 934, -211, -19, -50, -286, -443, - -8, 2634, -61, 942, 9, -17, -865, -865, 42, -865, - 1196, -865, 503, 73, -141, -365, 99, -7, -865, -440, - -240, -157, 147, -363, 97, -865, -865, -865, -865, -865, - -865, -865, -865, -865, -865, -865, -865, -865, -865, -865, - -865, 8, -200, -450, -76, -620, -865, -865, 178, 154, - -865, -536, -865, -865, -309, -865, -74, -865, -865, 155, - -865, -865, -865, -88, -865, -865, -452, -865, -68, -865, - -865, -865, -865, -865, -14, 26, -148, -865, -865, -865, - -865, -865, -259, -865, 717, -865, -865, -865, 6, -865, - -865, -865, 2469, 2735, 966, 2054, -865, -865, -16, 458, - 22, -633, 398, 27, -865, -865, -865, 302, 84, -126, - -249, -864, -681, -438, -865, 29, -650, -542, -838, 17, - -527, -865, -338, -865, 181, -340, -865, -865, -865, 38, - -429, 656, -351, -865, -865, -80, -865, 66, -23, 557, - -267, 327, -258, -64, -2 + -873, -873, -873, 436, -873, 34, -873, -233, 137, -873, + 40, -873, -188, -215, 560, 1421, 1889, -873, 20, -57, + -873, -640, -873, 30, 948, -211, -19, -50, -286, -475, + -11, 2634, -61, 957, 9, -17, -873, -873, 42, -873, + 1196, -873, 503, 73, -209, -365, 99, -7, -873, -440, + -240, -157, 147, -350, 97, -873, -873, -873, -873, -873, + -873, -873, -873, -873, -873, -873, -873, -873, -873, -873, + -873, 8, -200, -450, -71, -620, -873, -873, -873, 182, + 260, -873, -536, -873, -873, -302, -873, -65, -873, -873, + 163, -873, -873, -873, -88, -873, -873, -452, -873, -53, + -873, -873, -873, -873, -873, -14, 26, -148, -873, -873, + -873, -873, -873, -259, -873, 729, -873, -873, -873, 6, + -873, -873, -873, 2469, 2735, 980, 2054, -873, -873, 24, + 504, 0, 142, 405, 27, -873, -873, -873, 302, 84, + -126, -222, -843, -697, -438, -873, 301, -721, -545, -872, + 29, -527, -873, -448, -873, 208, -340, -873, -873, -873, + 38, -429, 656, -351, -873, -873, -80, -873, 66, -23, + 557, -267, 327, -258, -64, -2 }; /* YYDEFGOTO[NTERM-NUM]. */ @@ -2492,17 +2492,17 @@ static const yytype_int16 yydefgoto[] = 85, 304, 616, 651, 277, 507, 508, 278, 279, 268, 500, 536, 655, 606, 86, 210, 302, 738, 303, 318, 748, 223, 837, 224, 838, 709, 994, 676, 674, 922, - 458, 289, 469, 701, 829, 830, 230, 757, 1020, 967, - 881, 784, 785, 882, 854, 999, 1000, 549, 858, 395, - 601, 88, 89, 445, 666, 665, 492, 997, 688, 823, - 926, 930, 90, 91, 92, 331, 332, 554, 93, 94, - 95, 555, 253, 254, 255, 487, 96, 97, 98, 325, - 99, 100, 219, 220, 103, 221, 454, 675, 370, 371, - 372, 373, 374, 884, 885, 375, 376, 377, 770, 591, - 379, 380, 381, 382, 576, 383, 384, 385, 889, 890, - 386, 387, 388, 389, 390, 584, 209, 459, 309, 510, - 272, 129, 680, 653, 462, 457, 436, 514, 855, 515, - 534, 257, 258, 259, 301 + 458, 289, 469, 701, 829, 830, 230, 757, 947, 1020, + 967, 881, 784, 785, 882, 854, 999, 1000, 549, 858, + 395, 601, 88, 89, 445, 666, 665, 492, 997, 688, + 823, 926, 930, 90, 91, 92, 331, 332, 554, 93, + 94, 95, 555, 253, 254, 255, 487, 96, 97, 98, + 325, 99, 100, 219, 220, 103, 221, 454, 675, 370, + 371, 372, 373, 374, 884, 885, 375, 376, 377, 770, + 591, 379, 380, 381, 382, 576, 383, 384, 385, 889, + 890, 386, 387, 388, 389, 390, 584, 209, 459, 309, + 510, 272, 129, 680, 653, 462, 457, 436, 514, 855, + 515, 534, 257, 258, 259, 301 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -2513,197 +2513,197 @@ static const yytype_int16 yytable[] = 106, 439, 270, 270, 284, 347, 270, 433, 435, 343, 87, 285, 87, 126, 126, 282, 205, 218, 218, 280, 246, 229, 477, 218, 218, 218, 517, 542, 218, 703, - 222, 504, 400, 300, 246, 252, 712, 588, 617, 537, - 270, 270, 71, 539, 71, 107, 265, 265, 314, 206, - 265, 775, 307, 311, 271, 271, 206, 449, 271, 392, - 87, 721, 437, 772, 315, 721, 654, 324, 826, 550, - 206, 556, 391, 391, 218, 861, 724, 440, 652, 836, - 1001, 256, 661, -104, 525, 664, 334, 336, 338, 340, - 315, 681, 306, 310, 276, 281, -107, 393, 444, -111, - 206, 741, 125, 125, 573, 765, 682, 724, 696, 280, - 125, -109, 501, -487, 505, 267, 273, 706, 468, 274, - 578, 652, 782, 661, 856, 218, 437, 87, -110, 811, - 812, 1025, 682, 888, -486, 346, -106, -108, 474, 581, - -105, 3, -488, -483, 393, 910, 434, -489, 533, 483, - 883, 916, 771, 125, -77, 364, 365, 366, 378, 378, - 600, 430, -491, 269, 269, 790, -490, 269, 574, 783, - -487, 682, -104, 1001, 438, -91, -106, 287, 443, 125, - 275, 744, 367, 558, 276, 281, 558, 607, 558, 296, - 558, -486, 558, -96, 700, 293, 682, 466, 467, -488, - -96, 305, 443, 432, -489, 378, 378, 1025, 857, 522, - 396, 391, 391, -99, -341, -585, -103, 247, 87, -491, - 248, 249, 772, -490, 429, 683, 667, 670, -101, -341, - -586, 218, 218, 528, 772, 547, 393, -484, 438, 430, - 283, 535, 535, 478, 479, -102, 535, -492, 250, 394, - 251, 324, 773, -98, -100, 776, 296, -97, 542, 397, - 594, 270, 597, 541, -341, 270, -112, 502, 1007, 502, - 504, -341, -478, 511, 431, -106, 300, 921, -106, -106, - -482, 432, 247, 218, 206, 248, 249, 218, 721, 721, - 447, 218, 218, 460, 448, 87, 752, 378, 378, 747, - 724, 366, 87, 87, -492, 265, -106, 401, -106, 265, - 87, 771, 825, 250, 491, 251, 888, 271, 488, 888, - 995, 315, 542, 771, 822, -483, 367, 775, 489, -478, - 883, 248, 249, 883, 524, 417, 883, -482, 883, 603, - 441, 611, 530, 442, 613, 341, 342, 551, 896, 553, - 461, 275, 728, 729, -104, 87, 218, 218, 218, 218, - 87, 218, 218, 527, 721, 426, 427, 428, 566, 567, - 568, 569, -111, 585, 42, 585, 465, 43, 512, 300, - 87, 611, 611, 453, 613, 613, 883, 71, 565, 471, - 938, 609, 570, -103, 679, 888, 333, 475, 579, 327, - 328, 87, 378, 484, 218, 558, 87, 315, 476, 618, - 125, 773, 883, 455, 883, 480, 883, 270, 883, 353, - 354, 59, 509, 773, 520, 771, 269, 867, 430, 511, - 247, 901, 296, 248, 249, 771, 523, -111, 883, 218, - 442, 486, 270, 816, 652, 891, 661, 491, 788, 618, - 618, 329, 330, 378, 511, 335, 503, 327, 328, 270, - 517, 265, 689, 456, 218, -110, 87, 218, 270, -111, - 432, 511, 852, 450, 451, 659, 718, 87, 659, 499, - 511, 218, 847, 828, 825, 87, 265, 270, 996, 834, - 218, 270, 740, 519, 541, 87, 125, 835, 804, 659, - 934, 732, 721, 265, 805, 542, 660, 502, 502, 329, - 330, 417, 265, 724, 845, 526, 659, 106, -106, 270, - 807, -413, 270, 809, 246, 659, -108, 87, 771, -105, - 660, 954, 270, -106, 806, 296, 87, -76, 797, 722, - 517, 807, 470, 605, 511, 964, 965, 660, 605, 470, - 315, 893, 315, 523, 218, 532, 660, 844, 541, 71, - 206, 538, 87, -108, 659, 505, 771, 911, 737, 212, - 212, 739, 959, 960, 727, 212, 265, 551, 919, 452, - 452, 540, -110, 544, 906, -413, 493, 472, 218, 659, - 912, 914, 563, 564, 580, 660, -105, 517, -498, 786, - -413, 805, 430, -102, 583, 758, 692, 218, 599, 847, - 762, 771, 586, 798, 699, 560, 315, 327, 328, 595, - 660, 587, 774, 945, 711, 778, 590, 593, 1023, 779, - -106, 1026, 378, -413, 598, -413, 596, 473, 714, 125, - 610, 125, -413, 634, 432, 802, 870, 872, 874, -582, - 876, -98, 877, 502, 808, 468, 686, 810, 105, 280, - 105, 672, 280, 786, 786, 105, 105, 1056, 687, 329, - 330, 105, 105, 105, 493, 535, 105, 446, 1044, 690, - 280, 806, 682, 218, 87, 824, 827, 691, 575, 983, - 827, 751, 942, 841, 820, 815, 978, 827, 693, 552, - 715, 911, 734, 764, 726, 125, 589, 1066, 105, 731, - -108, -91, 749, -478, 270, 270, 246, 218, 761, 781, - 502, 917, 105, 791, 792, 801, 989, 206, -478, 840, - -105, -100, 991, 611, 276, 793, 613, 276, 803, 611, - 817, 541, 613, 908, 818, 611, 611, 833, 613, 613, - 825, -97, 206, 801, 247, 276, 839, 248, 249, -291, - 842, -582, 843, -478, 768, 585, 849, -582, 768, -108, - -478, 850, 853, 105, -291, 105, 859, 863, 865, 573, + 222, 504, 400, 300, 246, 252, 712, 588, 107, 537, + 270, 270, 71, 539, 71, 314, 265, 265, 775, 206, + 265, 617, 307, 311, 271, 271, 206, 449, 271, 861, + 87, 721, 888, 772, 315, 721, 654, 324, 826, 741, + 206, 556, 391, 391, 218, 393, 724, 440, 652, 836, + -107, 256, 661, -104, 525, 664, 334, 336, 338, 340, + 315, 681, 306, 310, 276, 281, 550, 1025, 444, 392, + 206, 1001, 125, 125, -109, 573, 682, 724, 696, 280, + 125, -111, 501, -488, 505, 267, 273, 706, 437, 274, + 856, 652, 393, 661, 3, 218, 782, 87, 700, 811, + 812, 283, 682, 790, 287, 346, -487, -485, 474, 581, + -110, -301, 773, 437, 293, 776, 434, 578, 533, 483, + -489, -106, 771, 125, -108, -105, -301, 366, 378, 378, + 600, 430, 910, 269, 269, 396, -112, 269, 916, 574, + -488, 682, -490, 783, 1025, 825, 468, 491, 443, 125, + 394, 744, 367, 558, 276, 281, 558, 607, 558, 296, + 558, -301, 558, -487, 1001, -587, 682, -99, -301, -586, + -96, 305, 443, 432, 857, 378, 378, -489, 401, 522, + -484, 391, 391, 611, 393, 441, 247, -492, 87, 248, + 249, -101, 772, -587, 904, 683, 667, 670, -103, -490, + 438, 218, 218, 528, 772, 547, 275, 466, 467, -104, + 397, 535, 535, 478, 479, 888, 535, 250, 888, 251, + 275, 324, 1007, 611, 611, 438, 296, -102, 542, -77, + 594, 270, 597, 541, 453, 270, 465, 502, -98, 502, + 504, -100, -97, 511, -492, 247, 300, 921, 248, 249, + -91, -491, 247, 218, 206, 248, 249, 218, 721, 721, + 905, 218, 218, -493, -479, 87, 752, 378, 378, 476, + 724, 773, 87, 87, -484, 265, 250, 523, 251, 265, + 87, 771, 442, 773, 471, 251, 896, 271, 488, -483, + 995, 315, 542, 771, 775, 888, 747, 755, -111, 356, + 357, 358, 359, -104, 524, 891, -110, 822, -491, 603, + 475, -111, 530, 460, 613, 360, 341, 342, 834, 553, + -493, -479, 728, 729, -96, 87, 218, 218, 218, 218, + 87, 218, 218, 527, 721, 353, 354, 480, 566, 567, + 568, 569, 484, 585, 835, 585, -483, -106, 512, 300, + 87, 565, 486, 442, 613, 613, 765, 71, 609, 491, + 938, 523, 570, 755, 679, 356, 357, 358, 359, 934, + 461, 87, 378, -108, 218, 558, 87, 315, -341, 618, + 125, 360, -111, 450, 451, 447, 805, 270, 860, 448, + -110, 954, 509, -341, 520, 771, 269, 867, -105, 511, + 503, 901, 296, -103, 499, 771, 364, 365, 366, 218, + 806, -102, 270, 816, 652, -106, 661, 519, 788, 618, + 618, 417, 807, 378, 511, 809, 828, 825, -341, 270, + 517, 265, 689, 367, 218, -341, 87, 218, 270, -108, + 526, 511, 852, 807, -76, 659, 718, 87, 659, 417, + 511, 218, 847, 538, 1006, 87, 265, 270, 996, 540, + 218, 270, 740, 532, 541, 87, 125, 563, 804, 659, + 544, 732, 721, 265, 911, 542, 660, 502, 502, 426, + 427, 428, 265, 724, 845, 564, 659, 106, 1023, 270, + 580, 1026, 270, -414, 246, 659, 42, 87, 771, 43, + 660, -499, 270, -105, 583, 296, 87, 586, 797, 722, + 517, 595, 470, 605, 511, 964, 965, 660, 605, 470, + 315, 893, 315, 805, 218, 587, 660, 844, 541, 71, + 206, 590, 87, 247, 659, 505, 248, 249, 737, 212, + 212, 739, 593, 59, 727, 212, 265, 429, 919, 959, + 960, 598, -106, 596, 906, 599, 493, -414, 218, 659, + 912, 914, 430, 806, 250, 660, 251, 517, 1067, 786, + 610, 771, -414, -98, 634, 611, 692, 218, -106, 847, + 762, 611, 771, 798, 699, 672, 315, 611, 611, 551, + 660, 686, -108, 945, 711, 452, 452, 431, 687, 779, + 690, 691, 378, 693, 432, -414, 552, -414, 714, 125, + 715, 125, -91, -100, -414, 802, 870, 872, 874, -583, + 876, 726, 877, 502, 808, 468, 731, 810, 105, 280, + 105, 734, 280, 786, 786, 105, 105, 1057, 749, 911, + 579, 105, 105, 105, 493, 535, 105, 446, 1045, 761, + 280, 764, 682, 218, 87, 824, 827, 781, 575, 983, + 827, 751, 942, 841, 820, 815, 978, 827, -105, 792, + -298, 791, 793, -298, -298, 125, 589, -106, 105, 803, + -106, -106, 817, -479, 270, 270, 246, 218, 818, -97, + 502, 917, 105, 611, 825, 801, 989, 206, -479, 840, + -298, -298, 991, -298, 276, 833, 613, 276, -106, 839, + -106, 541, 613, 908, 326, 327, 328, 489, 613, 613, + 248, 249, 206, 801, 247, 276, 843, 248, 249, 455, + 842, -583, 863, -479, 865, 585, 849, -583, 247, -108, + -479, 248, 249, 105, 430, 105, 850, 853, 573, 859, 517, 499, 270, 212, 212, 250, 869, 251, 871, 873, - 270, 875, 87, 878, 511, 924, 353, 354, 925, 315, - 87, 618, 481, 929, 218, 702, 702, 618, 218, -291, - 933, 786, 887, 618, 618, 935, -291, 430, 943, 87, - 87, 927, 973, 948, 931, 963, 265, 1008, 1010, 1011, - 1012, 966, 897, 87, 605, 969, 218, 559, 971, 659, - 327, 328, 849, 513, 516, 87, 87, 502, 932, 975, - 980, 611, 482, 87, 613, 493, 529, 981, 992, 432, - 531, 993, 493, 1002, 87, 87, 105, -301, -108, 1003, - 660, -108, -108, 1004, 247, 521, 1013, 248, 249, 105, - 105, 1009, -301, 585, 585, 767, 1014, 1015, 125, 947, - 430, 962, 329, 330, 1028, 1029, 968, 1030, 953, -108, - 955, -108, 1061, 545, 956, 250, 1033, 251, 212, 212, - 212, 212, 1037, 571, 572, 1064, 1040, -301, 430, 618, - 1045, -586, 733, 1047, -301, 473, 904, -585, 270, 87, - 87, 105, 432, 986, 1049, 105, 1051, 87, 827, 105, - 105, -586, 1069, 105, 669, 671, 1071, 227, 130, 920, - 105, 105, 755, 546, 356, 357, 358, 359, 105, 1060, - 432, 880, 928, 1062, 892, 918, 1059, 326, 327, 328, - 360, 490, -583, 208, 936, 937, 1038, 1005, 669, 671, - 125, 766, 940, 1022, 247, 125, 0, 248, 249, -589, - 1017, 0, 905, 0, 946, 0, 0, 87, 1024, 87, - 1027, 814, 87, 105, 105, 105, 105, 105, 105, 105, - 105, 0, 0, 0, -485, 0, 585, 251, 270, 684, - 329, 330, 125, 0, 0, 0, 735, 0, 105, -485, - 511, -290, 689, 827, 0, 1039, -482, 0, 1041, 0, - 218, 470, 0, 860, 970, 972, -290, 0, 0, 105, - 0, -482, 105, -589, 105, 0, 0, 105, 982, 0, - 0, 0, 265, 725, -485, 0, 990, 0, -589, 1063, - 730, -485, 0, 0, 1065, 659, 1067, -585, 0, 0, - 1068, -290, 736, 0, -583, 886, -482, 105, -290, -302, - -583, 0, 0, -482, 0, 0, 868, 105, 105, 0, - 1075, -589, 0, -589, -302, 0, 660, -585, 795, 1016, - -589, 0, 105, 0, 105, 105, 0, 0, 0, 0, - 1021, 0, 0, 430, 430, 105, 1034, 0, 1035, 105, - 0, 1036, 0, 105, 759, 760, 1031, 0, 105, -302, - 0, -585, 923, 105, 768, 0, -302, 892, 0, 0, - 892, 430, 892, 0, 0, 0, -585, 0, 796, 456, - -586, 337, 327, 328, 789, 432, 432, 702, 0, 755, - 0, 356, 357, 358, 359, 105, 1046, 1048, 1050, 0, - 1052, 1053, 0, 0, 105, 0, 1032, 360, 0, -585, - 0, -585, 0, 432, 0, -585, 0, 0, -585, 0, - 892, 0, 105, 0, 247, 217, 217, 248, 249, 0, - 105, 217, 266, 266, 329, 330, 266, 0, 0, 1070, - 1072, 1073, 1074, 0, -586, 0, 892, 0, 892, 1076, - 892, 0, 892, 0, 0, 212, 105, 251, 0, -586, - 0, 819, 0, 288, 290, 291, 292, 339, 327, 328, - 266, 308, 892, 470, 417, 105, 0, 0, 0, 470, - 1006, 0, 344, 345, 0, 1018, 0, 0, 886, 212, - 0, 886, -586, 886, -586, 552, 327, 328, -586, 0, - 0, -586, 424, 425, 426, 427, 428, 755, 0, 356, - 357, 358, 359, 0, 247, 851, 0, 248, 249, 0, - 329, 330, 907, 909, 0, 360, 0, 0, 913, 915, - 557, 327, 328, 217, 862, 561, 327, 328, 562, 327, - 328, 886, 750, 327, 328, 250, 0, 251, 329, 330, - 362, 105, 105, 0, 907, 909, 756, 913, 915, 0, - 777, 0, 356, 357, 358, 359, 0, 886, 0, 886, - 0, 886, 355, 886, 356, 357, 358, 359, 360, 0, - 0, 0, 0, 329, 330, 105, 414, 415, 329, 330, - 360, 329, 330, 886, 0, 329, 330, 0, 0, 417, - 0, 0, -298, 362, 361, -298, -298, 0, 212, 0, - 364, 365, 366, 0, 0, 362, 348, 349, 350, 351, - 352, 363, 364, 365, 366, 941, 423, 424, 425, 426, - 427, 428, -298, -298, 979, -298, 0, 367, 0, 217, - 217, 950, -612, 74, 0, 74, 121, 121, 0, 367, - 0, 0, 368, 0, 121, 0, 0, 979, 0, 247, - 105, 0, 248, 249, 0, 369, 0, 0, 105, 105, - 0, 0, 105, 0, 0, 105, 105, 495, 496, 497, - 344, 105, 105, 0, 0, 0, 499, 105, 105, 0, - 250, 266, 251, 74, 0, 266, 0, 121, 0, 217, + 270, 768, 87, 875, 511, 768, 878, 329, 330, 315, + 87, 618, 472, -584, 218, 702, 702, 618, 218, 456, + 924, 786, 925, 618, 618, 929, 432, 430, 933, 87, + 87, 927, 935, 943, 931, 948, 265, 1008, 1010, 1011, + 1012, 963, 897, 87, 605, 966, 218, 333, 969, 659, + 327, 328, 849, 513, 516, 87, 87, 502, 932, 551, + 971, 973, 473, 87, 613, 493, 529, 975, 980, 432, + 531, 981, 493, 992, 87, 87, 105, -483, -108, 993, + 660, -108, -108, 1002, 1003, 353, 354, 758, 1009, 105, + 105, 1013, -483, 585, 585, 767, 559, 1014, 125, 327, + 328, 962, 329, 330, 774, 1015, 968, 778, 1028, -108, + 998, -108, 356, 357, 358, 359, 1033, 1029, 212, 212, + 212, 212, 1030, 571, 572, -584, 1065, -483, 360, 618, + 1037, -584, 1039, 1041, -483, 883, 1046, 1048, 270, 87, + 87, 105, -590, 986, 1050, 105, 1052, 87, 827, 105, + 105, 329, 330, 105, 669, 671, 1062, 1070, -586, 920, + 105, 105, -587, 247, 1072, 733, 248, 249, 105, -586, + -587, 227, 928, 130, 1061, 880, 335, 247, 327, 328, + 248, 249, 1063, 918, 936, 937, 1038, -291, 669, 671, + 125, 1060, 940, 490, 250, 125, 251, 208, 766, 0, + 1017, 892, -291, 0, 946, 1022, -590, 87, 481, 87, + 251, 814, 87, 105, 105, 105, 105, 105, 105, 105, + 105, -590, 0, 430, 0, 0, 585, 0, 270, 684, + 329, 330, 125, -586, -587, 0, 735, -291, 105, 0, + 511, 0, 689, 827, -291, 0, 0, 0, -586, -587, + 218, 470, 0, 0, -590, 521, -590, 0, 482, 105, + -586, 0, 105, -590, 105, 432, 0, 105, 982, 0, + 430, 0, 265, 725, 0, 560, 990, 327, 328, 0, + 730, -586, -587, -586, -587, 659, 0, -586, -587, 0, + -586, -587, 736, 0, 887, 886, 0, 105, 0, 777, + 0, 356, 357, 358, 359, 473, 868, 105, 105, 0, + 0, 0, 432, 545, 0, 883, 660, 360, 883, 0, + 0, 883, 105, 883, 105, 105, 0, 0, 430, 329, + 330, 0, 0, 0, 0, 105, 1034, 0, 1035, 105, + -486, 1036, 362, 105, 759, 760, 0, 0, 105, 364, + 365, 366, 923, 105, 0, -486, 0, -290, 0, 0, + 970, 972, 0, 546, 0, 0, 0, 0, -302, 0, + 432, 883, -290, 0, 789, 0, 367, 702, 795, 0, + 953, 768, 955, -302, 892, 105, 956, 892, 0, 892, + -486, 1016, 0, 430, 105, 0, 0, -486, 883, 0, + 883, 0, 883, 0, 883, 0, 430, -290, 0, 0, + 0, 0, 105, 0, -290, 217, 217, 1031, -302, 0, + 105, 217, 266, 266, 883, -302, 266, 0, 796, 0, + 0, 0, 430, 0, 0, 432, 1021, 892, 0, 0, + 0, 456, 0, 0, 0, 212, 105, 0, 432, 0, + 0, 819, 0, 288, 290, 291, 292, 417, 1004, 1005, + 266, 308, 0, 470, 892, 105, 892, 1032, 892, 470, + 892, 0, 344, 345, 432, 1018, 0, 0, 886, 212, + 1024, 886, 1027, 886, 0, 424, 425, 426, 427, 428, + 892, 0, 1047, 1049, 1051, 0, 1053, 1054, 0, 0, + 337, 327, 328, 0, 0, 851, 348, 349, 350, 351, + 352, 0, 907, 909, 0, 0, 0, 1040, 913, 915, + 1042, 0, 0, 217, 862, 339, 327, 328, 552, 327, + 328, 886, 0, 0, 0, 0, 1071, 1073, 1074, 1075, + 0, 105, 105, 0, 907, 909, 1077, 913, 915, 557, + 327, 328, 1064, 329, 330, 0, 0, 1066, 886, 1068, + 886, 0, 886, 1069, 886, 0, 0, 0, 355, 0, + 356, 357, 358, 359, 0, 105, 0, 0, 329, 330, + 0, 329, 330, 1076, 886, 0, 360, 561, 327, 328, + 0, 755, 0, 356, 357, 358, 359, 0, 212, 0, + 361, 0, 329, 330, 0, 0, 0, 0, 0, 360, + 0, 362, 0, 0, 0, 941, 0, 363, 364, 365, + 366, 562, 327, 328, 979, 0, 750, 327, 328, 217, + 217, 950, 0, 74, 362, 74, 121, 121, -613, 0, + 329, 330, 0, 0, 121, 367, 0, 979, 368, 0, + 105, 247, 0, 0, 248, 249, 0, 0, 105, 105, + 0, 369, 105, 0, 0, 105, 105, 495, 496, 497, + 344, 105, 105, 0, 329, 330, 0, 105, 105, 329, + 330, 266, 944, 74, 251, 266, 0, 121, 0, 217, 217, 105, 0, 0, 105, 0, 355, 0, 356, 357, - 358, 359, 0, 105, 105, 247, 0, 0, 248, 249, + 358, 359, 0, 105, 105, 0, 0, 0, 0, 0, 0, 105, 0, 121, 360, 755, 0, 356, 357, 358, - 359, 0, 105, 105, 414, 415, 0, 0, 361, 0, - 0, 0, 0, 360, 0, 0, 944, 417, 251, 362, - 0, 0, 0, 0, 0, 363, 364, 365, 366, 0, - 74, 0, 0, 0, 217, 217, 217, 217, 362, 217, - 217, 0, 0, 0, 949, 424, 425, 426, 427, 428, - 0, 0, 0, 367, 0, 0, 368, 105, 998, 582, - 356, 357, 358, 359, 0, 0, 0, 105, 105, 369, - 592, 0, 0, 0, 0, 105, 360, 0, 0, 0, + 359, 0, 105, 105, 0, 414, 415, 0, 361, 0, + 0, 0, 0, 360, 0, 0, 0, 0, 417, 362, + 414, 415, 0, 0, 0, 363, 364, 365, 366, 0, + 74, 0, 0, 417, 217, 217, 217, 217, 362, 217, + 217, 0, 0, 0, 756, 423, 424, 425, 426, 427, + 428, 0, 0, 367, 0, 0, 368, 105, 0, 582, + 0, 424, 425, 426, 427, 428, 0, 105, 105, 369, + 592, 0, 0, 0, 0, 105, 0, 0, 0, 0, 0, 0, 604, 0, 0, 0, 0, 615, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 0, 635, 636, 637, 638, 639, 640, 641, - 642, 643, 644, 645, 646, 0, 0, 266, 0, 0, - 755, 74, 356, 357, 358, 359, 0, 668, 668, 0, - 0, 0, 0, 0, 0, 105, 0, 105, 360, 0, - 105, 0, 266, 0, 0, 217, 0, 0, 0, 0, + 642, 643, 644, 645, 646, 0, 247, 266, 0, 248, + 249, 74, 0, 0, 0, 0, 0, 668, 668, 0, + 0, 0, 0, 0, 0, 105, 0, 105, 0, 0, + 105, 0, 266, 499, 0, 217, 0, 250, 0, 251, 0, 355, 0, 356, 357, 358, 359, 668, 0, 266, - 0, 668, 668, 362, 0, 0, 0, 0, 266, 360, + 0, 668, 668, 0, 0, 0, 0, 0, 266, 360, 0, 0, 0, 0, 0, 0, 0, 713, 105, 0, 716, 0, 0, 0, 717, 0, 0, 720, 0, 723, 0, 308, 292, 0, 362, 414, 415, 0, 74, 0, 363, 364, 365, 366, 0, 74, 74, 0, 417, 668, - 0, 0, 0, 74, 0, 0, 0, 0, 0, 720, + 0, 0, 755, 74, 356, 357, 358, 359, 0, 720, 0, 0, 308, 0, 121, 0, 0, 0, 367, 0, - 0, 368, 266, 421, 422, 423, 424, 425, 426, 427, + 360, 368, 266, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 0, 548, 0, 0, 0, 0, 753, - 754, 0, 0, 0, 0, 0, 0, 0, 74, 0, - 0, 0, 0, 74, 0, 0, 763, 0, 0, 0, + 754, 0, 0, 0, 0, 362, 0, 0, 74, 0, + 0, 949, 0, 74, 0, 0, 763, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -612, 0, 74, 0, 780, 0, 355, 787, 356, - 357, 358, 359, 0, -612, -612, -612, -612, -612, -612, - 0, -612, 0, 0, 74, 360, 0, -612, -612, 74, - 121, 0, 74, 0, 0, 0, 0, 0, -612, -612, - 0, -612, -612, -612, -612, -612, 0, 0, 0, 0, + 0, -613, 0, 74, 0, 780, 0, 355, 787, 356, + 357, 358, 359, 0, -613, -613, -613, -613, -613, -613, + 0, -613, 0, 0, 74, 360, 0, -613, -613, 74, + 121, 0, 74, 0, 0, 0, 0, 0, -613, -613, + 0, -613, -613, -613, -613, -613, 0, 0, 0, 0, 362, 0, 0, 0, 0, 0, 363, 364, 365, 366, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, 74, 0, 0, 0, 0, 0, 0, 0, 217, 0, 0, 367, 0, 0, 368, 0, 74, - 0, -612, 0, 821, 0, 0, 763, 780, 1019, 0, - 74, 75, 0, 75, 122, 122, -612, 0, 74, 0, - 0, 0, 122, 0, 0, 217, -612, 0, 74, -612, - -612, 0, 0, 0, 0, 846, 0, 0, 0, 0, - 0, 0, 0, 0, 720, 308, 0, 0, 0, -612, - -612, 0, 0, 0, 0, 275, -612, -612, -612, -612, + 0, -613, 0, 821, 0, 0, 763, 780, 1019, 0, + 74, 75, 0, 75, 122, 122, -613, 0, 74, 0, + 0, 0, 122, 0, 0, 217, -613, 0, 74, -613, + -613, 0, 0, 0, 0, 846, 0, 0, 0, 0, + 0, 0, 0, 0, 720, 308, 0, 0, 0, -613, + -613, 0, 0, 0, 0, 275, -613, -613, -613, -613, 74, 75, 0, 0, 0, 122, 0, 0, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 121, 0, 121, 0, 0, 0, 0, @@ -2821,8 +2821,8 @@ static const yytype_int16 yytable[] = 0, 0, 102, 0, 0, 0, 0, 102, 0, 0, 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, 0, 102, 0, 0, - 0, 84, 0, 0, -613, -613, -613, -613, 406, 407, - 0, 84, -613, -613, 0, 0, 0, 0, 102, 0, + 0, 84, 0, 0, -614, -614, -614, -614, 406, 407, + 0, 84, -614, -614, 0, 0, 0, 0, 102, 0, 414, 415, 0, 102, 0, 0, 102, 0, 0, 0, 0, 0, 0, 417, 0, 101, 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, 0, 0, 0, 0, @@ -2878,7 +2878,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 102, 102, 0, 0, 0, 0, 0, 0, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -612, 4, 0, 5, + 0, 0, 0, 0, 0, 0, -613, 4, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 0, 0, 0, 0, 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, @@ -2890,10 +2890,10 @@ static const yytype_int16 yytable[] = 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, -292, - 64, -612, 0, 0, -612, -612, 0, 0, 0, 0, + 64, -613, 0, 0, -613, -613, 0, 0, 0, 0, 0, 0, -292, -292, -292, -292, -292, -292, 0, -292, 65, 66, 67, 0, 0, 0, -292, -292, -292, 0, - 0, 0, -612, 0, -612, 0, -292, -292, 0, -292, + 0, 0, -613, 0, -613, 0, -292, -292, 0, -292, -292, -292, -292, -292, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -292, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -2903,90 +2903,90 @@ static const yytype_int16 yytable[] = -292, 0, 0, 0, -292, 0, 0, 0, 0, 0, 0, 0, -292, 0, -292, 0, 0, -292, -292, 0, 0, -292, -292, -292, -292, -292, -292, -292, -292, -292, - -292, -292, -292, 0, 0, -412, 0, 0, -292, -292, - -292, -292, 0, 0, -292, -292, -292, -292, -412, -412, - -412, -412, -412, -412, 0, -412, 0, 0, 0, 0, - 0, -412, -412, -412, 0, 0, 0, 0, 0, 0, - 0, 0, -412, -412, 0, -412, -412, -412, -412, -412, + -292, -292, -292, 0, 0, -413, 0, 0, -292, -292, + -292, -292, 0, 0, -292, -292, -292, -292, -413, -413, + -413, -413, -413, -413, 0, -413, 0, 0, 0, 0, + 0, -413, -413, -413, 0, 0, 0, 0, 0, 0, + 0, 0, -413, -413, 0, -413, -413, -413, -413, -413, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, -412, -412, -412, - -412, -412, -412, -412, -412, -412, -412, -412, -412, 0, - 0, 0, 0, -412, -412, -412, 0, 0, -412, 0, - 0, 0, 0, 0, -412, 0, -412, 0, 0, 0, - -412, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -412, 0, 0, -412, -412, 0, 0, -412, 0, -412, - -412, -412, -412, -412, -412, -412, -412, -412, -412, 0, - 0, -478, 0, -412, -412, -412, -412, -412, 0, 275, - -412, -412, -412, -412, -478, -478, -478, -478, -478, -478, - 0, -478, 0, 0, 0, 0, 0, 0, -478, -478, - 0, 0, 0, 0, 0, 0, 0, 0, -478, -478, - 0, -478, -478, -478, -478, -478, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -413, -413, -413, + -413, -413, -413, -413, -413, -413, -413, -413, -413, 0, + 0, 0, 0, -413, -413, -413, 0, 0, -413, 0, + 0, 0, 0, 0, -413, 0, -413, 0, 0, 0, + -413, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -413, 0, 0, -413, -413, 0, 0, -413, 0, -413, + -413, -413, -413, -413, -413, -413, -413, -413, -413, 0, + 0, -479, 0, -413, -413, -413, -413, -413, 0, 275, + -413, -413, -413, -413, -479, -479, -479, -479, -479, -479, + 0, -479, 0, 0, 0, 0, 0, 0, -479, -479, + 0, 0, 0, 0, 0, 0, 0, 0, -479, -479, + 0, -479, -479, -479, -479, -479, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 494, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, -478, -478, -478, -478, -478, -478, -478, - -478, -478, -478, -478, -478, 0, 0, 0, 0, -478, - -478, -478, 0, -478, -478, 0, 0, 0, 0, 0, - -478, 0, -478, 0, 0, 0, -478, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -478, 0, 0, -478, - -478, 0, -478, -478, 0, -478, -478, -478, -478, -478, - -478, -478, -478, -478, -478, 0, 0, -612, 0, 0, - -478, -478, -478, -478, 0, 0, -478, -478, -478, -478, - -612, -612, -612, -612, -612, -612, 0, -612, 0, 0, - 0, 0, 0, -612, -612, -612, 0, 0, 0, 0, - 0, 0, 0, 0, -612, -612, 0, -612, -612, -612, - -612, -612, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -479, -479, -479, -479, -479, -479, -479, + -479, -479, -479, -479, -479, 0, 0, 0, 0, -479, + -479, -479, 0, -479, -479, 0, 0, 0, 0, 0, + -479, 0, -479, 0, 0, 0, -479, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -479, 0, 0, -479, + -479, 0, -479, -479, 0, -479, -479, -479, -479, -479, + -479, -479, -479, -479, -479, 0, 0, -613, 0, 0, + -479, -479, -479, -479, 0, 0, -479, -479, -479, -479, + -613, -613, -613, -613, -613, -613, 0, -613, 0, 0, + 0, 0, 0, -613, -613, -613, 0, 0, 0, 0, + 0, 0, 0, 0, -613, -613, 0, -613, -613, -613, + -613, -613, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, -612, - -612, -612, -612, -612, -612, -612, -612, -612, -612, -612, - -612, 0, 0, 0, 0, -612, -612, -612, 0, 0, - -612, 0, 0, 0, 0, 0, -612, 0, -612, 0, - 0, 0, -612, 0, 0, 0, 0, 0, 0, 0, - 0, 0, -612, 0, 0, -612, -612, 0, 0, -612, - 0, -612, -612, -612, -612, -612, -612, -612, -612, -612, - -612, 0, 0, -612, 0, -612, -612, -612, -612, -612, - 0, 275, -612, -612, -612, -612, -612, -612, -612, -612, - -612, -612, 0, -612, 0, 0, 0, 0, 0, 0, - -612, -612, 0, 0, 0, 0, 0, 0, 0, 0, - -612, -612, 0, -612, -612, -612, -612, -612, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -613, + -613, -613, -613, -613, -613, -613, -613, -613, -613, -613, + -613, 0, 0, 0, 0, -613, -613, -613, 0, 0, + -613, 0, 0, 0, 0, 0, -613, 0, -613, 0, + 0, 0, -613, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -613, 0, 0, -613, -613, 0, 0, -613, + 0, -613, -613, -613, -613, -613, -613, -613, -613, -613, + -613, 0, 0, -613, 0, -613, -613, -613, -613, -613, + 0, 275, -613, -613, -613, -613, -613, -613, -613, -613, + -613, -613, 0, -613, 0, 0, 0, 0, 0, 0, + -613, -613, 0, 0, 0, 0, 0, 0, 0, 0, + -613, -613, 0, -613, -613, -613, -613, -613, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, -612, -612, -612, -612, -612, - -612, -612, -612, -612, -612, -612, -612, 0, 0, 0, - 0, -612, -612, -612, 0, 0, -612, 0, 0, 0, - 0, 0, -612, 0, -612, 0, 0, 0, -612, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -612, 0, - 0, -612, -612, 0, 0, -612, 0, -612, -612, -612, - -612, -612, -612, -612, -612, -612, -612, 0, 0, -589, - 0, 0, -612, -612, -612, -612, 0, 275, -612, -612, - -612, -612, -589, -589, -589, 0, -589, -589, 0, -589, - 0, 0, 0, 0, 0, -589, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -589, -589, 0, -589, - -589, -589, -589, -589, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -613, -613, -613, -613, -613, + -613, -613, -613, -613, -613, -613, -613, 0, 0, 0, + 0, -613, -613, -613, 0, 0, -613, 0, 0, 0, + 0, 0, -613, 0, -613, 0, 0, 0, -613, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -613, 0, + 0, -613, -613, 0, 0, -613, 0, -613, -613, -613, + -613, -613, -613, -613, -613, -613, -613, 0, 0, -590, + 0, 0, -613, -613, -613, -613, 0, 275, -613, -613, + -613, -613, -590, -590, -590, 0, -590, -590, 0, -590, + 0, 0, 0, 0, 0, -590, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -590, -590, 0, -590, + -590, -590, -590, -590, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -589, -589, -589, -589, -589, -589, -589, -589, -589, - -589, -589, -589, 0, 0, 0, 0, -589, -589, -589, - 0, 799, -589, 0, 0, 0, 0, 0, 0, 0, - -589, 0, 0, 0, -589, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -589, 0, 0, -589, -589, 0, - -107, -589, 0, -589, -589, -589, -589, -589, -589, -589, - -589, -589, -589, 0, 0, -589, 0, -589, -589, -589, - 0, -99, 0, 0, -589, -589, -589, -589, -589, -589, - -589, 0, -589, -589, 0, -589, 0, 0, 0, 0, - 0, -589, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, -589, -589, 0, -589, -589, -589, -589, -589, + 0, -590, -590, -590, -590, -590, -590, -590, -590, -590, + -590, -590, -590, 0, 0, 0, 0, -590, -590, -590, + 0, 799, -590, 0, 0, 0, 0, 0, 0, 0, + -590, 0, 0, 0, -590, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -590, 0, 0, -590, -590, 0, + -107, -590, 0, -590, -590, -590, -590, -590, -590, -590, + -590, -590, -590, 0, 0, -590, 0, -590, -590, -590, + 0, -99, 0, 0, -590, -590, -590, -590, -590, -590, + -590, 0, -590, -590, 0, -590, 0, 0, 0, 0, + 0, -590, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -590, -590, 0, -590, -590, -590, -590, -590, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, -589, -589, -589, - -589, -589, -589, -589, -589, -589, -589, -589, -589, 0, - 0, 0, 0, -589, -589, -589, 0, 799, -589, 0, - 0, 0, 0, 0, 0, 0, -589, 0, 0, 0, - -589, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -589, 0, 0, -589, -589, 0, -107, -589, 0, -589, - -589, -589, -589, -589, -589, -589, -589, -589, -589, 0, - 0, -301, 0, -589, -589, -589, 0, -589, 0, 0, - -589, -589, -589, -589, -301, -301, -301, 0, -301, -301, + 0, 0, 0, 0, 0, 0, 0, -590, -590, -590, + -590, -590, -590, -590, -590, -590, -590, -590, -590, 0, + 0, 0, 0, -590, -590, -590, 0, 799, -590, 0, + 0, 0, 0, 0, 0, 0, -590, 0, 0, 0, + -590, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -590, 0, 0, -590, -590, 0, -107, -590, 0, -590, + -590, -590, -590, -590, -590, -590, -590, -590, -590, 0, + 0, -301, 0, -590, -590, -590, 0, -590, 0, 0, + -590, -590, -590, -590, -301, -301, -301, 0, -301, -301, 0, -301, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -301, -301, 0, -301, -301, -301, -301, -301, 0, 0, 0, 0, @@ -3014,8 +3014,8 @@ static const yytype_int16 yytable[] = 0, -301, -301, -301, -301, -301, -301, -301, -301, -301, -301, 0, 0, 0, 0, 0, -301, -301, 0, -301, 0, 0, -301, -301, -301, -301, 294, 0, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, -612, -612, - -612, 0, 0, -612, 15, 0, 16, 17, 18, 19, + 7, 8, 9, 10, 11, 12, 13, 14, -613, -613, + -613, 0, 0, -613, 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, 32, 33, 34, 35, 36, 37, @@ -3025,11 +3025,11 @@ static const yytype_int16 yytable[] = 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, - -612, 0, 0, -612, -612, 0, 0, 0, 0, 0, + -613, 0, 0, -613, -613, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 66, 67, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -612, 294, -612, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 0, 0, -612, 0, -612, -612, + 0, -613, 294, -613, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 0, 0, -613, 0, -613, -613, 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, @@ -3039,12 +3039,12 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, - 0, 61, 62, 63, 0, 64, -612, 0, 0, -612, - -612, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 61, 62, 63, 0, 64, -613, 0, 0, -613, + -613, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 66, 67, 0, 0, - 0, 0, 0, 0, 0, 0, 0, -612, 294, -612, + 0, 0, 0, 0, 0, 0, 0, -613, 294, -613, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 0, 0, -612, 0, 0, -612, 15, -612, 16, 17, + 0, 0, -613, 0, 0, -613, 15, -613, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, 32, 33, 34, 35, @@ -3054,12 +3054,12 @@ static const yytype_int16 yytable[] = 0, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, - 0, 64, -612, 0, 0, -612, -612, 0, 0, 0, + 0, 64, -613, 0, 0, -613, -613, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 66, 67, 0, 0, 0, 0, 0, 0, - 0, 0, 0, -612, 294, -612, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 0, 0, -612, 0, - 0, -612, 15, 0, 16, 17, 18, 19, 0, 0, + 0, 0, 0, -613, 294, -613, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 0, 0, -613, 0, + 0, -613, 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, @@ -3068,11 +3068,11 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, - 59, 60, 0, 61, 62, 63, 0, 64, -612, 0, - 0, -612, -612, 4, 0, 5, 6, 7, 8, 9, + 59, 60, 0, 61, 62, 63, 0, 64, -613, 0, + 0, -613, -613, 4, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, - 0, 15, 0, 16, 17, 18, 19, 0, 0, -612, - 0, -612, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 15, 0, 16, 17, 18, 19, 0, 0, -613, + 0, -613, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, 40, 41, 42, 0, 0, 43, 0, 0, 44, 45, @@ -3080,12 +3080,12 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, - 60, 0, 61, 62, 63, 0, 64, -612, 0, 0, - -612, -612, 0, 0, 0, 0, 0, 0, 0, 0, + 60, 0, 61, 62, 63, 0, 64, -613, 0, 0, + -613, -613, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 66, 67, 0, - 0, -612, 0, 0, 0, 0, 0, 0, -612, 294, - -612, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 0, -612, -612, 0, 0, 0, 15, 0, 16, + 0, -613, 0, 0, 0, 0, 0, 0, -613, 294, + -613, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 0, -613, -613, 0, 0, 0, 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, 32, 33, 34, @@ -3095,10 +3095,10 @@ static const yytype_int16 yytable[] = 0, 0, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, - 63, 0, 64, -612, 0, 0, -612, -612, 294, 0, + 63, 0, 64, -613, 0, 0, -613, -613, 294, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, 0, 15, 0, 16, 17, - 18, 19, 0, 0, -612, 0, -612, 20, 21, 22, + 18, 19, 0, 0, -613, 0, -613, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, 40, 41, 42, 0, 0, @@ -3107,10 +3107,10 @@ static const yytype_int16 yytable[] = 0, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 295, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, - 0, 64, -612, 0, 0, -612, -612, 294, 0, 5, + 0, 64, -613, 0, 0, -613, -613, 294, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, 0, 15, 0, 16, 17, 18, - 19, 0, -612, -612, 0, -612, 20, 21, 22, 23, + 19, 0, -613, -613, 0, -613, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, 40, 41, 42, 0, 0, 43, @@ -3119,10 +3119,10 @@ static const yytype_int16 yytable[] = 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, - 64, -612, 0, 0, -612, -612, 294, 0, 5, 6, + 64, -613, 0, 0, -613, -613, 294, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, 0, 15, 0, 16, 17, 18, 19, - 0, -612, -612, 0, -612, 20, 21, 22, 23, 24, + 0, -613, -613, 0, -613, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, 40, 41, 42, 0, 0, 43, 0, @@ -3131,11 +3131,11 @@ static const yytype_int16 yytable[] = 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, - -612, 0, 0, -612, -612, 0, 0, 0, 0, 0, + -613, 0, 0, -613, -613, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, - 66, 67, 0, 0, -612, 0, 0, 0, 0, 0, - 0, -612, 294, -612, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 0, 0, -612, 0, 0, 0, + 66, 67, 0, 0, -613, 0, 0, 0, 0, 0, + 0, -613, 294, -613, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 0, 0, -613, 0, 0, 0, 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 0, 30, 31, @@ -3145,10 +3145,10 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, - 0, 61, 62, 63, 0, 64, -612, 0, 0, -612, - -612, 0, 0, 5, 6, 7, 8, 9, 10, 11, + 0, 61, 62, 63, 0, 64, -613, 0, 0, -613, + -613, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, 0, 15, - 0, 16, 17, 18, 19, 0, 0, -612, 0, -612, + 0, 16, 17, 18, 19, 0, 0, -613, 0, -613, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, 40, 41, @@ -3222,83 +3222,83 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 0, 201, 202, 0, - 0, 0, 0, 0, 0, 203, 204, -582, -582, -582, - -582, -582, -582, -582, -582, -582, 0, 0, 0, 0, - 0, 0, 0, -582, 0, -582, -582, -582, -582, 0, - -582, 0, 0, 0, -582, -582, -582, -582, -582, -582, - -582, 0, 0, -582, 0, 0, 0, 0, 0, 0, - 0, 0, -582, -582, -582, -582, -582, -582, -582, -582, - -582, 0, -582, -582, -582, 0, 0, -582, 0, 0, - -582, -582, 0, -582, -582, -582, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -582, -582, - 0, 0, 0, 0, 0, -582, 0, 0, -582, -582, - 0, -582, -582, 0, -582, 0, -582, -582, -582, 0, - -582, -582, -582, 0, -582, -582, -582, 0, -582, 0, + 0, 0, 0, 0, 0, 203, 204, -583, -583, -583, + -583, -583, -583, -583, -583, -583, 0, 0, 0, 0, + 0, 0, 0, -583, 0, -583, -583, -583, -583, 0, + -583, 0, 0, 0, -583, -583, -583, -583, -583, -583, + -583, 0, 0, -583, 0, 0, 0, 0, 0, 0, + 0, 0, -583, -583, -583, -583, -583, -583, -583, -583, + -583, 0, -583, -583, -583, 0, 0, -583, 0, 0, + -583, -583, 0, -583, -583, -583, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -583, -583, + 0, 0, 0, 0, 0, -583, 0, 0, -583, -583, + 0, -583, -583, 0, -583, 0, -583, -583, -583, 0, + -583, -583, -583, 0, -583, -583, -583, 0, -583, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -582, -582, - -582, 0, -582, 0, 0, 0, 0, 0, -582, -583, - -583, -583, -583, -583, -583, -583, -583, -583, 0, 0, - 0, 0, 0, 0, 0, -583, 0, -583, -583, -583, - -583, 0, -583, 0, 0, 0, -583, -583, -583, -583, - -583, -583, -583, 0, 0, -583, 0, 0, 0, 0, - 0, 0, 0, 0, -583, -583, -583, -583, -583, -583, - -583, -583, -583, 0, -583, -583, -583, 0, 0, -583, - 0, 0, -583, -583, 0, -583, -583, -583, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -583, -583, + -583, 0, -583, 0, 0, 0, 0, 0, -583, -584, + -584, -584, -584, -584, -584, -584, -584, -584, 0, 0, + 0, 0, 0, 0, 0, -584, 0, -584, -584, -584, + -584, 0, -584, 0, 0, 0, -584, -584, -584, -584, + -584, -584, -584, 0, 0, -584, 0, 0, 0, 0, + 0, 0, 0, 0, -584, -584, -584, -584, -584, -584, + -584, -584, -584, 0, -584, -584, -584, 0, 0, -584, + 0, 0, -584, -584, 0, -584, -584, -584, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -583, -583, 0, 0, 0, 0, 0, -583, 0, 0, - -583, -583, 0, -583, -583, 0, -583, 0, -583, -583, - -583, 0, -583, -583, -583, 0, -583, -583, -583, 0, - -583, 0, 0, 0, 0, 0, 0, -585, -585, -585, - -585, -585, -585, -585, -585, -585, 0, 0, 0, 0, - -583, -583, -583, -585, -583, -585, -585, -585, -585, 0, - -583, 0, 0, 0, -585, -585, -585, -585, -585, -585, - -585, 0, 0, -585, 0, 0, 0, 0, 0, 0, - 0, 0, -585, -585, -585, -585, -585, -585, -585, -585, - -585, 0, -585, -585, -585, 0, 0, -585, 0, 0, - -585, -585, 0, -585, -585, -585, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -585, -585, - 0, 0, 0, 0, 0, -585, 831, 0, -585, -585, - 0, -585, -585, 0, -585, 0, -585, -585, -585, 0, - -585, -585, -585, 0, -585, -585, -585, 0, -585, 0, - 0, 0, 0, 0, 0, -107, -586, -586, -586, -586, - -586, -586, -586, -586, -586, 0, 0, 0, -585, -585, - -585, 0, -586, 0, -586, -586, -586, -586, -585, 0, - 0, 0, 0, -586, -586, -586, -586, -586, -586, -586, - 0, 0, -586, 0, 0, 0, 0, 0, 0, 0, - 0, -586, -586, -586, -586, -586, -586, -586, -586, -586, - 0, -586, -586, -586, 0, 0, -586, 0, 0, -586, - -586, 0, -586, -586, -586, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, -586, -586, 0, - 0, 0, 0, 0, -586, 832, 0, -586, -586, 0, - -586, -586, 0, -586, 0, -586, -586, -586, 0, -586, - -586, -586, 0, -586, -586, -586, 0, -586, 0, 0, - 0, 0, 0, 0, -109, -587, -587, -587, -587, -587, - -587, -587, -587, -587, 0, 0, 0, -586, -586, -586, - 0, -587, 0, -587, -587, -587, -587, -586, 0, 0, - 0, 0, -587, -587, -587, -587, -587, -587, -587, 0, - 0, -587, 0, 0, 0, 0, 0, 0, 0, 0, - -587, -587, -587, -587, -587, -587, -587, -587, -587, 0, - -587, -587, -587, 0, 0, -587, 0, 0, -587, -587, - 0, -587, -587, -587, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -587, -587, 0, 0, - 0, 0, 0, -587, 0, 0, -587, -587, 0, -587, - -587, 0, -587, 0, -587, -587, -587, 0, -587, -587, - -587, 0, -587, -587, -587, 0, -587, 0, 0, 0, - 0, 0, 0, -588, -588, -588, -588, -588, -588, -588, - -588, -588, 0, 0, 0, 0, -587, -587, -587, -588, - 0, -588, -588, -588, -588, 0, -587, 0, 0, 0, - -588, -588, -588, -588, -588, -588, -588, 0, 0, -588, - 0, 0, 0, 0, 0, 0, 0, 0, -588, -588, - -588, -588, -588, -588, -588, -588, -588, 0, -588, -588, - -588, 0, 0, -588, 0, 0, -588, -588, 0, -588, - -588, -588, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -588, -588, 0, 0, 0, 0, - 0, -588, 0, 0, -588, -588, 0, -588, -588, 0, - -588, 0, -588, -588, -588, 0, -588, -588, -588, 0, - -588, -588, -588, 0, -588, 0, 0, 0, 0, 0, + -584, -584, 0, 0, 0, 0, 0, -584, 0, 0, + -584, -584, 0, -584, -584, 0, -584, 0, -584, -584, + -584, 0, -584, -584, -584, 0, -584, -584, -584, 0, + -584, 0, 0, 0, 0, 0, 0, -586, -586, -586, + -586, -586, -586, -586, -586, -586, 0, 0, 0, 0, + -584, -584, -584, -586, -584, -586, -586, -586, -586, 0, + -584, 0, 0, 0, -586, -586, -586, -586, -586, -586, + -586, 0, 0, -586, 0, 0, 0, 0, 0, 0, + 0, 0, -586, -586, -586, -586, -586, -586, -586, -586, + -586, 0, -586, -586, -586, 0, 0, -586, 0, 0, + -586, -586, 0, -586, -586, -586, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -586, -586, + 0, 0, 0, 0, 0, -586, 831, 0, -586, -586, + 0, -586, -586, 0, -586, 0, -586, -586, -586, 0, + -586, -586, -586, 0, -586, -586, -586, 0, -586, 0, + 0, 0, 0, 0, 0, -107, -587, -587, -587, -587, + -587, -587, -587, -587, -587, 0, 0, 0, -586, -586, + -586, 0, -587, 0, -587, -587, -587, -587, -586, 0, + 0, 0, 0, -587, -587, -587, -587, -587, -587, -587, + 0, 0, -587, 0, 0, 0, 0, 0, 0, 0, + 0, -587, -587, -587, -587, -587, -587, -587, -587, -587, + 0, -587, -587, -587, 0, 0, -587, 0, 0, -587, + -587, 0, -587, -587, -587, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -587, -587, 0, + 0, 0, 0, 0, -587, 832, 0, -587, -587, 0, + -587, -587, 0, -587, 0, -587, -587, -587, 0, -587, + -587, -587, 0, -587, -587, -587, 0, -587, 0, 0, + 0, 0, 0, 0, -109, -588, -588, -588, -588, -588, + -588, -588, -588, -588, 0, 0, 0, -587, -587, -587, + 0, -588, 0, -588, -588, -588, -588, -587, 0, 0, + 0, 0, -588, -588, -588, -588, -588, -588, -588, 0, + 0, -588, 0, 0, 0, 0, 0, 0, 0, 0, + -588, -588, -588, -588, -588, -588, -588, -588, -588, 0, + -588, -588, -588, 0, 0, -588, 0, 0, -588, -588, + 0, -588, -588, -588, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -588, -588, 0, 0, + 0, 0, 0, -588, 0, 0, -588, -588, 0, -588, + -588, 0, -588, 0, -588, -588, -588, 0, -588, -588, + -588, 0, -588, -588, -588, 0, -588, 0, 0, 0, + 0, 0, 0, -589, -589, -589, -589, -589, -589, -589, + -589, -589, 0, 0, 0, 0, -588, -588, -588, -589, + 0, -589, -589, -589, -589, 0, -588, 0, 0, 0, + -589, -589, -589, -589, -589, -589, -589, 0, 0, -589, + 0, 0, 0, 0, 0, 0, 0, 0, -589, -589, + -589, -589, -589, -589, -589, -589, -589, 0, -589, -589, + -589, 0, 0, -589, 0, 0, -589, -589, 0, -589, + -589, -589, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -589, -589, 0, 0, 0, 0, + 0, -589, 0, 0, -589, -589, 0, -589, -589, 0, + -589, 0, -589, -589, -589, 0, -589, -589, -589, 0, + -589, -589, -589, 0, -589, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -588, -588, -588, 0, 0, 0, - 0, 0, 0, 0, -588, 131, 132, 133, 134, 135, + 0, 0, 0, 0, -589, -589, -589, 0, 0, 0, + 0, 0, 0, 0, -589, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 0, 0, 0, 155, 156, 157, 233, 234, 235, 236, 162, @@ -3754,7 +3754,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 0, 201, 202, 1042, 648, 0, 0, 1043, 0, 203, + 0, 201, 202, 1043, 648, 0, 0, 1044, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, @@ -3762,8 +3762,8 @@ static const yytype_int16 yytable[] = 0, 0, 188, 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 0, 201, 202, 1054, - 648, 0, 0, 1055, 0, 203, 275, 0, 0, 0, + 195, 196, 197, 198, 199, 200, 0, 201, 202, 1055, + 648, 0, 0, 1056, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, @@ -3771,7 +3771,7 @@ static const yytype_int16 yytable[] = 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 0, 201, 202, 1057, 657, 0, 0, 1058, + 199, 200, 0, 201, 202, 1058, 657, 0, 0, 1059, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, @@ -3843,7 +3843,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 418, 0, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, -613, -613, 0, 0, + 406, 407, 408, 409, 410, 411, -614, -614, 0, 0, 0, 0, 414, 415, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -3856,181 +3856,181 @@ static const yytype_int16 yycheck[] = 2, 89, 16, 17, 27, 69, 20, 87, 88, 66, 2, 28, 4, 5, 6, 22, 7, 9, 10, 21, 14, 13, 222, 15, 16, 17, 284, 313, 20, 479, - 10, 271, 82, 52, 28, 15, 488, 377, 401, 306, - 54, 55, 2, 310, 4, 4, 16, 17, 56, 7, - 20, 593, 54, 55, 16, 17, 14, 118, 20, 75, - 52, 501, 26, 590, 56, 505, 431, 58, 688, 318, - 28, 330, 74, 75, 66, 756, 505, 91, 429, 699, - 944, 15, 433, 25, 295, 436, 60, 61, 62, 63, - 82, 456, 54, 55, 21, 22, 25, 75, 105, 25, - 58, 544, 5, 6, 57, 51, 457, 536, 473, 111, - 13, 25, 269, 90, 271, 16, 17, 482, 16, 20, - 369, 472, 79, 474, 29, 117, 26, 119, 25, 665, - 666, 969, 483, 783, 90, 69, 25, 25, 218, 372, - 25, 0, 90, 92, 122, 802, 90, 90, 305, 229, - 783, 808, 590, 56, 121, 101, 102, 103, 74, 75, - 393, 105, 90, 16, 17, 608, 90, 20, 121, 126, - 147, 522, 121, 1037, 138, 142, 16, 138, 105, 82, - 144, 546, 128, 331, 111, 112, 334, 398, 336, 52, - 338, 147, 340, 142, 27, 55, 547, 213, 214, 147, - 142, 54, 129, 147, 147, 121, 122, 1045, 113, 289, - 121, 213, 214, 142, 90, 144, 142, 115, 210, 147, - 118, 119, 749, 147, 90, 458, 441, 442, 142, 105, - 144, 223, 224, 297, 761, 315, 214, 92, 138, 105, - 144, 305, 306, 223, 224, 142, 310, 90, 146, 28, - 148, 242, 590, 142, 142, 593, 119, 142, 544, 142, - 386, 275, 388, 313, 140, 279, 121, 269, 949, 271, - 510, 147, 90, 275, 140, 115, 295, 813, 118, 119, - 90, 147, 115, 275, 242, 118, 119, 279, 728, 729, - 51, 283, 284, 90, 55, 287, 555, 213, 214, 548, - 729, 103, 294, 295, 147, 275, 146, 121, 148, 279, - 302, 749, 18, 146, 20, 148, 966, 279, 252, 969, - 940, 313, 608, 761, 687, 92, 128, 869, 115, 147, - 963, 118, 119, 966, 294, 101, 969, 147, 971, 396, - 92, 401, 302, 92, 401, 58, 59, 318, 791, 323, - 147, 144, 509, 510, 121, 347, 348, 349, 350, 351, - 352, 353, 354, 297, 804, 131, 132, 133, 348, 349, - 350, 351, 121, 375, 60, 377, 55, 63, 279, 398, - 372, 441, 442, 125, 441, 442, 1019, 347, 347, 121, - 840, 399, 352, 142, 455, 1045, 61, 92, 369, 64, - 65, 393, 318, 25, 396, 553, 398, 399, 92, 401, - 313, 749, 1045, 90, 1047, 55, 1049, 431, 1051, 37, - 38, 107, 275, 761, 287, 863, 279, 767, 105, 431, - 115, 796, 295, 118, 119, 873, 92, 121, 1071, 431, - 92, 142, 456, 676, 795, 783, 797, 20, 605, 441, - 442, 116, 117, 369, 456, 62, 57, 64, 65, 473, - 718, 431, 464, 140, 456, 121, 458, 459, 482, 121, - 147, 473, 739, 58, 59, 433, 499, 469, 436, 142, - 482, 473, 722, 17, 18, 477, 456, 501, 940, 92, - 482, 505, 542, 138, 544, 487, 399, 92, 655, 457, - 92, 518, 942, 473, 92, 791, 433, 509, 510, 116, - 117, 101, 482, 942, 714, 145, 474, 519, 121, 533, - 661, 26, 536, 664, 518, 483, 121, 519, 966, 121, - 457, 869, 546, 121, 92, 398, 528, 121, 618, 501, - 798, 682, 215, 396, 546, 885, 886, 474, 401, 222, - 542, 784, 544, 92, 546, 141, 483, 714, 608, 519, - 518, 139, 554, 121, 522, 722, 1004, 92, 528, 9, - 10, 533, 881, 882, 508, 15, 546, 548, 811, 121, - 122, 55, 121, 142, 799, 90, 259, 90, 580, 547, - 805, 806, 101, 101, 121, 522, 121, 855, 121, 601, - 105, 92, 105, 142, 142, 576, 469, 599, 121, 849, - 580, 1049, 51, 636, 477, 62, 608, 64, 65, 51, - 547, 142, 593, 856, 487, 596, 142, 142, 966, 599, - 121, 969, 548, 138, 51, 140, 142, 140, 491, 542, - 142, 544, 147, 51, 147, 652, 772, 773, 774, 26, - 776, 142, 778, 655, 661, 16, 15, 664, 2, 661, - 4, 99, 664, 665, 666, 9, 10, 1032, 13, 116, - 117, 15, 16, 17, 347, 739, 20, 117, 1018, 121, - 682, 92, 1033, 675, 676, 687, 688, 121, 361, 922, - 692, 554, 849, 710, 685, 675, 911, 699, 16, 63, - 15, 92, 139, 15, 145, 608, 379, 1045, 52, 145, - 121, 142, 142, 90, 728, 729, 710, 709, 142, 15, - 722, 809, 66, 142, 44, 652, 926, 685, 105, 709, - 121, 142, 932, 793, 661, 121, 793, 664, 141, 799, - 141, 791, 799, 800, 15, 805, 806, 141, 805, 806, - 18, 142, 710, 680, 115, 682, 141, 118, 119, 90, - 139, 138, 15, 140, 583, 767, 728, 144, 587, 16, - 147, 139, 141, 117, 105, 119, 139, 142, 44, 57, + 10, 271, 82, 52, 28, 15, 488, 377, 4, 306, + 54, 55, 2, 310, 4, 56, 16, 17, 593, 7, + 20, 401, 54, 55, 16, 17, 14, 118, 20, 756, + 52, 501, 783, 590, 56, 505, 431, 58, 688, 544, + 28, 330, 74, 75, 66, 75, 505, 91, 429, 699, + 25, 15, 433, 25, 295, 436, 60, 61, 62, 63, + 82, 456, 54, 55, 21, 22, 318, 969, 105, 75, + 58, 944, 5, 6, 25, 57, 457, 536, 473, 111, + 13, 25, 269, 90, 271, 16, 17, 482, 26, 20, + 29, 472, 122, 474, 0, 117, 79, 119, 27, 665, + 666, 144, 483, 608, 138, 69, 90, 92, 218, 372, + 25, 90, 590, 26, 55, 593, 90, 369, 305, 229, + 90, 25, 590, 56, 25, 25, 105, 103, 74, 75, + 393, 105, 802, 16, 17, 121, 121, 20, 808, 121, + 147, 522, 90, 126, 1046, 18, 16, 20, 105, 82, + 28, 546, 128, 331, 111, 112, 334, 398, 336, 52, + 338, 140, 340, 147, 1037, 144, 547, 142, 147, 144, + 142, 54, 129, 147, 113, 121, 122, 147, 121, 289, + 92, 213, 214, 401, 214, 92, 115, 90, 210, 118, + 119, 142, 749, 144, 57, 458, 441, 442, 142, 147, + 138, 223, 224, 297, 761, 315, 144, 213, 214, 121, + 142, 305, 306, 223, 224, 966, 310, 146, 969, 148, + 144, 242, 949, 441, 442, 138, 119, 142, 544, 121, + 386, 275, 388, 313, 125, 279, 55, 269, 142, 271, + 510, 142, 142, 275, 147, 115, 295, 813, 118, 119, + 142, 90, 115, 275, 242, 118, 119, 279, 728, 729, + 123, 283, 284, 90, 90, 287, 555, 213, 214, 92, + 729, 749, 294, 295, 92, 275, 146, 92, 148, 279, + 302, 749, 92, 761, 121, 148, 791, 279, 252, 90, + 940, 313, 608, 761, 869, 1046, 548, 51, 121, 53, + 54, 55, 56, 121, 294, 783, 121, 687, 147, 396, + 92, 121, 302, 90, 401, 69, 58, 59, 92, 323, + 147, 147, 509, 510, 142, 347, 348, 349, 350, 351, + 352, 353, 354, 297, 804, 37, 38, 55, 348, 349, + 350, 351, 25, 375, 92, 377, 147, 121, 279, 398, + 372, 347, 142, 92, 441, 442, 51, 347, 399, 20, + 840, 92, 352, 51, 455, 53, 54, 55, 56, 92, + 147, 393, 318, 121, 396, 553, 398, 399, 90, 401, + 313, 69, 121, 58, 59, 51, 92, 431, 142, 55, + 121, 869, 275, 105, 287, 863, 279, 767, 121, 431, + 57, 796, 295, 142, 142, 873, 101, 102, 103, 431, + 92, 142, 456, 676, 795, 121, 797, 138, 605, 441, + 442, 101, 661, 369, 456, 664, 17, 18, 140, 473, + 718, 431, 464, 128, 456, 147, 458, 459, 482, 121, + 145, 473, 739, 682, 121, 433, 499, 469, 436, 101, + 482, 473, 722, 139, 142, 477, 456, 501, 940, 55, + 482, 505, 542, 141, 544, 487, 399, 101, 655, 457, + 142, 518, 942, 473, 92, 791, 433, 509, 510, 131, + 132, 133, 482, 942, 714, 101, 474, 519, 966, 533, + 121, 969, 536, 26, 518, 483, 60, 519, 966, 63, + 457, 121, 546, 121, 142, 398, 528, 51, 618, 501, + 798, 51, 215, 396, 546, 885, 886, 474, 401, 222, + 542, 784, 544, 92, 546, 142, 483, 714, 608, 519, + 518, 142, 554, 115, 522, 722, 118, 119, 528, 9, + 10, 533, 142, 107, 508, 15, 546, 90, 811, 881, + 882, 51, 121, 142, 799, 121, 259, 90, 580, 547, + 805, 806, 105, 92, 146, 522, 148, 855, 1046, 601, + 142, 1039, 105, 142, 51, 793, 469, 599, 16, 849, + 580, 799, 1050, 636, 477, 99, 608, 805, 806, 318, + 547, 15, 121, 856, 487, 121, 122, 140, 13, 599, + 121, 121, 548, 16, 147, 138, 63, 140, 491, 542, + 15, 544, 142, 142, 147, 652, 772, 773, 774, 26, + 776, 145, 778, 655, 661, 16, 145, 664, 2, 661, + 4, 139, 664, 665, 666, 9, 10, 1032, 142, 92, + 369, 15, 16, 17, 347, 739, 20, 117, 1018, 142, + 682, 15, 1033, 675, 676, 687, 688, 15, 361, 922, + 692, 554, 849, 710, 685, 675, 911, 699, 121, 44, + 115, 142, 121, 118, 119, 608, 379, 115, 52, 141, + 118, 119, 141, 90, 728, 729, 710, 709, 15, 142, + 722, 809, 66, 911, 18, 652, 926, 685, 105, 709, + 145, 146, 932, 148, 661, 141, 793, 664, 146, 141, + 148, 791, 799, 800, 63, 64, 65, 115, 805, 806, + 118, 119, 710, 680, 115, 682, 15, 118, 119, 90, + 139, 138, 142, 140, 44, 767, 728, 144, 115, 16, + 147, 118, 119, 117, 105, 119, 139, 141, 57, 139, 1038, 142, 796, 223, 224, 146, 142, 148, 142, 142, - 804, 142, 784, 44, 796, 15, 37, 38, 93, 791, - 792, 793, 90, 14, 796, 478, 479, 799, 800, 140, - 15, 813, 783, 805, 806, 15, 147, 105, 145, 811, - 812, 823, 15, 142, 826, 142, 796, 953, 954, 955, + 804, 583, 784, 142, 796, 587, 44, 116, 117, 791, + 792, 793, 90, 26, 796, 478, 479, 799, 800, 140, + 15, 813, 93, 805, 806, 14, 147, 105, 15, 811, + 812, 823, 15, 145, 826, 142, 796, 953, 954, 955, 956, 142, 792, 825, 687, 142, 828, 61, 142, 797, - 64, 65, 804, 283, 284, 837, 838, 849, 828, 141, - 15, 911, 140, 845, 911, 528, 299, 139, 15, 147, - 303, 15, 535, 15, 856, 857, 210, 90, 115, 139, - 797, 118, 119, 142, 115, 90, 126, 118, 119, 223, - 224, 142, 105, 885, 886, 583, 126, 55, 791, 860, - 105, 883, 116, 117, 139, 15, 888, 55, 869, 146, - 871, 148, 15, 90, 875, 146, 986, 148, 348, 349, - 350, 351, 142, 353, 354, 1041, 142, 140, 105, 911, - 142, 144, 519, 142, 147, 140, 57, 144, 942, 921, - 922, 275, 147, 925, 142, 279, 142, 929, 940, 283, - 284, 144, 141, 287, 441, 442, 142, 13, 6, 812, - 294, 295, 51, 140, 53, 54, 55, 56, 302, 1035, - 147, 783, 825, 1037, 783, 810, 1034, 63, 64, 65, - 69, 254, 26, 7, 837, 838, 999, 948, 475, 476, - 883, 583, 845, 966, 115, 888, -1, 118, 119, 26, - 963, -1, 123, -1, 857, -1, -1, 989, 969, 991, - 971, 674, 994, 347, 348, 349, 350, 351, 352, 353, - 354, -1, -1, -1, 90, -1, 1018, 148, 1032, 459, - 116, 117, 925, -1, -1, -1, 523, -1, 372, 105, - 1032, 90, 1034, 1035, -1, 1006, 90, -1, 1009, -1, - 1032, 714, -1, 142, 890, 891, 105, -1, -1, 393, - -1, 105, 396, 90, 398, -1, -1, 401, 921, -1, - -1, -1, 1032, 506, 140, -1, 929, -1, 105, 1040, - 513, 147, -1, -1, 1045, 1033, 1047, 26, -1, -1, - 1051, 140, 525, -1, 138, 783, 140, 431, 147, 90, - 144, -1, -1, 147, -1, -1, 769, 441, 442, -1, - 1071, 138, -1, 140, 105, -1, 1033, 144, 90, 90, - 147, -1, 456, -1, 458, 459, -1, -1, -1, -1, - 966, -1, -1, 105, 105, 469, 989, -1, 991, 473, - -1, 994, -1, 477, 577, 578, 90, -1, 482, 140, - -1, 90, 815, 487, 963, -1, 147, 966, -1, -1, - 969, 105, 971, -1, -1, -1, 105, -1, 140, 140, - 26, 63, 64, 65, 607, 147, 147, 840, -1, 51, - -1, 53, 54, 55, 56, 519, 1022, 1023, 1024, -1, - 1026, 1027, -1, -1, 528, -1, 140, 69, -1, 138, - -1, 140, -1, 147, -1, 144, -1, -1, 147, -1, - 1019, -1, 546, -1, 115, 9, 10, 118, 119, -1, - 554, 15, 16, 17, 116, 117, 20, -1, -1, 1065, - 1066, 1067, 1068, -1, 90, -1, 1045, -1, 1047, 1075, - 1049, -1, 1051, -1, -1, 675, 580, 148, -1, 105, - -1, 684, -1, 47, 48, 49, 50, 63, 64, 65, - 54, 55, 1071, 926, 101, 599, -1, -1, -1, 932, - 142, -1, 66, 67, -1, 963, -1, -1, 966, 709, - -1, 969, 138, 971, 140, 63, 64, 65, 144, -1, - -1, 147, 129, 130, 131, 132, 133, 51, -1, 53, - 54, 55, 56, -1, 115, 738, -1, 118, 119, -1, - 116, 117, 799, 800, -1, 69, -1, -1, 805, 806, - 63, 64, 65, 117, 757, 63, 64, 65, 63, 64, - 65, 1019, 63, 64, 65, 146, -1, 148, 116, 117, - 94, 675, 676, -1, 831, 832, 100, 834, 835, -1, - 51, -1, 53, 54, 55, 56, -1, 1045, -1, 1047, - -1, 1049, 51, 1051, 53, 54, 55, 56, 69, -1, - -1, -1, -1, 116, 117, 709, 88, 89, 116, 117, - 69, 116, 117, 1071, -1, 116, 117, -1, -1, 101, - -1, -1, 115, 94, 83, 118, 119, -1, 828, -1, - 101, 102, 103, -1, -1, 94, 40, 41, 42, 43, - 44, 100, 101, 102, 103, 848, 128, 129, 130, 131, - 132, 133, 145, 146, 911, 148, -1, 128, -1, 223, - 224, 864, 121, 2, -1, 4, 5, 6, -1, 128, - -1, -1, 131, -1, 13, -1, -1, 934, -1, 115, - 784, -1, 118, 119, -1, 144, -1, -1, 792, 793, - -1, -1, 796, -1, -1, 799, 800, 261, 262, 263, - 264, 805, 806, -1, -1, -1, 142, 811, 812, -1, - 146, 275, 148, 52, -1, 279, -1, 56, -1, 283, + 64, 65, 804, 283, 284, 837, 838, 849, 828, 548, + 142, 15, 140, 845, 911, 528, 299, 141, 15, 147, + 303, 139, 535, 15, 856, 857, 210, 90, 115, 15, + 797, 118, 119, 15, 139, 37, 38, 576, 142, 223, + 224, 126, 105, 885, 886, 583, 61, 126, 791, 64, + 65, 883, 116, 117, 593, 55, 888, 596, 139, 146, + 51, 148, 53, 54, 55, 56, 986, 15, 348, 349, + 350, 351, 55, 353, 354, 138, 1042, 140, 69, 911, + 142, 144, 142, 142, 147, 783, 142, 142, 942, 921, + 922, 275, 26, 925, 142, 279, 142, 929, 940, 283, + 284, 116, 117, 287, 441, 442, 15, 141, 144, 812, + 294, 295, 144, 115, 142, 519, 118, 119, 302, 26, + 26, 13, 825, 6, 1035, 783, 62, 115, 64, 65, + 118, 119, 1037, 810, 837, 838, 999, 90, 475, 476, + 883, 1034, 845, 254, 146, 888, 148, 7, 583, -1, + 963, 783, 105, -1, 857, 966, 90, 989, 90, 991, + 148, 674, 994, 347, 348, 349, 350, 351, 352, 353, + 354, 105, -1, 105, -1, -1, 1018, -1, 1032, 459, + 116, 117, 925, 90, 90, -1, 523, 140, 372, -1, + 1032, -1, 1034, 1035, 147, -1, -1, -1, 105, 105, + 1032, 714, -1, -1, 138, 90, 140, -1, 140, 393, + 144, -1, 396, 147, 398, 147, -1, 401, 921, -1, + 105, -1, 1032, 506, -1, 62, 929, 64, 65, -1, + 513, 138, 138, 140, 140, 1033, -1, 144, 144, -1, + 147, 147, 525, -1, 783, 783, -1, 431, -1, 51, + -1, 53, 54, 55, 56, 140, 769, 441, 442, -1, + -1, -1, 147, 90, -1, 963, 1033, 69, 966, -1, + -1, 969, 456, 971, 458, 459, -1, -1, 105, 116, + 117, -1, -1, -1, -1, 469, 989, -1, 991, 473, + 90, 994, 94, 477, 577, 578, -1, -1, 482, 101, + 102, 103, 815, 487, -1, 105, -1, 90, -1, -1, + 890, 891, -1, 140, -1, -1, -1, -1, 90, -1, + 147, 1019, 105, -1, 607, -1, 128, 840, 90, -1, + 869, 963, 871, 105, 966, 519, 875, 969, -1, 971, + 140, 90, -1, 105, 528, -1, -1, 147, 1046, -1, + 1048, -1, 1050, -1, 1052, -1, 105, 140, -1, -1, + -1, -1, 546, -1, 147, 9, 10, 90, 140, -1, + 554, 15, 16, 17, 1072, 147, 20, -1, 140, -1, + -1, -1, 105, -1, -1, 147, 966, 1019, -1, -1, + -1, 140, -1, -1, -1, 675, 580, -1, 147, -1, + -1, 684, -1, 47, 48, 49, 50, 101, 947, 948, + 54, 55, -1, 926, 1046, 599, 1048, 140, 1050, 932, + 1052, -1, 66, 67, 147, 963, -1, -1, 966, 709, + 969, 969, 971, 971, -1, 129, 130, 131, 132, 133, + 1072, -1, 1022, 1023, 1024, -1, 1026, 1027, -1, -1, + 63, 64, 65, -1, -1, 738, 40, 41, 42, 43, + 44, -1, 799, 800, -1, -1, -1, 1006, 805, 806, + 1009, -1, -1, 117, 757, 63, 64, 65, 63, 64, + 65, 1019, -1, -1, -1, -1, 1066, 1067, 1068, 1069, + -1, 675, 676, -1, 831, 832, 1076, 834, 835, 63, + 64, 65, 1041, 116, 117, -1, -1, 1046, 1046, 1048, + 1048, -1, 1050, 1052, 1052, -1, -1, -1, 51, -1, + 53, 54, 55, 56, -1, 709, -1, -1, 116, 117, + -1, 116, 117, 1072, 1072, -1, 69, 63, 64, 65, + -1, 51, -1, 53, 54, 55, 56, -1, 828, -1, + 83, -1, 116, 117, -1, -1, -1, -1, -1, 69, + -1, 94, -1, -1, -1, 848, -1, 100, 101, 102, + 103, 63, 64, 65, 911, -1, 63, 64, 65, 223, + 224, 864, -1, 2, 94, 4, 5, 6, 121, -1, + 116, 117, -1, -1, 13, 128, -1, 934, 131, -1, + 784, 115, -1, -1, 118, 119, -1, -1, 792, 793, + -1, 144, 796, -1, -1, 799, 800, 261, 262, 263, + 264, 805, 806, -1, 116, 117, -1, 811, 812, 116, + 117, 275, 146, 52, 148, 279, -1, 56, -1, 283, 284, 825, -1, -1, 828, -1, 51, -1, 53, 54, - 55, 56, -1, 837, 838, 115, -1, -1, 118, 119, + 55, 56, -1, 837, 838, -1, -1, -1, -1, -1, -1, 845, -1, 82, 69, 51, -1, 53, 54, 55, - 56, -1, 856, 857, 88, 89, -1, -1, 83, -1, - -1, -1, -1, 69, -1, -1, 146, 101, 148, 94, - -1, -1, -1, -1, -1, 100, 101, 102, 103, -1, - 119, -1, -1, -1, 348, 349, 350, 351, 94, 353, - 354, -1, -1, -1, 100, 129, 130, 131, 132, 133, - -1, -1, -1, 128, -1, -1, 131, 911, 51, 373, - 53, 54, 55, 56, -1, -1, -1, 921, 922, 144, - 384, -1, -1, -1, -1, 929, 69, -1, -1, -1, + 56, -1, 856, 857, -1, 88, 89, -1, 83, -1, + -1, -1, -1, 69, -1, -1, -1, -1, 101, 94, + 88, 89, -1, -1, -1, 100, 101, 102, 103, -1, + 119, -1, -1, 101, 348, 349, 350, 351, 94, 353, + 354, -1, -1, -1, 100, 128, 129, 130, 131, 132, + 133, -1, -1, 128, -1, -1, 131, 911, -1, 373, + -1, 129, 130, 131, 132, 133, -1, 921, 922, 144, + 384, -1, -1, -1, -1, 929, -1, -1, -1, -1, -1, -1, 396, -1, -1, -1, -1, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, -1, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, -1, -1, 431, -1, -1, - 51, 210, 53, 54, 55, 56, -1, 441, 442, -1, - -1, -1, -1, -1, -1, 989, -1, 991, 69, -1, - 994, -1, 456, -1, -1, 459, -1, -1, -1, -1, + 424, 425, 426, 427, 428, -1, 115, 431, -1, 118, + 119, 210, -1, -1, -1, -1, -1, 441, 442, -1, + -1, -1, -1, -1, -1, 989, -1, 991, -1, -1, + 994, -1, 456, 142, -1, 459, -1, 146, -1, 148, -1, 51, -1, 53, 54, 55, 56, 471, -1, 473, - -1, 475, 476, 94, -1, -1, -1, -1, 482, 69, + -1, 475, 476, -1, -1, -1, -1, -1, 482, 69, -1, -1, -1, -1, -1, -1, -1, 491, 1032, -1, 494, -1, -1, -1, 498, -1, -1, 501, -1, 503, -1, 505, 506, -1, 94, 88, 89, -1, 287, -1, 100, 101, 102, 103, -1, 294, 295, -1, 101, 523, - -1, -1, -1, 302, -1, -1, -1, -1, -1, 533, + -1, -1, 51, 302, 53, 54, 55, 56, -1, 533, -1, -1, 536, -1, 313, -1, -1, -1, 128, -1, - -1, 131, 546, 126, 127, 128, 129, 130, 131, 132, + 69, 131, 546, 126, 127, 128, 129, 130, 131, 132, 133, -1, -1, -1, 144, -1, -1, -1, -1, 563, - 564, -1, -1, -1, -1, -1, -1, -1, 347, -1, - -1, -1, -1, 352, -1, -1, 580, -1, -1, -1, + 564, -1, -1, -1, -1, 94, -1, -1, 347, -1, + -1, 100, -1, 352, -1, -1, 580, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 372, -1, 599, -1, 51, 602, 53, 54, 55, 56, -1, 13, 14, 15, 16, 17, 18, @@ -5206,11 +5206,11 @@ static const yytype_int16 yystos[] = 85, 91, 94, 95, 97, 98, 100, 104, 106, 107, 108, 110, 111, 112, 114, 134, 135, 136, 152, 153, 154, 159, 161, 163, 164, 165, 168, 169, 172, 173, - 175, 176, 177, 179, 180, 189, 203, 220, 240, 241, - 251, 252, 253, 257, 258, 259, 265, 266, 267, 269, - 270, 271, 272, 273, 274, 310, 323, 154, 21, 22, + 175, 176, 177, 179, 180, 189, 203, 220, 241, 242, + 252, 253, 254, 258, 259, 260, 266, 267, 268, 270, + 271, 272, 273, 274, 275, 311, 324, 154, 21, 22, 30, 31, 32, 39, 51, 55, 69, 88, 91, 94, - 134, 164, 165, 181, 182, 203, 220, 271, 274, 310, + 134, 164, 165, 181, 182, 203, 220, 272, 275, 311, 182, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 30, 31, 32, 33, 34, @@ -5218,94 +5218,94 @@ static const yytype_int16 yystos[] = 50, 51, 52, 55, 70, 71, 72, 73, 74, 75, 76, 77, 80, 81, 86, 87, 88, 89, 100, 101, 102, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 135, 136, 143, 144, 183, 187, 188, 273, 305, - 204, 91, 163, 164, 165, 167, 180, 189, 220, 271, - 272, 274, 167, 210, 212, 69, 91, 173, 180, 220, - 225, 271, 274, 33, 34, 35, 36, 48, 49, 50, - 51, 55, 106, 183, 184, 185, 267, 115, 118, 119, - 146, 148, 167, 261, 262, 263, 316, 320, 321, 322, + 133, 135, 136, 143, 144, 183, 187, 188, 274, 306, + 204, 91, 163, 164, 165, 167, 180, 189, 220, 272, + 273, 275, 167, 210, 212, 69, 91, 173, 180, 220, + 225, 272, 275, 33, 34, 35, 36, 48, 49, 50, + 51, 55, 106, 183, 184, 185, 268, 115, 118, 119, + 146, 148, 167, 262, 263, 264, 317, 321, 322, 323, 51, 100, 102, 103, 135, 172, 189, 195, 198, 201, - 253, 308, 309, 195, 195, 144, 192, 193, 196, 197, - 323, 192, 196, 144, 317, 184, 155, 138, 189, 220, + 254, 309, 310, 195, 195, 144, 192, 193, 196, 197, + 324, 192, 196, 144, 318, 184, 155, 138, 189, 220, 189, 189, 189, 55, 1, 94, 157, 158, 159, 174, - 175, 323, 205, 207, 190, 201, 308, 323, 189, 307, - 308, 323, 91, 142, 179, 220, 271, 274, 208, 53, - 54, 56, 63, 107, 183, 268, 63, 64, 65, 116, - 117, 254, 255, 61, 254, 62, 254, 63, 254, 63, - 254, 58, 59, 168, 189, 189, 316, 322, 40, 41, + 175, 324, 205, 207, 190, 201, 309, 324, 189, 308, + 309, 324, 91, 142, 179, 220, 272, 275, 208, 53, + 54, 56, 63, 107, 183, 269, 63, 64, 65, 116, + 117, 255, 256, 61, 255, 62, 255, 63, 255, 63, + 255, 58, 59, 168, 189, 189, 317, 323, 40, 41, 42, 43, 44, 37, 38, 51, 53, 54, 55, 56, 69, 83, 94, 100, 101, 102, 103, 128, 131, 144, - 277, 278, 279, 280, 281, 284, 285, 286, 287, 289, - 290, 291, 292, 294, 295, 296, 299, 300, 301, 302, - 303, 323, 277, 279, 28, 238, 121, 142, 94, 100, + 278, 279, 280, 281, 282, 285, 286, 287, 288, 290, + 291, 292, 293, 295, 296, 297, 300, 301, 302, 303, + 304, 324, 278, 280, 28, 239, 121, 142, 94, 100, 176, 121, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 88, 89, 93, 101, 122, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 90, - 105, 140, 147, 314, 90, 314, 315, 26, 138, 242, - 253, 92, 92, 192, 196, 242, 163, 51, 55, 181, - 58, 59, 278, 125, 275, 90, 140, 314, 219, 306, - 90, 147, 313, 156, 157, 55, 277, 277, 16, 221, - 320, 121, 90, 140, 314, 92, 92, 221, 167, 167, - 55, 90, 140, 314, 25, 107, 142, 264, 316, 115, - 263, 20, 245, 320, 57, 189, 189, 189, 93, 142, - 199, 200, 323, 57, 199, 200, 85, 194, 195, 201, - 308, 323, 195, 163, 316, 318, 163, 321, 160, 138, - 157, 90, 314, 92, 159, 174, 145, 316, 322, 318, - 159, 318, 141, 200, 319, 322, 200, 319, 139, 319, - 55, 176, 177, 178, 142, 90, 140, 314, 144, 236, - 289, 294, 63, 254, 256, 260, 261, 63, 255, 61, + 105, 140, 147, 315, 90, 315, 316, 26, 138, 243, + 254, 92, 92, 192, 196, 243, 163, 51, 55, 181, + 58, 59, 279, 125, 276, 90, 140, 315, 219, 307, + 90, 147, 314, 156, 157, 55, 278, 278, 16, 221, + 321, 121, 90, 140, 315, 92, 92, 221, 167, 167, + 55, 90, 140, 315, 25, 107, 142, 265, 317, 115, + 264, 20, 246, 321, 57, 189, 189, 189, 93, 142, + 199, 200, 324, 57, 199, 200, 85, 194, 195, 201, + 309, 324, 195, 163, 317, 319, 163, 322, 160, 138, + 157, 90, 315, 92, 159, 174, 145, 317, 323, 319, + 159, 319, 141, 200, 320, 323, 200, 320, 139, 320, + 55, 176, 177, 178, 142, 90, 140, 315, 144, 237, + 290, 295, 63, 255, 257, 261, 262, 63, 256, 61, 62, 63, 63, 101, 101, 154, 167, 167, 167, 167, - 159, 163, 163, 57, 121, 320, 293, 85, 289, 294, - 121, 156, 189, 142, 304, 323, 51, 142, 304, 320, - 142, 288, 189, 142, 288, 51, 142, 288, 51, 121, - 156, 239, 100, 168, 189, 201, 202, 174, 142, 179, - 142, 161, 162, 168, 180, 189, 191, 202, 220, 274, + 159, 163, 163, 57, 121, 321, 294, 85, 290, 295, + 121, 156, 189, 142, 305, 324, 51, 142, 305, 321, + 142, 289, 189, 142, 289, 51, 142, 289, 51, 121, + 156, 240, 100, 168, 189, 201, 202, 174, 142, 179, + 142, 161, 162, 168, 180, 189, 191, 202, 220, 275, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 51, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 51, 52, 55, - 187, 192, 311, 312, 194, 201, 51, 52, 55, 187, - 192, 311, 51, 55, 311, 244, 243, 162, 189, 191, - 162, 191, 99, 170, 217, 276, 216, 51, 55, 181, - 311, 194, 311, 156, 163, 166, 15, 13, 247, 323, + 187, 192, 312, 313, 194, 201, 51, 52, 55, 187, + 192, 312, 51, 55, 312, 245, 244, 162, 189, 191, + 162, 191, 99, 170, 217, 277, 216, 51, 55, 181, + 312, 194, 312, 156, 163, 166, 15, 13, 248, 324, 121, 121, 157, 16, 51, 55, 194, 51, 55, 157, - 27, 222, 320, 222, 51, 55, 194, 51, 55, 214, - 186, 157, 245, 189, 201, 15, 189, 189, 317, 100, - 189, 198, 308, 189, 309, 318, 145, 316, 200, 200, - 318, 145, 184, 152, 139, 191, 318, 159, 206, 308, - 176, 178, 51, 55, 194, 51, 55, 289, 209, 142, - 63, 157, 261, 189, 189, 51, 100, 226, 294, 318, - 318, 142, 172, 189, 15, 51, 281, 286, 303, 85, - 287, 292, 299, 301, 294, 296, 301, 51, 294, 172, - 189, 15, 79, 126, 230, 231, 323, 189, 200, 318, - 178, 142, 44, 121, 44, 90, 140, 314, 317, 92, + 27, 222, 321, 222, 51, 55, 194, 51, 55, 214, + 186, 157, 246, 189, 201, 15, 189, 189, 318, 100, + 189, 198, 309, 189, 310, 319, 145, 317, 200, 200, + 319, 145, 184, 152, 139, 191, 319, 159, 206, 309, + 176, 178, 51, 55, 194, 51, 55, 290, 209, 142, + 63, 157, 262, 189, 189, 51, 100, 226, 295, 319, + 319, 142, 172, 189, 15, 51, 282, 287, 304, 85, + 288, 293, 300, 302, 295, 297, 302, 51, 295, 172, + 189, 15, 79, 126, 231, 232, 324, 189, 200, 319, + 178, 142, 44, 121, 44, 90, 140, 315, 318, 92, 92, 192, 196, 141, 200, 92, 92, 193, 196, 193, - 196, 230, 230, 171, 320, 167, 156, 141, 15, 318, - 183, 189, 202, 248, 323, 18, 224, 323, 17, 223, + 196, 231, 231, 171, 321, 167, 156, 141, 15, 319, + 183, 189, 202, 249, 324, 18, 224, 324, 17, 223, 224, 92, 92, 141, 92, 92, 224, 211, 213, 141, - 167, 184, 139, 15, 200, 221, 189, 199, 85, 308, - 139, 318, 319, 141, 233, 317, 29, 113, 237, 139, - 142, 291, 318, 142, 85, 44, 44, 304, 320, 142, - 288, 142, 288, 142, 288, 142, 288, 288, 44, 44, - 227, 229, 232, 280, 282, 283, 286, 294, 295, 297, - 298, 301, 303, 156, 100, 189, 178, 159, 189, 51, + 167, 184, 139, 15, 200, 221, 189, 199, 85, 309, + 139, 319, 320, 141, 234, 318, 29, 113, 238, 139, + 142, 292, 319, 142, 85, 44, 44, 305, 321, 142, + 289, 142, 289, 142, 289, 142, 289, 289, 44, 44, + 228, 230, 233, 281, 283, 284, 287, 295, 296, 298, + 299, 302, 304, 156, 100, 189, 178, 159, 189, 51, 55, 194, 51, 55, 57, 123, 162, 191, 168, 191, - 170, 92, 162, 191, 162, 191, 170, 242, 238, 156, - 157, 230, 218, 320, 15, 93, 249, 323, 157, 14, - 250, 323, 167, 15, 92, 15, 157, 157, 222, 189, - 157, 318, 200, 145, 146, 156, 157, 294, 142, 100, - 318, 189, 189, 294, 301, 294, 294, 189, 189, 233, - 233, 91, 220, 142, 304, 304, 142, 228, 220, 142, - 228, 142, 228, 15, 189, 141, 189, 189, 162, 191, - 15, 139, 157, 156, 91, 180, 220, 271, 274, 221, - 157, 221, 15, 15, 215, 224, 245, 246, 51, 234, - 235, 290, 15, 139, 142, 294, 142, 291, 288, 142, - 288, 288, 288, 126, 126, 55, 90, 282, 286, 142, - 227, 228, 298, 301, 294, 297, 301, 294, 139, 15, - 55, 90, 140, 314, 157, 157, 157, 142, 317, 294, - 142, 294, 51, 55, 304, 142, 228, 142, 228, 142, - 228, 142, 228, 228, 51, 55, 194, 51, 55, 247, - 223, 15, 235, 294, 288, 294, 301, 294, 294, 141, - 228, 142, 228, 228, 228, 294, 228 + 170, 92, 162, 191, 162, 191, 170, 243, 239, 156, + 157, 231, 218, 321, 15, 93, 250, 324, 157, 14, + 251, 324, 167, 15, 92, 15, 157, 157, 222, 189, + 157, 319, 200, 145, 146, 156, 157, 227, 142, 100, + 319, 189, 189, 295, 302, 295, 295, 189, 189, 234, + 234, 91, 220, 142, 305, 305, 142, 229, 220, 142, + 229, 142, 229, 15, 189, 141, 189, 189, 162, 191, + 15, 139, 157, 156, 91, 180, 220, 272, 275, 221, + 157, 221, 15, 15, 215, 224, 246, 247, 51, 235, + 236, 291, 15, 139, 295, 295, 142, 292, 289, 142, + 289, 289, 289, 126, 126, 55, 90, 283, 287, 142, + 228, 229, 299, 302, 295, 298, 302, 295, 139, 15, + 55, 90, 140, 315, 157, 157, 157, 142, 318, 142, + 295, 142, 295, 51, 55, 305, 142, 229, 142, 229, + 142, 229, 142, 229, 229, 51, 55, 194, 51, 55, + 248, 223, 15, 236, 295, 289, 295, 302, 295, 295, + 141, 229, 142, 229, 229, 229, 295, 229 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ @@ -5347,32 +5347,32 @@ static const yytype_int16 yyr1[] = 217, 218, 203, 219, 203, 203, 203, 203, 203, 203, 203, 220, 221, 221, 221, 222, 222, 223, 223, 224, 224, 225, 225, 226, 226, 226, 226, 226, 226, 226, - 226, 226, 227, 227, 227, 227, 228, 228, 229, 229, - 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, - 229, 229, 229, 230, 230, 232, 231, 231, 231, 233, - 233, 234, 234, 235, 235, 236, 236, 237, 237, 239, - 238, 240, 240, 240, 240, 241, 241, 241, 241, 241, - 241, 241, 241, 241, 243, 242, 244, 242, 245, 246, - 246, 247, 247, 248, 248, 248, 249, 249, 250, 250, - 251, 251, 251, 251, 252, 252, 253, 253, 253, 253, - 254, 254, 255, 256, 255, 255, 255, 257, 257, 258, - 258, 259, 260, 260, 261, 261, 262, 262, 263, 264, - 263, 265, 265, 266, 266, 267, 268, 268, 268, 268, - 268, 268, 269, 269, 270, 270, 270, 270, 271, 271, - 271, 271, 271, 272, 272, 273, 273, 273, 273, 273, - 273, 273, 273, 274, 274, 275, 276, 275, 277, 277, - 278, 278, 278, 279, 279, 279, 279, 280, 281, 281, - 282, 282, 283, 283, 284, 284, 285, 285, 286, 286, - 287, 287, 287, 287, 288, 288, 289, 289, 289, 289, - 289, 289, 289, 289, 289, 289, 289, 289, 289, 289, - 289, 290, 290, 290, 290, 290, 291, 291, 292, 293, - 292, 294, 294, 295, 296, 297, 298, 298, 299, 299, - 300, 300, 301, 301, 302, 302, 303, 303, 304, 304, - 305, 306, 305, 307, 307, 308, 308, 309, 309, 309, - 309, 309, 310, 310, 310, 311, 311, 311, 311, 312, - 312, 312, 313, 313, 314, 314, 315, 315, 316, 316, - 317, 317, 318, 319, 319, 319, 320, 320, 321, 321, - 322, 322, 323 + 226, 227, 226, 228, 228, 228, 228, 229, 229, 230, + 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 231, 231, 233, 232, 232, 232, + 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, + 240, 239, 241, 241, 241, 241, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 244, 243, 245, 243, 246, + 247, 247, 248, 248, 249, 249, 249, 250, 250, 251, + 251, 252, 252, 252, 252, 253, 253, 254, 254, 254, + 254, 255, 255, 256, 257, 256, 256, 256, 258, 258, + 259, 259, 260, 261, 261, 262, 262, 263, 263, 264, + 265, 264, 266, 266, 267, 267, 268, 269, 269, 269, + 269, 269, 269, 270, 270, 271, 271, 271, 271, 272, + 272, 272, 272, 272, 273, 273, 274, 274, 274, 274, + 274, 274, 274, 274, 275, 275, 276, 277, 276, 278, + 278, 279, 279, 279, 280, 280, 280, 280, 281, 282, + 282, 283, 283, 284, 284, 285, 285, 286, 286, 287, + 287, 288, 288, 288, 288, 289, 289, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 291, 291, 291, 291, 291, 292, 292, 293, + 294, 293, 295, 295, 296, 297, 298, 299, 299, 300, + 300, 301, 301, 302, 302, 303, 303, 304, 304, 305, + 305, 306, 307, 306, 308, 308, 309, 309, 310, 310, + 310, 310, 310, 311, 311, 311, 312, 312, 312, 312, + 313, 313, 313, 314, 314, 315, 315, 316, 316, 317, + 317, 318, 318, 319, 320, 320, 320, 321, 321, 322, + 322, 323, 323, 324 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ @@ -5414,32 +5414,32 @@ static const yytype_int8 yyr2[] = 0, 0, 8, 0, 5, 4, 4, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 5, 1, 2, 1, 1, 1, 4, 6, 3, 5, 2, 4, - 1, 3, 4, 2, 2, 1, 2, 0, 6, 8, - 4, 6, 4, 3, 6, 2, 4, 6, 2, 4, - 2, 4, 1, 1, 1, 0, 4, 1, 4, 1, - 4, 1, 3, 1, 1, 4, 1, 3, 3, 0, - 5, 2, 4, 5, 5, 2, 4, 4, 3, 3, - 3, 2, 1, 4, 0, 5, 0, 5, 5, 1, - 1, 6, 1, 1, 1, 1, 2, 1, 2, 1, - 1, 1, 1, 1, 1, 2, 1, 1, 2, 3, - 1, 2, 1, 0, 4, 1, 2, 2, 3, 2, - 3, 1, 1, 2, 1, 2, 1, 2, 1, 0, - 4, 2, 3, 1, 4, 2, 1, 1, 1, 1, - 1, 2, 2, 3, 1, 1, 2, 2, 1, 1, + 1, 0, 4, 4, 2, 2, 1, 2, 0, 6, + 8, 4, 6, 4, 3, 6, 2, 4, 6, 2, + 4, 2, 4, 1, 1, 1, 0, 4, 1, 4, + 1, 4, 1, 3, 1, 1, 4, 1, 3, 3, + 0, 5, 2, 4, 5, 5, 2, 4, 4, 3, + 3, 3, 2, 1, 4, 0, 5, 0, 5, 5, + 1, 1, 6, 1, 1, 1, 1, 2, 1, 2, + 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, + 3, 1, 2, 1, 0, 4, 1, 2, 2, 3, + 2, 3, 1, 1, 2, 1, 2, 1, 2, 1, + 0, 4, 2, 3, 1, 4, 2, 1, 1, 1, + 1, 1, 2, 2, 3, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 0, 0, 4, 1, 1, - 3, 5, 3, 1, 2, 4, 2, 2, 2, 1, - 2, 1, 1, 3, 1, 3, 1, 1, 2, 1, - 4, 2, 2, 1, 2, 0, 6, 8, 4, 6, - 4, 6, 2, 4, 6, 2, 4, 2, 4, 1, - 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, - 4, 1, 3, 2, 2, 2, 1, 3, 1, 3, - 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, - 1, 0, 4, 1, 2, 1, 3, 3, 3, 2, - 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, - 0, 2, 2, 0, 1, 1, 1, 1, 1, 1, - 1, 2, 0 + 1, 1, 1, 1, 1, 1, 0, 0, 4, 1, + 1, 3, 5, 3, 1, 2, 4, 2, 2, 2, + 1, 2, 1, 1, 3, 1, 3, 1, 1, 2, + 1, 4, 2, 2, 1, 2, 0, 6, 8, 4, + 6, 4, 6, 2, 4, 6, 2, 4, 2, 4, + 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 4, 1, 3, 2, 2, 2, 1, 3, 1, + 3, 1, 1, 2, 1, 1, 1, 2, 1, 2, + 1, 1, 0, 4, 1, 2, 1, 3, 3, 3, + 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 0, 2, 2, 0, 1, 1, 1, 1, 1, + 1, 1, 2, 0 }; @@ -8443,346 +8443,356 @@ yyreduce: case 356: #line 2964 "mrbgems/mruby-compiler/core/parse.y" { + local_add_f(p, intern_op(mul)); (yyval.nd) = list3((yyvsp[-2].nd), nint(-1), 0); } -#line 8449 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8450 "mrbgems/mruby-compiler/core/y.tab.c" break; case 357: -#line 2968 "mrbgems/mruby-compiler/core/parse.y" +#line 2969 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-4].nd), nint(-1), (yyvsp[0].nd)); } -#line 8457 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8458 "mrbgems/mruby-compiler/core/y.tab.c" break; case 358: -#line 2972 "mrbgems/mruby-compiler/core/parse.y" +#line 2973 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, new_arg(p, (yyvsp[0].id)), 0); } -#line 8465 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8466 "mrbgems/mruby-compiler/core/y.tab.c" break; case 359: -#line 2976 "mrbgems/mruby-compiler/core/parse.y" +#line 2977 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd)); } -#line 8473 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8474 "mrbgems/mruby-compiler/core/y.tab.c" break; case 360: -#line 2980 "mrbgems/mruby-compiler/core/parse.y" +#line 2981 "mrbgems/mruby-compiler/core/parse.y" { + local_add_f(p, intern_op(mul)); (yyval.nd) = list3(0, nint(-1), 0); } -#line 8481 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8483 "mrbgems/mruby-compiler/core/y.tab.c" break; case 361: -#line 2984 "mrbgems/mruby-compiler/core/parse.y" +#line 2986 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = list3(0, nint(-1), (yyvsp[0].nd)); + local_add_f(p, intern_op(mul)); } -#line 8489 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8491 "mrbgems/mruby-compiler/core/y.tab.c" break; case 362: #line 2990 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id)); + (yyval.nd) = list3(0, nint(-1), (yyvsp[0].nd)); } -#line 8497 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8499 "mrbgems/mruby-compiler/core/y.tab.c" break; case 363: -#line 2994 "mrbgems/mruby-compiler/core/parse.y" +#line 2996 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id)); + (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 8505 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8507 "mrbgems/mruby-compiler/core/y.tab.c" break; case 364: -#line 2998 "mrbgems/mruby-compiler/core/parse.y" +#line 3000 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id)); + (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id)); } -#line 8513 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8515 "mrbgems/mruby-compiler/core/y.tab.c" break; case 365: -#line 3002 "mrbgems/mruby-compiler/core/parse.y" +#line 3004 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id)); + (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 8521 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8523 "mrbgems/mruby-compiler/core/y.tab.c" break; case 366: #line 3008 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = (yyvsp[0].nd); + (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id)); } -#line 8529 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8531 "mrbgems/mruby-compiler/core/y.tab.c" break; case 367: -#line 3012 "mrbgems/mruby-compiler/core/parse.y" +#line 3014 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, 0, 0, 0); + (yyval.nd) = (yyvsp[0].nd); } -#line 8537 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8539 "mrbgems/mruby-compiler/core/y.tab.c" break; case 368: #line 3018 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); + (yyval.nd) = new_args_tail(p, 0, 0, 0); } -#line 8545 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8547 "mrbgems/mruby-compiler/core/y.tab.c" break; case 369: -#line 3022 "mrbgems/mruby-compiler/core/parse.y" +#line 3024 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8553 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8555 "mrbgems/mruby-compiler/core/y.tab.c" break; case 370: -#line 3026 "mrbgems/mruby-compiler/core/parse.y" +#line 3028 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8561 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8563 "mrbgems/mruby-compiler/core/y.tab.c" break; case 371: -#line 3030 "mrbgems/mruby-compiler/core/parse.y" +#line 3032 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 8569 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8571 "mrbgems/mruby-compiler/core/y.tab.c" break; case 372: -#line 3034 "mrbgems/mruby-compiler/core/parse.y" +#line 3036 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8577 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8579 "mrbgems/mruby-compiler/core/y.tab.c" break; case 373: -#line 3038 "mrbgems/mruby-compiler/core/parse.y" +#line 3040 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8585 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8587 "mrbgems/mruby-compiler/core/y.tab.c" break; case 374: -#line 3042 "mrbgems/mruby-compiler/core/parse.y" +#line 3044 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 8593 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8595 "mrbgems/mruby-compiler/core/y.tab.c" break; case 375: -#line 3046 "mrbgems/mruby-compiler/core/parse.y" +#line 3048 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8601 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8603 "mrbgems/mruby-compiler/core/y.tab.c" break; case 376: -#line 3050 "mrbgems/mruby-compiler/core/parse.y" +#line 3052 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 8609 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8611 "mrbgems/mruby-compiler/core/y.tab.c" break; case 377: -#line 3054 "mrbgems/mruby-compiler/core/parse.y" +#line 3056 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8617 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8619 "mrbgems/mruby-compiler/core/y.tab.c" break; case 378: -#line 3058 "mrbgems/mruby-compiler/core/parse.y" +#line 3060 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8625 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8627 "mrbgems/mruby-compiler/core/y.tab.c" break; case 379: -#line 3062 "mrbgems/mruby-compiler/core/parse.y" +#line 3064 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 8633 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8635 "mrbgems/mruby-compiler/core/y.tab.c" break; case 380: -#line 3066 "mrbgems/mruby-compiler/core/parse.y" +#line 3068 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8641 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8643 "mrbgems/mruby-compiler/core/y.tab.c" break; case 381: -#line 3070 "mrbgems/mruby-compiler/core/parse.y" +#line 3072 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8649 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8651 "mrbgems/mruby-compiler/core/y.tab.c" break; case 382: -#line 3074 "mrbgems/mruby-compiler/core/parse.y" +#line 3076 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8657 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8659 "mrbgems/mruby-compiler/core/y.tab.c" break; case 383: #line 3080 "mrbgems/mruby-compiler/core/parse.y" { - local_add_blk(p, 0); - (yyval.nd) = 0; + (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd)); } -#line 8666 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8667 "mrbgems/mruby-compiler/core/y.tab.c" break; case 384: -#line 3085 "mrbgems/mruby-compiler/core/parse.y" - { - p->cmd_start = TRUE; - (yyval.nd) = (yyvsp[0].nd); +#line 3086 "mrbgems/mruby-compiler/core/parse.y" + { + local_add_blk(p, 0); + (yyval.nd) = 0; } -#line 8675 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8676 "mrbgems/mruby-compiler/core/y.tab.c" break; case 385: #line 3091 "mrbgems/mruby-compiler/core/parse.y" - {local_add_blk(p, 0);} -#line 8681 "mrbgems/mruby-compiler/core/y.tab.c" + { + p->cmd_start = TRUE; + (yyval.nd) = (yyvsp[0].nd); + } +#line 8685 "mrbgems/mruby-compiler/core/y.tab.c" break; case 386: -#line 3092 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = 0; - } -#line 8689 "mrbgems/mruby-compiler/core/y.tab.c" +#line 3097 "mrbgems/mruby-compiler/core/parse.y" + {local_add_blk(p, 0);} +#line 8691 "mrbgems/mruby-compiler/core/y.tab.c" break; case 387: -#line 3096 "mrbgems/mruby-compiler/core/parse.y" +#line 3098 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = 0; + } +#line 8699 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 388: +#line 3102 "mrbgems/mruby-compiler/core/parse.y" { local_add_blk(p, 0); (yyval.nd) = 0; } -#line 8698 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 388: -#line 3101 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = (yyvsp[-2].nd); - } -#line 8706 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8708 "mrbgems/mruby-compiler/core/y.tab.c" break; case 389: -#line 3108 "mrbgems/mruby-compiler/core/parse.y" +#line 3107 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = 0; + (yyval.nd) = (yyvsp[-2].nd); } -#line 8714 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8716 "mrbgems/mruby-compiler/core/y.tab.c" break; case 390: -#line 3112 "mrbgems/mruby-compiler/core/parse.y" +#line 3114 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 8722 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8724 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 393: -#line 3122 "mrbgems/mruby-compiler/core/parse.y" + case 391: +#line 3118 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = 0; + } +#line 8732 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 394: +#line 3128 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); new_bv(p, (yyvsp[0].id)); } -#line 8731 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 395: -#line 3130 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = (yyvsp[-2].nd); - } -#line 8739 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8741 "mrbgems/mruby-compiler/core/y.tab.c" break; case 396: -#line 3134 "mrbgems/mruby-compiler/core/parse.y" +#line 3136 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = (yyvsp[0].nd); + (yyval.nd) = (yyvsp[-2].nd); } -#line 8747 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8749 "mrbgems/mruby-compiler/core/y.tab.c" break; case 397: #line 3140 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = (yyvsp[-1].nd); + (yyval.nd) = (yyvsp[0].nd); } -#line 8755 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8757 "mrbgems/mruby-compiler/core/y.tab.c" break; case 398: -#line 3144 "mrbgems/mruby-compiler/core/parse.y" +#line 3146 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 8763 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8765 "mrbgems/mruby-compiler/core/y.tab.c" break; case 399: #line 3150 "mrbgems/mruby-compiler/core/parse.y" { - local_nest(p); - nvars_nest(p); + (yyval.nd) = (yyvsp[-1].nd); } -#line 8772 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8773 "mrbgems/mruby-compiler/core/y.tab.c" break; case 400: -#line 3157 "mrbgems/mruby-compiler/core/parse.y" +#line 3156 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); - local_unnest(p); - nvars_unnest(p); + local_nest(p); + nvars_nest(p); } #line 8782 "mrbgems/mruby-compiler/core/y.tab.c" break; case 401: -#line 3165 "mrbgems/mruby-compiler/core/parse.y" +#line 3163 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); + local_unnest(p); + nvars_unnest(p); + } +#line 8792 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 402: +#line 3171 "mrbgems/mruby-compiler/core/parse.y" { if (typen((yyvsp[-1].nd)->car) == NODE_YIELD) { yyerror(p, "block given to yield"); @@ -8792,159 +8802,159 @@ yyreduce: } (yyval.nd) = (yyvsp[-1].nd); } -#line 8796 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 402: -#line 3175 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); - } -#line 8804 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8806 "mrbgems/mruby-compiler/core/y.tab.c" break; case 403: -#line 3179 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num)); - call_with_block(p, (yyval.nd), (yyvsp[0].nd)); - } -#line 8813 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 404: -#line 3184 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num)); - call_with_block(p, (yyval.nd), (yyvsp[0].nd)); - } -#line 8822 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 405: -#line 3191 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd)); - } -#line 8830 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 406: -#line 3195 "mrbgems/mruby-compiler/core/parse.y" +#line 3181 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 8838 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8814 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 404: +#line 3185 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num)); + call_with_block(p, (yyval.nd), (yyvsp[0].nd)); + } +#line 8823 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 405: +#line 3190 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num)); + call_with_block(p, (yyval.nd), (yyvsp[0].nd)); + } +#line 8832 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 406: +#line 3197 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd)); + } +#line 8840 "mrbgems/mruby-compiler/core/y.tab.c" break; case 407: -#line 3199 "mrbgems/mruby-compiler/core/parse.y" +#line 3201 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2); + (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 8846 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8848 "mrbgems/mruby-compiler/core/y.tab.c" break; case 408: -#line 3203 "mrbgems/mruby-compiler/core/parse.y" +#line 3205 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2); + (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2); } -#line 8854 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8856 "mrbgems/mruby-compiler/core/y.tab.c" break; case 409: -#line 3207 "mrbgems/mruby-compiler/core/parse.y" +#line 3209 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), (yyvsp[-1].num)); + (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2); } -#line 8862 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8864 "mrbgems/mruby-compiler/core/y.tab.c" break; case 410: -#line 3211 "mrbgems/mruby-compiler/core/parse.y" +#line 3213 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), tCOLON2); + (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), (yyvsp[-1].num)); } -#line 8870 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8872 "mrbgems/mruby-compiler/core/y.tab.c" break; case 411: -#line 3215 "mrbgems/mruby-compiler/core/parse.y" +#line 3217 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_super(p, (yyvsp[0].nd)); + (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), tCOLON2); } -#line 8878 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8880 "mrbgems/mruby-compiler/core/y.tab.c" break; case 412: -#line 3219 "mrbgems/mruby-compiler/core/parse.y" +#line 3221 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_zsuper(p); + (yyval.nd) = new_super(p, (yyvsp[0].nd)); } -#line 8886 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8888 "mrbgems/mruby-compiler/core/y.tab.c" break; case 413: -#line 3223 "mrbgems/mruby-compiler/core/parse.y" +#line 3225 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.'); + (yyval.nd) = new_zsuper(p); } -#line 8894 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8896 "mrbgems/mruby-compiler/core/y.tab.c" break; case 414: #line 3229 "mrbgems/mruby-compiler/core/parse.y" { - local_nest(p); - nvars_nest(p); - (yyval.num) = p->lineno; + (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.'); } #line 8904 "mrbgems/mruby-compiler/core/y.tab.c" break; case 415: -#line 3236 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); - SET_LINENO((yyval.nd), (yyvsp[-3].num)); - local_unnest(p); - nvars_unnest(p); - } -#line 8915 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 416: -#line 3243 "mrbgems/mruby-compiler/core/parse.y" +#line 3235 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); (yyval.num) = p->lineno; } -#line 8925 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8914 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 417: -#line 3250 "mrbgems/mruby-compiler/core/parse.y" + case 416: +#line 3242 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-3].num)); local_unnest(p); nvars_unnest(p); } -#line 8936 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8925 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 417: +#line 3249 "mrbgems/mruby-compiler/core/parse.y" + { + local_nest(p); + nvars_nest(p); + (yyval.num) = p->lineno; + } +#line 8935 "mrbgems/mruby-compiler/core/y.tab.c" break; case 418: -#line 3261 "mrbgems/mruby-compiler/core/parse.y" +#line 3256 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd)); + (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); + SET_LINENO((yyval.nd), (yyvsp[-3].num)); + local_unnest(p); + nvars_unnest(p); } -#line 8944 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8946 "mrbgems/mruby-compiler/core/y.tab.c" break; case 419: #line 3267 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd)); + } +#line 8954 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 420: +#line 3273 "mrbgems/mruby-compiler/core/parse.y" { if ((yyvsp[0].nd)) { (yyval.nd) = cons(cons(0, (yyvsp[0].nd)), 0); @@ -8953,60 +8963,60 @@ yyreduce: (yyval.nd) = 0; } } -#line 8957 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8967 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 421: -#line 3281 "mrbgems/mruby-compiler/core/parse.y" + case 422: +#line 3287 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(list3((yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd))); if ((yyvsp[0].nd)) (yyval.nd) = append((yyval.nd), (yyvsp[0].nd)); } -#line 8966 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8976 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 423: -#line 3289 "mrbgems/mruby-compiler/core/parse.y" + case 424: +#line 3295 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 8974 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8984 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 426: -#line 3297 "mrbgems/mruby-compiler/core/parse.y" + case 427: +#line 3303 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8982 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8992 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 428: -#line 3304 "mrbgems/mruby-compiler/core/parse.y" + case 429: +#line 3310 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8990 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9000 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 435: -#line 3318 "mrbgems/mruby-compiler/core/parse.y" + case 436: +#line 3324 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = concat_string(p, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8998 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 438: -#line 3326 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = (yyvsp[0].nd); - } -#line 9006 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9008 "mrbgems/mruby-compiler/core/y.tab.c" break; case 439: -#line 3330 "mrbgems/mruby-compiler/core/parse.y" +#line 3332 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = (yyvsp[0].nd); + } +#line 9016 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 440: +#line 3336 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { @@ -9017,69 +9027,69 @@ yyreduce: } (yyval.nd) = new_dstr(p, n); } -#line 9021 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 441: -#line 3344 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd)); - } -#line 9029 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9031 "mrbgems/mruby-compiler/core/y.tab.c" break; case 442: #line 3350 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = list1((yyvsp[0].nd)); + (yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9037 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9039 "mrbgems/mruby-compiler/core/y.tab.c" break; case 443: -#line 3354 "mrbgems/mruby-compiler/core/parse.y" +#line 3356 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = p->lex_strterm; - p->lex_strterm = NULL; + (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9046 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9047 "mrbgems/mruby-compiler/core/y.tab.c" break; case 444: #line 3360 "mrbgems/mruby-compiler/core/parse.y" { - p->lex_strterm = (yyvsp[-2].nd); - (yyval.nd) = list2((yyvsp[-3].nd), (yyvsp[-1].nd)); + (yyval.nd) = p->lex_strterm; + p->lex_strterm = NULL; } -#line 9055 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9056 "mrbgems/mruby-compiler/core/y.tab.c" break; case 445: -#line 3365 "mrbgems/mruby-compiler/core/parse.y" +#line 3366 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = list1(new_literal_delim(p)); + p->lex_strterm = (yyvsp[-2].nd); + (yyval.nd) = list2((yyvsp[-3].nd), (yyvsp[-1].nd)); } -#line 9063 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9065 "mrbgems/mruby-compiler/core/y.tab.c" break; case 446: -#line 3369 "mrbgems/mruby-compiler/core/parse.y" +#line 3371 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(new_literal_delim(p)); } -#line 9071 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9073 "mrbgems/mruby-compiler/core/y.tab.c" break; case 447: #line 3375 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = (yyvsp[0].nd); + (yyval.nd) = list1(new_literal_delim(p)); } -#line 9079 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9081 "mrbgems/mruby-compiler/core/y.tab.c" break; case 448: -#line 3379 "mrbgems/mruby-compiler/core/parse.y" +#line 3381 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = (yyvsp[0].nd); + } +#line 9089 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 449: +#line 3385 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { @@ -9090,31 +9100,21 @@ yyreduce: } (yyval.nd) = new_dxstr(p, n); } -#line 9094 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 449: -#line 3392 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = (yyvsp[0].nd); - } -#line 9102 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9104 "mrbgems/mruby-compiler/core/y.tab.c" break; case 450: -#line 3396 "mrbgems/mruby-compiler/core/parse.y" +#line 3398 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_dregx(p, (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = (yyvsp[0].nd); } -#line 9110 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9112 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 454: -#line 3409 "mrbgems/mruby-compiler/core/parse.y" + case 451: +#line 3402 "mrbgems/mruby-compiler/core/parse.y" { - parser_heredoc_info * inf = parsing_heredoc_inf(p); - inf->doc = push(inf->doc, new_str(p, "", 0)); - heredoc_end(p); + (yyval.nd) = new_dregx(p, (yyvsp[-1].nd), (yyvsp[0].nd)); } #line 9120 "mrbgems/mruby-compiler/core/y.tab.c" break; @@ -9122,17 +9122,17 @@ yyreduce: case 455: #line 3415 "mrbgems/mruby-compiler/core/parse.y" { + parser_heredoc_info * inf = parsing_heredoc_inf(p); + inf->doc = push(inf->doc, new_str(p, "", 0)); heredoc_end(p); } -#line 9128 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9130 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 458: -#line 3425 "mrbgems/mruby-compiler/core/parse.y" + case 456: +#line 3421 "mrbgems/mruby-compiler/core/parse.y" { - parser_heredoc_info * inf = parsing_heredoc_inf(p); - inf->doc = push(inf->doc, (yyvsp[0].nd)); - heredoc_treat_nextline(p); + heredoc_end(p); } #line 9138 "mrbgems/mruby-compiler/core/y.tab.c" break; @@ -9140,32 +9140,42 @@ yyreduce: case 459: #line 3431 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = p->lex_strterm; - p->lex_strterm = NULL; + parser_heredoc_info * inf = parsing_heredoc_inf(p); + inf->doc = push(inf->doc, (yyvsp[0].nd)); + heredoc_treat_nextline(p); } -#line 9147 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9148 "mrbgems/mruby-compiler/core/y.tab.c" break; case 460: #line 3437 "mrbgems/mruby-compiler/core/parse.y" { - parser_heredoc_info * inf = parsing_heredoc_inf(p); - p->lex_strterm = (yyvsp[-2].nd); - inf->doc = push(push(inf->doc, (yyvsp[-3].nd)), (yyvsp[-1].nd)); + (yyval.nd) = p->lex_strterm; + p->lex_strterm = NULL; } #line 9157 "mrbgems/mruby-compiler/core/y.tab.c" break; case 461: -#line 3445 "mrbgems/mruby-compiler/core/parse.y" +#line 3443 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_words(p, list1((yyvsp[0].nd))); + parser_heredoc_info * inf = parsing_heredoc_inf(p); + p->lex_strterm = (yyvsp[-2].nd); + inf->doc = push(push(inf->doc, (yyvsp[-3].nd)), (yyvsp[-1].nd)); } -#line 9165 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9167 "mrbgems/mruby-compiler/core/y.tab.c" break; case 462: -#line 3449 "mrbgems/mruby-compiler/core/parse.y" +#line 3451 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_words(p, list1((yyvsp[0].nd))); + } +#line 9175 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 463: +#line 3455 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { @@ -9176,20 +9186,20 @@ yyreduce: } (yyval.nd) = new_words(p, n); } -#line 9180 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9190 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 463: -#line 3463 "mrbgems/mruby-compiler/core/parse.y" + case 464: +#line 3469 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_ENDARG; (yyval.nd) = new_sym(p, (yyvsp[0].id)); } -#line 9189 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9199 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 464: -#line 3468 "mrbgems/mruby-compiler/core/parse.y" + case 465: +#line 3474 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); p->lstate = EXPR_ENDARG; @@ -9201,43 +9211,43 @@ yyreduce: } (yyval.nd) = new_dsym(p, new_dstr(p, n)); } -#line 9205 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9215 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 465: -#line 3482 "mrbgems/mruby-compiler/core/parse.y" + case 466: +#line 3488 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = (yyvsp[0].id); } -#line 9213 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 470: -#line 3492 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.id) = new_strsym(p, (yyvsp[0].nd)); - } -#line 9221 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9223 "mrbgems/mruby-compiler/core/y.tab.c" break; case 471: -#line 3496 "mrbgems/mruby-compiler/core/parse.y" +#line 3498 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = new_strsym(p, (yyvsp[0].nd)); } -#line 9229 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9231 "mrbgems/mruby-compiler/core/y.tab.c" break; case 472: #line 3502 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_symbols(p, list1((yyvsp[0].nd))); + (yyval.id) = new_strsym(p, (yyvsp[0].nd)); } -#line 9237 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9239 "mrbgems/mruby-compiler/core/y.tab.c" break; case 473: -#line 3506 "mrbgems/mruby-compiler/core/parse.y" +#line 3508 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_symbols(p, list1((yyvsp[0].nd))); + } +#line 9247 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 474: +#line 3512 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { @@ -9245,123 +9255,123 @@ yyreduce: } (yyval.nd) = new_symbols(p, n); } -#line 9249 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 476: -#line 3518 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_negate(p, (yyvsp[0].nd)); - } -#line 9257 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9259 "mrbgems/mruby-compiler/core/y.tab.c" break; case 477: -#line 3522 "mrbgems/mruby-compiler/core/parse.y" +#line 3524 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_negate(p, (yyvsp[0].nd)); } -#line 9265 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9267 "mrbgems/mruby-compiler/core/y.tab.c" break; case 478: #line 3528 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_lvar(p, (yyvsp[0].id)); + (yyval.nd) = new_negate(p, (yyvsp[0].nd)); } -#line 9273 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9275 "mrbgems/mruby-compiler/core/y.tab.c" break; case 479: -#line 3532 "mrbgems/mruby-compiler/core/parse.y" +#line 3534 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_ivar(p, (yyvsp[0].id)); + (yyval.nd) = new_lvar(p, (yyvsp[0].id)); } -#line 9281 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9283 "mrbgems/mruby-compiler/core/y.tab.c" break; case 480: -#line 3536 "mrbgems/mruby-compiler/core/parse.y" +#line 3538 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_gvar(p, (yyvsp[0].id)); + (yyval.nd) = new_ivar(p, (yyvsp[0].id)); } -#line 9289 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9291 "mrbgems/mruby-compiler/core/y.tab.c" break; case 481: -#line 3540 "mrbgems/mruby-compiler/core/parse.y" +#line 3542 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_cvar(p, (yyvsp[0].id)); + (yyval.nd) = new_gvar(p, (yyvsp[0].id)); } -#line 9297 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9299 "mrbgems/mruby-compiler/core/y.tab.c" break; case 482: -#line 3544 "mrbgems/mruby-compiler/core/parse.y" +#line 3546 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_const(p, (yyvsp[0].id)); + (yyval.nd) = new_cvar(p, (yyvsp[0].id)); } -#line 9305 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9307 "mrbgems/mruby-compiler/core/y.tab.c" break; case 483: #line 3550 "mrbgems/mruby-compiler/core/parse.y" { - assignable(p, (yyvsp[0].nd)); + (yyval.nd) = new_const(p, (yyvsp[0].id)); } -#line 9313 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9315 "mrbgems/mruby-compiler/core/y.tab.c" break; case 484: -#line 3554 "mrbgems/mruby-compiler/core/parse.y" +#line 3556 "mrbgems/mruby-compiler/core/parse.y" { - yyerror(p, "can't assign to numbered parameter"); + assignable(p, (yyvsp[0].nd)); } -#line 9321 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9323 "mrbgems/mruby-compiler/core/y.tab.c" break; case 485: #line 3560 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = var_reference(p, (yyvsp[0].nd)); + yyerror(p, "can't assign to numbered parameter"); } -#line 9329 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9331 "mrbgems/mruby-compiler/core/y.tab.c" break; case 486: -#line 3564 "mrbgems/mruby-compiler/core/parse.y" +#line 3566 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_nil(p); + (yyval.nd) = var_reference(p, (yyvsp[0].nd)); } -#line 9337 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9339 "mrbgems/mruby-compiler/core/y.tab.c" break; case 487: -#line 3568 "mrbgems/mruby-compiler/core/parse.y" +#line 3570 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_self(p); + (yyval.nd) = new_nil(p); } -#line 9345 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9347 "mrbgems/mruby-compiler/core/y.tab.c" break; case 488: -#line 3572 "mrbgems/mruby-compiler/core/parse.y" +#line 3574 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_true(p); + (yyval.nd) = new_self(p); } -#line 9353 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9355 "mrbgems/mruby-compiler/core/y.tab.c" break; case 489: -#line 3576 "mrbgems/mruby-compiler/core/parse.y" +#line 3578 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_false(p); + (yyval.nd) = new_true(p); } -#line 9361 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9363 "mrbgems/mruby-compiler/core/y.tab.c" break; case 490: -#line 3580 "mrbgems/mruby-compiler/core/parse.y" +#line 3582 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_false(p); + } +#line 9371 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 491: +#line 3586 "mrbgems/mruby-compiler/core/parse.y" { const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL); if (!fn) { @@ -9369,117 +9379,107 @@ yyreduce: } (yyval.nd) = new_str(p, fn, strlen(fn)); } -#line 9373 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9383 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 491: -#line 3588 "mrbgems/mruby-compiler/core/parse.y" + case 492: +#line 3594 "mrbgems/mruby-compiler/core/parse.y" { char buf[16]; dump_int(p->lineno, buf); (yyval.nd) = new_int(p, buf, 10, 0); } -#line 9384 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9394 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 492: -#line 3595 "mrbgems/mruby-compiler/core/parse.y" + case 493: +#line 3601 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, MRB_SYM_2(p->mrb, __ENCODING__), 0); } -#line 9392 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 495: -#line 3605 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = 0; - } -#line 9400 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9402 "mrbgems/mruby-compiler/core/y.tab.c" break; case 496: -#line 3609 "mrbgems/mruby-compiler/core/parse.y" +#line 3611 "mrbgems/mruby-compiler/core/parse.y" { - p->lstate = EXPR_BEG; - p->cmd_start = TRUE; + (yyval.nd) = 0; } -#line 9409 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9410 "mrbgems/mruby-compiler/core/y.tab.c" break; case 497: -#line 3614 "mrbgems/mruby-compiler/core/parse.y" +#line 3615 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = (yyvsp[-1].nd); - } -#line 9417 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 500: -#line 3630 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = (yyvsp[-1].nd); p->lstate = EXPR_BEG; p->cmd_start = TRUE; } +#line 9419 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 498: +#line 3620 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = (yyvsp[-1].nd); + } #line 9427 "mrbgems/mruby-compiler/core/y.tab.c" break; case 501: #line 3636 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_dots(p, (yyvsp[-3].nd)); + (yyval.nd) = (yyvsp[-1].nd); + p->lstate = EXPR_BEG; + p->cmd_start = TRUE; } -#line 9435 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9437 "mrbgems/mruby-compiler/core/y.tab.c" break; case 502: -#line 3640 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_args_dots(p, 0); - } -#line 9443 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 504: -#line 3647 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = (yyvsp[-1].nd); - } -#line 9451 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 505: -#line 3651 "mrbgems/mruby-compiler/core/parse.y" +#line 3642 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_dots(p, (yyvsp[-3].nd)); } -#line 9459 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9445 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 506: -#line 3655 "mrbgems/mruby-compiler/core/parse.y" + case 503: +#line 3646 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_dots(p, 0); } -#line 9467 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9453 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 505: +#line 3653 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = (yyvsp[-1].nd); + } +#line 9461 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 506: +#line 3657 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_args_dots(p, (yyvsp[-3].nd)); + } +#line 9469 "mrbgems/mruby-compiler/core/y.tab.c" break; case 507: #line 3661 "mrbgems/mruby-compiler/core/parse.y" { - local_nest(p); + (yyval.nd) = new_args_dots(p, 0); } -#line 9475 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9477 "mrbgems/mruby-compiler/core/y.tab.c" break; case 508: #line 3667 "mrbgems/mruby-compiler/core/parse.y" { - void_expr_error(p, (yyvsp[0].nd)); - (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p))); - local_unnest(p); + local_nest(p); } #line 9485 "mrbgems/mruby-compiler/core/y.tab.c" break; @@ -9487,17 +9487,17 @@ yyreduce: case 509: #line 3673 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0); + void_expr_error(p, (yyvsp[0].nd)); + (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p))); local_unnest(p); } -#line 9494 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9495 "mrbgems/mruby-compiler/core/y.tab.c" break; case 510: -#line 3680 "mrbgems/mruby-compiler/core/parse.y" +#line 3679 "mrbgems/mruby-compiler/core/parse.y" { - void_expr_error(p, (yyvsp[0].nd)); - (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p))); + (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0); local_unnest(p); } #line 9504 "mrbgems/mruby-compiler/core/y.tab.c" @@ -9506,461 +9506,472 @@ yyreduce: case 511: #line 3686 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0); + void_expr_error(p, (yyvsp[0].nd)); + (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p))); local_unnest(p); } -#line 9513 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9514 "mrbgems/mruby-compiler/core/y.tab.c" break; case 512: -#line 3693 "mrbgems/mruby-compiler/core/parse.y" +#line 3692 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = list1((yyvsp[0].nd)); + (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0); + local_unnest(p); } -#line 9521 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9523 "mrbgems/mruby-compiler/core/y.tab.c" break; case 513: -#line 3697 "mrbgems/mruby-compiler/core/parse.y" +#line 3699 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); + (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9529 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9531 "mrbgems/mruby-compiler/core/y.tab.c" break; case 514: #line 3703 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = list1((yyvsp[0].nd)); + (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9537 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9539 "mrbgems/mruby-compiler/core/y.tab.c" break; case 515: -#line 3707 "mrbgems/mruby-compiler/core/parse.y" +#line 3709 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = list1((yyvsp[0].nd)); + } +#line 9547 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 516: +#line 3713 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9545 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 518: -#line 3717 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_kw_rest_args(p, nsym((yyvsp[0].id))); - } -#line 9553 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9555 "mrbgems/mruby-compiler/core/y.tab.c" break; case 519: -#line 3721 "mrbgems/mruby-compiler/core/parse.y" +#line 3723 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_kw_rest_args(p, 0); + (yyval.nd) = new_kw_rest_args(p, nsym((yyvsp[0].id))); } -#line 9561 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9563 "mrbgems/mruby-compiler/core/y.tab.c" break; case 520: #line 3727 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id)); + (yyval.nd) = new_kw_rest_args(p, 0); } -#line 9569 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9571 "mrbgems/mruby-compiler/core/y.tab.c" break; case 521: -#line 3731 "mrbgems/mruby-compiler/core/parse.y" +#line 3733 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id)); + (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 9577 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9579 "mrbgems/mruby-compiler/core/y.tab.c" break; case 522: -#line 3735 "mrbgems/mruby-compiler/core/parse.y" +#line 3737 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id)); + (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id)); } -#line 9585 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9587 "mrbgems/mruby-compiler/core/y.tab.c" break; case 523: -#line 3739 "mrbgems/mruby-compiler/core/parse.y" +#line 3741 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id)); + (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 9593 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9595 "mrbgems/mruby-compiler/core/y.tab.c" break; case 524: #line 3745 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = (yyvsp[0].nd); + (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id)); } -#line 9601 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9603 "mrbgems/mruby-compiler/core/y.tab.c" break; case 525: -#line 3749 "mrbgems/mruby-compiler/core/parse.y" +#line 3751 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args_tail(p, 0, 0, 0); + (yyval.nd) = (yyvsp[0].nd); } -#line 9609 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9611 "mrbgems/mruby-compiler/core/y.tab.c" break; case 526: #line 3755 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); + (yyval.nd) = new_args_tail(p, 0, 0, 0); } -#line 9617 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9619 "mrbgems/mruby-compiler/core/y.tab.c" break; case 527: -#line 3759 "mrbgems/mruby-compiler/core/parse.y" +#line 3761 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9625 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9627 "mrbgems/mruby-compiler/core/y.tab.c" break; case 528: -#line 3763 "mrbgems/mruby-compiler/core/parse.y" +#line 3765 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9633 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9635 "mrbgems/mruby-compiler/core/y.tab.c" break; case 529: -#line 3767 "mrbgems/mruby-compiler/core/parse.y" +#line 3769 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 9641 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9643 "mrbgems/mruby-compiler/core/y.tab.c" break; case 530: -#line 3771 "mrbgems/mruby-compiler/core/parse.y" +#line 3773 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9649 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9651 "mrbgems/mruby-compiler/core/y.tab.c" break; case 531: -#line 3775 "mrbgems/mruby-compiler/core/parse.y" +#line 3777 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9657 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9659 "mrbgems/mruby-compiler/core/y.tab.c" break; case 532: -#line 3779 "mrbgems/mruby-compiler/core/parse.y" +#line 3781 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9665 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9667 "mrbgems/mruby-compiler/core/y.tab.c" break; case 533: -#line 3783 "mrbgems/mruby-compiler/core/parse.y" +#line 3785 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 9673 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9675 "mrbgems/mruby-compiler/core/y.tab.c" break; case 534: -#line 3787 "mrbgems/mruby-compiler/core/parse.y" +#line 3789 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9681 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9683 "mrbgems/mruby-compiler/core/y.tab.c" break; case 535: -#line 3791 "mrbgems/mruby-compiler/core/parse.y" +#line 3793 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9689 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9691 "mrbgems/mruby-compiler/core/y.tab.c" break; case 536: -#line 3795 "mrbgems/mruby-compiler/core/parse.y" +#line 3797 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 9697 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9699 "mrbgems/mruby-compiler/core/y.tab.c" break; case 537: -#line 3799 "mrbgems/mruby-compiler/core/parse.y" +#line 3801 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9705 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9707 "mrbgems/mruby-compiler/core/y.tab.c" break; case 538: -#line 3803 "mrbgems/mruby-compiler/core/parse.y" +#line 3805 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9713 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9715 "mrbgems/mruby-compiler/core/y.tab.c" break; case 539: -#line 3807 "mrbgems/mruby-compiler/core/parse.y" +#line 3809 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd)); + (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9721 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9723 "mrbgems/mruby-compiler/core/y.tab.c" break; case 540: -#line 3811 "mrbgems/mruby-compiler/core/parse.y" +#line 3813 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd)); + } +#line 9731 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 541: +#line 3817 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, intern_op(and)); (yyval.nd) = new_args(p, 0, 0, 0, 0, 0); } -#line 9730 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9740 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 541: -#line 3818 "mrbgems/mruby-compiler/core/parse.y" + case 542: +#line 3824 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a constant"); (yyval.nd) = 0; } -#line 9739 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9749 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 542: -#line 3823 "mrbgems/mruby-compiler/core/parse.y" + case 543: +#line 3829 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be an instance variable"); (yyval.nd) = 0; } -#line 9748 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9758 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 543: -#line 3828 "mrbgems/mruby-compiler/core/parse.y" + case 544: +#line 3834 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a global variable"); (yyval.nd) = 0; } -#line 9757 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9767 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 544: -#line 3833 "mrbgems/mruby-compiler/core/parse.y" + case 545: +#line 3839 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a class variable"); (yyval.nd) = 0; } -#line 9766 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9776 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 545: -#line 3838 "mrbgems/mruby-compiler/core/parse.y" + case 546: +#line 3844 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a numbered parameter"); (yyval.nd) = 0; } -#line 9775 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 546: -#line 3845 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.id) = 0; - } -#line 9783 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9785 "mrbgems/mruby-compiler/core/y.tab.c" break; case 547: -#line 3849 "mrbgems/mruby-compiler/core/parse.y" +#line 3851 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.id) = 0; + } +#line 9793 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 548: +#line 3855 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); (yyval.id) = (yyvsp[0].id); } -#line 9792 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 548: -#line 3856 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = new_arg(p, (yyvsp[0].id)); - } -#line 9800 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9802 "mrbgems/mruby-compiler/core/y.tab.c" break; case 549: -#line 3860 "mrbgems/mruby-compiler/core/parse.y" +#line 3862 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = local_switch(p); + (yyval.nd) = new_arg(p, (yyvsp[0].id)); } -#line 9808 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9810 "mrbgems/mruby-compiler/core/y.tab.c" break; case 550: -#line 3864 "mrbgems/mruby-compiler/core/parse.y" +#line 3866 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_masgn_param(p, (yyvsp[-1].nd), p->locals->car); - local_resume(p, (yyvsp[-2].nd)); + (yyval.nd) = local_switch(p); } -#line 9817 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9818 "mrbgems/mruby-compiler/core/y.tab.c" break; case 551: -#line 3871 "mrbgems/mruby-compiler/core/parse.y" +#line 3870 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = list1((yyvsp[0].nd)); + (yyval.nd) = new_masgn_param(p, (yyvsp[-1].nd), p->locals->car); + local_resume(p, (yyvsp[-2].nd)); + local_add_f(p, 0); } -#line 9825 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9828 "mrbgems/mruby-compiler/core/y.tab.c" break; case 552: -#line 3875 "mrbgems/mruby-compiler/core/parse.y" +#line 3878 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); + (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9833 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9836 "mrbgems/mruby-compiler/core/y.tab.c" break; case 553: -#line 3881 "mrbgems/mruby-compiler/core/parse.y" +#line 3882 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); + } +#line 9844 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 554: +#line 3888 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[-1].id)); local_nest(p); (yyval.id) = (yyvsp[-1].id); } -#line 9843 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 554: -#line 3889 "mrbgems/mruby-compiler/core/parse.y" - { - void_expr_error(p, (yyvsp[0].nd)); - (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p))); - local_unnest(p); - } -#line 9853 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9854 "mrbgems/mruby-compiler/core/y.tab.c" break; case 555: -#line 3897 "mrbgems/mruby-compiler/core/parse.y" +#line 3896 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p))); local_unnest(p); } -#line 9863 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9864 "mrbgems/mruby-compiler/core/y.tab.c" break; case 556: -#line 3905 "mrbgems/mruby-compiler/core/parse.y" +#line 3904 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = list1((yyvsp[0].nd)); + void_expr_error(p, (yyvsp[0].nd)); + (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p))); + local_unnest(p); } -#line 9871 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9874 "mrbgems/mruby-compiler/core/y.tab.c" break; case 557: -#line 3909 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); - } -#line 9879 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 558: -#line 3915 "mrbgems/mruby-compiler/core/parse.y" +#line 3912 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9887 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9882 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 559: -#line 3919 "mrbgems/mruby-compiler/core/parse.y" + case 558: +#line 3916 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9895 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9890 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 562: -#line 3929 "mrbgems/mruby-compiler/core/parse.y" + case 559: +#line 3922 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = list1((yyvsp[0].nd)); + } +#line 9898 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 560: +#line 3926 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); + } +#line 9906 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 563: +#line 3936 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); (yyval.id) = (yyvsp[0].id); } -#line 9904 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9915 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 563: -#line 3934 "mrbgems/mruby-compiler/core/parse.y" + case 564: +#line 3941 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(mul); local_add_f(p, (yyval.id)); } -#line 9913 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 566: -#line 3945 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.id) = (yyvsp[0].id); - } -#line 9921 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9924 "mrbgems/mruby-compiler/core/y.tab.c" break; case 567: -#line 3949 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.id) = intern_op(and); - } -#line 9929 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 568: -#line 3955 "mrbgems/mruby-compiler/core/parse.y" +#line 3952 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = (yyvsp[0].id); } -#line 9937 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9932 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 568: +#line 3956 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.id) = intern_op(and); + } +#line 9940 "mrbgems/mruby-compiler/core/y.tab.c" break; case 569: -#line 3959 "mrbgems/mruby-compiler/core/parse.y" +#line 3962 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.id) = 0; + (yyval.id) = (yyvsp[0].id); } -#line 9945 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9948 "mrbgems/mruby-compiler/core/y.tab.c" break; case 570: -#line 3965 "mrbgems/mruby-compiler/core/parse.y" +#line 3966 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.id) = 0; + } +#line 9956 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 571: +#line 3972 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); if (!(yyval.nd)) (yyval.nd) = new_nil(p); } -#line 9954 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 571: -#line 3969 "mrbgems/mruby-compiler/core/parse.y" - {p->lstate = EXPR_BEG;} -#line 9960 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9965 "mrbgems/mruby-compiler/core/y.tab.c" break; case 572: -#line 3970 "mrbgems/mruby-compiler/core/parse.y" +#line 3976 "mrbgems/mruby-compiler/core/parse.y" + {p->lstate = EXPR_BEG;} +#line 9971 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 573: +#line 3977 "mrbgems/mruby-compiler/core/parse.y" { if ((yyvsp[-1].nd) == 0) { yyerror(p, "can't define singleton method for ()."); @@ -9983,63 +9994,63 @@ yyreduce: } (yyval.nd) = (yyvsp[-1].nd); } -#line 9987 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 574: -#line 3996 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = (yyvsp[-1].nd); - } -#line 9995 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9998 "mrbgems/mruby-compiler/core/y.tab.c" break; case 575: -#line 4002 "mrbgems/mruby-compiler/core/parse.y" +#line 4003 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = (yyvsp[-1].nd); + } +#line 10006 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 576: +#line 4009 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 10004 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 576: -#line 4007 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); - } -#line 10012 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10015 "mrbgems/mruby-compiler/core/y.tab.c" break; case 577: -#line 4013 "mrbgems/mruby-compiler/core/parse.y" +#line 4014 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); + } +#line 10023 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 578: +#line 4020 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[-2].nd)); void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 10022 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10033 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 578: -#line 4019 "mrbgems/mruby-compiler/core/parse.y" + case 579: +#line 4026 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons(new_sym(p, (yyvsp[-2].id)), (yyvsp[0].nd)); } -#line 10031 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 579: -#line 4024 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.nd) = cons(new_sym(p, (yyvsp[-1].id)), label_reference(p, (yyvsp[-1].id))); - } -#line 10039 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10042 "mrbgems/mruby-compiler/core/y.tab.c" break; case 580: -#line 4028 "mrbgems/mruby-compiler/core/parse.y" +#line 4031 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = cons(new_sym(p, (yyvsp[-1].id)), label_reference(p, (yyvsp[-1].id))); + } +#line 10050 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 581: +#line 4035 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); if (typen((yyvsp[-2].nd)->car) == NODE_DSTR) { @@ -10049,67 +10060,67 @@ yyreduce: (yyval.nd) = cons(new_sym(p, new_strsym(p, (yyvsp[-2].nd))), (yyvsp[0].nd)); } } -#line 10053 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10064 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 581: -#line 4038 "mrbgems/mruby-compiler/core/parse.y" + case 582: +#line 4045 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons(new_kw_rest_args(p, 0), (yyvsp[0].nd)); } -#line 10062 "mrbgems/mruby-compiler/core/y.tab.c" - break; - - case 594: -#line 4065 "mrbgems/mruby-compiler/core/parse.y" - { - (yyval.num) = '.'; - } -#line 10070 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10073 "mrbgems/mruby-compiler/core/y.tab.c" break; case 595: -#line 4069 "mrbgems/mruby-compiler/core/parse.y" +#line 4072 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.num) = '.'; + } +#line 10081 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 596: +#line 4076 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = 0; } -#line 10078 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10089 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 597: -#line 4076 "mrbgems/mruby-compiler/core/parse.y" + case 598: +#line 4083 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = tCOLON2; } -#line 10086 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10097 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 606: -#line 4097 "mrbgems/mruby-compiler/core/parse.y" + case 607: +#line 4104 "mrbgems/mruby-compiler/core/parse.y" {yyerrok;} -#line 10092 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10103 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 608: -#line 4102 "mrbgems/mruby-compiler/core/parse.y" + case 609: +#line 4109 "mrbgems/mruby-compiler/core/parse.y" { p->lineno += (yyvsp[0].num); p->column = 0; } -#line 10101 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10112 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 612: -#line 4114 "mrbgems/mruby-compiler/core/parse.y" + case 613: +#line 4121 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 10109 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10120 "mrbgems/mruby-compiler/core/y.tab.c" break; -#line 10113 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10124 "mrbgems/mruby-compiler/core/y.tab.c" default: break; } @@ -10341,7 +10352,7 @@ yyreturn: #endif return yyresult; } -#line 4118 "mrbgems/mruby-compiler/core/parse.y" +#line 4125 "mrbgems/mruby-compiler/core/parse.y" #define pylval (*((YYSTYPE*)(p->ylval))) From 90e61e6a267c7eb12bdc52525bd89f2f07c675b8 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 16 Feb 2022 14:05:48 +0000 Subject: [PATCH 081/292] build(deps): bump github/super-linter from 4.8.7 to 4.9.0 Bumps [github/super-linter](https://github.com/github/super-linter) from 4.8.7 to 4.9.0. - [Release notes](https://github.com/github/super-linter/releases) - [Changelog](https://github.com/github/super-linter/blob/main/docs/release-process.md) - [Commits](https://github.com/github/super-linter/compare/v4.8.7...v4.9.0) --- updated-dependencies: - dependency-name: github/super-linter dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- .github/workflows/super-linter.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/super-linter.yml b/.github/workflows/super-linter.yml index 39e0772fd..c13425139 100644 --- a/.github/workflows/super-linter.yml +++ b/.github/workflows/super-linter.yml @@ -13,7 +13,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2.4.0 - - uses: github/super-linter@v4.8.7 + - uses: github/super-linter@v4.9.0 env: ERROR_ON_MISSING_EXEC_BIT: true VALIDATE_BASH: true From 47068ae07a5fa3aa9a1879cdfe98a9ce0f339299 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 18 Feb 2022 14:38:07 +0900 Subject: [PATCH 082/292] vm.c: packed arguments length may be zero for `send` method. --- src/vm.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/vm.c b/src/vm.c index 9cb50847f..aa5569503 100644 --- a/src/vm.c +++ b/src/vm.c @@ -689,9 +689,11 @@ mrb_f_send(mrb_state *mrb, mrb_value self) regs = mrb->c->ci->stack+1; if (n == 0) { + argnum_error: mrb_argnum_error(mrb, 0, 1, -1); } else if (n == 15) { + if (RARRAY_LEN(regs[0]) == 0) goto argnum_error; name = mrb_obj_to_sym(mrb, RARRAY_PTR(regs[0])[0]); } else { From 12d51807a397545d5cf423d2f9bd9b52b7e4a786 Mon Sep 17 00:00:00 2001 From: dearblue Date: Fri, 18 Feb 2022 22:15:50 +0900 Subject: [PATCH 083/292] Insert an empty hash before the first `NODE_KW_REST_ARGS` I expect this will fix the two problems that "#5640" didn't address. - It is expected to raise an exception `TypeError`, but it didn't before. ```console % bin/mruby -e 'p [**1]' [1] ``` - The variable `h` is expected to keep an empty hash, but it didn't before. ```console % bin/mruby -e 'h = {}; p(**h, a: 1, b: 2); p h' {:a=>1, :b=>2} {:a=>1, :b=>2} ``` --- mrbgems/mruby-compiler/core/codegen.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index b90eae3e8..20b7d5c89 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1605,10 +1605,16 @@ gen_hash(codegen_scope *s, node *tree, int val, int limit) if (cursp() >= GEN_LIT_ARY_MAX) slimit = INT16_MAX; int len = 0; mrb_bool update = FALSE; + mrb_bool first = TRUE; while (tree) { if (nint(tree->car->car->car) == NODE_KW_REST_ARGS) { - if (val && len > 0) { + if (val && first) { + genop_2(s, OP_HASH, cursp(), 0); + push(); + update = TRUE; + } + else if (val && len > 0) { pop_n(len*2); if (!update) { genop_2(s, OP_HASH, cursp(), len); @@ -1647,6 +1653,7 @@ gen_hash(codegen_scope *s, node *tree, int val, int limit) update = TRUE; len = 0; } + first = FALSE; } if (val && len > limit) { pop_n(len*2); From 401d316bcfc275227bf1c567092540cecbb34ed2 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 19 Feb 2022 14:39:17 +0900 Subject: [PATCH 084/292] Update `doc/mruby3.1.md` - `OP_GETIDX`, `OP_SETIDX` : Fix operand number - `OP_SYMBOL` : Add entry --- doc/mruby3.1.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/doc/mruby3.1.md b/doc/mruby3.1.md index 0c9ba8108..5588ae24d 100644 --- a/doc/mruby3.1.md +++ b/doc/mruby3.1.md @@ -72,10 +72,11 @@ Those instructions for method calls with variable number of arguments are no lon `mruby3.1` introduces following new instructions. -* `OP_GETIDX`: takes 2 operands `a[b]` -* `OP_SETIDX`: takes 3 operands `a[b]=c` +* `OP_GETIDX`: takes 1 operands `R[a][a+1]` +* `OP_SETIDX`: takes 1 operands `R[a][a+1]=R[a+2]` * `OP_SSEND`: takes 3 operands `a=self.b(c...)`; see `OP_SEND` * `OP_SSENDB`: takes 3 operands `a=self.b(c...){...}`; see `OP_SEND` +* `OP_SYMBOL`: takes 2 operands `R[a] = intern(Pool[b])` ### `OP_GETIDX` and `OP_SETIDX` @@ -85,6 +86,10 @@ Execute `obj[int]` and `obj[int] = value` respectively, where `obj` is `string|a They are similar to `OP_SEND` and `OP_SENDB` respectively. They initialize the `R[a]` by `self` first so that we can skip one `OP_LOADSELF` instruction for each call. +### `OP_SYMBOL` + +Extracts the character string placed in the pool as a symbol. + ## Changed Instructions ### `OP_SEND` and `OP_SENDB` From 621cafde680a1deafc0b3fe29d27e9ab5181ed65 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 19 Feb 2022 15:01:46 +0900 Subject: [PATCH 085/292] Need to check the type of the method return value --- mrbgems/mruby-socket/src/socket.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index f0213ad39..9af143e2f 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -265,7 +265,7 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen) static int socket_fd(mrb_state *mrb, mrb_value sock) { - return (int)mrb_integer(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0)); + return (int)mrb_as_int(mrb, mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0)); } static int @@ -468,9 +468,10 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self) } else if (argc == 1) { if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option"); - level = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(level), 0)); - optname = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0)); + level = mrb_as_int(mrb, mrb_funcall_id(mrb, so, MRB_SYM(level), 0)); + optname = mrb_as_int(mrb, mrb_funcall_id(mrb, so, MRB_SYM(optname), 0)); optval = mrb_funcall_id(mrb, so, MRB_SYM(data), 0); + mrb_ensure_string_type(mrb, optval); } else { mrb_argnum_error(mrb, argc, 3, 3); } From 44f591aa8f7091e6ca6cb418e428ae6d4ceaf77d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 19 Feb 2022 16:13:16 +0900 Subject: [PATCH 086/292] codegen.c: adjust stack position for `OP_SUPER` instruction. --- mrbgems/mruby-compiler/core/codegen.c | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 20b7d5c89..729f57566 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2954,19 +2954,20 @@ codegen(codegen_scope *s, node *tree, int val) if (tree->cdr->cdr) { codegen(s, tree->cdr->cdr, VAL); } - else if (!s2) {/* super at top-level */ - push(); /* no need to push block */ - } + else if (s2) gen_blkmove(s, s2->ainfo, lv); else { - gen_blkmove(s, s2->ainfo, lv); + genop_1(s, OP_LOADNIL, cursp()); + push(); } - st++; } else { - if (!s2) push(); - else gen_blkmove(s, s2->ainfo, lv); - st++; + if (s2) gen_blkmove(s, s2->ainfo, lv); + else { + genop_1(s, OP_LOADNIL, cursp()); + push(); + } } + st++; pop_n(st+1); genop_2(s, OP_SUPER, cursp(), n); if (val) push(); @@ -3218,6 +3219,7 @@ codegen(codegen_scope *s, node *tree, int val) codegen_error(s, "no anonymous block argument"); } gen_move(s, cursp(), idx, val); + if (val) push(); } else { codegen(s, tree, val); From d7c09fb24a21aa781861b7ea007773b0788382d7 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 19 Feb 2022 21:55:52 +0900 Subject: [PATCH 087/292] Improved documentation for `struct mrb_kwargs` [ci skip] - Changed the description to match the order of the changed members. - Replaced "array of symbols" instead of "array of strings that mean symbols". - The `mrb_kwargs::optional` member has not been present since the first merge. It is a remnant from development time. - Removed `const` modifier used in variable declarations in examples. This is not always necessary from a user perspective. - Added note on the use of `MRB_SYM()`. resolved #5649 --- include/mruby.h | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/include/mruby.h b/include/mruby.h index 3e92021ac..f18fd472b 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -948,14 +948,14 @@ typedef const char *mrb_args_format; /** * Get keyword arguments by `mrb_get_args()` with `:` specifier. * - * `mrb_kwargs::num` indicates that the number of keyword values. + * `mrb_kwargs::num` indicates that the total number of keyword values. * - * `mrb_kwargs::values` is an object array, and the keyword argument corresponding to the string array is assigned. - * Note that `undef` is assigned if there is no keyword argument corresponding to `mrb_kwargs::optional`. + * `mrb_kwargs::required` indicates that the specified number of keywords starting from the beginning of the `mrb_sym` array are required. * - * `mrb_kwargs::table` accepts a string array. + * `mrb_kwargs::table` accepts a `mrb_sym` array of C. * - * `mrb_kwargs::required` indicates that the specified number of keywords starting from the beginning of the string array are required. + * `mrb_kwargs::values` is an object array of C, and the keyword argument corresponding to the `mrb_sym` array is assigned. + * Note that `undef` is assigned if there is no keyword argument corresponding over `mrb_kwargs::required` to `mrb_kwargs::num`. * * `mrb_kwargs::rest` is the remaining keyword argument that can be accepted as `**rest` in Ruby. * If `NULL` is specified, `ArgumentError` is raised when there is an undefined keyword. @@ -965,10 +965,10 @@ typedef const char *mrb_args_format; * // def method(a: 1, b: 2) * * uint32_t kw_num = 2; - * const char *kw_names[kw_num] = { "a", "b" }; * uint32_t kw_required = 0; + * mrb_sym kw_names[] = { mrb_intern_lit(mrb, "a"), mrb_intern_lit(mrb, "b") }; * mrb_value kw_values[kw_num]; - * const mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, NULL }; + * mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, NULL }; * * mrb_get_args(mrb, ":", &kwargs); * if (mrb_undef_p(kw_values[0])) { kw_values[0] = mrb_fixnum_value(1); } @@ -979,10 +979,12 @@ typedef const char *mrb_args_format; * * mrb_value str, kw_rest; * uint32_t kw_num = 3; - * const mrb_sym kw_names[kw_num] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) }; * uint32_t kw_required = 1; + * // Note that `#include ` is required beforehand because `MRB_SYM()` is used. + * // If the usage of `MRB_SYM()` is not desired, replace it with `mrb_intern_lit()`. + * mrb_sym kw_names[] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) }; * mrb_value kw_values[kw_num]; - * const mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, &kw_rest }; + * mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, &kw_rest }; * * mrb_get_args(mrb, "S:", &str, &kwargs); * // or: mrb_get_args(mrb, ":S", &kwargs, &str); From ce3b1c4780df195134d91442708d2f118e554556 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 19 Feb 2022 23:17:33 +0900 Subject: [PATCH 088/292] SECURITY.md: added memory allocation error as a non security issue. mruby expects `malloc(3)` returns `NULL` for too big allocations, so even if big object allocation (e.g. `[1,2,3]*268888888888888818`) caused ASAN/Valgrind warnings, it's intentional, and we won't consider the warning as a security issue. --- SECURITY.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/SECURITY.md b/SECURITY.md index 2f0ae5b28..5227f98e7 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -15,4 +15,6 @@ We *don't* consider following issues as vulnerabilities: * Runtime C undefined behavior (including integer overflow) * Crash caused by misused API -* Crash caused by tweaked compiled binary +* Crash caused by modified compiled binary +* ASAN/Valgrind warning for too big memory allocation + mruby assumes `malloc(3)` returns `NULL` for too big allocations From 349307ba884740b132dcf08dfb615c0f329d2579 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 21 Feb 2022 11:46:34 +0900 Subject: [PATCH 089/292] codedump.c: do not print nameless registers. --- src/codedump.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/codedump.c b/src/codedump.c index 003a20394..7c71fb400 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -101,7 +101,10 @@ codedump(mrb_state *mrb, const mrb_irep *irep) printf("local variable names:\n"); for (i = 1; i < irep->nlocals; ++i) { char const *s = mrb_sym_dump(mrb, irep->lv[i - 1]); - printf(" R%d:%s\n", i, s ? s : ""); + if (s) { + printf(" R%d:%s", i, s); + } + putchar('\n'); } } From f72315575f78a9a773adbce0ee7d3ec33434cb76 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 22 Feb 2022 11:06:20 +0900 Subject: [PATCH 090/292] codegen.c: fix a argument generation bug in array assignment. --- mrbgems/mruby-compiler/core/codegen.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 729f57566..37b1307e6 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1904,8 +1904,12 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) if (val) { gen_move(s, top, cursp(), 1); } - if (n < 14) { + if (n < 15) { n++; + if (n == 15) { + pop_n(14); + genop_2(s, OP_ARRAY, cursp(), 15); + } } else { pop(); From 80b44c6ade483815868eccd0d0f543977e583503 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 22 Feb 2022 11:46:02 +0900 Subject: [PATCH 091/292] socket.c: avoid `mrb_funcall_id()` to retrieve file descriptor. --- mrbgems/mruby-socket/src/socket.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 9af143e2f..fd5967cf9 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -262,10 +262,12 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen) return ary; } +int mrb_io_fileno(mrb_state *mrb, mrb_value io); + static int socket_fd(mrb_state *mrb, mrb_value sock) { - return (int)mrb_as_int(mrb, mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0)); + return mrb_io_fileno(mrb, sock); } static int From 0282d3ec9f9fb309eeaf00437d83b9b57b6c0e23 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 22 Feb 2022 16:43:51 +0900 Subject: [PATCH 092/292] codegen.c: rename gen_vmassinment to gen_massignment. `m` stands for `multiple` but I don't remember why I put `v` first. --- mrbgems/mruby-compiler/core/codegen.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 37b1307e6..d33b79426 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -102,7 +102,7 @@ static int catch_handler_new(codegen_scope *s); static void catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target); static void gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val); -static void gen_vmassignment(codegen_scope *s, node *tree, int sp, int val); +static void gen_massignment(codegen_scope *s, node *tree, int sp, int val); static void codegen(codegen_scope *s, node *tree, int val); static void raise_error(codegen_scope *s, const char *msg); @@ -1278,7 +1278,7 @@ for_body(codegen_scope *s, node *tree) gen_assignment(s, n2->car->car, NULL, 1, NOVAL); } else { - gen_vmassignment(s, n2, 1, VAL); + gen_massignment(s, n2, 1, VAL); } /* construct loop */ lp = loop_push(s, LOOP_FOR); @@ -1444,7 +1444,7 @@ lambda_body(codegen_scope *s, node *tree, int blk) pos = 1; while (n) { if (nint(n->car->car) == NODE_MASGN) { - gen_vmassignment(s, n->car->cdr->car, pos, NOVAL); + gen_massignment(s, n->car->cdr->car, pos, NOVAL); } pos++; n = n->cdr; @@ -1456,7 +1456,7 @@ lambda_body(codegen_scope *s, node *tree, int blk) pos = ma+oa+ra+1; while (n) { if (nint(n->car->car) == NODE_MASGN) { - gen_vmassignment(s, n->car->cdr->car, pos, NOVAL); + gen_massignment(s, n->car->cdr->car, pos, NOVAL); } pos++; n = n->cdr; @@ -1930,7 +1930,7 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) break; case NODE_MASGN: - gen_vmassignment(s, tree->car, sp, val); + gen_massignment(s, tree->car, sp, val); break; /* splat without assignment */ @@ -1945,7 +1945,7 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) } static void -gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val) +gen_massignment(codegen_scope *s, node *tree, int rhs, int val) { int n = 0, post = 0; node *t, *p; @@ -2761,7 +2761,7 @@ codegen(codegen_scope *s, node *tree, int val) else { /* variable rhs */ codegen(s, t, VAL); - gen_vmassignment(s, tree->car, rhs, val); + gen_massignment(s, tree->car, rhs, val); if (!val) { pop(); } From ae231924a92fc2dc6e2ad4856046be1f52f24d4b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 22 Feb 2022 16:46:02 +0900 Subject: [PATCH 093/292] parse.y: small refactoring in mrb_parser_dump(). --- mrbgems/mruby-compiler/core/parse.y | 10 ++++------ mrbgems/mruby-compiler/core/y.tab.c | 10 ++++------ 2 files changed, 8 insertions(+), 12 deletions(-) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index a2ae02d8f..dce985182 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -7418,12 +7418,10 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) } } n2 = n2->cdr; - if (n2) { - if (n2->car) { - dump_prefix(n2, offset+2); - printf("post:\n"); - dump_recur(mrb, n2->car, offset+3); - } + if (n2 && n2->car) { + dump_prefix(n2, offset+2); + printf("post:\n"); + dump_recur(mrb, n2->car, offset+3); } } } diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index f692dfff0..2343f7c37 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -13649,12 +13649,10 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) } } n2 = n2->cdr; - if (n2) { - if (n2->car) { - dump_prefix(n2, offset+2); - printf("post:\n"); - dump_recur(mrb, n2->car, offset+3); - } + if (n2 && n2->car) { + dump_prefix(n2, offset+2); + printf("post:\n"); + dump_recur(mrb, n2->car, offset+3); } } } From 75e86dcfcdd902130c191d387344f0242c98b7db Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 22 Feb 2022 17:20:00 +0900 Subject: [PATCH 094/292] codegen.c: assign post assignees for fixed number of RHS. --- mrbgems/mruby-compiler/core/codegen.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index d33b79426..288f54b16 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2745,8 +2745,14 @@ codegen(codegen_scope *s, node *tree, int val) } if (t->cdr && t->cdr->car) { t = t->cdr->car; - while (ncar, NULL, rhs+n, NOVAL); + while (t) { + if (ncar, NULL, rhs+n, NOVAL); + } + else { + genop_1(s, OP_LOADNIL, cursp()); + gen_assignment(s, t->car, NULL, cursp(), NOVAL); + } t = t->cdr; n++; } From c37f648552b9697f721b9533bc0e4d173461168d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 22 Feb 2022 17:21:51 +0900 Subject: [PATCH 095/292] codegen.c: use `OP_ARRAY` instead of `OP_ARRAY2` if possible. `OP_ARRAY` inline elements, i.e: with `OP_ARRAY Rn Rm len`, `Rn` and `Rm` should always be the same register. --- mrbgems/mruby-compiler/core/codegen.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 288f54b16..ea383f711 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2739,7 +2739,12 @@ codegen(codegen_scope *s, node *tree, int val) else { rn = len - post - n; } - genop_3(s, OP_ARRAY2, cursp(), rhs+n, rn); + if (cursp() == rhs+n) { + genop_2(s, OP_ARRAY, cursp(), rn); + } + else { + genop_3(s, OP_ARRAY2, cursp(), rhs+n, rn); + } gen_assignment(s, t->car, NULL, cursp(), NOVAL); n += rn; } From d4d29b21b3760f4c33d1d0e2b58e8d809f5c159b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 22 Feb 2022 17:27:24 +0900 Subject: [PATCH 096/292] codegen.c: peephole optimize `OP_MOVE` after `OP_ARRAY` or `OP_ARRAY2`. --- mrbgems/mruby-compiler/core/codegen.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index ea383f711..b36f80acc 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -606,7 +606,7 @@ gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep) rewind_pc(s); genop_1(s, data.insn, dst); return; - case OP_HASH: case OP_ARRAY: + case OP_HASH: if (data.b != 0) goto normal; /* fall through */ case OP_LOADI: case OP_LOADINEG: @@ -631,6 +631,19 @@ gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep) genop_2SS(s, data.insn, dst, i); } return; + case OP_ARRAY: + if (data.a != src || data.a < s->nlocals || data.a < dst) goto normal; + rewind_pc(s); + if (data.b == 0) + genop_2(s, OP_ARRAY, dst, 0); + else + genop_3(s, OP_ARRAY2, dst, data.a, data.b); + return; + case OP_ARRAY2: + if (data.a != src || data.a < s->nlocals || data.a < dst) goto normal; + rewind_pc(s); + genop_3(s, OP_ARRAY2, dst, data.b, data.c); + return; case OP_AREF: case OP_GETUPVAR: if (data.a != src || data.a < s->nlocals) goto normal; From 776be1b3979f25bedf742417fd1161ab552882cc Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 22 Feb 2022 19:27:47 +0900 Subject: [PATCH 097/292] codegen.c: use `OP_ARRAY` instead of `OP_ARRAY2` in optimization. If operand 1 and operand 2 specify the same register `OP_ARRAY2` can/should be transformed to `OP_ARRAY`. --- mrbgems/mruby-compiler/core/codegen.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index b36f80acc..4b9ff64df 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -634,7 +634,7 @@ gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep) case OP_ARRAY: if (data.a != src || data.a < s->nlocals || data.a < dst) goto normal; rewind_pc(s); - if (data.b == 0) + if (data.b == 0 || dst == data.a) genop_2(s, OP_ARRAY, dst, 0); else genop_3(s, OP_ARRAY2, dst, data.a, data.b); From 8d1ffa8a119ce44261717aa2ff2ff0b52075936f Mon Sep 17 00:00:00 2001 From: Chris Reuter Date: Sun, 23 Jan 2022 16:27:08 -0500 Subject: [PATCH 098/292] Refactored load_gems.rb to be simpler and easier to understand: - Converted LoadGems::load_special_path_gems() into a class, then subdivided the various types of gem dependencies into smaller private methods. - Added class GemDepDetails to hold the relationship between a gem's location on the local disk and its upstream repository. This will be used later. - Removed the last remains of the '--pull-gems' option from the code base and documentation. This is no longer present and the dead code is clutter. Gracefully handle the case where multiple gems use the same git checkout path. Previously, if two gems had the same directory name when cloning them from git, mrbgems would assume they were the same gem. This also applied to different branches and/or commits of the same repository. This led to a strange situation where the first `conf.gem` statement "won" in cloning the repository but the last `conf.gem` ended up choosing the branch/commit-id to use. This change detects this situation and makes it an error. It also allows the config writer to explicitly specify a gem checkout to use in place of the others. --- doc/guides/mrbgems.md | 23 +- lib/mruby/build/load_gems.rb | 404 ++++++++++++++++++++++++++++------- 2 files changed, 342 insertions(+), 85 deletions(-) diff --git a/doc/guides/mrbgems.md b/doc/guides/mrbgems.md index 7649f40d2..64a12cff4 100644 --- a/doc/guides/mrbgems.md +++ b/doc/guides/mrbgems.md @@ -33,6 +33,9 @@ conf.gem :github => 'masuidrive/mrbgems-example', :branch => 'master' conf.gem :bitbucket => 'mruby/mrbgems-example', :branch => 'master' ``` +NOTE: `:bitbucket` option supports only git. Hg is unsupported in this +version. + You can specify the subdirectory of the repository with `:path` option: ```ruby @@ -55,10 +58,24 @@ conf.gem mgem: 'mruby-redis', checksum_hash: '3446d19fc4a3f9697b5ddbf2a904f301c4 If there are missing dependencies, mrbgem dependencies solver will reference mrbgem from the core or mgem-list. -To pull all gems from remote GIT repository on build, call `rake -p`, -or `rake --pull-gems`. +Note that if more than one git-based gem has the same base name +(i.e. the default checkout directory name), it is (now) an error +**UNLESS** they are have the same repository URL, branch name and +commit-id (i.e. checksum hash). You can bypass this by explicitly +importing your preferred version **first** and setting the +`canonical:` option to `true`: -NOTE: `:bitbucket` option supports only git. Hg is unsupported in this version. +```ruby +conf.gem github: 'me/mruby-yaml', branch: 'my-hacked-branch', canonical: true +``` + +If you do this, the system will (mostly) silently ignore other +attempts to clone a gem with this name. + +Note that this only affects cloning the gem from git. It does not +resolve version conflicts. If the version as specified in the gem's +rakefile is incompatible with a dependency, your build will still +fail. ## GemBox diff --git a/lib/mruby/build/load_gems.rb b/lib/mruby/build/load_gems.rb index 6609a5c8e..15331dd6f 100644 --- a/lib/mruby/build/load_gems.rb +++ b/lib/mruby/build/load_gems.rb @@ -1,5 +1,6 @@ module MRuby module LoadGems + def gembox(gemboxfile) gembox = File.expand_path("#{gemboxfile}.gembox", "#{MRUBY_ROOT}/mrbgems") fail "Can't find gembox '#{gembox}'" unless File.exist?(gembox) @@ -12,28 +13,30 @@ module MRuby GemBox.path = nil end - def gem(gemdir, &block) - if gemdir.is_a?(Hash) - gemdir = load_special_path_gem(gemdir) - elsif GemBox.path - gemdir = File.expand_path(gemdir, File.dirname(GemBox.path)) - else - caller_dir = File.expand_path(File.dirname(caller(1,1)[0][/^(.*?):\d/,1])) - if caller_dir == "#{MRUBY_ROOT}/build_config" - caller_dir = MRUBY_ROOT - end - gemdir = File.expand_path(gemdir, caller_dir) - end + def gem(gem_src, &block) - gemrake = File.join(gemdir, "mrbgem.rake") + caller_dir = File.expand_path(File.dirname(caller(1,1)[0][/^(.*?):\d/,1])) + gem_src = {gemdir: gem_src} if gem_src.is_a? String + + @gem_checkouts ||= {} + checkout = GemLoader + .new(self, caller_dir, @gem_checkouts, **gem_src) + .fetch! + return nil unless checkout + @gem_checkouts[checkout.gemdir] = checkout + + # Load the gem's rakefile + gemrake = File.join(checkout.gemdir, "mrbgem.rake") fail "Can't find #{gemrake}" unless File.exist?(gemrake) + Gem.current = nil load gemrake return nil unless Gem.current current = Gem.current - current.dir = gemdir + # Add it to gems + current.dir = checkout.gemdir current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current current.build_config_initializer = block gems << current @@ -44,92 +47,329 @@ module MRuby current end - def load_special_path_gem(params) - if params[:github] - params[:git] = "https://github.com/#{params[:github]}.git" - elsif params[:bitbucket] - if params[:method] == "ssh" - params[:git] = "git@bitbucket.org:#{params[:bitbucket]}.git" - else - params[:git] = "https://bitbucket.org/#{params[:bitbucket]}.git" - end - elsif params[:mgem] - mgem_list_dir = "#{gem_clone_dir}/mgem-list" - mgem_list_url = 'https://github.com/mruby/mgem-list.git' - if File.exist? mgem_list_dir - git.run_pull mgem_list_dir, mgem_list_url if $pull_gems - else - mkdir_p mgem_list_dir - git.run_clone mgem_list_dir, mgem_list_url, "--depth 1" - end - require 'yaml' + # Class to represent the relationship between a gem dependency and + # its remote repository (if any). + class GemCheckout + attr_reader :gemdir, :repo, :branch, :commit - conf_path = "#{mgem_list_dir}/#{params[:mgem]}.gem" - conf_path = "#{mgem_list_dir}/mruby-#{params[:mgem]}.gem" unless File.exist? conf_path - fail "mgem not found: #{params[:mgem]}" unless File.exist? conf_path - conf = YAML.load File.read conf_path + def initialize(gemdir, repo, branch, commit, canonical) + @gemdir = gemdir # Working copy of the gem - fail "unknown mgem protocol: #{conf['protocol']}" if conf['protocol'] != 'git' - params[:git] = conf['repository'] - params[:branch] = conf['branch'] if conf['branch'] + @repo = repo # Remote gem repo + @branch = branch # Branch to check out + @commit = commit # Commit-id to use + + @canonical = canonical # This is the One True checkout end - if params[:core] - gemdir = "#{root}/mrbgems/#{params[:core]}" - elsif params[:git] - url = params[:git] - gemdir = "#{gem_clone_dir}/#{url.match(/([-\w]+)(\.[-\w]+|)$/).to_a[1]}" + def canonical?() return @canonical; end + def git?() return !!@repo; end + def gemname() return File.basename(@gemdir); end - # by default the 'master' branch is used - branch = params[:branch] ? params[:branch] : 'master' + def hash() + return [@gemdir, @repo, @branch, @commit, @canonical].hash + end - lock = locks[url] if lock_enabled? + def ==(other) + return @gemdir == other.gemdir && @repo == other.repo && + @branch == other.branch && @commit == other.commit && + @canonical == other.canonical? + end + alias_method :eql?, :== - if File.exist?(gemdir) - if $pull_gems - # Jump to the top of the branch - git.run_checkout gemdir, branch - git.run_pull gemdir, url - elsif params[:checksum_hash] - git.run_checkout_detach gemdir, params[:checksum_hash] - elsif lock - git.run_checkout_detach gemdir, lock['commit'] - end + def to_s + desc = @gemdir + desc += " -> #{@repo}/#{@branch}" if git? + desc += "/#{commit}" if commit + return desc + end + end + + # Class to decode the argument set given to 'MRuby::Build::gem', + # and git-clone+git-checkout the sources if needed. + class GemLoader + def initialize(build, + build_config_dir, # Parent dir. of build_config + gem_checkouts, # Hash of existing checkouts + + # Git repo: + git: nil, + branch: "master", + checksum_hash: nil, + options: [], + + # Git repo on GitHub + github: nil, + + # Git repo on BitBucket + bitbucket: nil, + method: nil, + + # mgem entry + mgem: nil, + + # Core package + core: nil, + + # Path relative to the mruby checkout; probably wrong! + path: nil, + + # Local file(s) + gemdir: nil, + + # Related flags: + canonical: false # Ignore subsequent checkout of this gem + ) + @build = build + @build_config_dir = build_config_dir + @gem_checkouts = gem_checkouts + @canonical = canonical + + @git = git + @branch = branch + @checksum_hash = checksum_hash + @options = options + @canonical = canonical + + @github = github + + @bitbucket = bitbucket + @method = method + + @mgem = mgem + @core = core + @path = path + @gemdir = gemdir + + + actions = [git, github, bitbucket, mgem, core, path, gemdir] + fail("Need to set exactly ONE of git, github, bitbucket, mgem, core, " + + "path, or gemdir") unless actions.compact.size == 1 + end + + # Retrieve the repo and return the details in a GemCheckout + # object or nil if nothing needed to be done. + def fetch! + return fromGemdir! if @gemdir + return fromCore! if @core + return fromPath! if @path + return fromGitHub! if @github + return fromBitBucket! if @bitbucket + + return fromMGem! if @mgem + + return fromGit!(@git, @branch) if @git + + # Shouldn't be reachable, but... + fail "Invalid gem configuration!" + end + + private + + # + # Local Paths + # + + def fromGemdir! + gem_src = @gemdir + + # If @gemdir is a relative path, we first convert it to an + # absolute path; this depends on circumstances. + if MRuby::GemBox.path + # If GemBox.path is set, it means that this fetch operation is + # happening as part of a gembox evaluation and we use the + # gembox's path as the starting point. + gem_src = File.expand_path(gem_src, File.dirname(MRuby::GemBox.path)) else - options = [params[:options]] || [] - options << "--recursive" - options << "--branch \"#{branch}\"" - options << "--depth 1" unless params[:checksum_hash] || lock - mkdir_p "#{gem_clone_dir}" - git.run_clone gemdir, url, options + # Otherwise, we use the path to the build_config.rb file that + # requested this gem. This path was extracted earlier and + # stored in @build_config_dir via the second argument of + # 'initialize'. + root_dir = @build_config_dir - # Jump to the specified commit - if params[:checksum_hash] - git.run_checkout_detach gemdir, params[:checksum_hash] - elsif lock - git.run_checkout_detach gemdir, lock['commit'] - end + # And we default to the repo root if the file is one of the + # stock configs in build_config/. + root_dir = MRUBY_ROOT if root_dir == "#{MRUBY_ROOT}/build_config" + + gem_src = File.expand_path(gem_src, root_dir) end - if lock_enabled? - @gem_dir_to_repo_url[gemdir] = url unless params[:path] - locks[url] = { + return GemCheckout.new(gem_src, nil, nil, nil, @canonical) + end + + def fromCore! + return GemCheckout.new("#{@build.root}/mrbgems/#{@core}", nil, nil, + nil, @canonical) + end + + # This is probably incorrect. + # + # According to doc/guides/mrbgems.md, this should specify a + # subdirectory of a git checkout (i.e. for the case where the gem + # itself is not in the repository's root.) + # + # However, the code treats this as simple path to a local + # directory (just like :gemdir) with relative paths resolved + # relative to the project root. + # + # I'm pretty sure that the correct thing is what guide says but + # I'm going to keep the initial semantics for now. + def fromPath! + p = Pathname.new(@path).absolute? ? @path : "#{@build.root}/#{@path}" + return GemCheckout.new(p, nil, nil, nil, @canonical) + end + + + # + # Git forges + # + + def fromGitHub! + url = "https://github.com/#{@github}.git" + return fromGit!(url, @branch) + end + + def fromBitBucket! + if @method == "ssh" + url = "git@bitbucket.org:#{@bitbucket}.git" + else + url = "https://bitbucket.org/#{@bitbucket}.git" + end + + return fromGit!(url, @branch) + end + + + # + # mgem file + # + + def fromMGem! + mgem = fetchMGem(@mgem) + + url = mgem['repository'] + branch = mgem['branch'] || @branch + + return fromGit!(url, branch) + end + + # Fetch the contents of the named mgem item. Will clone the + # mgem-list repo if not present + def fetchMGem(mgem) + list_dir = "#{@build.gem_clone_dir}/mgem-list" + url = 'https://github.com/mruby/mgem-list.git' + + git_clone_dependency(url, list_dir, nil, 'master') + + conf_path = "#{list_dir}/#{mgem}.gem" + conf_path = "#{list_dir}/mruby-#{mgem}.gem" unless + File.exist? conf_path + fail "mgem not found: #{mgem}" unless File.exist? conf_path + + conf = YAML.load File.read conf_path + fail "unknown mgem protocol: #{conf['protocol']}" if + conf['protocol'] != 'git' + + return conf + end + + + # + # Git checkouts + # + + def fromGit!(url, branch) + repo_dir = "#{@build.gem_clone_dir}/" + + "#{url.match(/([-\w]+)(\.[-\w]+|)$/).to_a[1]}" + commit = @checksum_hash + + return nil if skip_this?(url, repo_dir, branch, commit) + + # If there's a lockfile entry for this repo AND the user hasn't + # specified a specific commit ID, we use the locked branch and + # commit. + lock = @build.locks[url] if @build.lock_enabled? + if !commit && lock + branch = lock['branch'] + commit = lock['commit'] + end + + # Clone the dependency (if needed) and checkout the expected + # revision. + git_clone_dependency(url, repo_dir, commit, branch) + git_checkout_dependency(repo_dir, commit, branch) + + # Set the lockfile entry if enabled + if @build.lock_enabled? + @build.gem_dir_to_repo_url[repo_dir] = url + @build.locks[url] = { 'url' => url, - 'branch' => git.current_branch(gemdir), - 'commit' => git.commit_hash(gemdir), + 'branch' => @build.git.current_branch(repo_dir), + 'commit' => @build.git.commit_hash(repo_dir), } end - gemdir << "/#{params[:path]}" if params[:path] - elsif params[:path] - require 'pathname' - gemdir = Pathname.new(params[:path]).absolute? ? params[:path] : "#{root}/#{params[:path]}" - else - fail "unknown gem option #{params}" + return GemCheckout.new(repo_dir, url, branch, commit, @canonical) end - gemdir + + # Test if this repo can be skipped. This will happen if it's + # already in @gem_checkouts and EITHER it is identical (same + # url, branch and commit-ID) as the current checkout OR it's + # "canonical" flag is true. If it's in @gem_checkouts and + # neither of these conditions is true, that's a fatal error; it + # means there are multiple incompatible versions of this gem to + # be checked out into this directory. + # + # Otherwise, returns false. + def skip_this?(url, repo_dir, branch, commit) + prev = @gem_checkouts[repo_dir] + return false unless prev + + # Canonical declarations must precede all others. + fail("Attempted to re-declare #{prev.gemname} as canonical!\n" + + "('canonical' can only be used on its first declaration.)") if + prev && @canonical + + # If prev is canonical, we can ignore this + if prev.canonical? + puts "Found canonical #{prev.gemname}; skipping this one." + return true + end + + # If this checkout is identical to the current one, we can skip it. + candidate = GemCheckout.new(repo_dir, url, branch, commit, @canonical) + if prev == candidate + puts "Found duplicate checkout for #{repo_dir}; ignoring." + return true + end + + # Otherwise, we have a checkout conflict. This is an error. + fail "Conflicting gem definitions for '#{repo_dir}':\n" + + " #{candidate}\n" + + " #{prev}\n" + end + + + # Retrieve a git repo if it's not present. Return + # [path_to_checkout, did_clone] + def git_clone_dependency(url, repo_dir, commit, branch) + return if File.exist?(repo_dir) + + FileUtils.mkdir_p repo_dir + + options = @options.dup + options << "--recursive" + options << "--branch \"#{branch}\"" + options << "--depth 1" unless commit + + @build.git.run_clone repo_dir, url, options + end + + def git_checkout_dependency(repo_dir, commit, branch) + @build.git.run_checkout_detach(repo_dir, commit) + end end def enable_gems? From 73df87f7bd58e775acfb4fdf6f3aa222ba34fb57 Mon Sep 17 00:00:00 2001 From: Chris Reuter Date: Wed, 23 Feb 2022 14:23:57 -0500 Subject: [PATCH 099/292] Added a dependency on 'yaml' to load_gems.rb. It appears that some execution paths no longer load YAML before it is needed so we explicitly `require` it here. --- lib/mruby/build/load_gems.rb | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/mruby/build/load_gems.rb b/lib/mruby/build/load_gems.rb index 15331dd6f..9633c67bf 100644 --- a/lib/mruby/build/load_gems.rb +++ b/lib/mruby/build/load_gems.rb @@ -1,3 +1,5 @@ +require 'yaml' + module MRuby module LoadGems From b118ba9fb33836f7e037f24770efced7cb91a371 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 25 Feb 2022 17:53:55 +0900 Subject: [PATCH 100/292] rational.c: avoid indirect calls using `mrb_funcall()`. --- mrbgems/mruby-complex/src/complex.c | 4 ++-- mrbgems/mruby-rational/src/rational.c | 14 +++++++++----- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 6a02b1e93..17bd40d94 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -326,7 +326,7 @@ complex_div(mrb_state *mrb, mrb_value self) mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y); mrb_value mrb_rational_new(mrb_state *mrb, mrb_int n, mrb_int d); -mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x); +mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y); /* 15.2.8.3.4 */ /* @@ -345,7 +345,7 @@ cpx_int_div(mrb_state *mrb, mrb_value x) switch (mrb_type(y)) { #ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: - return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1)); + return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1), y); #endif case MRB_TT_COMPLEX: x = complex_new(mrb, (mrb_float)a, 0); diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index e66046543..ff9b6bd91 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -601,10 +601,9 @@ rational_mul(mrb_state *mrb, mrb_value x) } mrb_value -mrb_rational_div(mrb_state *mrb, mrb_value x) +mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y) { struct mrb_rational *p1 = rational_ptr(mrb, x); - mrb_value y = mrb_get_arg1(mrb); switch (mrb_type(y)) { case MRB_TT_INTEGER: @@ -642,7 +641,12 @@ mrb_rational_div(mrb_state *mrb, mrb_value x) } } -#define rational_div mrb_rational_div +mrb_value rational_div(mrb_state *mrb, mrb_value x) +{ + mrb_value y = mrb_get_arg1(mrb); + return mrb_rational_div(mrb, x, y); +} + mrb_int mrb_div_int(mrb_state *, mrb_int, mrb_int); #ifndef MRB_USE_COMPLEX @@ -662,7 +666,7 @@ rational_int_div(mrb_state *mrb, mrb_value x) } switch (mrb_type(y)) { case MRB_TT_RATIONAL: - return rational_div(mrb, rational_new(mrb, a, 1)); + return rational_div(mrb, rational_new(mrb, a, 1), y); default: #ifdef MRB_NO_FLOAT case MRB_TT_FLOAT: @@ -690,7 +694,7 @@ rational_int_quo(mrb_state *mrb, mrb_value x) switch (mrb_type(y)) { case MRB_TT_RATIONAL: x = rational_new(mrb, a, 1); - return mrb_funcall_id(mrb, x, MRB_OPSYM(div), 1, y); + return mrb_rational_div(mrb, x, y); default: #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer multiplication"); From 5305c5c84d9c994201efbcf5da1b330db2715316 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 26 Feb 2022 14:19:05 +0900 Subject: [PATCH 101/292] array.c: call `mrb_ary_delete_at()` directly from `Array#slice!`. Avoid `mrb_funcall()`. --- mrbgems/mruby-array-ext/src/array.c | 16 +++++----------- src/array.c | 2 +- 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c index ae8a55d4d..b5031530f 100644 --- a/mrbgems/mruby-array-ext/src/array.c +++ b/mrbgems/mruby-array-ext/src/array.c @@ -111,6 +111,8 @@ mrb_ary_values_at(mrb_state *mrb, mrb_value self) return mrb_get_values_at(mrb, self, RARRAY_LEN(self), argc, argv, ary_ref); } +mrb_value mrb_ary_delete_at(mrb_state *mrb, mrb_value self); + /* * call-seq: * ary.slice!(index) -> obj or nil @@ -146,21 +148,13 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self) if (mrb_get_argc(mrb) == 1) { mrb_value index = mrb_get_arg1(mrb); - switch (mrb_type(index)) { - case MRB_TT_RANGE: + if (mrb_type(index) == MRB_TT_RANGE) { if (mrb_range_beg_len(mrb, index, &i, &len, ARY_LEN(a), TRUE) == MRB_RANGE_OK) { goto delete_pos_len; } - else { - return mrb_nil_value(); - } - case MRB_TT_INTEGER: - val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index); - return val; - default: - val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index); - return val; + return mrb_nil_value(); } + return mrb_ary_delete_at(mrb, self); } mrb_get_args(mrb, "ii", &i, &len); diff --git a/src/array.c b/src/array.c index 07ceefb7e..f8b56bfa2 100644 --- a/src/array.c +++ b/src/array.c @@ -1009,7 +1009,7 @@ mrb_ary_aset(mrb_state *mrb, mrb_value self) return v3; } -static mrb_value +mrb_value mrb_ary_delete_at(mrb_state *mrb, mrb_value self) { struct RArray *a = mrb_ary_ptr(self); From 57540fbf6cc90a2265299950524edcbf613a0cdd Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 26 Feb 2022 22:01:52 +0900 Subject: [PATCH 102/292] object.c: improve handling of the broken `inspect` method. When `inspect` method returns non-string value, it will return a string given from `to_s` (and if `to_s` fails, will raise an exception). --- src/object.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/object.c b/src/object.c index a42293016..b430f2057 100644 --- a/src/object.c +++ b/src/object.c @@ -606,7 +606,11 @@ mrb_check_hash_type(mrb_state *mrb, mrb_value hash) MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj) { - return mrb_obj_as_string(mrb, mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0)); + mrb_value v = mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0); + if (!mrb_string_p(v)) { + v = mrb_obj_as_string(mrb, obj); + } + return v; } MRB_API mrb_bool From 740083eb72b8cb724fc9f12ab4bccf6fc8ba92f9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 27 Feb 2022 18:31:07 +0900 Subject: [PATCH 103/292] AUTHORS: update entries [ci skip] --- AUTHORS | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/AUTHORS b/AUTHORS index 404cb2f9c..2ed71ed02 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,16 +1,16 @@ # Authors of mruby (mruby developers) -## The List of Contributors sorted by number of commits (as of 2022-01-10 69b1667) +## The List of Contributors sorted by number of commits (as of 2022-02-27 57540fb) - 7956 Yukihiro "Matz" Matsumoto (@matz)* + 8048 Yukihiro "Matz" Matsumoto (@matz)* 586 KOBAYASHI Shuji (@shuujii) 376 Daniel Bovensiepen (@bovi) + 352 dearblue (@dearblue)* 346 Takeshi Watanabe (@take-cheeze)* - 342 dearblue (@dearblue)* 334 Masaki Muranaka (@monaka) - 298 Tomoyuki Sahara (@tsahara)* + 308 Tomoyuki Sahara (@tsahara)* 234 Jun Hiroe (@suzukaze) - 219 Cremno (@cremno)* + 220 Cremno (@cremno)* 208 Yuki Kurihara (@ksss)+ 148 Yasuhiro Matsumoto (@mattn)* 113 Carson McDonald (@carsonmcdonald) @@ -20,12 +20,12 @@ 74 Yuichiro MASUI (@masuidrive) 71 Tatsuhiko Kubo (@cubicdaiya)* 68 Hiroshi Mimaki (@mimaki)* - 63 Akira Yumiyama (@akiray03)* + 67 Akira Yumiyama (@akiray03)* 62 Paolo Bosetti (@pbosetti)* 59 Kurebayashi, Takahiro (@crimsonwoods)* 56 h2so5 (@h2so5) 52 Ralph Desir (@Mav7)* - 49 John Bampton (@jbampton) + 50 John Bampton (@jbampton) 45 Rory O'Connell (@RoryO)* 43 Yuichiro Kaneko (@yui-knk)+ 42 fleuria (@flaneur2020) @@ -66,10 +66,10 @@ 12 Ukrainskiy Sergey (@ukrainskiysergey) 12 Xuejie "Rafael" Xiao (@xxuejie)* 11 Julien Ammous (@schmurfy) + 11 Kazuho Oku (@kazuho) 11 Seeker (@SeekingMeaning) 11 YAMAMOTO Masaya (pandax381) 11 takkaw (@takkaw) - 10 Kazuho Oku (@kazuho) 10 Miura Hideki (@miura1729) 10 Narihiro Nakamura (@authorNari) 10 Ray Chason (@chasonr)* @@ -107,6 +107,7 @@ 5 Yurie Yamane (@yurie)+ 5 dreamedge (@dreamedge) 5 nkshigeru (@nkshigeru) + 4 Chris Reuter (@suetanvil) 4 Dante Catalfamo (@dantecatalfamo) 4 Goro Kikuchi (@gorogit) 4 Herwin Weststrate (@herwinw) @@ -225,6 +226,7 @@ 1 Kazuhiro NISHIYAMA (@znz) 1 Kei Sawada (@remore) 1 Kim H Madsen (@kimhmadsen) + 1 Koichi ITO (@koic) 1 Konstantin Haase (@rkh) 1 Leo Neat (@Leo-Neat) 1 Lian Cheng (@liancheng) From 9d8f3c60ff7d154c7d2250ec448b74b43dd96f2d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 28 Feb 2022 19:07:31 +0900 Subject: [PATCH 104/292] kernel.c: inline `mrb_obj_extend()` that is called only from one place. --- src/kernel.c | 31 ++++++++++++------------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/src/kernel.c b/src/kernel.c index dff627b8c..3c55fc948 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -215,24 +215,6 @@ mrb_obj_class_m(mrb_state *mrb, mrb_value self) return mrb_obj_value(mrb_obj_class(mrb, self)); } -static mrb_value -mrb_obj_extend(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value obj) -{ - mrb_int i; - - if (argc == 0) { - mrb_argnum_error(mrb, argc, 1, -1); - } - for (i = 0; i < argc; i++) { - mrb_check_type(mrb, argv[i], MRB_TT_MODULE); - } - while (argc--) { - mrb_funcall_id(mrb, argv[argc], MRB_SYM(extend_object), 1, obj); - mrb_funcall_id(mrb, argv[argc], MRB_SYM(extended), 1, obj); - } - return obj; -} - /* 15.3.1.3.13 */ /* * call-seq: @@ -265,7 +247,18 @@ mrb_obj_extend_m(mrb_state *mrb, mrb_value self) mrb_int argc; mrb_get_args(mrb, "*", &argv, &argc); - return mrb_obj_extend(mrb, argc, argv, self); + + if (argc == 0) { + mrb_argnum_error(mrb, argc, 1, -1); + } + for (mrb_int i = 0; i < argc; i++) { + mrb_check_type(mrb, argv[i], MRB_TT_MODULE); + } + while (argc--) { + mrb_funcall_id(mrb, argv[argc], MRB_SYM(extend_object), 1, self); + mrb_funcall_id(mrb, argv[argc], MRB_SYM(extended), 1, self); + } + return self; } MRB_API mrb_value From 1508da474090fd921c9e533ca5c080edc6ff1615 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 1 Mar 2022 15:04:08 +0900 Subject: [PATCH 105/292] array.c: check integer overflow in mrb_ary_set(). --- src/array.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/array.c b/src/array.c index f8b56bfa2..0f325bab0 100644 --- a/src/array.c +++ b/src/array.c @@ -716,6 +716,9 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) mrb_raisef(mrb, E_INDEX_ERROR, "index %i out of array", n - len); } } + if (n == MRB_INT_MAX) { + mrb_raise(mrb, E_INDEX_ERROR, "index too big"); + } if (len <= n) { if (ARY_CAPA(a) <= n) ary_expand_capa(mrb, a, n + 1); From d6ac7a3a7d87a5af4ee99760d5c474b5f3fe5786 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 2 Mar 2022 14:10:07 +0000 Subject: [PATCH 106/292] build(deps): bump actions/checkout from 2.4.0 to 3 Bumps [actions/checkout](https://github.com/actions/checkout) from 2.4.0 to 3. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v2.4.0...v3) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/build.yml | 16 ++++++++-------- .github/workflows/codeql-analysis.yml | 2 +- .github/workflows/lint.yml | 4 ++-- .github/workflows/super-linter.yml | 2 +- 4 files changed, 12 insertions(+), 12 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 3a1ef5e2a..a697ca079 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -10,7 +10,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: gcc steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - name: Ruby version run: ruby -v - name: Compiler version @@ -25,7 +25,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: clang steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - name: Ruby version run: ruby -v - name: Compiler version @@ -40,7 +40,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: gcc steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - name: Ruby version run: ruby -v - name: Compiler version @@ -55,7 +55,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: clang steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - name: Ruby version run: ruby -v - name: Compiler version @@ -70,7 +70,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: clang steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - name: Ruby version run: ruby -v - name: Compiler version @@ -85,7 +85,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: gcc steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - name: Ruby version run: ruby -v - name: Compiler version @@ -105,7 +105,7 @@ jobs: package-dir: C:\cygwin-package cache-version: v1 steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - uses: actions/cache@v2.1.7 with: path: ${{ env.package-dir }} @@ -145,7 +145,7 @@ jobs: env: MRUBY_CONFIG: ci/msvc steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - name: Ruby version run: ruby -v - name: Build and test diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index 184ca54c3..a6fb5d425 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -13,7 +13,7 @@ jobs: steps: - name: Checkout repository - uses: actions/checkout@v2.4.0 + uses: actions/checkout@v3 with: # We must fetch at least the immediate parents so that if this is # a pull request then we can checkout the head. diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 880b7ab6f..95518838f 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -8,7 +8,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Check Out - uses: actions/checkout@v2.4.0 + uses: actions/checkout@v3 - name: Install run: wget -O - -q https://git.io/misspell | sh -s -- -b . - name: Misspell @@ -17,7 +17,7 @@ jobs: name: Run pre-commit runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - name: Check merge conflict run: | python -m pip install --upgrade pip diff --git a/.github/workflows/super-linter.yml b/.github/workflows/super-linter.yml index c13425139..d0b0fe8f8 100644 --- a/.github/workflows/super-linter.yml +++ b/.github/workflows/super-linter.yml @@ -12,7 +12,7 @@ jobs: name: Lint Code Base runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2.4.0 + - uses: actions/checkout@v3 - uses: github/super-linter@v4.9.0 env: ERROR_ON_MISSING_EXEC_BIT: true From 0bf1ed9f2ca966327ca2ca8f3665b6a68121a2cf Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Mar 2022 15:33:02 +0900 Subject: [PATCH 107/292] array-ext/array.c: remove unused local variable. --- mrbgems/mruby-array-ext/src/array.c | 1 - 1 file changed, 1 deletion(-) diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c index b5031530f..9b7be2d42 100644 --- a/mrbgems/mruby-array-ext/src/array.c +++ b/mrbgems/mruby-array-ext/src/array.c @@ -139,7 +139,6 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self) { struct RArray *a = mrb_ary_ptr(self); mrb_int i, j, k, len, alen; - mrb_value val; mrb_value *ptr; mrb_value ary; From 51a3317c5babfe8ecb44c72528aba5cd6f119b0c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Mar 2022 15:34:28 +0900 Subject: [PATCH 108/292] string.c: check integer overflow using `mrb_int_mul_overflow()`. --- src/string.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/string.c b/src/string.c index 332c4e777..890300432 100644 --- a/src/string.c +++ b/src/string.c @@ -928,11 +928,9 @@ mrb_str_times(mrb_state *mrb, mrb_value self) if (times < 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argument"); } - if (times && MRB_SSIZE_MAX / times < RSTRING_LEN(self)) { + if (mrb_int_mul_overflow(RSTRING_LEN(self), times, &len)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "argument too big"); } - - len = RSTRING_LEN(self)*times; str2 = str_new(mrb, 0, len); p = RSTR_PTR(str2); if (len > 0) { From a4f740ff9ab8f42fd242eb34290821624d0d8b94 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Mar 2022 15:35:28 +0900 Subject: [PATCH 109/292] string.c: use `mrb_int` instead of `size_t`. --- include/mruby.h | 4 +-- include/mruby/string.h | 2 +- mrbgems/mruby-compiler/core/codegen.c | 4 +-- mrbgems/mruby-compiler/core/parse.y | 2 +- mrbgems/mruby-compiler/core/y.tab.c | 2 +- mrbgems/mruby-socket/src/socket.c | 2 +- src/string.c | 42 +++++++++++++-------------- src/vm.c | 2 +- 8 files changed, 30 insertions(+), 30 deletions(-) diff --git a/include/mruby.h b/include/mruby.h index f18fd472b..bca53003f 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1180,13 +1180,13 @@ MRB_API void mrb_free(mrb_state*, void*); */ #define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass)) -MRB_API mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len); +MRB_API mrb_value mrb_str_new(mrb_state *mrb, const char *p, mrb_int len); /** * Turns a C string into a Ruby string value. */ MRB_API mrb_value mrb_str_new_cstr(mrb_state*, const char*); -MRB_API mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len); +MRB_API mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, mrb_int len); #define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit)) MRB_API mrb_value mrb_obj_freeze(mrb_state*, mrb_value); diff --git a/include/mruby/string.h b/include/mruby/string.h index b296832af..3a8d73a70 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -324,7 +324,7 @@ MRB_API mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len); */ MRB_API mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len); -MRB_API mrb_value mrb_str_new_capa(mrb_state *mrb, size_t capa); +MRB_API mrb_value mrb_str_new_capa(mrb_state *mrb, mrb_int capa); #define mrb_str_buf_new(mrb, capa) mrb_str_new_capa(mrb, (capa)) /* NULL terminated C string from mrb_value */ diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 4b9ff64df..4d4d6abb7 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -3344,7 +3344,7 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_STR: if (val) { char *p = (char*)tree->car; - size_t len = (intptr_t)tree->cdr; + mrb_int len = nint(tree->cdr); int ai = mrb_gc_arena_save(s->mrb); int off = new_lit(s, mrb_str_new(s->mrb, p, len)); @@ -3429,7 +3429,7 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_XSTR: { char *p = (char*)tree->car; - size_t len = (intptr_t)tree->cdr; + mrb_int len = nint(tree->cdr); int ai = mrb_gc_arena_save(s->mrb); int off = new_lit(s, mrb_str_new(s->mrb, p, len)); int sym; diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index dce985182..3496b36d0 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -6933,7 +6933,7 @@ mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrbc_context *c) return mrb_load_exec(mrb, mrb_parse_file_continue(mrb, fp, leading.b, bufsize, c), c); } else { - size_t binsize; + mrb_int binsize; uint8_t *bin; mrb_value bin_obj = mrb_nil_value(); /* temporary string object */ mrb_value result; diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 2343f7c37..429c2209b 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -13164,7 +13164,7 @@ mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrbc_context *c) return mrb_load_exec(mrb, mrb_parse_file_continue(mrb, fp, leading.b, bufsize, c), c); } else { - size_t binsize; + mrb_int binsize; uint8_t *bin; mrb_value bin_obj = mrb_nil_value(); /* temporary string object */ mrb_value result; diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index fd5967cf9..a002a85a0 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -626,7 +626,7 @@ mrb_socket_accept2(mrb_state *mrb, mrb_value klass) mrb_get_args(mrb, "i", &s0); socklen = sizeof(struct sockaddr_storage); - sastr = mrb_str_new_capa(mrb, socklen); + sastr = mrb_str_new_capa(mrb, (mrb_int)socklen); s1 = (int)accept(s0, (struct sockaddr *)RSTRING_PTR(sastr), &socklen); if (s1 == -1) { mrb_sys_fail(mrb, "accept"); diff --git a/src/string.c b/src/string.c index 890300432..60ad00b6f 100644 --- a/src/string.c +++ b/src/string.c @@ -19,7 +19,7 @@ typedef struct mrb_shared_string { int refcnt; - mrb_ssize capa; + mrb_int capa; char *ptr; } mrb_shared_string; @@ -29,26 +29,26 @@ const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; static struct RString* str_init_normal_capa(mrb_state *mrb, struct RString *s, - const char *p, size_t len, size_t capa) + const char *p, mrb_int len, mrb_int capa) { char *dst = (char *)mrb_malloc(mrb, capa + 1); if (p) memcpy(dst, p, len); dst[len] = '\0'; s->as.heap.ptr = dst; - s->as.heap.len = (mrb_ssize)len; - s->as.heap.aux.capa = (mrb_ssize)capa; + s->as.heap.len = len; + s->as.heap.aux.capa = capa; RSTR_UNSET_TYPE_FLAG(s); return s; } static struct RString* -str_init_normal(mrb_state *mrb, struct RString *s, const char *p, size_t len) +str_init_normal(mrb_state *mrb, struct RString *s, const char *p, mrb_int len) { return str_init_normal_capa(mrb, s, p, len, len); } static struct RString* -str_init_embed(struct RString *s, const char *p, size_t len) +str_init_embed(struct RString *s, const char *p, mrb_int len) { if (p) memcpy(RSTR_EMBED_PTR(s), p, len); RSTR_EMBED_PTR(s)[len] = '\0'; @@ -58,10 +58,10 @@ str_init_embed(struct RString *s, const char *p, size_t len) } static struct RString* -str_init_nofree(struct RString *s, const char *p, size_t len) +str_init_nofree(struct RString *s, const char *p, mrb_int len) { s->as.heap.ptr = (char *)p; - s->as.heap.len = (mrb_ssize)len; + s->as.heap.len = len; s->as.heap.aux.capa = 0; /* nofree */ RSTR_SET_TYPE_FLAG(s, NOFREE); return s; @@ -97,7 +97,7 @@ str_init_fshared(const struct RString *orig, struct RString *s, struct RString * } static struct RString* -str_init_modifiable(mrb_state *mrb, struct RString *s, const char *p, size_t len) +str_init_modifiable(mrb_state *mrb, struct RString *s, const char *p, mrb_int len) { if (RSTR_EMBEDDABLE_P(len)) { return str_init_embed(s, p, len); @@ -108,7 +108,7 @@ str_init_modifiable(mrb_state *mrb, struct RString *s, const char *p, size_t len } static struct RString* -str_new_static(mrb_state *mrb, const char *p, size_t len) +str_new_static(mrb_state *mrb, const char *p, mrb_int len) { if (RSTR_EMBEDDABLE_P(len)) { return str_init_embed(mrb_obj_alloc_string(mrb), p, len); @@ -120,7 +120,7 @@ str_new_static(mrb_state *mrb, const char *p, size_t len) } static struct RString* -str_new(mrb_state *mrb, const char *p, size_t len) +str_new(mrb_state *mrb, const char *p, mrb_int len) { if (RSTR_EMBEDDABLE_P(len)) { return str_init_embed(mrb_obj_alloc_string(mrb), p, len); @@ -135,7 +135,7 @@ str_new(mrb_state *mrb, const char *p, size_t len) } MRB_API mrb_value -mrb_str_new_capa(mrb_state *mrb, size_t capa) +mrb_str_new_capa(mrb_state *mrb, mrb_int capa) { struct RString *s; @@ -155,7 +155,7 @@ mrb_str_new_capa(mrb_state *mrb, size_t capa) } static void -resize_capa(mrb_state *mrb, struct RString *s, size_t capacity) +resize_capa(mrb_state *mrb, struct RString *s, mrb_int capacity) { #if SIZE_MAX > MRB_SSIZE_MAX mrb_assert(capacity < MRB_SSIZE_MAX); @@ -172,7 +172,7 @@ resize_capa(mrb_state *mrb, struct RString *s, size_t capacity) } MRB_API mrb_value -mrb_str_new(mrb_state *mrb, const char *p, size_t len) +mrb_str_new(mrb_state *mrb, const char *p, mrb_int len) { return mrb_obj_value(str_new(mrb, p, len)); } @@ -181,7 +181,7 @@ MRB_API mrb_value mrb_str_new_cstr(mrb_state *mrb, const char *p) { struct RString *s; - size_t len; + mrb_int len; if (p) { len = strlen(p); @@ -196,7 +196,7 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p) } MRB_API mrb_value -mrb_str_new_static(mrb_state *mrb, const char *p, size_t len) +mrb_str_new_static(mrb_state *mrb, const char *p, mrb_int len) { struct RString *s = str_new_static(mrb, p, len); return mrb_obj_value(s); @@ -225,12 +225,12 @@ str_modify_keep_ascii(mrb_state *mrb, struct RString *s) mrb_free(mrb, shared); } else { - str_init_modifiable(mrb, s, s->as.heap.ptr, (size_t)s->as.heap.len); + str_init_modifiable(mrb, s, s->as.heap.ptr, s->as.heap.len); str_decref(mrb, shared); } } else if (RSTR_NOFREE_P(s) || RSTR_FSHARED_P(s)) { - str_init_modifiable(mrb, s, s->as.heap.ptr, (size_t)s->as.heap.len); + str_init_modifiable(mrb, s, s->as.heap.ptr, s->as.heap.len); } } @@ -833,7 +833,7 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0) struct RString *s; const char *p = RSTRING_PTR(str0); - size_t len = RSTRING_LEN(str0); + mrb_int len = RSTRING_LEN(str0); check_null_byte(mrb, str0); if (RSTR_EMBEDDABLE_P(len)) { s = str_init_embed(mrb_obj_alloc_string(mrb), p, len); @@ -920,7 +920,7 @@ mrb_str_bytesize(mrb_state *mrb, mrb_value self) static mrb_value mrb_str_times(mrb_state *mrb, mrb_value self) { - mrb_int n,len,times; + mrb_int n, len, times; struct RString *str2; char *p; @@ -2644,7 +2644,7 @@ MRB_API mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len) { struct RString *s = mrb_str_ptr(str); - size_t capa; + mrb_int capa; size_t total; ptrdiff_t off = -1; diff --git a/src/vm.c b/src/vm.c index aa5569503..09f524a9d 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2729,7 +2729,7 @@ RETRY_TRY_BLOCK: } CASE(OP_STRING, BB) { - size_t len; + mrb_int len; mrb_assert((pool[b].tt&IREP_TT_NFLAG)==0); len = pool[b].tt >> 2; From a9bde42641c315773b787cd33ca542f2a2d57789 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Mar 2022 15:48:09 +0900 Subject: [PATCH 110/292] string.c: small refactoring (open `else` clause after `return`). --- src/string.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/string.c b/src/string.c index 60ad00b6f..d5a914776 100644 --- a/src/string.c +++ b/src/string.c @@ -102,9 +102,7 @@ str_init_modifiable(mrb_state *mrb, struct RString *s, const char *p, mrb_int le if (RSTR_EMBEDDABLE_P(len)) { return str_init_embed(s, p, len); } - else { - return str_init_normal(mrb, s, p, len); - } + return str_init_normal(mrb, s, p, len); } static struct RString* From 1a9991f16575b922746e6e656d7e05e5812bbda9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Mar 2022 15:49:01 +0900 Subject: [PATCH 111/292] string.c: remove unnecessary size check before string initialization. --- src/string.c | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/string.c b/src/string.c index d5a914776..d49494bbb 100644 --- a/src/string.c +++ b/src/string.c @@ -111,9 +111,6 @@ str_new_static(mrb_state *mrb, const char *p, mrb_int len) if (RSTR_EMBEDDABLE_P(len)) { return str_init_embed(mrb_obj_alloc_string(mrb), p, len); } - if (len >= MRB_SSIZE_MAX) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big"); - } return str_init_nofree(mrb_obj_alloc_string(mrb), p, len); } @@ -123,9 +120,6 @@ str_new(mrb_state *mrb, const char *p, mrb_int len) if (RSTR_EMBEDDABLE_P(len)) { return str_init_embed(mrb_obj_alloc_string(mrb), p, len); } - if (len >= MRB_SSIZE_MAX) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big"); - } if (p && mrb_ro_data_p(p)) { return str_init_nofree(mrb_obj_alloc_string(mrb), p, len); } From c3f0f84da5e767955b0ae1eab57dca0b4401d8d5 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Mar 2022 15:49:34 +0900 Subject: [PATCH 112/292] string.c: remove code duplication using `str_init_modifiable()`. --- src/string.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/string.c b/src/string.c index d49494bbb..7cc9c4ff3 100644 --- a/src/string.c +++ b/src/string.c @@ -827,12 +827,7 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0) const char *p = RSTRING_PTR(str0); mrb_int len = RSTRING_LEN(str0); check_null_byte(mrb, str0); - if (RSTR_EMBEDDABLE_P(len)) { - s = str_init_embed(mrb_obj_alloc_string(mrb), p, len); - } - else { - s = str_init_normal(mrb, mrb_obj_alloc_string(mrb), p, len); - } + s = str_init_modifiable(mrb, mrb_obj_alloc_string(mrb), p, len); return RSTR_PTR(s); } From b6531fa691a08b3380ac3eb59b90086722416556 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Mar 2022 11:42:58 +0900 Subject: [PATCH 113/292] error.h: remove obsolete macro `mrb_exc_new_str_lit()`. --- include/mruby/error.h | 1 - 1 file changed, 1 deletion(-) diff --git a/include/mruby/error.h b/include/mruby/error.h index b53b1bacf..fb3557405 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -26,7 +26,6 @@ struct RException { MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg); MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str); #define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit)) -#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_lit(mrb, c, lit) MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv); mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc); mrb_value mrb_get_backtrace(mrb_state *mrb); From ef3a56c92b6c68da7590cdbbdedd99bdae864b94 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Mar 2022 11:48:31 +0900 Subject: [PATCH 114/292] error.c: (mrb_exc_new) use `mrb_int` instead of `size_t`. --- include/mruby.h | 2 +- src/error.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/mruby.h b/include/mruby.h index bca53003f..7dc1e697d 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1338,7 +1338,7 @@ MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self); #define TOLOWER(c) (ISUPPER(c) ? ((c) | 0x20) : (c)) #endif -MRB_API mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, size_t len); +MRB_API mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, mrb_int len); MRB_API mrb_noreturn void mrb_exc_raise(mrb_state *mrb, mrb_value exc); MRB_API mrb_noreturn void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg); diff --git a/src/error.c b/src/error.c index faea9616d..2b23222c9 100644 --- a/src/error.c +++ b/src/error.c @@ -59,7 +59,7 @@ mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str) } MRB_API mrb_value -mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, size_t len) +mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, mrb_int len) { return mrb_exc_new_str(mrb, c, mrb_str_new(mrb, ptr, len)); } From 85c347c3af4ff36d4ada8ae0dee1561e991c8540 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Mar 2022 14:46:54 +0900 Subject: [PATCH 115/292] codegen.c: fix a bug in `super` with keyword arguments; fix #5660 --- mrbgems/mruby-compiler/core/codegen.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 4d4d6abb7..4a33ec9f4 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2972,7 +2972,7 @@ codegen(codegen_scope *s, node *tree, int val) } } /* keyword arguments */ - if (s2 && (s2->ainfo & 0x1) && tree->cdr->car) { + if (tree->cdr->car) { nk = gen_hash(s, tree->cdr->car->cdr, VAL, 14); if (nk < 0) {st++; nk = 15;} else st += nk*2; From 876bcba69477657104ce09a5f9b5e7f6ca4c8c5d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Mar 2022 16:29:54 +0900 Subject: [PATCH 116/292] string.c: avoid integer type mixture in mrb_str_cat(). --- src/string.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/string.c b/src/string.c index 7cc9c4ff3..e444d8ecf 100644 --- a/src/string.c +++ b/src/string.c @@ -2632,7 +2632,7 @@ mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len) { struct RString *s = mrb_str_ptr(str); mrb_int capa; - size_t total; + mrb_int total; ptrdiff_t off = -1; if (len == 0) return str; From 31d4bbcfea0e216aa2e3b856c0e177802ad84a2d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 4 Mar 2022 14:17:21 +0900 Subject: [PATCH 117/292] string.c: improve size/capacity check before allocations. --- src/string.c | 28 +++++----------------------- 1 file changed, 5 insertions(+), 23 deletions(-) diff --git a/src/string.c b/src/string.c index e444d8ecf..b2247f316 100644 --- a/src/string.c +++ b/src/string.c @@ -129,29 +129,20 @@ str_new(mrb_state *mrb, const char *p, mrb_int len) MRB_API mrb_value mrb_str_new_capa(mrb_state *mrb, mrb_int capa) { - struct RString *s; + struct RString *s = mrb_obj_alloc_string(mrb); if (RSTR_EMBEDDABLE_P(capa)) { - s = str_init_embed(mrb_obj_alloc_string(mrb), NULL, 0); - } - else if (capa >= MRB_SSIZE_MAX) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "string capacity size too big"); - /* not reached */ - s = NULL; + s = str_init_embed(s, NULL, 0); } else { - s = str_init_normal_capa(mrb, mrb_obj_alloc_string(mrb), NULL, 0, capa); + s = str_init_normal_capa(mrb, s, NULL, 0, capa); } - return mrb_obj_value(s); } static void resize_capa(mrb_state *mrb, struct RString *s, mrb_int capacity) { -#if SIZE_MAX > MRB_SSIZE_MAX - mrb_assert(capacity < MRB_SSIZE_MAX); -#endif if (RSTR_EMBED_P(s)) { if (!RSTR_EMBEDDABLE_P(capacity)) { str_init_normal_capa(mrb, s, RSTR_EMBED_PTR(s), RSTR_EMBED_LEN(s), capacity); @@ -2642,23 +2633,14 @@ mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len) } capa = RSTR_CAPA(s); - total = RSTR_LEN(s)+len; - if (total >= MRB_SSIZE_MAX) { + if (mrb_int_add_overflow(RSTR_LEN(s), len, &total)) { size_error: mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big"); } if (capa <= total) { if (capa == 0) capa = 1; while (capa <= total) { - if (capa <= MRB_SSIZE_MAX / 2) { - capa *= 2; - } - else { - capa = total+1; - } - } - if (capa <= total || capa > MRB_SSIZE_MAX) { - goto size_error; + if (mrb_int_mul_overflow(capa, 2, &capa)) goto size_error; } resize_capa(mrb, s, capa); } From bc9476e7caa75e0a258682f4dc3247a00fed5581 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 4 Mar 2022 14:18:20 +0900 Subject: [PATCH 118/292] unpack.c: unpack_BER() did assume the string length is not zero. --- mrbgems/mruby-pack/src/pack.c | 1 + 1 file changed, 1 insertion(+) diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index 1edaac93b..b150f5e16 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -414,6 +414,7 @@ unpack_BER(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, const unsigned char *p = src; const unsigned char *e = p + srclen; + if (srclen == 0) return 0; for (i=1; p (MRB_INT_MAX>>7)) { mrb_raise(mrb, E_RANGE_ERROR, "BER unpacking 'w' overflow"); From 278f46f9716ef9aa41ea163665358cf7dd05e5ee Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 4 Mar 2022 14:19:10 +0900 Subject: [PATCH 119/292] unpack.c: check if srcidx is shorter than srclen for safety. --- mrbgems/mruby-pack/src/pack.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index b150f5e16..dfac9caef 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -1525,7 +1525,7 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single) break; } - while (count != 0) { + while (count != 0 && srcidx < srclen) { if (srclen - srcidx < size) { while (count-- > 0) { mrb_ary_push(mrb, result, mrb_nil_value()); From d6e69ffef89458c6a3e9c661cdc2644174eacaa9 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 4 Mar 2022 14:07:02 +0000 Subject: [PATCH 120/292] build(deps): bump actions/upload-artifact from 2.3.1 to 3 Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 2.3.1 to 3. - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/v2.3.1...v3) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/oss-fuzz.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/oss-fuzz.yml b/.github/workflows/oss-fuzz.yml index da3cc2891..687b807dd 100644 --- a/.github/workflows/oss-fuzz.yml +++ b/.github/workflows/oss-fuzz.yml @@ -16,7 +16,7 @@ jobs: fuzz-seconds: 600 dry-run: false - name: Upload Crash - uses: actions/upload-artifact@v2.3.1 + uses: actions/upload-artifact@v3 if: failure() with: name: artifacts From 7528c25aaeb48e635722e188cb6eb0c1f68f53d1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 4 Mar 2022 14:28:51 +0900 Subject: [PATCH 121/292] string.c: remove unnecessary `mrb_assert_int_fit()`. --- src/string.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/string.c b/src/string.c index b2247f316..b3e159396 100644 --- a/src/string.c +++ b/src/string.c @@ -1210,7 +1210,7 @@ str_replace_partial(mrb_state *mrb, mrb_value src, mrb_int pos, mrb_int end, mrb } replen = (mrb_nil_p(rep) ? 0 : RSTRING_LEN(rep)); - if (mrb_int_add_overflow(replen, len - (end - pos), &newlen) || newlen >= MRB_SSIZE_MAX) { + if (mrb_int_add_overflow(replen, len - (end - pos), &newlen)) { mrb_raise(mrb, E_RUNTIME_ERROR, "string size too big"); } @@ -2648,7 +2648,6 @@ mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len) ptr = RSTR_PTR(s) + off; } memcpy(RSTR_PTR(s) + RSTR_LEN(s), ptr, len); - mrb_assert_int_fit(size_t, total, mrb_ssize, MRB_SSIZE_MAX); RSTR_SET_LEN(s, total); RSTR_PTR(s)[total] = '\0'; /* sentinel */ return str; From 41f5f464ae11e91e30ea3898c1a9fc3597a13811 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 5 Mar 2022 08:01:58 +0900 Subject: [PATCH 122/292] codegen.c: disable constant folding if `no_optimize` is set; ref #5661 --- mrbgems/mruby-compiler/core/codegen.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 4a33ec9f4..3d086de70 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1689,7 +1689,7 @@ static void gen_call(codegen_scope *s, node *tree, int val, int safe) { mrb_sym sym = nsym(tree->cdr->car); - int skip = 0, n = 0, nk = 0, noop = 0, noself = 0, blk = 0, sp_save = cursp(); + int skip = 0, n = 0, nk = 0, noop = no_optimize(s), noself = 0, blk = 0, sp_save = cursp(); if (!tree->car) { noself = noop = 1; From 2dff7ed6a2ccd25e8cfc643a90b5867875c8035d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 5 Mar 2022 08:02:58 +0900 Subject: [PATCH 123/292] mrbc.c: add `--no-optimize` option to disable optimization; close #5661 --- mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c index 7732914d7..9de756dcf 100644 --- a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c +++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c @@ -25,7 +25,8 @@ struct mrbc_args { mrb_bool verbose : 1; mrb_bool remove_lv : 1; mrb_bool no_ext_ops : 1; - uint8_t flags : 4; + mrb_bool no_optimize : 1; + uint8_t flags : 2; }; static void @@ -42,6 +43,7 @@ usage(const char *name) "-s define as static variable", "--remove-lv remove local variables", "--no-ext-ops prohibit using OP_EXTs", + "--no-optimize disable peephole optimization", "--verbose run at verbose mode", "--version print the version", "--copyright print the copyright", @@ -169,6 +171,10 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args) args->no_ext_ops = TRUE; break; } + else if (strcmp(argv[i] + 2, "no-optimize") == 0) { + args->no_optimize = TRUE; + break; + } return -1; default: return i; @@ -224,6 +230,7 @@ load_file(mrb_state *mrb, struct mrbc_args *args) c->dump_result = TRUE; c->no_exec = TRUE; c->no_ext_ops = args->no_ext_ops; + c->no_optimize = args->no_optimize; if (input[0] == '-' && input[1] == '\0') { infile = stdin; } From 9d04183ce146f78394a7168e48106d4468cd56af Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Mar 2022 13:43:31 +0900 Subject: [PATCH 124/292] Small improvements to `Module#{include,prepend}` Array objects obtained as splat arguments are generated within the method. Therefore, it is safe to perform destructive operations. --- mrblib/00class.rb | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/mrblib/00class.rb b/mrblib/00class.rb index d7a718ba1..5bef3f126 100644 --- a/mrblib/00class.rb +++ b/mrblib/00class.rb @@ -22,7 +22,8 @@ class Module # 15.2.2.4.27 def include(*args) - args.reverse.each do |m| + args.reverse! + args.each do |m| m.append_features(self) m.included(self) end @@ -30,7 +31,8 @@ class Module end def prepend(*args) - args.reverse.each do |m| + args.reverse! + args.each do |m| m.prepend_features(self) m.prepended(self) end From ac0d27d1a999fd59d00b4d1490730dc5e5deb79b Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Mar 2022 13:48:04 +0900 Subject: [PATCH 125/292] Reimplement `Kernel.extend` in Ruby --- mrblib/00kernel.rb | 35 ++++++++++++++++++++++++++++++++++ src/kernel.c | 47 ---------------------------------------------- 2 files changed, 35 insertions(+), 47 deletions(-) create mode 100644 mrblib/00kernel.rb diff --git a/mrblib/00kernel.rb b/mrblib/00kernel.rb new file mode 100644 index 000000000..02f3a9981 --- /dev/null +++ b/mrblib/00kernel.rb @@ -0,0 +1,35 @@ +module Kernel + ## + # call-seq: + # obj.extend(module, ...) -> obj + # + # Adds to _obj_ the instance methods from each module given as a + # parameter. + # + # module Mod + # def hello + # "Hello from Mod.\n" + # end + # end + # + # class Klass + # def hello + # "Hello from Klass.\n" + # end + # end + # + # k = Klass.new + # k.hello #=> "Hello from Klass.\n" + # k.extend(Mod) #=> # + # k.hello #=> "Hello from Mod.\n" + # + # ISO 15.3.1.3.13 + def extend(*args) + args.reverse! + args.each do |m| + m.extend_object(self) + m.extended(self) + end + self + end +end diff --git a/src/kernel.c b/src/kernel.c index 3c55fc948..0ed76076b 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -215,52 +215,6 @@ mrb_obj_class_m(mrb_state *mrb, mrb_value self) return mrb_obj_value(mrb_obj_class(mrb, self)); } -/* 15.3.1.3.13 */ -/* - * call-seq: - * obj.extend(module, ...) -> obj - * - * Adds to _obj_ the instance methods from each module given as a - * parameter. - * - * module Mod - * def hello - * "Hello from Mod.\n" - * end - * end - * - * class Klass - * def hello - * "Hello from Klass.\n" - * end - * end - * - * k = Klass.new - * k.hello #=> "Hello from Klass.\n" - * k.extend(Mod) #=> # - * k.hello #=> "Hello from Mod.\n" - */ -static mrb_value -mrb_obj_extend_m(mrb_state *mrb, mrb_value self) -{ - const mrb_value *argv; - mrb_int argc; - - mrb_get_args(mrb, "*", &argv, &argc); - - if (argc == 0) { - mrb_argnum_error(mrb, argc, 1, -1); - } - for (mrb_int i = 0; i < argc; i++) { - mrb_check_type(mrb, argv[i], MRB_TT_MODULE); - } - while (argc--) { - mrb_funcall_id(mrb, argv[argc], MRB_SYM(extend_object), 1, self); - mrb_funcall_id(mrb, argv[argc], MRB_SYM(extended), 1, self); - } - return self; -} - MRB_API mrb_value mrb_obj_freeze(mrb_state *mrb, mrb_value self) { @@ -633,7 +587,6 @@ mrb_init_kernel(mrb_state *mrb) mrb_define_method(mrb, krn, "clone", mrb_obj_clone, MRB_ARGS_NONE()); /* 15.3.1.3.8 */ mrb_define_method(mrb, krn, "dup", mrb_obj_dup, MRB_ARGS_NONE()); /* 15.3.1.3.9 */ mrb_define_method(mrb, krn, "eql?", mrb_obj_equal_m, MRB_ARGS_REQ(1)); /* 15.3.1.3.10 */ - mrb_define_method(mrb, krn, "extend", mrb_obj_extend_m, MRB_ARGS_ANY()); /* 15.3.1.3.13 */ mrb_define_method(mrb, krn, "freeze", mrb_obj_freeze, MRB_ARGS_NONE()); mrb_define_method(mrb, krn, "frozen?", mrb_obj_frozen, MRB_ARGS_NONE()); mrb_define_method(mrb, krn, "hash", mrb_obj_hash, MRB_ARGS_NONE()); /* 15.3.1.3.15 */ From dfddb040635eebc200ba6a4df92ce08cf79d2243 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Mar 2022 15:27:50 +0900 Subject: [PATCH 126/292] Use standardized approach for get build configuration name --- tasks/benchmark.rake | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/tasks/benchmark.rake b/tasks/benchmark.rake index 12e0d4602..271b645f2 100644 --- a/tasks/benchmark.rake +++ b/tasks/benchmark.rake @@ -9,11 +9,8 @@ def bm_files end def build_config_name - if !ENV['MRUBY_CONFIG'].to_s.empty? - File.basename(ENV['MRUBY_CONFIG'], '.rb').gsub('build_config_', '') - else - "bm" - end + path = MRuby::Build.mruby_config_path + File.basename(path, '.rb').gsub('build_config_', '') end def plot_file From e39581242db8f873eea3b3cc95605b35ce4f3d0e Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Mar 2022 15:28:56 +0900 Subject: [PATCH 127/292] Display file paths for benchmark results --- tasks/benchmark.rake | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tasks/benchmark.rake b/tasks/benchmark.rake index 271b645f2..a10718435 100644 --- a/tasks/benchmark.rake +++ b/tasks/benchmark.rake @@ -43,6 +43,8 @@ def plot p.puts "e" end end + + puts "Benchmark results output to #{plot_file}" end From 1f0d265a830469598e68583334cc1f88e6f08103 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Mar 2022 15:29:35 +0900 Subject: [PATCH 128/292] Raise an exception if there is no benchmark target --- tasks/benchmark.rake | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tasks/benchmark.rake b/tasks/benchmark.rake index a10718435..9dbd344e5 100644 --- a/tasks/benchmark.rake +++ b/tasks/benchmark.rake @@ -18,6 +18,8 @@ def plot_file end def plot + raise "no build target to benchmark against" if $dat_files.empty? + opts_file = "#{MRUBY_ROOT}/benchmark/plot.gpl" opts = File.read(opts_file).each_line.to_a.map(&:strip).join(';') From 267dd15767a18b433790117d7c6fc3f77c5a1b83 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 6 Mar 2022 15:35:05 +0900 Subject: [PATCH 129/292] Allow build settings to define if benchmarks are covered or not Each build target can be explicitly disabled from benchmarking with `MRuby::Build#disable_benchmark`. Also, the build target "host", which was previously excluded, is now included in the benchmark. --- lib/mruby/build.rb | 9 +++++++++ tasks/benchmark.rake | 2 +- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/lib/mruby/build.rb b/lib/mruby/build.rb index 66005a6df..771aa7f3e 100644 --- a/lib/mruby/build.rb +++ b/lib/mruby/build.rb @@ -123,6 +123,7 @@ module MRuby @enable_test = false @enable_lock = true @enable_presym = true + @enable_benchmark = true @mrbcfile_external = false @internal = internal @toolchains = [] @@ -232,6 +233,14 @@ module MRuby @cxx_abi_enabled = true end + def benchmark_enabled? + @enable_benchmark + end + + def disable_benchmark + @enable_benchmark = false + end + def compile_as_cxx(src, cxx_src = nil, obj = nil, includes = []) # # If `cxx_src` is specified, this method behaves the same as before as diff --git a/tasks/benchmark.rake b/tasks/benchmark.rake index 9dbd344e5..b32d165bf 100644 --- a/tasks/benchmark.rake +++ b/tasks/benchmark.rake @@ -51,7 +51,7 @@ end MRuby.each_target do |target| - next if target.name == 'host' || target.internal? + next if !target.benchmark_enabled? || target.internal? mruby_bin = "#{target.build_dir}/bin/mruby" bm_files.each do |bm_file| From dc98988482c94f29654b647536bffd632e663bde Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 6 Mar 2022 23:49:40 +0900 Subject: [PATCH 130/292] string.c: small refactoring regarding `check_null_byte`. --- src/string.c | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/src/string.c b/src/string.c index b3e159396..7c97d24fc 100644 --- a/src/string.c +++ b/src/string.c @@ -218,10 +218,9 @@ str_modify_keep_ascii(mrb_state *mrb, struct RString *s) } static void -check_null_byte(mrb_state *mrb, mrb_value str) +check_null_byte(mrb_state *mrb, struct RString *str) { - mrb_ensure_string_type(mrb, str); - if (memchr(RSTRING_PTR(str), '\0', RSTRING_LEN(str))) { + if (memchr(RSTR_PTR(str), '\0', RSTR_LEN(str))) { mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte"); } } @@ -700,15 +699,11 @@ str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos) MRB_API mrb_int mrb_str_strlen(mrb_state *mrb, struct RString *s) { - mrb_int i, max = RSTR_LEN(s); + mrb_int max = RSTR_LEN(s); char *p = RSTR_PTR(s); if (!p) return 0; - for (i=0; i Date: Mon, 7 Mar 2022 13:58:24 +0900 Subject: [PATCH 131/292] string.c: remove unnecessary `goto`. --- src/string.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/string.c b/src/string.c index 7c97d24fc..b1dc1e1e5 100644 --- a/src/string.c +++ b/src/string.c @@ -2304,7 +2304,7 @@ mrb_str_len_to_integer(mrb_state *mrb, const char *str, size_t len, mrb_int base } } if (badcheck && *p == '\0') { - goto nullbyte; + mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte"); } c = conv_digit(*p); if (c < 0 || c >= base) { @@ -2331,9 +2331,6 @@ mrb_str_len_to_integer(mrb_state *mrb, const char *str, size_t len, mrb_int base } return mrb_int_value(mrb, sign ? val : -val); - nullbyte: - mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte"); - /* not reached */ bad: mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid string for number(%!l)", str, pend-str); /* not reached */ From 22a98a0ba7e7ffe3f2f71c2ffa9aaa42d15c3441 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Mar 2022 15:04:07 +0900 Subject: [PATCH 132/292] pack.c: unify duplicated error handling code. --- mrbgems/mruby-pack/src/pack.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index dfac9caef..4f70f9ba4 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -621,6 +621,7 @@ utf8_to_uv(mrb_state *mrb, const char *p, long *lenp) } if (!(uv & 0x40)) { *lenp = 1; + malformed: mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character"); } @@ -631,7 +632,7 @@ utf8_to_uv(mrb_state *mrb, const char *p, long *lenp) else if (!(uv & 0x02)) { n = 6; uv &= 0x01; } else { *lenp = 1; - mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character"); + goto malformed; } if (n > *lenp) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character (expected %d bytes, given %d bytes)", @@ -643,7 +644,7 @@ utf8_to_uv(mrb_state *mrb, const char *p, long *lenp) c = *p++ & 0xff; if ((c & 0xc0) != 0x80) { *lenp -= n + 1; - mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character"); + goto malformed; } else { c &= 0x3f; From 50f357ee5d671786f7a9caf7f28bc0c81b6c9a22 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Mar 2022 15:05:00 +0900 Subject: [PATCH 133/292] mruby-sleep: make error messages consistent. --- mrbgems/mruby-sleep/src/sleep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-sleep/src/sleep.c b/mrbgems/mruby-sleep/src/sleep.c index 79a5af650..d05bc1944 100644 --- a/mrbgems/mruby-sleep/src/sleep.c +++ b/mrbgems/mruby-sleep/src/sleep.c @@ -95,7 +95,7 @@ mrb_f_usleep(mrb_state *mrb, mrb_value self) if (usec >= 0) { usleep(usec); } else { - mrb_raise(mrb, E_ARGUMENT_ERROR, "time interval must not be negative integer"); + mrb_raise(mrb, E_ARGUMENT_ERROR, "time interval must not be negative"); } #ifdef _WIN32 From 2cb82803b3394202c2940a851a1aba388fd3cc49 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Mar 2022 16:13:23 +0900 Subject: [PATCH 134/292] socket.c: reorganize error condition in `mrb_ipsocket_ntop()`. --- mrbgems/mruby-socket/src/socket.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index a002a85a0..5bc95298a 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -518,9 +518,8 @@ mrb_ipsocket_ntop(mrb_state *mrb, mrb_value klass) char buf[50]; mrb_get_args(mrb, "is", &af, &addr, &n); - if ((af == AF_INET && n != 4) || (af == AF_INET6 && n != 16)) - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address"); - if (inet_ntop((int)af, addr, buf, sizeof(buf)) == NULL) + if ((af == AF_INET && n != 4) || (af == AF_INET6 && n != 16) || + inet_ntop((int)af, addr, buf, sizeof(buf)) == NULL) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address"); return mrb_str_new_cstr(mrb, buf); } From 6fa5aaf6941ffc140a0f4abb90fa2185a890edeb Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Mar 2022 16:14:51 +0900 Subject: [PATCH 135/292] socket.c: unify error handling code. --- mrbgems/mruby-socket/src/socket.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 5bc95298a..cd7470121 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -532,8 +532,7 @@ mrb_ipsocket_pton(mrb_state *mrb, mrb_value klass) char buf[50]; mrb_get_args(mrb, "is", &af, &bp, &n); - if ((size_t)n > sizeof(buf) - 1) - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address"); + if ((size_t)n > sizeof(buf) - 1) goto invalid; memcpy(buf, bp, n); buf[n] = '\0'; From 6e964bd1c6b1fcaab0d9fdcb3b87c7567b29d932 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 8 Mar 2022 17:16:49 +0900 Subject: [PATCH 136/292] array.c: check size bound by `ARY_MAX_SIZE` not `MRB_INT_MAX`. --- src/array.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/array.c b/src/array.c index 0f325bab0..b5fe1284e 100644 --- a/src/array.c +++ b/src/array.c @@ -716,7 +716,7 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) mrb_raisef(mrb, E_INDEX_ERROR, "index %i out of array", n - len); } } - if (n == MRB_INT_MAX) { + if (n >= ARY_MAX_SIZE) { mrb_raise(mrb, E_INDEX_ERROR, "index too big"); } if (len <= n) { From da48e7dbb20024c198493b8724adae1b842083aa Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 9 Mar 2022 15:20:13 +0900 Subject: [PATCH 137/292] fiber.c: should pack 15+ arguments in an array. --- mrbgems/mruby-fiber/src/fiber.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/mrbgems/mruby-fiber/src/fiber.c b/mrbgems/mruby-fiber/src/fiber.c index 0d85bedad..322ed36ea 100644 --- a/mrbgems/mruby-fiber/src/fiber.c +++ b/mrbgems/mruby-fiber/src/fiber.c @@ -208,15 +208,22 @@ fiber_switch(mrb_state *mrb, mrb_value self, mrb_int len, const mrb_value *a, mr if (!c->ci->proc) { mrb_raise(mrb, E_FIBER_ERROR, "double resume (current)"); } - mrb_stack_extend(mrb, len+2); /* for receiver and (optional) block */ - b = c->stbase+1; - e = b + len; - while (bci--; /* pop dummy callinfo */ } + if (len >= 15) { + mrb_stack_extend(mrb, 3); /* for receiver, args and (optional) block */ + c->stbase[1] = mrb_ary_new_from_values(mrb, len, a); + len = 15; + } + else { + mrb_stack_extend(mrb, len+2); /* for receiver and (optional) block */ + b = c->stbase+1; + e = b + len; + while (bcibase->n = len; value = c->stbase[0] = MRB_PROC_ENV(c->cibase->proc)->stack[0]; } From 6ca1e5c8e0c5cbb938ec6017215895a061e5a755 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 9 Mar 2022 17:14:57 +0900 Subject: [PATCH 138/292] kernel.c: use preallocated symbol. --- src/kernel.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/kernel.c b/src/kernel.c index 0ed76076b..18640ab5c 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -542,7 +542,7 @@ mrb_obj_ceqq(mrb_state *mrb, mrb_value self) return mrb_false_value(); } else { - ary = mrb_funcall(mrb, self, "to_a", 0); + ary = mrb_funcall_id(mrb, self, MRB_SYM(to_a), 0); if (mrb_nil_p(ary)) { return mrb_funcall_argv(mrb, self, eqq, 1, &v); } From 0293037b218e178ac10e2e5b96e67102423474f9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 10 Mar 2022 10:43:22 +0900 Subject: [PATCH 139/292] proc.c: refactor proc type checking. --- src/proc.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/src/proc.c b/src/proc.c index abace39de..769323950 100644 --- a/src/proc.c +++ b/src/proc.c @@ -237,14 +237,20 @@ mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class) return proc; } +static void +check_proc(mrb_state *mrb, mrb_value proc) +{ + if (!mrb_proc_p(proc)) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "not a proc"); + } +} + static mrb_value mrb_proc_init_copy(mrb_state *mrb, mrb_value self) { mrb_value proc = mrb_get_arg1(mrb); - if (!mrb_proc_p(proc)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "not a proc"); - } + check_proc(mrb, proc); mrb_proc_copy(mrb, mrb_proc_ptr(self), mrb_proc_ptr(proc)); return self; } @@ -275,9 +281,7 @@ proc_lambda(mrb_state *mrb, mrb_value self) if (mrb_nil_p(blk)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block"); } - if (!mrb_proc_p(blk)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "not a proc"); - } + check_proc(mrb, blk); p = mrb_proc_ptr(blk); if (!MRB_PROC_STRICT_P(p)) { struct RProc *p2 = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, p->c); From b3416832f4c070396a0c848f86890bb1a5786259 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 10 Mar 2022 10:43:51 +0900 Subject: [PATCH 140/292] vm.c: refactor block type checking. --- src/vm.c | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/src/vm.c b/src/vm.c index 09f524a9d..8b81031a3 100644 --- a/src/vm.c +++ b/src/vm.c @@ -736,6 +736,17 @@ mrb_f_send(mrb_state *mrb, mrb_value self) return exec_irep(mrb, self, MRB_METHOD_PROC(m)); } +static void +check_block(mrb_state *mrb, mrb_value blk) +{ + if (mrb_nil_p(blk)) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given"); + } + if (!mrb_proc_p(blk)) { + mrb_raise(mrb, E_TYPE_ERROR, "not a block"); + } +} + static mrb_value eval_under(mrb_state *mrb, mrb_value self, mrb_value blk, struct RClass *c) { @@ -743,9 +754,7 @@ eval_under(mrb_state *mrb, mrb_value self, mrb_value blk, struct RClass *c) mrb_callinfo *ci; int nregs; - if (mrb_nil_p(blk)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given"); - } + check_block(mrb, blk); ci = mrb->c->ci; if (ci->cci == CINFO_DIRECT) { return mrb_yield_with_class(mrb, blk, 1, &self, self, c); @@ -836,9 +845,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value mrb_value val; mrb_int n; - if (mrb_nil_p(b)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given"); - } + check_block(mrb, b); ci = mrb->c->ci; n = mrb_ci_nregs(ci); p = mrb_proc_ptr(b); @@ -896,13 +903,7 @@ mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const struct RProc *p; mrb_callinfo *ci; - if (mrb_nil_p(b)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given"); - } - if (!mrb_proc_p(b)) { - mrb_raise(mrb, E_TYPE_ERROR, "not a block"); - } - + check_block(mrb, b); p = mrb_proc_ptr(b); ci = mrb->c->ci; From 55476efb62b8638d2be1d0086adc9faeda184e6c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 11 Mar 2022 10:25:32 +0900 Subject: [PATCH 141/292] error.c: use `mrb_funcall_id` and presym to call `_sys_fail` method. --- src/error.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/error.c b/src/error.c index 2b23222c9..46d26bece 100644 --- a/src/error.c +++ b/src/error.c @@ -544,10 +544,10 @@ mrb_sys_fail(mrb_state *mrb, const char *mesg) if (mrb_class_defined_id(mrb, MRB_SYM(SystemCallError))) { sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError)); if (mesg != NULL) { - mrb_funcall(mrb, mrb_obj_value(sce), "_sys_fail", 2, mrb_fixnum_value(no), mrb_str_new_cstr(mrb, mesg)); + mrb_funcall_id(mrb, mrb_obj_value(sce), MRB_SYM(_sys_fail), 2, mrb_fixnum_value(no), mrb_str_new_cstr(mrb, mesg)); } else { - mrb_funcall(mrb, mrb_obj_value(sce), "_sys_fail", 1, mrb_fixnum_value(no)); + mrb_funcall_id(mrb, mrb_obj_value(sce), MRB_SYM(_sys_fail), 1, mrb_fixnum_value(no)); } } else { From 10001ff67fbf750c4de53abb016c1671e3fb54c2 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 08:35:07 +0900 Subject: [PATCH 142/292] rational.c, complex.c: expose arithmetic operation functions. * mrb_{rational,complex}_{add,sub,mul,div} --- mrbgems/mruby-complex/src/complex.c | 40 +++++++++++++++++++++------ mrbgems/mruby-rational/src/rational.c | 32 ++++++++++++++++----- 2 files changed, 57 insertions(+), 15 deletions(-) diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 17bd40d94..472609c39 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -168,10 +168,9 @@ complex_eq(mrb_state *mrb, mrb_value x) return mrb_bool_value(mrb_complex_eq(mrb, x, y)); } -static mrb_value -complex_add(mrb_state *mrb, mrb_value x) +mrb_value +mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y) { - mrb_value y = mrb_get_arg1(mrb); struct mrb_complex *p1 = complex_ptr(mrb, x); switch (mrb_type(y)) { @@ -190,9 +189,15 @@ complex_add(mrb_state *mrb, mrb_value x) } static mrb_value -complex_sub(mrb_state *mrb, mrb_value x) +complex_add(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); + return mrb_complex_add(mrb, x, y); +} + +mrb_value +mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y) +{ struct mrb_complex *p1 = complex_ptr(mrb, x); switch (mrb_type(y)) { @@ -211,9 +216,15 @@ complex_sub(mrb_state *mrb, mrb_value x) } static mrb_value -complex_mul(mrb_state *mrb, mrb_value x) +complex_sub(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); + return mrb_complex_sub(mrb, x, y); +} + +mrb_value +mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y) +{ struct mrb_complex *p1 = complex_ptr(mrb, x); switch (mrb_type(y)) { @@ -232,6 +243,13 @@ complex_mul(mrb_state *mrb, mrb_value x) } } +static mrb_value +complex_mul(mrb_state *mrb, mrb_value x) +{ + mrb_value y = mrb_get_arg1(mrb); + return mrb_complex_mul(mrb, x, y); +} + /* Arithmetic on (significand, exponent) pairs avoids premature overflow in complex division */ struct float_pair { @@ -272,11 +290,10 @@ div_pair(struct float_pair *q, struct float_pair const *a, q->x = a->x - b->x; } -static mrb_value -complex_div(mrb_state *mrb, mrb_value self) +mrb_value +mrb_complex_div(mrb_state *mrb, mrb_value self, mrb_value rhs) { struct mrb_complex *a, *b; - mrb_value rhs = mrb_get_arg1(mrb); a = complex_ptr(mrb, self); if (mrb_type(rhs) != MRB_TT_COMPLEX) { @@ -324,6 +341,13 @@ complex_div(mrb_state *mrb, mrb_value self) return complex_new(mrb, F(ldexp)(zr.s, zr.x), F(ldexp)(zi.s, zi.x)); } +static mrb_value +complex_div(mrb_state *mrb, mrb_value x) +{ + mrb_value y = mrb_get_arg1(mrb); + return mrb_complex_div(mrb, x, y); +} + mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y); mrb_value mrb_rational_new(mrb_state *mrb, mrb_int n, mrb_int d); mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y); diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index ff9b6bd91..e77b6410e 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -479,11 +479,10 @@ rational_minus(mrb_state *mrb, mrb_value x) return rational_new(mrb, -n, p->denominator); } -static mrb_value -rational_add(mrb_state *mrb, mrb_value x) +mrb_value +mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y) { struct mrb_rational *p1 = rational_ptr(mrb, x); - mrb_value y = mrb_get_arg1(mrb); switch (mrb_type(y)) { case MRB_TT_INTEGER: @@ -519,10 +518,16 @@ rational_add(mrb_state *mrb, mrb_value x) } static mrb_value -rational_sub(mrb_state *mrb, mrb_value x) +rational_add(mrb_state *mrb, mrb_value x) +{ + mrb_value y = mrb_get_arg1(mrb); + return mrb_rational_add(mrb, x, y); +} + +mrb_value +mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y) { struct mrb_rational *p1 = rational_ptr(mrb, x); - mrb_value y = mrb_get_arg1(mrb); switch (mrb_type(y)) { case MRB_TT_INTEGER: @@ -565,10 +570,16 @@ rational_sub(mrb_state *mrb, mrb_value x) } static mrb_value -rational_mul(mrb_state *mrb, mrb_value x) +rational_sub(mrb_state *mrb, mrb_value x) +{ + mrb_value y = mrb_get_arg1(mrb); + return mrb_rational_sub(mrb, x, y); +} + +mrb_value +mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y) { struct mrb_rational *p1 = rational_ptr(mrb, x); - mrb_value y = mrb_get_arg1(mrb); switch (mrb_type(y)) { case MRB_TT_INTEGER: @@ -600,6 +611,13 @@ rational_mul(mrb_state *mrb, mrb_value x) } } +static mrb_value +rational_mul(mrb_state *mrb, mrb_value x) +{ + mrb_value y = mrb_get_arg1(mrb); + return mrb_rational_mul(mrb, x, y); +} + mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y) { From 5636e6ab54cecb6584478ce8afe1fa9893596a3d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 08:42:50 +0900 Subject: [PATCH 143/292] numeric.c: rename and expose integer arithmetic functions. * mrb_int_add() * mrb_int_sub() * mrb_int_mul() --- src/numeric.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/numeric.c b/src/numeric.c index 7a6f8d765..4e0485369 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -991,8 +991,8 @@ int_to_i(mrb_state *mrb, mrb_value num) return num; } -static mrb_value -fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y) +mrb_value +mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y) { mrb_int a; @@ -1026,7 +1026,7 @@ MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) { if (mrb_integer_p(x)) { - return fixnum_mul(mrb, x, y); + return mrb_int_mul(mrb, x, y); } #ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { @@ -1061,7 +1061,7 @@ int_mul(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); - return fixnum_mul(mrb, x, y); + return mrb_int_mul(mrb, x, y); } static void @@ -1432,8 +1432,8 @@ mrb_float_to_integer(mrb_state *mrb, mrb_value x) } #endif -static mrb_value -int_plus(mrb_state *mrb, mrb_value x, mrb_value y) +mrb_value +mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y) { mrb_int a; @@ -1467,7 +1467,7 @@ MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) { if (mrb_integer_p(x)) { - return int_plus(mrb, x, y); + return mrb_int_add(mrb, x, y); } #ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { @@ -1501,11 +1501,11 @@ int_add(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); - return int_plus(mrb, self, other); + return mrb_int_add(mrb, self, other); } -static mrb_value -int_minus(mrb_state *mrb, mrb_value x, mrb_value y) +mrb_value +mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y) { mrb_int a; @@ -1539,7 +1539,7 @@ MRB_API mrb_value mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) { if (mrb_integer_p(x)) { - return int_minus(mrb, x, y); + return mrb_int_sub(mrb, x, y); } #ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { @@ -1574,7 +1574,7 @@ int_sub(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); - return int_minus(mrb, self, other); + return mrb_int_sub(mrb, self, other); } MRB_API char* From a20064bcb75abd85c094f866d362bc45b207e135 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 08:47:48 +0900 Subject: [PATCH 144/292] numops.c: separate API functions not used from mruby. * mrb_num_plus() * mrb_num_minus() * mrb_num_mul() --- src/numeric.c | 72 -------------------------------------- src/numops.c | 95 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 95 insertions(+), 72 deletions(-) create mode 100644 src/numops.c diff --git a/src/numeric.c b/src/numeric.c index 4e0485369..25bb8ab74 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1022,30 +1022,6 @@ mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y) } } -MRB_API mrb_value -mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) -{ - if (mrb_integer_p(x)) { - return mrb_int_mul(mrb, x, y); - } -#ifndef MRB_NO_FLOAT - if (mrb_float_p(x)) { - return mrb_float_value(mrb, mrb_float(x) * mrb_as_float(mrb, y)); - } -#endif -#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) - switch (mrb_type(x)) { - case MRB_TT_RATIONAL: - case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, x, MRB_OPSYM(mul), 1, y); - default: - break; - } -#endif - mrb_raise(mrb, E_TYPE_ERROR, "no number multiply"); - return mrb_nil_value(); /* not reached */ -} - /* 15.2.8.3.3 */ /* * call-seq: @@ -1463,30 +1439,6 @@ mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y) } } -MRB_API mrb_value -mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) -{ - if (mrb_integer_p(x)) { - return mrb_int_add(mrb, x, y); - } -#ifndef MRB_NO_FLOAT - if (mrb_float_p(x)) { - return mrb_float_value(mrb, mrb_float(x) + mrb_as_float(mrb, y)); - } -#endif -#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) - switch (mrb_type(x)) { - case MRB_TT_RATIONAL: - case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, x, MRB_OPSYM(add), 1, y); - default: - break; - } -#endif - mrb_raise(mrb, E_TYPE_ERROR, "no number addition"); - return mrb_nil_value(); /* not reached */ -} - /* 15.2.8.3.1 */ /* * call-seq: @@ -1535,30 +1487,6 @@ mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y) } } -MRB_API mrb_value -mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) -{ - if (mrb_integer_p(x)) { - return mrb_int_sub(mrb, x, y); - } -#ifndef MRB_NO_FLOAT - if (mrb_float_p(x)) { - return mrb_float_value(mrb, mrb_float(x) - mrb_as_float(mrb, y)); - } -#endif -#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) - switch (mrb_type(x)) { - case MRB_TT_RATIONAL: - case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, x, MRB_OPSYM(sub), 1, y); - default: - break; - } -#endif - mrb_raise(mrb, E_TYPE_ERROR, "no number subtraction"); - return mrb_nil_value(); /* not reached */ -} - /* 15.2.8.3.2 */ /* 15.2.8.3.16 */ /* diff --git a/src/numops.c b/src/numops.c new file mode 100644 index 000000000..7973cfd02 --- /dev/null +++ b/src/numops.c @@ -0,0 +1,95 @@ +/* +** numeric.c - Numeric, Integer, Float class +** +** See Copyright Notice in mruby.h +*/ + +#include +#include +#include + +mrb_value mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y); + +mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); +mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y); + +mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y); + +MRB_API mrb_value +mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) +{ + if (mrb_integer_p(x)) { + return mrb_int_add(mrb, x, y); + } +#ifndef MRB_NO_FLOAT + if (mrb_float_p(x)) { + return mrb_float_value(mrb, mrb_float(x) + mrb_as_float(mrb, y)); + } +#endif +#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) + switch (mrb_type(x)) { + case MRB_TT_RATIONAL: + case MRB_TT_COMPLEX: + return mrb_funcall_id(mrb, x, MRB_OPSYM(add), 1, y); + default: + break; + } +#endif + mrb_raise(mrb, E_TYPE_ERROR, "no number addition"); + return mrb_nil_value(); /* not reached */ +} + +MRB_API mrb_value +mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) +{ + if (mrb_integer_p(x)) { + return mrb_int_sub(mrb, x, y); + } +#ifndef MRB_NO_FLOAT + if (mrb_float_p(x)) { + return mrb_float_value(mrb, mrb_float(x) - mrb_as_float(mrb, y)); + } +#endif +#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) + switch (mrb_type(x)) { + case MRB_TT_RATIONAL: + case MRB_TT_COMPLEX: + return mrb_funcall_id(mrb, x, MRB_OPSYM(sub), 1, y); + default: + break; + } +#endif + mrb_raise(mrb, E_TYPE_ERROR, "no number subtraction"); + return mrb_nil_value(); /* not reached */ +} + +MRB_API mrb_value +mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) +{ + if (mrb_integer_p(x)) { + return mrb_int_mul(mrb, x, y); + } +#ifndef MRB_NO_FLOAT + if (mrb_float_p(x)) { + return mrb_float_value(mrb, mrb_float(x) * mrb_as_float(mrb, y)); + } +#endif +#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) + switch (mrb_type(x)) { + case MRB_TT_RATIONAL: + case MRB_TT_COMPLEX: + return mrb_funcall_id(mrb, x, MRB_OPSYM(mul), 1, y); + default: + break; + } +#endif + mrb_raise(mrb, E_TYPE_ERROR, "no number multiply"); + return mrb_nil_value(); /* not reached */ +} From b0d6413f2d4dfdd75606159ca315fb3c6d6c1ddd Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 08:53:57 +0900 Subject: [PATCH 145/292] numops.c: rename functions for addition and subtraction. To more consistent names. * mrb_num_plus() -> mrb_num_add() * mrb_num_minus() -> mrb_num_sub() Since no one seems to use those functions, there should be no problem. We added migration macros for compatibility for safety. --- include/mruby/numeric.h | 8 ++++++-- src/numops.c | 4 ++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index aec46413c..99b642172 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -30,9 +30,13 @@ MRB_BEGIN_DECL #endif #endif -MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y); -MRB_API mrb_value mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y); +/* utility functions */ +MRB_API mrb_value mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y); +MRB_API mrb_value mrb_num_sub(mrb_state *mrb, mrb_value x, mrb_value y); MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y); +/* obsolete old names */ +#define mrb_num_plus(mrb, x, y) mrb_num_add(mrb, x, y) +#define mrb_num_minus(mrb, x, y) mrb_num_sub(mrb, x, y) MRB_API mrb_value mrb_integer_to_str(mrb_state *mrb, mrb_value x, mrb_int base); MRB_API char *mrb_int_to_cstr(char *buf, size_t len, mrb_int n, mrb_int base); diff --git a/src/numops.c b/src/numops.c index 7973cfd02..8ea1cccc2 100644 --- a/src/numops.c +++ b/src/numops.c @@ -23,7 +23,7 @@ mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y); MRB_API mrb_value -mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) +mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y) { if (mrb_integer_p(x)) { return mrb_int_add(mrb, x, y); @@ -47,7 +47,7 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) } MRB_API mrb_value -mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) +mrb_num_sub(mrb_state *mrb, mrb_value x, mrb_value y) { if (mrb_integer_p(x)) { return mrb_int_sub(mrb, x, y); From 7659b3b27199c4458bd3ccd833d8182a745ada10 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 10:09:30 +0900 Subject: [PATCH 146/292] numeric.c: avoid `mrb_funcall`; call functions directly. When you try to call functions defined in mrbgems, you need to add the names of functions to `mrbc.c`, since `mrbc` does not link any mrbgem regardless of the configuration. --- mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c | 51 +++++++++++++++++++----- src/numeric.c | 39 +++++++++++++----- 2 files changed, 69 insertions(+), 21 deletions(-) diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c index 9de756dcf..aae91b285 100644 --- a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c +++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c @@ -374,30 +374,61 @@ mrb_final_mrbgems(mrb_state *mrb) } #endif +/* + functions defined in mrbgems referenced from the core should be listed here + to avoid link errors, since mrbc does not link any mrbgem ignoring configuration. +*/ + #ifdef MRB_USE_COMPLEX -mrb_value mrb_complex_to_i(mrb_state *mrb, mrb_value comp) +mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y) { - /* dummy method */ return mrb_nil_value(); } -mrb_value mrb_complex_to_f(mrb_state *mrb, mrb_value comp) +mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_to_i(mrb_state *mrb, mrb_value x) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_to_f(mrb_state *mrb, mrb_value x) { - /* dummy method */ return mrb_nil_value(); } #endif #ifdef MRB_USE_RATIONAL -mrb_value -mrb_rational_to_i(mrb_state *mrb, mrb_value rat) +mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y) { - /* dummy method */ return mrb_nil_value(); } -mrb_value -mrb_rational_to_f(mrb_state *mrb, mrb_value rat) +mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_to_i(mrb_state *mrb, mrb_value x) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_to_f(mrb_state *mrb, mrb_value x) { - /* dummy method */ return mrb_nil_value(); } #endif diff --git a/src/numeric.c b/src/numeric.c index 25bb8ab74..45b37451e 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -20,6 +20,16 @@ #endif #endif +mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); +mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y); + +mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y); + static void int_overflow(mrb_state *mrb, const char *reason) { @@ -328,7 +338,7 @@ flo_add(mrb_state *mrb, mrb_value x) return mrb_float_value(mrb, a + mrb_float(y)); #if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, y, MRB_OPSYM(add), 1, x); + return mrb_complex_add(mrb, y, x); #endif default: return mrb_float_value(mrb, a + mrb_as_float(mrb, y)); @@ -355,8 +365,7 @@ flo_sub(mrb_state *mrb, mrb_value x) return mrb_float_value(mrb, a - mrb_float(y)); #if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - x = mrb_funcall_id(mrb, y, MRB_OPSYM(sub), 1, x); - return mrb_funcall_id(mrb, x, MRB_OPSYM(minus), 0); + return mrb_complex_sub(mrb, mrb_complex_new(mrb, a, 0), y); #endif default: return mrb_float_value(mrb, a - mrb_as_float(mrb, y)); @@ -383,7 +392,7 @@ flo_mul(mrb_state *mrb, mrb_value x) return mrb_float_value(mrb, a * mrb_float(y)); #if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, y, MRB_OPSYM(mul), 1, x); + return mrb_complex_mul(mrb, y, x); #endif default: return mrb_float_value(mrb, a * mrb_as_float(mrb, y)); @@ -1008,10 +1017,13 @@ mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y) return mrb_int_value(mrb, c); } switch (mrb_type(y)) { -#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) +#if defined(MRB_USE_RATIONAL) case MRB_TT_RATIONAL: + return mrb_rational_mul(mrb, y, x); +#endif +#if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, y, MRB_OPSYM(mul), 1, x); + return mrb_complex_mul(mrb, y, x); #endif default: #ifdef MRB_NO_FLOAT @@ -1425,10 +1437,13 @@ mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y) return mrb_int_value(mrb, c); } switch (mrb_type(y)) { -#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) +#if defined(MRB_USE_RATIONAL) case MRB_TT_RATIONAL: + return mrb_rational_add(mrb, y, x); +#endif +#if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, y, MRB_OPSYM(add), 1, x); + return mrb_complex_add(mrb, y, x); #endif default: #ifdef MRB_NO_FLOAT @@ -1472,11 +1487,13 @@ mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y) return mrb_int_value(mrb, c); } switch (mrb_type(y)) { -#if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) +#if defined(MRB_USE_RATIONAL) case MRB_TT_RATIONAL: + return mrb_rational_sub(mrb, mrb_rational_new(mrb, a, 1), y); +#endif +#if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - x = mrb_funcall_id(mrb, y, MRB_OPSYM(sub), 1, x); - return mrb_funcall_id(mrb, x, MRB_OPSYM(minus), 0); + return mrb_complex_sub(mrb, mrb_complex_new(mrb, (mrb_float)a, 0), y); #endif default: #ifdef MRB_NO_FLOAT From 062c2128a3a31aa3dd9e7b630cbd4fb4f996b3f0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 10:25:29 +0900 Subject: [PATCH 147/292] numops.c: avoid `mrb_funcall`; call functions directly. --- src/numops.c | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/src/numops.c b/src/numops.c index 8ea1cccc2..97fa81186 100644 --- a/src/numops.c +++ b/src/numops.c @@ -35,9 +35,14 @@ mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y) #endif #if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) switch (mrb_type(x)) { +#if defined(MRB_USE_RATIONAL) case MRB_TT_RATIONAL: + return mrb_rational_add(mrb, x, y); +#endif +#if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, x, MRB_OPSYM(add), 1, y); + return mrb_complex_add(mrb, x, y); +#endif default: break; } @@ -59,9 +64,14 @@ mrb_num_sub(mrb_state *mrb, mrb_value x, mrb_value y) #endif #if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) switch (mrb_type(x)) { +#if defined(MRB_USE_RATIONAL) case MRB_TT_RATIONAL: + return mrb_rational_sub(mrb, x, y); +#endif +#if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, x, MRB_OPSYM(sub), 1, y); + return mrb_complex_sub(mrb, x, y); +#endif default: break; } @@ -83,9 +93,14 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) #endif #if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) switch (mrb_type(x)) { +#if defined(MRB_USE_RATIONAL) case MRB_TT_RATIONAL: + return mrb_rational_mul(mrb, x, y); +#endif +#if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - return mrb_funcall_id(mrb, x, MRB_OPSYM(mul), 1, y); + return mrb_complex_mul(mrb, x, y); +#endif default: break; } From 2772e07dc8087b614ab6610b4a31149b9fec7ee9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 10:40:13 +0900 Subject: [PATCH 148/292] rational.c: avoid `mrb_funcall`; call functions directly. --- mrbgems/mruby-rational/src/rational.c | 33 +++++++++++++++------------ 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index e77b6410e..0730c3ecb 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -3,6 +3,13 @@ #include #include +mrb_value mrb_complex_new(mrb_state *, mrb_float, mrb_float); +mrb_bool mrb_complex_eq(mrb_state *mrb, mrb_value, mrb_value); +mrb_value mrb_complex_add(mrb_state *mrb, mrb_value, mrb_value); +mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value, mrb_value); +mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value, mrb_value); +mrb_value mrb_complex_div(mrb_state *mrb, mrb_value, mrb_value); + struct mrb_rational { mrb_int numerator; mrb_int denominator; @@ -393,7 +400,6 @@ rational_eq(mrb_state *mrb, mrb_value x) #ifdef MRB_USE_COMPLEX case MRB_TT_COMPLEX: { - mrb_bool mrb_complex_eq(mrb_state *mrb, mrb_value, mrb_value); result = mrb_complex_eq(mrb, y, mrb_rational_to_f(mrb, x)); break; } @@ -405,10 +411,6 @@ rational_eq(mrb_state *mrb, mrb_value x) return mrb_bool_value(result); } -#ifndef MRB_NO_FLOAT -mrb_value mrb_complex_new(mrb_state *, mrb_float, mrb_float); -#endif - static mrb_value rational_cmp(mrb_state *mrb, mrb_value x) { @@ -454,11 +456,6 @@ rational_cmp(mrb_state *mrb, mrb_value x) return mrb_fixnum_value(-1); return mrb_fixnum_value(0); } -#endif -#ifdef MRB_USE_COMPLEX - case MRB_TT_COMPLEX: - x = mrb_complex_new(mrb, rat_float(p1), 0); - return mrb_funcall_id(mrb, x, MRB_OPSYM(cmp), 1, y); #endif default: x = mrb_funcall_id(mrb, y, MRB_OPSYM(cmp), 1, x); @@ -512,6 +509,11 @@ mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y) } #endif +#if defined(MRB_USE_COMPLEX) + case MRB_TT_COMPLEX: + return mrb_complex_add(mrb, mrb_complex_new(mrb, rat_float(p1), 0), y); +#endif + default: return mrb_funcall_id(mrb, y, MRB_OPSYM(add), 1, x); } @@ -551,8 +553,7 @@ mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y) #if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - x = mrb_complex_new(mrb, rat_float(p1), 0); - return mrb_funcall_id(mrb, x, MRB_OPSYM(sub), 1, y); + return mrb_complex_sub(mrb, mrb_complex_new(mrb, rat_float(p1), 0), y); #endif #ifndef MRB_NO_FLOAT @@ -606,6 +607,11 @@ mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y) } #endif +#if defined(MRB_USE_COMPLEX) + case MRB_TT_COMPLEX: + return mrb_complex_mul(mrb, mrb_complex_new(mrb, rat_float(p1), 0), y); +#endif + default: return mrb_funcall_id(mrb, y, MRB_OPSYM(mul), 1, x); } @@ -642,8 +648,7 @@ mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y) #if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - x = mrb_complex_new(mrb, rat_float(p1), 0); - return mrb_funcall_id(mrb, x, MRB_OPSYM(div), 1, y); + return mrb_complex_div(mrb, mrb_complex_new(mrb, rat_float(p1), 0), y); #endif default: From 4beebc73a726f304f905e24c6251b57073d933bf Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 10:48:50 +0900 Subject: [PATCH 149/292] complex.c: avoid `mrb_funcall`; call functions directly. --- mrbgems/mruby-complex/src/complex.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 472609c39..31c0abe89 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -393,8 +393,7 @@ cpx_int_quo(mrb_state *mrb, mrb_value x) switch (mrb_type(y)) { #ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: - x = mrb_rational_new(mrb, a, 1); - return mrb_funcall_id(mrb, x, MRB_OPSYM(div), 1, y); + return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1), y); #endif case MRB_TT_COMPLEX: x = complex_new(mrb, (mrb_float)a, 0); From a2e90052869e5c9bc1337d422f7b8e699e861b7c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 12 Mar 2022 13:31:46 +0900 Subject: [PATCH 150/292] parse.y: add type cast to integer comparison. --- mrbgems/mruby-compiler/core/parse.y | 2 +- mrbgems/mruby-compiler/core/y.tab.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 3496b36d0..9e3f35bd7 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -6941,7 +6941,7 @@ mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrbc_context *c) binsize = bin_to_uint32(leading.h.binary_size); bin_obj = mrb_str_new(mrb, NULL, binsize); bin = (uint8_t *)RSTRING_PTR(bin_obj); - if (binsize > bufsize) { + if ((size_t)binsize > bufsize) { memcpy(bin, leading.b, bufsize); if (fread(bin + bufsize, binsize - bufsize, 1, fp) == 0) { binsize = bufsize; diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 429c2209b..2ba45e94e 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -13172,7 +13172,7 @@ mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrbc_context *c) binsize = bin_to_uint32(leading.h.binary_size); bin_obj = mrb_str_new(mrb, NULL, binsize); bin = (uint8_t *)RSTRING_PTR(bin_obj); - if (binsize > bufsize) { + if ((size_t)binsize > bufsize) { memcpy(bin, leading.b, bufsize); if (fread(bin + bufsize, binsize - bufsize, 1, fp) == 0) { binsize = bufsize; From 34048abcfcd15578b2daede56aeb2bbf7d209e6a Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 13 Mar 2022 14:56:56 +0900 Subject: [PATCH 151/292] Correct truncated `SystemStackError` [ci skip] --- include/mruby.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mruby.h b/include/mruby.h index 7dc1e697d..8a0396753 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -312,7 +312,7 @@ typedef struct mrb_state { struct RClass *eException_class; struct RClass *eStandardError_class; struct RObject *nomem_err; /* pre-allocated NoMemoryError */ - struct RObject *stack_err; /* pre-allocated SysStackError */ + struct RObject *stack_err; /* pre-allocated SystemStackError */ #ifdef MRB_GC_FIXED_ARENA struct RObject *arena_err; /* pre-allocated arena overflow error */ #endif From c3eac4fe5cd623a8d19da5149cd07f04d31d038e Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 13 Mar 2022 16:28:43 +0900 Subject: [PATCH 152/292] No need to protect red objects The object in `GC_RED` does not need to be marked, and the objects connected to this object should also not need to be marked. --- src/gc.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/gc.c b/src/gc.c index a6ff0c588..b0885a307 100644 --- a/src/gc.c +++ b/src/gc.c @@ -448,6 +448,7 @@ mrb_gc_destroy(mrb_state *mrb, mrb_gc *gc) static void gc_protect(mrb_state *mrb, mrb_gc *gc, struct RBasic *p) { + if (is_red(p)) return; #ifdef MRB_GC_FIXED_ARENA if (gc->arena_idx >= MRB_GC_ARENA_SIZE) { /* arena overflow error */ From 98d90d83ccd8edb0d3c1a877173a7c7174a8a3fb Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 13 Mar 2022 16:45:20 +0900 Subject: [PATCH 153/292] Change function name `mrb_bob_init` to `mrb_do_nothing` This is because it is not limited to the `BasicObject#initialize` method. --- src/class.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/class.c b/src/class.c index 0c15fbf42..09ce57832 100644 --- a/src/class.c +++ b/src/class.c @@ -545,7 +545,7 @@ mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super) return mrb_define_class_id(mrb, mrb_intern_cstr(mrb, name), super); } -static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value); +static mrb_value mrb_do_nothing(mrb_state *mrb, mrb_value); #ifndef MRB_NO_METHOD_CACHE static void mc_clear(mrb_state *mrb); #else @@ -564,7 +564,7 @@ mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass) s = mrb_obj_value(super); mrb_mc_clear_by_class(mrb, klass); mid = MRB_SYM(inherited); - if (!mrb_func_basic_p(mrb, s, mid, mrb_bob_init)) { + if (!mrb_func_basic_p(mrb, s, mid, mrb_do_nothing)) { mrb_value c = mrb_obj_value(klass); mrb_funcall_argv(mrb, s, mid, 1, &c); } @@ -1971,7 +1971,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv) mrb_get_args(mrb, "*!&", &argv, &argc, &blk); obj = mrb_instance_alloc(mrb, cv); init = MRB_SYM(initialize); - if (!mrb_func_basic_p(mrb, obj, init, mrb_bob_init)) { + if (!mrb_func_basic_p(mrb, obj, init, mrb_do_nothing)) { mrb_funcall_with_block(mrb, obj, init, argc, argv, blk); } return obj; @@ -1985,7 +1985,7 @@ mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *arg obj = mrb_instance_alloc(mrb, mrb_obj_value(c)); mid = MRB_SYM(initialize); - if (!mrb_func_basic_p(mrb, obj, mid, mrb_bob_init)) { + if (!mrb_func_basic_p(mrb, obj, mid, mrb_do_nothing)) { mrb_funcall_argv(mrb, obj, mid, argc, argv); } return obj; @@ -2042,7 +2042,7 @@ mrb_class_superclass(mrb_state *mrb, mrb_value klass) } static mrb_value -mrb_bob_init(mrb_state *mrb, mrb_value cv) +mrb_do_nothing(mrb_state *mrb, mrb_value cv) { return mrb_nil_value(); } @@ -2931,32 +2931,32 @@ mrb_init_class(mrb_state *mrb) MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC); MRB_SET_INSTANCE_TT(cls, MRB_TT_CLASS); - mrb_define_method(mrb, bob, "initialize", mrb_bob_init, MRB_ARGS_NONE()); + mrb_define_method(mrb, bob, "initialize", mrb_do_nothing, MRB_ARGS_NONE()); mrb_define_method(mrb, bob, "!", mrb_bob_not, MRB_ARGS_NONE()); mrb_define_method(mrb, bob, "==", mrb_obj_equal_m, MRB_ARGS_REQ(1)); /* 15.3.1.3.1 */ mrb_define_method(mrb, bob, "__id__", mrb_obj_id_m, MRB_ARGS_NONE()); /* 15.3.1.3.4 */ mrb_define_method(mrb, bob, "__send__", mrb_f_send, MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK()); /* 15.3.1.3.5 */ mrb_define_method(mrb, bob, "equal?", mrb_obj_equal_m, MRB_ARGS_REQ(1)); /* 15.3.1.3.11 */ mrb_define_method(mrb, bob, "instance_eval", mrb_obj_instance_eval, MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK()); /* 15.3.1.3.18 */ - mrb_define_method(mrb, bob, "singleton_method_added", mrb_bob_init, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, bob, "singleton_method_added", mrb_do_nothing, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK()); mrb_define_method(mrb, cls, "allocate", mrb_instance_alloc, MRB_ARGS_NONE()); mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, MRB_ARGS_NONE()); /* 15.2.3.3.4 */ mrb_define_method(mrb, cls, "initialize", mrb_class_initialize, MRB_ARGS_OPT(1)); /* 15.2.3.3.1 */ - mrb_define_method(mrb, cls, "inherited", mrb_bob_init, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, cls, "inherited", mrb_do_nothing, MRB_ARGS_REQ(1)); init_class_new(mrb, cls); MRB_SET_INSTANCE_TT(mod, MRB_TT_MODULE); mrb_define_method(mrb, mod, "extend_object", mrb_mod_extend_object, MRB_ARGS_REQ(1)); /* 15.2.2.4.25 */ - mrb_define_method(mrb, mod, "extended", mrb_bob_init, MRB_ARGS_REQ(1)); /* 15.2.2.4.26 */ - mrb_define_method(mrb, mod, "prepended", mrb_bob_init, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, mod, "extended", mrb_do_nothing, MRB_ARGS_REQ(1)); /* 15.2.2.4.26 */ + mrb_define_method(mrb, mod, "prepended", mrb_do_nothing, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mod, "prepend_features", mrb_mod_prepend_features, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mod, "include?", mrb_mod_include_p, MRB_ARGS_REQ(1)); /* 15.2.2.4.28 */ mrb_define_method(mrb, mod, "append_features", mrb_mod_append_features, MRB_ARGS_REQ(1)); /* 15.2.2.4.10 */ mrb_define_method(mrb, mod, "class_eval", mrb_mod_module_eval, MRB_ARGS_ANY()); /* 15.2.2.4.15 */ - mrb_define_method(mrb, mod, "included", mrb_bob_init, MRB_ARGS_REQ(1)); /* 15.2.2.4.29 */ + mrb_define_method(mrb, mod, "included", mrb_do_nothing, MRB_ARGS_REQ(1)); /* 15.2.2.4.29 */ mrb_define_method(mrb, mod, "initialize", mrb_mod_initialize, MRB_ARGS_NONE()); /* 15.2.2.4.31 */ mrb_define_method(mrb, mod, "module_eval", mrb_mod_module_eval, MRB_ARGS_ANY()); /* 15.2.2.4.35 */ mrb_define_method(mrb, mod, "module_function", mrb_mod_module_function, MRB_ARGS_ANY()); @@ -2979,7 +2979,7 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, mod, "define_method", mod_define_method, MRB_ARGS_ARG(1,1)); mrb_define_method(mrb, mod, "===", mrb_mod_eqq, MRB_ARGS_REQ(1)); /* 15.2.2.4.7 */ mrb_define_method(mrb, mod, "dup", mrb_mod_dup, MRB_ARGS_NONE()); - mrb_define_method(mrb, bob, "method_added", mrb_bob_init, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, bob, "method_added", mrb_do_nothing, MRB_ARGS_REQ(1)); mrb_undef_method(mrb, cls, "append_features"); mrb_undef_method(mrb, cls, "prepend_features"); From 75371b8831a1533edb315f34302484af8aee39a6 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 13 Mar 2022 18:56:23 +0900 Subject: [PATCH 154/292] Reimplement `Exception#message` in Ruby Suppresses the possibility of `mrb_vm_exec()` being called recursively. --- mrblib/10error.rb | 13 +++++++++++++ src/error.c | 15 --------------- 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/mrblib/10error.rb b/mrblib/10error.rb index aa9da91bb..431f77809 100644 --- a/mrblib/10error.rb +++ b/mrblib/10error.rb @@ -1,3 +1,16 @@ +class Exception + ## + # call-seq: + # exception.message -> string + # + # Returns the result of invoking exception.to_s. + # Normally this returns the exception's message or name. + # + def message + to_s + end +end + # ISO 15.2.24 class ArgumentError < StandardError end diff --git a/src/error.c b/src/error.c index 46d26bece..acad904e3 100644 --- a/src/error.c +++ b/src/error.c @@ -136,20 +136,6 @@ exc_to_s(mrb_state *mrb, mrb_value exc) return mesg; } -/* - * call-seq: - * exception.message -> string - * - * Returns the result of invoking exception.to_s. - * Normally this returns the exception's message or name. - */ - -static mrb_value -exc_message(mrb_state *mrb, mrb_value exc) -{ - return mrb_funcall_id(mrb, exc, MRB_SYM(to_s), 0); -} - /* * call-seq: * exception.inspect -> string @@ -667,7 +653,6 @@ mrb_init_exception(mrb_state *mrb) mrb_define_method(mrb, exception, "exception", exc_exception, MRB_ARGS_OPT(1)); mrb_define_method(mrb, exception, "initialize", exc_initialize, MRB_ARGS_OPT(1)); mrb_define_method(mrb, exception, "to_s", exc_to_s, MRB_ARGS_NONE()); - mrb_define_method(mrb, exception, "message", exc_message, MRB_ARGS_NONE()); mrb_define_method(mrb, exception, "inspect", mrb_exc_inspect, MRB_ARGS_NONE()); mrb_define_method(mrb, exception, "backtrace", mrb_exc_backtrace, MRB_ARGS_NONE()); mrb_define_method(mrb, exception, "set_backtrace", exc_set_backtrace, MRB_ARGS_REQ(1)); From c5f2ac896cefc5919a227df1860e551213465962 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 13 Mar 2022 16:20:27 +0900 Subject: [PATCH 155/292] array.c: refactoring allocation size error. --- src/array.c | 35 +++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/src/array.c b/src/array.c index b5fe1284e..484723e8e 100644 --- a/src/array.c +++ b/src/array.c @@ -18,15 +18,26 @@ #define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value)) #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1)) +static void +ary_too_big(mrb_state *mrb) +{ + mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big"); +} + +static void +ary_check_too_big(mrb_state *mrb, mrb_int a, mrb_int b) +{ + if (a > ARY_MAX_SIZE - b || a < 0) + ary_too_big(mrb); +} + static struct RArray* ary_new_capa(mrb_state *mrb, mrb_int capa) { struct RArray *a; size_t blen; - if (capa > ARY_MAX_SIZE) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big"); - } + ary_check_too_big(mrb, capa, 0); blen = capa * sizeof(mrb_value); a = MRB_OBJ_ALLOC(mrb, MRB_TT_ARRAY, mrb->array_class); @@ -188,11 +199,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, mrb_int len) { mrb_int capa = ARY_CAPA(a); - if (len > ARY_MAX_SIZE || len < 0) { - size_error: - mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big"); - } - + ary_check_too_big(mrb, len, 0); if (capa < ARY_DEFAULT_LEN) { capa = ARY_DEFAULT_LEN; } @@ -205,7 +212,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, mrb_int len) } } if (capa < len || capa > ARY_MAX_SIZE) { - goto size_error; + ary_too_big(mrb); } if (ARY_EMBED_P(a)) { @@ -302,9 +309,7 @@ ary_concat(mrb_state *mrb, struct RArray *a, struct RArray *a2) ary_replace(mrb, a, a2); return; } - if (ARY_LEN(a2) > ARY_MAX_SIZE - ARY_LEN(a)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big"); - } + ary_check_too_big(mrb, ARY_LEN(a2), ARY_LEN(a)); len = ARY_LEN(a) + ARY_LEN(a2); ary_modify(mrb, a); @@ -343,9 +348,7 @@ mrb_ary_plus(mrb_state *mrb, mrb_value self) mrb_int blen, len1; mrb_get_args(mrb, "a", &ptr, &blen); - if (ARY_MAX_SIZE - blen < ARY_LEN(a1)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big"); - } + ary_check_too_big(mrb, ARY_LEN(a1), blen); len1 = ARY_LEN(a1); a2 = ary_new_capa(mrb, len1 + blen); array_copy(ARY_PTR(a2), ARY_PTR(a1), len1); @@ -440,7 +443,7 @@ mrb_ary_times(mrb_state *mrb, mrb_value self) } if (times == 0) return mrb_ary_new(mrb); if (ARY_MAX_SIZE / times < ARY_LEN(a1)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big"); + ary_too_big(mrb); } len1 = ARY_LEN(a1); a2 = ary_new_capa(mrb, len1 * times); From 37d65069729432698ee60fd9d80be3830b4ad7fa Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 14 Mar 2022 07:22:01 +0900 Subject: [PATCH 156/292] string.c: remove unused API `mrb_str_strlen()`. Compatibility macro is provided for safety. --- include/mruby/string.h | 3 ++- src/string.c | 11 ----------- 2 files changed, 2 insertions(+), 12 deletions(-) diff --git a/include/mruby/string.h b/include/mruby/string.h index 3a8d73a70..b172a3263 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -102,7 +102,6 @@ struct RStringEmbed { #define RSTRING_LEN(s) RSTR_LEN(RSTRING(s)) #define RSTRING_CAPA(s) RSTR_CAPA(RSTRING(s)) #define RSTRING_END(s) (RSTRING_PTR(s) + RSTRING_LEN(s)) -MRB_API mrb_int mrb_str_strlen(mrb_state*, struct RString*); #define RSTRING_CSTR(mrb,s) mrb_string_cstr(mrb, s) #define MRB_STR_SHARED 1 @@ -335,6 +334,8 @@ MRB_API const char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *str); MRB_API const char *mrb_string_value_ptr(mrb_state *mrb, mrb_value str); /* obsolete: use RSTRING_LEN() */ MRB_API mrb_int mrb_string_value_len(mrb_state *mrb, mrb_value str); +/* obsolete: substituted by a macro; shall be removed */ +#define mrb_str_strlen(mrb, s) strlen(RSTR_PTR(s)) /** * Duplicates a string object. diff --git a/src/string.c b/src/string.c index b1dc1e1e5..41d14bd32 100644 --- a/src/string.c +++ b/src/string.c @@ -696,17 +696,6 @@ str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos) } } -MRB_API mrb_int -mrb_str_strlen(mrb_state *mrb, struct RString *s) -{ - mrb_int max = RSTR_LEN(s); - char *p = RSTR_PTR(s); - - if (!p) return 0; - check_null_byte(mrb, s); - return max; -} - #ifdef _WIN32 #include From 6aa5d538673b6fbc79634f0e600c6e9ae5e4b17f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 15 Mar 2022 19:06:47 +0900 Subject: [PATCH 157/292] numeric.c: avoid `mrb_float` with `MRB_NO_FLOAT`; fix #5671 `MRB_USE_COMPLEX` is exclusive with `MRB_NO_FLOAT`, so we only need to check the former. --- src/numeric.c | 2 ++ src/numops.c | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/numeric.c b/src/numeric.c index 45b37451e..109833bb9 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -20,10 +20,12 @@ #endif #endif +#ifdef MRB_USE_COMPLEX mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y); +#endif mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y); mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); diff --git a/src/numops.c b/src/numops.c index 97fa81186..f98aa418c 100644 --- a/src/numops.c +++ b/src/numops.c @@ -12,10 +12,12 @@ mrb_value mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y); +#ifdef MRB_USE_COMPLEX mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y); +#endif mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y); mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); From 4e1cf3293b69432089449f0e6d88973adfcf9e11 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 15 Mar 2022 19:08:25 +0900 Subject: [PATCH 158/292] string.h: replace obsolete functions with macros. - mrb_string_value_ptr() - mrb_string_value_len() --- include/mruby/string.h | 4 ++-- src/string.c | 16 ---------------- 2 files changed, 2 insertions(+), 18 deletions(-) diff --git a/include/mruby/string.h b/include/mruby/string.h index b172a3263..faa0d055b 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -331,9 +331,9 @@ MRB_API const char *mrb_string_cstr(mrb_state *mrb, mrb_value str); /* NULL terminated C string from mrb_value; `str` will be updated */ MRB_API const char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *str); /* obsolete: use RSTRING_PTR() */ -MRB_API const char *mrb_string_value_ptr(mrb_state *mrb, mrb_value str); +#define mrb_string_value_ptr(mrb, str) RSTRING_PTR(str) /* obsolete: use RSTRING_LEN() */ -MRB_API mrb_int mrb_string_value_len(mrb_state *mrb, mrb_value str); +#define mrb_string_value_len(mrb, str) RSTRING_LEN(str) /* obsolete: substituted by a macro; shall be removed */ #define mrb_str_strlen(mrb, s) strlen(RSTR_PTR(s)) diff --git a/src/string.c b/src/string.c index 41d14bd32..111eefb76 100644 --- a/src/string.c +++ b/src/string.c @@ -1019,22 +1019,6 @@ mrb_str_equal_m(mrb_state *mrb, mrb_value str1) } /* ---------------------------------- */ -/* obslete: use RSTRING_PTR() */ -MRB_API const char* -mrb_string_value_ptr(mrb_state *mrb, mrb_value str) -{ - str = mrb_obj_as_string(mrb, str); - return RSTRING_PTR(str); -} - -/* obslete: use RSTRING_LEN() */ -MRB_API mrb_int -mrb_string_value_len(mrb_state *mrb, mrb_value ptr) -{ - mrb_ensure_string_type(mrb, ptr); - return RSTRING_LEN(ptr); -} - MRB_API mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str) { From a869e4e540f4acba2d0a5dc0af3344424e61b75b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 15 Mar 2022 19:10:49 +0900 Subject: [PATCH 159/292] numeric.h: remove obsolete functions. - mrb_flo_to_fixnum() - mrb_to_flo() This commit removes weird abbreviation `_flo`. --- include/mruby/numeric.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index 99b642172..425b0253d 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -170,10 +170,6 @@ mrb_float mrb_div_float(mrb_float x, mrb_float y); mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt); int mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, char sign); -/* obsolete functions; will be removed */ -#define mrb_flo_to_fixnum(mrb, val) mrb_float_to_integer(mrb, val) -#define mrb_to_flo(mrb, x) mrb_as_float(mrb, x) - #endif /* MRB_NO_FLOAT */ MRB_END_DECL From 13d014ab5eeceab2c238a9104d7473fd6dff21a1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 15 Mar 2022 19:13:32 +0900 Subject: [PATCH 160/292] complex.c: rename static functions to remove abbreviations. - `flo_` - `cpx_` --- mrbgems/mruby-complex/src/complex.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 31c0abe89..870e54a6a 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -357,7 +357,7 @@ mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y); * redefine Integer#/ */ static mrb_value -cpx_int_div(mrb_state *mrb, mrb_value x) +complex_int_div(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); mrb_int a = mrb_integer(x); @@ -385,7 +385,7 @@ cpx_int_div(mrb_state *mrb, mrb_value x) */ static mrb_value -cpx_int_quo(mrb_state *mrb, mrb_value x) +complex_int_quo(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); mrb_int a = mrb_integer(x); @@ -404,7 +404,7 @@ cpx_int_quo(mrb_state *mrb, mrb_value x) } static mrb_value -cpx_flo_div(mrb_state *mrb, mrb_value x) +complex_float_div(mrb_state *mrb, mrb_value x) { mrb_float a = mrb_float(x); mrb_value y = mrb_get_arg1(mrb); @@ -447,10 +447,10 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb) mrb_define_method(mrb, comp, "/", complex_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, comp, "quo", complex_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, comp, "==", complex_eq, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, mrb->integer_class, "/", cpx_int_div, MRB_ARGS_REQ(1)); /* override */ - mrb_define_method(mrb, mrb->integer_class, "quo", cpx_int_quo, MRB_ARGS_REQ(1)); /* override */ - mrb_define_method(mrb, mrb->float_class, "/", cpx_flo_div, MRB_ARGS_REQ(1)); /* override */ - mrb_define_method(mrb, mrb->float_class, "quo", cpx_flo_div, MRB_ARGS_REQ(1)); /* override */ + mrb_define_method(mrb, mrb->integer_class, "/", complex_int_div, MRB_ARGS_REQ(1)); /* override */ + mrb_define_method(mrb, mrb->integer_class, "quo", complex_int_quo, MRB_ARGS_REQ(1)); /* override */ + mrb_define_method(mrb, mrb->float_class, "/", complex_float_div, MRB_ARGS_REQ(1)); /* override */ + mrb_define_method(mrb, mrb->float_class, "quo", complex_float_div, MRB_ARGS_REQ(1)); /* override */ } void From 4dcdf78f8ae834db2e81b274aa432913f37885f5 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 17 Mar 2022 23:25:50 +0900 Subject: [PATCH 161/292] numeric_ext.c: add `Integer#pow()` method. Which takes optional second argument of modulo. --- mrbgems/mruby-numeric-ext/src/numeric_ext.c | 58 ++++++++++++++++++--- mrbgems/mruby-numeric-ext/test/numeric.rb | 6 +++ src/numeric.c | 49 ++++++++--------- 3 files changed, 81 insertions(+), 32 deletions(-) diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index 2f2a6c755..4220f9207 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -2,6 +2,9 @@ #include #include +void mrb_int_zerodiv(mrb_state *mrb); +void mrb_int_overflow(mrb_state *mrb, const char *reason); + /* * call-seq: * int.allbits?(mask) -> true or false @@ -50,12 +53,6 @@ int_nobits(mrb_state *mrb, mrb_value self) return mrb_bool_value((n & m) == 0); } -static void -zerodiv(mrb_state *mrb) -{ - mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); -} - /* * call-seq: * num.remainder(numeric) -> real @@ -73,7 +70,7 @@ int_remainder(mrb_state *mrb, mrb_value x) a = mrb_integer(x); if (mrb_integer_p(y)) { b = mrb_integer(y); - if (b == 0) zerodiv(mrb); + if (b == 0) mrb_int_zerodiv(mrb); if (a == MRB_INT_MIN && b == -1) return mrb_fixnum_value(0); return mrb_int_value(mrb, a % b); } @@ -88,6 +85,49 @@ int_remainder(mrb_state *mrb, mrb_value x) #endif } +mrb_value mrb_int_pow(mrb_state *mrb, mrb_value x); + +/* + * call-seq: + * integer.pow(numeric) -> numeric + * integer.pow(integer, integer) -> integer + * + * Returns (modular) exponentiation as: + * + * a.pow(b) #=> same as a**b + * a.pow(b, m) #=> same as (a**b) % m, but avoids huge temporary values + */ +static mrb_value +int_powm(mrb_state *mrb, mrb_value x) +{ + mrb_int base, exp, mod, result = 1; + + if (mrb_get_argc(mrb) == 1) { + return mrb_int_pow(mrb, x); + } + mrb_get_args(mrb, "ii", &exp, &mod); + if (exp < 0) mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): n must be positive"); + if (mod < 0) mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): m must be positive"); + if (mod == 0) mrb_int_zerodiv(mrb); + if (mod == 1) return mrb_fixnum_value(0); + base = mrb_integer(x); + for (;;) { + if (exp & 1) { + if (mrb_int_mul_overflow(result, base, &result)) { + mrb_int_overflow(mrb, "pow"); + } + result %= mod; + } + exp >>= 1; + if (exp == 0) break; + if (mrb_int_mul_overflow(base, base, &base)) { + mrb_int_overflow(mrb, "pow"); + } + base %= mod; + } + return mrb_int_value(mrb, result); +} + #ifndef MRB_NO_FLOAT static mrb_value flo_remainder(mrb_state *mrb, mrb_value self) @@ -96,7 +136,7 @@ flo_remainder(mrb_state *mrb, mrb_value self) a = mrb_float(self); mrb_get_args(mrb, "f", &b); - if (b == 0) zerodiv(mrb); + if (b == 0) mrb_int_zerodiv(mrb); if (isinf(b)) return mrb_float_value(mrb, a); return mrb_float_value(mrb, a-b*trunc(a/b)); } @@ -114,6 +154,8 @@ mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) mrb_define_alias(mrb, i, "modulo", "%"); mrb_define_method(mrb, i, "remainder", int_remainder, MRB_ARGS_REQ(1)); + mrb_define_method_id(mrb, i, MRB_SYM(pow), int_powm, MRB_ARGS_ARG(1,1)); + #ifndef MRB_NO_FLOAT struct RClass *f = mrb_class_get(mrb, "Float"); diff --git a/mrbgems/mruby-numeric-ext/test/numeric.rb b/mrbgems/mruby-numeric-ext/test/numeric.rb index efdf25a34..7ff6bdb97 100644 --- a/mrbgems/mruby-numeric-ext/test/numeric.rb +++ b/mrbgems/mruby-numeric-ext/test/numeric.rb @@ -19,3 +19,9 @@ assert('Integer#nonzero?') do assert_equal nil, 0.nonzero? assert_equal 1000, 1000.nonzero? end + +assert('Integer#pow') do + assert_equal(8, 2.pow(3)) + assert_equal(-8, (-2).pow(3)) + assert_equal(361, 9.pow(1024,1000)) +end diff --git a/src/numeric.c b/src/numeric.c index 109833bb9..aa07853ac 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -32,14 +32,14 @@ mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y); -static void -int_overflow(mrb_state *mrb, const char *reason) +void +mrb_int_overflow(mrb_state *mrb, const char *reason) { mrb_raisef(mrb, E_RANGE_ERROR, "integer overflow in %s", reason); } -static void -int_zerodiv(mrb_state *mrb) +void +mrb_int_zerodiv(mrb_state *mrb) { mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); } @@ -53,8 +53,8 @@ int_zerodiv(mrb_state *mrb) * * 2.0**3 #=> 8.0 */ -static mrb_value -int_pow(mrb_state *mrb, mrb_value x) +mrb_value +mrb_int_pow(mrb_state *mrb, mrb_value x) { mrb_int base = mrb_integer(x); mrb_int result = 1; @@ -78,32 +78,33 @@ int_pow(mrb_state *mrb, mrb_value x) #ifndef MRB_NO_FLOAT return mrb_float_value(mrb, pow((double)base, (double)exp)); #else - int_overflow(mrb, "negative power"); + mrb_int_overflow(mrb, "negative power"); #endif } for (;;) { if (exp & 1) { if (mrb_int_mul_overflow(result, base, &result)) { - int_overflow(mrb, "power"); + mrb_int_overflow(mrb, "power"); } } exp >>= 1; if (exp == 0) break; if (mrb_int_mul_overflow(base, base, &base)) { - int_overflow(mrb, "power"); + mrb_int_overflow(mrb, "power"); } } return mrb_int_value(mrb, result); } +#define int_pow mrb_int_pow mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y) { if (y == 0) { - int_zerodiv(mrb); + mrb_int_zerodiv(mrb); } else if(x == MRB_INT_MIN && y == -1) { - int_overflow(mrb, "division"); + mrb_int_overflow(mrb, "division"); } else { mrb_int div = x / y; @@ -165,7 +166,7 @@ int_idiv(mrb_state *mrb, mrb_value x) mrb_get_args(mrb, "i", &y); if (y == 0) { - int_zerodiv(mrb); + mrb_int_zerodiv(mrb); } return mrb_int_value(mrb, mrb_integer(x) / y); } @@ -180,7 +181,7 @@ int_quo(mrb_state *mrb, mrb_value xv) mrb_get_args(mrb, "f", &y); if (y == 0) { - int_zerodiv(mrb); + mrb_int_zerodiv(mrb); } return mrb_float_value(mrb, mrb_integer(xv) / y); #endif @@ -412,7 +413,7 @@ flodivmod(mrb_state *mrb, double x, double y, mrb_float *divp, mrb_float *modp) goto exit; } if (y == 0.0) { - int_zerodiv(mrb); + mrb_int_zerodiv(mrb); } if (isinf(y) && !isinf(x)) { mod = x; @@ -553,7 +554,7 @@ static mrb_value int64_value(mrb_state *mrb, int64_t v) { if (!TYPED_FIXABLE(v,int64_t)) { - int_overflow(mrb, "bit operation"); + mrb_int_overflow(mrb, "bit operation"); } return mrb_fixnum_value((mrb_int)v); } @@ -1014,7 +1015,7 @@ mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y) if (a == 0) return x; b = mrb_integer(y); if (mrb_int_mul_overflow(a, b, &c)) { - int_overflow(mrb, "multiplication"); + mrb_int_overflow(mrb, "multiplication"); } return mrb_int_value(mrb, c); } @@ -1058,10 +1059,10 @@ static void intdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp) { if (y == 0) { - int_zerodiv(mrb); + mrb_int_zerodiv(mrb); } else if(x == MRB_INT_MIN && y == -1) { - int_overflow(mrb, "division"); + mrb_int_overflow(mrb, "division"); } else { mrb_int div = x / y; @@ -1094,7 +1095,7 @@ int_mod(mrb_state *mrb, mrb_value x) a = mrb_integer(x); if (mrb_integer_p(y)) { b = mrb_integer(y); - if (b == 0) int_zerodiv(mrb); + if (b == 0) mrb_int_zerodiv(mrb); if (a == MRB_INT_MIN && b == -1) return mrb_fixnum_value(0); mrb_int mod = a % b; if ((a < 0) != (b < 0) && mod != 0) { @@ -1338,7 +1339,7 @@ int_lshift(mrb_state *mrb, mrb_value x) val = mrb_integer(x); if (val == 0) return x; if (!mrb_num_shift(mrb, val, width, &val)) { - int_overflow(mrb, "bit shift"); + mrb_int_overflow(mrb, "bit shift"); } return mrb_int_value(mrb, val); } @@ -1362,9 +1363,9 @@ int_rshift(mrb_state *mrb, mrb_value x) } val = mrb_integer(x); if (val == 0) return x; - if (width == MRB_INT_MIN) int_overflow(mrb, "bit shift"); + if (width == MRB_INT_MIN) mrb_int_overflow(mrb, "bit shift"); if (!mrb_num_shift(mrb, val, -width, &val)) { - int_overflow(mrb, "bit shift"); + mrb_int_overflow(mrb, "bit shift"); } return mrb_int_value(mrb, val); } @@ -1434,7 +1435,7 @@ mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y) if (a == 0) return y; b = mrb_integer(y); if (mrb_int_add_overflow(a, b, &c)) { - int_overflow(mrb, "addition"); + mrb_int_overflow(mrb, "addition"); } return mrb_int_value(mrb, c); } @@ -1484,7 +1485,7 @@ mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y) b = mrb_integer(y); if (mrb_int_sub_overflow(a, b, &c)) { - int_overflow(mrb, "subtraction"); + mrb_int_overflow(mrb, "subtraction"); } return mrb_int_value(mrb, c); } From fe03e01078545fc6b546dc0f12f91a7d98c52512 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 18 Mar 2022 12:27:46 +0900 Subject: [PATCH 162/292] numeric.c: enhance integer division to support Rational and Complex. No longer need to override division methods in mrbgems. --- mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c | 8 +++ mrbgems/mruby-complex/src/complex.c | 57 --------------------- mrbgems/mruby-rational/src/rational.c | 63 +----------------------- src/numeric.c | 44 +++++++++++++++-- test/t/integer.rb | 15 ++++-- 5 files changed, 60 insertions(+), 127 deletions(-) diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c index aae91b285..a72e07701 100644 --- a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c +++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c @@ -396,6 +396,10 @@ mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y) { return mrb_nil_value(); } +mrb_value mrb_complex_div(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} mrb_value mrb_complex_to_i(mrb_state *mrb, mrb_value x) { return mrb_nil_value(); @@ -423,6 +427,10 @@ mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y) { return mrb_nil_value(); } +mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} mrb_value mrb_rational_to_i(mrb_state *mrb, mrb_value x) { return mrb_nil_value(); diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 870e54a6a..2cd111ded 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -348,61 +348,6 @@ complex_div(mrb_state *mrb, mrb_value x) return mrb_complex_div(mrb, x, y); } -mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y); -mrb_value mrb_rational_new(mrb_state *mrb, mrb_int n, mrb_int d); -mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y); - -/* 15.2.8.3.4 */ -/* - * redefine Integer#/ - */ -static mrb_value -complex_int_div(mrb_state *mrb, mrb_value x) -{ - mrb_value y = mrb_get_arg1(mrb); - mrb_int a = mrb_integer(x); - - if (mrb_integer_p(y)) { - mrb_int div = mrb_div_int(mrb, a, mrb_integer(y)); - return mrb_int_value(mrb, div); - } - switch (mrb_type(y)) { -#ifdef MRB_USE_RATIONAL - case MRB_TT_RATIONAL: - return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1), y); -#endif - case MRB_TT_COMPLEX: - x = complex_new(mrb, (mrb_float)a, 0); - return complex_div(mrb, x); - default: - return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); - } -} - -/* 15.2.9.3.19(x) */ -/* - * redefine Integer#quo - */ - -static mrb_value -complex_int_quo(mrb_state *mrb, mrb_value x) -{ - mrb_value y = mrb_get_arg1(mrb); - mrb_int a = mrb_integer(x); - - switch (mrb_type(y)) { -#ifdef MRB_USE_RATIONAL - case MRB_TT_RATIONAL: - return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1), y); -#endif - case MRB_TT_COMPLEX: - x = complex_new(mrb, (mrb_float)a, 0); - return complex_div(mrb, x); - default: - return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); - } -} - static mrb_value complex_float_div(mrb_state *mrb, mrb_value x) { @@ -447,8 +392,6 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb) mrb_define_method(mrb, comp, "/", complex_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, comp, "quo", complex_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, comp, "==", complex_eq, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, mrb->integer_class, "/", complex_int_div, MRB_ARGS_REQ(1)); /* override */ - mrb_define_method(mrb, mrb->integer_class, "quo", complex_int_quo, MRB_ARGS_REQ(1)); /* override */ mrb_define_method(mrb, mrb->float_class, "/", complex_float_div, MRB_ARGS_REQ(1)); /* override */ mrb_define_method(mrb, mrb->float_class, "quo", complex_float_div, MRB_ARGS_REQ(1)); /* override */ } diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index 0730c3ecb..8fed218d3 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -664,7 +664,8 @@ mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y) } } -mrb_value rational_div(mrb_state *mrb, mrb_value x) +static mrb_value +rational_div(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); return mrb_rational_div(mrb, x, y); @@ -672,62 +673,6 @@ mrb_value rational_div(mrb_state *mrb, mrb_value x) mrb_int mrb_div_int(mrb_state *, mrb_int, mrb_int); -#ifndef MRB_USE_COMPLEX -/* 15.2.8.3.4 */ -/* - * redefine Integer#/ - */ -static mrb_value -rational_int_div(mrb_state *mrb, mrb_value x) -{ - mrb_value y = mrb_get_arg1(mrb); - mrb_int a = mrb_integer(x); - - if (mrb_integer_p(y)) { - mrb_int div = mrb_div_int(mrb, a, mrb_integer(y)); - return mrb_int_value(mrb, div); - } - switch (mrb_type(y)) { - case MRB_TT_RATIONAL: - return rational_div(mrb, rational_new(mrb, a, 1), y); - default: -#ifdef MRB_NO_FLOAT - case MRB_TT_FLOAT: - mrb_raise(mrb, E_TYPE_ERROR, "non integer multiplication"); -#else - return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); -#endif - } -} - -/* 15.2.9.3.19(x) */ -/* - * redefine Integer#quo - */ - -static mrb_value -rational_int_quo(mrb_state *mrb, mrb_value x) -{ - mrb_value y = mrb_get_arg1(mrb); - mrb_int a = mrb_integer(x); - - if (mrb_integer_p(y)) { - return rational_new(mrb, a, mrb_integer(y)); - } - switch (mrb_type(y)) { - case MRB_TT_RATIONAL: - x = rational_new(mrb, a, 1); - return mrb_rational_div(mrb, x, y); - default: -#ifdef MRB_NO_FLOAT - mrb_raise(mrb, E_TYPE_ERROR, "non integer multiplication"); -#else - return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); -#endif - } -} -#endif /* !MRB_USE_COMPLEX */ - void mrb_mruby_rational_gem_init(mrb_state *mrb) { struct RClass *rat; @@ -753,10 +698,6 @@ void mrb_mruby_rational_gem_init(mrb_state *mrb) mrb_define_method(mrb, rat, "/", rational_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, rat, "quo", rational_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb->integer_class, "to_r", fix_to_r, MRB_ARGS_NONE()); -#ifndef MRB_USE_COMPLEX - mrb_define_method(mrb, mrb->integer_class, "/", rational_int_div, MRB_ARGS_REQ(1)); /* override */ - mrb_define_method(mrb, mrb->integer_class, "quo", rational_int_quo, MRB_ARGS_REQ(1)); /* override */ -#endif mrb_define_method(mrb, mrb->kernel_module, "Rational", rational_m, MRB_ARGS_ARG(1,1)); } diff --git a/src/numeric.c b/src/numeric.c index aa07853ac..d4e124c2b 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -25,12 +25,14 @@ mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_complex_div(mrb_state *mrb, mrb_value x, mrb_value y); #endif mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y); mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y); void mrb_int_overflow(mrb_state *mrb, const char *reason) @@ -138,11 +140,23 @@ int_div(mrb_state *mrb, mrb_value x) mrb_int div = mrb_div_int(mrb, a, mrb_integer(y)); return mrb_int_value(mrb, div); } -#ifdef MRB_NO_FLOAT - mrb_raise(mrb, E_TYPE_ERROR, "non integer division"); -#else - return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); + switch (mrb_type(y)) { +#ifdef MRB_USE_RATIONAL + case MRB_TT_RATIONAL: + return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1), y); #endif +#ifdef MRB_USE_COMPLEX + case MRB_TT_COMPLEX: + x = mrb_complex_new(mrb, (mrb_float)a, 0); + return mrb_complex_div(mrb, x, y); +#endif + default: +#ifdef MRB_NO_FLOAT + mrb_raise(mrb, E_TYPE_ERROR, "non integer division"); +#else + return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); +#endif + } } /* 15.2.9.3.19(x) */ @@ -172,8 +186,12 @@ int_idiv(mrb_state *mrb, mrb_value x) } static mrb_value -int_quo(mrb_state *mrb, mrb_value xv) +int_quo(mrb_state *mrb, mrb_value x) { + mrb_value y = mrb_get_arg1(mrb); + mrb_int a = mrb_integer(x); + +#ifndef MRB_USE_RATIONAL #ifdef MRB_NO_FLOAT return int_idiv(mrb, xv); #else @@ -185,6 +203,22 @@ int_quo(mrb_state *mrb, mrb_value xv) } return mrb_float_value(mrb, mrb_integer(xv) / y); #endif +#else + if (mrb_integer_p(y) && mrb_class_defined_id(mrb, MRB_SYM(Rational))) { + return mrb_rational_new(mrb, a, mrb_integer(y)); + } + switch (mrb_type(y)) { + case MRB_TT_RATIONAL: + x = mrb_rational_new(mrb, a, 1); + return mrb_rational_div(mrb, x, y); + default: +#ifdef MRB_NO_FLOAT + mrb_raise(mrb, E_TYPE_ERROR, "non integer division"); +#else + return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); +#endif + } +#endif } static mrb_value diff --git a/test/t/integer.rb b/test/t/integer.rb index d4076f38a..71066bfb1 100644 --- a/test/t/integer.rb +++ b/test/t/integer.rb @@ -45,10 +45,17 @@ assert('Integer#/', '15.2.8.3.4') do assert_equal 2.0, b end -assert('Integer#quo') do - a = 6.quo(5) - assert_equal 1.2, a -end if Object.const_defined?(:Float) +if Object.const_defined?(:Rational) + assert('Integer#quo') do + a = 6.quo(5) + assert_equal 5/6r, a + end +elsif Object.const_defined?(:Float) + assert('Integer#quo') do + a = 6.quo(5) + assert_equal 1.2, a + end +end assert('Integer#%', '15.2.8.3.5') do a = 1%1 From e45081d310852d5f184337c007c824839ef8cd74 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 18 Mar 2022 12:29:47 +0900 Subject: [PATCH 163/292] mrbc/stub.c: define stub functions in a separated file. --- mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c | 67 ----------------------- mrbgems/mruby-bin-mrbc/tools/mrbc/stub.c | 68 ++++++++++++++++++++++++ 2 files changed, 68 insertions(+), 67 deletions(-) create mode 100644 mrbgems/mruby-bin-mrbc/tools/mrbc/stub.c diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c index a72e07701..a54db42db 100644 --- a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c +++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c @@ -373,70 +373,3 @@ mrb_final_mrbgems(mrb_state *mrb) { } #endif - -/* - functions defined in mrbgems referenced from the core should be listed here - to avoid link errors, since mrbc does not link any mrbgem ignoring configuration. -*/ - -#ifdef MRB_USE_COMPLEX -mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y) -{ - return mrb_nil_value(); -} -mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y) -{ - return mrb_nil_value(); -} -mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y) -{ - return mrb_nil_value(); -} -mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y) -{ - return mrb_nil_value(); -} -mrb_value mrb_complex_div(mrb_state *mrb, mrb_value x, mrb_value y) -{ - return mrb_nil_value(); -} -mrb_value mrb_complex_to_i(mrb_state *mrb, mrb_value x) -{ - return mrb_nil_value(); -} -mrb_value mrb_complex_to_f(mrb_state *mrb, mrb_value x) -{ - return mrb_nil_value(); -} -#endif - -#ifdef MRB_USE_RATIONAL -mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y) -{ - return mrb_nil_value(); -} -mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y) -{ - return mrb_nil_value(); -} -mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y) -{ - return mrb_nil_value(); -} -mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y) -{ - return mrb_nil_value(); -} -mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y) -{ - return mrb_nil_value(); -} -mrb_value mrb_rational_to_i(mrb_state *mrb, mrb_value x) -{ - return mrb_nil_value(); -} -mrb_value mrb_rational_to_f(mrb_state *mrb, mrb_value x) -{ - return mrb_nil_value(); -} -#endif diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/stub.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/stub.c new file mode 100644 index 000000000..1ad628664 --- /dev/null +++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/stub.c @@ -0,0 +1,68 @@ +#include + +/* + functions defined in mrbgems referenced from the core should be listed here + to avoid link errors, since mrbc does not link any mrbgem ignoring configuration. +*/ + +#ifdef MRB_USE_COMPLEX +mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_div(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_to_i(mrb_state *mrb, mrb_value x) +{ + return mrb_nil_value(); +} +mrb_value mrb_complex_to_f(mrb_state *mrb, mrb_value x) +{ + return mrb_nil_value(); +} +#endif + +#ifdef MRB_USE_RATIONAL +mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_to_i(mrb_state *mrb, mrb_value x) +{ + return mrb_nil_value(); +} +mrb_value mrb_rational_to_f(mrb_state *mrb, mrb_value x) +{ + return mrb_nil_value(); +} +#endif From 4f869f3367a3cf98b967bcb25184101b233dd0f1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 18 Mar 2022 14:23:17 +0900 Subject: [PATCH 164/292] numeric.c: enhance float division to support Complex. --- mrbgems/mruby-complex/src/complex.c | 20 -------------------- src/numeric.c | 12 +++++++++--- 2 files changed, 9 insertions(+), 23 deletions(-) diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 2cd111ded..9e89e002d 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -348,24 +348,6 @@ complex_div(mrb_state *mrb, mrb_value x) return mrb_complex_div(mrb, x, y); } -static mrb_value -complex_float_div(mrb_state *mrb, mrb_value x) -{ - mrb_float a = mrb_float(x); - mrb_value y = mrb_get_arg1(mrb); - - switch(mrb_type(y)) { - case MRB_TT_COMPLEX: - return complex_div(mrb, complex_new(mrb, a, 0)); - case MRB_TT_FLOAT: - a = mrb_div_float(a, mrb_float(y)); - return mrb_float_value(mrb, a); - default: - a = mrb_div_float(a, mrb_as_float(mrb, y)); - return mrb_float_value(mrb, a); - } -} - void mrb_mruby_complex_gem_init(mrb_state *mrb) { struct RClass *comp; @@ -392,8 +374,6 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb) mrb_define_method(mrb, comp, "/", complex_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, comp, "quo", complex_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, comp, "==", complex_eq, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, mrb->float_class, "/", complex_float_div, MRB_ARGS_REQ(1)); /* override */ - mrb_define_method(mrb, mrb->float_class, "quo", complex_float_div, MRB_ARGS_REQ(1)); /* override */ } void diff --git a/src/numeric.c b/src/numeric.c index d4e124c2b..b8161878b 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -286,11 +286,17 @@ flo_div(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); mrb_float a = mrb_float(x); - if (mrb_float_p(y)) { + switch(mrb_type(y)) { +#ifdef MRB_USE_COMPLEX + case MRB_TT_COMPLEX: + return mrb_complex_div(mrb, mrb_complex_new(mrb, a, 0), y); +#endif + case MRB_TT_FLOAT: a = mrb_div_float(a, mrb_float(y)); - } - else { + return mrb_float_value(mrb, a); + default: a = mrb_div_float(a, mrb_as_float(mrb, y)); + return mrb_float_value(mrb, a); } return mrb_float_value(mrb, a); } From 59d95352d6613ac8d602df358d7f805d2f398704 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 19 Mar 2022 14:37:55 +0900 Subject: [PATCH 165/292] doc/mruby3.2.md: new file to describe 3.2 changes. --- doc/mruby3.2.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 doc/mruby3.2.md diff --git a/doc/mruby3.2.md b/doc/mruby3.2.md new file mode 100644 index 000000000..57e8624d9 --- /dev/null +++ b/doc/mruby3.2.md @@ -0,0 +1,27 @@ +# User visible changes in `mruby3.2` from `mruby3.1` + +# The language + +* Now `a::B = c` should evaluate `a` then `c`. +* Anonymous arguments `*`, `**`, `&` can be passed for forwarding. + +# Tools + +## `mruby` + +* `-b` only specifies the script is the binary. The files loaded by `-r` are not affected by the option. +* `mruby` now loads complied binary if the suffix is `.mrb`. + +## `mrbc` + +* Add `--no-optimize` option to disable optimization. + +# mrbgems + +## mruby-errno + +* `mruby-errno` gem is now bundled. + +## mruby-class-ext + +* Add `Class#subclasses` method. From 74597c6159a8d5fd40347f9a5643e12ffe54581f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 20 Mar 2022 18:54:06 +0900 Subject: [PATCH 166/292] numeric.c: fix compile errors with `MRB_NO_FLOAT`; fix #5672 --- src/numeric.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/numeric.c b/src/numeric.c index b8161878b..681088d31 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -188,12 +188,9 @@ int_idiv(mrb_state *mrb, mrb_value x) static mrb_value int_quo(mrb_state *mrb, mrb_value x) { - mrb_value y = mrb_get_arg1(mrb); - mrb_int a = mrb_integer(x); - #ifndef MRB_USE_RATIONAL #ifdef MRB_NO_FLOAT - return int_idiv(mrb, xv); + return int_idiv(mrb, x); #else mrb_float y; @@ -201,9 +198,11 @@ int_quo(mrb_state *mrb, mrb_value x) if (y == 0) { mrb_int_zerodiv(mrb); } - return mrb_float_value(mrb, mrb_integer(xv) / y); + return mrb_float_value(mrb, mrb_integer(x) / y); #endif #else + mrb_int a = mrb_integer(x); + mrb_value y = mrb_get_arg1(mrb); if (mrb_integer_p(y) && mrb_class_defined_id(mrb, MRB_SYM(Rational))) { return mrb_rational_new(mrb, a, mrb_integer(y)); } From 982a4769a1eac120dc2970be2acb68b5d76845d4 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 21 Mar 2022 11:15:23 +0900 Subject: [PATCH 167/292] metaprog.c: add `undefined_instance_methods` method. --- doc/mruby3.2.md | 1 + mrbgems/mruby-metaprog/src/metaprog.c | 34 +++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/doc/mruby3.2.md b/doc/mruby3.2.md index 57e8624d9..987f20780 100644 --- a/doc/mruby3.2.md +++ b/doc/mruby3.2.md @@ -25,3 +25,4 @@ ## mruby-class-ext * Add `Class#subclasses` method. +* Add `Module#undefined_instance_methods` method. diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c index 4bf31cbeb..d679f7f2e 100644 --- a/mrbgems/mruby-metaprog/src/metaprog.c +++ b/mrbgems/mruby-metaprog/src/metaprog.c @@ -575,6 +575,39 @@ mrb_mod_instance_methods(mrb_state *mrb, mrb_value mod) return mrb_class_instance_method_list(mrb, recur, c); } +static int +undefined_method_i(mrb_state *mrb, mrb_sym mid, mrb_method_t m, void *p) +{ + mrb_value ary = *(mrb_value*)p; + + if (MRB_METHOD_UNDEF_P(m)) { + mrb_ary_push(mrb, ary, mrb_symbol_value(mid)); + } + return 0; +} + +/* + * call-seq: + * mod.undefined_methods() -> array + * + * Returns an array containing the names of the undefined methods of the module/class. + */ +static mrb_value +mrb_mod_undefined_methods(mrb_state *mrb, mrb_value mod) +{ + struct RClass *m = mrb_class_ptr(mod); + mrb_get_args(mrb, ""); /* no argument */ + + mrb_value ary = mrb_ary_new(mrb); + + if (m->flags & MRB_FL_CLASS_IS_PREPENDED) { + MRB_CLASS_ORIGIN(m); + } + mrb_mt_foreach(mrb, m, undefined_method_i, (void*)&ary); + + return ary; +} + /* 15.2.2.4.41 */ /* * call-seq: @@ -663,6 +696,7 @@ mrb_mruby_metaprog_gem_init(mrb_state* mrb) mrb_define_method(mrb, mod, "class_variable_set", mrb_mod_cvar_set, MRB_ARGS_REQ(2)); /* 15.2.2.4.18 */ mrb_define_method(mrb, mod, "included_modules", mrb_mod_included_modules, MRB_ARGS_NONE()); /* 15.2.2.4.30 */ mrb_define_method(mrb, mod, "instance_methods", mrb_mod_instance_methods, MRB_ARGS_ANY()); /* 15.2.2.4.33 */ + mrb_define_method(mrb, mod, "undefined_instance_methods", mrb_mod_undefined_methods, MRB_ARGS_NONE()); mrb_define_method(mrb, mod, "remove_method", mrb_mod_remove_method, MRB_ARGS_ANY()); /* 15.2.2.4.41 */ mrb_define_method(mrb, mod, "method_removed", mrb_f_nil, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mod, "constants", mrb_mod_constants, MRB_ARGS_OPT(1)); /* 15.2.2.4.24 */ From be229d666f3f68b64ba4e9534847712d18f6916c Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 21 Mar 2022 14:09:17 +0000 Subject: [PATCH 168/292] build(deps): bump actions/cache from 2.1.7 to 3 Bumps [actions/cache](https://github.com/actions/cache) from 2.1.7 to 3. - [Release notes](https://github.com/actions/cache/releases) - [Commits](https://github.com/actions/cache/compare/v2.1.7...v3) --- updated-dependencies: - dependency-name: actions/cache dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/build.yml | 2 +- .github/workflows/lint.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index a697ca079..8a5f96b88 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -106,7 +106,7 @@ jobs: cache-version: v1 steps: - uses: actions/checkout@v3 - - uses: actions/cache@v2.1.7 + - uses: actions/cache@v3 with: path: ${{ env.package-dir }} key: ${{ runner.os }}-cygwin-${{ env.cache-version }} diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 95518838f..f8f140066 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -24,7 +24,7 @@ jobs: pip install pre-commit - name: Set PY run: echo "PY=$(python -VV | sha256sum | cut -d' ' -f1)" >> $GITHUB_ENV - - uses: actions/cache@v2.1.7 + - uses: actions/cache@v3 with: path: ~/.cache/pre-commit key: pre-commit|${{ env.PY }}|${{ hashFiles('.pre-commit-config.yaml') }} From 7e4eaaa11a0ea26b16835a8eae889baac2d54b18 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Thu, 24 Mar 2022 01:00:24 +1000 Subject: [PATCH 169/292] Format Markdown tables --- doc/internal/opcode.md | 208 +++++++++++++++--------------- mrbgems/mruby-io/README.md | 258 ++++++++++++++++++------------------- 2 files changed, 233 insertions(+), 233 deletions(-) diff --git a/doc/internal/opcode.md b/doc/internal/opcode.md index 11f2133c6..230848cb5 100644 --- a/doc/internal/opcode.md +++ b/doc/internal/opcode.md @@ -22,107 +22,107 @@ sign) of operands. ## table.1 Instruction Table -| Instruction Name | Operand type | Semantics | -|------------------|--------------|----------------------------------------------------------| -| `OP_NOP` | `-` | `no operation` | -| `OP_MOVE` | `BB` | `R(a) = R(b)` | -| `OP_LOADL` | `BB` | `R(a) = Pool(b)` | -| `OP_LOADI` | `BB` | `R(a) = mrb_int(b)` | -| `OP_LOADINEG` | `BB` | `R(a) = mrb_int(-b)` | -| `OP_LOADI__1` | `B` | `R(a) = mrb_int(-1)` | -| `OP_LOADI_0` | `B` | `R(a) = mrb_int(0)` | -| `OP_LOADI_1` | `B` | `R(a) = mrb_int(1)` | -| `OP_LOADI_2` | `B` | `R(a) = mrb_int(2)` | -| `OP_LOADI_3` | `B` | `R(a) = mrb_int(3)` | -| `OP_LOADI_4` | `B` | `R(a) = mrb_int(4)` | -| `OP_LOADI_5` | `B` | `R(a) = mrb_int(5)` | -| `OP_LOADI_6` | `B` | `R(a) = mrb_int(6)` | -| `OP_LOADI_7` | `B` | `R(a) = mrb_int(7)` | -| `OP_LOADI16` | `BS` | `R(a) = mrb_int(b)` | -| `OP_LOADI32` | `BSS` | `R(a) = mrb_int((b<<16)+c)` | -| `OP_LOADSYM` | `BB` | `R(a) = Syms(b)` | -| `OP_LOADNIL` | `B` | `R(a) = nil` | -| `OP_LOADSELF` | `B` | `R(a) = self` | -| `OP_LOADT` | `B` | `R(a) = true` | -| `OP_LOADF` | `B` | `R(a) = false` | -| `OP_GETGV` | `BB` | `R(a) = getglobal(Syms(b))` | -| `OP_SETGV` | `BB` | `setglobal(Syms(b), R(a))` | -| `OP_GETSV` | `BB` | `R(a) = Special[Syms(b)]` | -| `OP_SETSV` | `BB` | `Special[Syms(b)] = R(a)` | -| `OP_GETIV` | `BB` | `R(a) = ivget(Syms(b))` | -| `OP_SETIV` | `BB` | `ivset(Syms(b),R(a))` | -| `OP_GETCV` | `BB` | `R(a) = cvget(Syms(b))` | -| `OP_SETCV` | `BB` | `cvset(Syms(b),R(a))` | -| `OP_GETCONST` | `BB` | `R(a) = constget(Syms(b))` | -| `OP_SETCONST` | `BB` | `constset(Syms(b),R(a))` | -| `OP_GETMCNST` | `BB` | `R(a) = R(a)::Syms(b)` | -| `OP_SETMCNST` | `BB` | `R(a+1)::Syms(b) = R(a)` | -| `OP_GETUPVAR` | `BBB` | `R(a) = uvget(b,c)` | -| `OP_SETUPVAR` | `BBB` | `uvset(b,c,R(a))` | -| `OP_JMP` | `S` | `pc+=a` | -| `OP_JMPIF` | `BS` | `if R(a) pc+=b` | -| `OP_JMPNOT` | `BS` | `if !R(a) pc+=b` | -| `OP_JMPNIL` | `BS` | `if R(a)==nil pc+=b` | -| `OP_JMPUW` | `S` | `unwind_and_jump_to(a)` | -| `OP_EXCEPT` | `B` | `R(a) = exc` | -| `OP_RESCUE` | `BB` | `R(b) = R(a).isa?(R(b))` | -| `OP_RAISEIF` | `B` | `raise(R(a)) if R(a)` | -| `OP_SEND` | `BBB` | `R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))` | -| `OP_SENDB` | `BBB` | `R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1))` | -| `OP_CALL` | `-` | `R(0) = self.call(frame.argc, frame.argv)` | -| `OP_SUPER` | `BB` | `R(a) = super(R(a+1),... ,R(a+b+1))` | -| `OP_ARGARY` | `BS` | `R(a) = argument array (16=m5:r1:m5:d1:lv4)` | -| `OP_ENTER` | `W` | `arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1)` | -| `OP_KEY_P` | `BB` | `R(a) = kdict.key?(Syms(b))` | -| `OP_KEYEND` | `-` | `raise unless kdict.empty?` | -| `OP_KARG` | `BB` | `R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))` | -| `OP_RETURN` | `B` | `return R(a) (normal)` | -| `OP_RETURN_BLK` | `B` | `return R(a) (in-block return)` | -| `OP_BREAK` | `B` | `break R(a)` | -| `OP_BLKPUSH` | `BS` | `R(a) = block (16=m5:r1:m5:d1:lv4)` | -| `OP_ADD` | `B` | `R(a) = R(a)+R(a+1)` | -| `OP_ADDI` | `BB` | `R(a) = R(a)+mrb_int(b)` | -| `OP_SUB` | `B` | `R(a) = R(a)-R(a+1)` | -| `OP_SUBI` | `BB` | `R(a) = R(a)-mrb_int(b)` | -| `OP_MUL` | `B` | `R(a) = R(a)*R(a+1)` | -| `OP_DIV` | `B` | `R(a) = R(a)/R(a+1)` | -| `OP_EQ` | `B` | `R(a) = R(a)==R(a+1)` | -| `OP_LT` | `B` | `R(a) = R(a)R(a+1)` | -| `OP_GE` | `B` | `R(a) = R(a)>=R(a+1)` | -| `OP_ARRAY` | `BB` | `R(a) = ary_new(R(a),R(a+1)..R(a+b))` | -| `OP_ARRAY2` | `BBB` | `R(a) = ary_new(R(b),R(b+1)..R(b+c))` | -| `OP_ARYCAT` | `B` | `ary_cat(R(a),R(a+1))` | -| `OP_ARYPUSH` | `BB` | `ary_push(R(a),R(a+1)..R(a+b))` | -| `OP_ARYDUP` | `B` | `R(a) = ary_dup(R(a))` | -| `OP_AREF` | `BBB` | `R(a) = R(b)[c]` | -| `OP_ASET` | `BBB` | `R(b)[c] = R(a)` | -| `OP_APOST` | `BBB` | `*R(a),R(a+1)..R(a+c) = R(a)[b..]` | -| `OP_INTERN` | `B` | `R(a) = intern(R(a))` | -| `OP_STRING` | `BB` | `R(a) = str_dup(Pool(b))` | -| `OP_STRCAT` | `B` | `str_cat(R(a),R(a+1))` | -| `OP_HASH` | `BB` | `R(a) = hash_new(R(a),R(a+1)..R(a+b*2-1))` | -| `OP_HASHADD` | `BB` | `hash_push(R(a),R(a+1)..R(a+b*2))` | -| `OP_HASHCAT` | `B` | `R(a) = hash_cat(R(a),R(a+1))` | -| `OP_LAMBDA` | `BB` | `R(a) = lambda(Irep(b),OP_L_LAMBDA)` | -| `OP_BLOCK` | `BB` | `R(a) = lambda(Irep(b),OP_L_BLOCK)` | -| `OP_METHOD` | `BB` | `R(a) = lambda(Irep(b),OP_L_METHOD)` | -| `OP_RANGE_INC` | `B` | `R(a) = range_new(R(a),R(a+1),FALSE)` | -| `OP_RANGE_EXC` | `B` | `R(a) = range_new(R(a),R(a+1),TRUE)` | -| `OP_OCLASS` | `B` | `R(a) = ::Object` | -| `OP_CLASS` | `BB` | `R(a) = newclass(R(a),Syms(b),R(a+1))` | -| `OP_MODULE` | `BB` | `R(a) = newmodule(R(a),Syms(b))` | -| `OP_EXEC` | `BB` | `R(a) = blockexec(R(a),Irep[b])` | -| `OP_DEF` | `BB` | `R(a).newmethod(Syms(b),R(a+1)); R(a) = Syms(b)` | -| `OP_ALIAS` | `BB` | `alias_method(target_class,Syms(a),Syms(b))` | -| `OP_UNDEF` | `B` | `undef_method(target_class,Syms(a))` | -| `OP_SCLASS` | `B` | `R(a) = R(a).singleton_class` | -| `OP_TCLASS` | `B` | `R(a) = target_class` | -| `OP_DEBUG` | `BBB` | `print a,b,c` | -| `OP_ERR` | `B` | `raise(LocalJumpError, Pool(a))` | -| `OP_EXT1` | `-` | `make 1st operand 16bit` | -| `OP_EXT2` | `-` | `make 2nd operand 16bit` | -| `OP_EXT3` | `-` | `make 1st and 2nd operands 16bit` | -| `OP_STOP` | `-` | `stop VM` | -|------------------|--------------|----------------------------------------------------------| +| Instruction Name | Operand type | Semantics | +|--------------------|----------------|------------------------------------------------------------| +| `OP_NOP` | `-` | `no operation` | +| `OP_MOVE` | `BB` | `R(a) = R(b)` | +| `OP_LOADL` | `BB` | `R(a) = Pool(b)` | +| `OP_LOADI` | `BB` | `R(a) = mrb_int(b)` | +| `OP_LOADINEG` | `BB` | `R(a) = mrb_int(-b)` | +| `OP_LOADI__1` | `B` | `R(a) = mrb_int(-1)` | +| `OP_LOADI_0` | `B` | `R(a) = mrb_int(0)` | +| `OP_LOADI_1` | `B` | `R(a) = mrb_int(1)` | +| `OP_LOADI_2` | `B` | `R(a) = mrb_int(2)` | +| `OP_LOADI_3` | `B` | `R(a) = mrb_int(3)` | +| `OP_LOADI_4` | `B` | `R(a) = mrb_int(4)` | +| `OP_LOADI_5` | `B` | `R(a) = mrb_int(5)` | +| `OP_LOADI_6` | `B` | `R(a) = mrb_int(6)` | +| `OP_LOADI_7` | `B` | `R(a) = mrb_int(7)` | +| `OP_LOADI16` | `BS` | `R(a) = mrb_int(b)` | +| `OP_LOADI32` | `BSS` | `R(a) = mrb_int((b<<16)+c)` | +| `OP_LOADSYM` | `BB` | `R(a) = Syms(b)` | +| `OP_LOADNIL` | `B` | `R(a) = nil` | +| `OP_LOADSELF` | `B` | `R(a) = self` | +| `OP_LOADT` | `B` | `R(a) = true` | +| `OP_LOADF` | `B` | `R(a) = false` | +| `OP_GETGV` | `BB` | `R(a) = getglobal(Syms(b))` | +| `OP_SETGV` | `BB` | `setglobal(Syms(b), R(a))` | +| `OP_GETSV` | `BB` | `R(a) = Special[Syms(b)]` | +| `OP_SETSV` | `BB` | `Special[Syms(b)] = R(a)` | +| `OP_GETIV` | `BB` | `R(a) = ivget(Syms(b))` | +| `OP_SETIV` | `BB` | `ivset(Syms(b),R(a))` | +| `OP_GETCV` | `BB` | `R(a) = cvget(Syms(b))` | +| `OP_SETCV` | `BB` | `cvset(Syms(b),R(a))` | +| `OP_GETCONST` | `BB` | `R(a) = constget(Syms(b))` | +| `OP_SETCONST` | `BB` | `constset(Syms(b),R(a))` | +| `OP_GETMCNST` | `BB` | `R(a) = R(a)::Syms(b)` | +| `OP_SETMCNST` | `BB` | `R(a+1)::Syms(b) = R(a)` | +| `OP_GETUPVAR` | `BBB` | `R(a) = uvget(b,c)` | +| `OP_SETUPVAR` | `BBB` | `uvset(b,c,R(a))` | +| `OP_JMP` | `S` | `pc+=a` | +| `OP_JMPIF` | `BS` | `if R(a) pc+=b` | +| `OP_JMPNOT` | `BS` | `if !R(a) pc+=b` | +| `OP_JMPNIL` | `BS` | `if R(a)==nil pc+=b` | +| `OP_JMPUW` | `S` | `unwind_and_jump_to(a)` | +| `OP_EXCEPT` | `B` | `R(a) = exc` | +| `OP_RESCUE` | `BB` | `R(b) = R(a).isa?(R(b))` | +| `OP_RAISEIF` | `B` | `raise(R(a)) if R(a)` | +| `OP_SEND` | `BBB` | `R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))` | +| `OP_SENDB` | `BBB` | `R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1))` | +| `OP_CALL` | `-` | `R(0) = self.call(frame.argc, frame.argv)` | +| `OP_SUPER` | `BB` | `R(a) = super(R(a+1),... ,R(a+b+1))` | +| `OP_ARGARY` | `BS` | `R(a) = argument array (16=m5:r1:m5:d1:lv4)` | +| `OP_ENTER` | `W` | `arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1)` | +| `OP_KEY_P` | `BB` | `R(a) = kdict.key?(Syms(b))` | +| `OP_KEYEND` | `-` | `raise unless kdict.empty?` | +| `OP_KARG` | `BB` | `R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))` | +| `OP_RETURN` | `B` | `return R(a) (normal)` | +| `OP_RETURN_BLK` | `B` | `return R(a) (in-block return)` | +| `OP_BREAK` | `B` | `break R(a)` | +| `OP_BLKPUSH` | `BS` | `R(a) = block (16=m5:r1:m5:d1:lv4)` | +| `OP_ADD` | `B` | `R(a) = R(a)+R(a+1)` | +| `OP_ADDI` | `BB` | `R(a) = R(a)+mrb_int(b)` | +| `OP_SUB` | `B` | `R(a) = R(a)-R(a+1)` | +| `OP_SUBI` | `BB` | `R(a) = R(a)-mrb_int(b)` | +| `OP_MUL` | `B` | `R(a) = R(a)*R(a+1)` | +| `OP_DIV` | `B` | `R(a) = R(a)/R(a+1)` | +| `OP_EQ` | `B` | `R(a) = R(a)==R(a+1)` | +| `OP_LT` | `B` | `R(a) = R(a)R(a+1)` | +| `OP_GE` | `B` | `R(a) = R(a)>=R(a+1)` | +| `OP_ARRAY` | `BB` | `R(a) = ary_new(R(a),R(a+1)..R(a+b))` | +| `OP_ARRAY2` | `BBB` | `R(a) = ary_new(R(b),R(b+1)..R(b+c))` | +| `OP_ARYCAT` | `B` | `ary_cat(R(a),R(a+1))` | +| `OP_ARYPUSH` | `BB` | `ary_push(R(a),R(a+1)..R(a+b))` | +| `OP_ARYDUP` | `B` | `R(a) = ary_dup(R(a))` | +| `OP_AREF` | `BBB` | `R(a) = R(b)[c]` | +| `OP_ASET` | `BBB` | `R(b)[c] = R(a)` | +| `OP_APOST` | `BBB` | `*R(a),R(a+1)..R(a+c) = R(a)[b..]` | +| `OP_INTERN` | `B` | `R(a) = intern(R(a))` | +| `OP_STRING` | `BB` | `R(a) = str_dup(Pool(b))` | +| `OP_STRCAT` | `B` | `str_cat(R(a),R(a+1))` | +| `OP_HASH` | `BB` | `R(a) = hash_new(R(a),R(a+1)..R(a+b*2-1))` | +| `OP_HASHADD` | `BB` | `hash_push(R(a),R(a+1)..R(a+b*2))` | +| `OP_HASHCAT` | `B` | `R(a) = hash_cat(R(a),R(a+1))` | +| `OP_LAMBDA` | `BB` | `R(a) = lambda(Irep(b),OP_L_LAMBDA)` | +| `OP_BLOCK` | `BB` | `R(a) = lambda(Irep(b),OP_L_BLOCK)` | +| `OP_METHOD` | `BB` | `R(a) = lambda(Irep(b),OP_L_METHOD)` | +| `OP_RANGE_INC` | `B` | `R(a) = range_new(R(a),R(a+1),FALSE)` | +| `OP_RANGE_EXC` | `B` | `R(a) = range_new(R(a),R(a+1),TRUE)` | +| `OP_OCLASS` | `B` | `R(a) = ::Object` | +| `OP_CLASS` | `BB` | `R(a) = newclass(R(a),Syms(b),R(a+1))` | +| `OP_MODULE` | `BB` | `R(a) = newmodule(R(a),Syms(b))` | +| `OP_EXEC` | `BB` | `R(a) = blockexec(R(a),Irep[b])` | +| `OP_DEF` | `BB` | `R(a).newmethod(Syms(b),R(a+1)); R(a) = Syms(b)` | +| `OP_ALIAS` | `BB` | `alias_method(target_class,Syms(a),Syms(b))` | +| `OP_UNDEF` | `B` | `undef_method(target_class,Syms(a))` | +| `OP_SCLASS` | `B` | `R(a) = R(a).singleton_class` | +| `OP_TCLASS` | `B` | `R(a) = target_class` | +| `OP_DEBUG` | `BBB` | `print a,b,c` | +| `OP_ERR` | `B` | `raise(LocalJumpError, Pool(a))` | +| `OP_EXT1` | `-` | `make 1st operand 16bit` | +| `OP_EXT2` | `-` | `make 2nd operand 16bit` | +| `OP_EXT3` | `-` | `make 1st and 2nd operands 16bit` | +| `OP_STOP` | `-` | `stop VM` | +| ------------------ | -------------- | ---------------------------------------------------------- | diff --git a/mrbgems/mruby-io/README.md b/mrbgems/mruby-io/README.md index c07a6e89b..3e601b62a 100644 --- a/mrbgems/mruby-io/README.md +++ b/mrbgems/mruby-io/README.md @@ -16,158 +16,158 @@ Add the line below to your build configuration. * -| method | mruby-io | memo | -| ------------------------- | -------- | ---- | -| IO.binread | | | -| IO.binwrite | | | -| IO.copy_stream | | | -| IO.new, IO.for_fd, IO.open | o | | -| IO.foreach | | | -| IO.pipe | o | | -| IO.popen | o | | -| IO.read | o | | -| IO.readlines | | | -| IO.select | o | | -| IO.sysopen | o | | -| IO.try_convert | | | -| IO.write | | | -| IO#<< | | | -| IO#advise | | | -| IO#autoclose= | | | -| IO#autoclose? | | | -| IO#binmode | | | -| IO#binmode? | | | +| method | mruby-io | memo | +|----------------------------|----------|----------| +| IO.binread | | | +| IO.binwrite | | | +| IO.copy_stream | | | +| IO.new, IO.for_fd, IO.open | o | | +| IO.foreach | | | +| IO.pipe | o | | +| IO.popen | o | | +| IO.read | o | | +| IO.readlines | | | +| IO.select | o | | +| IO.sysopen | o | | +| IO.try_convert | | | +| IO.write | | | +| IO#<< | | | +| IO#advise | | | +| IO#autoclose= | | | +| IO#autoclose? | | | +| IO#binmode | | | +| IO#binmode? | | | | IO#bytes | | obsolete | | IO#chars | | obsolete | -| IO#clone, IO#dup | o | | -| IO#close | o | | -| IO#close_on_exec= | o | | -| IO#close_on_exec? | o | | -| IO#close_read | | | -| IO#close_write | | | -| IO#closed? | o | | +| IO#clone, IO#dup | o | | +| IO#close | o | | +| IO#close_on_exec= | o | | +| IO#close_on_exec? | o | | +| IO#close_read | | | +| IO#close_write | | | +| IO#closed? | o | | | IO#codepoints | | obsolete | -| IO#each_byte | o | | -| IO#each_char | o | | -| IO#each_codepoint | | | -| IO#each_line | o | | -| IO#eof, IO#eof? | o | | -| IO#external_encoding | | | -| IO#fcntl | | | -| IO#fdatasync | | | -| IO#fileno, IO#to_i | o | | -| IO#flush | o | | -| IO#fsync | | | -| IO#getbyte | o | | -| IO#getc | o | | -| IO#gets | o | | -| IO#internal_encoding | | | -| IO#ioctl | | | -| IO#isatty, IO#tty? | o | | -| IO#lineno | | | -| IO#lineno= | | | +| IO#each_byte | o | | +| IO#each_char | o | | +| IO#each_codepoint | | | +| IO#each_line | o | | +| IO#eof, IO#eof? | o | | +| IO#external_encoding | | | +| IO#fcntl | | | +| IO#fdatasync | | | +| IO#fileno, IO#to_i | o | | +| IO#flush | o | | +| IO#fsync | | | +| IO#getbyte | o | | +| IO#getc | o | | +| IO#gets | o | | +| IO#internal_encoding | | | +| IO#ioctl | | | +| IO#isatty, IO#tty? | o | | +| IO#lineno | | | +| IO#lineno= | | | | IO#lines | | obsolete | -| IO#pid | o | | -| IO#pos, IO#tell | o | | -| IO#pos= | o | | -| IO#print | o | | -| IO#printf | o | | -| IO#putc | | | -| IO#puts | o | | -| IO#read | o | | -| IO#read_nonblock | | | -| IO#readbyte | o | | -| IO#readchar | o | | -| IO#readline | o | | -| IO#readlines | o | | -| IO#readpartial | | | -| IO#reopen | | | -| IO#rewind | | | -| IO#seek | o | | -| IO#set_encoding | | | -| IO#stat | | | -| IO#sync | o | | -| IO#sync= | o | | -| IO#sysread | o | | -| IO#sysseek | o | | -| IO#syswrite | o | | -| IO#to_io | | | -| IO#ungetbyte | o | | -| IO#ungetc | o | | -| IO#write | o | | -| IO#write_nonblock | | | +| IO#pid | o | | +| IO#pos, IO#tell | o | | +| IO#pos= | o | | +| IO#print | o | | +| IO#printf | o | | +| IO#putc | | | +| IO#puts | o | | +| IO#read | o | | +| IO#read_nonblock | | | +| IO#readbyte | o | | +| IO#readchar | o | | +| IO#readline | o | | +| IO#readlines | o | | +| IO#readpartial | | | +| IO#reopen | | | +| IO#rewind | | | +| IO#seek | o | | +| IO#set_encoding | | | +| IO#stat | | | +| IO#sync | o | | +| IO#sync= | o | | +| IO#sysread | o | | +| IO#sysseek | o | | +| IO#syswrite | o | | +| IO#to_io | | | +| IO#ungetbyte | o | | +| IO#ungetc | o | | +| IO#write | o | | +| IO#write_nonblock | | | ### File * -| method | mruby-io | memo | -| --------------------------- | -------- | ---- | -| File.absolute_path | | | -| File.atime | | | -| File.basename | o | | +| method | mruby-io | memo | +|-----------------------------|----------|----------| +| File.absolute_path | | | +| File.atime | | | +| File.basename | o | | | File.blockdev? | | FileTest | | File.chardev? | | FileTest | -| File.chmod | o | | -| File.chown | | | -| File.ctime | | | -| File.delete, File.unlink | o | | -| File.directory? | o | FileTest | -| File.dirname | o | | +| File.chmod | o | | +| File.chown | | | +| File.ctime | | | +| File.delete, File.unlink | o | | +| File.directory? | o | FileTest | +| File.dirname | o | | | File.executable? | | FileTest | | File.executable_real? | | FileTest | -| File.exist?, exists? | o | FileTest | -| File.expand_path | o | | -| File.extname | o | | -| File.file? | o | FileTest | -| File.fnmatch, File.fnmatch? | | | -| File.ftype | | | +| File.exist?, exists? | o | FileTest | +| File.expand_path | o | | +| File.extname | o | | +| File.file? | o | FileTest | +| File.fnmatch, File.fnmatch? | | | +| File.ftype | | | | File.grpowned? | | FileTest | | File.identical? | | FileTest | -| File.join | o | | -| File.lchmod | | | -| File.lchown | | | -| File.link | | | -| File.lstat | | | -| File.mtime | | | -| File.new, File.open | o | | +| File.join | o | | +| File.lchmod | | | +| File.lchown | | | +| File.link | | | +| File.lstat | | | +| File.mtime | | | +| File.new, File.open | o | | | File.owned? | | FileTest | -| File.path | | | -| File.pipe? | o | FileTest | +| File.path | | | +| File.pipe? | o | FileTest | | File.readable? | | FileTest | | File.readable_real? | | FileTest | -| File.readlink | o | | -| File.realdirpath | | | -| File.realpath | o | | -| File.rename | o | | +| File.readlink | o | | +| File.realdirpath | | | +| File.realpath | o | | +| File.rename | o | | | File.setgid? | | FileTest | | File.setuid? | | FileTest | -| File.size | o | | -| File.size? | o | FileTest | -| File.socket? | o | FileTest | -| File.split | | | -| File.stat | | | +| File.size | o | | +| File.size? | o | FileTest | +| File.socket? | o | FileTest | +| File.split | | | +| File.stat | | | | File.sticky? | | FileTest | -| File.symlink | | | -| File.symlink? | o | FileTest | -| File.truncate | | | -| File.umask | o | | -| File.utime | | | -| File.world_readable? | | | -| File.world_writable? | | | +| File.symlink | | | +| File.symlink? | o | FileTest | +| File.truncate | | | +| File.umask | o | | +| File.utime | | | +| File.world_readable? | | | +| File.world_writable? | | | | File.writable? | | FileTest | | File.writable_real? | | FileTest | -| File.zero? | o | FileTest | -| File#atime | | | -| File#chmod | | | -| File#chown | | | -| File#ctime | | | -| File#flock | o | | -| File#lstat | | | -| File#mtime | | | -| File#path, File#to_path | o | | -| File#size | | | -| File#truncate | | | +| File.zero? | o | FileTest | +| File#atime | | | +| File#chmod | | | +| File#chown | | | +| File#ctime | | | +| File#flock | o | | +| File#lstat | | | +| File#mtime | | | +| File#path, File#to_path | o | | +| File#size | | | +| File#truncate | | | ## License From b4168c9b68daf759ce890c7da9e4ad5547058330 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 25 Mar 2022 07:45:06 +0900 Subject: [PATCH 170/292] parse.y: empty here-doc delimiter caused infinite loop; fix #5676 --- mrbgems/mruby-compiler/core/parse.y | 2 +- mrbgems/mruby-compiler/core/y.tab.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 9e3f35bd7..7039c4507 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -4856,7 +4856,7 @@ parse_string(parser_state *p) --len; } } - if ((len-1 == hinf->term_len) && (strncmp(s, hinf->term, len-1) == 0)) { + if (hinf->term_len > 0 && len-1 == hinf->term_len && strncmp(s, hinf->term, len-1) == 0) { heredoc_remove_indent(p, hinf); return tHEREDOC_END; } diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 2ba45e94e..826be9d70 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -11087,7 +11087,7 @@ parse_string(parser_state *p) --len; } } - if ((len-1 == hinf->term_len) && (strncmp(s, hinf->term, len-1) == 0)) { + if (hinf->term_len > 0 && len-1 == hinf->term_len && strncmp(s, hinf->term, len-1) == 0) { heredoc_remove_indent(p, hinf); return tHEREDOC_END; } From aaa28a508903041dd7399d4159a8ace9766b022f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 25 Mar 2022 12:42:12 +0900 Subject: [PATCH 171/292] vm.c: stack may be reallocated in functions calls. Probably due to recursive VM calls via `mrb_funcall()`. --- src/vm.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/src/vm.c b/src/vm.c index 8b81031a3..fd17e90cc 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1394,14 +1394,16 @@ RETRY_TRY_BLOCK: regs[a] = mrb_ary_entry(va, mrb_integer(vb)); break; case MRB_TT_HASH: - regs[a] = mrb_hash_get(mrb, va, vb); + va = mrb_hash_get(mrb, va, vb); + regs[a] = va; break; case MRB_TT_STRING: switch (mrb_type(vb)) { case MRB_TT_INTEGER: case MRB_TT_STRING: case MRB_TT_RANGE: - regs[a] = mrb_str_aref(mrb, va, vb, mrb_undef_value()); + va = mrb_str_aref(mrb, va, vb, mrb_undef_value()); + regs[a] = va; break; default: goto getidx_fallback; @@ -1423,7 +1425,8 @@ RETRY_TRY_BLOCK: } CASE(OP_GETCONST, BB) { - regs[a] = mrb_vm_const_get(mrb, syms[b]); + mrb_value v = mrb_vm_const_get(mrb, syms[b]); + regs[a] = v; NEXT; } @@ -1433,7 +1436,8 @@ RETRY_TRY_BLOCK: } CASE(OP_GETMCNST, BB) { - regs[a] = mrb_const_get(mrb, regs[a], syms[b]); + mrb_value v = mrb_const_get(mrb, regs[a], syms[b]); + regs[a] = v; NEXT; } @@ -2014,14 +2018,15 @@ RETRY_TRY_BLOCK: CASE(OP_KARG, BB) { mrb_value k = mrb_symbol_value(syms[b]); mrb_int kidx = mrb_ci_kidx(mrb->c->ci); - mrb_value kdict; + mrb_value kdict, v; if (kidx < 0 || !mrb_hash_p(kdict=regs[kidx]) || !mrb_hash_key_p(mrb, kdict, k)) { mrb_value str = mrb_format(mrb, "missing keyword: %v", k); mrb_exc_set(mrb, mrb_exc_new_str(mrb, E_ARGUMENT_ERROR, str)); goto L_RAISE; } - regs[a] = mrb_hash_get(mrb, kdict, k); + v = mrb_hash_get(mrb, kdict, k); + regs[a] = v; mrb_hash_delete_key(mrb, kdict, k); NEXT; } From 4b118fcb0c7b3cdcafdd1897d79a66850817ba73 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 25 Mar 2022 14:08:20 +0000 Subject: [PATCH 172/292] build(deps): bump github/super-linter from 4.9.0 to 4.9.1 Bumps [github/super-linter](https://github.com/github/super-linter) from 4.9.0 to 4.9.1. - [Release notes](https://github.com/github/super-linter/releases) - [Changelog](https://github.com/github/super-linter/blob/main/docs/release-process.md) - [Commits](https://github.com/github/super-linter/compare/v4.9.0...v4.9.1) --- updated-dependencies: - dependency-name: github/super-linter dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- .github/workflows/super-linter.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/super-linter.yml b/.github/workflows/super-linter.yml index d0b0fe8f8..94e919e16 100644 --- a/.github/workflows/super-linter.yml +++ b/.github/workflows/super-linter.yml @@ -13,7 +13,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - uses: github/super-linter@v4.9.0 + - uses: github/super-linter@v4.9.1 env: ERROR_ON_MISSING_EXEC_BIT: true VALIDATE_BASH: true From 90969cef4c298d3fca0bcbdb7868b8113a820c67 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 26 Mar 2022 11:10:12 +0900 Subject: [PATCH 173/292] codegen.c: fix the negative division regression; fix #5678 --- mrbgems/mruby-compiler/core/codegen.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 3d086de70..1a4f6b213 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -852,7 +852,7 @@ gen_muldiv(codegen_scope *s, uint8_t op, uint16_t dst) } else { /* OP_DIV */ if (n0 == MRB_INT_MIN && n == -1) goto normal; - n = n0 / n; + n = mrb_div_int(s->mrb, n0, n); } s->pc = addr_pc(s, data0.addr); gen_int(s, dst, n); From a91b55f5ca6828f5a15fbb6a673c7b2da3ff6647 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 26 Mar 2022 11:11:00 +0900 Subject: [PATCH 174/292] codegen.c: allow constant folding for multiply with zero. --- mrbgems/mruby-compiler/core/codegen.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 1a4f6b213..258aee8ae 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -844,13 +844,14 @@ gen_muldiv(codegen_scope *s, uint8_t op, uint16_t dst) goto normal; } struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr)); - if (!get_int_operand(s, &data0, &n0) || n == 0) { + if (!get_int_operand(s, &data0, &n0)) { goto normal; } if (op == OP_MUL) { if (mrb_int_mul_overflow(n0, n, &n)) goto normal; } else { /* OP_DIV */ + if (n == 0) goto normal; if (n0 == MRB_INT_MIN && n == -1) goto normal; n = mrb_div_int(s->mrb, n0, n); } From bf5bbf0a4b7f19ea3960e59f32ec252b3aee2c1a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 26 Mar 2022 11:23:17 +0900 Subject: [PATCH 175/292] test/integer: test negative integer divisions; ref #5678 --- test/t/integer.rb | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/t/integer.rb b/test/t/integer.rb index 71066bfb1..5a5098b92 100644 --- a/test/t/integer.rb +++ b/test/t/integer.rb @@ -40,6 +40,10 @@ assert('Integer#/', '15.2.8.3.4') do assert_equal 2, a a = 5/2 assert_equal 2, a + b = -1/2 + assert_equal(-1, b) + b = 1/-2 + assert_equal(-1, b) skip unless Object.const_defined?(:Float) b = 2/1.0 assert_equal 2.0, b From 7f5a490d09f4d56801ac3a3e4e39e03e1471b44c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 26 Mar 2022 21:06:02 +0900 Subject: [PATCH 176/292] vm.c: vm.c: stack may be reallocated in functions calls; aaa28a5 `mrb_range_new()` also calls VM recursively. --- src/vm.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/vm.c b/src/vm.c index fd17e90cc..77edbb38f 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2819,13 +2819,15 @@ RETRY_TRY_BLOCK: } CASE(OP_RANGE_INC, B) { - regs[a] = mrb_range_new(mrb, regs[a], regs[a+1], FALSE); + mrb_value v = mrb_range_new(mrb, regs[a], regs[a+1], FALSE); + regs[a] = v; mrb_gc_arena_restore(mrb, ai); NEXT; } CASE(OP_RANGE_EXC, B) { - regs[a] = mrb_range_new(mrb, regs[a], regs[a+1], TRUE); + mrb_value v = mrb_range_new(mrb, regs[a], regs[a+1], TRUE); + regs[a] = v; mrb_gc_arena_restore(mrb, ai); NEXT; } From 91255c7e9fbcfabae9b9f42a4016c02a45d7c5c9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 26 Mar 2022 22:57:41 +0900 Subject: [PATCH 177/292] mrblib/array.rb: `Array#<=>` to handle `NoMethodError` exception. Array element may not respond to `<=>` method. --- mrblib/array.rb | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/mrblib/array.rb b/mrblib/array.rb index 6b4f74b96..cef944f8a 100644 --- a/mrblib/array.rb +++ b/mrblib/array.rb @@ -167,10 +167,14 @@ class Array n = other.size len = n if len > n i = 0 - while i < len - n = (self[i] <=> other[i]) - return n if n.nil? || n != 0 - i += 1 + begin + while i < len + n = (self[i] <=> other[i]) + return n if n.nil? || n != 0 + i += 1 + end + rescue NoMethodError + return nil end len = self.size - other.size if len == 0 From f9d72908cade1f00026d99ca1d4bf1be3b355723 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 27 Mar 2022 11:26:43 +0900 Subject: [PATCH 178/292] Remove old compatibility code The `mrb_voidp()` related macros have been removed in mruby-1.1.0. --- mrbgems/mruby-socket/src/socket.c | 6 ------ 1 file changed, 6 deletions(-) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index cd7470121..a79e33652 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -52,12 +52,6 @@ #define E_SOCKET_ERROR mrb_class_get_id(mrb, MRB_SYM(SocketError)) -#if !defined(mrb_cptr) -#define mrb_cptr_value(m,p) mrb_voidp_value((m),(p)) -#define mrb_cptr(o) mrb_voidp(o) -#define mrb_cptr_p(o) mrb_voidp_p(o) -#endif - #ifdef _WIN32 static const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt) { From 9593c156031a7b18b403caf8b43e145289bbbdf5 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 28 Mar 2022 17:19:36 +0900 Subject: [PATCH 179/292] AUTHORS: update entries [ci skip] --- AUTHORS | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/AUTHORS b/AUTHORS index 2ed71ed02..e6ed326d6 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,11 +1,11 @@ # Authors of mruby (mruby developers) -## The List of Contributors sorted by number of commits (as of 2022-02-27 57540fb) +## The List of Contributors sorted by number of commits (as of 2022-03-27 bb5f6a8) - 8048 Yukihiro "Matz" Matsumoto (@matz)* + 8121 Yukihiro "Matz" Matsumoto (@matz)* 586 KOBAYASHI Shuji (@shuujii) 376 Daniel Bovensiepen (@bovi) - 352 dearblue (@dearblue)* + 363 dearblue (@dearblue)* 346 Takeshi Watanabe (@take-cheeze)* 334 Masaki Muranaka (@monaka) 308 Tomoyuki Sahara (@tsahara)* @@ -25,7 +25,7 @@ 59 Kurebayashi, Takahiro (@crimsonwoods)* 56 h2so5 (@h2so5) 52 Ralph Desir (@Mav7)* - 50 John Bampton (@jbampton) + 51 John Bampton (@jbampton) 45 Rory O'Connell (@RoryO)* 43 Yuichiro Kaneko (@yui-knk)+ 42 fleuria (@flaneur2020) @@ -129,6 +129,7 @@ 3 Carlo Prelz (@asfluido)* 3 David Turnbull (@AE9RB) 3 Franck Verrot (@franckverrot) + 3 HASUMI Hitoshi (@hasumikin) 3 Horimoto Yasuhiro (@komainu8) 3 J. Mutua (@katmutua)+ 3 Jan Berdajs (@mrbrdo) @@ -159,7 +160,6 @@ 2 Francois Chagnon (@EiNSTeiN-)* 2 Gilad Zohari (@gzohari) 2 Go Saito (@govm) - 2 HASUMI Hitoshi (@hasumikin) 2 Hirohito Higashi (@HirohitoHigashi) 2 Hiroyuki Iwatsuki (@iwadon) 2 Huei-Horng Yo (@hiroshiyui) @@ -197,7 +197,6 @@ 1 Atsushi Morimoto (@mynz) 1 Ben A Morgan (@BenMorganIO) 1 Benoit Daloze (@eregon) - 1 Chris Reuter (@suetanvil) 1 Daehyub Kim (@lateau) 1 Daniel Varga (@vargad) 1 Edgar Boda-Majer (@eboda) From 60cf382ff9765e36b21143d79688a3e758b66fd4 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 29 Mar 2022 22:36:40 +0900 Subject: [PATCH 180/292] codegen.c: peephole optimize consecutive `MOVE` instructions. --- mrbgems/mruby-compiler/core/codegen.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 258aee8ae..50dac1a46 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -594,9 +594,18 @@ gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep) switch (data.insn) { case OP_MOVE: - if (dst == src) return; /* remove useless MOVE */ - if (data.b == dst && data.a == src) /* skip swapping MOVE */ + if (dst == src) return; /* remove useless MOVE */ + if (data.a == src) { + if (data.b == dst) /* skip swapping MOVE */ + return; + if (data.a < s->nlocals) goto normal; + rewind_pc(s); + genop_2(s, OP_MOVE, dst, data.b); return; + } + if (dst == data.a) { /* skip overwritten move */ + rewind_pc(s); + } goto normal; case OP_LOADNIL: case OP_LOADSELF: case OP_LOADT: case OP_LOADF: case OP_LOADI__1: From a3f2c95334873aa1685b50df20bfe79215c6e814 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 30 Mar 2022 15:34:40 +0900 Subject: [PATCH 181/292] codegen.c: skip overwritten `MOVE` instructions. --- mrbgems/mruby-compiler/core/codegen.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 50dac1a46..b59f8d432 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -600,11 +600,15 @@ gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep) return; if (data.a < s->nlocals) goto normal; rewind_pc(s); - genop_2(s, OP_MOVE, dst, data.b); + s->lastpc = addr_pc(s, mrb_prev_pc(s, data.addr)); + gen_move(s, dst, data.b, FALSE); return; } if (dst == data.a) { /* skip overwritten move */ rewind_pc(s); + s->lastpc = addr_pc(s, mrb_prev_pc(s, data.addr)); + gen_move(s, dst, src, FALSE); + return; } goto normal; case OP_LOADNIL: case OP_LOADSELF: case OP_LOADT: case OP_LOADF: From cc380c654682148e1a4df257a9583c2d7bc63b97 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Fri, 1 Apr 2022 08:26:29 +1000 Subject: [PATCH 182/292] pre-commit autoupdate https://pre-commit.com/#pre-commit-autoupdate --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index a39da4e08..f91ef3e90 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -39,7 +39,7 @@ repos: description: Check spelling with codespell entry: codespell --ignore-words=codespell.txt - repo: https://github.com/igorshubovych/markdownlint-cli - rev: v0.31.0 + rev: v0.31.1 hooks: - id: markdownlint name: Run markdownlint From d1f1b4ea38cd5a2a9d0b2aa3547d4f2828180299 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 31 Mar 2022 18:28:01 +0900 Subject: [PATCH 183/292] cdump.c: add `const` qualifier for line number arrays. --- include/mruby/debug.h | 7 ++++--- src/cdump.c | 6 +++--- src/debug.c | 12 ++++++------ src/load.c | 17 ++++++++++------- src/symbol.c | 6 +++--- 5 files changed, 26 insertions(+), 22 deletions(-) diff --git a/include/mruby/debug.h b/include/mruby/debug.h index 7319ccb3f..4a62cce42 100644 --- a/include/mruby/debug.h +++ b/include/mruby/debug.h @@ -31,10 +31,11 @@ typedef struct mrb_irep_debug_info_file { uint32_t line_entry_count; mrb_debug_line_type line_type; union { + const char *s; void *ptr; - uint16_t *ary; - mrb_irep_debug_info_line *flat_map; - uint8_t *packed_map; + const uint16_t *ary; + const mrb_irep_debug_info_line *flat_map; + const uint8_t *packed_map; } lines; } mrb_irep_debug_info_file; diff --git a/src/cdump.c b/src/cdump.c index b4dfc4e87..12173583d 100644 --- a/src/cdump.c +++ b/src/cdump.c @@ -302,7 +302,7 @@ cdump_debug(mrb_state *mrb, const char *name, int n, mrb_irep_debug_info *info, line_type = "mrb_debug_line_flat_map"; fprintf(fp, "static struct mrb_irep_debug_info_line %s_debug_lines_%d[%d] = {", name, n, len); for (i=0; ifiles[0]->lines.flat_map[i]; + const mrb_irep_debug_info_line *fmap = &info->files[0]->lines.flat_map[i]; fprintf(fp, "\t{.start_pos=0x%04x,.line=%d},\n", fmap->start_pos, fmap->line); } fputs("};\n", fp); @@ -310,8 +310,8 @@ cdump_debug(mrb_state *mrb, const char *name, int n, mrb_irep_debug_info *info, case mrb_debug_line_packed_map: line_type = "mrb_debug_line_packed_map"; - fprintf(fp, "static char %s_debug_lines_%d[] = \"", name, n); - uint8_t *pmap = info->files[0]->lines.packed_map; + fprintf(fp, "static const char %s_debug_lines_%d[] = \"", name, n); + const uint8_t *pmap = info->files[0]->lines.packed_map; for (i=0; ilines.flat_map; + const mrb_irep_debug_info_line *ret = f->lines.flat_map; uint32_t count = f->line_entry_count; while (count > 0) { int32_t step = count / 2; - mrb_irep_debug_info_line *it = ret + step; + const mrb_irep_debug_info_line *it = ret + step; if (!(pc < it->start_pos)) { ret = it + 1; count -= step + 1; @@ -131,8 +131,8 @@ mrb_debug_get_line(mrb_state *mrb, const mrb_irep *irep, uint32_t pc) } case mrb_debug_line_packed_map: { - uint8_t *p = f->lines.packed_map; - uint8_t *pend = p + f->line_entry_count; + const uint8_t *p = f->lines.packed_map; + const uint8_t *pend = p + f->line_entry_count; uint32_t pos = 0, line = 0, line_diff; while (p < pend) { pos += mrb_packed_int_decode(p, &p); @@ -209,7 +209,7 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *d, packed_size += mrb_packed_int_len(lines[start_pos+i]-prev_line); prev_line = lines[start_pos + i]; } - p = f->lines.packed_map = (uint8_t*)mrb_malloc(mrb, packed_size); + f->lines.packed_map = p = (uint8_t*)mrb_malloc(mrb, packed_size); pend = p + packed_size; prev_line = 0; prev_pc = 0; for (i = 0; i < file_pc_count; ++i) { diff --git a/src/load.c b/src/load.c index bb22a6130..d8e2b22ac 100644 --- a/src/load.c +++ b/src/load.c @@ -352,11 +352,12 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, const uint8_t *end, mrb_ size_t l = sizeof(uint16_t) * (size_t)file->line_entry_count; if (bin + l > end) return MRB_DUMP_GENERAL_FAILURE; - file->lines.ary = (uint16_t *)mrb_malloc(mrb, l); + uint16_t *ary = (uint16_t *)mrb_malloc(mrb, l); for (l = 0; l < file->line_entry_count; ++l) { - file->lines.ary[l] = bin_to_uint16(bin); + ary[l] = bin_to_uint16(bin); bin += sizeof(uint16_t); } + file->lines.ary = ary; } break; case mrb_debug_line_flat_map: { @@ -364,21 +365,23 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, const uint8_t *end, mrb_ size_t n = sizeof(mrb_irep_debug_info_line); if (bin + c*n > end) return MRB_DUMP_GENERAL_FAILURE; - file->lines.flat_map = (mrb_irep_debug_info_line*)mrb_calloc(mrb, c, n); + mrb_irep_debug_info_line *flat_map = (mrb_irep_debug_info_line*)mrb_calloc(mrb, c, n); for (size_t l = 0; l < file->line_entry_count; ++l) { - file->lines.flat_map[l].start_pos = bin_to_uint32(bin); + flat_map[l].start_pos = bin_to_uint32(bin); bin += sizeof(uint32_t); - file->lines.flat_map[l].line = bin_to_uint16(bin); + flat_map[l].line = bin_to_uint16(bin); bin += sizeof(uint16_t); } + file->lines.flat_map = flat_map; } break; case mrb_debug_line_packed_map: { size_t l = (size_t)file->line_entry_count; if (bin + l > end) return MRB_DUMP_GENERAL_FAILURE; - file->lines.packed_map = (uint8_t*)mrb_calloc(mrb, 1, l); - memcpy(file->lines.packed_map, bin, file->line_entry_count); + uint8_t *packed_map = (uint8_t*)mrb_malloc(mrb, l); + memcpy(packed_map, bin, file->line_entry_count); + file->lines.packed_map = packed_map; bin += file->line_entry_count; } break; diff --git a/src/symbol.c b/src/symbol.c index cc8986eaa..c371752c9 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -136,7 +136,7 @@ symhash(const char *key, size_t len) size_t mrb_packed_int_len(uint32_t num); size_t mrb_packed_int_encode(uint32_t num, uint8_t *p, uint8_t *pend); -uint32_t mrb_packed_int_decode(uint8_t *p, uint8_t **newpos); +uint32_t mrb_packed_int_decode(const uint8_t *p, const uint8_t **newpos); #define sym_lit_p(mrb, i) (mrb->symflags[i>>3]&(1<<(i&7))) #define sym_lit_set(mrb, i) mrb->symflags[i>>3]|=(1<<(i&7)) @@ -154,7 +154,7 @@ sym_check(mrb_state *mrb, const char *name, size_t len, mrb_sym i) } else { /* length in BER */ - symlen = mrb_packed_int_decode((uint8_t*)symname, (uint8_t**)&symname); + symlen = mrb_packed_int_decode((const uint8_t*)symname, (const uint8_t**)&symname); } if (len == symlen && memcmp(symname, name, len) == 0) { return TRUE; @@ -347,7 +347,7 @@ sym2name_len(mrb_state *mrb, mrb_sym sym, char *buf, mrb_int *lenp) const char *symname = mrb->symtbl[sym]; if (!sym_lit_p(mrb, sym)) { - size_t len = mrb_packed_int_decode((uint8_t*)symname, (uint8_t**)&symname); + uint32_t len = mrb_packed_int_decode((const uint8_t*)symname, (const uint8_t**)&symname); if (lenp) *lenp = (mrb_int)len; } else if (lenp) { From 00acae117da1b45b318dc36531a7b0021b8097ae Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 1 Apr 2022 16:40:06 +0900 Subject: [PATCH 184/292] vm.c: target class may be NULL. --- src/vm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/vm.c b/src/vm.c index 77edbb38f..3bb9510ec 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1749,7 +1749,7 @@ RETRY_TRY_BLOCK: } else if (target_class->tt == MRB_TT_MODULE) { target_class = mrb_vm_ci_target_class(ci); - if (target_class->tt != MRB_TT_ICLASS) { + if (!target_class || target_class->tt != MRB_TT_ICLASS) { goto super_typeerror; } } From 7d85092bc4e1b3d2a204af50906adb144502571f Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 13 Mar 2022 15:20:12 +0900 Subject: [PATCH 185/292] Reorganize the `struct RException::mesg` member There is no need to limit the type to `struct RString`. Also, the `MRB_EXC_MESG_STRING_FLAG` flag can be eliminated by checking if `struct RException::mesg` is `NULL` or not. ref. #2485 --- include/mruby/error.h | 3 +-- src/error.c | 17 ++++++----------- src/gc.c | 4 ++-- 3 files changed, 9 insertions(+), 15 deletions(-) diff --git a/include/mruby/error.h b/include/mruby/error.h index fb3557405..01082f931 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -17,11 +17,10 @@ MRB_BEGIN_DECL struct RException { MRB_OBJECT_HEADER; struct iv_tbl *iv; - struct RString *mesg; + struct RObject *mesg; // NULL or probably RString }; #define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v)) -#define MRB_EXC_MESG_STRING_FLAG 0x100 MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg); MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str); diff --git a/src/error.c b/src/error.c index 46d26bece..1a8f65dbf 100644 --- a/src/error.c +++ b/src/error.c @@ -20,26 +20,21 @@ void mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg) { - if (mrb_string_p(mesg)) { - exc->flags |= MRB_EXC_MESG_STRING_FLAG; - exc->mesg = RSTRING(mesg); + if (!mrb_immediate_p(mesg)) { + exc->mesg = mrb_obj_ptr(mesg); mrb_field_write_barrier_value(mrb, (struct RBasic*)exc, mesg); + mrb_iv_remove(mrb, mrb_obj_value(exc), MRB_SYM(mesg)); } else { - exc->flags &= ~MRB_EXC_MESG_STRING_FLAG; - if (mrb_nil_p(mesg)) { - exc->mesg = 0; - } - else { - mrb_obj_iv_set(mrb, (struct RObject*)exc, MRB_SYM(mesg), mesg); - } + exc->mesg = NULL; + mrb_obj_iv_set(mrb, (struct RObject*)exc, MRB_SYM(mesg), mesg); } } mrb_value mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc) { - if ((exc->flags & MRB_EXC_MESG_STRING_FLAG) != 0) { + if (exc->mesg) { return mrb_obj_value(exc->mesg); } else { diff --git a/src/gc.c b/src/gc.c index a6ff0c588..1a139fcf9 100644 --- a/src/gc.c +++ b/src/gc.c @@ -760,7 +760,7 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) case MRB_TT_EXCEPTION: mrb_gc_mark_iv(mrb, (struct RObject*)obj); - if ((obj->flags & MRB_EXC_MESG_STRING_FLAG) != 0) { + if (((struct RException*)obj)->mesg) { mrb_gc_mark(mrb, (struct RBasic*)((struct RException*)obj)->mesg); } break; @@ -1049,7 +1049,7 @@ gc_gray_counts(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) case MRB_TT_EXCEPTION: children += mrb_gc_mark_iv_size(mrb, (struct RObject*)obj); - if ((obj->flags & MRB_EXC_MESG_STRING_FLAG) != 0) { + if (((struct RException*)obj)->mesg) { children++; } break; From 92ef9f1a9e46f448d93d9cc641be435a97703ffc Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 13 Mar 2022 15:39:07 +0900 Subject: [PATCH 186/292] Store backtrace to field of `struct RException` Since the possible values of the backtrace are limited to `nil`, `RData`, and `RAray`, they are now stored as object pointers. This change saves memory by eliminating the need to use instance variables for common exceptions. ref. #2485 --- include/mruby/error.h | 1 + src/backtrace.c | 76 +++++++++++++++++++++++-------------------- src/error.c | 3 +- src/gc.c | 4 +++ 4 files changed, 48 insertions(+), 36 deletions(-) diff --git a/include/mruby/error.h b/include/mruby/error.h index 01082f931..7226b98b6 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -18,6 +18,7 @@ struct RException { MRB_OBJECT_HEADER; struct iv_tbl *iv; struct RObject *mesg; // NULL or probably RString + struct RObject *backtrace; // NULL, RArray or RData }; #define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v)) diff --git a/src/backtrace.c b/src/backtrace.c index d6648cc43..7b25bb331 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -27,7 +27,7 @@ typedef void (*each_backtrace_func)(mrb_state*, const struct backtrace_location* static const mrb_data_type bt_type = { "Backtrace", mrb_free }; mrb_value mrb_exc_inspect(mrb_state *mrb, mrb_value exc); -mrb_value mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace); +struct RObject *mrb_unpack_backtrace(mrb_state *mrb, struct RObject *backtrace); static void each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, each_backtrace_func func, void *data) @@ -97,17 +97,17 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, each_backtrace_func func, void * #ifndef MRB_NO_STDIO static void -print_backtrace(mrb_state *mrb, struct RObject *exc, mrb_value backtrace) +print_backtrace(mrb_state *mrb, struct RObject *exc, struct RArray *backtrace) { mrb_int i; - mrb_int n = RARRAY_LEN(backtrace); + mrb_int n = ARY_LEN(backtrace); mrb_value *loc, mesg; if (n != 0) { if (n > 1) { fprintf(stderr, "trace (most recent call last):\n"); } - for (i=n-1,loc=&RARRAY_PTR(backtrace)[i]; i>0; i--,loc--) { + for (i=n-1,loc=&ARY_PTR(backtrace)[i]; i>0; i--,loc--) { if (mrb_string_p(*loc)) { fprintf(stderr, "\t[%d] %.*s\n", (int)i, (int)RSTRING_LEN(*loc), RSTRING_PTR(*loc)); @@ -130,16 +130,14 @@ print_backtrace(mrb_state *mrb, struct RObject *exc, mrb_value backtrace) MRB_API void mrb_print_backtrace(mrb_state *mrb) { - mrb_value backtrace; - if (!mrb->exc) { return; } - backtrace = mrb_obj_iv_get(mrb, mrb->exc, MRB_SYM(backtrace)); - if (mrb_nil_p(backtrace)) return; - if (!mrb_array_p(backtrace)) backtrace = mrb_unpack_backtrace(mrb, backtrace); - print_backtrace(mrb, mrb->exc, backtrace); + struct RObject *backtrace = ((struct RException*)mrb->exc)->backtrace; + if (!backtrace) return; + if (backtrace->tt != MRB_TT_ARRAY) backtrace = mrb_unpack_backtrace(mrb, backtrace); + print_backtrace(mrb, mrb->exc, (struct RArray*)backtrace); } #else @@ -172,7 +170,7 @@ pack_backtrace_i(mrb_state *mrb, *pptr = ptr+1; } -static mrb_value +static struct RObject* packed_backtrace(mrb_state *mrb) { struct RData *backtrace; @@ -183,44 +181,51 @@ packed_backtrace(mrb_state *mrb) each_backtrace(mrb, ciidx, count_backtrace_i, &len); size = len * sizeof(struct backtrace_location); + backtrace = mrb_data_object_alloc(mrb, NULL, NULL, &bt_type); ptr = mrb_malloc(mrb, size); - backtrace = mrb_data_object_alloc(mrb, NULL, ptr, &bt_type); + backtrace->data = ptr; backtrace->flags = (uint32_t)len; each_backtrace(mrb, ciidx, pack_backtrace_i, &ptr); - return mrb_obj_value(backtrace); + return (struct RObject*)backtrace; +} + +static void +store_backtrace(mrb_state *mrb, mrb_value exc, struct RObject *backtrace) +{ + struct RException *e = mrb_exc_ptr(exc); + e->backtrace = backtrace; + mrb_field_write_barrier(mrb, (struct RBasic*)e, (struct RBasic*)backtrace); } void mrb_keep_backtrace(mrb_state *mrb, mrb_value exc) { - mrb_sym sym = MRB_SYM(backtrace); - mrb_value backtrace; int ai; - if (mrb_iv_defined(mrb, exc, sym)) return; + if (mrb_exc_ptr(exc)->backtrace) return; ai = mrb_gc_arena_save(mrb); - backtrace = packed_backtrace(mrb); - mrb_iv_set(mrb, exc, sym, backtrace); + struct RObject *backtrace = packed_backtrace(mrb); + store_backtrace(mrb, exc, backtrace); mrb_gc_arena_restore(mrb, ai); } -mrb_value -mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace) +struct RObject* +mrb_unpack_backtrace(mrb_state *mrb, struct RObject *backtrace) { const struct backtrace_location *bt; mrb_int n, i; int ai; - if (mrb_nil_p(backtrace)) { + if (backtrace == NULL) { empty_backtrace: - return mrb_ary_new_capa(mrb, 0); + return mrb_obj_ptr(mrb_ary_new_capa(mrb, 0)); } - if (mrb_array_p(backtrace)) return backtrace; - bt = (struct backtrace_location*)mrb_data_check_get_ptr(mrb, backtrace, &bt_type); + if (backtrace->tt == MRB_TT_ARRAY) return backtrace; + bt = (struct backtrace_location*)mrb_data_check_get_ptr(mrb, mrb_obj_value(backtrace), &bt_type); if (bt == NULL) goto empty_backtrace; - n = (mrb_int)RDATA(backtrace)->flags; + n = (mrb_int)backtrace->flags; if (n == 0) goto empty_backtrace; - backtrace = mrb_ary_new_capa(mrb, n); + backtrace = mrb_obj_ptr(mrb_ary_new_capa(mrb, n)); ai = mrb_gc_arena_save(mrb); for (i = 0; i < n; i++) { const struct backtrace_location *entry = &bt[i]; @@ -236,7 +241,7 @@ mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace) mrb_str_cat_lit(mrb, btline, ":in "); mrb_str_cat_cstr(mrb, btline, mrb_sym_name(mrb, entry->method_id)); } - mrb_ary_push(mrb, backtrace, btline); + mrb_ary_push(mrb, mrb_obj_value(backtrace), btline); mrb_gc_arena_restore(mrb, ai); } @@ -246,20 +251,21 @@ mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace) mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc) { - mrb_value backtrace; - - backtrace = mrb_iv_get(mrb, exc, MRB_SYM(backtrace)); - if (mrb_nil_p(backtrace) || mrb_array_p(backtrace)) { - return backtrace; + struct RObject *backtrace = mrb_exc_ptr(exc)->backtrace; + if (backtrace == NULL) { + return mrb_nil_value(); + } + if (backtrace->tt == MRB_TT_ARRAY) { + return mrb_obj_value(backtrace); } /* unpack packed-backtrace */ backtrace = mrb_unpack_backtrace(mrb, backtrace); - mrb_iv_set(mrb, exc, MRB_SYM(backtrace), backtrace); - return backtrace; + store_backtrace(mrb, exc, backtrace); + return mrb_obj_value(backtrace); } mrb_value mrb_get_backtrace(mrb_state *mrb) { - return mrb_unpack_backtrace(mrb, packed_backtrace(mrb)); + return mrb_obj_value(mrb_unpack_backtrace(mrb, packed_backtrace(mrb))); } diff --git a/src/error.c b/src/error.c index 1a8f65dbf..2a87887ee 100644 --- a/src/error.c +++ b/src/error.c @@ -182,7 +182,8 @@ set_backtrace(mrb_state *mrb, mrb_value exc, mrb_value backtrace) p++; } } - mrb_iv_set(mrb, exc, MRB_SYM(backtrace), backtrace); + mrb_exc_ptr(exc)->backtrace = mrb_obj_ptr(backtrace); + mrb_field_write_barrier_value(mrb, mrb_basic_ptr(exc), backtrace); } static mrb_value diff --git a/src/gc.c b/src/gc.c index 1a139fcf9..999acde92 100644 --- a/src/gc.c +++ b/src/gc.c @@ -763,6 +763,7 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) if (((struct RException*)obj)->mesg) { mrb_gc_mark(mrb, (struct RBasic*)((struct RException*)obj)->mesg); } + mrb_gc_mark(mrb, (struct RBasic*)((struct RException*)obj)->backtrace); break; default: @@ -1052,6 +1053,9 @@ gc_gray_counts(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) if (((struct RException*)obj)->mesg) { children++; } + if (((struct RException*)obj)->backtrace) { + children++; + } break; default: From b99c389ec3b8190e67532606384007d7173db9f5 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 2 Apr 2022 15:46:18 +0900 Subject: [PATCH 187/292] internal.h: aggregate internal functions. Internal functions can only be called from within the library. Functions listed in `mruby/internal.h` can be called from: * core (src/*.c) * gems (mrbgems/**/*.c) But not from the application linked with `libmruby`. --- include/mruby/array.h | 3 - include/mruby/class.h | 11 - include/mruby/dump.h | 5 - include/mruby/error.h | 5 - include/mruby/gc.h | 3 +- include/mruby/hash.h | 6 - include/mruby/internal.h | 157 ++ include/mruby/irep.h | 19 - include/mruby/numeric.h | 3 - include/mruby/proc.h | 4 - include/mruby/range.h | 2 - include/mruby/string.h | 18 - include/mruby/variable.h | 23 - mrbgems/mruby-array-ext/src/array.c | 1 + .../mruby-bin-debugger/tools/mrdb/apibreak.c | 7 +- mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c | 1 + mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c | 1 + .../tools/mruby-strip/mruby-strip.c | 1 + mrbgems/mruby-compiler/core/codegen.c | 1 + mrbgems/mruby-compiler/core/parse.y | 1 + mrbgems/mruby-compiler/core/y.tab.c | 2003 +++++++++-------- mrbgems/mruby-errno/src/errno.c | 3 +- mrbgems/mruby-io/src/io.c | 1 + mrbgems/mruby-kernel-ext/src/kernel.c | 1 + mrbgems/mruby-metaprog/src/metaprog.c | 1 + mrbgems/mruby-method/src/method.c | 1 + mrbgems/mruby-os-memsize/src/memsize.c | 1 + mrbgems/mruby-socket/src/socket.c | 1 + mrbgems/mruby-string-ext/src/string.c | 1 + mrbgems/mruby-struct/src/struct.c | 1 + mrbgems/mruby-symbol-ext/src/symbol.c | 1 + src/array.c | 1 + src/backtrace.c | 6 +- src/cdump.c | 1 + src/class.c | 5 +- src/codedump.c | 1 + src/error.c | 1 + src/gc.c | 1 + src/hash.c | 1 + src/kernel.c | 1 + src/load.c | 1 + src/numeric.c | 15 +- src/numops.c | 17 +- src/proc.c | 3 +- src/state.c | 1 + src/string.c | 1 + src/symbol.c | 5 +- src/variable.c | 1 + src/vm.c | 4 +- 49 files changed, 1201 insertions(+), 1152 deletions(-) create mode 100644 include/mruby/internal.h diff --git a/include/mruby/array.h b/include/mruby/array.h index 8bb652472..df5a16a91 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -85,7 +85,6 @@ struct RArray { #define ARY_SET_SHARED_FLAG(a) ((a)->flags |= MRB_ARY_SHARED) #define ARY_UNSET_SHARED_FLAG(a) ((a)->flags &= ~MRB_ARY_SHARED) -void mrb_ary_decref(mrb_state*, mrb_shared_array*); MRB_API void mrb_ary_modify(mrb_state*, struct RArray*); MRB_API mrb_value mrb_ary_new_capa(mrb_state*, mrb_int); @@ -296,8 +295,6 @@ MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep); */ MRB_API mrb_value mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len); -/* helper functions */ -mrb_value mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len); MRB_END_DECL diff --git a/include/mruby/class.h b/include/mruby/class.h index b97bc3991..ff16f1ac1 100644 --- a/include/mruby/class.h +++ b/include/mruby/class.h @@ -73,8 +73,6 @@ mrb_class(mrb_state *mrb, mrb_value v) #define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt))) #define MRB_INSTANCE_TT(c) (enum mrb_vtype)((c)->flags & MRB_INSTANCE_TT_MASK) -struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym); -struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym); MRB_API void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, mrb_method_t); MRB_API void mrb_alias_method(mrb_state*, struct RClass *c, mrb_sym a, mrb_sym b); MRB_API void mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym sym); @@ -83,15 +81,6 @@ MRB_API mrb_method_t mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym); MRB_API mrb_method_t mrb_method_search(mrb_state*, struct RClass*, mrb_sym); MRB_API struct RClass* mrb_class_real(struct RClass* cl); -mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); - -void mrb_class_name_class(mrb_state*, struct RClass*, struct RClass*, mrb_sym); -mrb_bool mrb_const_name_p(mrb_state*, const char*, mrb_int); -mrb_value mrb_class_find_path(mrb_state*, struct RClass*); -mrb_value mrb_mod_to_s(mrb_state*, mrb_value); -void mrb_gc_mark_mt(mrb_state*, struct RClass*); -size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*); -void mrb_gc_free_mt(mrb_state*, struct RClass*); #ifndef MRB_NO_METHOD_CACHE void mrb_mc_clear_by_class(mrb_state *mrb, struct RClass* c); diff --git a/include/mruby/dump.h b/include/mruby/dump.h index 20400714c..a976deef0 100644 --- a/include/mruby/dump.h +++ b/include/mruby/dump.h @@ -21,12 +21,7 @@ MRB_BEGIN_DECL #define MRB_DUMP_STATIC 2 #define DUMP_DEBUG_INFO MRB_DUMP_DEBUG_INFO /* deprecated */ -int mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size); #ifndef MRB_NO_STDIO -int mrb_dump_irep_binary(mrb_state*, const mrb_irep*, uint8_t, FILE*); -int mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname); -int mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname); -mrb_irep *mrb_read_irep_file(mrb_state*, FILE*); MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*); MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*); #endif diff --git a/include/mruby/error.h b/include/mruby/error.h index fb3557405..752baae84 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -27,11 +27,6 @@ MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg); MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str); #define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit)) MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv); -mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc); -mrb_value mrb_get_backtrace(mrb_state *mrb); -void mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg); -mrb_value mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc); - MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...); /* declaration for `fail` method */ diff --git a/include/mruby/gc.h b/include/mruby/gc.h index 9f9bba410..9f4ceec4d 100644 --- a/include/mruby/gc.h +++ b/include/mruby/gc.h @@ -84,8 +84,7 @@ typedef struct mrb_gc { size_t majorgc_old_threshold; } mrb_gc; -MRB_API mrb_bool -mrb_object_dead_p(struct mrb_state *mrb, struct RBasic *object); +MRB_API mrb_bool mrb_object_dead_p(struct mrb_state *mrb, struct RBasic *object); #define MRB_GC_RED 7 diff --git a/include/mruby/hash.h b/include/mruby/hash.h index 1b37a12d4..e591172ea 100644 --- a/include/mruby/hash.h +++ b/include/mruby/hash.h @@ -35,7 +35,6 @@ struct RHash { #define mrb_hash_ptr(v) ((struct RHash*)(mrb_ptr(v))) #define mrb_hash_value(p) mrb_obj_value((void*)(p)) -size_t mrb_hash_memsize(mrb_value obj); MRB_API mrb_value mrb_hash_new_capa(mrb_state *mrb, mrb_int capa); /* @@ -226,11 +225,6 @@ MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2); #define MRB_RHASH_DEFAULT_P(hash) (RHASH(hash)->flags & MRB_HASH_DEFAULT) #define MRB_RHASH_PROCDEFAULT_P(hash) (RHASH(hash)->flags & MRB_HASH_PROC_DEFAULT) -/* GC functions */ -void mrb_gc_mark_hash(mrb_state*, struct RHash*); -size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*); -void mrb_gc_free_hash(mrb_state*, struct RHash*); - /* return non zero to break the loop */ typedef int (mrb_hash_foreach_func)(mrb_state *mrb, mrb_value key, mrb_value val, void *data); MRB_API void mrb_hash_foreach(mrb_state *mrb, struct RHash *hash, mrb_hash_foreach_func *func, void *p); diff --git a/include/mruby/internal.h b/include/mruby/internal.h new file mode 100644 index 000000000..b86931ad9 --- /dev/null +++ b/include/mruby/internal.h @@ -0,0 +1,157 @@ +/** +** @file mruby/internal.h - Functions only called from within the library +** +** See Copyright Notice in mruby.h +*/ + +#ifndef MRUBY_INTERNAL_H +#define MRUBY_INTERNAL_H + +#ifdef MRUBY_ARRAY_H +void mrb_ary_decref(mrb_state*, mrb_shared_array*); +mrb_value mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len); +#endif + +#ifdef MRUBY_CLASS_H +struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym); +struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym); +mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); +void mrb_class_name_class(mrb_state*, struct RClass*, struct RClass*, mrb_sym); +mrb_bool mrb_const_name_p(mrb_state*, const char*, mrb_int); +mrb_value mrb_class_find_path(mrb_state*, struct RClass*); +mrb_value mrb_mod_to_s(mrb_state *, mrb_value); +void mrb_method_added(mrb_state *mrb, struct RClass *c, mrb_sym mid); +#endif + +/* debug */ +size_t mrb_packed_int_len(uint32_t num); +size_t mrb_packed_int_encode(uint32_t num, uint8_t *p, uint8_t *pend); +uint32_t mrb_packed_int_decode(const uint8_t *p, const uint8_t **newpos); + +/* dump */ +#ifdef MRUBY_IREP_H +int mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size); +#ifndef MRB_NO_STDIO +int mrb_dump_irep_binary(mrb_state*, const mrb_irep*, uint8_t, FILE*); +int mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname); +int mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname); +mrb_irep *mrb_read_irep_file(mrb_state*, FILE*); +#endif +#endif + +/* error */ +mrb_value mrb_exc_inspect(mrb_state *mrb, mrb_value exc); +mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc); +mrb_value mrb_get_backtrace(mrb_state *mrb); +void mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg); +mrb_value mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc); + +/* gc */ +void mrb_gc_mark_mt(mrb_state*, struct RClass*); +size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*); +void mrb_gc_free_mt(mrb_state*, struct RClass*); + +/* hash */ +size_t mrb_hash_memsize(mrb_value obj); +void mrb_gc_mark_hash(mrb_state*, struct RHash*); +size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*); +void mrb_gc_free_hash(mrb_state*, struct RHash*); + +/* irep */ +struct mrb_insn_data mrb_decode_insn(const mrb_code *pc); +#ifdef MRUBY_IREP_H +void mrb_irep_free(mrb_state*, struct mrb_irep*); +void mrb_irep_incref(mrb_state*, struct mrb_irep*); +void mrb_irep_decref(mrb_state*, struct mrb_irep*); +void mrb_irep_cutref(mrb_state*, struct mrb_irep*); +void mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep); + +static inline const struct mrb_irep_catch_handler * +mrb_irep_catch_handler_table(const struct mrb_irep *irep) +{ + if (irep->clen > 0) { + return (const struct mrb_irep_catch_handler*)(irep->iseq + irep->ilen); + } + else { + return (const struct mrb_irep_catch_handler*)NULL; + } +} +#endif + +/* numeric */ +mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y); + +#ifdef MRB_USE_COMPLEX +mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); +mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_complex_div(mrb_state *mrb, mrb_value x, mrb_value y); +#endif +#ifdef MRB_USE_RATIONAL +mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y); +#endif + +#ifdef MRUBY_PROC_H +struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*); +struct RProc *mrb_closure_new(mrb_state*, const mrb_irep*); +void mrb_proc_copy(mrb_state *mrb, struct RProc *a, struct RProc *b); +mrb_int mrb_proc_arity(const struct RProc *p); +#endif + +/* range */ +#ifdef MRUBY_RANGE_H +mrb_value mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, const mrb_value *argv, mrb_value (*func)(mrb_state*, mrb_value, mrb_int)); +void mrb_gc_mark_range(mrb_state *mrb, struct RRange *r); +#endif + +/* string */ +void mrb_gc_free_str(mrb_state*, struct RString*); +uint32_t mrb_str_hash(mrb_state *mrb, mrb_value str); +mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str); +mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str); +mrb_bool mrb_str_beg_len(mrb_int str_len, mrb_int *begp, mrb_int *lenp); +mrb_value mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len); +mrb_value mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value idx, mrb_value len); + +#ifdef MRB_UTF8_STRING +mrb_int mrb_utf8len(const char *str, const char *end); +mrb_int mrb_utf8_strlen(const char *str, mrb_int byte_len); +#endif + +/* variable */ +mrb_value mrb_vm_special_get(mrb_state*, mrb_sym); +void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value); +mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym); +void mrb_vm_cv_set(mrb_state*, mrb_sym, mrb_value); +mrb_value mrb_vm_const_get(mrb_state*, mrb_sym); +void mrb_vm_const_set(mrb_state*, mrb_sym, mrb_value); +size_t mrb_obj_iv_tbl_memsize(mrb_value); +mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*); +void mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v); +mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod); +mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self); +mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value); +mrb_value mrb_mod_class_variables(mrb_state*, mrb_value); +mrb_value mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym); +mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym); +mrb_bool mrb_ident_p(const char *s, mrb_int len); + +/* GC functions */ +void mrb_gc_mark_gv(mrb_state*); +void mrb_gc_free_gv(mrb_state*); +void mrb_gc_mark_iv(mrb_state*, struct RObject*); +size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*); +void mrb_gc_free_iv(mrb_state*, struct RObject*); + +/* VM */ +mrb_int mrb_ci_bidx(mrb_callinfo *ci); + +#endif /* MRUBY_INTERNAL_H */ diff --git a/include/mruby/irep.h b/include/mruby/irep.h index ff78c1857..9957c98d2 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -112,12 +112,6 @@ MRB_API mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*); */ MRB_API mrb_value mrb_load_irep_buf_cxt(mrb_state*, const void*, size_t, mrbc_context*); -void mrb_irep_free(mrb_state*, struct mrb_irep*); -void mrb_irep_incref(mrb_state*, struct mrb_irep*); -void mrb_irep_decref(mrb_state*, struct mrb_irep*); -void mrb_irep_cutref(mrb_state*, struct mrb_irep*); -void mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep); - struct mrb_insn_data { uint8_t insn; uint16_t a; @@ -126,19 +120,6 @@ struct mrb_insn_data { const mrb_code *addr; }; -struct mrb_insn_data mrb_decode_insn(const mrb_code *pc); - -static inline const struct mrb_irep_catch_handler * -mrb_irep_catch_handler_table(const struct mrb_irep *irep) -{ - if (irep->clen > 0) { - return (const struct mrb_irep_catch_handler*)(irep->iseq + irep->ilen); - } - else { - return (const struct mrb_irep_catch_handler*)NULL; - } -} - #define mrb_irep_catch_handler_pack(n, v) uint32_to_bin(n, v) #define mrb_irep_catch_handler_unpack(v) bin_to_uint32(v) diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index 425b0253d..48adea3d1 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -41,9 +41,6 @@ MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y); MRB_API mrb_value mrb_integer_to_str(mrb_state *mrb, mrb_value x, mrb_int base); MRB_API char *mrb_int_to_cstr(char *buf, size_t len, mrb_int n, mrb_int base); -/* internal function(s) */ -mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y); - /* obsolete function(s); will be removed */ #define mrb_fixnum_to_str(mrb, x, base) mrb_integer_to_str(mrb, x, base) diff --git a/include/mruby/proc.h b/include/mruby/proc.h index a6aa4ed7f..97ae48e96 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -88,12 +88,8 @@ struct RProc { #define mrb_proc_ptr(v) ((struct RProc*)(mrb_ptr(v))) -struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*); -struct RProc *mrb_closure_new(mrb_state*, const mrb_irep*); MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t); MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals); -void mrb_proc_copy(mrb_state *mrb, struct RProc *a, struct RProc *b); -mrb_int mrb_proc_arity(const struct RProc *p); /* following functions are defined in mruby-proc-ext so please include it when using */ MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv); diff --git a/include/mruby/range.h b/include/mruby/range.h index fea700c24..3898ef3cf 100644 --- a/include/mruby/range.h +++ b/include/mruby/range.h @@ -71,8 +71,6 @@ enum mrb_range_beg_len { }; MRB_API enum mrb_range_beg_len mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc); -mrb_value mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, const mrb_value *argv, mrb_value (*func)(mrb_state*, mrb_value, mrb_int)); -void mrb_gc_mark_range(mrb_state *mrb, struct RRange *r); MRB_END_DECL diff --git a/include/mruby/string.h b/include/mruby/string.h index faa0d055b..cd300f8bd 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -114,8 +114,6 @@ struct RStringEmbed { #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT) #define MRB_STR_TYPE_MASK 15 -void mrb_gc_free_str(mrb_state*, struct RString*); - MRB_API void mrb_str_modify(mrb_state *mrb, struct RString *s); /* mrb_str_modify() with keeping ASCII flag if set */ MRB_API void mrb_str_modify_keep_ascii(mrb_state *mrb, struct RString *s); @@ -423,27 +421,11 @@ MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2); */ MRB_API char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str); -uint32_t mrb_str_hash(mrb_state *mrb, mrb_value str); -mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str); - -/** - * Returns a printable version of str, surrounded by quote marks, with special characters escaped. - */ -mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str); - /* For backward compatibility */ #define mrb_str_cat2(mrb, str, ptr) mrb_str_cat_cstr(mrb, str, ptr) #define mrb_str_buf_cat(mrb, str, ptr, len) mrb_str_cat(mrb, str, ptr, len) #define mrb_str_buf_append(mrb, str, str2) mrb_str_cat_str(mrb, str, str2) -mrb_bool mrb_str_beg_len(mrb_int str_len, mrb_int *begp, mrb_int *lenp); -mrb_value mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len); - -#ifdef MRB_UTF8_STRING -mrb_int mrb_utf8len(const char *str, const char *end); -mrb_int mrb_utf8_strlen(const char *str, mrb_int byte_len); -#endif - MRB_END_DECL #endif /* MRUBY_STRING_H */ diff --git a/include/mruby/variable.h b/include/mruby/variable.h index 3dc2c9a6d..0a7b7b42e 100644 --- a/include/mruby/variable.h +++ b/include/mruby/variable.h @@ -14,13 +14,6 @@ */ MRB_BEGIN_DECL -mrb_value mrb_vm_special_get(mrb_state*, mrb_sym); -void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value); -mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym); -void mrb_vm_cv_set(mrb_state*, mrb_sym, mrb_value); -mrb_value mrb_vm_const_get(mrb_state*, mrb_sym); -void mrb_vm_const_set(mrb_state*, mrb_sym, mrb_value); -size_t mrb_obj_iv_tbl_memsize(mrb_value); MRB_API mrb_value mrb_const_get(mrb_state*, mrb_value, mrb_sym); MRB_API void mrb_const_set(mrb_state*, mrb_value, mrb_sym, mrb_value); MRB_API mrb_bool mrb_const_defined(mrb_state*, mrb_value, mrb_sym); @@ -99,22 +92,6 @@ MRB_API mrb_value mrb_cv_get(mrb_state *mrb, mrb_value mod, mrb_sym sym); MRB_API void mrb_mod_cv_set(mrb_state *mrb, struct RClass * c, mrb_sym sym, mrb_value v); MRB_API void mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v); MRB_API mrb_bool mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym); -mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*); -void mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v); -mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod); -mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self); -mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value); -mrb_value mrb_mod_class_variables(mrb_state*, mrb_value); -mrb_value mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym); -mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym); -mrb_bool mrb_ident_p(const char *s, mrb_int len); - -/* GC functions */ -void mrb_gc_mark_gv(mrb_state*); -void mrb_gc_free_gv(mrb_state*); -void mrb_gc_mark_iv(mrb_state*, struct RObject*); -size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*); -void mrb_gc_free_iv(mrb_state*, struct RObject*); /* return non zero to break the loop */ typedef int (mrb_iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*); diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c index 9b7be2d42..97a394691 100644 --- a/mrbgems/mruby-array-ext/src/array.c +++ b/mrbgems/mruby-array-ext/src/array.c @@ -3,6 +3,7 @@ #include #include #include +#include #include /* diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c index 55c6cd125..a69d65dd9 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c @@ -12,6 +12,7 @@ #include #include #include +#include #include "mrdberror.h" #include "apibreak.h" #include "apistring.h" @@ -20,8 +21,6 @@ #define MRB_DEBUG_BP_FILE_OK (0x0001) #define MRB_DEBUG_BP_LINENO_OK (0x0002) -uint32_t mrb_packed_int_decode(uint8_t *p, uint8_t **newpos); - static uint16_t check_lineno(mrb_irep_debug_info_file *info_file, uint16_t lineno) { @@ -47,8 +46,8 @@ check_lineno(mrb_irep_debug_info_file *info_file, uint16_t lineno) case mrb_debug_line_packed_map: { - uint8_t *p = info_file->lines.packed_map; - uint8_t *pend = p + count; + const uint8_t *p = info_file->lines.packed_map; + const uint8_t *pend = p + count; uint32_t line = 0; while (p < pend) { mrb_packed_int_decode(p, &p); diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c index ee2ae0aca..340a57b56 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c @@ -14,6 +14,7 @@ #include #include #include +#include #include "mrdb.h" #include "apibreak.h" diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c index a54db42db..ef806bdf0 100644 --- a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c +++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c @@ -9,6 +9,7 @@ #include #include #include +#include #define RITEBIN_EXT ".mrb" #define C_EXT ".c" diff --git a/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c b/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c index 0c632b7c1..ff39dd357 100644 --- a/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c +++ b/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c @@ -8,6 +8,7 @@ #include #include #include +#include struct strip_args { int argc_start; diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index b59f8d432..8f7b5b013 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -18,6 +18,7 @@ #include #include #include +#include #ifndef MRB_CODEGEN_LEVEL_MAX #define MRB_CODEGEN_LEVEL_MAX 256 diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 7039c4507..032673b9b 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -21,6 +21,7 @@ #include #include #include +#include #include #include "node.h" diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 826be9d70..cfbb3032c 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -84,6 +84,7 @@ #include #include #include +#include #include #include "node.h" @@ -1497,7 +1498,7 @@ heredoc_end(parser_state *p) /* xxx ----------------------------- */ -#line 1501 "mrbgems/mruby-compiler/core/y.tab.c" +#line 1502 "mrbgems/mruby-compiler/core/y.tab.c" # ifndef YY_CAST # ifdef __cplusplus @@ -1669,7 +1670,7 @@ extern int yydebug; #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED union YYSTYPE { -#line 1443 "mrbgems/mruby-compiler/core/parse.y" +#line 1444 "mrbgems/mruby-compiler/core/parse.y" node *nd; mrb_sym id; @@ -1677,7 +1678,7 @@ union YYSTYPE stack_type stack; const struct vtable *vars; -#line 1681 "mrbgems/mruby-compiler/core/y.tab.c" +#line 1682 "mrbgems/mruby-compiler/core/y.tab.c" }; typedef union YYSTYPE YYSTYPE; @@ -2063,68 +2064,68 @@ static const yytype_uint8 yytranslate[] = /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { - 0, 1614, 1614, 1614, 1625, 1631, 1635, 1640, 1644, 1650, - 1652, 1651, 1665, 1692, 1698, 1702, 1707, 1711, 1717, 1717, - 1721, 1725, 1729, 1733, 1737, 1741, 1745, 1750, 1751, 1755, - 1759, 1763, 1767, 1773, 1776, 1780, 1784, 1788, 1792, 1796, - 1801, 1805, 1814, 1823, 1832, 1841, 1848, 1849, 1853, 1857, - 1858, 1862, 1866, 1870, 1874, 1878, 1888, 1887, 1902, 1911, - 1912, 1915, 1916, 1923, 1922, 1937, 1941, 1946, 1950, 1955, - 1959, 1964, 1968, 1972, 1976, 1980, 1986, 1990, 1996, 1997, - 2003, 2007, 2011, 2015, 2019, 2023, 2027, 2031, 2035, 2039, - 2045, 2046, 2052, 2056, 2062, 2066, 2072, 2076, 2080, 2084, - 2088, 2092, 2098, 2104, 2111, 2115, 2119, 2123, 2127, 2131, - 2137, 2143, 2148, 2154, 2158, 2161, 2165, 2169, 2176, 2177, - 2178, 2179, 2184, 2191, 2192, 2195, 2199, 2199, 2205, 2206, - 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, - 2217, 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, - 2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2237, 2237, - 2237, 2238, 2238, 2239, 2239, 2239, 2240, 2240, 2240, 2240, - 2241, 2241, 2241, 2242, 2242, 2242, 2243, 2243, 2243, 2243, - 2244, 2244, 2244, 2244, 2245, 2245, 2245, 2245, 2246, 2246, - 2246, 2246, 2247, 2247, 2247, 2247, 2248, 2248, 2251, 2255, - 2259, 2263, 2267, 2271, 2275, 2280, 2285, 2290, 2294, 2298, - 2302, 2306, 2310, 2314, 2318, 2322, 2326, 2330, 2334, 2338, - 2342, 2346, 2350, 2354, 2358, 2362, 2366, 2370, 2374, 2378, - 2382, 2386, 2390, 2394, 2398, 2402, 2406, 2410, 2414, 2418, - 2422, 2426, 2430, 2434, 2438, 2447, 2456, 2465, 2474, 2480, - 2481, 2486, 2490, 2497, 2501, 2508, 2512, 2521, 2538, 2539, - 2542, 2543, 2544, 2549, 2554, 2561, 2567, 2572, 2577, 2582, - 2589, 2589, 2600, 2604, 2610, 2614, 2620, 2623, 2629, 2634, - 2639, 2645, 2650, 2654, 2660, 2661, 2662, 2663, 2664, 2665, - 2666, 2667, 2671, 2676, 2675, 2687, 2691, 2686, 2696, 2696, - 2700, 2704, 2708, 2712, 2717, 2722, 2726, 2730, 2734, 2738, - 2742, 2743, 2749, 2756, 2748, 2769, 2777, 2785, 2785, 2785, - 2792, 2792, 2792, 2799, 2805, 2810, 2812, 2809, 2821, 2819, - 2837, 2842, 2835, 2859, 2857, 2873, 2883, 2894, 2898, 2902, - 2906, 2912, 2919, 2920, 2921, 2924, 2925, 2928, 2929, 2937, - 2938, 2944, 2948, 2951, 2955, 2959, 2963, 2968, 2972, 2976, - 2980, 2986, 2985, 2995, 2999, 3003, 3007, 3013, 3018, 3023, - 3027, 3031, 3035, 3039, 3043, 3047, 3051, 3055, 3059, 3063, - 3067, 3071, 3075, 3079, 3085, 3090, 3097, 3097, 3101, 3106, - 3113, 3117, 3123, 3124, 3127, 3132, 3135, 3139, 3145, 3149, - 3156, 3155, 3170, 3180, 3184, 3189, 3196, 3200, 3204, 3208, - 3212, 3216, 3220, 3224, 3228, 3235, 3234, 3249, 3248, 3264, - 3272, 3281, 3284, 3291, 3294, 3298, 3299, 3302, 3306, 3309, - 3313, 3316, 3317, 3318, 3319, 3322, 3323, 3329, 3330, 3331, - 3335, 3348, 3349, 3355, 3360, 3359, 3370, 3374, 3380, 3384, - 3397, 3401, 3407, 3410, 3411, 3414, 3420, 3426, 3427, 3430, - 3437, 3436, 3450, 3454, 3468, 3473, 3487, 3493, 3494, 3495, - 3496, 3497, 3501, 3507, 3511, 3521, 3522, 3523, 3527, 3533, - 3537, 3541, 3545, 3549, 3555, 3559, 3565, 3569, 3573, 3577, - 3581, 3585, 3593, 3600, 3606, 3607, 3611, 3615, 3614, 3631, - 3632, 3635, 3641, 3645, 3651, 3652, 3656, 3660, 3666, 3672, - 3678, 3685, 3691, 3698, 3702, 3708, 3712, 3718, 3719, 3722, - 3726, 3732, 3736, 3740, 3744, 3750, 3755, 3760, 3764, 3768, - 3772, 3776, 3780, 3784, 3788, 3792, 3796, 3800, 3804, 3808, - 3812, 3817, 3823, 3828, 3833, 3838, 3843, 3850, 3854, 3861, - 3866, 3865, 3877, 3881, 3887, 3895, 3903, 3911, 3915, 3921, - 3925, 3931, 3932, 3935, 3940, 3947, 3948, 3951, 3955, 3961, - 3965, 3971, 3976, 3976, 4001, 4002, 4008, 4013, 4019, 4025, - 4030, 4034, 4044, 4051, 4052, 4053, 4056, 4057, 4058, 4059, - 4062, 4063, 4064, 4067, 4068, 4071, 4075, 4081, 4082, 4088, - 4089, 4092, 4093, 4096, 4099, 4100, 4101, 4104, 4105, 4108, - 4113, 4116, 4117, 4121 + 0, 1615, 1615, 1615, 1626, 1632, 1636, 1641, 1645, 1651, + 1653, 1652, 1666, 1693, 1699, 1703, 1708, 1712, 1718, 1718, + 1722, 1726, 1730, 1734, 1738, 1742, 1746, 1751, 1752, 1756, + 1760, 1764, 1768, 1774, 1777, 1781, 1785, 1789, 1793, 1797, + 1802, 1806, 1815, 1824, 1833, 1842, 1849, 1850, 1854, 1858, + 1859, 1863, 1867, 1871, 1875, 1879, 1889, 1888, 1903, 1912, + 1913, 1916, 1917, 1924, 1923, 1938, 1942, 1947, 1951, 1956, + 1960, 1965, 1969, 1973, 1977, 1981, 1987, 1991, 1997, 1998, + 2004, 2008, 2012, 2016, 2020, 2024, 2028, 2032, 2036, 2040, + 2046, 2047, 2053, 2057, 2063, 2067, 2073, 2077, 2081, 2085, + 2089, 2093, 2099, 2105, 2112, 2116, 2120, 2124, 2128, 2132, + 2138, 2144, 2149, 2155, 2159, 2162, 2166, 2170, 2177, 2178, + 2179, 2180, 2185, 2192, 2193, 2196, 2200, 2200, 2206, 2207, + 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, + 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, + 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2238, 2238, + 2238, 2239, 2239, 2240, 2240, 2240, 2241, 2241, 2241, 2241, + 2242, 2242, 2242, 2243, 2243, 2243, 2244, 2244, 2244, 2244, + 2245, 2245, 2245, 2245, 2246, 2246, 2246, 2246, 2247, 2247, + 2247, 2247, 2248, 2248, 2248, 2248, 2249, 2249, 2252, 2256, + 2260, 2264, 2268, 2272, 2276, 2281, 2286, 2291, 2295, 2299, + 2303, 2307, 2311, 2315, 2319, 2323, 2327, 2331, 2335, 2339, + 2343, 2347, 2351, 2355, 2359, 2363, 2367, 2371, 2375, 2379, + 2383, 2387, 2391, 2395, 2399, 2403, 2407, 2411, 2415, 2419, + 2423, 2427, 2431, 2435, 2439, 2448, 2457, 2466, 2475, 2481, + 2482, 2487, 2491, 2498, 2502, 2509, 2513, 2522, 2539, 2540, + 2543, 2544, 2545, 2550, 2555, 2562, 2568, 2573, 2578, 2583, + 2590, 2590, 2601, 2605, 2611, 2615, 2621, 2624, 2630, 2635, + 2640, 2646, 2651, 2655, 2661, 2662, 2663, 2664, 2665, 2666, + 2667, 2668, 2672, 2677, 2676, 2688, 2692, 2687, 2697, 2697, + 2701, 2705, 2709, 2713, 2718, 2723, 2727, 2731, 2735, 2739, + 2743, 2744, 2750, 2757, 2749, 2770, 2778, 2786, 2786, 2786, + 2793, 2793, 2793, 2800, 2806, 2811, 2813, 2810, 2822, 2820, + 2838, 2843, 2836, 2860, 2858, 2874, 2884, 2895, 2899, 2903, + 2907, 2913, 2920, 2921, 2922, 2925, 2926, 2929, 2930, 2938, + 2939, 2945, 2949, 2952, 2956, 2960, 2964, 2969, 2973, 2977, + 2981, 2987, 2986, 2996, 3000, 3004, 3008, 3014, 3019, 3024, + 3028, 3032, 3036, 3040, 3044, 3048, 3052, 3056, 3060, 3064, + 3068, 3072, 3076, 3080, 3086, 3091, 3098, 3098, 3102, 3107, + 3114, 3118, 3124, 3125, 3128, 3133, 3136, 3140, 3146, 3150, + 3157, 3156, 3171, 3181, 3185, 3190, 3197, 3201, 3205, 3209, + 3213, 3217, 3221, 3225, 3229, 3236, 3235, 3250, 3249, 3265, + 3273, 3282, 3285, 3292, 3295, 3299, 3300, 3303, 3307, 3310, + 3314, 3317, 3318, 3319, 3320, 3323, 3324, 3330, 3331, 3332, + 3336, 3349, 3350, 3356, 3361, 3360, 3371, 3375, 3381, 3385, + 3398, 3402, 3408, 3411, 3412, 3415, 3421, 3427, 3428, 3431, + 3438, 3437, 3451, 3455, 3469, 3474, 3488, 3494, 3495, 3496, + 3497, 3498, 3502, 3508, 3512, 3522, 3523, 3524, 3528, 3534, + 3538, 3542, 3546, 3550, 3556, 3560, 3566, 3570, 3574, 3578, + 3582, 3586, 3594, 3601, 3607, 3608, 3612, 3616, 3615, 3632, + 3633, 3636, 3642, 3646, 3652, 3653, 3657, 3661, 3667, 3673, + 3679, 3686, 3692, 3699, 3703, 3709, 3713, 3719, 3720, 3723, + 3727, 3733, 3737, 3741, 3745, 3751, 3756, 3761, 3765, 3769, + 3773, 3777, 3781, 3785, 3789, 3793, 3797, 3801, 3805, 3809, + 3813, 3818, 3824, 3829, 3834, 3839, 3844, 3851, 3855, 3862, + 3867, 3866, 3878, 3882, 3888, 3896, 3904, 3912, 3916, 3922, + 3926, 3932, 3933, 3936, 3941, 3948, 3949, 3952, 3956, 3962, + 3966, 3972, 3977, 3977, 4002, 4003, 4009, 4014, 4020, 4026, + 4031, 4035, 4045, 4052, 4053, 4054, 4057, 4058, 4059, 4060, + 4063, 4064, 4065, 4068, 4069, 4072, 4076, 4082, 4083, 4089, + 4090, 4093, 4094, 4097, 4100, 4101, 4102, 4105, 4106, 4109, + 4114, 4117, 4118, 4122 }; #endif @@ -6141,86 +6142,86 @@ yyreduce: switch (yyn) { case 2: -#line 1614 "mrbgems/mruby-compiler/core/parse.y" +#line 1615 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_BEG; if (!p->locals) p->locals = cons(0,0); } -#line 6150 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6151 "mrbgems/mruby-compiler/core/y.tab.c" break; case 3: -#line 1619 "mrbgems/mruby-compiler/core/parse.y" +#line 1620 "mrbgems/mruby-compiler/core/parse.y" { p->tree = new_scope(p, (yyvsp[0].nd)); NODE_LINENO(p->tree, (yyvsp[0].nd)); } -#line 6159 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6160 "mrbgems/mruby-compiler/core/y.tab.c" break; case 4: -#line 1626 "mrbgems/mruby-compiler/core/parse.y" +#line 1627 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 6167 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6168 "mrbgems/mruby-compiler/core/y.tab.c" break; case 5: -#line 1632 "mrbgems/mruby-compiler/core/parse.y" +#line 1633 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, 0); } -#line 6175 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6176 "mrbgems/mruby-compiler/core/y.tab.c" break; case 6: -#line 1636 "mrbgems/mruby-compiler/core/parse.y" +#line 1637 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 6184 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6185 "mrbgems/mruby-compiler/core/y.tab.c" break; case 7: -#line 1641 "mrbgems/mruby-compiler/core/parse.y" +#line 1642 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd))); } -#line 6192 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6193 "mrbgems/mruby-compiler/core/y.tab.c" break; case 8: -#line 1645 "mrbgems/mruby-compiler/core/parse.y" +#line 1646 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, 0); } -#line 6200 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6201 "mrbgems/mruby-compiler/core/y.tab.c" break; case 10: -#line 1652 "mrbgems/mruby-compiler/core/parse.y" +#line 1653 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = local_switch(p); nvars_block(p); } -#line 6209 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6210 "mrbgems/mruby-compiler/core/y.tab.c" break; case 11: -#line 1657 "mrbgems/mruby-compiler/core/parse.y" +#line 1658 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "BEGIN not supported"); local_resume(p, (yyvsp[-3].nd)); nvars_unnest(p); (yyval.nd) = 0; } -#line 6220 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6221 "mrbgems/mruby-compiler/core/y.tab.c" break; case 12: -#line 1669 "mrbgems/mruby-compiler/core/parse.y" +#line 1670 "mrbgems/mruby-compiler/core/parse.y" { if ((yyvsp[-2].nd)) { (yyval.nd) = new_rescue(p, (yyvsp[-3].nd), (yyvsp[-2].nd), (yyvsp[-1].nd)); @@ -6242,222 +6243,222 @@ yyreduce: } } } -#line 6246 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6247 "mrbgems/mruby-compiler/core/y.tab.c" break; case 13: -#line 1693 "mrbgems/mruby-compiler/core/parse.y" +#line 1694 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 6254 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6255 "mrbgems/mruby-compiler/core/y.tab.c" break; case 14: -#line 1699 "mrbgems/mruby-compiler/core/parse.y" +#line 1700 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, 0); } -#line 6262 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6263 "mrbgems/mruby-compiler/core/y.tab.c" break; case 15: -#line 1703 "mrbgems/mruby-compiler/core/parse.y" +#line 1704 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 6271 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6272 "mrbgems/mruby-compiler/core/y.tab.c" break; case 16: -#line 1708 "mrbgems/mruby-compiler/core/parse.y" +#line 1709 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd))); } -#line 6279 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6280 "mrbgems/mruby-compiler/core/y.tab.c" break; case 17: -#line 1712 "mrbgems/mruby-compiler/core/parse.y" +#line 1713 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, (yyvsp[0].nd)); } -#line 6287 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6288 "mrbgems/mruby-compiler/core/y.tab.c" break; case 18: -#line 1717 "mrbgems/mruby-compiler/core/parse.y" +#line 1718 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_FNAME;} -#line 6293 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6294 "mrbgems/mruby-compiler/core/y.tab.c" break; case 19: -#line 1718 "mrbgems/mruby-compiler/core/parse.y" +#line 1719 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_alias(p, (yyvsp[-2].id), (yyvsp[0].id)); } -#line 6301 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6302 "mrbgems/mruby-compiler/core/y.tab.c" break; case 20: -#line 1722 "mrbgems/mruby-compiler/core/parse.y" +#line 1723 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 6309 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6310 "mrbgems/mruby-compiler/core/y.tab.c" break; case 21: -#line 1726 "mrbgems/mruby-compiler/core/parse.y" +#line 1727 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0); } -#line 6317 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6318 "mrbgems/mruby-compiler/core/y.tab.c" break; case 22: -#line 1730 "mrbgems/mruby-compiler/core/parse.y" +#line 1731 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_unless(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0); } -#line 6325 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6326 "mrbgems/mruby-compiler/core/y.tab.c" break; case 23: -#line 1734 "mrbgems/mruby-compiler/core/parse.y" +#line 1735 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_while(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd)); } -#line 6333 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6334 "mrbgems/mruby-compiler/core/y.tab.c" break; case 24: -#line 1738 "mrbgems/mruby-compiler/core/parse.y" +#line 1739 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_until(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd)); } -#line 6341 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6342 "mrbgems/mruby-compiler/core/y.tab.c" break; case 25: -#line 1742 "mrbgems/mruby-compiler/core/parse.y" +#line 1743 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6349 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6350 "mrbgems/mruby-compiler/core/y.tab.c" break; case 26: -#line 1746 "mrbgems/mruby-compiler/core/parse.y" +#line 1747 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "END not supported"); (yyval.nd) = new_postexe(p, (yyvsp[-1].nd)); } -#line 6358 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6359 "mrbgems/mruby-compiler/core/y.tab.c" break; case 28: -#line 1752 "mrbgems/mruby-compiler/core/parse.y" +#line 1753 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6366 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6367 "mrbgems/mruby-compiler/core/y.tab.c" break; case 29: -#line 1756 "mrbgems/mruby-compiler/core/parse.y" +#line 1757 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd))); } -#line 6374 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6375 "mrbgems/mruby-compiler/core/y.tab.c" break; case 30: -#line 1760 "mrbgems/mruby-compiler/core/parse.y" +#line 1761 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6382 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6383 "mrbgems/mruby-compiler/core/y.tab.c" break; case 31: -#line 1764 "mrbgems/mruby-compiler/core/parse.y" +#line 1765 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd))); } -#line 6390 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6391 "mrbgems/mruby-compiler/core/y.tab.c" break; case 32: -#line 1768 "mrbgems/mruby-compiler/core/parse.y" +#line 1769 "mrbgems/mruby-compiler/core/parse.y" { node *lhs = new_lvar(p, (yyvsp[0].id)); assignable(p, lhs); (yyval.nd) = new_asgn(p, lhs, (yyvsp[-2].nd)); } -#line 6400 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6401 "mrbgems/mruby-compiler/core/y.tab.c" break; case 34: -#line 1777 "mrbgems/mruby-compiler/core/parse.y" +#line 1778 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6408 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6409 "mrbgems/mruby-compiler/core/y.tab.c" break; case 35: -#line 1781 "mrbgems/mruby-compiler/core/parse.y" +#line 1782 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6416 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6417 "mrbgems/mruby-compiler/core/y.tab.c" break; case 36: -#line 1785 "mrbgems/mruby-compiler/core/parse.y" +#line 1786 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_op(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6424 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6425 "mrbgems/mruby-compiler/core/y.tab.c" break; case 37: -#line 1789 "mrbgems/mruby-compiler/core/parse.y" +#line 1790 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6432 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6433 "mrbgems/mruby-compiler/core/y.tab.c" break; case 38: -#line 1793 "mrbgems/mruby-compiler/core/parse.y" +#line 1794 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6440 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6441 "mrbgems/mruby-compiler/core/y.tab.c" break; case 39: -#line 1797 "mrbgems/mruby-compiler/core/parse.y" +#line 1798 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "constant re-assignment"); (yyval.nd) = 0; } -#line 6449 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6450 "mrbgems/mruby-compiler/core/y.tab.c" break; case 40: -#line 1802 "mrbgems/mruby-compiler/core/parse.y" +#line 1803 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6457 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6458 "mrbgems/mruby-compiler/core/y.tab.c" break; case 41: -#line 1806 "mrbgems/mruby-compiler/core/parse.y" +#line 1807 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); endless_method_name(p, (yyvsp[-3].nd)); @@ -6466,11 +6467,11 @@ yyreduce: nvars_unnest(p); p->in_def--; } -#line 6470 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6471 "mrbgems/mruby-compiler/core/y.tab.c" break; case 42: -#line 1815 "mrbgems/mruby-compiler/core/parse.y" +#line 1816 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-5].nd); endless_method_name(p, (yyvsp[-5].nd)); @@ -6479,11 +6480,11 @@ yyreduce: nvars_unnest(p); p->in_def--; } -#line 6483 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6484 "mrbgems/mruby-compiler/core/y.tab.c" break; case 43: -#line 1824 "mrbgems/mruby-compiler/core/parse.y" +#line 1825 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); void_expr_error(p, (yyvsp[0].nd)); @@ -6492,11 +6493,11 @@ yyreduce: p->in_def--; p->in_single--; } -#line 6496 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6497 "mrbgems/mruby-compiler/core/y.tab.c" break; case 44: -#line 1833 "mrbgems/mruby-compiler/core/parse.y" +#line 1834 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-5].nd); void_expr_error(p, (yyvsp[-2].nd)); @@ -6505,79 +6506,79 @@ yyreduce: p->in_def--; p->in_single--; } -#line 6509 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6510 "mrbgems/mruby-compiler/core/y.tab.c" break; case 45: -#line 1842 "mrbgems/mruby-compiler/core/parse.y" +#line 1843 "mrbgems/mruby-compiler/core/parse.y" { backref_error(p, (yyvsp[-2].nd)); (yyval.nd) = new_begin(p, 0); } -#line 6518 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6519 "mrbgems/mruby-compiler/core/y.tab.c" break; case 47: -#line 1850 "mrbgems/mruby-compiler/core/parse.y" +#line 1851 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6526 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6527 "mrbgems/mruby-compiler/core/y.tab.c" break; case 50: -#line 1859 "mrbgems/mruby-compiler/core/parse.y" +#line 1860 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6534 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6535 "mrbgems/mruby-compiler/core/y.tab.c" break; case 51: -#line 1863 "mrbgems/mruby-compiler/core/parse.y" +#line 1864 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6542 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6543 "mrbgems/mruby-compiler/core/y.tab.c" break; case 52: -#line 1867 "mrbgems/mruby-compiler/core/parse.y" +#line 1868 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!"); } -#line 6550 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6551 "mrbgems/mruby-compiler/core/y.tab.c" break; case 53: -#line 1871 "mrbgems/mruby-compiler/core/parse.y" +#line 1872 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!"); } -#line 6558 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6559 "mrbgems/mruby-compiler/core/y.tab.c" break; case 55: -#line 1879 "mrbgems/mruby-compiler/core/parse.y" +#line 1880 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_def(p, (yyvsp[0].id), nint(p->cmdarg_stack), local_switch(p)); p->cmdarg_stack = 0; p->in_def++; nvars_block(p); } -#line 6569 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6570 "mrbgems/mruby-compiler/core/y.tab.c" break; case 56: -#line 1888 "mrbgems/mruby-compiler/core/parse.y" +#line 1889 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_FNAME; } -#line 6577 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6578 "mrbgems/mruby-compiler/core/y.tab.c" break; case 57: -#line 1892 "mrbgems/mruby-compiler/core/parse.y" +#line 1893 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_sdef(p, (yyvsp[-3].nd), (yyvsp[0].id), nint(p->cmdarg_stack), local_switch(p)); p->cmdarg_stack = 0; @@ -6586,1054 +6587,1054 @@ yyreduce: nvars_block(p); p->lstate = EXPR_ENDFN; /* force for args */ } -#line 6590 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6591 "mrbgems/mruby-compiler/core/y.tab.c" break; case 58: -#line 1903 "mrbgems/mruby-compiler/core/parse.y" +#line 1904 "mrbgems/mruby-compiler/core/parse.y" { if (!(yyvsp[0].nd)) (yyval.nd) = new_nil(p); else { (yyval.nd) = (yyvsp[0].nd); } } -#line 6601 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6602 "mrbgems/mruby-compiler/core/y.tab.c" break; case 62: -#line 1917 "mrbgems/mruby-compiler/core/parse.y" +#line 1918 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 6609 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6610 "mrbgems/mruby-compiler/core/y.tab.c" break; case 63: -#line 1923 "mrbgems/mruby-compiler/core/parse.y" +#line 1924 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); } -#line 6618 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6619 "mrbgems/mruby-compiler/core/y.tab.c" break; case 64: -#line 1930 "mrbgems/mruby-compiler/core/parse.y" +#line 1931 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block(p, (yyvsp[-2].nd), (yyvsp[-1].nd)); local_unnest(p); nvars_unnest(p); } -#line 6628 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6629 "mrbgems/mruby-compiler/core/y.tab.c" break; case 65: -#line 1938 "mrbgems/mruby-compiler/core/parse.y" +#line 1939 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6636 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6637 "mrbgems/mruby-compiler/core/y.tab.c" break; case 66: -#line 1942 "mrbgems/mruby-compiler/core/parse.y" +#line 1943 "mrbgems/mruby-compiler/core/parse.y" { args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd)); (yyval.nd) = new_fcall(p, (yyvsp[-2].id), (yyvsp[-1].nd)); } -#line 6645 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6646 "mrbgems/mruby-compiler/core/y.tab.c" break; case 67: -#line 1947 "mrbgems/mruby-compiler/core/parse.y" +#line 1948 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 6653 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6654 "mrbgems/mruby-compiler/core/y.tab.c" break; case 68: -#line 1951 "mrbgems/mruby-compiler/core/parse.y" +#line 1952 "mrbgems/mruby-compiler/core/parse.y" { args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd)); (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num)); } -#line 6662 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6663 "mrbgems/mruby-compiler/core/y.tab.c" break; case 69: -#line 1956 "mrbgems/mruby-compiler/core/parse.y" +#line 1957 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2); } -#line 6670 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6671 "mrbgems/mruby-compiler/core/y.tab.c" break; case 70: -#line 1960 "mrbgems/mruby-compiler/core/parse.y" +#line 1961 "mrbgems/mruby-compiler/core/parse.y" { args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd)); (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), tCOLON2); } -#line 6679 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6680 "mrbgems/mruby-compiler/core/y.tab.c" break; case 71: -#line 1965 "mrbgems/mruby-compiler/core/parse.y" +#line 1966 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_super(p, (yyvsp[0].nd)); } -#line 6687 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6688 "mrbgems/mruby-compiler/core/y.tab.c" break; case 72: -#line 1969 "mrbgems/mruby-compiler/core/parse.y" +#line 1970 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_yield(p, (yyvsp[0].nd)); } -#line 6695 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6696 "mrbgems/mruby-compiler/core/y.tab.c" break; case 73: -#line 1973 "mrbgems/mruby-compiler/core/parse.y" +#line 1974 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_return(p, ret_args(p, (yyvsp[0].nd))); } -#line 6703 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6704 "mrbgems/mruby-compiler/core/y.tab.c" break; case 74: -#line 1977 "mrbgems/mruby-compiler/core/parse.y" +#line 1978 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_break(p, ret_args(p, (yyvsp[0].nd))); } -#line 6711 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6712 "mrbgems/mruby-compiler/core/y.tab.c" break; case 75: -#line 1981 "mrbgems/mruby-compiler/core/parse.y" +#line 1982 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_next(p, ret_args(p, (yyvsp[0].nd))); } -#line 6719 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6720 "mrbgems/mruby-compiler/core/y.tab.c" break; case 76: -#line 1987 "mrbgems/mruby-compiler/core/parse.y" +#line 1988 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 6727 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6728 "mrbgems/mruby-compiler/core/y.tab.c" break; case 77: -#line 1991 "mrbgems/mruby-compiler/core/parse.y" +#line 1992 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 6735 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6736 "mrbgems/mruby-compiler/core/y.tab.c" break; case 79: -#line 1998 "mrbgems/mruby-compiler/core/parse.y" +#line 1999 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 6743 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6744 "mrbgems/mruby-compiler/core/y.tab.c" break; case 80: -#line 2004 "mrbgems/mruby-compiler/core/parse.y" +#line 2005 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 6751 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6752 "mrbgems/mruby-compiler/core/y.tab.c" break; case 81: -#line 2008 "mrbgems/mruby-compiler/core/parse.y" +#line 2009 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(push((yyvsp[-1].nd),(yyvsp[0].nd))); } -#line 6759 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6760 "mrbgems/mruby-compiler/core/y.tab.c" break; case 82: -#line 2012 "mrbgems/mruby-compiler/core/parse.y" +#line 2013 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list2((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6767 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6768 "mrbgems/mruby-compiler/core/y.tab.c" break; case 83: -#line 2016 "mrbgems/mruby-compiler/core/parse.y" +#line 2017 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-4].nd), (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6775 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6776 "mrbgems/mruby-compiler/core/y.tab.c" break; case 84: -#line 2020 "mrbgems/mruby-compiler/core/parse.y" +#line 2021 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list2((yyvsp[-1].nd), new_nil(p)); } -#line 6783 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6784 "mrbgems/mruby-compiler/core/y.tab.c" break; case 85: -#line 2024 "mrbgems/mruby-compiler/core/parse.y" +#line 2025 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-3].nd), new_nil(p), (yyvsp[0].nd)); } -#line 6791 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6792 "mrbgems/mruby-compiler/core/y.tab.c" break; case 86: -#line 2028 "mrbgems/mruby-compiler/core/parse.y" +#line 2029 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list2(0, (yyvsp[0].nd)); } -#line 6799 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6800 "mrbgems/mruby-compiler/core/y.tab.c" break; case 87: -#line 2032 "mrbgems/mruby-compiler/core/parse.y" +#line 2033 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6807 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6808 "mrbgems/mruby-compiler/core/y.tab.c" break; case 88: -#line 2036 "mrbgems/mruby-compiler/core/parse.y" +#line 2037 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list2(0, new_nil(p)); } -#line 6815 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6816 "mrbgems/mruby-compiler/core/y.tab.c" break; case 89: -#line 2040 "mrbgems/mruby-compiler/core/parse.y" +#line 2041 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, new_nil(p), (yyvsp[0].nd)); } -#line 6823 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6824 "mrbgems/mruby-compiler/core/y.tab.c" break; case 91: -#line 2047 "mrbgems/mruby-compiler/core/parse.y" +#line 2048 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn(p, (yyvsp[-1].nd), NULL); } -#line 6831 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6832 "mrbgems/mruby-compiler/core/y.tab.c" break; case 92: -#line 2053 "mrbgems/mruby-compiler/core/parse.y" +#line 2054 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[-1].nd)); } -#line 6839 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6840 "mrbgems/mruby-compiler/core/y.tab.c" break; case 93: -#line 2057 "mrbgems/mruby-compiler/core/parse.y" +#line 2058 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[-1].nd)); } -#line 6847 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6848 "mrbgems/mruby-compiler/core/y.tab.c" break; case 94: -#line 2063 "mrbgems/mruby-compiler/core/parse.y" +#line 2064 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 6855 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6856 "mrbgems/mruby-compiler/core/y.tab.c" break; case 95: -#line 2067 "mrbgems/mruby-compiler/core/parse.y" +#line 2068 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 6863 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6864 "mrbgems/mruby-compiler/core/y.tab.c" break; case 96: -#line 2073 "mrbgems/mruby-compiler/core/parse.y" +#line 2074 "mrbgems/mruby-compiler/core/parse.y" { assignable(p, (yyvsp[0].nd)); } -#line 6871 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6872 "mrbgems/mruby-compiler/core/y.tab.c" break; case 97: -#line 2077 "mrbgems/mruby-compiler/core/parse.y" +#line 2078 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.'); } -#line 6879 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6880 "mrbgems/mruby-compiler/core/y.tab.c" break; case 98: -#line 2081 "mrbgems/mruby-compiler/core/parse.y" +#line 2082 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num)); } -#line 6887 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6888 "mrbgems/mruby-compiler/core/y.tab.c" break; case 99: -#line 2085 "mrbgems/mruby-compiler/core/parse.y" +#line 2086 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2); } -#line 6895 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6896 "mrbgems/mruby-compiler/core/y.tab.c" break; case 100: -#line 2089 "mrbgems/mruby-compiler/core/parse.y" +#line 2090 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num)); } -#line 6903 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6904 "mrbgems/mruby-compiler/core/y.tab.c" break; case 101: -#line 2093 "mrbgems/mruby-compiler/core/parse.y" +#line 2094 "mrbgems/mruby-compiler/core/parse.y" { if (p->in_def || p->in_single) yyerror(p, "dynamic constant assignment"); (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id)); } -#line 6913 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6914 "mrbgems/mruby-compiler/core/y.tab.c" break; case 102: -#line 2099 "mrbgems/mruby-compiler/core/parse.y" +#line 2100 "mrbgems/mruby-compiler/core/parse.y" { if (p->in_def || p->in_single) yyerror(p, "dynamic constant assignment"); (yyval.nd) = new_colon3(p, (yyvsp[0].id)); } -#line 6923 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6924 "mrbgems/mruby-compiler/core/y.tab.c" break; case 103: -#line 2105 "mrbgems/mruby-compiler/core/parse.y" +#line 2106 "mrbgems/mruby-compiler/core/parse.y" { backref_error(p, (yyvsp[0].nd)); (yyval.nd) = 0; } -#line 6932 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6933 "mrbgems/mruby-compiler/core/y.tab.c" break; case 104: -#line 2112 "mrbgems/mruby-compiler/core/parse.y" +#line 2113 "mrbgems/mruby-compiler/core/parse.y" { assignable(p, (yyvsp[0].nd)); } -#line 6940 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6941 "mrbgems/mruby-compiler/core/y.tab.c" break; case 105: -#line 2116 "mrbgems/mruby-compiler/core/parse.y" +#line 2117 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.'); } -#line 6948 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6949 "mrbgems/mruby-compiler/core/y.tab.c" break; case 106: -#line 2120 "mrbgems/mruby-compiler/core/parse.y" +#line 2121 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num)); } -#line 6956 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6957 "mrbgems/mruby-compiler/core/y.tab.c" break; case 107: -#line 2124 "mrbgems/mruby-compiler/core/parse.y" +#line 2125 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2); } -#line 6964 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6965 "mrbgems/mruby-compiler/core/y.tab.c" break; case 108: -#line 2128 "mrbgems/mruby-compiler/core/parse.y" +#line 2129 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num)); } -#line 6972 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6973 "mrbgems/mruby-compiler/core/y.tab.c" break; case 109: -#line 2132 "mrbgems/mruby-compiler/core/parse.y" +#line 2133 "mrbgems/mruby-compiler/core/parse.y" { if (p->in_def || p->in_single) yyerror(p, "dynamic constant assignment"); (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id)); } -#line 6982 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6983 "mrbgems/mruby-compiler/core/y.tab.c" break; case 110: -#line 2138 "mrbgems/mruby-compiler/core/parse.y" +#line 2139 "mrbgems/mruby-compiler/core/parse.y" { if (p->in_def || p->in_single) yyerror(p, "dynamic constant assignment"); (yyval.nd) = new_colon3(p, (yyvsp[0].id)); } -#line 6992 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6993 "mrbgems/mruby-compiler/core/y.tab.c" break; case 111: -#line 2144 "mrbgems/mruby-compiler/core/parse.y" +#line 2145 "mrbgems/mruby-compiler/core/parse.y" { backref_error(p, (yyvsp[0].nd)); (yyval.nd) = 0; } -#line 7001 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7002 "mrbgems/mruby-compiler/core/y.tab.c" break; case 112: -#line 2149 "mrbgems/mruby-compiler/core/parse.y" +#line 2150 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "can't assign to numbered parameter"); } -#line 7009 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7010 "mrbgems/mruby-compiler/core/y.tab.c" break; case 113: -#line 2155 "mrbgems/mruby-compiler/core/parse.y" +#line 2156 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "class/module name must be CONSTANT"); } -#line 7017 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7018 "mrbgems/mruby-compiler/core/y.tab.c" break; case 115: -#line 2162 "mrbgems/mruby-compiler/core/parse.y" +#line 2163 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(nint(1), nsym((yyvsp[0].id))); } -#line 7025 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7026 "mrbgems/mruby-compiler/core/y.tab.c" break; case 116: -#line 2166 "mrbgems/mruby-compiler/core/parse.y" +#line 2167 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(nint(0), nsym((yyvsp[0].id))); } -#line 7033 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7034 "mrbgems/mruby-compiler/core/y.tab.c" break; case 117: -#line 2170 "mrbgems/mruby-compiler/core/parse.y" +#line 2171 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[-2].nd)); (yyval.nd) = cons((yyvsp[-2].nd), nsym((yyvsp[0].id))); } -#line 7042 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7043 "mrbgems/mruby-compiler/core/y.tab.c" break; case 121: -#line 2180 "mrbgems/mruby-compiler/core/parse.y" +#line 2181 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_ENDFN; (yyval.id) = (yyvsp[0].id); } -#line 7051 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7052 "mrbgems/mruby-compiler/core/y.tab.c" break; case 122: -#line 2185 "mrbgems/mruby-compiler/core/parse.y" +#line 2186 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_ENDFN; (yyval.id) = (yyvsp[0].id); } -#line 7060 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7061 "mrbgems/mruby-compiler/core/y.tab.c" break; case 125: -#line 2196 "mrbgems/mruby-compiler/core/parse.y" +#line 2197 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_undef(p, (yyvsp[0].id)); } -#line 7068 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7069 "mrbgems/mruby-compiler/core/y.tab.c" break; case 126: -#line 2199 "mrbgems/mruby-compiler/core/parse.y" +#line 2200 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_FNAME;} -#line 7074 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7075 "mrbgems/mruby-compiler/core/y.tab.c" break; case 127: -#line 2200 "mrbgems/mruby-compiler/core/parse.y" +#line 2201 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-3].nd), nsym((yyvsp[0].id))); } -#line 7082 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7083 "mrbgems/mruby-compiler/core/y.tab.c" break; case 128: -#line 2205 "mrbgems/mruby-compiler/core/parse.y" +#line 2206 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(or); } -#line 7088 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7089 "mrbgems/mruby-compiler/core/y.tab.c" break; case 129: -#line 2206 "mrbgems/mruby-compiler/core/parse.y" +#line 2207 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(xor); } -#line 7094 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7095 "mrbgems/mruby-compiler/core/y.tab.c" break; case 130: -#line 2207 "mrbgems/mruby-compiler/core/parse.y" +#line 2208 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(and); } -#line 7100 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7101 "mrbgems/mruby-compiler/core/y.tab.c" break; case 131: -#line 2208 "mrbgems/mruby-compiler/core/parse.y" +#line 2209 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(cmp); } -#line 7106 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7107 "mrbgems/mruby-compiler/core/y.tab.c" break; case 132: -#line 2209 "mrbgems/mruby-compiler/core/parse.y" +#line 2210 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(eq); } -#line 7112 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7113 "mrbgems/mruby-compiler/core/y.tab.c" break; case 133: -#line 2210 "mrbgems/mruby-compiler/core/parse.y" +#line 2211 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(eqq); } -#line 7118 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7119 "mrbgems/mruby-compiler/core/y.tab.c" break; case 134: -#line 2211 "mrbgems/mruby-compiler/core/parse.y" +#line 2212 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(match); } -#line 7124 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7125 "mrbgems/mruby-compiler/core/y.tab.c" break; case 135: -#line 2212 "mrbgems/mruby-compiler/core/parse.y" +#line 2213 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(nmatch); } -#line 7130 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7131 "mrbgems/mruby-compiler/core/y.tab.c" break; case 136: -#line 2213 "mrbgems/mruby-compiler/core/parse.y" +#line 2214 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(gt); } -#line 7136 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7137 "mrbgems/mruby-compiler/core/y.tab.c" break; case 137: -#line 2214 "mrbgems/mruby-compiler/core/parse.y" +#line 2215 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(ge); } -#line 7142 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7143 "mrbgems/mruby-compiler/core/y.tab.c" break; case 138: -#line 2215 "mrbgems/mruby-compiler/core/parse.y" +#line 2216 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(lt); } -#line 7148 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7149 "mrbgems/mruby-compiler/core/y.tab.c" break; case 139: -#line 2216 "mrbgems/mruby-compiler/core/parse.y" +#line 2217 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(le); } -#line 7154 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7155 "mrbgems/mruby-compiler/core/y.tab.c" break; case 140: -#line 2217 "mrbgems/mruby-compiler/core/parse.y" +#line 2218 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(neq); } -#line 7160 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7161 "mrbgems/mruby-compiler/core/y.tab.c" break; case 141: -#line 2218 "mrbgems/mruby-compiler/core/parse.y" +#line 2219 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(lshift); } -#line 7166 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7167 "mrbgems/mruby-compiler/core/y.tab.c" break; case 142: -#line 2219 "mrbgems/mruby-compiler/core/parse.y" +#line 2220 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(rshift); } -#line 7172 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7173 "mrbgems/mruby-compiler/core/y.tab.c" break; case 143: -#line 2220 "mrbgems/mruby-compiler/core/parse.y" +#line 2221 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(add); } -#line 7178 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7179 "mrbgems/mruby-compiler/core/y.tab.c" break; case 144: -#line 2221 "mrbgems/mruby-compiler/core/parse.y" +#line 2222 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(sub); } -#line 7184 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7185 "mrbgems/mruby-compiler/core/y.tab.c" break; case 145: -#line 2222 "mrbgems/mruby-compiler/core/parse.y" +#line 2223 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(mul); } -#line 7190 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7191 "mrbgems/mruby-compiler/core/y.tab.c" break; case 146: -#line 2223 "mrbgems/mruby-compiler/core/parse.y" +#line 2224 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(mul); } -#line 7196 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7197 "mrbgems/mruby-compiler/core/y.tab.c" break; case 147: -#line 2224 "mrbgems/mruby-compiler/core/parse.y" +#line 2225 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(div); } -#line 7202 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7203 "mrbgems/mruby-compiler/core/y.tab.c" break; case 148: -#line 2225 "mrbgems/mruby-compiler/core/parse.y" +#line 2226 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(mod); } -#line 7208 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7209 "mrbgems/mruby-compiler/core/y.tab.c" break; case 149: -#line 2226 "mrbgems/mruby-compiler/core/parse.y" +#line 2227 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(pow); } -#line 7214 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7215 "mrbgems/mruby-compiler/core/y.tab.c" break; case 150: -#line 2227 "mrbgems/mruby-compiler/core/parse.y" +#line 2228 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(pow); } -#line 7220 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7221 "mrbgems/mruby-compiler/core/y.tab.c" break; case 151: -#line 2228 "mrbgems/mruby-compiler/core/parse.y" +#line 2229 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(not); } -#line 7226 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7227 "mrbgems/mruby-compiler/core/y.tab.c" break; case 152: -#line 2229 "mrbgems/mruby-compiler/core/parse.y" +#line 2230 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(neg); } -#line 7232 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7233 "mrbgems/mruby-compiler/core/y.tab.c" break; case 153: -#line 2230 "mrbgems/mruby-compiler/core/parse.y" +#line 2231 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(plus); } -#line 7238 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7239 "mrbgems/mruby-compiler/core/y.tab.c" break; case 154: -#line 2231 "mrbgems/mruby-compiler/core/parse.y" +#line 2232 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(minus); } -#line 7244 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7245 "mrbgems/mruby-compiler/core/y.tab.c" break; case 155: -#line 2232 "mrbgems/mruby-compiler/core/parse.y" +#line 2233 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(aref); } -#line 7250 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7251 "mrbgems/mruby-compiler/core/y.tab.c" break; case 156: -#line 2233 "mrbgems/mruby-compiler/core/parse.y" +#line 2234 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(aset); } -#line 7256 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7257 "mrbgems/mruby-compiler/core/y.tab.c" break; case 157: -#line 2234 "mrbgems/mruby-compiler/core/parse.y" +#line 2235 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(tick); } -#line 7262 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7263 "mrbgems/mruby-compiler/core/y.tab.c" break; case 198: -#line 2252 "mrbgems/mruby-compiler/core/parse.y" +#line 2253 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7270 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7271 "mrbgems/mruby-compiler/core/y.tab.c" break; case 199: -#line 2256 "mrbgems/mruby-compiler/core/parse.y" +#line 2257 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 7278 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7279 "mrbgems/mruby-compiler/core/y.tab.c" break; case 200: -#line 2260 "mrbgems/mruby-compiler/core/parse.y" +#line 2261 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_op(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 7286 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7287 "mrbgems/mruby-compiler/core/y.tab.c" break; case 201: -#line 2264 "mrbgems/mruby-compiler/core/parse.y" +#line 2265 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 7294 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7295 "mrbgems/mruby-compiler/core/y.tab.c" break; case 202: -#line 2268 "mrbgems/mruby-compiler/core/parse.y" +#line 2269 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 7302 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7303 "mrbgems/mruby-compiler/core/y.tab.c" break; case 203: -#line 2272 "mrbgems/mruby-compiler/core/parse.y" +#line 2273 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 7310 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7311 "mrbgems/mruby-compiler/core/y.tab.c" break; case 204: -#line 2276 "mrbgems/mruby-compiler/core/parse.y" +#line 2277 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "constant re-assignment"); (yyval.nd) = new_begin(p, 0); } -#line 7319 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7320 "mrbgems/mruby-compiler/core/y.tab.c" break; case 205: -#line 2281 "mrbgems/mruby-compiler/core/parse.y" +#line 2282 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "constant re-assignment"); (yyval.nd) = new_begin(p, 0); } -#line 7328 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7329 "mrbgems/mruby-compiler/core/y.tab.c" break; case 206: -#line 2286 "mrbgems/mruby-compiler/core/parse.y" +#line 2287 "mrbgems/mruby-compiler/core/parse.y" { backref_error(p, (yyvsp[-2].nd)); (yyval.nd) = new_begin(p, 0); } -#line 7337 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7338 "mrbgems/mruby-compiler/core/y.tab.c" break; case 207: -#line 2291 "mrbgems/mruby-compiler/core/parse.y" +#line 2292 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot2(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7345 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7346 "mrbgems/mruby-compiler/core/y.tab.c" break; case 208: -#line 2295 "mrbgems/mruby-compiler/core/parse.y" +#line 2296 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot2(p, (yyvsp[-1].nd), new_nil(p)); } -#line 7353 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7354 "mrbgems/mruby-compiler/core/y.tab.c" break; case 209: -#line 2299 "mrbgems/mruby-compiler/core/parse.y" +#line 2300 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot2(p, new_nil(p), (yyvsp[0].nd)); } -#line 7361 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7362 "mrbgems/mruby-compiler/core/y.tab.c" break; case 210: -#line 2303 "mrbgems/mruby-compiler/core/parse.y" +#line 2304 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot3(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7369 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7370 "mrbgems/mruby-compiler/core/y.tab.c" break; case 211: -#line 2307 "mrbgems/mruby-compiler/core/parse.y" +#line 2308 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot3(p, (yyvsp[-1].nd), new_nil(p)); } -#line 7377 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7378 "mrbgems/mruby-compiler/core/y.tab.c" break; case 212: -#line 2311 "mrbgems/mruby-compiler/core/parse.y" +#line 2312 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot3(p, new_nil(p), (yyvsp[0].nd)); } -#line 7385 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7386 "mrbgems/mruby-compiler/core/y.tab.c" break; case 213: -#line 2315 "mrbgems/mruby-compiler/core/parse.y" +#line 2316 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "+", (yyvsp[0].nd)); } -#line 7393 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7394 "mrbgems/mruby-compiler/core/y.tab.c" break; case 214: -#line 2319 "mrbgems/mruby-compiler/core/parse.y" +#line 2320 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "-", (yyvsp[0].nd)); } -#line 7401 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7402 "mrbgems/mruby-compiler/core/y.tab.c" break; case 215: -#line 2323 "mrbgems/mruby-compiler/core/parse.y" +#line 2324 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "*", (yyvsp[0].nd)); } -#line 7409 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7410 "mrbgems/mruby-compiler/core/y.tab.c" break; case 216: -#line 2327 "mrbgems/mruby-compiler/core/parse.y" +#line 2328 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "/", (yyvsp[0].nd)); } -#line 7417 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7418 "mrbgems/mruby-compiler/core/y.tab.c" break; case 217: -#line 2331 "mrbgems/mruby-compiler/core/parse.y" +#line 2332 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "%", (yyvsp[0].nd)); } -#line 7425 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7426 "mrbgems/mruby-compiler/core/y.tab.c" break; case 218: -#line 2335 "mrbgems/mruby-compiler/core/parse.y" +#line 2336 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)); } -#line 7433 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7434 "mrbgems/mruby-compiler/core/y.tab.c" break; case 219: -#line 2339 "mrbgems/mruby-compiler/core/parse.y" +#line 2340 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_negate(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd))); } -#line 7441 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7442 "mrbgems/mruby-compiler/core/y.tab.c" break; case 220: -#line 2343 "mrbgems/mruby-compiler/core/parse.y" +#line 2344 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_negate(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd))); } -#line 7449 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7450 "mrbgems/mruby-compiler/core/y.tab.c" break; case 221: -#line 2347 "mrbgems/mruby-compiler/core/parse.y" +#line 2348 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "+@"); } -#line 7457 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7458 "mrbgems/mruby-compiler/core/y.tab.c" break; case 222: -#line 2351 "mrbgems/mruby-compiler/core/parse.y" +#line 2352 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_negate(p, (yyvsp[0].nd)); } -#line 7465 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7466 "mrbgems/mruby-compiler/core/y.tab.c" break; case 223: -#line 2355 "mrbgems/mruby-compiler/core/parse.y" +#line 2356 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "|", (yyvsp[0].nd)); } -#line 7473 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7474 "mrbgems/mruby-compiler/core/y.tab.c" break; case 224: -#line 2359 "mrbgems/mruby-compiler/core/parse.y" +#line 2360 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "^", (yyvsp[0].nd)); } -#line 7481 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7482 "mrbgems/mruby-compiler/core/y.tab.c" break; case 225: -#line 2363 "mrbgems/mruby-compiler/core/parse.y" +#line 2364 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "&", (yyvsp[0].nd)); } -#line 7489 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7490 "mrbgems/mruby-compiler/core/y.tab.c" break; case 226: -#line 2367 "mrbgems/mruby-compiler/core/parse.y" +#line 2368 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=>", (yyvsp[0].nd)); } -#line 7497 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7498 "mrbgems/mruby-compiler/core/y.tab.c" break; case 227: -#line 2371 "mrbgems/mruby-compiler/core/parse.y" +#line 2372 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">", (yyvsp[0].nd)); } -#line 7505 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7506 "mrbgems/mruby-compiler/core/y.tab.c" break; case 228: -#line 2375 "mrbgems/mruby-compiler/core/parse.y" +#line 2376 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">=", (yyvsp[0].nd)); } -#line 7513 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7514 "mrbgems/mruby-compiler/core/y.tab.c" break; case 229: -#line 2379 "mrbgems/mruby-compiler/core/parse.y" +#line 2380 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<", (yyvsp[0].nd)); } -#line 7521 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7522 "mrbgems/mruby-compiler/core/y.tab.c" break; case 230: -#line 2383 "mrbgems/mruby-compiler/core/parse.y" +#line 2384 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=", (yyvsp[0].nd)); } -#line 7529 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7530 "mrbgems/mruby-compiler/core/y.tab.c" break; case 231: -#line 2387 "mrbgems/mruby-compiler/core/parse.y" +#line 2388 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "==", (yyvsp[0].nd)); } -#line 7537 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7538 "mrbgems/mruby-compiler/core/y.tab.c" break; case 232: -#line 2391 "mrbgems/mruby-compiler/core/parse.y" +#line 2392 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "===", (yyvsp[0].nd)); } -#line 7545 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7546 "mrbgems/mruby-compiler/core/y.tab.c" break; case 233: -#line 2395 "mrbgems/mruby-compiler/core/parse.y" +#line 2396 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!=", (yyvsp[0].nd)); } -#line 7553 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7554 "mrbgems/mruby-compiler/core/y.tab.c" break; case 234: -#line 2399 "mrbgems/mruby-compiler/core/parse.y" +#line 2400 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "=~", (yyvsp[0].nd)); } -#line 7561 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7562 "mrbgems/mruby-compiler/core/y.tab.c" break; case 235: -#line 2403 "mrbgems/mruby-compiler/core/parse.y" +#line 2404 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!~", (yyvsp[0].nd)); } -#line 7569 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7570 "mrbgems/mruby-compiler/core/y.tab.c" break; case 236: -#line 2407 "mrbgems/mruby-compiler/core/parse.y" +#line 2408 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!"); } -#line 7577 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7578 "mrbgems/mruby-compiler/core/y.tab.c" break; case 237: -#line 2411 "mrbgems/mruby-compiler/core/parse.y" +#line 2412 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "~"); } -#line 7585 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7586 "mrbgems/mruby-compiler/core/y.tab.c" break; case 238: -#line 2415 "mrbgems/mruby-compiler/core/parse.y" +#line 2416 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<<", (yyvsp[0].nd)); } -#line 7593 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7594 "mrbgems/mruby-compiler/core/y.tab.c" break; case 239: -#line 2419 "mrbgems/mruby-compiler/core/parse.y" +#line 2420 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">>", (yyvsp[0].nd)); } -#line 7601 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7602 "mrbgems/mruby-compiler/core/y.tab.c" break; case 240: -#line 2423 "mrbgems/mruby-compiler/core/parse.y" +#line 2424 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7609 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7610 "mrbgems/mruby-compiler/core/y.tab.c" break; case 241: -#line 2427 "mrbgems/mruby-compiler/core/parse.y" +#line 2428 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7617 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7618 "mrbgems/mruby-compiler/core/y.tab.c" break; case 242: -#line 2431 "mrbgems/mruby-compiler/core/parse.y" +#line 2432 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd)); } -#line 7625 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7626 "mrbgems/mruby-compiler/core/y.tab.c" break; case 243: -#line 2435 "mrbgems/mruby-compiler/core/parse.y" +#line 2436 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd)); } -#line 7633 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7634 "mrbgems/mruby-compiler/core/y.tab.c" break; case 244: -#line 2439 "mrbgems/mruby-compiler/core/parse.y" +#line 2440 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); endless_method_name(p, (yyvsp[-3].nd)); @@ -7642,11 +7643,11 @@ yyreduce: nvars_unnest(p); p->in_def--; } -#line 7646 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7647 "mrbgems/mruby-compiler/core/y.tab.c" break; case 245: -#line 2448 "mrbgems/mruby-compiler/core/parse.y" +#line 2449 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-5].nd); endless_method_name(p, (yyvsp[-5].nd)); @@ -7655,11 +7656,11 @@ yyreduce: nvars_unnest(p); p->in_def--; } -#line 7659 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7660 "mrbgems/mruby-compiler/core/y.tab.c" break; case 246: -#line 2457 "mrbgems/mruby-compiler/core/parse.y" +#line 2458 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); void_expr_error(p, (yyvsp[0].nd)); @@ -7668,11 +7669,11 @@ yyreduce: p->in_def--; p->in_single--; } -#line 7672 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7673 "mrbgems/mruby-compiler/core/y.tab.c" break; case 247: -#line 2466 "mrbgems/mruby-compiler/core/parse.y" +#line 2467 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-5].nd); void_expr_error(p, (yyvsp[-2].nd)); @@ -7681,70 +7682,70 @@ yyreduce: p->in_def--; p->in_single--; } -#line 7685 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7686 "mrbgems/mruby-compiler/core/y.tab.c" break; case 248: -#line 2475 "mrbgems/mruby-compiler/core/parse.y" +#line 2476 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 7693 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7694 "mrbgems/mruby-compiler/core/y.tab.c" break; case 250: -#line 2482 "mrbgems/mruby-compiler/core/parse.y" +#line 2483 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7702 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7703 "mrbgems/mruby-compiler/core/y.tab.c" break; case 251: -#line 2487 "mrbgems/mruby-compiler/core/parse.y" +#line 2488 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-3].nd), new_hash(p, (yyvsp[-1].nd))); } -#line 7710 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7711 "mrbgems/mruby-compiler/core/y.tab.c" break; case 252: -#line 2491 "mrbgems/mruby-compiler/core/parse.y" +#line 2492 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(new_kw_hash(p, (yyvsp[-1].nd)), 0); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7719 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7720 "mrbgems/mruby-compiler/core/y.tab.c" break; case 253: -#line 2498 "mrbgems/mruby-compiler/core/parse.y" +#line 2499 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 7727 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7728 "mrbgems/mruby-compiler/core/y.tab.c" break; case 254: -#line 2502 "mrbgems/mruby-compiler/core/parse.y" +#line 2503 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[-2].nd)); (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7736 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7737 "mrbgems/mruby-compiler/core/y.tab.c" break; case 255: -#line 2509 "mrbgems/mruby-compiler/core/parse.y" +#line 2510 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 7744 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7745 "mrbgems/mruby-compiler/core/y.tab.c" break; case 256: -#line 2513 "mrbgems/mruby-compiler/core/parse.y" +#line 2514 "mrbgems/mruby-compiler/core/parse.y" { mrb_sym r = intern_op(mul); mrb_sym k = intern_op(pow); @@ -7753,11 +7754,11 @@ yyreduce: new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k)))), new_block_arg(p, new_lvar(p, b))); } -#line 7757 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7758 "mrbgems/mruby-compiler/core/y.tab.c" break; case 257: -#line 2522 "mrbgems/mruby-compiler/core/parse.y" +#line 2523 "mrbgems/mruby-compiler/core/parse.y" { mrb_sym r = intern_op(mul); mrb_sym k = intern_op(pow); @@ -7772,378 +7773,378 @@ yyreduce: (yyval.nd) = 0; } } -#line 7776 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7777 "mrbgems/mruby-compiler/core/y.tab.c" break; case 262: -#line 2545 "mrbgems/mruby-compiler/core/parse.y" +#line 2546 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_callargs(p,(yyvsp[-1].nd),0,0); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7785 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7786 "mrbgems/mruby-compiler/core/y.tab.c" break; case 263: -#line 2550 "mrbgems/mruby-compiler/core/parse.y" +#line 2551 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_callargs(p,(yyvsp[-3].nd),new_kw_hash(p,(yyvsp[-1].nd)),0); NODE_LINENO((yyval.nd), (yyvsp[-3].nd)); } -#line 7794 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7795 "mrbgems/mruby-compiler/core/y.tab.c" break; case 264: -#line 2555 "mrbgems/mruby-compiler/core/parse.y" +#line 2556 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_callargs(p,0,new_kw_hash(p,(yyvsp[-1].nd)),0); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7803 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7804 "mrbgems/mruby-compiler/core/y.tab.c" break; case 265: -#line 2562 "mrbgems/mruby-compiler/core/parse.y" +#line 2563 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = new_callargs(p, list1((yyvsp[0].nd)), 0, 0); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 7813 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7814 "mrbgems/mruby-compiler/core/y.tab.c" break; case 266: -#line 2568 "mrbgems/mruby-compiler/core/parse.y" +#line 2569 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_callargs(p, (yyvsp[-1].nd), 0, (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7822 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7823 "mrbgems/mruby-compiler/core/y.tab.c" break; case 267: -#line 2573 "mrbgems/mruby-compiler/core/parse.y" +#line 2574 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_callargs(p, 0, new_kw_hash(p, (yyvsp[-1].nd)), (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7831 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7832 "mrbgems/mruby-compiler/core/y.tab.c" break; case 268: -#line 2578 "mrbgems/mruby-compiler/core/parse.y" +#line 2579 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_callargs(p, (yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd)), (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[-3].nd)); } -#line 7840 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7841 "mrbgems/mruby-compiler/core/y.tab.c" break; case 269: -#line 2583 "mrbgems/mruby-compiler/core/parse.y" +#line 2584 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_callargs(p, 0, 0, (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 7849 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7850 "mrbgems/mruby-compiler/core/y.tab.c" break; case 270: -#line 2589 "mrbgems/mruby-compiler/core/parse.y" +#line 2590 "mrbgems/mruby-compiler/core/parse.y" { (yyval.stack) = p->cmdarg_stack; CMDARG_PUSH(1); } -#line 7858 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7859 "mrbgems/mruby-compiler/core/y.tab.c" break; case 271: -#line 2594 "mrbgems/mruby-compiler/core/parse.y" +#line 2595 "mrbgems/mruby-compiler/core/parse.y" { p->cmdarg_stack = (yyvsp[-1].stack); (yyval.nd) = (yyvsp[0].nd); } -#line 7867 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7868 "mrbgems/mruby-compiler/core/y.tab.c" break; case 272: -#line 2601 "mrbgems/mruby-compiler/core/parse.y" +#line 2602 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block_arg(p, (yyvsp[0].nd)); } -#line 7875 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7876 "mrbgems/mruby-compiler/core/y.tab.c" break; case 273: -#line 2605 "mrbgems/mruby-compiler/core/parse.y" +#line 2606 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block_arg(p, 0); } -#line 7883 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7884 "mrbgems/mruby-compiler/core/y.tab.c" break; case 274: -#line 2611 "mrbgems/mruby-compiler/core/parse.y" +#line 2612 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 7891 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7892 "mrbgems/mruby-compiler/core/y.tab.c" break; case 275: -#line 2615 "mrbgems/mruby-compiler/core/parse.y" +#line 2616 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 7899 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7900 "mrbgems/mruby-compiler/core/y.tab.c" break; case 277: -#line 2624 "mrbgems/mruby-compiler/core/parse.y" +#line 2625 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = list1((yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 7909 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7910 "mrbgems/mruby-compiler/core/y.tab.c" break; case 278: -#line 2630 "mrbgems/mruby-compiler/core/parse.y" +#line 2631 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(new_splat(p, (yyvsp[0].nd))); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 7918 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7919 "mrbgems/mruby-compiler/core/y.tab.c" break; case 279: -#line 2635 "mrbgems/mruby-compiler/core/parse.y" +#line 2636 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7927 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7928 "mrbgems/mruby-compiler/core/y.tab.c" break; case 280: -#line 2640 "mrbgems/mruby-compiler/core/parse.y" +#line 2641 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd))); } -#line 7935 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7936 "mrbgems/mruby-compiler/core/y.tab.c" break; case 281: -#line 2646 "mrbgems/mruby-compiler/core/parse.y" +#line 2647 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7944 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7945 "mrbgems/mruby-compiler/core/y.tab.c" break; case 282: -#line 2651 "mrbgems/mruby-compiler/core/parse.y" +#line 2652 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd))); } -#line 7952 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7953 "mrbgems/mruby-compiler/core/y.tab.c" break; case 283: -#line 2655 "mrbgems/mruby-compiler/core/parse.y" +#line 2656 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(new_splat(p, (yyvsp[0].nd))); } -#line 7960 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7961 "mrbgems/mruby-compiler/core/y.tab.c" break; case 291: -#line 2668 "mrbgems/mruby-compiler/core/parse.y" +#line 2669 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_nvar(p, (yyvsp[0].num)); } -#line 7968 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7969 "mrbgems/mruby-compiler/core/y.tab.c" break; case 292: -#line 2672 "mrbgems/mruby-compiler/core/parse.y" +#line 2673 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, (yyvsp[0].id), 0); } -#line 7976 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7977 "mrbgems/mruby-compiler/core/y.tab.c" break; case 293: -#line 2676 "mrbgems/mruby-compiler/core/parse.y" +#line 2677 "mrbgems/mruby-compiler/core/parse.y" { (yyval.stack) = p->cmdarg_stack; p->cmdarg_stack = 0; } -#line 7985 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7986 "mrbgems/mruby-compiler/core/y.tab.c" break; case 294: -#line 2682 "mrbgems/mruby-compiler/core/parse.y" +#line 2683 "mrbgems/mruby-compiler/core/parse.y" { p->cmdarg_stack = (yyvsp[-2].stack); (yyval.nd) = (yyvsp[-1].nd); } -#line 7994 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7995 "mrbgems/mruby-compiler/core/y.tab.c" break; case 295: -#line 2687 "mrbgems/mruby-compiler/core/parse.y" +#line 2688 "mrbgems/mruby-compiler/core/parse.y" { (yyval.stack) = p->cmdarg_stack; p->cmdarg_stack = 0; } -#line 8003 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8004 "mrbgems/mruby-compiler/core/y.tab.c" break; case 296: -#line 2691 "mrbgems/mruby-compiler/core/parse.y" +#line 2692 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_ENDARG;} -#line 8009 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8010 "mrbgems/mruby-compiler/core/y.tab.c" break; case 297: -#line 2692 "mrbgems/mruby-compiler/core/parse.y" +#line 2693 "mrbgems/mruby-compiler/core/parse.y" { p->cmdarg_stack = (yyvsp[-3].stack); (yyval.nd) = (yyvsp[-2].nd); } -#line 8018 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8019 "mrbgems/mruby-compiler/core/y.tab.c" break; case 298: -#line 2696 "mrbgems/mruby-compiler/core/parse.y" +#line 2697 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_ENDARG;} -#line 8024 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8025 "mrbgems/mruby-compiler/core/y.tab.c" break; case 299: -#line 2697 "mrbgems/mruby-compiler/core/parse.y" +#line 2698 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_nil(p); } -#line 8032 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8033 "mrbgems/mruby-compiler/core/y.tab.c" break; case 300: -#line 2701 "mrbgems/mruby-compiler/core/parse.y" +#line 2702 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 8040 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8041 "mrbgems/mruby-compiler/core/y.tab.c" break; case 301: -#line 2705 "mrbgems/mruby-compiler/core/parse.y" +#line 2706 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id)); } -#line 8048 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8049 "mrbgems/mruby-compiler/core/y.tab.c" break; case 302: -#line 2709 "mrbgems/mruby-compiler/core/parse.y" +#line 2710 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_colon3(p, (yyvsp[0].id)); } -#line 8056 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8057 "mrbgems/mruby-compiler/core/y.tab.c" break; case 303: -#line 2713 "mrbgems/mruby-compiler/core/parse.y" +#line 2714 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_array(p, (yyvsp[-1].nd)); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 8065 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8066 "mrbgems/mruby-compiler/core/y.tab.c" break; case 304: -#line 2718 "mrbgems/mruby-compiler/core/parse.y" +#line 2719 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_hash(p, (yyvsp[-1].nd)); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 8074 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8075 "mrbgems/mruby-compiler/core/y.tab.c" break; case 305: -#line 2723 "mrbgems/mruby-compiler/core/parse.y" +#line 2724 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_return(p, 0); } -#line 8082 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8083 "mrbgems/mruby-compiler/core/y.tab.c" break; case 306: -#line 2727 "mrbgems/mruby-compiler/core/parse.y" +#line 2728 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_yield(p, (yyvsp[0].nd)); } -#line 8090 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8091 "mrbgems/mruby-compiler/core/y.tab.c" break; case 307: -#line 2731 "mrbgems/mruby-compiler/core/parse.y" +#line 2732 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[-1].nd)), "!"); } -#line 8098 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8099 "mrbgems/mruby-compiler/core/y.tab.c" break; case 308: -#line 2735 "mrbgems/mruby-compiler/core/parse.y" +#line 2736 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, new_nil(p), "!"); } -#line 8106 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8107 "mrbgems/mruby-compiler/core/y.tab.c" break; case 309: -#line 2739 "mrbgems/mruby-compiler/core/parse.y" +#line 2740 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, (yyvsp[-1].id), new_callargs(p, 0, 0, (yyvsp[0].nd))); } -#line 8114 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8115 "mrbgems/mruby-compiler/core/y.tab.c" break; case 311: -#line 2744 "mrbgems/mruby-compiler/core/parse.y" +#line 2745 "mrbgems/mruby-compiler/core/parse.y" { call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd)); (yyval.nd) = (yyvsp[-1].nd); } -#line 8123 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8124 "mrbgems/mruby-compiler/core/y.tab.c" break; case 312: -#line 2749 "mrbgems/mruby-compiler/core/parse.y" +#line 2750 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); (yyval.num) = p->lpar_beg; p->lpar_beg = ++p->paren_nest; } -#line 8134 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8135 "mrbgems/mruby-compiler/core/y.tab.c" break; case 313: -#line 2756 "mrbgems/mruby-compiler/core/parse.y" +#line 2757 "mrbgems/mruby-compiler/core/parse.y" { (yyval.stack) = p->cmdarg_stack; p->cmdarg_stack = 0; } -#line 8143 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8144 "mrbgems/mruby-compiler/core/y.tab.c" break; case 314: -#line 2761 "mrbgems/mruby-compiler/core/parse.y" +#line 2762 "mrbgems/mruby-compiler/core/parse.y" { p->lpar_beg = (yyvsp[-3].num); (yyval.nd) = new_lambda(p, (yyvsp[-2].nd), (yyvsp[0].nd)); @@ -8152,149 +8153,149 @@ yyreduce: p->cmdarg_stack = (yyvsp[-1].stack); CMDARG_LEXPOP(); } -#line 8156 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8157 "mrbgems/mruby-compiler/core/y.tab.c" break; case 315: -#line 2773 "mrbgems/mruby-compiler/core/parse.y" +#line 2774 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-5].num)); } -#line 8165 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8166 "mrbgems/mruby-compiler/core/y.tab.c" break; case 316: -#line 2781 "mrbgems/mruby-compiler/core/parse.y" +#line 2782 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_unless(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-5].num)); } -#line 8174 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8175 "mrbgems/mruby-compiler/core/y.tab.c" break; case 317: -#line 2785 "mrbgems/mruby-compiler/core/parse.y" +#line 2786 "mrbgems/mruby-compiler/core/parse.y" {COND_PUSH(1);} -#line 8180 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8181 "mrbgems/mruby-compiler/core/y.tab.c" break; case 318: -#line 2785 "mrbgems/mruby-compiler/core/parse.y" +#line 2786 "mrbgems/mruby-compiler/core/parse.y" {COND_POP();} -#line 8186 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8187 "mrbgems/mruby-compiler/core/y.tab.c" break; case 319: -#line 2788 "mrbgems/mruby-compiler/core/parse.y" +#line 2789 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_while(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-6].num)); } -#line 8195 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8196 "mrbgems/mruby-compiler/core/y.tab.c" break; case 320: -#line 2792 "mrbgems/mruby-compiler/core/parse.y" +#line 2793 "mrbgems/mruby-compiler/core/parse.y" {COND_PUSH(1);} -#line 8201 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8202 "mrbgems/mruby-compiler/core/y.tab.c" break; case 321: -#line 2792 "mrbgems/mruby-compiler/core/parse.y" +#line 2793 "mrbgems/mruby-compiler/core/parse.y" {COND_POP();} -#line 8207 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8208 "mrbgems/mruby-compiler/core/y.tab.c" break; case 322: -#line 2795 "mrbgems/mruby-compiler/core/parse.y" +#line 2796 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_until(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-6].num)); } -#line 8216 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8217 "mrbgems/mruby-compiler/core/y.tab.c" break; case 323: -#line 2802 "mrbgems/mruby-compiler/core/parse.y" +#line 2803 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_case(p, (yyvsp[-3].nd), (yyvsp[-1].nd)); } -#line 8224 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8225 "mrbgems/mruby-compiler/core/y.tab.c" break; case 324: -#line 2806 "mrbgems/mruby-compiler/core/parse.y" +#line 2807 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_case(p, 0, (yyvsp[-1].nd)); } -#line 8232 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8233 "mrbgems/mruby-compiler/core/y.tab.c" break; case 325: -#line 2810 "mrbgems/mruby-compiler/core/parse.y" +#line 2811 "mrbgems/mruby-compiler/core/parse.y" {COND_PUSH(1);} -#line 8238 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8239 "mrbgems/mruby-compiler/core/y.tab.c" break; case 326: -#line 2812 "mrbgems/mruby-compiler/core/parse.y" +#line 2813 "mrbgems/mruby-compiler/core/parse.y" {COND_POP();} -#line 8244 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8245 "mrbgems/mruby-compiler/core/y.tab.c" break; case 327: -#line 2815 "mrbgems/mruby-compiler/core/parse.y" +#line 2816 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_for(p, (yyvsp[-7].nd), (yyvsp[-4].nd), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-8].num)); } -#line 8253 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8254 "mrbgems/mruby-compiler/core/y.tab.c" break; case 328: -#line 2821 "mrbgems/mruby-compiler/core/parse.y" +#line 2822 "mrbgems/mruby-compiler/core/parse.y" { if (p->in_def || p->in_single) yyerror(p, "class definition in method body"); (yyval.nd) = local_switch(p); nvars_block(p); } -#line 8264 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8265 "mrbgems/mruby-compiler/core/y.tab.c" break; case 329: -#line 2829 "mrbgems/mruby-compiler/core/parse.y" +#line 2830 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_class(p, (yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-5].num)); local_resume(p, (yyvsp[-2].nd)); nvars_unnest(p); } -#line 8275 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8276 "mrbgems/mruby-compiler/core/y.tab.c" break; case 330: -#line 2837 "mrbgems/mruby-compiler/core/parse.y" +#line 2838 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = p->in_def; p->in_def = 0; } -#line 8284 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8285 "mrbgems/mruby-compiler/core/y.tab.c" break; case 331: -#line 2842 "mrbgems/mruby-compiler/core/parse.y" +#line 2843 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(local_switch(p), nint(p->in_single)); nvars_block(p); p->in_single = 0; } -#line 8294 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8295 "mrbgems/mruby-compiler/core/y.tab.c" break; case 332: -#line 2849 "mrbgems/mruby-compiler/core/parse.y" +#line 2850 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_sclass(p, (yyvsp[-5].nd), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-7].num)); @@ -8303,44 +8304,44 @@ yyreduce: p->in_def = (yyvsp[-4].num); p->in_single = intn((yyvsp[-2].nd)->cdr); } -#line 8307 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8308 "mrbgems/mruby-compiler/core/y.tab.c" break; case 333: -#line 2859 "mrbgems/mruby-compiler/core/parse.y" +#line 2860 "mrbgems/mruby-compiler/core/parse.y" { if (p->in_def || p->in_single) yyerror(p, "module definition in method body"); (yyval.nd) = local_switch(p); nvars_block(p); } -#line 8318 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8319 "mrbgems/mruby-compiler/core/y.tab.c" break; case 334: -#line 2867 "mrbgems/mruby-compiler/core/parse.y" +#line 2868 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_module(p, (yyvsp[-3].nd), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-4].num)); local_resume(p, (yyvsp[-2].nd)); nvars_unnest(p); } -#line 8329 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8330 "mrbgems/mruby-compiler/core/y.tab.c" break; case 335: -#line 2877 "mrbgems/mruby-compiler/core/parse.y" +#line 2878 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd)); nvars_unnest(p); p->in_def--; } -#line 8340 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8341 "mrbgems/mruby-compiler/core/y.tab.c" break; case 336: -#line 2887 "mrbgems/mruby-compiler/core/parse.y" +#line 2888 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd)); @@ -8348,451 +8349,451 @@ yyreduce: p->in_def--; p->in_single--; } -#line 8352 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8353 "mrbgems/mruby-compiler/core/y.tab.c" break; case 337: -#line 2895 "mrbgems/mruby-compiler/core/parse.y" +#line 2896 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_break(p, 0); } -#line 8360 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8361 "mrbgems/mruby-compiler/core/y.tab.c" break; case 338: -#line 2899 "mrbgems/mruby-compiler/core/parse.y" +#line 2900 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_next(p, 0); } -#line 8368 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8369 "mrbgems/mruby-compiler/core/y.tab.c" break; case 339: -#line 2903 "mrbgems/mruby-compiler/core/parse.y" +#line 2904 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_redo(p); } -#line 8376 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8377 "mrbgems/mruby-compiler/core/y.tab.c" break; case 340: -#line 2907 "mrbgems/mruby-compiler/core/parse.y" +#line 2908 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_retry(p); } -#line 8384 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8385 "mrbgems/mruby-compiler/core/y.tab.c" break; case 341: -#line 2913 "mrbgems/mruby-compiler/core/parse.y" +#line 2914 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); if (!(yyval.nd)) (yyval.nd) = new_nil(p); } -#line 8393 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8394 "mrbgems/mruby-compiler/core/y.tab.c" break; case 348: -#line 2932 "mrbgems/mruby-compiler/core/parse.y" +#line 2933 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[-3].nd)), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8401 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8402 "mrbgems/mruby-compiler/core/y.tab.c" break; case 350: -#line 2939 "mrbgems/mruby-compiler/core/parse.y" +#line 2940 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8409 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8410 "mrbgems/mruby-compiler/core/y.tab.c" break; case 351: -#line 2945 "mrbgems/mruby-compiler/core/parse.y" +#line 2946 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(list1((yyvsp[0].nd))); } -#line 8417 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8418 "mrbgems/mruby-compiler/core/y.tab.c" break; case 353: -#line 2952 "mrbgems/mruby-compiler/core/parse.y" +#line 2953 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[0].nd),0,0); } -#line 8425 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8426 "mrbgems/mruby-compiler/core/y.tab.c" break; case 354: -#line 2956 "mrbgems/mruby-compiler/core/parse.y" +#line 2957 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-3].nd), new_arg(p, (yyvsp[0].id)), 0); } -#line 8433 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8434 "mrbgems/mruby-compiler/core/y.tab.c" break; case 355: -#line 2960 "mrbgems/mruby-compiler/core/parse.y" +#line 2961 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-5].nd), new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd)); } -#line 8441 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8442 "mrbgems/mruby-compiler/core/y.tab.c" break; case 356: -#line 2964 "mrbgems/mruby-compiler/core/parse.y" +#line 2965 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, intern_op(mul)); (yyval.nd) = list3((yyvsp[-2].nd), nint(-1), 0); } -#line 8450 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8451 "mrbgems/mruby-compiler/core/y.tab.c" break; case 357: -#line 2969 "mrbgems/mruby-compiler/core/parse.y" +#line 2970 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-4].nd), nint(-1), (yyvsp[0].nd)); } -#line 8458 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8459 "mrbgems/mruby-compiler/core/y.tab.c" break; case 358: -#line 2973 "mrbgems/mruby-compiler/core/parse.y" +#line 2974 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, new_arg(p, (yyvsp[0].id)), 0); } -#line 8466 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8467 "mrbgems/mruby-compiler/core/y.tab.c" break; case 359: -#line 2977 "mrbgems/mruby-compiler/core/parse.y" +#line 2978 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd)); } -#line 8474 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8475 "mrbgems/mruby-compiler/core/y.tab.c" break; case 360: -#line 2981 "mrbgems/mruby-compiler/core/parse.y" +#line 2982 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, intern_op(mul)); (yyval.nd) = list3(0, nint(-1), 0); } -#line 8483 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8484 "mrbgems/mruby-compiler/core/y.tab.c" break; case 361: -#line 2986 "mrbgems/mruby-compiler/core/parse.y" +#line 2987 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, intern_op(mul)); } -#line 8491 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8492 "mrbgems/mruby-compiler/core/y.tab.c" break; case 362: -#line 2990 "mrbgems/mruby-compiler/core/parse.y" +#line 2991 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, nint(-1), (yyvsp[0].nd)); } -#line 8499 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8500 "mrbgems/mruby-compiler/core/y.tab.c" break; case 363: -#line 2996 "mrbgems/mruby-compiler/core/parse.y" +#line 2997 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 8507 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8508 "mrbgems/mruby-compiler/core/y.tab.c" break; case 364: -#line 3000 "mrbgems/mruby-compiler/core/parse.y" +#line 3001 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id)); } -#line 8515 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8516 "mrbgems/mruby-compiler/core/y.tab.c" break; case 365: -#line 3004 "mrbgems/mruby-compiler/core/parse.y" +#line 3005 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 8523 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8524 "mrbgems/mruby-compiler/core/y.tab.c" break; case 366: -#line 3008 "mrbgems/mruby-compiler/core/parse.y" +#line 3009 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id)); } -#line 8531 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8532 "mrbgems/mruby-compiler/core/y.tab.c" break; case 367: -#line 3014 "mrbgems/mruby-compiler/core/parse.y" +#line 3015 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8539 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8540 "mrbgems/mruby-compiler/core/y.tab.c" break; case 368: -#line 3018 "mrbgems/mruby-compiler/core/parse.y" +#line 3019 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, 0, 0); } -#line 8547 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8548 "mrbgems/mruby-compiler/core/y.tab.c" break; case 369: -#line 3024 "mrbgems/mruby-compiler/core/parse.y" +#line 3025 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8555 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8556 "mrbgems/mruby-compiler/core/y.tab.c" break; case 370: -#line 3028 "mrbgems/mruby-compiler/core/parse.y" +#line 3029 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8563 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8564 "mrbgems/mruby-compiler/core/y.tab.c" break; case 371: -#line 3032 "mrbgems/mruby-compiler/core/parse.y" +#line 3033 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 8571 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8572 "mrbgems/mruby-compiler/core/y.tab.c" break; case 372: -#line 3036 "mrbgems/mruby-compiler/core/parse.y" +#line 3037 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8579 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8580 "mrbgems/mruby-compiler/core/y.tab.c" break; case 373: -#line 3040 "mrbgems/mruby-compiler/core/parse.y" +#line 3041 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8587 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8588 "mrbgems/mruby-compiler/core/y.tab.c" break; case 374: -#line 3044 "mrbgems/mruby-compiler/core/parse.y" +#line 3045 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 8595 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8596 "mrbgems/mruby-compiler/core/y.tab.c" break; case 375: -#line 3048 "mrbgems/mruby-compiler/core/parse.y" +#line 3049 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8603 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8604 "mrbgems/mruby-compiler/core/y.tab.c" break; case 376: -#line 3052 "mrbgems/mruby-compiler/core/parse.y" +#line 3053 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 8611 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8612 "mrbgems/mruby-compiler/core/y.tab.c" break; case 377: -#line 3056 "mrbgems/mruby-compiler/core/parse.y" +#line 3057 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8619 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8620 "mrbgems/mruby-compiler/core/y.tab.c" break; case 378: -#line 3060 "mrbgems/mruby-compiler/core/parse.y" +#line 3061 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8627 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8628 "mrbgems/mruby-compiler/core/y.tab.c" break; case 379: -#line 3064 "mrbgems/mruby-compiler/core/parse.y" +#line 3065 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 8635 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8636 "mrbgems/mruby-compiler/core/y.tab.c" break; case 380: -#line 3068 "mrbgems/mruby-compiler/core/parse.y" +#line 3069 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8643 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8644 "mrbgems/mruby-compiler/core/y.tab.c" break; case 381: -#line 3072 "mrbgems/mruby-compiler/core/parse.y" +#line 3073 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8651 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8652 "mrbgems/mruby-compiler/core/y.tab.c" break; case 382: -#line 3076 "mrbgems/mruby-compiler/core/parse.y" +#line 3077 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8659 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8660 "mrbgems/mruby-compiler/core/y.tab.c" break; case 383: -#line 3080 "mrbgems/mruby-compiler/core/parse.y" +#line 3081 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd)); } -#line 8667 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8668 "mrbgems/mruby-compiler/core/y.tab.c" break; case 384: -#line 3086 "mrbgems/mruby-compiler/core/parse.y" +#line 3087 "mrbgems/mruby-compiler/core/parse.y" { local_add_blk(p, 0); (yyval.nd) = 0; } -#line 8676 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8677 "mrbgems/mruby-compiler/core/y.tab.c" break; case 385: -#line 3091 "mrbgems/mruby-compiler/core/parse.y" +#line 3092 "mrbgems/mruby-compiler/core/parse.y" { p->cmd_start = TRUE; (yyval.nd) = (yyvsp[0].nd); } -#line 8685 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8686 "mrbgems/mruby-compiler/core/y.tab.c" break; case 386: -#line 3097 "mrbgems/mruby-compiler/core/parse.y" +#line 3098 "mrbgems/mruby-compiler/core/parse.y" {local_add_blk(p, 0);} -#line 8691 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8692 "mrbgems/mruby-compiler/core/y.tab.c" break; case 387: -#line 3098 "mrbgems/mruby-compiler/core/parse.y" +#line 3099 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 8699 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8700 "mrbgems/mruby-compiler/core/y.tab.c" break; case 388: -#line 3102 "mrbgems/mruby-compiler/core/parse.y" +#line 3103 "mrbgems/mruby-compiler/core/parse.y" { local_add_blk(p, 0); (yyval.nd) = 0; } -#line 8708 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8709 "mrbgems/mruby-compiler/core/y.tab.c" break; case 389: -#line 3107 "mrbgems/mruby-compiler/core/parse.y" +#line 3108 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-2].nd); } -#line 8716 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8717 "mrbgems/mruby-compiler/core/y.tab.c" break; case 390: -#line 3114 "mrbgems/mruby-compiler/core/parse.y" +#line 3115 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 8724 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8725 "mrbgems/mruby-compiler/core/y.tab.c" break; case 391: -#line 3118 "mrbgems/mruby-compiler/core/parse.y" +#line 3119 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 8732 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8733 "mrbgems/mruby-compiler/core/y.tab.c" break; case 394: -#line 3128 "mrbgems/mruby-compiler/core/parse.y" +#line 3129 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); new_bv(p, (yyvsp[0].id)); } -#line 8741 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8742 "mrbgems/mruby-compiler/core/y.tab.c" break; case 396: -#line 3136 "mrbgems/mruby-compiler/core/parse.y" +#line 3137 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-2].nd); } -#line 8749 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8750 "mrbgems/mruby-compiler/core/y.tab.c" break; case 397: -#line 3140 "mrbgems/mruby-compiler/core/parse.y" +#line 3141 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8757 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8758 "mrbgems/mruby-compiler/core/y.tab.c" break; case 398: -#line 3146 "mrbgems/mruby-compiler/core/parse.y" +#line 3147 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 8765 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8766 "mrbgems/mruby-compiler/core/y.tab.c" break; case 399: -#line 3150 "mrbgems/mruby-compiler/core/parse.y" +#line 3151 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 8773 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8774 "mrbgems/mruby-compiler/core/y.tab.c" break; case 400: -#line 3156 "mrbgems/mruby-compiler/core/parse.y" +#line 3157 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); } -#line 8782 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8783 "mrbgems/mruby-compiler/core/y.tab.c" break; case 401: -#line 3163 "mrbgems/mruby-compiler/core/parse.y" +#line 3164 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); local_unnest(p); nvars_unnest(p); } -#line 8792 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8793 "mrbgems/mruby-compiler/core/y.tab.c" break; case 402: -#line 3171 "mrbgems/mruby-compiler/core/parse.y" +#line 3172 "mrbgems/mruby-compiler/core/parse.y" { if (typen((yyvsp[-1].nd)->car) == NODE_YIELD) { yyerror(p, "block given to yield"); @@ -8802,159 +8803,159 @@ yyreduce: } (yyval.nd) = (yyvsp[-1].nd); } -#line 8806 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8807 "mrbgems/mruby-compiler/core/y.tab.c" break; case 403: -#line 3181 "mrbgems/mruby-compiler/core/parse.y" +#line 3182 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 8814 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8815 "mrbgems/mruby-compiler/core/y.tab.c" break; case 404: -#line 3185 "mrbgems/mruby-compiler/core/parse.y" +#line 3186 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num)); call_with_block(p, (yyval.nd), (yyvsp[0].nd)); } -#line 8823 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8824 "mrbgems/mruby-compiler/core/y.tab.c" break; case 405: -#line 3190 "mrbgems/mruby-compiler/core/parse.y" +#line 3191 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num)); call_with_block(p, (yyval.nd), (yyvsp[0].nd)); } -#line 8832 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8833 "mrbgems/mruby-compiler/core/y.tab.c" break; case 406: -#line 3197 "mrbgems/mruby-compiler/core/parse.y" +#line 3198 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 8840 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8841 "mrbgems/mruby-compiler/core/y.tab.c" break; case 407: -#line 3201 "mrbgems/mruby-compiler/core/parse.y" +#line 3202 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 8848 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8849 "mrbgems/mruby-compiler/core/y.tab.c" break; case 408: -#line 3205 "mrbgems/mruby-compiler/core/parse.y" +#line 3206 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2); } -#line 8856 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8857 "mrbgems/mruby-compiler/core/y.tab.c" break; case 409: -#line 3209 "mrbgems/mruby-compiler/core/parse.y" +#line 3210 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2); } -#line 8864 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8865 "mrbgems/mruby-compiler/core/y.tab.c" break; case 410: -#line 3213 "mrbgems/mruby-compiler/core/parse.y" +#line 3214 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), (yyvsp[-1].num)); } -#line 8872 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8873 "mrbgems/mruby-compiler/core/y.tab.c" break; case 411: -#line 3217 "mrbgems/mruby-compiler/core/parse.y" +#line 3218 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), tCOLON2); } -#line 8880 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8881 "mrbgems/mruby-compiler/core/y.tab.c" break; case 412: -#line 3221 "mrbgems/mruby-compiler/core/parse.y" +#line 3222 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_super(p, (yyvsp[0].nd)); } -#line 8888 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8889 "mrbgems/mruby-compiler/core/y.tab.c" break; case 413: -#line 3225 "mrbgems/mruby-compiler/core/parse.y" +#line 3226 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_zsuper(p); } -#line 8896 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8897 "mrbgems/mruby-compiler/core/y.tab.c" break; case 414: -#line 3229 "mrbgems/mruby-compiler/core/parse.y" +#line 3230 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.'); } -#line 8904 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8905 "mrbgems/mruby-compiler/core/y.tab.c" break; case 415: -#line 3235 "mrbgems/mruby-compiler/core/parse.y" +#line 3236 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); (yyval.num) = p->lineno; } -#line 8914 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8915 "mrbgems/mruby-compiler/core/y.tab.c" break; case 416: -#line 3242 "mrbgems/mruby-compiler/core/parse.y" +#line 3243 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-3].num)); local_unnest(p); nvars_unnest(p); } -#line 8925 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8926 "mrbgems/mruby-compiler/core/y.tab.c" break; case 417: -#line 3249 "mrbgems/mruby-compiler/core/parse.y" +#line 3250 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); (yyval.num) = p->lineno; } -#line 8935 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8936 "mrbgems/mruby-compiler/core/y.tab.c" break; case 418: -#line 3256 "mrbgems/mruby-compiler/core/parse.y" +#line 3257 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-3].num)); local_unnest(p); nvars_unnest(p); } -#line 8946 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8947 "mrbgems/mruby-compiler/core/y.tab.c" break; case 419: -#line 3267 "mrbgems/mruby-compiler/core/parse.y" +#line 3268 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd)); } -#line 8954 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8955 "mrbgems/mruby-compiler/core/y.tab.c" break; case 420: -#line 3273 "mrbgems/mruby-compiler/core/parse.y" +#line 3274 "mrbgems/mruby-compiler/core/parse.y" { if ((yyvsp[0].nd)) { (yyval.nd) = cons(cons(0, (yyvsp[0].nd)), 0); @@ -8963,60 +8964,60 @@ yyreduce: (yyval.nd) = 0; } } -#line 8967 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8968 "mrbgems/mruby-compiler/core/y.tab.c" break; case 422: -#line 3287 "mrbgems/mruby-compiler/core/parse.y" +#line 3288 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(list3((yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd))); if ((yyvsp[0].nd)) (yyval.nd) = append((yyval.nd), (yyvsp[0].nd)); } -#line 8976 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8977 "mrbgems/mruby-compiler/core/y.tab.c" break; case 424: -#line 3295 "mrbgems/mruby-compiler/core/parse.y" +#line 3296 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 8984 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8985 "mrbgems/mruby-compiler/core/y.tab.c" break; case 427: -#line 3303 "mrbgems/mruby-compiler/core/parse.y" +#line 3304 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8992 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8993 "mrbgems/mruby-compiler/core/y.tab.c" break; case 429: -#line 3310 "mrbgems/mruby-compiler/core/parse.y" +#line 3311 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 9000 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9001 "mrbgems/mruby-compiler/core/y.tab.c" break; case 436: -#line 3324 "mrbgems/mruby-compiler/core/parse.y" +#line 3325 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = concat_string(p, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9008 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9009 "mrbgems/mruby-compiler/core/y.tab.c" break; case 439: -#line 3332 "mrbgems/mruby-compiler/core/parse.y" +#line 3333 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 9016 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9017 "mrbgems/mruby-compiler/core/y.tab.c" break; case 440: -#line 3336 "mrbgems/mruby-compiler/core/parse.y" +#line 3337 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { @@ -9027,69 +9028,69 @@ yyreduce: } (yyval.nd) = new_dstr(p, n); } -#line 9031 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9032 "mrbgems/mruby-compiler/core/y.tab.c" break; case 442: -#line 3350 "mrbgems/mruby-compiler/core/parse.y" +#line 3351 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9039 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9040 "mrbgems/mruby-compiler/core/y.tab.c" break; case 443: -#line 3356 "mrbgems/mruby-compiler/core/parse.y" +#line 3357 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9047 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9048 "mrbgems/mruby-compiler/core/y.tab.c" break; case 444: -#line 3360 "mrbgems/mruby-compiler/core/parse.y" +#line 3361 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = p->lex_strterm; p->lex_strterm = NULL; } -#line 9056 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9057 "mrbgems/mruby-compiler/core/y.tab.c" break; case 445: -#line 3366 "mrbgems/mruby-compiler/core/parse.y" +#line 3367 "mrbgems/mruby-compiler/core/parse.y" { p->lex_strterm = (yyvsp[-2].nd); (yyval.nd) = list2((yyvsp[-3].nd), (yyvsp[-1].nd)); } -#line 9065 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9066 "mrbgems/mruby-compiler/core/y.tab.c" break; case 446: -#line 3371 "mrbgems/mruby-compiler/core/parse.y" +#line 3372 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(new_literal_delim(p)); } -#line 9073 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9074 "mrbgems/mruby-compiler/core/y.tab.c" break; case 447: -#line 3375 "mrbgems/mruby-compiler/core/parse.y" +#line 3376 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(new_literal_delim(p)); } -#line 9081 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9082 "mrbgems/mruby-compiler/core/y.tab.c" break; case 448: -#line 3381 "mrbgems/mruby-compiler/core/parse.y" +#line 3382 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 9089 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9090 "mrbgems/mruby-compiler/core/y.tab.c" break; case 449: -#line 3385 "mrbgems/mruby-compiler/core/parse.y" +#line 3386 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { @@ -9100,82 +9101,82 @@ yyreduce: } (yyval.nd) = new_dxstr(p, n); } -#line 9104 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9105 "mrbgems/mruby-compiler/core/y.tab.c" break; case 450: -#line 3398 "mrbgems/mruby-compiler/core/parse.y" +#line 3399 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 9112 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9113 "mrbgems/mruby-compiler/core/y.tab.c" break; case 451: -#line 3402 "mrbgems/mruby-compiler/core/parse.y" +#line 3403 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dregx(p, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9120 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9121 "mrbgems/mruby-compiler/core/y.tab.c" break; case 455: -#line 3415 "mrbgems/mruby-compiler/core/parse.y" +#line 3416 "mrbgems/mruby-compiler/core/parse.y" { parser_heredoc_info * inf = parsing_heredoc_inf(p); inf->doc = push(inf->doc, new_str(p, "", 0)); heredoc_end(p); } -#line 9130 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9131 "mrbgems/mruby-compiler/core/y.tab.c" break; case 456: -#line 3421 "mrbgems/mruby-compiler/core/parse.y" +#line 3422 "mrbgems/mruby-compiler/core/parse.y" { heredoc_end(p); } -#line 9138 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9139 "mrbgems/mruby-compiler/core/y.tab.c" break; case 459: -#line 3431 "mrbgems/mruby-compiler/core/parse.y" +#line 3432 "mrbgems/mruby-compiler/core/parse.y" { parser_heredoc_info * inf = parsing_heredoc_inf(p); inf->doc = push(inf->doc, (yyvsp[0].nd)); heredoc_treat_nextline(p); } -#line 9148 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9149 "mrbgems/mruby-compiler/core/y.tab.c" break; case 460: -#line 3437 "mrbgems/mruby-compiler/core/parse.y" +#line 3438 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = p->lex_strterm; p->lex_strterm = NULL; } -#line 9157 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9158 "mrbgems/mruby-compiler/core/y.tab.c" break; case 461: -#line 3443 "mrbgems/mruby-compiler/core/parse.y" +#line 3444 "mrbgems/mruby-compiler/core/parse.y" { parser_heredoc_info * inf = parsing_heredoc_inf(p); p->lex_strterm = (yyvsp[-2].nd); inf->doc = push(push(inf->doc, (yyvsp[-3].nd)), (yyvsp[-1].nd)); } -#line 9167 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9168 "mrbgems/mruby-compiler/core/y.tab.c" break; case 462: -#line 3451 "mrbgems/mruby-compiler/core/parse.y" +#line 3452 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_words(p, list1((yyvsp[0].nd))); } -#line 9175 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9176 "mrbgems/mruby-compiler/core/y.tab.c" break; case 463: -#line 3455 "mrbgems/mruby-compiler/core/parse.y" +#line 3456 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { @@ -9186,20 +9187,20 @@ yyreduce: } (yyval.nd) = new_words(p, n); } -#line 9190 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9191 "mrbgems/mruby-compiler/core/y.tab.c" break; case 464: -#line 3469 "mrbgems/mruby-compiler/core/parse.y" +#line 3470 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_ENDARG; (yyval.nd) = new_sym(p, (yyvsp[0].id)); } -#line 9199 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9200 "mrbgems/mruby-compiler/core/y.tab.c" break; case 465: -#line 3474 "mrbgems/mruby-compiler/core/parse.y" +#line 3475 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); p->lstate = EXPR_ENDARG; @@ -9211,43 +9212,43 @@ yyreduce: } (yyval.nd) = new_dsym(p, new_dstr(p, n)); } -#line 9215 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9216 "mrbgems/mruby-compiler/core/y.tab.c" break; case 466: -#line 3488 "mrbgems/mruby-compiler/core/parse.y" +#line 3489 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = (yyvsp[0].id); } -#line 9223 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9224 "mrbgems/mruby-compiler/core/y.tab.c" break; case 471: -#line 3498 "mrbgems/mruby-compiler/core/parse.y" +#line 3499 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = new_strsym(p, (yyvsp[0].nd)); } -#line 9231 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9232 "mrbgems/mruby-compiler/core/y.tab.c" break; case 472: -#line 3502 "mrbgems/mruby-compiler/core/parse.y" +#line 3503 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = new_strsym(p, (yyvsp[0].nd)); } -#line 9239 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9240 "mrbgems/mruby-compiler/core/y.tab.c" break; case 473: -#line 3508 "mrbgems/mruby-compiler/core/parse.y" +#line 3509 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_symbols(p, list1((yyvsp[0].nd))); } -#line 9247 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9248 "mrbgems/mruby-compiler/core/y.tab.c" break; case 474: -#line 3512 "mrbgems/mruby-compiler/core/parse.y" +#line 3513 "mrbgems/mruby-compiler/core/parse.y" { node *n = (yyvsp[-1].nd); if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { @@ -9255,123 +9256,123 @@ yyreduce: } (yyval.nd) = new_symbols(p, n); } -#line 9259 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9260 "mrbgems/mruby-compiler/core/y.tab.c" break; case 477: -#line 3524 "mrbgems/mruby-compiler/core/parse.y" +#line 3525 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_negate(p, (yyvsp[0].nd)); } -#line 9267 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9268 "mrbgems/mruby-compiler/core/y.tab.c" break; case 478: -#line 3528 "mrbgems/mruby-compiler/core/parse.y" +#line 3529 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_negate(p, (yyvsp[0].nd)); } -#line 9275 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9276 "mrbgems/mruby-compiler/core/y.tab.c" break; case 479: -#line 3534 "mrbgems/mruby-compiler/core/parse.y" +#line 3535 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_lvar(p, (yyvsp[0].id)); } -#line 9283 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9284 "mrbgems/mruby-compiler/core/y.tab.c" break; case 480: -#line 3538 "mrbgems/mruby-compiler/core/parse.y" +#line 3539 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_ivar(p, (yyvsp[0].id)); } -#line 9291 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9292 "mrbgems/mruby-compiler/core/y.tab.c" break; case 481: -#line 3542 "mrbgems/mruby-compiler/core/parse.y" +#line 3543 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_gvar(p, (yyvsp[0].id)); } -#line 9299 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9300 "mrbgems/mruby-compiler/core/y.tab.c" break; case 482: -#line 3546 "mrbgems/mruby-compiler/core/parse.y" +#line 3547 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_cvar(p, (yyvsp[0].id)); } -#line 9307 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9308 "mrbgems/mruby-compiler/core/y.tab.c" break; case 483: -#line 3550 "mrbgems/mruby-compiler/core/parse.y" +#line 3551 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_const(p, (yyvsp[0].id)); } -#line 9315 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9316 "mrbgems/mruby-compiler/core/y.tab.c" break; case 484: -#line 3556 "mrbgems/mruby-compiler/core/parse.y" +#line 3557 "mrbgems/mruby-compiler/core/parse.y" { assignable(p, (yyvsp[0].nd)); } -#line 9323 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9324 "mrbgems/mruby-compiler/core/y.tab.c" break; case 485: -#line 3560 "mrbgems/mruby-compiler/core/parse.y" +#line 3561 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "can't assign to numbered parameter"); } -#line 9331 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9332 "mrbgems/mruby-compiler/core/y.tab.c" break; case 486: -#line 3566 "mrbgems/mruby-compiler/core/parse.y" +#line 3567 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = var_reference(p, (yyvsp[0].nd)); } -#line 9339 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9340 "mrbgems/mruby-compiler/core/y.tab.c" break; case 487: -#line 3570 "mrbgems/mruby-compiler/core/parse.y" +#line 3571 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_nil(p); } -#line 9347 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9348 "mrbgems/mruby-compiler/core/y.tab.c" break; case 488: -#line 3574 "mrbgems/mruby-compiler/core/parse.y" +#line 3575 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_self(p); } -#line 9355 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9356 "mrbgems/mruby-compiler/core/y.tab.c" break; case 489: -#line 3578 "mrbgems/mruby-compiler/core/parse.y" +#line 3579 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_true(p); } -#line 9363 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9364 "mrbgems/mruby-compiler/core/y.tab.c" break; case 490: -#line 3582 "mrbgems/mruby-compiler/core/parse.y" +#line 3583 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_false(p); } -#line 9371 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9372 "mrbgems/mruby-compiler/core/y.tab.c" break; case 491: -#line 3586 "mrbgems/mruby-compiler/core/parse.y" +#line 3587 "mrbgems/mruby-compiler/core/parse.y" { const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL); if (!fn) { @@ -9379,599 +9380,599 @@ yyreduce: } (yyval.nd) = new_str(p, fn, strlen(fn)); } -#line 9383 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9384 "mrbgems/mruby-compiler/core/y.tab.c" break; case 492: -#line 3594 "mrbgems/mruby-compiler/core/parse.y" +#line 3595 "mrbgems/mruby-compiler/core/parse.y" { char buf[16]; dump_int(p->lineno, buf); (yyval.nd) = new_int(p, buf, 10, 0); } -#line 9394 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9395 "mrbgems/mruby-compiler/core/y.tab.c" break; case 493: -#line 3601 "mrbgems/mruby-compiler/core/parse.y" +#line 3602 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, MRB_SYM_2(p->mrb, __ENCODING__), 0); } -#line 9402 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9403 "mrbgems/mruby-compiler/core/y.tab.c" break; case 496: -#line 3611 "mrbgems/mruby-compiler/core/parse.y" +#line 3612 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 9410 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9411 "mrbgems/mruby-compiler/core/y.tab.c" break; case 497: -#line 3615 "mrbgems/mruby-compiler/core/parse.y" +#line 3616 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_BEG; p->cmd_start = TRUE; } -#line 9419 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9420 "mrbgems/mruby-compiler/core/y.tab.c" break; case 498: -#line 3620 "mrbgems/mruby-compiler/core/parse.y" +#line 3621 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 9427 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9428 "mrbgems/mruby-compiler/core/y.tab.c" break; case 501: -#line 3636 "mrbgems/mruby-compiler/core/parse.y" +#line 3637 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); p->lstate = EXPR_BEG; p->cmd_start = TRUE; } -#line 9437 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9438 "mrbgems/mruby-compiler/core/y.tab.c" break; case 502: -#line 3642 "mrbgems/mruby-compiler/core/parse.y" +#line 3643 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_dots(p, (yyvsp[-3].nd)); } -#line 9445 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9446 "mrbgems/mruby-compiler/core/y.tab.c" break; case 503: -#line 3646 "mrbgems/mruby-compiler/core/parse.y" +#line 3647 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_dots(p, 0); } -#line 9453 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9454 "mrbgems/mruby-compiler/core/y.tab.c" break; case 505: -#line 3653 "mrbgems/mruby-compiler/core/parse.y" +#line 3654 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 9461 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9462 "mrbgems/mruby-compiler/core/y.tab.c" break; case 506: -#line 3657 "mrbgems/mruby-compiler/core/parse.y" +#line 3658 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_dots(p, (yyvsp[-3].nd)); } -#line 9469 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9470 "mrbgems/mruby-compiler/core/y.tab.c" break; case 507: -#line 3661 "mrbgems/mruby-compiler/core/parse.y" +#line 3662 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_dots(p, 0); } -#line 9477 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9478 "mrbgems/mruby-compiler/core/y.tab.c" break; case 508: -#line 3667 "mrbgems/mruby-compiler/core/parse.y" +#line 3668 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); } -#line 9485 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9486 "mrbgems/mruby-compiler/core/y.tab.c" break; case 509: -#line 3673 "mrbgems/mruby-compiler/core/parse.y" +#line 3674 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p))); local_unnest(p); } -#line 9495 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9496 "mrbgems/mruby-compiler/core/y.tab.c" break; case 510: -#line 3679 "mrbgems/mruby-compiler/core/parse.y" +#line 3680 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0); local_unnest(p); } -#line 9504 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9505 "mrbgems/mruby-compiler/core/y.tab.c" break; case 511: -#line 3686 "mrbgems/mruby-compiler/core/parse.y" +#line 3687 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p))); local_unnest(p); } -#line 9514 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9515 "mrbgems/mruby-compiler/core/y.tab.c" break; case 512: -#line 3692 "mrbgems/mruby-compiler/core/parse.y" +#line 3693 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0); local_unnest(p); } -#line 9523 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9524 "mrbgems/mruby-compiler/core/y.tab.c" break; case 513: -#line 3699 "mrbgems/mruby-compiler/core/parse.y" +#line 3700 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9531 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9532 "mrbgems/mruby-compiler/core/y.tab.c" break; case 514: -#line 3703 "mrbgems/mruby-compiler/core/parse.y" +#line 3704 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9539 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9540 "mrbgems/mruby-compiler/core/y.tab.c" break; case 515: -#line 3709 "mrbgems/mruby-compiler/core/parse.y" +#line 3710 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9547 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9548 "mrbgems/mruby-compiler/core/y.tab.c" break; case 516: -#line 3713 "mrbgems/mruby-compiler/core/parse.y" +#line 3714 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9555 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9556 "mrbgems/mruby-compiler/core/y.tab.c" break; case 519: -#line 3723 "mrbgems/mruby-compiler/core/parse.y" +#line 3724 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_kw_rest_args(p, nsym((yyvsp[0].id))); } -#line 9563 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9564 "mrbgems/mruby-compiler/core/y.tab.c" break; case 520: -#line 3727 "mrbgems/mruby-compiler/core/parse.y" +#line 3728 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_kw_rest_args(p, 0); } -#line 9571 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9572 "mrbgems/mruby-compiler/core/y.tab.c" break; case 521: -#line 3733 "mrbgems/mruby-compiler/core/parse.y" +#line 3734 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 9579 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9580 "mrbgems/mruby-compiler/core/y.tab.c" break; case 522: -#line 3737 "mrbgems/mruby-compiler/core/parse.y" +#line 3738 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id)); } -#line 9587 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9588 "mrbgems/mruby-compiler/core/y.tab.c" break; case 523: -#line 3741 "mrbgems/mruby-compiler/core/parse.y" +#line 3742 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 9595 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9596 "mrbgems/mruby-compiler/core/y.tab.c" break; case 524: -#line 3745 "mrbgems/mruby-compiler/core/parse.y" +#line 3746 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id)); } -#line 9603 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9604 "mrbgems/mruby-compiler/core/y.tab.c" break; case 525: -#line 3751 "mrbgems/mruby-compiler/core/parse.y" +#line 3752 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 9611 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9612 "mrbgems/mruby-compiler/core/y.tab.c" break; case 526: -#line 3755 "mrbgems/mruby-compiler/core/parse.y" +#line 3756 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, 0, 0); } -#line 9619 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9620 "mrbgems/mruby-compiler/core/y.tab.c" break; case 527: -#line 3761 "mrbgems/mruby-compiler/core/parse.y" +#line 3762 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9627 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9628 "mrbgems/mruby-compiler/core/y.tab.c" break; case 528: -#line 3765 "mrbgems/mruby-compiler/core/parse.y" +#line 3766 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9635 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9636 "mrbgems/mruby-compiler/core/y.tab.c" break; case 529: -#line 3769 "mrbgems/mruby-compiler/core/parse.y" +#line 3770 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 9643 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9644 "mrbgems/mruby-compiler/core/y.tab.c" break; case 530: -#line 3773 "mrbgems/mruby-compiler/core/parse.y" +#line 3774 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9651 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9652 "mrbgems/mruby-compiler/core/y.tab.c" break; case 531: -#line 3777 "mrbgems/mruby-compiler/core/parse.y" +#line 3778 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9659 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9660 "mrbgems/mruby-compiler/core/y.tab.c" break; case 532: -#line 3781 "mrbgems/mruby-compiler/core/parse.y" +#line 3782 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9667 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9668 "mrbgems/mruby-compiler/core/y.tab.c" break; case 533: -#line 3785 "mrbgems/mruby-compiler/core/parse.y" +#line 3786 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 9675 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9676 "mrbgems/mruby-compiler/core/y.tab.c" break; case 534: -#line 3789 "mrbgems/mruby-compiler/core/parse.y" +#line 3790 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9683 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9684 "mrbgems/mruby-compiler/core/y.tab.c" break; case 535: -#line 3793 "mrbgems/mruby-compiler/core/parse.y" +#line 3794 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9691 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9692 "mrbgems/mruby-compiler/core/y.tab.c" break; case 536: -#line 3797 "mrbgems/mruby-compiler/core/parse.y" +#line 3798 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 9699 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9700 "mrbgems/mruby-compiler/core/y.tab.c" break; case 537: -#line 3801 "mrbgems/mruby-compiler/core/parse.y" +#line 3802 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9707 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9708 "mrbgems/mruby-compiler/core/y.tab.c" break; case 538: -#line 3805 "mrbgems/mruby-compiler/core/parse.y" +#line 3806 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9715 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9716 "mrbgems/mruby-compiler/core/y.tab.c" break; case 539: -#line 3809 "mrbgems/mruby-compiler/core/parse.y" +#line 3810 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9723 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9724 "mrbgems/mruby-compiler/core/y.tab.c" break; case 540: -#line 3813 "mrbgems/mruby-compiler/core/parse.y" +#line 3814 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd)); } -#line 9731 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9732 "mrbgems/mruby-compiler/core/y.tab.c" break; case 541: -#line 3817 "mrbgems/mruby-compiler/core/parse.y" +#line 3818 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, intern_op(and)); (yyval.nd) = new_args(p, 0, 0, 0, 0, 0); } -#line 9740 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9741 "mrbgems/mruby-compiler/core/y.tab.c" break; case 542: -#line 3824 "mrbgems/mruby-compiler/core/parse.y" +#line 3825 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a constant"); (yyval.nd) = 0; } -#line 9749 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9750 "mrbgems/mruby-compiler/core/y.tab.c" break; case 543: -#line 3829 "mrbgems/mruby-compiler/core/parse.y" +#line 3830 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be an instance variable"); (yyval.nd) = 0; } -#line 9758 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9759 "mrbgems/mruby-compiler/core/y.tab.c" break; case 544: -#line 3834 "mrbgems/mruby-compiler/core/parse.y" +#line 3835 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a global variable"); (yyval.nd) = 0; } -#line 9767 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9768 "mrbgems/mruby-compiler/core/y.tab.c" break; case 545: -#line 3839 "mrbgems/mruby-compiler/core/parse.y" +#line 3840 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a class variable"); (yyval.nd) = 0; } -#line 9776 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9777 "mrbgems/mruby-compiler/core/y.tab.c" break; case 546: -#line 3844 "mrbgems/mruby-compiler/core/parse.y" +#line 3845 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a numbered parameter"); (yyval.nd) = 0; } -#line 9785 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9786 "mrbgems/mruby-compiler/core/y.tab.c" break; case 547: -#line 3851 "mrbgems/mruby-compiler/core/parse.y" +#line 3852 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = 0; } -#line 9793 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9794 "mrbgems/mruby-compiler/core/y.tab.c" break; case 548: -#line 3855 "mrbgems/mruby-compiler/core/parse.y" +#line 3856 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); (yyval.id) = (yyvsp[0].id); } -#line 9802 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9803 "mrbgems/mruby-compiler/core/y.tab.c" break; case 549: -#line 3862 "mrbgems/mruby-compiler/core/parse.y" +#line 3863 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_arg(p, (yyvsp[0].id)); } -#line 9810 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9811 "mrbgems/mruby-compiler/core/y.tab.c" break; case 550: -#line 3866 "mrbgems/mruby-compiler/core/parse.y" +#line 3867 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = local_switch(p); } -#line 9818 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9819 "mrbgems/mruby-compiler/core/y.tab.c" break; case 551: -#line 3870 "mrbgems/mruby-compiler/core/parse.y" +#line 3871 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn_param(p, (yyvsp[-1].nd), p->locals->car); local_resume(p, (yyvsp[-2].nd)); local_add_f(p, 0); } -#line 9828 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9829 "mrbgems/mruby-compiler/core/y.tab.c" break; case 552: -#line 3878 "mrbgems/mruby-compiler/core/parse.y" +#line 3879 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9836 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9837 "mrbgems/mruby-compiler/core/y.tab.c" break; case 553: -#line 3882 "mrbgems/mruby-compiler/core/parse.y" +#line 3883 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9844 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9845 "mrbgems/mruby-compiler/core/y.tab.c" break; case 554: -#line 3888 "mrbgems/mruby-compiler/core/parse.y" +#line 3889 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[-1].id)); local_nest(p); (yyval.id) = (yyvsp[-1].id); } -#line 9854 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9855 "mrbgems/mruby-compiler/core/y.tab.c" break; case 555: -#line 3896 "mrbgems/mruby-compiler/core/parse.y" +#line 3897 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p))); local_unnest(p); } -#line 9864 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9865 "mrbgems/mruby-compiler/core/y.tab.c" break; case 556: -#line 3904 "mrbgems/mruby-compiler/core/parse.y" +#line 3905 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p))); local_unnest(p); } -#line 9874 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9875 "mrbgems/mruby-compiler/core/y.tab.c" break; case 557: -#line 3912 "mrbgems/mruby-compiler/core/parse.y" +#line 3913 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9882 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9883 "mrbgems/mruby-compiler/core/y.tab.c" break; case 558: -#line 3916 "mrbgems/mruby-compiler/core/parse.y" +#line 3917 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9890 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9891 "mrbgems/mruby-compiler/core/y.tab.c" break; case 559: -#line 3922 "mrbgems/mruby-compiler/core/parse.y" +#line 3923 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9898 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9899 "mrbgems/mruby-compiler/core/y.tab.c" break; case 560: -#line 3926 "mrbgems/mruby-compiler/core/parse.y" +#line 3927 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9906 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9907 "mrbgems/mruby-compiler/core/y.tab.c" break; case 563: -#line 3936 "mrbgems/mruby-compiler/core/parse.y" +#line 3937 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); (yyval.id) = (yyvsp[0].id); } -#line 9915 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9916 "mrbgems/mruby-compiler/core/y.tab.c" break; case 564: -#line 3941 "mrbgems/mruby-compiler/core/parse.y" +#line 3942 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(mul); local_add_f(p, (yyval.id)); } -#line 9924 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9925 "mrbgems/mruby-compiler/core/y.tab.c" break; case 567: -#line 3952 "mrbgems/mruby-compiler/core/parse.y" +#line 3953 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = (yyvsp[0].id); } -#line 9932 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9933 "mrbgems/mruby-compiler/core/y.tab.c" break; case 568: -#line 3956 "mrbgems/mruby-compiler/core/parse.y" +#line 3957 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(and); } -#line 9940 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9941 "mrbgems/mruby-compiler/core/y.tab.c" break; case 569: -#line 3962 "mrbgems/mruby-compiler/core/parse.y" +#line 3963 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = (yyvsp[0].id); } -#line 9948 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9949 "mrbgems/mruby-compiler/core/y.tab.c" break; case 570: -#line 3966 "mrbgems/mruby-compiler/core/parse.y" +#line 3967 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = 0; } -#line 9956 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9957 "mrbgems/mruby-compiler/core/y.tab.c" break; case 571: -#line 3972 "mrbgems/mruby-compiler/core/parse.y" +#line 3973 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); if (!(yyval.nd)) (yyval.nd) = new_nil(p); } -#line 9965 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9966 "mrbgems/mruby-compiler/core/y.tab.c" break; case 572: -#line 3976 "mrbgems/mruby-compiler/core/parse.y" +#line 3977 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_BEG;} -#line 9971 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9972 "mrbgems/mruby-compiler/core/y.tab.c" break; case 573: -#line 3977 "mrbgems/mruby-compiler/core/parse.y" +#line 3978 "mrbgems/mruby-compiler/core/parse.y" { if ((yyvsp[-1].nd) == 0) { yyerror(p, "can't define singleton method for ()."); @@ -9994,63 +9995,63 @@ yyreduce: } (yyval.nd) = (yyvsp[-1].nd); } -#line 9998 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9999 "mrbgems/mruby-compiler/core/y.tab.c" break; case 575: -#line 4003 "mrbgems/mruby-compiler/core/parse.y" +#line 4004 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 10006 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10007 "mrbgems/mruby-compiler/core/y.tab.c" break; case 576: -#line 4009 "mrbgems/mruby-compiler/core/parse.y" +#line 4010 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 10015 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10016 "mrbgems/mruby-compiler/core/y.tab.c" break; case 577: -#line 4014 "mrbgems/mruby-compiler/core/parse.y" +#line 4015 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 10023 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10024 "mrbgems/mruby-compiler/core/y.tab.c" break; case 578: -#line 4020 "mrbgems/mruby-compiler/core/parse.y" +#line 4021 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[-2].nd)); void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 10033 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10034 "mrbgems/mruby-compiler/core/y.tab.c" break; case 579: -#line 4026 "mrbgems/mruby-compiler/core/parse.y" +#line 4027 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons(new_sym(p, (yyvsp[-2].id)), (yyvsp[0].nd)); } -#line 10042 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10043 "mrbgems/mruby-compiler/core/y.tab.c" break; case 580: -#line 4031 "mrbgems/mruby-compiler/core/parse.y" +#line 4032 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(new_sym(p, (yyvsp[-1].id)), label_reference(p, (yyvsp[-1].id))); } -#line 10050 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10051 "mrbgems/mruby-compiler/core/y.tab.c" break; case 581: -#line 4035 "mrbgems/mruby-compiler/core/parse.y" +#line 4036 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); if (typen((yyvsp[-2].nd)->car) == NODE_DSTR) { @@ -10060,67 +10061,67 @@ yyreduce: (yyval.nd) = cons(new_sym(p, new_strsym(p, (yyvsp[-2].nd))), (yyvsp[0].nd)); } } -#line 10064 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10065 "mrbgems/mruby-compiler/core/y.tab.c" break; case 582: -#line 4045 "mrbgems/mruby-compiler/core/parse.y" +#line 4046 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = cons(new_kw_rest_args(p, 0), (yyvsp[0].nd)); } -#line 10073 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10074 "mrbgems/mruby-compiler/core/y.tab.c" break; case 595: -#line 4072 "mrbgems/mruby-compiler/core/parse.y" +#line 4073 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = '.'; } -#line 10081 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10082 "mrbgems/mruby-compiler/core/y.tab.c" break; case 596: -#line 4076 "mrbgems/mruby-compiler/core/parse.y" +#line 4077 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = 0; } -#line 10089 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10090 "mrbgems/mruby-compiler/core/y.tab.c" break; case 598: -#line 4083 "mrbgems/mruby-compiler/core/parse.y" +#line 4084 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = tCOLON2; } -#line 10097 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10098 "mrbgems/mruby-compiler/core/y.tab.c" break; case 607: -#line 4104 "mrbgems/mruby-compiler/core/parse.y" +#line 4105 "mrbgems/mruby-compiler/core/parse.y" {yyerrok;} -#line 10103 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10104 "mrbgems/mruby-compiler/core/y.tab.c" break; case 609: -#line 4109 "mrbgems/mruby-compiler/core/parse.y" +#line 4110 "mrbgems/mruby-compiler/core/parse.y" { p->lineno += (yyvsp[0].num); p->column = 0; } -#line 10112 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10113 "mrbgems/mruby-compiler/core/y.tab.c" break; case 613: -#line 4121 "mrbgems/mruby-compiler/core/parse.y" +#line 4122 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 10120 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10121 "mrbgems/mruby-compiler/core/y.tab.c" break; -#line 10124 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10125 "mrbgems/mruby-compiler/core/y.tab.c" default: break; } @@ -10352,7 +10353,7 @@ yyreturn: #endif return yyresult; } -#line 4125 "mrbgems/mruby-compiler/core/parse.y" +#line 4126 "mrbgems/mruby-compiler/core/parse.y" #define pylval (*((YYSTYPE*)(p->ylval))) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index 806e9f085..f31b37608 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -6,9 +6,10 @@ #include "mruby/numeric.h" #include "mruby/string.h" #include "mruby/variable.h" +#include "mruby/internal.h" +#include #include #include -#include static const struct { #ifdef MRB_NO_PRESYM diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 765dc9051..209a37f31 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -11,6 +11,7 @@ #include "mruby/variable.h" #include "mruby/ext/io.h" #include "mruby/error.h" +#include "mruby/internal.h" #include "mruby/presym.h" #include diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index 976615f6e..94afb2a9c 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -6,6 +6,7 @@ #include #include #include +#include #include static mrb_value diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c index d679f7f2e..70da56c47 100644 --- a/mrbgems/mruby-metaprog/src/metaprog.c +++ b/mrbgems/mruby-metaprog/src/metaprog.c @@ -5,6 +5,7 @@ #include "mruby/proc.h" #include "mruby/class.h" #include "mruby/string.h" +#include #include "mruby/presym.h" typedef enum { diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c index 85e8872e2..093d4c5a0 100644 --- a/mrbgems/mruby-method/src/method.c +++ b/mrbgems/mruby-method/src/method.c @@ -4,6 +4,7 @@ #include "mruby/variable.h" #include "mruby/proc.h" #include "mruby/string.h" +#include "mruby/internal.h" #include "mruby/presym.h" mrb_noreturn void mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args); diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c index b6a25a204..d4ade914f 100644 --- a/mrbgems/mruby-os-memsize/src/memsize.c +++ b/mrbgems/mruby-os-memsize/src/memsize.c @@ -10,6 +10,7 @@ #include #include #include +#include static size_t os_memsize_of_irep(mrb_state* state, const struct mrb_irep *irep) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index a79e33652..a9ce33d2e 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -38,6 +38,7 @@ #include "mruby/string.h" #include "mruby/variable.h" #include "mruby/error.h" +#include "mruby/internal.h" #include "mruby/presym.h" #include "mruby/ext/io.h" diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c index 8360a051c..30ca5ab8d 100644 --- a/mrbgems/mruby-string-ext/src/string.c +++ b/mrbgems/mruby-string-ext/src/string.c @@ -4,6 +4,7 @@ #include #include #include +#include #define ENC_ASCII_8BIT "ASCII-8BIT" #define ENC_BINARY "BINARY" diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index 2d864bdaf..393e6719c 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #define RSTRUCT_LEN(st) RARRAY_LEN(st) diff --git a/mrbgems/mruby-symbol-ext/src/symbol.c b/mrbgems/mruby-symbol-ext/src/symbol.c index 460d2531d..4340d74a3 100644 --- a/mrbgems/mruby-symbol-ext/src/symbol.c +++ b/mrbgems/mruby-symbol-ext/src/symbol.c @@ -1,6 +1,7 @@ #include #include #include +#include #ifdef MRB_USE_ALL_SYMBOLS # include #endif diff --git a/src/array.c b/src/array.c index 484723e8e..29ac2f8b3 100644 --- a/src/array.c +++ b/src/array.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #include "value_array.h" diff --git a/src/backtrace.c b/src/backtrace.c index d6648cc43..3bfa46ee9 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -14,6 +14,7 @@ #include #include #include +#include #include struct backtrace_location { @@ -26,8 +27,7 @@ typedef void (*each_backtrace_func)(mrb_state*, const struct backtrace_location* static const mrb_data_type bt_type = { "Backtrace", mrb_free }; -mrb_value mrb_exc_inspect(mrb_state *mrb, mrb_value exc); -mrb_value mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace); +static mrb_value mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace); static void each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, each_backtrace_func func, void *data) @@ -204,7 +204,7 @@ mrb_keep_backtrace(mrb_state *mrb, mrb_value exc) mrb_gc_arena_restore(mrb, ai); } -mrb_value +static mrb_value mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace) { const struct backtrace_location *bt; diff --git a/src/cdump.c b/src/cdump.c index 12173583d..1c1d6c1ca 100644 --- a/src/cdump.c +++ b/src/cdump.c @@ -9,6 +9,7 @@ #include #include #include +#include #include diff --git a/src/class.c b/src/class.c index 09ce57832..37fc4e68a 100644 --- a/src/class.c +++ b/src/class.c @@ -16,6 +16,7 @@ #include #include #include +#include #include union mt_ptr { @@ -877,8 +878,6 @@ mrb_get_arg1(mrb_state *mrb) return array_argv[0]; } -mrb_int mrb_ci_bidx(mrb_callinfo *ci); - MRB_API mrb_bool mrb_block_given_p(mrb_state *mrb) { @@ -2306,8 +2305,6 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass) } } -void mrb_method_added(mrb_state *mrb, struct RClass *c, mrb_sym mid); - static mrb_value mrb_mod_alias(mrb_state *mrb, mrb_value mod) { diff --git a/src/codedump.c b/src/codedump.c index 7c71fb400..074eb0622 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -5,6 +5,7 @@ #include #include #include +#include #ifndef MRB_NO_STDIO static void diff --git a/src/error.c b/src/error.c index acad904e3..2c2f709b1 100644 --- a/src/error.c +++ b/src/error.c @@ -15,6 +15,7 @@ #include #include #include +#include #include void diff --git a/src/gc.c b/src/gc.c index b0885a307..cda8b544c 100644 --- a/src/gc.c +++ b/src/gc.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #ifdef MRB_GC_STRESS diff --git a/src/hash.c b/src/hash.c index fc6b6fa6b..a0491de27 100644 --- a/src/hash.c +++ b/src/hash.c @@ -11,6 +11,7 @@ #include #include #include +#include #include /* diff --git a/src/kernel.c b/src/kernel.c index 18640ab5c..9514c07bd 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -13,6 +13,7 @@ #include #include #include +#include #include MRB_API mrb_bool diff --git a/src/load.c b/src/load.c index d8e2b22ac..4ed270569 100644 --- a/src/load.c +++ b/src/load.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #if SIZE_MAX < UINT32_MAX diff --git a/src/numeric.c b/src/numeric.c index 681088d31..e173f658a 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include @@ -20,20 +21,6 @@ #endif #endif -#ifdef MRB_USE_COMPLEX -mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); -mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_complex_div(mrb_state *mrb, mrb_value x, mrb_value y); -#endif - -mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y); -mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y); - void mrb_int_overflow(mrb_state *mrb, const char *reason) { diff --git a/src/numops.c b/src/numops.c index f98aa418c..6bfe508e2 100644 --- a/src/numops.c +++ b/src/numops.c @@ -6,24 +6,9 @@ #include #include +#include #include -mrb_value mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y); - -#ifdef MRB_USE_COMPLEX -mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); -mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y); -#endif - -mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y); -mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y); - MRB_API mrb_value mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y) { diff --git a/src/proc.c b/src/proc.c index 769323950..100e04150 100644 --- a/src/proc.c +++ b/src/proc.c @@ -9,9 +9,10 @@ #include #include #include -#include #include #include +#include +#include static const mrb_code call_iseq[] = { OP_CALL, diff --git a/src/state.c b/src/state.c index 4045a0fed..4632e81d7 100644 --- a/src/state.c +++ b/src/state.c @@ -12,6 +12,7 @@ #include #include #include +#include void mrb_init_core(mrb_state*); void mrb_init_mrbgems(mrb_state*); diff --git a/src/string.c b/src/string.c index 111eefb76..0273f74e3 100644 --- a/src/string.c +++ b/src/string.c @@ -14,6 +14,7 @@ #include #include #include +#include #include #include diff --git a/src/symbol.c b/src/symbol.c index c371752c9..db7047ac6 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #ifndef MRB_NO_PRESYM @@ -134,10 +135,6 @@ symhash(const char *key, size_t len) return hash & 0xff; } -size_t mrb_packed_int_len(uint32_t num); -size_t mrb_packed_int_encode(uint32_t num, uint8_t *p, uint8_t *pend); -uint32_t mrb_packed_int_decode(const uint8_t *p, const uint8_t **newpos); - #define sym_lit_p(mrb, i) (mrb->symflags[i>>3]&(1<<(i&7))) #define sym_lit_set(mrb, i) mrb->symflags[i>>3]|=(1<<(i&7)) #define sym_flags_clear(mrb, i) mrb->symflags[i>>3]&=~(1<<(i&7)) diff --git a/src/variable.c b/src/variable.c index 53b760d0f..a07412684 100644 --- a/src/variable.c +++ b/src/variable.c @@ -10,6 +10,7 @@ #include #include #include +#include #include /* Instance variable table structure */ diff --git a/src/vm.c b/src/vm.c index 3bb9510ec..3796f4173 100644 --- a/src/vm.c +++ b/src/vm.c @@ -19,6 +19,7 @@ #include "value_array.h" #include #include +#include #include #ifdef MRB_NO_STDIO @@ -1163,9 +1164,6 @@ hash_new_from_values(mrb_state *mrb, mrb_int argc, mrb_value *regs) return hash; } -void mrb_method_added(mrb_state *mrb, struct RClass *c, mrb_sym mid); -mrb_value mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value idx, mrb_value len); - #define ARGUMENT_NORMALIZE(arg_base, arg_info, insn) do { \ int n = *(arg_info)&0xf; \ int nk = (*(arg_info)>>4)&0xf; \ From 3dabd18dccac70ce39f9681cb473e89c468fefbe Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 2 Apr 2022 18:24:20 +0900 Subject: [PATCH 188/292] errno.c: resolve signedness warning. --- mrbgems/mruby-errno/src/errno.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index f31b37608..d8af9a178 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -45,7 +45,7 @@ mrb_sce_init(mrb_state *mrb, mrb_value self, mrb_value m, mrb_int n) m_errno = mrb_module_get_id(mrb, MRB_SYM(Errno)); if (!no_errno) { - int i; + size_t i; for (i=0; i < E2C_LEN; i++) { if (e2c[i].eno == n) { From 8aec568fc50c23f4062153fbc75b423ba22219e9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 3 Apr 2022 18:39:40 +0900 Subject: [PATCH 189/292] range.c: detect integer overflow. --- src/range.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/range.c b/src/range.c index 7507173b6..34ae7e451 100644 --- a/src/range.c +++ b/src/range.c @@ -362,9 +362,13 @@ range_num_to_a(mrb_state *mrb, mrb_value range) mrb_int len; if (mrb_int_sub_overflow(b, a, &len)) { + too_long: mrb_raise(mrb, E_RANGE_ERROR, "integer range too long"); } - if (!RANGE_EXCL(r)) len++; + if (!RANGE_EXCL(r)) { + if (len == MRB_INT_MAX) goto too_long; + len++; + } ary = mrb_ary_new_capa(mrb, len); for (mrb_int i=0; i Date: Sun, 3 Apr 2022 22:14:42 +0900 Subject: [PATCH 190/292] Fixed bounds check for `heap_p()` function in `src/gc.c` One extra element was included. --- src/gc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gc.c b/src/gc.c index cda8b544c..c978b6131 100644 --- a/src/gc.c +++ b/src/gc.c @@ -307,7 +307,7 @@ heap_p(mrb_gc *gc, struct RBasic *object) RVALUE *p; p = objects(page); - if (&p[0].as.basic <= object && object <= &p[MRB_HEAP_PAGE_SIZE].as.basic) { + if (&p[0].as.basic <= object && object <= &p[MRB_HEAP_PAGE_SIZE - 1].as.basic) { return TRUE; } page = page->next; From 3cf291f72224715942beaf8553e42ba8891ab3c6 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 4 Apr 2022 12:26:52 +0900 Subject: [PATCH 191/292] vm.c: create break object before clearing GC arena. Otherwise it possibly cause use-after-free. --- src/vm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/vm.c b/src/vm.c index 3796f4173..6d61386b3 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2268,9 +2268,9 @@ RETRY_TRY_BLOCK: } if (ci->cci > CINFO_NONE) { ci = cipop(mrb); + mrb->exc = (struct RObject*)break_new(mrb, RBREAK_TAG_BREAK, proc, v); mrb_gc_arena_restore(mrb, ai); mrb->c->vmexec = FALSE; - mrb->exc = (struct RObject*)break_new(mrb, RBREAK_TAG_BREAK, proc, v); mrb->jmp = prev_jmp; MRB_THROW(prev_jmp); } From 70aded64f7308fa847a77501701bdada2c11412b Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 4 Apr 2022 14:08:43 +0000 Subject: [PATCH 192/292] build(deps): bump github/super-linter from 4.9.1 to 4.9.2 Bumps [github/super-linter](https://github.com/github/super-linter) from 4.9.1 to 4.9.2. - [Release notes](https://github.com/github/super-linter/releases) - [Changelog](https://github.com/github/super-linter/blob/main/docs/release-process.md) - [Commits](https://github.com/github/super-linter/compare/v4.9.1...v4.9.2) --- updated-dependencies: - dependency-name: github/super-linter dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- .github/workflows/super-linter.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/super-linter.yml b/.github/workflows/super-linter.yml index 94e919e16..c5c5e01af 100644 --- a/.github/workflows/super-linter.yml +++ b/.github/workflows/super-linter.yml @@ -13,7 +13,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - uses: github/super-linter@v4.9.1 + - uses: github/super-linter@v4.9.2 env: ERROR_ON_MISSING_EXEC_BIT: true VALIDATE_BASH: true From b4c70fbe51a9f5c953012834dbae6edcf136ec54 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Tue, 5 Apr 2022 00:18:29 +1000 Subject: [PATCH 193/292] Run Super-Linter only once --- .github/workflows/super-linter.yml | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/.github/workflows/super-linter.yml b/.github/workflows/super-linter.yml index 94e919e16..9a93c7997 100644 --- a/.github/workflows/super-linter.yml +++ b/.github/workflows/super-linter.yml @@ -1,11 +1,6 @@ name: Super Linter -on: - push: - branches-ignore: [master] - # Remove the line above to run when pushing to master - pull_request: - branches: [master] +on: [pull_request] jobs: build: From 5bef8e41350398c1edda77d5b84e7669297afebe Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 5 Apr 2022 19:05:38 +0900 Subject: [PATCH 194/292] numeric.c: the result of `-5.div(2)` should be `-3` as CRuby does. --- src/numeric.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/numeric.c b/src/numeric.c index e173f658a..7962fe0ae 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -166,10 +166,7 @@ int_idiv(mrb_state *mrb, mrb_value x) mrb_int y; mrb_get_args(mrb, "i", &y); - if (y == 0) { - mrb_int_zerodiv(mrb); - } - return mrb_int_value(mrb, mrb_integer(x) / y); + return mrb_int_value(mrb, mrb_div_int(mrb, mrb_integer(x), y)); } static mrb_value From 5a27b69aa63ee3806a4e10fd0b34da6014e1005c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 6 Apr 2022 13:31:29 +0900 Subject: [PATCH 195/292] numeric.c: remove duplicated code in `int_divmod`. --- src/numeric.c | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/src/numeric.c b/src/numeric.c index 7962fe0ae..781a06b4b 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1136,6 +1136,10 @@ int_mod(mrb_state *mrb, mrb_value x) #endif } +#ifndef MRB_NO_FLOAT +static mrb_value flo_divmod(mrb_state *mrb, mrb_value x); +#endif + /* * call-seq: * int.divmod(numeric) -> array @@ -1156,15 +1160,7 @@ int_divmod(mrb_state *mrb, mrb_value x) #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer divmod"); #else - else { - mrb_float div, mod; - mrb_value a, b; - - flodivmod(mrb, (mrb_float)mrb_integer(x), mrb_as_float(mrb, y), &div, &mod); - a = mrb_int_value(mrb, (mrb_int)div); - b = mrb_float_value(mrb, mod); - return mrb_assoc_new(mrb, a, b); - } + return flo_divmod(mrb, x); #endif } From e3c20b7319e4943e298ede2232a18b0032c9a467 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 6 Apr 2022 22:49:04 +0900 Subject: [PATCH 196/292] build_config: use full-core gembox on host configuration (except default) --- build_config/boxing.rb | 2 +- build_config/host-f32.rb | 2 +- build_config/host-gprof.rb | 2 +- build_config/host-m32.rb | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/build_config/boxing.rb b/build_config/boxing.rb index d861bd537..8a31ab454 100644 --- a/build_config/boxing.rb +++ b/build_config/boxing.rb @@ -5,7 +5,7 @@ ints = [64, 32] boxings.product(bits, ints) do |boxing, bit, int| MRuby::Build.new("boxing-#{boxing}-m#{bit}-i#{int}") do |conf| conf.toolchain :gcc - conf.gembox 'default' + conf.gembox 'full-core' conf.compilers.each do |c| c.defines << "MRB_#{boxing.upcase}_BOXING" c.defines << "MRB_INT#{int}" diff --git a/build_config/host-f32.rb b/build_config/host-f32.rb index a449547ae..ef15231a0 100644 --- a/build_config/host-f32.rb +++ b/build_config/host-f32.rb @@ -3,7 +3,7 @@ MRuby::Build.new do |conf| toolchain :gcc # include the GEM box - conf.gembox 'default' + conf.gembox 'full-core' conf.cc.defines << 'MRB_USE_FLOAT32' diff --git a/build_config/host-gprof.rb b/build_config/host-gprof.rb index 2bdf5bebd..aab119b3e 100644 --- a/build_config/host-gprof.rb +++ b/build_config/host-gprof.rb @@ -3,7 +3,7 @@ MRuby::Build.new do |conf| toolchain :gcc # include the GEM box - conf.gembox 'default' + conf.gembox 'full-core' conf.cc.flags << '-pg' conf.linker.flags << '-pg' diff --git a/build_config/host-m32.rb b/build_config/host-m32.rb index 9e27a0792..5d67ccd62 100644 --- a/build_config/host-m32.rb +++ b/build_config/host-m32.rb @@ -3,7 +3,7 @@ MRuby::Build.new do |conf| toolchain :gcc # include the GEM box - conf.gembox 'default' + conf.gembox 'full-core' conf.cc.flags << '-m32' conf.linker.flags << '-m32' From dcaf4083d55b270b2850e1ec3f8ae89ad01265f2 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 7 Apr 2022 16:45:21 +0900 Subject: [PATCH 197/292] src/bigint.c: implement multi-precision integer. To enable multi-precision integer support, you need to link `mruby-bigint` mrbgem. The gem itself is empty but it turns on the "bigint" support. --- include/mruby/bigint.h | 117 ++ include/mruby/internal.h | 34 + include/mruby/value.h | 6 +- mrbgems/mruby-bigint/README-fgmp.md | 154 ++ mrbgems/mruby-bigint/README.md | 9 + mrbgems/mruby-bigint/mrbgem.rake | 6 + mrbgems/mruby-numeric-ext/src/numeric_ext.c | 79 +- mrbgems/mruby-os-memsize/src/memsize.c | 17 +- src/array.c | 2 +- src/bigint.c | 1410 +++++++++++++++++++ src/gc.c | 7 + src/load.c | 2 +- src/numeric.c | 179 ++- src/numops.c | 15 + src/object.c | 6 + src/string.c | 37 +- src/vm.c | 26 +- 17 files changed, 2065 insertions(+), 41 deletions(-) create mode 100644 include/mruby/bigint.h create mode 100644 mrbgems/mruby-bigint/README-fgmp.md create mode 100644 mrbgems/mruby-bigint/README.md create mode 100644 mrbgems/mruby-bigint/mrbgem.rake create mode 100644 src/bigint.c diff --git a/include/mruby/bigint.h b/include/mruby/bigint.h new file mode 100644 index 000000000..142a11d30 --- /dev/null +++ b/include/mruby/bigint.h @@ -0,0 +1,117 @@ +/** +** @file mruby/bigint.h - Multi-precision, Integer +** +** See Copyright Notice in mruby.h +*/ +#ifdef MRB_USE_BIGINT + +#ifndef MRUBY_BIGINT_H +#define MRUBY_BIGINT_H +/* + * FREE GMP - a public domain implementation of a subset of the + * gmp library + * + * I hearby place the file in the public domain. + * + * Do whatever you want with this code. Change it. Sell it. Claim you + * wrote it. + * Bugs, complaints, flames, rants: please send email to + * Mark Henderson + * I'm already aware that fgmp is considerably slower than gmp + * + * CREDITS: + * Paul Rouse - generic bug fixes, mpz_sqrt and + * mpz_sqrtrem, and modifications to get fgmp to compile on a system + * with int and long of different sizes (specifically MS-DOS,286 compiler) + * Also see the file "notes" included with the fgmp distribution, for + * more credits. + * + * VERSION 1.0 - beta 5 + */ + +#include + +#ifdef MRB_32BIT +/* + * The values below are for 32 bit machines (i.e. machines with a + * 32 bit long type) + * You'll need to change them, if you're using something else + * If DIGITBITS is odd, see the comment at the top of mpz_sqrtrem + */ +typedef int32_t mp_limb; +#define LMAX 0x3fffffffL +#define LC 0xc0000000L +#define OVMASK 0x2 +#define CMASK (LMAX+1) +#define HLMAX 0x7fffL +#define HCMASK (HLMAX + 1) +#define HIGH(x) (((x) & 0x3fff8000L) >> 15) +#define LOW(x) ((x) & 0x7fffL) + +#else +/* 64 bit long type */ +typedef int64_t mp_limb; +#define LMAX 0x3fffffffffffffffL +#define LC 0xc000000000000000L +#define OVMASK 0x2 +#define CMASK (LMAX+1) +#define HLMAX 0x7fffffffL +#define HCMASK (HLMAX + 1) +#define HIGH(x) (((x) & 0x3fffffff80000000L) >> 31) +#define LOW(x) ((x) & 0x7fffffffL) +#endif + +typedef struct _mpz_t { + mp_limb *p; + short sn; + size_t sz; +} mpz_t; + +struct RBigint { + MRB_OBJECT_HEADER; + mpz_t mp; +}; +#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v)) + +#define iabs(x) ((x>0) ? (x) : (-x)) +#define imax(x,y) ((x>y)?x:y) +#define LONGBITS (sizeof(mp_limb)*8) +#define DIGITBITS (LONGBITS-2) +#define HALFDIGITBITS ((LONGBITS-2)/2) + +#define hd(x,i) (((size_t)(i)>=2*((x)->sz))? 0:(((i)%2) ? HIGH((x)->p[(i)/2]) \ + : LOW((x)->p[(i)/2]))) +#define dg(x,i) (((size_t)(i) < (x)->sz) ? ((x)->p)[i] : 0) + +#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v)) + +mrb_value mrb_bint_new_int(mrb_state *mrb, mrb_int x); +mrb_value mrb_bint_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_mul(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_div(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_divmod(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_add_ii(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_bint_sub_ii(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_bint_mul_ii(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_bint_div_ii(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_bint_mod(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_rem(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_pow(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_powm(mrb_state *mrb, mrb_value x, mrb_int y, mrb_value z); +mrb_value mrb_bint_and(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_or(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_xor(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_rev(mrb_state *mrb, mrb_value x); +mrb_value mrb_bint_lshift(mrb_state *mrb, mrb_value x, mrb_int width); +mrb_value mrb_bint_rshift(mrb_state *mrb, mrb_value x, mrb_int width); +mrb_value mrb_bint_to_s(mrb_state *mrb, mrb_value x, mrb_int base); +#ifndef MRB_NO_FLOAT +mrb_float mrb_bint_as_float(mrb_state *mrb, mrb_value x); +#endif +mrb_int mrb_bint_as_int(mrb_state *mrb, mrb_value x); +mrb_int mrb_bint_cmp(mrb_state *mrb, mrb_value x, mrb_value y); +void mrb_gc_free_bint(mrb_state *mrb, struct RBasic *x); +#endif + +#endif /* MRB_USE_BIGINT */ diff --git a/include/mruby/internal.h b/include/mruby/internal.h index b86931ad9..9ce87c8aa 100644 --- a/include/mruby/internal.h +++ b/include/mruby/internal.h @@ -83,6 +83,8 @@ mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y); mrb_value mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y); mrb_value mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y); +void mrb_int_zerodiv(mrb_state *mrb); +void mrb_int_overflow(mrb_state *mrb, const char *reason); #ifdef MRB_USE_COMPLEX mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y); @@ -154,4 +156,36 @@ void mrb_gc_free_iv(mrb_state*, struct RObject*); /* VM */ mrb_int mrb_ci_bidx(mrb_callinfo *ci); +#ifdef MRB_USE_BIGINT +mrb_value mrb_bint_new_int(mrb_state *mrb, mrb_int x); +mrb_value mrb_bint_new_str(mrb_state *mrb, const char *x, mrb_int len, mrb_int base); +mrb_value mrb_as_bint(mrb_state *mrb, mrb_value x); +mrb_value mrb_bint_add(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_sub(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_mul(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_div(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_divmod(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_add_ii(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_bint_sub_ii(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_bint_mul_ii(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_bint_div_ii(mrb_state *mrb, mrb_int x, mrb_int y); +mrb_value mrb_bint_mod(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_rem(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_pow(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_powm(mrb_state *mrb, mrb_value x, mrb_int y, mrb_value z); +mrb_value mrb_bint_and(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_or(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_xor(mrb_state *mrb, mrb_value x, mrb_value y); +mrb_value mrb_bint_rev(mrb_state *mrb, mrb_value x); +mrb_value mrb_bint_lshift(mrb_state *mrb, mrb_value x, mrb_int width); +mrb_value mrb_bint_rshift(mrb_state *mrb, mrb_value x, mrb_int width); +mrb_value mrb_bint_to_s(mrb_state *mrb, mrb_value x, mrb_int base); +#ifndef MRB_NO_FLOAT +mrb_float mrb_bint_as_float(mrb_state *mrb, mrb_value x); +#endif +mrb_int mrb_bint_as_int(mrb_state *mrb, mrb_value x); +mrb_int mrb_bint_cmp(mrb_state *mrb, mrb_value x, mrb_value y); +void mrb_gc_free_bint(mrb_state *mrb, struct RBasic *x); +#endif + #endif /* MRUBY_INTERNAL_H */ diff --git a/include/mruby/value.h b/include/mruby/value.h index ad439334b..d3a41cefd 100644 --- a/include/mruby/value.h +++ b/include/mruby/value.h @@ -154,7 +154,8 @@ static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000; f(MRB_TT_ISTRUCT, struct RIStruct, "istruct") \ f(MRB_TT_BREAK, struct RBreak, "break") \ f(MRB_TT_COMPLEX, struct RComplex, "Complex") \ - f(MRB_TT_RATIONAL, struct RRational, "Rational") + f(MRB_TT_RATIONAL, struct RRational, "Rational") \ + f(MRB_TT_BIGINT, struct RBigint, "Integer") enum mrb_vtype { #define MRB_VTYPE_DEFINE(tt, type, name) tt, @@ -300,6 +301,9 @@ struct RCptr { #define mrb_bool(o) (mrb_type(o) != MRB_TT_FALSE) #endif #define mrb_test(o) mrb_bool(o) +#ifndef mrb_bigint_p +#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT) +#endif /** * Returns a float in Ruby. diff --git a/mrbgems/mruby-bigint/README-fgmp.md b/mrbgems/mruby-bigint/README-fgmp.md new file mode 100644 index 000000000..3e5400dd5 --- /dev/null +++ b/mrbgems/mruby-bigint/README-fgmp.md @@ -0,0 +1,154 @@ +# fgmp + +FGMP is a public domain implementation of a subset of the GNU gmp library with the same API. + +WELCOME TO FGMP. + +FGMP is a public domain implementation of a subset of the GNU gmp library +with the same API. + +For instance, you can link the following trivial program with either +this code, or libgmp.a and get the same results. + +``` C +#include +#include "gmp.h" +main() +{ + MP_INT a; MP_INT b; MP_INT c; + + mpz_init_set_ui(&a,1); mpz_init_set_ui(&b,2); mpz_init(&c); + mpz_add(&c,&a,&b); + printf("\n%s\n", mpz_get_str(NULL,10,&c)); +} +``` + +FGMP is really in the public domain. You can do whatever you want with +it. + +I wrote FGMP so that we would all have access to a (truly free) +implementation of this subset of the API of GNU libgmp. I encourage +everyone to distribute this as widely as possible. + +If you need more documentation, I suggest you look at the file +gmp.texi which is included with the GNU gmp library. + +You can send me bug reports, implementations of missing functions, flames +and rants by Email. + +Any submissions of new code to be integrated into fgmp must also be +placed in the public domain (For the particularly dense, you can +release a new fgmp yourself under different licensing terms. This +is a condition for including a submission in a release of FGMP that +I personally prepare). + +Mark Henderson + +# This is the fifth BETA release. 1.0b5 + +I hearby place this file and all of FGMP in the public domain. + +Thanks to Paul Rouse for changes to get fgmp +to work on a 286 MS-DOS compiler, the functions mpz_sqrt and +mpz_sqrtrem, plus other general bug fixes. + +Thanks also to Erick Gallesio for a fix +to mpz_init_set_str + +Define B64 if your "long" type is 64 bits. Otherwise we assume 32 +bit longs. (The 64 bit version hasn't been tested enough) + +``` +Platforms: +Linux 0.99 (gcc) +IBM RS6000/AIX 3.2 (IBM xlc compiler and gcc 2.3) +Sun OS 4.1, Sun 3/4 +DEC Alpha OSF/1 (only lightly tested, 64 bit longs do make a difference, + thanks to DEC for providing access via axposf.pa.dec.com). Define B64 + for this platform +MS-DOS 286 C compiler (see credits above) +``` + +# Some differences between gmp and fgmp + +1. fgmp is considerably slower than gmp +2. fgmp does not implement the following: + all mpq_* + internal mpn_* functions + mpz_perfect_square_p + mpz_inp_raw, mpz_out_raw + mp_set_memory_functions, mpz_out_str, mpz_inp_str +3. fgmp implements the following in addition to the routines in GNU gmp. + `int mpz_jacobi(MP_INT *a, MP_INT *b)` + - finds the jacobi symbol (a/b) +4. mpz_sizeinbase often overestimates the exact value + +5. To convert your gmp based program to fgmp (subject to the +above) + +- recompile your source. Make sure to include the gmp.h file included + with fgmp rather than that included with gmp. (The point is to recompile + all files which include gmp.h) +- link with gmp.o instead of libgmp.a + +Here's a complete sorted list of function implemented in fgmp: + +``` +_mpz_realloc +mpz_abs +mpz_add +mpz_add_ui +mpz_and +mpz_clear +mpz_cmp +mpz_cmp_si +mpz_cmp_ui +mpz_div +mpz_div_2exp +mpz_div_ui +mpz_divmod +mpz_divmod_ui +mpz_fac_ui +mpz_gcd +mpz_gcdext +mpz_get_si +mpz_get_str +mpz_get_ui +mpz_init +mpz_init_set +mpz_init_set_si +mpz_init_set_str +mpz_init_set_ui +mpz_jacobi +mpz_mdiv +mpz_mdiv_ui +mpz_mdivmod +mpz_mdivmod_ui +mpz_mmod +mpz_mmod_ui +mpz_mod +mpz_mod_2exp +mpz_mod_ui +mpz_mul +mpz_mul_2exp +mpz_mul_ui +mpz_neg +mpz_or +mpz_pow_ui +mpz_powm +mpz_powm_ui +mpz_probab_prime_p +mpz_random +mpz_random2 +mpz_set +mpz_set_si +mpz_set_str +mpz_set_ui +mpz_size +mpz_sizeinbase +mpz_sqrt +mpz_sqrtrem +mpz_sub +mpz_sub_ui +mpz_xor +``` diff --git a/mrbgems/mruby-bigint/README.md b/mrbgems/mruby-bigint/README.md new file mode 100644 index 000000000..bf15b7f24 --- /dev/null +++ b/mrbgems/mruby-bigint/README.md @@ -0,0 +1,9 @@ +# Multi-precision Integer extension for mruby + +This extension uses fgmp, which is a public domain implementation of a subset of the GNU gmp library by Mark Henderson +But it's heavily modified to fit with mruby. You can get the original source code from +You can read the original README for fgmp in + +## Implementation + +This mrbgem is only to turn on `MRB_USE_BIGINT` flag. The implementation resides in `include/mruby/bigint.h` and `src/bigint.c`. diff --git a/mrbgems/mruby-bigint/mrbgem.rake b/mrbgems/mruby-bigint/mrbgem.rake new file mode 100644 index 000000000..528a7ee70 --- /dev/null +++ b/mrbgems/mruby-bigint/mrbgem.rake @@ -0,0 +1,6 @@ +MRuby::Gem::Specification.new('mruby-bigint') do |spec| + spec.license = 'MIT' + spec.author = 'mruby developers' + spec.summary = 'Integer class extension to multiple-precision' + spec.build.defines << "MRB_USE_BIGINT" +end diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index 4220f9207..1010d8fa7 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -1,9 +1,40 @@ #include #include +#include #include -void mrb_int_zerodiv(mrb_state *mrb); -void mrb_int_overflow(mrb_state *mrb, const char *reason); +#ifdef MRB_USE_BIGINT +#include + +static mrb_value +bint_allbits(mrb_state *mrb, mrb_value x, mrb_value y) +{ + y = mrb_as_bint(mrb, y); + x = mrb_bint_and(mrb, x, y); + if (mrb_bint_cmp(mrb, x, y) == 0) return mrb_true_value(); + return mrb_false_value(); +} + +static mrb_value +bint_anybits(mrb_state *mrb, mrb_value x, mrb_value y) +{ + y = mrb_as_bint(mrb, y); + x = mrb_bint_and(mrb, x, y); + if (mrb_bint_cmp(mrb, x, mrb_fixnum_value(0)) != 0) + return mrb_true_value(); + return mrb_false_value(); +} + +static mrb_value +bint_nobits(mrb_state *mrb, mrb_value x, mrb_value y) +{ + y = mrb_as_bint(mrb, y); + x = mrb_bint_and(mrb, x, y); + if (mrb_bint_cmp(mrb, x, mrb_fixnum_value(0)) == 0) + return mrb_true_value(); + return mrb_false_value(); +} +#endif /* * call-seq: @@ -14,6 +45,9 @@ void mrb_int_overflow(mrb_state *mrb, const char *reason); static mrb_value int_allbits(mrb_state *mrb, mrb_value self) { +#ifdef MRB_USE_BIGINT + return bint_allbits(mrb, self, mrb_get_arg1(mrb)); +#endif mrb_int n, m; mrb_get_args(mrb, "i", &m); @@ -30,6 +64,9 @@ int_allbits(mrb_state *mrb, mrb_value self) static mrb_value int_anybits(mrb_state *mrb, mrb_value self) { +#ifdef MRB_USE_BIGINT + return bint_anybits(mrb, self, mrb_get_arg1(mrb)); +#endif mrb_int n, m; mrb_get_args(mrb, "i", &m); @@ -46,6 +83,9 @@ int_anybits(mrb_state *mrb, mrb_value self) static mrb_value int_nobits(mrb_state *mrb, mrb_value self) { +#ifdef MRB_USE_BIGINT + return bint_nobits(mrb, self, mrb_get_arg1(mrb)); +#endif mrb_int n, m; mrb_get_args(mrb, "i", &m); @@ -53,6 +93,10 @@ int_nobits(mrb_state *mrb, mrb_value self) return mrb_bool_value((n & m) == 0); } +#ifndef MRB_NO_FLOAT +static mrb_value flo_remainder(mrb_state *mrb, mrb_value self); +#endif + /* * call-seq: * num.remainder(numeric) -> real @@ -67,6 +111,14 @@ int_remainder(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); mrb_int a, b; +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + if (mrb_integer_p(y) || mrb_bigint_p(y)) { + return mrb_bint_rem(mrb, x, y); + } + return flo_remainder(mrb, mrb_float_value(mrb, mrb_as_float(mrb, x))); + } +#endif a = mrb_integer(x); if (mrb_integer_p(y)) { b = mrb_integer(y); @@ -77,11 +129,7 @@ int_remainder(mrb_state *mrb, mrb_value x) #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer remainder"); #else - mrb_float n = (mrb_float)a; - mrb_float m = mrb_as_float(mrb, y); - - if (isinf(m)) return mrb_float_value(mrb, n); - return mrb_float_value(mrb, n-m*trunc(n/m)); + return flo_remainder(mrb, mrb_float_value(mrb, mrb_as_float(mrb, x))); #endif } @@ -100,14 +148,25 @@ mrb_value mrb_int_pow(mrb_state *mrb, mrb_value x); static mrb_value int_powm(mrb_state *mrb, mrb_value x) { + mrb_value m; mrb_int base, exp, mod, result = 1; if (mrb_get_argc(mrb) == 1) { return mrb_int_pow(mrb, x); } - mrb_get_args(mrb, "ii", &exp, &mod); - if (exp < 0) mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): n must be positive"); - if (mod < 0) mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): m must be positive"); + mrb_get_args(mrb, "io", &exp, &m); + if (exp < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "int.pow(n,m): n must be positive"); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_powm(mrb, x, exp, m); + } + if (mrb_bigint_p(m)) { + return mrb_bint_powm(mrb, mrb_bint_new_int(mrb, mrb_integer(x)), exp, m); + } +#endif + if (!mrb_integer_p(m)) mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): m must be integer"); + mod = mrb_integer(m); + if (mod < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "int.pow(n,m): m must be positive"); if (mod == 0) mrb_int_zerodiv(mrb); if (mod == 1) return mrb_fixnum_value(0); base = mrb_integer(x); diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c index d4ade914f..121cbb060 100644 --- a/mrbgems/mruby-os-memsize/src/memsize.c +++ b/mrbgems/mruby-os-memsize/src/memsize.c @@ -128,23 +128,24 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj) case MRB_TT_INTEGER: if (mrb_immediate_p(obj)) break; - case MRB_TT_RATIONAL: + case MRB_TT_RATIONAL: #if defined(MRB_USE_RATIONAL) #if defined(MRB_INT64) && defined(MRB_32BIT) - size += sizeof(mrb_int)*2; + size += sizeof(mrb_int)*2; #endif - size += mrb_objspace_page_slot_size(); + size += mrb_objspace_page_slot_size(); #endif - break; + break; - case MRB_TT_COMPLEX: + case MRB_TT_COMPLEX: #if defined(MRB_USE_COMPLEX) #if defined(MRB_32BIT) && !defined(MRB_USE_FLOAT32) - size += sizeof(mrb_float)*2; + size += sizeof(mrb_float)*2; #endif - size += mrb_objspace_page_slot_size(); + size += mrb_objspace_page_slot_size(); #endif - break; + break; + case MRB_TT_BIGINT: case MRB_TT_DATA: case MRB_TT_ISTRUCT: size += mrb_objspace_page_slot_size(); diff --git a/src/array.c b/src/array.c index 29ac2f8b3..6d096a61d 100644 --- a/src/array.c +++ b/src/array.c @@ -847,7 +847,7 @@ ary_subseq(mrb_state *mrb, struct RArray *a, mrb_int beg, mrb_int len) return mrb_ary_new_from_values(mrb, len, ARY_PTR(a)+beg); } ary_make_shared(mrb, a); - b = MRB_OBJ_ALLOC(mrb, MRB_TT_ARRAY, mrb->array_class); + b = MRB_OBJ_ALLOC(mrb, MRB_TT_ARRAY, mrb->array_class); b->as.heap.ptr = a->as.heap.ptr + beg; b->as.heap.len = len; b->as.heap.aux.shared = a->as.heap.aux.shared; diff --git a/src/bigint.c b/src/bigint.c new file mode 100644 index 000000000..136c0c78b --- /dev/null +++ b/src/bigint.c @@ -0,0 +1,1410 @@ +/** +** @file mruby/bigint.h - Multi-precision, Integer +** +** See Copyright Notice in mruby.h +*/ +#ifdef MRB_USE_BIGINT + +#include +#include +#include +#include +#include +#include +#include +#include + +static void +mpz_init(mrb_state *mrb, mpz_t *s) +{ + s->p = (mp_limb*)mrb_malloc(mrb, sizeof(mp_limb)*2); + (s->p)[0] = 0; + (s->p)[1] = 0; + s->sn=0; + s->sz=2; +} + +#if 0 +static void +mpz_init_set(mrb_state *mrb, mpz_t *s, mpz_t *t) +{ + int i; + s->p = (mp_limb*)mrb_malloc(mrb, sizeof(mp_limb) * t->sz); + for (i=0;i < t->sz ; i++) + (s->p)[i] = (t->p)[i]; + + s->sn = t->sn; + s->sz = t->sz; +} +#endif + +static void +mpz_set_int(mrb_state *mrb, mpz_t *y, long v) +{ + for (size_t i=1; isz; i++) + y->p[i] = 0; + if (v < 0) { + y->sn = -1; + y->p[0] = (-v) & LMAX; + y->p[1] = ((-v) & LC) >> DIGITBITS; + } + else if (v > 0) { + y->sn = 1; + y->p[0] = v & LMAX; + y->p[1] = (v & LC) >> DIGITBITS; + } + else { + y->sn=0; + y->p[0] = 0; + y->p[1] = 0; + } +} + +static void +mpz_init_set_int(mrb_state *mrb, mpz_t *y, mrb_int v) +{ + size_t u; + + y->p = (mp_limb*)mrb_malloc(mrb, sizeof(mp_limb)*2); + if (v < 0) { + y->sn = -1; + u = -v; + } + else if (v > 0) { + y->sn = 1; + u = v; + } + else { + y->sn=0; + u = 0; + } + y->p[0] = u & LMAX; + y->p[1] = (u & LC) >> DIGITBITS; + y -> sz = 2; +} + +static void +mpz_clear(mrb_state *mrb, mpz_t *s) +{ + if (s->p) + mrb_free(mrb, s->p); + s->p=NULL; + s->sn=0; + s->sz=0; +} + +static void +mpz_realloc(mrb_state *mrb, mpz_t *x, size_t size) +{ + if (size > 1 && x->sz < size) { + x->p=(mp_limb*)mrb_realloc(mrb,x->p,size * sizeof(mp_limb)); + for (size_t i=x->sz; ip)[i] = 0; + x->sz = size; + } +} + +static size_t +digits(mpz_t *x) +{ + int i; + for (i = (x->sz) - 1; i>=0 && (x->p)[i] == 0 ; i--) + ; + return i+1; +} + +/* y = x */ +static void +mpz_set(mrb_state *mrb, mpz_t *y, mpz_t *x) +{ + size_t i,k = x->sz; + if (y->sz < k) { + k=digits(x); + mpz_realloc(mrb, y, (size_t)k); + } + if (y->sz > x->sz) { + mpz_clear(mrb, y); + mpz_init(mrb, y); + mpz_realloc(mrb, y, (size_t)(x->sz)); + } + + for (i=0;i < k; i++) + (y->p)[i] = (x->p)[i]; + + for (;isz;i++) + (y->p)[i] = 0; + + y->sn = x->sn; +} + +/* z = x + y, without regard for sign */ +static void +uadd(mrb_state *mrb, mpz_t *z, mpz_t *x, mpz_t *y) +{ + mp_limb c; + size_t i; + mpz_t *t; + + if (y->sz < x->sz) { + t=x; x=y; y=t; + } + + /* now y->sz >= x->sz */ + + mpz_realloc(mrb, z, (size_t)((y->sz)+1)); + + c=0; + for (i=0; isz; i++) { + if (( z->p[i] = y->p[i] + x->p[i] + c ) & CMASK) { + c=1; + (z->p[i]) &=LMAX; + } + else + c=0; + } + for (;isz; i++) { + if ((z->p[i] = (y->p[i] + c)) & CMASK) + z->p[i]=0; + else + c=0; + } + (z->p)[y->sz]=c; +} + +/* z = y - x, ignoring sign */ +/* precondition: abs(y) >= abs(x) */ +static void +usub(mrb_state *mrb, mpz_t *z, mpz_t *y, mpz_t *x) +{ + mp_limb b,m; + mpz_realloc(mrb, z, (size_t)(y->sz)); + b=0; + for (size_t i=0;isz;i++) { + m=((y->p)[i]-b)-dg(x,i); + if (m < 0) { + b = 1; + m = LMAX + 1 + m; + } + else + b = 0; + z->p[i] = m; + } +} + +/* compare abs(x) and abs(y) */ +static int +ucmp(mpz_t *y, mpz_t *x) +{ + int i; + for (i=imax(x->sz,y->sz)-1;i>=0;i--) { + if (dg(y,i) < dg(x,i)) + return (-1); + else if (dg(y,i) > dg(x,i)) + return 1; + } + return 0; +} + +static int +uzero(mpz_t *x) +{ + for (size_t i=0; i < x->sz; i++) + if ((x->p)[i] != 0) + return 0; + return 1; +} + +static void +zero(mpz_t *x) +{ + x->sn=0; + for (size_t i=0;isz;i++) + (x->p)[i] = 0; +} + +/* z = x + y */ +static void +mpz_add(mrb_state *mrb, mpz_t *zz, mpz_t *x, mpz_t *y) +{ + int mg; + mpz_t z; + if (x->sn == 0) { + mpz_set(mrb, zz, y); + return; + } + if (y->sn == 0) { + mpz_set(mrb, zz, x); + return; + } + mpz_init(mrb, &z); + + if (x->sn > 0 && y->sn > 0) { + uadd(mrb, &z, x, y); + z.sn = 1; + } + else if (x->sn < 0 && y->sn < 0) { + uadd(mrb, &z, x, y); + z.sn = -1; + } + else { + /* signs differ */ + if ((mg = ucmp(x,y)) == 0) { + zero(&z); + } + else if (mg > 0) { /* abs(y) < abs(x) */ + usub(mrb, &z, x, y); + z.sn = (x->sn > 0 && y->sn < 0) ? 1 : (-1); + } + else { /* abs(y) > abs(x) */ + usub(mrb, &z, y, x); + z.sn = (x->sn < 0 && y->sn > 0) ? 1 : (-1); + } + } + mpz_set(mrb,zz,&z); + mpz_clear(mrb,&z); +} + +/* z = x - y -- just use mpz_add - I'm lazy */ +static void +mpz_sub(mrb_state *mrb, mpz_t *z, mpz_t *x, mpz_t *y) +{ + mpz_t u; + mpz_init(mrb, &u); + mpz_set(mrb, &u, y); + u.sn = -(u.sn); + mpz_add(mrb, z, x, &u); + mpz_clear(mrb, &u); +} + +/* x = y - n */ +static void +mpz_sub_int(mrb_state *mrb, mpz_t *x, mpz_t *y, mrb_int n) +{ + mpz_t z; + mpz_init_set_int(mrb, &z, n); + mpz_sub(mrb, x, y, &z); + mpz_clear(mrb, &z); +} + +/* w = u * v */ +static void +mpz_mul(mrb_state *mrb, mpz_t *ww, mpz_t *u, mpz_t *v) +{ + size_t i,j; + mp_limb t0,t1,t2,t3; + mp_limb cc; + mpz_t w; + + mpz_init(mrb, &w); + mpz_realloc(mrb, &w, (size_t)(u->sz + v->sz)); + for (j=0; j < 2*u->sz; j++) { + cc = (mp_limb)0; + t3 = hd(u,j); + for (i=0; i < 2*v->sz; i++) { + t0 = t3 * hd(v,i); + t1 = HIGH(t0); t0 = LOW(t0); + if ((i+j)%2) + t2 = HIGH(w.p[(i+j)/2]); + else + t2 = LOW(w.p[(i+j)/2]); + t2 += cc; + if (t2 & HCMASK) { + cc = 1; t2&=HLMAX; + } + else + cc = 0; + t2 += t0; + if (t2 & HCMASK) { + cc++ ; t2&=HLMAX; + } + cc+=t1; + if ((i+j)%2) + w.p[(i+j)/2] = LOW(w.p[(i+j)/2]) | + (t2 << HALFDIGITBITS); + else + w.p[(i+j)/2] = (HIGH(w.p[(i+j)/2]) << HALFDIGITBITS) | t2; + } + if (cc) { + if ((j+i)%2) + w.p[(i+j)/2] += cc << HALFDIGITBITS; + else + w.p[(i+j)/2] += cc; + } + } + w.sn = (u->sn) * (v->sn); + mpz_set(mrb, ww, &w); + mpz_clear(mrb, &w); +} + +static void +mpz_mul_int(mrb_state *mrb, mpz_t *x, mpz_t *y, mrb_int n) +{ + mpz_t z; + mpz_init_set_int(mrb,&z,n); + mpz_mul(mrb,x,y,&z); + mpz_clear(mrb,&z); +} + +/* number of leading zero bits in digit */ +static int +lzb(mp_limb a) +{ + mp_limb i; size_t j=0; + + for (i = ((mp_limb)1 << (DIGITBITS-1)); i && !(a&i) ; j++,i>>=1) + ; + return j; +} + +/* c1 = a>>n */ +/* n must be < DIGITBITS */ +static void +urshift(mrb_state *mrb, mpz_t *c1, mpz_t *a, int n) +{ + mp_limb cc = 0; + mrb_assert(n < DIGITBITS); + if (n == 0) + mpz_set(mrb, c1, a); + else { + mpz_t c; size_t i; + mp_limb rm = (((mp_limb)1<sz)); + for (i=a->sz-1;; i--) { + c.p[i] = ((a->p[i] >> n) | cc) & LMAX; + cc = (a->p[i] & rm) << (DIGITBITS - n); + if (i == 0) break; + } + mpz_set(mrb,c1,&c); + mpz_clear(mrb,&c); + } +} + +/* c1 = a<sz + 1)); + for (i=0; isz; i++) { + c.p[i] = (((mrb_uint)a->p[i] << n) | cc) & LMAX; + cc = (a->p[i] & rm) >> (DIGITBITS -n); + } + c.p[i] = cc; + mpz_set(mrb,c1,&c); + mpz_clear(mrb,&c); + } +} + +/* internal routine to compute x/y and x%y ignoring signs */ +static void +udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) +{ + mpz_t q, x, y, r; + int ns,f,xd,yd,i,j,ccc=0; + mp_limb zz,z,qhat,b,u,m; + + if (uzero(yy)) + return; + mpz_init(mrb,&q); mpz_init(mrb,&x);mpz_init(mrb,&y);mpz_init(mrb,&r); + mpz_realloc(mrb,&x,(size_t)((xx->sz)+1)); + yd = digits(yy); + ns = lzb(yy->p[yd-1]); + ulshift(mrb,&x,xx,ns); + ulshift(mrb,&y,yy,ns); + xd = digits(&x); + mpz_realloc(mrb,&q,(size_t)xd); + xd*=2; yd*=2; + z = hd(&y,yd-1); + for (j=(xd-yd);j>=0;j--) { + if (z == LMAX) + qhat = hd(&x,j+yd); + else { + qhat = ((hd(&x,j+yd)<< HALFDIGITBITS) + hd(&x,j+yd-1)) / (z+1); + } + b = 0; zz=0; + if (qhat) { + for (i=0; i < yd; i++) { + zz = qhat * hd(&y,i); + u = hd(&x,i+j); + u-=b; + if (u<0) { + b=1; u+=HLMAX+1; + } + else + b=0; + u-=LOW(zz); + if (u < 0) { + b++; + u+=HLMAX+1; + } + b+=HIGH(zz); + if ((i+j)%2) + x.p[(i+j)/2] = LOW(x.p[(i+j)/2]) | (u << HALFDIGITBITS); + else + x.p[(i+j)/2] = (HIGH(x.p[(i+j)/2]) << HALFDIGITBITS) | u; + } + if (b) { + if ((j+i)%2) + x.p[(i+j)/2] -= b << HALFDIGITBITS; + else + x.p[(i+j)/2] -= b; + } + } + for(;;zz++) { + f=1; + if (!hd(&x,j+yd)) { + for(i=yd-1; i>=0; i--) { + if (hd(&x,j+i) > hd(&y,i)) { + f=1; + break; + } + if (hd(&x,j+i) < hd(&y,i)) { + f=0; + break; + } + } + } + if (!f) + break; + qhat++; + ccc++; + b=0; + for (i=0;isz)); + zero(&r); + urshift(mrb,&r,&x,ns); + mpz_set(mrb,rr,&r); + mpz_set(mrb,qq,&q); + mpz_clear(mrb,&x); mpz_clear(mrb,&y); + mpz_clear(mrb,&q); mpz_clear(mrb,&r); +} + +static void +mpz_mdiv(mrb_state *mrb, mpz_t *q, mpz_t *x, mpz_t *y) +{ + mpz_t r; + short sn1 = x->sn, sn2 = y->sn, qsign; + mpz_init(mrb,&r); + udiv(mrb,q,&r,x,y); + qsign = q->sn = sn1*sn2; + if (uzero(q)) + q->sn = 0; + /* now if r != 0 and q < 0 we need to round q towards -inf */ + if (!uzero(&r) && qsign < 0) + mpz_sub_int(mrb,q,q,1); + mpz_clear(mrb,&r); +} + +static void +mpz_mmod(mrb_state *mrb, mpz_t *r, mpz_t *x, mpz_t *y) +{ + mpz_t q; + short sn1 = x->sn, sn2 = y->sn; + mpz_init(mrb, &q); + if (sn1 == 0) { + zero(r); + return; + } + udiv(mrb,&q,r,x,y); + if (uzero(r)) { + r->sn = 0; + return; + } + q.sn = sn1*sn2; + if (q.sn > 0) + r->sn = sn1; + else if (sn1 < 0 && sn2 > 0) { + r->sn = 1; + mpz_sub(mrb,r,y,r); + } + else { + r->sn = 1; + mpz_add(mrb,r,y,r); + } +} + +static void +mpz_mdivmod(mrb_state *mrb, mpz_t *q, mpz_t *r, mpz_t *x, mpz_t *y) +{ + short sn1 = x->sn, sn2 = y->sn, qsign; + if (sn1 == 0) { + zero(q); + zero(r); + return; + } + udiv(mrb,q,r,x,y); + qsign = q->sn = sn1*sn2; + if (uzero(r)) { + /* q != 0, since q=r=0 would mean x=0, which was tested above */ + r->sn = 0; + return; + } + if (q->sn > 0) + r->sn = sn1; + else if (sn1 < 0 && sn2 > 0) { + r->sn = 1; + mpz_sub(mrb,r,y,r); + } + else { + r->sn = 1; + mpz_add(mrb,r,y,r); + } + if (uzero(q)) + q->sn = 0; + /* now if r != 0 and q < 0 we need to round q towards -inf */ + if (!uzero(r) && qsign < 0) + mpz_sub_int(mrb,q,q,1); +} + +static void +mpz_mod(mrb_state *mrb, mpz_t *r, mpz_t *x, mpz_t *y) +{ + mpz_t q; + short sn = x->sn; + mpz_init(mrb, &q); + if (x->sn == 0) { + zero(r); + return; + } + udiv(mrb,&q,r,x,y); + r->sn = sn; + if (uzero(r)) + r->sn = 0; + mpz_clear(mrb,&q); +} + +static mrb_int +mpz_cmp(mrb_state *mrb, mpz_t *x, mpz_t *y) +{ + int abscmp; + if (x->sn < 0 && y->sn > 0) + return (-1); + if (x->sn > 0 && y->sn < 0) + return 1; + abscmp=ucmp(x,y); + if (x->sn >=0 && y->sn >=0) + return abscmp; + return (-abscmp); // if (x->sn <=0 && y->sn <=0) +} + +/* 2<=base <=36 - this overestimates the optimal value, which is OK */ +static int +mpz_sizeinbase(mpz_t *x, int base) +{ + int i,j; + int bits = digits(x) * DIGITBITS; + mrb_assert(2 <= base && base <= 36); + for (j=0,i=1; i<=base;i*=2,j++) + ; + return ((bits)/(j-1)+1); +} + +static int +mpz_init_set_str(mrb_state *mrb, mpz_t *x, const char *s, mrb_int len, mrb_int base) +{ + mrb_int i; + mrb_int retval = 0; + mpz_t t,m,bb; + short sn; + unsigned int k; + mpz_init(mrb,x); + mpz_init_set_int(mrb,&m,1); + mpz_init(mrb,&t); + zero(x); + if (*s == '-') { + sn = -1; s++; + } + else if (base < 0) { /* trick: negative if base < 0 */ + sn = -1; base = -base; + } + else + sn = 1; + mpz_init_set_int(mrb,&bb, base); + for (i = len-1; i>=0; i--) { + if (s[i]=='_') continue; + if (s[i] >= '0' && s[i] <= '9') + k = (unsigned int)s[i] - (unsigned int)'0'; + else if (s[i] >= 'A' && s[i] <= 'Z') + k = (unsigned int)s[i] - (unsigned int)'A'+10; + else if (s[i] >= 'a' && s[i] <= 'z') + k = (unsigned int)s[i] - (unsigned int)'a'+10; + else { + retval = (-1); + break; + } + if (k >= base) { + retval = (-1); + break; + } + mpz_mul_int(mrb,&t,&m,(mrb_int)k); + mpz_add(mrb,x,x,&t); + mpz_mul(mrb,&m,&m,&bb); + } + if (x->sn) + x->sn = sn; + mpz_clear(mrb,&m); + mpz_clear(mrb,&bb); + mpz_clear(mrb,&t); + return retval; +} + +static char* +mpz_get_str(mrb_state *mrb, char *s, int sz, int base, mpz_t *x) +{ + mpz_t xx,q,r,bb; + char *p,*t,*ps; + mp_limb d; + mrb_assert(2 <= base && base <= 36); + if (uzero(x)) { + *s='0'; + *(s+1)='\0'; + return s; + } + t = (char*)mrb_malloc(mrb, sz+2); + mpz_init(mrb,&xx); mpz_init(mrb,&q); mpz_init(mrb,&r); + mpz_init_set_int(mrb,&bb,base); + mpz_set(mrb,&xx,x); + ps = s; + if (x->sn < 0) { + *ps++= '-'; + xx.sn = 1; + } + p = t; + while (!uzero(&xx)) { + udiv(mrb,&xx,&r,&xx,&bb); + d = r.p[0]; + if (d < 10) + *p++ = (char)(r.p[0] + '0'); + else + *p++ = (char)(r.p[0] + -10 + 'a'); + } + + p--; + for (;p>=t;p--,ps++) + *ps = *p; + *ps='\0'; + + mrb_free(mrb,t); + mpz_clear(mrb,&xx); mpz_clear(mrb,&q); mpz_clear(mrb,&r); mpz_clear(mrb,&bb); + return s; +} + +static int +mpz_get_int(mpz_t *y, mrb_int *v) +{ + mrb_int i; + + if (y->sn == 0) { + i = 0; + } + else if (y->sz > 2 || y->p[1] > 1) { + return FALSE; + } + else { + i = (y->sn * (y->p[0] | (y->p[1] & 1) << DIGITBITS)); + } + *v = i; + return TRUE; +} + +static void +mpz_mul_2exp(mrb_state *mrb, mpz_t *z, mpz_t *x, mrb_int e) +{ + short sn = x->sn; + if (e==0) + mpz_set(mrb,z,x); + else { + size_t i; + long digs = (e / DIGITBITS); + size_t bs = (e % (DIGITBITS)); + mpz_t y; + + mpz_init(mrb, &y); + mpz_realloc(mrb, &y,(size_t)((x->sz)+digs)); + for (i=digs;i<((x->sz) + digs);i++) + (y.p)[i] = (x->p)[i - digs]; + if (bs) { + ulshift(mrb,z,&y,bs); + } + else { + mpz_set(mrb,z,&y); + } + z->sn = sn; + mpz_clear(mrb,&y); + } +} + +static void +mpz_div_2exp(mrb_state *mrb, mpz_t *z, mpz_t *x, mrb_int e) +{ + short sn = x->sn; + if (e==0) + mpz_set(mrb,z,x); + else { + size_t i; + long digs = (e / DIGITBITS); + size_t bs = (e % (DIGITBITS)); + mpz_t y; + + mpz_init(mrb,&y); + mpz_realloc(mrb,&y,(size_t)((x->sz) - digs)); + for (i=0; i < (x->sz - digs); i++) + (y.p)[i] = (x->p)[i+digs]; + if (bs) { + urshift(mrb,z,&y,bs); + } + else { + mpz_set(mrb,z,&y); + } + if (uzero(z)) + z->sn = 0; + else + z->sn = sn; + mpz_clear(mrb,&y); + } +} + +static void +mpz_neg(mrb_state *mrb, mpz_t *x, mpz_t *y) +{ + if (x!=y) + mpz_set(mrb,x,y); + x->sn = -(y->sn); +} + +static void +mpz_and(mrb_state *mrb, mpz_t *z, mpz_t *x, mpz_t *y) /* not the most efficient way to do this */ +{ + size_t i,sz; + sz = imax(x->sz, y->sz); + mpz_realloc(mrb,z,(size_t)sz); + for (i=0; i < sz; i++) + (z->p)[i] = dg(x,i) & dg(y,i); + if (x->sn < 0 && y->sn < 0) + z->sn = (-1); + else + z->sn = 1; + if (uzero(z)) + z->sn = 0; +} + +static void +mpz_or(mrb_state *mrb, mpz_t *z, mpz_t *x, mpz_t *y) /* not the most efficient way to do this */ +{ + size_t i,sz; + sz = imax(x->sz, y->sz); + mpz_realloc(mrb,z,(size_t)sz); + for (i=0; i < sz; i++) + (z->p)[i] = dg(x,i) | dg(y,i); + if (x->sn < 0 || y->sn < 0) + z->sn = (-1); + else + z->sn = 1; + if (uzero(z)) + z->sn = 0; +} + +static void +mpz_xor(mrb_state *mrb, mpz_t *z, mpz_t *x, mpz_t *y) /* not the most efficient way to do this */ +{ + size_t i,sz; + sz = imax(x->sz, y->sz); + mpz_realloc(mrb,z,(size_t)sz); + for (i=0; i < sz; i++) + (z->p)[i] = dg(x,i) ^ dg(y,i); + if ((x->sn <= 0 && y->sn > 0) || (x->sn > 0 && y->sn <=0)) + z->sn = (-1); + else + z->sn = 1; + if (uzero(z)) + z->sn = 0; +} + +static void +mpz_pow(mrb_state *mrb, mpz_t *zz, mpz_t *x, mrb_int e) +{ + mpz_t t; + size_t mask = (1UL<< (LONGBITS-1)); + + if (e==0) { + mpz_set_int(mrb, zz, 1L); + return; + } + + mpz_init(mrb,&t); + mpz_set(mrb,&t,x); + for (;!(mask &e); mask>>=1) + ; + mask>>=1; + for (;mask!=0; mask>>=1) { + mpz_mul(mrb,&t,&t,&t); + if (e & mask) + mpz_mul(mrb,&t,&t,x); + } + mpz_set(mrb,zz,&t); + mpz_clear(mrb,&t); +} + +#define lowdigit(x) (((x)->p)[0]) + +struct is { + mp_limb v; + struct is *next; +}; + +static void +push(mrb_state *mrb, mp_limb i, struct is **sp) +{ + struct is *tmp; + tmp = *sp; + *sp = (struct is*)mrb_malloc(mrb, sizeof(struct is)); + (*sp)->v = i; + (*sp)->next=tmp; +} + +static mp_limb +pop(mrb_state *mrb, struct is **sp) +{ + struct is *tmp; + mp_limb i; + if (!(*sp)) + return (-1); + tmp = *sp; + *sp = (*sp)->next; + i = tmp->v; + tmp->v = 0; + mrb_free(mrb,tmp); + return i; +} + +static void +mpz_powm(mrb_state *mrb, mpz_t *zz, mpz_t *x, mrb_int ex, mpz_t *n) +{ + mpz_t t, e; + struct is *stack = NULL; + int k,i; + + if (ex == 0) { + mpz_set_int(mrb,zz,1); + return; + } + + if (ex < 0) { + return; + } + mpz_init(mrb,&e); + mpz_init(mrb,&t); + mpz_set_int(mrb,&e,ex); + + for (k=0;!uzero(&e);k++,mpz_div_2exp(mrb,&e,&e,1)) + push(mrb,lowdigit(&e) & 1,&stack); + k--; + i=pop(mrb,&stack); + + mpz_mod(mrb,&t,x,n); /* t=x%n */ + + for (i=k-1;i>=0;i--) { + mpz_mul(mrb,&t,&t,&t); + mpz_mod(mrb,&t,&t,n); + if (pop(mrb,&stack)) { + mpz_mul(mrb,&t,&t,x); + mpz_mod(mrb,&t,&t,n); + } + } + mpz_set(mrb,zz,&t); + mpz_clear(mrb,&t); + mpz_clear(mrb,&e); +} + +/* --- mruby functions --- */ +static struct RBigint* +bint_new(mrb_state *mrb) +{ + struct RBigint *b = MRB_OBJ_ALLOC(mrb, MRB_TT_BIGINT, mrb->integer_class); + mpz_init(mrb, &b->mp); + return b; +} + +static struct RBigint* +bint_new_int(mrb_state *mrb, mrb_int x) +{ + struct RBigint *b = MRB_OBJ_ALLOC(mrb, MRB_TT_BIGINT, mrb->integer_class); + mpz_init_set_int(mrb, &b->mp, x); + return b; +} + +mrb_value +mrb_bint_new(mrb_state *mrb) +{ + struct RBigint *b = bint_new(mrb); + return mrb_obj_value(b); +} + +mrb_value +mrb_bint_new_int(mrb_state *mrb, mrb_int x) +{ + struct RBigint *b = bint_new_int(mrb, x); + return mrb_obj_value(b); +} + +mrb_value +mrb_bint_new_str(mrb_state *mrb, const char *x, mrb_int len, mrb_int base) +{ + struct RBigint *b = MRB_OBJ_ALLOC(mrb, MRB_TT_BIGINT, mrb->integer_class); + mrb_assert(2 <= iabs(base) && iabs(base) <= 36); + mpz_init_set_str(mrb, &b->mp, x, len, base); + return mrb_obj_value(b); +} + +static mrb_value +bint_norm(mrb_state *mrb, struct RBigint *b) +{ + mrb_int i; + + if (mpz_get_int(&b->mp, &i)) { + return mrb_int_value(mrb, i); + } + return mrb_obj_value(b); +} + +void +mrb_gc_free_bint(mrb_state *mrb, struct RBasic *x) +{ + struct RBigint *b = (struct RBigint*)x; + mpz_clear(mrb, &b->mp); +} + +#ifndef MRB_NO_FLOAT +mrb_float +mrb_bint_as_float(mrb_state *mrb, mrb_value self) +{ + struct RBigint *b = RBIGINT(self); + mpz_t *i = &b->mp; + mp_limb *d = i->p + i->sz; + mrb_float val = 0; + + while (d-- > i->p) { + val = val * (LMAX+1) + *d; + } + + if (i->sn < 0) { + val = -val; + } + return val; +} +#endif + +mrb_value +mrb_as_bint(mrb_state *mrb, mrb_value x) +{ + if (mrb_bigint_p(x)) return x; + return mrb_bint_new_int(mrb, mrb_as_int(mrb, x)); +} + +mrb_int +mrb_bint_as_int(mrb_state *mrb, mrb_value x) +{ + struct RBigint *b = RBIGINT(x); + mrb_int i; + + if (!mpz_get_int(&b->mp, &i)) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow"); + } + return i; +} + +mrb_value +mrb_bint_add(mrb_state *mrb, mrb_value x, mrb_value y) +{ +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mrb_float v1 = mrb_bint_as_float(mrb, x); + mrb_float v2 = mrb_float(y); + return mrb_float_value(mrb,v1+v2); + } +#endif + y = mrb_as_bint(mrb, y); + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = RBIGINT(y); + struct RBigint *b3 = bint_new(mrb); + mpz_add(mrb, &b3->mp, &b->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_sub(mrb_state *mrb, mrb_value x, mrb_value y) +{ +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mrb_float v1 = mrb_bint_as_float(mrb, x); + mrb_float v2 = mrb_float(y); + return mrb_float_value(mrb,v1-v2); + } +#endif + y = mrb_as_bint(mrb, y); + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = RBIGINT(y); + struct RBigint *b3 = bint_new(mrb); + mpz_sub(mrb, &b3->mp, &b->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_mul(mrb_state *mrb, mrb_value x, mrb_value y) +{ +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mrb_float v1 = mrb_bint_as_float(mrb, x); + mrb_float v2 = mrb_float(y); + return mrb_float_value(mrb,v1*v2); + } +#endif + y = mrb_as_bint(mrb, y); + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = RBIGINT(y); + struct RBigint *b3 = bint_new(mrb); + mpz_mul(mrb, &b3->mp, &b->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_div(mrb_state *mrb, mrb_value x, mrb_value y) +{ +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mrb_float v1 = mrb_bint_as_float(mrb, x); + mrb_float v2 = mrb_float(y); + return mrb_float_value(mrb,v1*v2); + } +#endif + y = mrb_as_bint(mrb, y); + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = RBIGINT(y); + struct RBigint *b3 = bint_new(mrb); + mpz_mdiv(mrb, &b3->mp, &b->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_add_ii(mrb_state *mrb, mrb_int x, mrb_int y) +{ + struct RBigint *b = bint_new(mrb); + mpz_t z1, z2; + + mpz_init_set_int(mrb,&z1,x); + mpz_init_set_int(mrb,&z2,y); + mpz_add(mrb,&b->mp,&z1,&z2); + mpz_clear(mrb,&z1); + mpz_clear(mrb,&z2); + return mrb_obj_value(b); +} + +mrb_value +mrb_bint_sub_ii(mrb_state *mrb, mrb_int x, mrb_int y) +{ + struct RBigint *b = bint_new(mrb); + mpz_t z1, z2; + + mpz_init_set_int(mrb,&z1,x); + mpz_init_set_int(mrb,&z2,y); + mpz_sub(mrb,&b->mp,&z1,&z2); + mpz_clear(mrb,&z1); + mpz_clear(mrb,&z2); + return mrb_obj_value(b); +} + +mrb_value +mrb_bint_mul_ii(mrb_state *mrb, mrb_int x, mrb_int y) +{ + struct RBigint *b = bint_new(mrb); + mpz_t z1, z2; + + mpz_init_set_int(mrb,&z1,x); + mpz_init_set_int(mrb,&z2,y); + mpz_mul(mrb,&b->mp,&z1,&z2); + mpz_clear(mrb,&z1); + mpz_clear(mrb,&z2); + return mrb_obj_value(b); +} + +mrb_value +mrb_bint_div_ii(mrb_state *mrb, mrb_int x, mrb_int y) +{ + struct RBigint *b = bint_new(mrb); + mpz_t z1, z2; + + mpz_init_set_int(mrb,&z1,x); + mpz_init_set_int(mrb,&z2,y); + mpz_mdiv(mrb,&b->mp,&z1,&z2); + mpz_clear(mrb,&z1); + mpz_clear(mrb,&z2); + return mrb_obj_value(b); +} + +mrb_value +mrb_bint_idiv(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_nil_value(); +} + +mrb_value +mrb_bint_mod(mrb_state *mrb, mrb_value x, mrb_value y) +{ +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mrb_float v1 = mrb_bint_as_float(mrb, x); + mrb_float v2 = mrb_float(y); + return mrb_float_value(mrb,fmod(v1,v2)); + } +#endif + y = mrb_as_bint(mrb, y); + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = RBIGINT(y); + struct RBigint *b3 = bint_new(mrb); + mpz_mmod(mrb, &b3->mp, &b->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_rem(mrb_state *mrb, mrb_value x, mrb_value y) +{ + /* called from mrbgems/mruby-numeric-ext/src/numeric_ext.c */ + /* y should not be float */ + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = RBIGINT(y); + struct RBigint *b3 = bint_new(mrb); + y = mrb_as_bint(mrb, y); + mpz_mod(mrb, &b3->mp, &b->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_divmod(mrb_state *mrb, mrb_value x, mrb_value y) +{ + /* called from src/numeric.c */ + /* y should not be float */ + y = mrb_as_bint(mrb, y); + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = RBIGINT(y); + struct RBigint *b3 = bint_new(mrb); + struct RBigint *b4 = bint_new(mrb); + mpz_mdivmod(mrb, &b3->mp, &b4->mp, &b->mp, &b2->mp); + x = bint_norm(mrb, b3); + y = bint_norm(mrb, b4); + return mrb_assoc_new(mrb, x, y); +} + +mrb_int +mrb_bint_cmp(mrb_state *mrb, mrb_value x, mrb_value y) +{ +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mrb_float v1 = mrb_bint_as_float(mrb, x); + mrb_float v2 = mrb_float(y); + if (v1 == v2) return 0; + if (v1 > v2) return 1; + return -1; + } +#endif + if (!mrb_bigint_p(y)) { + if (!mrb_integer_p(y)) return -2; /* type mismatch */ + y = mrb_bint_new_int(mrb, mrb_integer(y)); + } + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = RBIGINT(y); + return mpz_cmp(mrb, &b->mp, &b2->mp); +} + +mrb_value +mrb_bint_pow(mrb_state *mrb, mrb_value x, mrb_value y) +{ + struct RBigint *b = RBIGINT(x); + switch (mrb_type(y)) { + case MRB_TT_INTEGER: + { + struct RBigint *b3 = bint_new(mrb); + mpz_pow(mrb, &b3->mp, &b->mp, mrb_integer(y)); + return mrb_obj_value(b3); + } + case MRB_TT_BIGINT: + mrb_raise(mrb, E_TYPE_ERROR, "too big power"); + default: + mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be convert to integer", y); + } + return mrb_nil_value(); +} + +mrb_value +mrb_bint_powm(mrb_state *mrb, mrb_value x, mrb_int exp, mrb_value mod) +{ + struct RBigint *b = RBIGINT(x); + switch (mrb_type(mod)) { + case MRB_TT_INTEGER: + { + struct RBigint *b2 = bint_new(mrb); + struct RBigint *b3 = bint_new_int(mrb, mrb_integer(mod)); + mpz_powm(mrb, &b2->mp, &b->mp, exp, &b3->mp); + return mrb_obj_value(b3); + } + case MRB_TT_BIGINT: + { + struct RBigint *b2 = bint_new(mrb); + struct RBigint *b3 = RBIGINT(mod); + mpz_powm(mrb, &b2->mp, &b->mp, exp, &b3->mp); + return bint_norm(mrb, b3); + } + mrb_raise(mrb, E_TYPE_ERROR, "too big power"); + default: + mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be convert to integer", mod); + } + return mrb_nil_value(); +} + +mrb_value +mrb_bint_to_s(mrb_state *mrb, mrb_value x, mrb_int base) +{ + struct RBigint *b = RBIGINT(x); + mrb_int len = mpz_sizeinbase(&b->mp, base); + mrb_value str = mrb_str_new(mrb, NULL, len+2); + mpz_get_str(mrb, RSTRING_PTR(str), len, base, &b->mp); + RSTR_SET_LEN(RSTRING(str), strlen(RSTRING_PTR(str))); + return str; +} + +mrb_value +mrb_bint_and(mrb_state *mrb, mrb_value x, mrb_value y) +{ + struct RBigint *b1 = RBIGINT(x); + struct RBigint *b3 = bint_new(mrb); + +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mpz_t z; + mpz_init_set_int(mrb, &z, (mrb_int)mrb_float(y)); + mpz_and(mrb, &b3->mp, &b1->mp, &z); + mpz_clear(mrb, &z); + return bint_norm(mrb, b3); + } +#endif + y = mrb_as_bint(mrb, y); + struct RBigint *b2 = RBIGINT(y); + mpz_and(mrb, &b3->mp, &b1->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_or(mrb_state *mrb, mrb_value x, mrb_value y) +{ + struct RBigint *b1 = RBIGINT(x); + struct RBigint *b3 = bint_new(mrb); + +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mpz_t z; + mpz_init_set_int(mrb, &z, (mrb_int)mrb_float(y)); + mpz_or(mrb, &b3->mp, &b1->mp, &z); + mpz_clear(mrb, &z); + return bint_norm(mrb, b3); + } +#endif + y = mrb_as_bint(mrb, y); + struct RBigint *b2 = RBIGINT(y); + mpz_or(mrb, &b3->mp, &b1->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_xor(mrb_state *mrb, mrb_value x, mrb_value y) +{ + struct RBigint *b3 = bint_new(mrb); + struct RBigint *b1 = RBIGINT(x); + +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mpz_t z; + mpz_init_set_int(mrb, &z, (mrb_int)mrb_float(y)); + mpz_xor(mrb, &b3->mp, &b1->mp, &z); + mpz_clear(mrb, &z); + return bint_norm(mrb, b3); + } +#endif + y = mrb_as_bint(mrb, y); + struct RBigint *b2 = RBIGINT(y); + mpz_xor(mrb, &b3->mp, &b1->mp, &b2->mp); + return bint_norm(mrb, b3); +} + +mrb_value +mrb_bint_rev(mrb_state *mrb, mrb_value x) +{ + struct RBigint *b1 = RBIGINT(x); + struct RBigint *b2 = bint_new(mrb); + + mpz_neg(mrb, &b2->mp, &b1->mp); + mpz_sub_int(mrb, &b2->mp, &b2->mp, 1); + return bint_norm(mrb, b2); +} + +mrb_value +mrb_bint_lshift(mrb_state *mrb, mrb_value x, mrb_int width) +{ + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = bint_new(mrb); + if (width < 0) { + mpz_div_2exp(mrb, &b2->mp, &b->mp, -width); + } + else { + mpz_mul_2exp(mrb, &b2->mp, &b->mp, width); + } + return mrb_obj_value(b2); +} + +mrb_value +mrb_bint_rshift(mrb_state *mrb, mrb_value x, mrb_int width) +{ + struct RBigint *b = RBIGINT(x); + struct RBigint *b2 = bint_new(mrb); + if (width < 0) { + mpz_mul_2exp(mrb, &b2->mp, &b->mp, -width); + } + else { + mpz_div_2exp(mrb, &b2->mp, &b->mp, width); + } + return bint_norm(mrb, b2); +} + +void mpz_abs(mpz_t *, mpz_t *); +void mpz_gcd(mpz_t *, mpz_t *, mpz_t *); + +#endif /* MRB_USE_BIGINT */ diff --git a/src/gc.c b/src/gc.c index c978b6131..99fc5e40b 100644 --- a/src/gc.c +++ b/src/gc.c @@ -555,6 +555,7 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls) ttype != MRB_TT_SCLASS && ttype != MRB_TT_ICLASS && ttype != MRB_TT_ENV && + ttype != MRB_TT_BIGINT && ttype != tt) { mrb_raisef(mrb, E_TYPE_ERROR, "allocation failure of %C", cls); } @@ -909,6 +910,12 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end) break; #endif +#ifdef MRB_USE_BIGINT + case MRB_TT_BIGINT: + mrb_gc_free_bint(mrb, obj); + break; +#endif + default: break; } diff --git a/src/load.c b/src/load.c index 4ed270569..b02650b98 100644 --- a/src/load.c +++ b/src/load.c @@ -166,7 +166,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, const uint8_t *end, size_ pool_data_len = bin_to_uint8(src); /* pool data length */ src += sizeof(uint8_t); if (src + pool_data_len > end) return FALSE; - { + { char *p; pool[i].tt = IREP_TT_BIGINT; p = (char*)mrb_malloc(mrb, pool_data_len+2); diff --git a/src/numeric.c b/src/numeric.c index 781a06b4b..aa6550d7a 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -45,6 +45,18 @@ mrb_int_zerodiv(mrb_state *mrb) mrb_value mrb_int_pow(mrb_state *mrb, mrb_value x) { +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + mrb_value y = mrb_get_arg1(mrb); + +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + return mrb_float_value(mrb, pow(mrb_bint_as_float(mrb, x), mrb_float(y))); + } +#endif + return mrb_bint_pow(mrb, x, y); + } +#endif mrb_int base = mrb_integer(x); mrb_int result = 1; mrb_int exp; @@ -79,7 +91,11 @@ mrb_int_pow(mrb_state *mrb, mrb_value x) exp >>= 1; if (exp == 0) break; if (mrb_int_mul_overflow(base, base, &base)) { +#ifdef MRB_USE_BIGINT + return mrb_bint_pow(mrb, mrb_bint_new_int(mrb, mrb_integer(x)), y); +#else mrb_int_overflow(mrb, "power"); +#endif } } return mrb_int_value(mrb, result); @@ -121,13 +137,28 @@ static mrb_value int_div(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_div(mrb, x, y); + } +#endif mrb_int a = mrb_integer(x); if (mrb_integer_p(y)) { - mrb_int div = mrb_div_int(mrb, a, mrb_integer(y)); + mrb_int b = mrb_integer(y); +#ifdef MRB_USE_BIGINT + if(a == MRB_INT_MIN && b == -1) { + return mrb_bint_mul_ii(mrb, a, b); + } +#endif + mrb_int div = mrb_div_int(mrb, a, b); return mrb_int_value(mrb, div); } switch (mrb_type(y)) { +#ifdef MRB_USE_BIGINT + case MRB_TT_BIGINT: + return mrb_bint_div(mrb, mrb_bint_new_int(mrb, a), y); +#endif #ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1), y); @@ -163,6 +194,11 @@ int_div(mrb_state *mrb, mrb_value x) static mrb_value int_idiv(mrb_state *mrb, mrb_value x) { +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_div(mrb, x, mrb_get_arg1(mrb)); + } +#endif mrb_int y; mrb_get_args(mrb, "i", &y); @@ -182,6 +218,11 @@ int_quo(mrb_state *mrb, mrb_value x) if (y == 0) { mrb_int_zerodiv(mrb); } +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_float_value(mrb, mrb_bint_as_float(mrb, x) / y); + } +#endif return mrb_float_value(mrb, mrb_integer(x) / y); #endif #else @@ -502,6 +543,11 @@ int_eql(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bool_value(mrb_bint_cmp(mrb, x, y) == 0); + } +#endif if (!mrb_integer_p(y)) return mrb_false_value(); return mrb_bool_value(mrb_integer(x) == mrb_integer(y)); } @@ -1038,16 +1084,25 @@ mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y) if (a == 0) return x; b = mrb_integer(y); if (mrb_int_mul_overflow(a, b, &c)) { +#ifdef MRB_USE_BIGINT + x = mrb_bint_new_int(mrb, a); + return mrb_bint_mul(mrb, x, y); +#else mrb_int_overflow(mrb, "multiplication"); +#endif } return mrb_int_value(mrb, c); } switch (mrb_type(y)) { -#if defined(MRB_USE_RATIONAL) +#ifdef MRB_USE_BIGINT + case MRB_TT_BIGINT: + return mrb_bint_mul(mrb, y, x); +#endif +#ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: return mrb_rational_mul(mrb, y, x); #endif -#if defined(MRB_USE_COMPLEX) +#ifdef MRB_USE_COMPLEX case MRB_TT_COMPLEX: return mrb_complex_mul(mrb, y, x); #endif @@ -1075,6 +1130,11 @@ int_mul(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_mul(mrb, x, y); + } +#endif return mrb_int_mul(mrb, x, y); } @@ -1115,6 +1175,11 @@ int_mod(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); mrb_int a, b; +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_mod(mrb, x, y); + } +#endif a = mrb_integer(x); if (mrb_integer_p(y)) { b = mrb_integer(y); @@ -1151,6 +1216,17 @@ int_divmod(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { +#ifndef MRB_NO_FLOAT + if (mrb_float_p(y)) { + mrb_float f = mrb_bint_as_float(mrb, x); + return flo_divmod(mrb, mrb_float_value(mrb, f)); + } +#endif + return mrb_bint_divmod(mrb, x, y); + } +#endif if (mrb_integer_p(y)) { mrb_int div, mod; @@ -1206,6 +1282,10 @@ int_equal(mrb_state *mrb, mrb_value x) case MRB_TT_FLOAT: return mrb_bool_value((mrb_float)mrb_integer(x) == mrb_float(y)); #endif +#ifdef MRB_USE_BIGINT + case MRB_TT_BIGINT: + return mrb_bool_value(mrb_bint_cmp(mrb, y, x) == 0); +#endif #ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: return mrb_bool_value(mrb_equal(mrb, y, x)); @@ -1235,6 +1315,11 @@ int_rev(mrb_state *mrb, mrb_value num) { mrb_int val = mrb_integer(num); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(num)) { + mrb_bint_rev(mrb, num); + } +#endif return mrb_int_value(mrb, ~val); } @@ -1265,6 +1350,11 @@ int_and(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_and(mrb, x, y); + } +#endif bit_op(x, y, and, &); } @@ -1281,6 +1371,11 @@ int_or(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_or(mrb, x, y); + } +#endif bit_op(x, y, or, |); } @@ -1297,6 +1392,11 @@ int_xor(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_xor(mrb, x, y); + } +#endif bit_op(x, y, or, ^); } @@ -1355,10 +1455,20 @@ int_lshift(mrb_state *mrb, mrb_value x) if (width == 0) { return x; } + if (width == MRB_INT_MIN) mrb_int_overflow(mrb, "bit shift"); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_lshift(mrb, x, width); + } +#endif val = mrb_integer(x); if (val == 0) return x; if (!mrb_num_shift(mrb, val, width, &val)) { +#ifdef MRB_USE_BIGINT + return mrb_bint_lshift(mrb, mrb_bint_new_int(mrb, val), width); +#else mrb_int_overflow(mrb, "bit shift"); +#endif } return mrb_int_value(mrb, val); } @@ -1380,11 +1490,20 @@ int_rshift(mrb_state *mrb, mrb_value x) if (width == 0) { return x; } + if (width == MRB_INT_MIN) mrb_int_overflow(mrb, "bit shift"); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_rshift(mrb, x, width); + } +#endif val = mrb_integer(x); if (val == 0) return x; - if (width == MRB_INT_MIN) mrb_int_overflow(mrb, "bit shift"); if (!mrb_num_shift(mrb, val, -width, &val)) { +#ifdef MRB_USE_BIGINT + return mrb_bint_rshift(mrb, mrb_bint_new_int(mrb, val), width); +#else mrb_int_overflow(mrb, "bit shift"); +#endif } return mrb_int_value(mrb, val); } @@ -1402,6 +1521,11 @@ int_rshift(mrb_state *mrb, mrb_value x) static mrb_value int_to_f(mrb_state *mrb, mrb_value num) { +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(num)) { + return mrb_float_value(mrb, mrb_bint_as_float(mrb, num)); + } +#endif return mrb_float_value(mrb, (mrb_float)mrb_integer(num)); } @@ -1454,16 +1578,25 @@ mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y) if (a == 0) return y; b = mrb_integer(y); if (mrb_int_add_overflow(a, b, &c)) { +#ifdef MRB_USE_BIGINT + x = mrb_bint_new_int(mrb, a); + return mrb_bint_add(mrb, x, y); +#else mrb_int_overflow(mrb, "addition"); +#endif } return mrb_int_value(mrb, c); } switch (mrb_type(y)) { -#if defined(MRB_USE_RATIONAL) +#ifdef MRB_USE_BIGINT + case MRB_TT_BIGINT: + return mrb_bint_add(mrb, y, x); +#endif +#ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: return mrb_rational_add(mrb, y, x); #endif -#if defined(MRB_USE_COMPLEX) +#ifdef MRB_USE_COMPLEX case MRB_TT_COMPLEX: return mrb_complex_add(mrb, y, x); #endif @@ -1490,6 +1623,11 @@ int_add(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(self)) { + return mrb_bint_add(mrb, self, other); + } +#endif return mrb_int_add(mrb, self, other); } @@ -1504,16 +1642,25 @@ mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y) b = mrb_integer(y); if (mrb_int_sub_overflow(a, b, &c)) { +#ifdef MRB_USE_BIGINT + x = mrb_bint_new_int(mrb, a); + return mrb_bint_sub(mrb, x, y); +#else mrb_int_overflow(mrb, "subtraction"); +#endif } return mrb_int_value(mrb, c); } switch (mrb_type(y)) { -#if defined(MRB_USE_RATIONAL) +#ifdef MRB_USE_BIGINT + case MRB_TT_BIGINT: + return mrb_bint_sub(mrb, mrb_bint_new_int(mrb, a), y); +#endif +#ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: return mrb_rational_sub(mrb, mrb_rational_new(mrb, a, 1), y); #endif -#if defined(MRB_USE_COMPLEX) +#ifdef MRB_USE_COMPLEX case MRB_TT_COMPLEX: return mrb_complex_sub(mrb, mrb_complex_new(mrb, (mrb_float)a, 0), y); #endif @@ -1541,6 +1688,11 @@ int_sub(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(self)) { + return mrb_bint_sub(mrb, self, other); + } +#endif return mrb_int_sub(mrb, self, other); } @@ -1615,6 +1767,11 @@ int_to_s(mrb_state *mrb, mrb_value self) mrb_int base = 10; mrb_get_args(mrb, "|i", &base); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(self)) { + return mrb_bint_to_s(mrb, self, base); + } +#endif return mrb_integer_to_str(mrb, self, base); } @@ -1622,6 +1779,12 @@ int_to_s(mrb_state *mrb, mrb_value self) static mrb_int cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) { +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(v2)) { + return mrb_bint_cmp(mrb, v1, v2); + } +#endif + #ifdef MRB_NO_FLOAT mrb_int x, y; #else diff --git a/src/numops.c b/src/numops.c index 6bfe508e2..ff8adc2d6 100644 --- a/src/numops.c +++ b/src/numops.c @@ -12,6 +12,11 @@ MRB_API mrb_value mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y) { +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_add(mrb, x, y); + } +#endif if (mrb_integer_p(x)) { return mrb_int_add(mrb, x, y); } @@ -41,6 +46,11 @@ mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y) MRB_API mrb_value mrb_num_sub(mrb_state *mrb, mrb_value x, mrb_value y) { +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_sub(mrb, x, y); + } +#endif if (mrb_integer_p(x)) { return mrb_int_sub(mrb, x, y); } @@ -70,6 +80,11 @@ mrb_num_sub(mrb_state *mrb, mrb_value x, mrb_value y) MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) { +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_mul(mrb, x, y); + } +#endif if (mrb_integer_p(x)) { return mrb_int_mul(mrb, x, y); } diff --git a/src/object.c b/src/object.c index b430f2057..d03bfcfea 100644 --- a/src/object.c +++ b/src/object.c @@ -9,6 +9,7 @@ #include #include #include +#include #include MRB_API mrb_bool @@ -547,6 +548,11 @@ mrb_ensure_float_type(mrb_state *mrb, mrb_value val) return mrb_complex_to_f(mrb, val); #endif +#ifdef MRB_USE_BIGINT + case MRB_TT_BIGINT: + return mrb_float_value(mrb, mrb_bint_as_float(mrb, val)); +#endif + default: mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Float", val); /* not reached */ diff --git a/src/string.c b/src/string.c index 0273f74e3..2ab45e289 100644 --- a/src/string.c +++ b/src/string.c @@ -2150,11 +2150,24 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) return result; } +static mrb_bool +trailingbad(const char *str, const char *p, const char *pend) +{ + if (p == str) return TRUE; /* no number */ + if (*(p - 1) == '_') return TRUE; /* trailing '_' */ + while (p= base) break; + p3++; + } + if (badcheck && trailingbad(str, p, pend)) goto bad; + return mrb_bint_new_str(mrb, p2, (mrb_int)(p3-p2), sign ? base : -base); +#endif mrb_raisef(mrb, E_RANGE_ERROR, "string (%l) too big for integer", str, pend-str); } n += c; } val = (mrb_int)n; - if (badcheck) { - if (p == str) goto bad; /* no number */ - if (*(p - 1) == '_') goto bad; /* trailing '_' */ - while (p Date: Fri, 8 Apr 2022 07:45:52 +0900 Subject: [PATCH 198/292] load.c: should not skip bigint literal length. --- src/load.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/load.c b/src/load.c index b02650b98..ee8d1f223 100644 --- a/src/load.c +++ b/src/load.c @@ -164,9 +164,8 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, const uint8_t *end, size_ case IREP_TT_BIGINT: pool_data_len = bin_to_uint8(src); /* pool data length */ - src += sizeof(uint8_t); if (src + pool_data_len > end) return FALSE; - { + { char *p; pool[i].tt = IREP_TT_BIGINT; p = (char*)mrb_malloc(mrb, pool_data_len+2); From f33537f4fd5ddc730789f4456a37d5295c606d90 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 8 Apr 2022 15:42:11 +0900 Subject: [PATCH 199/292] dump.c: fix a bug in dump data size of BIGINT pool. Was dumping extra NUL (\0) after the data. --- src/dump.c | 2 -- src/load.c | 10 +++++----- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/dump.c b/src/dump.c index 3841e12ac..97acf1024 100644 --- a/src/dump.c +++ b/src/dump.c @@ -131,7 +131,6 @@ get_pool_block_size(mrb_state *mrb, const mrb_irep *irep) { mrb_int len = irep->pool[pool_no].u.str[0]; mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX); - size += sizeof(uint8_t); size += (size_t)len+2; } break; @@ -199,7 +198,6 @@ write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) len = irep->pool[pool_no].u.str[0]; memcpy(cur, irep->pool[pool_no].u.str, (size_t)len+2); cur += len+2; - *cur++ = '\0'; break; case IREP_TT_FLOAT: diff --git a/src/load.c b/src/load.c index ee8d1f223..1916c6c9d 100644 --- a/src/load.c +++ b/src/load.c @@ -163,16 +163,16 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, const uint8_t *end, size_ #endif case IREP_TT_BIGINT: - pool_data_len = bin_to_uint8(src); /* pool data length */ + pool_data_len = bin_to_uint8(src) + 2; /* pool data length */ if (src + pool_data_len > end) return FALSE; - { + else { char *p; pool[i].tt = IREP_TT_BIGINT; - p = (char*)mrb_malloc(mrb, pool_data_len+2); - memcpy(p, src, pool_data_len+2); + p = (char*)mrb_malloc(mrb, pool_data_len); + memcpy(p, src, pool_data_len); pool[i].u.str = (const char*)p; } - src += pool_data_len + 2; + src += pool_data_len; break; case IREP_TT_FLOAT: From 55b526167b2d52d113f013b6f0c14ff9aa64c1a1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 8 Apr 2022 16:12:21 +0900 Subject: [PATCH 200/292] test/bigint.rb: add test for multi-precision integers. --- mrbgems/mruby-bigint/test/bigint.rb | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 mrbgems/mruby-bigint/test/bigint.rb diff --git a/mrbgems/mruby-bigint/test/bigint.rb b/mrbgems/mruby-bigint/test/bigint.rb new file mode 100644 index 000000000..8ab09548e --- /dev/null +++ b/mrbgems/mruby-bigint/test/bigint.rb @@ -0,0 +1,23 @@ +assert 'Bigint basic' do + n = 1<<65 + assert_equal 36893488147419103232, n + assert_equal 36893488147419104229, n+997 + assert_equal 36893488147419102235, n-997 + assert_equal 36782807682976845922304, n*997 + assert_equal 37004501652376231, n.div(997) +end + +assert 'Bigint to_s' do + n = 1197857166996989179607278372168909873645893814254642585755536286462800958278984531968 + assert_equal n, "11978_571669_96989179607278372168909873645893814254642585755536286462800958278984531968".to_i + assert_equal(-n, "-11978_571669_96989179607278372168909873645893814254642585755536286462800958278984531968".to_i) + n = 0x1197857166996989179607278372168909873645893814254642585755536286462800958278984531968 + assert_equal n, "1197857166996989179607278372168909873645893814254642585755536286462800958278984531968".to_i(16) +end + +assert 'Bigint pow' do + n = 18446744073709551616 + assert_equal n, 2 ** 64 + assert_equal n, 1 << 64 + assert_equal 2, n >> 63 +end From c8c083cb750606b2da81582cd8e43b442bb143e6 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 8 Apr 2022 17:51:13 +0900 Subject: [PATCH 201/292] codegen.c: need to pack argument when `n==13` too. Because we have extra 2 arguments coming (kw and rhs). --- mrbgems/mruby-compiler/core/codegen.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 8f7b5b013..e222094be 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -1905,7 +1905,7 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) } } if (tree->cdr->car) { /* keyword arguments */ - if (n == 14) { + if (n == 13 || n == 14) { pop_n(n); genop_2(s, OP_ARRAY, cursp(), n); push(); From c30e6ebe1200962d37751255ca489defd96819d6 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 9 Apr 2022 09:22:39 +0900 Subject: [PATCH 202/292] gc.c: add red (persistent no scan) color in the comment [ci skip] --- src/gc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gc.c b/src/gc.c index 99fc5e40b..886ccfdf9 100644 --- a/src/gc.c +++ b/src/gc.c @@ -193,7 +193,7 @@ gettimeofday_time(void) #define GC_STEP_SIZE 1024 -/* white: 001 or 010, black: 100, gray: 000 */ +/* white: 001 or 010, black: 100, gray: 000, red:111 */ #define GC_GRAY 0 #define GC_WHITE_A 1 #define GC_WHITE_B (1 << 1) From b1d0296a937fe278239bdfac840a3fd0e93b3ee9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 9 Apr 2022 09:25:35 +0900 Subject: [PATCH 203/292] class.c: clear method cache after `remove_method`. --- src/class.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/class.c b/src/class.c index 37fc4e68a..68a0ff084 100644 --- a/src/class.c +++ b/src/class.c @@ -2361,7 +2361,10 @@ mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym mid) MRB_CLASS_ORIGIN(c); h = c->mt; - if (h && mt_del(mrb, h, mid)) return; + if (h && mt_del(mrb, h, mid)) { + mrb_mc_clear_by_class(mrb, c); + return; + } mrb_name_error(mrb, mid, "method '%n' not defined in %C", mid, c); } From 88e0c64ffc158a91a4d68a68b96e3df3260ab1b3 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 9 Apr 2022 09:26:39 +0900 Subject: [PATCH 204/292] class.c: fix bugs in inline method cache. --- src/class.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/class.c b/src/class.c index 68a0ff084..214aa0204 100644 --- a/src/class.c +++ b/src/class.c @@ -151,9 +151,11 @@ mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym, union mt_ptr *pp) hash = kh_int_hash_func(mrb, sym); #ifdef MRB_USE_INLINE_METHOD_CACHE int cpos = (hash^(uintptr_t)t) % MT_CACHE_SIZE; + mrb_sym key; pos = mt_cache[cpos]; - if (cpos < t->alloc && t->table[cpos].key == sym) { - return &t->table[cpos]; + if (cpos < t->alloc && key = keys[pos] && MT_KEY_SYM(key) == sym) { + *pp = vals[pos]; + return key; } #endif start = pos = hash & (t->alloc-1); @@ -162,7 +164,7 @@ mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym, union mt_ptr *pp) if (MT_KEY_SYM(key) == sym) { *pp = vals[pos]; #ifdef MRB_USE_INLINE_METHOD_CACHE - if (pos < 0xff) { + if (pos < 0x100) { mt_cache[cpos] = pos; } #endif From bbf4423f4cb8c32c8a1501da456bbb11df7960d4 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 9 Apr 2022 18:21:45 +0900 Subject: [PATCH 205/292] bigint.c: `y->sz > 2` can be fit in `mrb_int`. --- src/bigint.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/bigint.c b/src/bigint.c index 136c0c78b..c02fbca3d 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -28,9 +28,8 @@ mpz_init(mrb_state *mrb, mpz_t *s) static void mpz_init_set(mrb_state *mrb, mpz_t *s, mpz_t *t) { - int i; s->p = (mp_limb*)mrb_malloc(mrb, sizeof(mp_limb) * t->sz); - for (i=0;i < t->sz ; i++) + for (size_t i=0;i < t->sz ; i++) (s->p)[i] = (t->p)[i]; s->sn = t->sn; @@ -728,7 +727,7 @@ mpz_get_int(mpz_t *y, mrb_int *v) if (y->sn == 0) { i = 0; } - else if (y->sz > 2 || y->p[1] > 1) { + else if (digits(y) > 2 || y->p[1] > 1) { return FALSE; } else { From 4260ce83a93763f39823bf34918bee660ea8409f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 9 Apr 2022 23:43:03 +0900 Subject: [PATCH 206/292] vm.c: avoid bare macro constant reference. wrap it by defined(). --- src/vm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/vm.c b/src/vm.c index 5f2ef779a..315eb75ca 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2384,7 +2384,7 @@ RETRY_TRY_BLOCK: NEXT; } -#if !defined(MRB_USE_BIGINT) || (defined(MRB_INT32) && MRB_32BIT) +#if !defined(MRB_USE_BIGINT) || (defined(MRB_INT32) && defined(MRB_32BIT)) L_INT_OVERFLOW: { mrb_value exc = mrb_exc_new_lit(mrb, E_RANGE_ERROR, "integer overflow"); From b22044fca6e738864b9ee3ceeafbd97c3dc72655 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 10 Apr 2022 17:36:03 +0900 Subject: [PATCH 207/292] vm.c: cipush() to take `uint16_t` argc. --- src/vm.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/vm.c b/src/vm.c index 315eb75ca..80e929c04 100644 --- a/src/vm.c +++ b/src/vm.c @@ -246,7 +246,7 @@ top_proc(mrb_state *mrb, const struct RProc *proc) static inline mrb_callinfo* cipush(mrb_state *mrb, mrb_int push_stacks, uint8_t cci, - struct RClass *target_class, const struct RProc *proc, mrb_sym mid, uint8_t argc) + struct RClass *target_class, const struct RProc *proc, mrb_sym mid, uint16_t argc) { struct mrb_context *c = mrb->c; mrb_callinfo *ci = c->ci; @@ -535,7 +535,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc argc = (mrb_int)ac; mid = MRB_SYM(method_missing); } - ci = cipush(mrb, n, 0, c, NULL, mid, argc); + ci = cipush(mrb, n, 0, c, NULL, mid, (uint16_t)argc); if (MRB_METHOD_PROC_P(m)) { struct RProc *p = MRB_METHOD_PROC(m); From b3420faafd824268a1323ddd5ca1f9520f70c07d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 10 Apr 2022 19:02:17 +0900 Subject: [PATCH 208/292] class.c: use `mrb_ssize` to keep the array length. --- src/class.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/class.c b/src/class.c index 214aa0204..07399fe7d 100644 --- a/src/class.c +++ b/src/class.c @@ -936,7 +936,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) int i = 0; va_list ap; mrb_callinfo *ci = mrb->c->ci; - int argc = ci->n; + mrb_ssize argc = ci->n; const mrb_value *argv = ci->stack+1; mrb_bool argv_on_stack; mrb_bool opt = FALSE; @@ -944,7 +944,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) const mrb_value *pickarg = NULL; /* arguments currently being processed */ mrb_value kdict = mrb_nil_value(); mrb_bool reqkarg = FALSE; - int argc_min = 0, argc_max = 0; + mrb_ssize argc_min = 0, argc_max = 0; va_start(ap, format); From 17a31efa8a4d60be9bc849513179c7de20117619 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 10 Apr 2022 19:03:01 +0900 Subject: [PATCH 209/292] vm.c: adjust size of int types. --- src/vm.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/vm.c b/src/vm.c index 80e929c04..ca8791377 100644 --- a/src/vm.c +++ b/src/vm.c @@ -597,7 +597,7 @@ static mrb_value exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p) { mrb_callinfo *ci = mrb->c->ci; - int keep, nregs; + mrb_int keep, nregs; ci->stack[0] = self; mrb_vm_ci_proc_set(ci, p); @@ -640,7 +640,7 @@ mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p) cipop(mrb); } else { - int keep = mrb_ci_bidx(ci) + 1; /* receiver + block */ + mrb_int keep = mrb_ci_bidx(ci) + 1; /* receiver + block */ ret = mrb_top_run(mrb, p, self, keep); } if (mrb->exc && mrb->jmp) { @@ -857,7 +857,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value n = 3; } else { - ci->n = argc; + ci->n = (uint8_t)argc; n = argc + 2; } mrb_stack_extend(mrb, n); @@ -2012,7 +2012,7 @@ RETRY_TRY_BLOCK: } /* format arguments for generated code */ - mrb->c->ci->n = len; + mrb->c->ci->n = (uint8_t)len; /* clear local (but non-argument) variables */ if (irep->nlocals-blk_pos-1 > 0) { From e14782e8a1dbf52dbb2c6be7d4a81ca49fa4dc90 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 10 Apr 2022 19:03:37 +0900 Subject: [PATCH 210/292] vm.c: fixed wrong compilation condition for `MRB_INT32`. --- src/vm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/vm.c b/src/vm.c index ca8791377..9538efd81 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2384,7 +2384,7 @@ RETRY_TRY_BLOCK: NEXT; } -#if !defined(MRB_USE_BIGINT) || (defined(MRB_INT32) && defined(MRB_32BIT)) +#if !defined(MRB_USE_BIGINT) || defined(MRB_INT32) L_INT_OVERFLOW: { mrb_value exc = mrb_exc_new_lit(mrb, E_RANGE_ERROR, "integer overflow"); From 2f832f4479078f2dc824604df362aa9ae30bc6dd Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 10 Apr 2022 19:04:20 +0900 Subject: [PATCH 211/292] bigint.c: fix infinite loop bugs. --- src/bigint.c | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/src/bigint.c b/src/bigint.c index c02fbca3d..c6715ca06 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -106,9 +106,9 @@ mpz_realloc(mrb_state *mrb, mpz_t *x, size_t size) static size_t digits(mpz_t *x) { - int i; - for (i = (x->sz) - 1; i>=0 && (x->p)[i] == 0 ; i--) - ; + size_t i; + for (i = (x->sz) - 1; (x->p)[i] == 0 ; i--) + if (i == 0) break; return i+1; } @@ -194,12 +194,13 @@ usub(mrb_state *mrb, mpz_t *z, mpz_t *y, mpz_t *x) static int ucmp(mpz_t *y, mpz_t *x) { - int i; - for (i=imax(x->sz,y->sz)-1;i>=0;i--) { + size_t i; + for (i=imax(x->sz,y->sz)-1;;i--) { if (dg(y,i) < dg(x,i)) return (-1); else if (dg(y,i) > dg(x,i)) return 1; + if (i == 0) break; } return 0; } @@ -348,7 +349,7 @@ mpz_mul_int(mrb_state *mrb, mpz_t *x, mpz_t *y, mrb_int n) static int lzb(mp_limb a) { - mp_limb i; size_t j=0; + mp_limb i; int j=0; for (i = ((mp_limb)1 << (DIGITBITS-1)); i && !(a&i) ; j++,i>>=1) ; @@ -406,7 +407,8 @@ static void udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) { mpz_t q, x, y, r; - int ns,f,xd,yd,i,j,ccc=0; + int ns,f,ccc=0; + size_t xd,yd,i, j; mp_limb zz,z,qhat,b,u,m; if (uzero(yy)) @@ -421,7 +423,7 @@ udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) mpz_realloc(mrb,&q,(size_t)xd); xd*=2; yd*=2; z = hd(&y,yd-1); - for (j=(xd-yd);j>=0;j--) { + for (j=(xd-yd);;j--) { if (z == LMAX) qhat = hd(&x,j+yd); else { @@ -429,7 +431,7 @@ udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) } b = 0; zz=0; if (qhat) { - for (i=0; i < yd; i++) { + for (i=0; i=0; i--) { + for (i=yd-1; ; i--) { if (hd(&x,j+i) > hd(&y,i)) { f=1; break; @@ -469,6 +471,7 @@ udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) break; } } + if (i == 0) break; } if (!f) break; @@ -499,6 +502,7 @@ udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) q.p[j/2] |= qhat << HALFDIGITBITS; else q.p[j/2] |= qhat; + if (j == 0) break; } mpz_realloc(mrb,&r,(size_t)(yy->sz)); zero(&r); @@ -624,7 +628,7 @@ mpz_sizeinbase(mpz_t *x, int base) int i,j; int bits = digits(x) * DIGITBITS; mrb_assert(2 <= base && base <= 36); - for (j=0,i=1; i<=base;i*=2,j++) + for (j=0,i=1; i<=base; i*=2,j++) ; return ((bits)/(j-1)+1); } @@ -632,7 +636,7 @@ mpz_sizeinbase(mpz_t *x, int base) static int mpz_init_set_str(mrb_state *mrb, mpz_t *x, const char *s, mrb_int len, mrb_int base) { - mrb_int i; + size_t i; mrb_int retval = 0; mpz_t t,m,bb; short sn; @@ -650,7 +654,7 @@ mpz_init_set_str(mrb_state *mrb, mpz_t *x, const char *s, mrb_int len, mrb_int b else sn = 1; mpz_init_set_int(mrb,&bb, base); - for (i = len-1; i>=0; i--) { + for (i = len-1;; i--) { if (s[i]=='_') continue; if (s[i] >= '0' && s[i] <= '9') k = (unsigned int)s[i] - (unsigned int)'0'; @@ -669,6 +673,7 @@ mpz_init_set_str(mrb_state *mrb, mpz_t *x, const char *s, mrb_int len, mrb_int b mpz_mul_int(mrb,&t,&m,(mrb_int)k); mpz_add(mrb,x,x,&t); mpz_mul(mrb,&m,&m,&bb); + if (i == 0) break; } if (x->sn) x->sn = sn; @@ -912,7 +917,7 @@ mpz_powm(mrb_state *mrb, mpz_t *zz, mpz_t *x, mrb_int ex, mpz_t *n) { mpz_t t, e; struct is *stack = NULL; - int k,i; + size_t k,i; if (ex == 0) { mpz_set_int(mrb,zz,1); @@ -933,13 +938,14 @@ mpz_powm(mrb_state *mrb, mpz_t *zz, mpz_t *x, mrb_int ex, mpz_t *n) mpz_mod(mrb,&t,x,n); /* t=x%n */ - for (i=k-1;i>=0;i--) { + for (i=k-1;;i--) { mpz_mul(mrb,&t,&t,&t); mpz_mod(mrb,&t,&t,n); if (pop(mrb,&stack)) { mpz_mul(mrb,&t,&t,x); mpz_mod(mrb,&t,&t,n); } + if (i == 0) break; } mpz_set(mrb,zz,&t); mpz_clear(mrb,&t); From dda1626105cbc7ce874828a02795275540a61aa9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 10 Apr 2022 19:55:22 +0900 Subject: [PATCH 212/292] bigint.c: wrong position of `break` statement. --- src/bigint.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bigint.c b/src/bigint.c index c6715ca06..c8b789f0e 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -470,8 +470,8 @@ udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) f=0; break; } + if (i == 0) break; } - if (i == 0) break; } if (!f) break; From 676e9bcf8112e91645a1e7b34fada11118c3644a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 10 Apr 2022 19:55:45 +0900 Subject: [PATCH 213/292] bigint.h: use `LL` suffix for bigger integer literals. --- include/mruby/bigint.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/include/mruby/bigint.h b/include/mruby/bigint.h index 142a11d30..364900ce9 100644 --- a/include/mruby/bigint.h +++ b/include/mruby/bigint.h @@ -51,14 +51,14 @@ typedef int32_t mp_limb; #else /* 64 bit long type */ typedef int64_t mp_limb; -#define LMAX 0x3fffffffffffffffL -#define LC 0xc000000000000000L +#define LMAX 0x3fffffffffffffffLL +#define LC 0xc000000000000000LL #define OVMASK 0x2 #define CMASK (LMAX+1) -#define HLMAX 0x7fffffffL +#define HLMAX 0x7fffffffLL #define HCMASK (HLMAX + 1) -#define HIGH(x) (((x) & 0x3fffffff80000000L) >> 31) -#define LOW(x) ((x) & 0x7fffffffL) +#define HIGH(x) (((x) & 0x3fffffff80000000LL) >> 31) +#define LOW(x) ((x) & 0x7fffffffLL) #endif typedef struct _mpz_t { From ef5ae084d759fb829a9b19432d3348f652a09bfa Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 10 Apr 2022 21:36:59 +0900 Subject: [PATCH 214/292] Must the `mrb_sys_fail()` function raise an exception Normal return of control from the `mrb_sys_fail()` function has unexpected results. Example: double free, malloc with huge size used as error integer The following is an example of an actual crash: ```console % cat crash.rb def SystemCallError._sys_fail(*a) nil end File.readlink("/404") % bin/mruby crash.rb zsh: segmentation fault (core dumped) bin/mruby crash.rb ``` --- include/mruby/error.h | 2 +- src/error.c | 7 +++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/include/mruby/error.h b/include/mruby/error.h index 752baae84..225234a77 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -23,7 +23,7 @@ struct RException { #define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v)) #define MRB_EXC_MESG_STRING_FLAG 0x100 -MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg); +MRB_API mrb_noreturn void mrb_sys_fail(mrb_state *mrb, const char *mesg); MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str); #define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit)) MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv); diff --git a/src/error.c b/src/error.c index 2c2f709b1..643279bd4 100644 --- a/src/error.c +++ b/src/error.c @@ -521,7 +521,7 @@ exception_call: return mesg; } -MRB_API void +MRB_API mrb_noreturn void mrb_sys_fail(mrb_state *mrb, const char *mesg) { struct RClass *sce; @@ -537,9 +537,8 @@ mrb_sys_fail(mrb_state *mrb, const char *mesg) mrb_funcall_id(mrb, mrb_obj_value(sce), MRB_SYM(_sys_fail), 1, mrb_fixnum_value(no)); } } - else { - mrb_raise(mrb, E_RUNTIME_ERROR, mesg); - } + + mrb_raise(mrb, E_RUNTIME_ERROR, mesg); } MRB_API mrb_noreturn void From bafca84c54de98fde7ce8ee400e9a7398cc4d3c7 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 11 Apr 2022 11:00:49 +0900 Subject: [PATCH 215/292] dump.c: should dump INT64 with MRB_32BIT. --- src/dump.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dump.c b/src/dump.c index 97acf1024..c0ad4b689 100644 --- a/src/dump.c +++ b/src/dump.c @@ -110,7 +110,7 @@ get_pool_block_size(mrb_state *mrb, const mrb_irep *irep) switch (irep->pool[pool_no].tt) { case IREP_TT_INT64: -#ifdef MRB_64BIT +#if defined(MRB_64BIT) || defined(MRB_INT64) { int64_t i = irep->pool[pool_no].u.i64; @@ -172,8 +172,8 @@ write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) int ai = mrb_gc_arena_save(mrb); switch (irep->pool[pool_no].tt) { -#ifdef MRB_64BIT case IREP_TT_INT64: +#if defined(MRB_64BIT) || defined(MRB_INT64) { int64_t i = irep->pool[pool_no].u.i64; if (i < INT32_MIN || INT32_MAX < i) { From 30f6669d09600ca04d133c06ec1a75579a9377e1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 11 Apr 2022 11:03:08 +0900 Subject: [PATCH 216/292] bigint.h: use `int64_t` as `mp_limb` if `MRB_INT64` is set. --- include/mruby/bigint.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mruby/bigint.h b/include/mruby/bigint.h index 364900ce9..643bc1204 100644 --- a/include/mruby/bigint.h +++ b/include/mruby/bigint.h @@ -31,7 +31,7 @@ #include -#ifdef MRB_32BIT +#if !(defined(MRB_64BIT) || defined(MRB_INT64)) /* * The values below are for 32 bit machines (i.e. machines with a * 32 bit long type) From f63f57391fdcb809ccb46d6f81d25d1f3da584b2 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 11 Apr 2022 11:04:22 +0900 Subject: [PATCH 217/292] bigint.c: fix bugs caused by integer size variety. --- include/mruby/bigint.h | 2 ++ src/bigint.c | 25 +++++++++++++------------ 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/include/mruby/bigint.h b/include/mruby/bigint.h index 643bc1204..876d370a6 100644 --- a/include/mruby/bigint.h +++ b/include/mruby/bigint.h @@ -39,6 +39,7 @@ * If DIGITBITS is odd, see the comment at the top of mpz_sqrtrem */ typedef int32_t mp_limb; +typedef uint32_t mp_ulimb; #define LMAX 0x3fffffffL #define LC 0xc0000000L #define OVMASK 0x2 @@ -51,6 +52,7 @@ typedef int32_t mp_limb; #else /* 64 bit long type */ typedef int64_t mp_limb; +typedef uint64_t mp_ulimb; #define LMAX 0x3fffffffffffffffLL #define LC 0xc000000000000000LL #define OVMASK 0x2 diff --git a/src/bigint.c b/src/bigint.c index c8b789f0e..f204f0346 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -62,7 +62,7 @@ mpz_set_int(mrb_state *mrb, mpz_t *y, long v) static void mpz_init_set_int(mrb_state *mrb, mpz_t *y, mrb_int v) { - size_t u; + mp_limb u; y->p = (mp_limb*)mrb_malloc(mrb, sizeof(mp_limb)*2); if (v < 0) { @@ -390,10 +390,10 @@ ulshift(mrb_state *mrb, mpz_t *c1, mpz_t *a, int n) mpz_set(mrb,c1,a); else { mpz_t c; size_t i; - mp_limb rm = (((mp_limb)1<sz + 1)); for (i=0; isz; i++) { - c.p[i] = (((mrb_uint)a->p[i] << n) | cc) & LMAX; + c.p[i] = (((mp_limb)a->p[i] << n) | cc) & LMAX; cc = (a->p[i] & rm) >> (DIGITBITS -n); } c.p[i] = cc; @@ -408,7 +408,7 @@ udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) { mpz_t q, x, y, r; int ns,f,ccc=0; - size_t xd,yd,i, j; + size_t xd,yd,i,j; mp_limb zz,z,qhat,b,u,m; if (uzero(yy)) @@ -514,7 +514,7 @@ udiv(mrb_state *mrb, mpz_t *qq, mpz_t *rr, mpz_t *xx, mpz_t *yy) } static void -mpz_mdiv(mrb_state *mrb, mpz_t *q, mpz_t *x, mpz_t *y) +mpz_mdiv(mrb_state *mrb, mpz_t *q, mpz_t *x, mpz_t *y) { mpz_t r; short sn1 = x->sn, sn2 = y->sn, qsign; @@ -727,7 +727,7 @@ mpz_get_str(mrb_state *mrb, char *s, int sz, int base, mpz_t *x) static int mpz_get_int(mpz_t *y, mrb_int *v) { - mrb_int i; + mp_limb i; if (y->sn == 0) { i = 0; @@ -737,6 +737,7 @@ mpz_get_int(mpz_t *y, mrb_int *v) } else { i = (y->sn * (y->p[0] | (y->p[1] & 1) << DIGITBITS)); + if (MRB_INT_MAX < i || i < MRB_INT_MIN) return FALSE; } *v = i; return TRUE; @@ -859,7 +860,7 @@ static void mpz_pow(mrb_state *mrb, mpz_t *zz, mpz_t *x, mrb_int e) { mpz_t t; - size_t mask = (1UL<< (LONGBITS-1)); + mp_ulimb mask = (((mp_ulimb)1)<< (LONGBITS-1)); if (e==0) { mpz_set_int(mrb, zz, 1L); @@ -1132,7 +1133,7 @@ mrb_bint_add_ii(mrb_state *mrb, mrb_int x, mrb_int y) mpz_add(mrb,&b->mp,&z1,&z2); mpz_clear(mrb,&z1); mpz_clear(mrb,&z2); - return mrb_obj_value(b); + return bint_norm(mrb, b); } mrb_value @@ -1146,7 +1147,7 @@ mrb_bint_sub_ii(mrb_state *mrb, mrb_int x, mrb_int y) mpz_sub(mrb,&b->mp,&z1,&z2); mpz_clear(mrb,&z1); mpz_clear(mrb,&z2); - return mrb_obj_value(b); + return bint_norm(mrb, b); } mrb_value @@ -1160,7 +1161,7 @@ mrb_bint_mul_ii(mrb_state *mrb, mrb_int x, mrb_int y) mpz_mul(mrb,&b->mp,&z1,&z2); mpz_clear(mrb,&z1); mpz_clear(mrb,&z2); - return mrb_obj_value(b); + return bint_norm(mrb, b); } mrb_value @@ -1174,7 +1175,7 @@ mrb_bint_div_ii(mrb_state *mrb, mrb_int x, mrb_int y) mpz_mdiv(mrb,&b->mp,&z1,&z2); mpz_clear(mrb,&z1); mpz_clear(mrb,&z2); - return mrb_obj_value(b); + return bint_norm(mrb, b); } mrb_value @@ -1392,7 +1393,7 @@ mrb_bint_lshift(mrb_state *mrb, mrb_value x, mrb_int width) else { mpz_mul_2exp(mrb, &b2->mp, &b->mp, width); } - return mrb_obj_value(b2); + return bint_norm(mrb, b2); } mrb_value From 0ec5c3e4931e96e92d1b6be74f005354d8cbc50d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 11 Apr 2022 11:12:47 +0900 Subject: [PATCH 218/292] bigint.c (mrb_bint_cmp): avoid object allocation for comparison. --- src/bigint.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/bigint.c b/src/bigint.c index f204f0346..9179ffbd4 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -1243,11 +1243,19 @@ mrb_bint_cmp(mrb_state *mrb, mrb_value x, mrb_value y) return -1; } #endif + struct RBigint *b = RBIGINT(x); if (!mrb_bigint_p(y)) { if (!mrb_integer_p(y)) return -2; /* type mismatch */ - y = mrb_bint_new_int(mrb, mrb_integer(y)); + + mrb_int i1, i2 = mrb_integer(y); + if (mpz_get_int(&b->mp, &i1)) { + if (i1 == i2) return 0; + if (i1 > i2) return 1; + return -1; + } + if (b->mp.sn > 0) return 1; + return -1; } - struct RBigint *b = RBIGINT(x); struct RBigint *b2 = RBIGINT(y); return mpz_cmp(mrb, &b->mp, &b2->mp); } From 0e975c15713317f848032135ee1dee7cad4e4fd0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 11 Apr 2022 19:02:09 +0900 Subject: [PATCH 219/292] bigint.h: simplified the condition. --- include/mruby/bigint.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mruby/bigint.h b/include/mruby/bigint.h index 876d370a6..02f745cc4 100644 --- a/include/mruby/bigint.h +++ b/include/mruby/bigint.h @@ -31,7 +31,7 @@ #include -#if !(defined(MRB_64BIT) || defined(MRB_INT64)) +#if defined(MRB_32BIT) && defined(MRB_INT32) /* * The values below are for 32 bit machines (i.e. machines with a * 32 bit long type) From 2f918f1926cfa4a5864b7e92f0a888a83bed09aa Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 12 Apr 2022 15:05:54 +0900 Subject: [PATCH 220/292] errno.c: fix `int` and `mrb_int` mixture. `strerror(3) takes `int` not `mrb_int`. --- mrbgems/mruby-errno/src/errno.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index d8af9a178..fc27cdf6e 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -36,7 +36,7 @@ static const struct { #define E2C_LEN (sizeof(e2c) / sizeof(e2c[0])) static void -mrb_sce_init(mrb_state *mrb, mrb_value self, mrb_value m, mrb_int n) +mrb_sce_init(mrb_state *mrb, mrb_value self, mrb_value m, int n) { mrb_value str; struct RClass *m_errno; @@ -86,7 +86,7 @@ mrb_sce_init_m(mrb_state *mrb, mrb_value self) n = -1; } } - mrb_sce_init(mrb, self, m, n); + mrb_sce_init(mrb, self, m, (int)n); return self; } @@ -124,7 +124,7 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) msg = mrb_nil_value(); } exc = mrb_obj_value(e); - mrb_sce_init(mrb, exc, msg, no); + mrb_sce_init(mrb, exc, msg, (int)no); mrb_exc_raise(mrb, exc); return mrb_nil_value(); /* NOTREACHED */ } From fef7deabd502f3b379fc2a2b119bb3127147b45a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 12 Apr 2022 20:28:17 +0900 Subject: [PATCH 221/292] doc/mruby3.2.md: add description about multi-precision integers. --- doc/mruby3.2.md | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/mruby3.2.md b/doc/mruby3.2.md index 987f20780..135084f2a 100644 --- a/doc/mruby3.2.md +++ b/doc/mruby3.2.md @@ -4,6 +4,7 @@ * Now `a::B = c` should evaluate `a` then `c`. * Anonymous arguments `*`, `**`, `&` can be passed for forwarding. +* Multi-precition integer is available now via `mruby-bigint` gem. # Tools From 3c96ee704b67ccd0e376f221ad049f02a58d513a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 14 Apr 2022 10:53:58 +0900 Subject: [PATCH 222/292] fiber.c: cast integer to avoid a warning. --- mrbgems/mruby-fiber/src/fiber.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-fiber/src/fiber.c b/mrbgems/mruby-fiber/src/fiber.c index 322ed36ea..4fca6cae0 100644 --- a/mrbgems/mruby-fiber/src/fiber.c +++ b/mrbgems/mruby-fiber/src/fiber.c @@ -224,7 +224,7 @@ fiber_switch(mrb_state *mrb, mrb_value self, mrb_int len, const mrb_value *a, mr *b++ = *a++; } } - c->cibase->n = len; + c->cibase->n = (uint8_t)len; value = c->stbase[0] = MRB_PROC_ENV(c->cibase->proc)->stack[0]; } else { From 15af07562a8aeb8465259b643a1b72da3f4b50b0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 14 Apr 2022 10:54:37 +0900 Subject: [PATCH 223/292] variable.c: use `size_t` to avoid integer type mismatch. --- src/variable.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/variable.c b/src/variable.c index a07412684..598850034 100644 --- a/src/variable.c +++ b/src/variable.c @@ -486,7 +486,7 @@ mrb_value mrb_obj_iv_inspect(mrb_state *mrb, struct RObject *obj) { iv_tbl *t = obj->iv; - int len = iv_size(mrb, t); + size_t len = iv_size(mrb, t); if (len > 0) { const char *cn = mrb_obj_classname(mrb, mrb_obj_value(obj)); From eba74c038edb6ea37deede0789e3c5c9e344de95 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 14 Apr 2022 10:55:00 +0900 Subject: [PATCH 224/292] string.c: avoid a local variable. --- src/string.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/string.c b/src/string.c index 2ab45e289..754a3b5ca 100644 --- a/src/string.c +++ b/src/string.c @@ -1984,10 +1984,9 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str) { mrb_value sub; mrb_int pos; - int argc = mrb_get_args(mrb, "S|i", &sub, &pos); mrb_int len = RSTRING_CHAR_LEN(str); - if (argc == 1) { + if (mrb_get_args(mrb, "S|i", &sub, &pos) == 1) { pos = len; } else { From aa4049e5e6f2a62ef6443532d5fd937bf10cebfc Mon Sep 17 00:00:00 2001 From: John Bampton Date: Fri, 15 Apr 2022 07:06:23 +1000 Subject: [PATCH 225/292] Fix spelling in `doc/mruby3.2.md` --- doc/mruby3.2.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/mruby3.2.md b/doc/mruby3.2.md index 135084f2a..85c3dea30 100644 --- a/doc/mruby3.2.md +++ b/doc/mruby3.2.md @@ -4,7 +4,7 @@ * Now `a::B = c` should evaluate `a` then `c`. * Anonymous arguments `*`, `**`, `&` can be passed for forwarding. -* Multi-precition integer is available now via `mruby-bigint` gem. +* Multi-precision integer is available now via `mruby-bigint` gem. # Tools From 888931c1032cee77c4ff2700a09ea2996e387832 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Fri, 15 Apr 2022 11:32:32 +1000 Subject: [PATCH 226/292] Fix grammar and case of Ruby --- doc/guides/mrbgems.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/guides/mrbgems.md b/doc/guides/mrbgems.md index 64a12cff4..68d0560c2 100644 --- a/doc/guides/mrbgems.md +++ b/doc/guides/mrbgems.md @@ -60,7 +60,7 @@ mrbgem from the core or mgem-list. Note that if more than one git-based gem has the same base name (i.e. the default checkout directory name), it is (now) an error -**UNLESS** they are have the same repository URL, branch name and +**UNLESS** they have the same repository URL, branch name and commit-id (i.e. checksum hash). You can bypass this by explicitly importing your preferred version **first** and setting the `canonical:` option to `true`: @@ -160,7 +160,7 @@ GEM directory. A typical GEM specification could look like this for example: MRuby::Gem::Specification.new('c_and_ruby_extension_example') do |spec| spec.license = 'MIT' spec.author = 'mruby developers' - spec.summary = 'Example mrbgem using C and ruby' + spec.summary = 'Example mrbgem using C and Ruby' end ``` From 2e35a88c7b1de887fea487b896c5c0f4f53ef1d0 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Fri, 15 Apr 2022 12:19:27 +1000 Subject: [PATCH 227/292] Enable markdownlint rule MD010 no-hard-tabs --- .github/linters/.markdown-lint.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/linters/.markdown-lint.yml b/.github/linters/.markdown-lint.yml index a1023acbd..5c6cbec4a 100644 --- a/.github/linters/.markdown-lint.yml +++ b/.github/linters/.markdown-lint.yml @@ -4,9 +4,6 @@ # MD001 heading-increment/header-increment - Heading levels should only increment by one level at a time MD001: false -# MD010 no-hard-tabs - Hard tabs -MD010: false - # MD013 line-length - Line length MD013: false From 1354ad96ec548487bd4952a7a6e6c9a643af433a Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 16 Apr 2022 18:22:32 +0900 Subject: [PATCH 228/292] Avoid creating temporary objects with `new_lit()` in `codegen.c` At the same time, the saving and restoration of unwanted object arenas was removed. In addition, the common code to extend the pool that existed before has been grouped together and newly established as `lit_pool_extend()`. Note that previously the variable `i` was updated at that time, but since it is the same as the value at the end of a `for` statement, it has been omitted. The original catalyst was that `bin/mrbc` with the `MRB_WORD_BOXING` + not `MRB_BOXWORD_NO_FLOAT_TRUNCATE` configuration caused `bin/mrbtest` with the `MRB_NO_BOXING` configuration to fail. Upon investigation, I concluded that avoiding the creation of temporary objects would prevent the truncation of floating point numbers. Therefore, this patch also prevents the `rake test` from failing with the following configuration. ```console % cat test_config.rb bootstrap_mrbc = nil MRuby::Build.new do |conf| conf.toolchain conf.enable_debug conf.enable_test conf.disable_presym conf.defines << %w(MRB_WORD_BOXING) #conf.defines << %w(MRB_WORDBOX_NO_FLOAT_TRUNCATE) gem core: "mruby-bin-mrbc" gem core: "mruby-kernel-ext" bootstrap_mrbc = File.join(conf.build_dir, "bin/mrbc") end MRuby::Build.new("nobox") do |conf| conf.toolchain conf.enable_debug conf.enable_test conf.defines << %(MRB_NO_BOXING) conf.mrbcfile = bootstrap_mrbc gem core: "mruby-kernel-ext" end ``` --- mrbgems/mruby-compiler/core/codegen.c | 222 +++++++++++++------------- 1 file changed, 107 insertions(+), 115 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index e222094be..ed393fc8f 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -989,6 +989,17 @@ pop_n_(codegen_scope *s, int n) #define pop_n(n) pop_n_(s,n) #define cursp() (s->sp) +static mrb_pool_value* +lit_pool_extend(codegen_scope *s) +{ + if (s->irep->plen == s->pcapa) { + s->pcapa *= 2; + s->pool = (mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*s->pcapa); + } + + return &s->pool[s->irep->plen++]; +} + static int new_litbn(codegen_scope *s, const char *p, int base, mrb_bool neg) { @@ -1009,13 +1020,8 @@ new_litbn(codegen_scope *s, const char *p, int base, mrb_bool neg) return i; } - if (s->irep->plen == s->pcapa) { - s->pcapa *= 2; - s->pool = (mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*s->pcapa); - } + pv = lit_pool_extend(s); - pv = &s->pool[s->irep->plen]; - i = s->irep->plen++; { char *buf; pv->tt = IREP_TT_BIGINT; @@ -1031,104 +1037,100 @@ new_litbn(codegen_scope *s, const char *p, int base, mrb_bool neg) } static int -new_lit(codegen_scope *s, mrb_value val) +new_lit_str(codegen_scope *s, const char *str, mrb_int len) { int i; mrb_pool_value *pv; - switch (mrb_type(val)) { - case MRB_TT_STRING: - for (i=0; iirep->plen; i++) { - mrb_int len; - pv = &s->pool[i]; - if (pv->tt & IREP_TT_NFLAG) continue; - len = pv->tt>>2; - if (RSTRING_LEN(val) != len) continue; - if (memcmp(pv->u.str, RSTRING_PTR(val), len) == 0) - return i; - } - break; -#ifndef MRB_NO_FLOAT - case MRB_TT_FLOAT: - for (i=0; iirep->plen; i++) { - mrb_float f1, f2; - pv = &s->pool[i]; - if (pv->tt != IREP_TT_FLOAT) continue; - pv = &s->pool[i]; - f1 = pv->u.f; - f2 = mrb_float(val); - if (f1 == f2 && !signbit(f1) == !signbit(f2)) return i; - } - break; -#endif - case MRB_TT_INTEGER: - for (i=0; iirep->plen; i++) { - mrb_int v = mrb_integer(val); - pv = &s->pool[i]; - if (pv->tt == IREP_TT_INT32) { - if (v == pv->u.i32) return i; - } -#ifdef MRB_64BIT - else if (pv->tt == IREP_TT_INT64) { - if (v == pv->u.i64) return i; - } - continue; -#endif - } - break; - default: - /* should not happen */ - return 0; + for (i=0; iirep->plen; i++) { + pv = &s->pool[i]; + if (pv->tt & IREP_TT_NFLAG) continue; + mrb_int plen = pv->tt>>2; + if (len != plen) continue; + if (memcmp(pv->u.str, str, plen) == 0) + return i; } - if (s->irep->plen == s->pcapa) { - s->pcapa *= 2; - s->pool = (mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*s->pcapa); + pv = lit_pool_extend(s); + + if (mrb_ro_data_p(str)) { + pv->tt = (uint32_t)(len<<2) | IREP_TT_SSTR; + pv->u.str = str; + } + else { + char *p; + pv->tt = (uint32_t)(len<<2) | IREP_TT_STR; + p = (char*)codegen_realloc(s, NULL, len+1); + memcpy(p, str, len); + p[len] = '\0'; + pv->u.str = p; } - pv = &s->pool[s->irep->plen]; - i = s->irep->plen++; - - switch (mrb_type(val)) { - case MRB_TT_STRING: - if (RSTR_NOFREE_P(RSTRING(val))) { - pv->tt = (uint32_t)(RSTRING_LEN(val)<<2) | IREP_TT_SSTR; - pv->u.str = RSTRING_PTR(val); - } - else { - char *p; - mrb_int len = RSTRING_LEN(val); - pv->tt = (uint32_t)(len<<2) | IREP_TT_STR; - p = (char*)codegen_realloc(s, NULL, len+1); - memcpy(p, RSTRING_PTR(val), len); - p[len] = '\0'; - pv->u.str = p; - } - break; - -#ifndef MRB_NO_FLOAT - case MRB_TT_FLOAT: - pv->tt = IREP_TT_FLOAT; - pv->u.f = mrb_float(val); - break; -#endif - case MRB_TT_INTEGER: -#ifdef MRB_INT64 - pv->tt = IREP_TT_INT64; - pv->u.i64 = mrb_integer(val); -#else - pv->tt = IREP_TT_INT32; - pv->u.i32 = mrb_integer(val); -#endif - break; - - default: - /* should not happen */ - break; - } return i; } +static int +new_lit_cstr(codegen_scope *s, const char *str) +{ + return new_lit_str(s, str, (mrb_int)strlen(str)); +} + +static int +new_lit_int(codegen_scope *s, mrb_int num) +{ + int i; + mrb_pool_value *pv; + + for (i=0; iirep->plen; i++) { + pv = &s->pool[i]; + if (pv->tt == IREP_TT_INT32) { + if (num == pv->u.i32) return i; + } +#ifdef MRB_64BIT + else if (pv->tt == IREP_TT_INT64) { + if (num == pv->u.i64) return i; + } + continue; +#endif + } + + pv = lit_pool_extend(s); + +#ifdef MRB_INT64 + pv->tt = IREP_TT_INT64; + pv->u.i64 = num; +#else + pv->tt = IREP_TT_INT32; + pv->u.i32 = num; +#endif + + return i; +} + +#ifndef MRB_NO_FLOAT +static int +new_lit_float(codegen_scope *s, mrb_float num) +{ + int i; + mrb_pool_value *pv; + + for (i=0; iirep->plen; i++) { + mrb_float f; + pv = &s->pool[i]; + if (pv->tt != IREP_TT_FLOAT) continue; + f = pv->u.f; + if (f == num && !signbit(f) == !signbit(num)) return i; + } + + pv = lit_pool_extend(s); + + pv->tt = IREP_TT_FLOAT; + pv->u.f = num; + + return i; +} +#endif + static int new_sym(codegen_scope *s, mrb_sym sym) { @@ -1181,7 +1183,7 @@ gen_int(codegen_scope *s, uint16_t dst, mrb_int i) else if (i <= INT32_MAX) genop_2SS(s, OP_LOADI32, dst, (uint32_t)i); else { int_lit: - genop_2(s, OP_LOADL, dst, new_lit(s, mrb_int_value(s->mrb, i))); + genop_2(s, OP_LOADL, dst, new_lit_int(s, i)); } } @@ -2117,7 +2119,7 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val) static void raise_error(codegen_scope *s, const char *msg) { - int idx = new_lit(s, mrb_str_new_cstr(s->mrb, msg)); + int idx = new_lit_cstr(s, msg); genop_1(s, OP_ERR, idx); } @@ -3293,7 +3295,7 @@ codegen(codegen_scope *s, node *tree, int val) if (val) { char *p = (char*)tree; mrb_float f = mrb_float_read(p, NULL); - int off = new_lit(s, mrb_float_value(s->mrb, f)); + int off = new_lit_float(s, f); genop_2(s, OP_LOADL, cursp(), off); push(); @@ -3310,7 +3312,7 @@ codegen(codegen_scope *s, node *tree, int val) if (val) { char *p = (char*)tree->cdr; mrb_float f = mrb_float_read(p, NULL); - int off = new_lit(s, mrb_float_value(s->mrb, -f)); + int off = new_lit_float(s, -f); genop_2(s, OP_LOADL, cursp(), off); push(); @@ -3360,10 +3362,8 @@ codegen(codegen_scope *s, node *tree, int val) if (val) { char *p = (char*)tree->car; mrb_int len = nint(tree->cdr); - int ai = mrb_gc_arena_save(s->mrb); - int off = new_lit(s, mrb_str_new(s->mrb, p, len)); + int off = new_lit_str(s, p, len); - mrb_gc_arena_restore(s->mrb, ai); genop_2(s, OP_STRING, cursp(), off); push(); } @@ -3414,7 +3414,6 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_DXSTR: { node *n; - int ai = mrb_gc_arena_save(s->mrb); int sym = new_sym(s, MRB_SYM_2(s->mrb, Kernel)); genop_1(s, OP_LOADSELF, cursp()); @@ -3437,7 +3436,6 @@ codegen(codegen_scope *s, node *tree, int val) sym = new_sym(s, MRB_OPSYM_2(s->mrb, tick)); /* ` */ genop_3(s, OP_SEND, cursp(), sym, 1); if (val) push(); - mrb_gc_arena_restore(s->mrb, ai); } break; @@ -3445,8 +3443,7 @@ codegen(codegen_scope *s, node *tree, int val) { char *p = (char*)tree->car; mrb_int len = nint(tree->cdr); - int ai = mrb_gc_arena_save(s->mrb); - int off = new_lit(s, mrb_str_new(s->mrb, p, len)); + int off = new_lit_str(s, p, len); int sym; genop_1(s, OP_LOADSELF, cursp()); @@ -3457,7 +3454,6 @@ codegen(codegen_scope *s, node *tree, int val) sym = new_sym(s, MRB_OPSYM_2(s->mrb, tick)); /* ` */ genop_3(s, OP_SEND, cursp(), sym, 1); if (val) push(); - mrb_gc_arena_restore(s->mrb, ai); } break; @@ -3466,9 +3462,8 @@ codegen(codegen_scope *s, node *tree, int val) char *p1 = (char*)tree->car; char *p2 = (char*)tree->cdr->car; char *p3 = (char*)tree->cdr->cdr; - int ai = mrb_gc_arena_save(s->mrb); int sym = new_sym(s, mrb_intern_lit(s->mrb, REGEXP_CLASS)); - int off = new_lit(s, mrb_str_new_cstr(s->mrb, p1)); + int off = new_lit_cstr(s, p1); int argc = 1; genop_1(s, OP_OCLASS, cursp()); @@ -3478,7 +3473,7 @@ codegen(codegen_scope *s, node *tree, int val) push(); if (p2 || p3) { if (p2) { /* opt */ - off = new_lit(s, mrb_str_new_cstr(s->mrb, p2)); + off = new_lit_cstr(s, p2); genop_2(s, OP_STRING, cursp(), off); } else { @@ -3487,7 +3482,7 @@ codegen(codegen_scope *s, node *tree, int val) push(); argc++; if (p3) { /* enc */ - off = new_lit(s, mrb_str_new(s->mrb, p3, 1)); + off = new_lit_str(s, p3, 1); genop_2(s, OP_STRING, cursp(), off); push(); argc++; @@ -3497,7 +3492,6 @@ codegen(codegen_scope *s, node *tree, int val) pop_n(argc+2); sym = new_sym(s, MRB_SYM_2(s->mrb, compile)); genop_3(s, OP_SEND, cursp(), sym, argc); - mrb_gc_arena_restore(s->mrb, ai); push(); } break; @@ -3505,7 +3499,6 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_DREGX: if (val) { node *n = tree->car; - int ai = mrb_gc_arena_save(s->mrb); int sym = new_sym(s, mrb_intern_lit(s->mrb, REGEXP_CLASS)); int argc = 1; int off; @@ -3526,7 +3519,7 @@ codegen(codegen_scope *s, node *tree, int val) n = tree->cdr->cdr; if (n->car) { /* tail */ p = (char*)n->car; - off = new_lit(s, mrb_str_new_cstr(s->mrb, p)); + off = new_lit_cstr(s, p); codegen(s, tree->car, VAL); genop_2(s, OP_STRING, cursp(), off); pop(); @@ -3535,14 +3528,14 @@ codegen(codegen_scope *s, node *tree, int val) } if (n->cdr->car) { /* opt */ char *p2 = (char*)n->cdr->car; - off = new_lit(s, mrb_str_new_cstr(s->mrb, p2)); + off = new_lit_cstr(s, p2); genop_2(s, OP_STRING, cursp(), off); push(); argc++; } if (n->cdr->cdr) { /* enc */ char *p2 = (char*)n->cdr->cdr; - off = new_lit(s, mrb_str_new_cstr(s->mrb, p2)); + off = new_lit_cstr(s, p2); genop_2(s, OP_STRING, cursp(), off); push(); argc++; @@ -3551,7 +3544,6 @@ codegen(codegen_scope *s, node *tree, int val) pop_n(argc+2); sym = new_sym(s, MRB_SYM_2(s->mrb, compile)); genop_3(s, OP_SEND, cursp(), sym, argc); - mrb_gc_arena_restore(s->mrb, ai); push(); } else { From d1f754cc198e282d020957d758f43ac582488e07 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Sat, 16 Apr 2022 22:35:34 +1000 Subject: [PATCH 229/292] Fix step names in lint workflow --- .github/workflows/lint.yml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index f8f140066..da6bc784a 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -11,14 +11,15 @@ jobs: uses: actions/checkout@v3 - name: Install run: wget -O - -q https://git.io/misspell | sh -s -- -b . - - name: Misspell + - name: Run misspell run: git ls-files --empty-directory | xargs ./misspell -error pre-commit: name: Run pre-commit runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - - name: Check merge conflict + - name: Check Out + uses: actions/checkout@v3 + - name: Install run: | python -m pip install --upgrade pip pip install pre-commit From 76d3ea84582c780b1fa8103540797fef0367f1c2 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 16 Apr 2022 22:23:34 +0900 Subject: [PATCH 230/292] Improvements to `String#each_byte` Each byte value is now retrieved inside the loop. --- mrblib/string.rb | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/mrblib/string.rb b/mrblib/string.rb index 81ddf6784..84e7530c9 100644 --- a/mrblib/string.rb +++ b/mrblib/string.rb @@ -150,10 +150,9 @@ class String # Call the given block for each byte of +self+. def each_byte(&block) return to_enum(:each_byte, &block) unless block - bytes = self.bytes pos = 0 - while pos < bytes.size - block.call(bytes[pos]) + while pos < bytesize + block.call(getbyte(pos)) pos += 1 end self From 790910b50a2ea061c9caa6a68e133924261d28e3 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 15 Apr 2022 22:54:41 +0900 Subject: [PATCH 231/292] codegen.c: genop_3 to take `uint16_t` instead of `uint8_t`. --- mrbgems/mruby-compiler/core/codegen.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index ed393fc8f..2357af9d2 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -287,10 +287,10 @@ genop_2(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b) } static void -genop_3(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b, uint8_t c) +genop_3(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b, uint16_t c) { genop_2(s, i, a, b); - gen_B(s, c); + gen_B(s, (uint8_t)c); } static void From c0ef940c9060fed770cbe8388e601f911d393d49 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 16 Apr 2022 09:31:35 +0900 Subject: [PATCH 232/292] numeric.c: add boundary checks in `Float#to_f`. - check_num_exact() before rounding the float value - check integer (mrb_int) overflow. --- src/numeric.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/numeric.c b/src/numeric.c index aa6550d7a..e33f1bed7 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1011,10 +1011,14 @@ flo_to_i(mrb_state *mrb, mrb_value num) { mrb_float f = mrb_float(num); + mrb_check_num_exact(mrb, f); + + if (!FIXABLE_FLOAT(f)) { + mrb_int_overflow(mrb, "to_f"); + } if (f > 0.0) f = floor(f); if (f < 0.0) f = ceil(f); - mrb_check_num_exact(mrb, f); return mrb_int_value(mrb, (mrb_int)f); } From c0b829accec596a1ac9f7f29cc528d1ebd68112b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 18 Apr 2022 11:30:50 +0900 Subject: [PATCH 233/292] bigint.h: remove unused macro OVMASK. --- include/mruby/bigint.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/include/mruby/bigint.h b/include/mruby/bigint.h index 02f745cc4..6dba4c7c9 100644 --- a/include/mruby/bigint.h +++ b/include/mruby/bigint.h @@ -42,7 +42,6 @@ typedef int32_t mp_limb; typedef uint32_t mp_ulimb; #define LMAX 0x3fffffffL #define LC 0xc0000000L -#define OVMASK 0x2 #define CMASK (LMAX+1) #define HLMAX 0x7fffL #define HCMASK (HLMAX + 1) @@ -55,7 +54,6 @@ typedef int64_t mp_limb; typedef uint64_t mp_ulimb; #define LMAX 0x3fffffffffffffffLL #define LC 0xc000000000000000LL -#define OVMASK 0x2 #define CMASK (LMAX+1) #define HLMAX 0x7fffffffLL #define HCMASK (HLMAX + 1) From a89130561bde987147fa32cc2dfeebd9fbafc261 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 18 Apr 2022 11:32:09 +0900 Subject: [PATCH 234/292] bigint.c: remove unused function prototypes. --- src/bigint.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/bigint.c b/src/bigint.c index 9179ffbd4..105f158d5 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -1417,8 +1417,4 @@ mrb_bint_rshift(mrb_state *mrb, mrb_value x, mrb_int width) } return bint_norm(mrb, b2); } - -void mpz_abs(mpz_t *, mpz_t *); -void mpz_gcd(mpz_t *, mpz_t *, mpz_t *); - #endif /* MRB_USE_BIGINT */ From 25e6e24c19de9b060ad27f3e52878b95fa3a736d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 18 Apr 2022 11:33:53 +0900 Subject: [PATCH 235/292] bigint.c: adjust integer types to remove warnings. --- src/bigint.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/src/bigint.c b/src/bigint.c index 105f158d5..bec9e77b6 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -38,7 +38,7 @@ mpz_init_set(mrb_state *mrb, mpz_t *s, mpz_t *t) #endif static void -mpz_set_int(mrb_state *mrb, mpz_t *y, long v) +mpz_set_int(mrb_state *mrb, mpz_t *y, mrb_int v) { for (size_t i=1; isz; i++) y->p[i] = 0; @@ -154,7 +154,7 @@ uadd(mrb_state *mrb, mpz_t *z, mpz_t *x, mpz_t *y) c=0; for (i=0; isz; i++) { - if (( z->p[i] = y->p[i] + x->p[i] + c ) & CMASK) { + if ((z->p[i] = y->p[i] + x->p[i] + c) & CMASK) { c=1; (z->p[i]) &=LMAX; } @@ -626,18 +626,18 @@ static int mpz_sizeinbase(mpz_t *x, int base) { int i,j; - int bits = digits(x) * DIGITBITS; + size_t bits = digits(x) * DIGITBITS; mrb_assert(2 <= base && base <= 36); for (j=0,i=1; i<=base; i*=2,j++) ; - return ((bits)/(j-1)+1); + return (int)((bits)/(j-1)+1); } static int mpz_init_set_str(mrb_state *mrb, mpz_t *x, const char *s, mrb_int len, mrb_int base) { size_t i; - mrb_int retval = 0; + int retval = 0; mpz_t t,m,bb; short sn; unsigned int k; @@ -684,7 +684,7 @@ mpz_init_set_str(mrb_state *mrb, mpz_t *x, const char *s, mrb_int len, mrb_int b } static char* -mpz_get_str(mrb_state *mrb, char *s, int sz, int base, mpz_t *x) +mpz_get_str(mrb_state *mrb, char *s, mrb_int sz, mrb_int base, mpz_t *x) { mpz_t xx,q,r,bb; char *p,*t,*ps; @@ -751,7 +751,7 @@ mpz_mul_2exp(mrb_state *mrb, mpz_t *z, mpz_t *x, mrb_int e) mpz_set(mrb,z,x); else { size_t i; - long digs = (e / DIGITBITS); + mp_limb digs = (e / DIGITBITS); size_t bs = (e % (DIGITBITS)); mpz_t y; @@ -778,7 +778,7 @@ mpz_div_2exp(mrb_state *mrb, mpz_t *z, mpz_t *x, mrb_int e) mpz_set(mrb,z,x); else { size_t i; - long digs = (e / DIGITBITS); + mp_limb digs = (e / DIGITBITS); size_t bs = (e % (DIGITBITS)); mpz_t y; @@ -928,9 +928,8 @@ mpz_powm(mrb_state *mrb, mpz_t *zz, mpz_t *x, mrb_int ex, mpz_t *n) if (ex < 0) { return; } - mpz_init(mrb,&e); + mpz_init_set_int(mrb,&e, ex); mpz_init(mrb,&t); - mpz_set_int(mrb,&e,ex); for (k=0;!uzero(&e);k++,mpz_div_2exp(mrb,&e,&e,1)) push(mrb,lowdigit(&e) & 1,&stack); From 96ff3c31c4fc988692c183004ed2dfa528affbf2 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 18 Apr 2022 11:34:30 +0900 Subject: [PATCH 236/292] bigint.c: cast to unsigned integer to avoid undefined behavior. --- src/bigint.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/bigint.c b/src/bigint.c index bec9e77b6..2ac5130c6 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -390,10 +390,10 @@ ulshift(mrb_state *mrb, mpz_t *c1, mpz_t *a, int n) mpz_set(mrb,c1,a); else { mpz_t c; size_t i; - mp_limb rm = (((mp_limb)1<sz + 1)); for (i=0; isz; i++) { - c.p[i] = (((mp_limb)a->p[i] << n) | cc) & LMAX; + c.p[i] = (((mp_ulimb)a->p[i] << n) | cc) & LMAX; cc = (a->p[i] & rm) >> (DIGITBITS -n); } c.p[i] = cc; From b38a76642759c9f1be229f0dcf645a1a88b4fa70 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 18 Apr 2022 11:35:15 +0900 Subject: [PATCH 237/292] numeric.c (flo_to_i): use bigint if the value is bigger than `mrb_int`. --- include/mruby/internal.h | 1 + src/bigint.c | 48 ++++++++++++++++++++++++++++++++++++++++ src/numeric.c | 4 ++++ 3 files changed, 53 insertions(+) diff --git a/include/mruby/internal.h b/include/mruby/internal.h index 9ce87c8aa..be71f0799 100644 --- a/include/mruby/internal.h +++ b/include/mruby/internal.h @@ -181,6 +181,7 @@ mrb_value mrb_bint_lshift(mrb_state *mrb, mrb_value x, mrb_int width); mrb_value mrb_bint_rshift(mrb_state *mrb, mrb_value x, mrb_int width); mrb_value mrb_bint_to_s(mrb_state *mrb, mrb_value x, mrb_int base); #ifndef MRB_NO_FLOAT +mrb_value mrb_bint_new_float(mrb_state *mrb, mrb_float x); mrb_float mrb_bint_as_float(mrb_state *mrb, mrb_value x); #endif mrb_int mrb_bint_as_int(mrb_state *mrb, mrb_value x); diff --git a/src/bigint.c b/src/bigint.c index 2ac5130c6..2f29d9fc5 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -1011,6 +1011,54 @@ mrb_gc_free_bint(mrb_state *mrb, struct RBasic *x) } #ifndef MRB_NO_FLOAT +mrb_value +mrb_bint_new_float(mrb_state *mrb, mrb_float x) +{ + /* x should not be NaN nor Infinity */ + mrb_assert(x == x && x != x * 0.5); + + if (x < 1.0) { + return mrb_fixnum_value(0); + } + + struct RBigint *bint = bint_new(mrb); + mpz_t *r = &bint->mp; + + if (x < 0.0) { + x = -x; + r->sn = -1; + } + else { + r->sn = 1; + } + + mrb_float b = (double)CMASK; + mrb_float bi = 1.0 / b; + size_t rn; + int i; + mp_limb *rp; + mp_limb f; + + for (rn = 1; x >= b; rn++) + x *= bi; + + mpz_realloc(mrb, r, rn); + rp = r->p; + f = (mp_limb)x; + x -= f; + mrb_assert(x < 1.0); + i = rn-1; + rp[i] = f; + while (--i >= 0) { + x = b * x; + f = (mp_limb)x; + x -= f; + mrb_assert(x < 1.0); + rp[i] = f; + } + return bint_norm(mrb, bint); +} + mrb_float mrb_bint_as_float(mrb_state *mrb, mrb_value self) { diff --git a/src/numeric.c b/src/numeric.c index e33f1bed7..60250ea32 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1014,7 +1014,11 @@ flo_to_i(mrb_state *mrb, mrb_value num) mrb_check_num_exact(mrb, f); if (!FIXABLE_FLOAT(f)) { +#ifdef MRB_USE_BIGINT + return mrb_bint_new_float(mrb, f); +#else mrb_int_overflow(mrb, "to_f"); +#endif } if (f > 0.0) f = floor(f); if (f < 0.0) f = ceil(f); From 94585a5902f370e67b5312f1add9d17d4d8d1374 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 18 Apr 2022 17:47:10 +0900 Subject: [PATCH 238/292] mruby-binding/bindinc.c: should not mix `int` and `size_t`. --- mrbgems/mruby-binding/src/binding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-binding/src/binding.c b/mrbgems/mruby-binding/src/binding.c index eb44f0e90..e4c362793 100644 --- a/mrbgems/mruby-binding/src/binding.c +++ b/mrbgems/mruby-binding/src/binding.c @@ -45,7 +45,7 @@ binding_eval_error_check(mrb_state *mrb, struct mrb_parser_state *p, const char struct expand_lvspace { mrb_irep *irep; struct REnv *env; - size_t numvar; + int numvar; mrb_sym syms[LV_BUFFERS]; }; From 8bd924c90593140ac4bdb4b1d2c994e97f3e094e Mon Sep 17 00:00:00 2001 From: dearblue Date: Tue, 19 Apr 2022 21:00:45 +0900 Subject: [PATCH 239/292] Move `method_added` method into the `Module` Previously defined as `BasicObject#method_added`. --- src/class.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/class.c b/src/class.c index 07399fe7d..2a3873eb1 100644 --- a/src/class.c +++ b/src/class.c @@ -2981,7 +2981,7 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, mod, "define_method", mod_define_method, MRB_ARGS_ARG(1,1)); mrb_define_method(mrb, mod, "===", mrb_mod_eqq, MRB_ARGS_REQ(1)); /* 15.2.2.4.7 */ mrb_define_method(mrb, mod, "dup", mrb_mod_dup, MRB_ARGS_NONE()); - mrb_define_method(mrb, bob, "method_added", mrb_do_nothing, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, mod, "method_added", mrb_do_nothing, MRB_ARGS_REQ(1)); mrb_undef_method(mrb, cls, "append_features"); mrb_undef_method(mrb, cls, "prepend_features"); From be782b7d36c308af33580478ddea477903caf571 Mon Sep 17 00:00:00 2001 From: dearblue Date: Tue, 19 Apr 2022 21:48:50 +0900 Subject: [PATCH 240/292] Setting `Command#build` correctly in automatic "mrbc" build for presym This was the cause of the command line flag being affected by changes in the parent build. So, for example, if `mruby-rational` was included, even the automatically added `mrbc` builds included `MRB_USE_RATIONAL`. --- lib/mruby/build.rb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/mruby/build.rb b/lib/mruby/build.rb index 771aa7f3e..4925cee33 100644 --- a/lib/mruby/build.rb +++ b/lib/mruby/build.rb @@ -500,7 +500,8 @@ EOS v = instance_variable_get(n) v = case v when nil, true, false, Numeric; v - when String, Command; v.clone + when String; v.clone + when Command; v.clone.tap { |u| u.build = build } else Marshal.load(Marshal.dump(v)) # deep clone end build.instance_variable_set(n, v) From b0be2b0176b6ab31e29ef779150b981e6f55e061 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 19 Apr 2022 07:50:54 +0900 Subject: [PATCH 241/292] bigint.c: fix integer size mixture warnings. --- src/bigint.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/bigint.c b/src/bigint.c index 2f29d9fc5..480c2826a 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -359,7 +359,7 @@ lzb(mp_limb a) /* c1 = a>>n */ /* n must be < DIGITBITS */ static void -urshift(mrb_state *mrb, mpz_t *c1, mpz_t *a, int n) +urshift(mrb_state *mrb, mpz_t *c1, mpz_t *a, size_t n) { mp_limb cc = 0; mrb_assert(n < DIGITBITS); @@ -382,7 +382,7 @@ urshift(mrb_state *mrb, mpz_t *c1, mpz_t *a, int n) /* c1 = a<mp, base); + mrb_int len = mpz_sizeinbase(&b->mp, (int)base); mrb_value str = mrb_str_new(mrb, NULL, len+2); mpz_get_str(mrb, RSTRING_PTR(str), len, base, &b->mp); RSTR_SET_LEN(RSTRING(str), strlen(RSTRING_PTR(str))); From dd582069eddb4cfedaafef2c83ed06e872c4c256 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 19 Apr 2022 07:51:19 +0900 Subject: [PATCH 242/292] bigint.c: simplify a loop in `mrb_bint_new_float()`. --- src/bigint.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/src/bigint.c b/src/bigint.c index 480c2826a..66683f5e1 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -1034,8 +1034,7 @@ mrb_bint_new_float(mrb_state *mrb, mrb_float x) mrb_float b = (double)CMASK; mrb_float bi = 1.0 / b; - size_t rn; - int i; + size_t rn, i; mp_limb *rp; mp_limb f; @@ -1044,17 +1043,12 @@ mrb_bint_new_float(mrb_state *mrb, mrb_float x) mpz_realloc(mrb, r, rn); rp = r->p; - f = (mp_limb)x; - x -= f; - mrb_assert(x < 1.0); - i = rn-1; - rp[i] = f; - while (--i >= 0) { - x = b * x; + for (i=rn-1;;i--) { f = (mp_limb)x; x -= f; mrb_assert(x < 1.0); rp[i] = f; + if (i == 0) break; } return bint_norm(mrb, bint); } From b07ce286f13e572394d225d359caeed35dbe5c9d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 20 Apr 2022 16:11:32 +0900 Subject: [PATCH 243/292] fmt_fp.c: fix `int` and `size_t` mixture. --- src/fmt_fp.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/fmt_fp.c b/src/fmt_fp.c index bcb9ccc24..9249baa08 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -78,7 +78,7 @@ static const mrb_float g_neg_pow[] = { int mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, char sign) { char *s = buf; - int buf_remaining = buf_size - 1; + int buf_remaining = (int)buf_size - 1; int alt_form = 0; if ((uint8_t)fmt & 0x80) { @@ -118,7 +118,7 @@ mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, ch *s++ = 'N' ^ uc; ret: *s = '\0'; - return s - buf; + return (int)(s - buf); } } @@ -358,6 +358,6 @@ mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, ch } *s = '\0'; - return s - buf; + return (int)(s - buf); } #endif From e7d0e6fd5a483e30cf200f4a3ac296da8e09d491 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 20 Apr 2022 16:18:18 +0900 Subject: [PATCH 244/292] vm.c: fix integer size mixtures. --- src/vm.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/vm.c b/src/vm.c index 9538efd81..5013c877d 100644 --- a/src/vm.c +++ b/src/vm.c @@ -531,7 +531,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc } if (MRB_METHOD_UNDEF_P(m)) { uint16_t ac = (uint16_t)argc; - m = prepare_missing(mrb, self, mid, &c, n, &ac, mrb_nil_value(), 0); + m = prepare_missing(mrb, self, mid, &c, (uint32_t)n, &ac, mrb_nil_value(), 0); argc = (mrb_int)ac; mid = MRB_SYM(method_missing); } @@ -581,7 +581,7 @@ mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, cons static void check_method_noarg(mrb_state *mrb, const mrb_callinfo *ci) { - int argc = ci->n == CALL_MAXARGS ? RARRAY_LEN(ci->stack[1]) : ci->n; + mrb_int argc = ci->n == CALL_MAXARGS ? RARRAY_LEN(ci->stack[1]) : ci->n; if (ci->nk > 0) { mrb_value kdict = ci->stack[mrb_ci_kidx(ci)]; if (!(mrb_hash_p(kdict) && mrb_hash_empty_p(mrb, kdict))) { From 9dd45df8046b8029c8b2b315b3379ad218487ed3 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 21 Apr 2022 11:35:52 +0900 Subject: [PATCH 245/292] numeric.c (int_pow): should not overflow. --- src/numeric.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/numeric.c b/src/numeric.c index 60250ea32..e55ee591b 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -85,7 +85,11 @@ mrb_int_pow(mrb_state *mrb, mrb_value x) for (;;) { if (exp & 1) { if (mrb_int_mul_overflow(result, base, &result)) { +#ifdef MRB_USE_BIGINT + return mrb_bint_pow(mrb, mrb_bint_new_int(mrb, mrb_integer(x)), y); +#else mrb_int_overflow(mrb, "power"); +#endif } } exp >>= 1; From 3be461077d50d72092ff9cc36d24f91f03365da8 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 21 Apr 2022 13:39:59 +0900 Subject: [PATCH 246/292] mruby-pack/pack.c: fix integer size mixtures. --- mrbgems/mruby-pack/src/pack.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index 4f70f9ba4..fa2c227f5 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -387,13 +387,13 @@ static int pack_BER(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) { mrb_int n = mrb_integer(o); - size_t i; + int i; char *p; if (n < 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "can't compress negative numbers"); } - for (i=1; iidx = e - tptr; + tmpl->idx = (int)(e - tptr); continue; } else if (ch == '*') { if (type == PACK_TYPE_NONE) From bdc244e9b035c608e3aeb1cb3440c47c2a5d61e6 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 21 Apr 2022 13:42:47 +0900 Subject: [PATCH 247/292] mruby-errno/errno.c: fix integer size mixtures. --- mrbgems/mruby-errno/src/errno.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-errno/src/errno.c b/mrbgems/mruby-errno/src/errno.c index fc27cdf6e..e96d321a3 100644 --- a/mrbgems/mruby-errno/src/errno.c +++ b/mrbgems/mruby-errno/src/errno.c @@ -112,7 +112,7 @@ mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls) struct RClass *sce; mrb_value msg; mrb_int no = -1; - int argc; + mrb_int argc; mrb->c->ci->mid = 0; sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError)); @@ -135,7 +135,7 @@ mrb_exxx_init(mrb_state *mrb, mrb_value self) mrb_value m, no, str; no = mrb_const_get(mrb, mrb_obj_value(mrb_class(mrb, self)), MRB_SYM(Errno)); - str = mrb_str_new_cstr(mrb, strerror(mrb_fixnum(no))); + str = mrb_str_new_cstr(mrb, strerror((int)mrb_fixnum(no))); m = mrb_nil_value(); mrb_get_args(mrb, "|S", &m); From a4d97934d51cb88954cc49161dc1d151f64afb6b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 22 Apr 2022 08:32:18 +0900 Subject: [PATCH 248/292] vm.c: check if target_class is NULL (when prepended). --- src/vm.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/vm.c b/src/vm.c index 5013c877d..aa043b06a 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1750,10 +1750,7 @@ RETRY_TRY_BLOCK: mrb_exc_set(mrb, exc); goto L_RAISE; } - if (target_class->flags & MRB_FL_CLASS_IS_PREPENDED) { - target_class = mrb_vm_ci_target_class(ci); - } - else if (target_class->tt == MRB_TT_MODULE) { + if ((target_class->flags & MRB_FL_CLASS_IS_PREPENDED) || target_class->tt == MRB_TT_MODULE) { target_class = mrb_vm_ci_target_class(ci); if (!target_class || target_class->tt != MRB_TT_ICLASS) { goto super_typeerror; From e3e85df13a22b82a6b34f51560d982aae3e7ee22 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 23 Apr 2022 21:11:42 +0900 Subject: [PATCH 249/292] Removed duplicate prototype declarations for bigint A part of `include/mruby/bigint.h` has been removed because it duplicates `include/mruby/internal.h`. --- include/mruby/bigint.h | 27 --------------------------- 1 file changed, 27 deletions(-) diff --git a/include/mruby/bigint.h b/include/mruby/bigint.h index 6dba4c7c9..925a5d27a 100644 --- a/include/mruby/bigint.h +++ b/include/mruby/bigint.h @@ -85,33 +85,6 @@ struct RBigint { #define RBIGINT(v) ((struct RBigint*)mrb_ptr(v)) -mrb_value mrb_bint_new_int(mrb_state *mrb, mrb_int x); -mrb_value mrb_bint_add(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_sub(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_mul(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_div(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_divmod(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_add_ii(mrb_state *mrb, mrb_int x, mrb_int y); -mrb_value mrb_bint_sub_ii(mrb_state *mrb, mrb_int x, mrb_int y); -mrb_value mrb_bint_mul_ii(mrb_state *mrb, mrb_int x, mrb_int y); -mrb_value mrb_bint_div_ii(mrb_state *mrb, mrb_int x, mrb_int y); -mrb_value mrb_bint_mod(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_rem(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_pow(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_powm(mrb_state *mrb, mrb_value x, mrb_int y, mrb_value z); -mrb_value mrb_bint_and(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_or(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_xor(mrb_state *mrb, mrb_value x, mrb_value y); -mrb_value mrb_bint_rev(mrb_state *mrb, mrb_value x); -mrb_value mrb_bint_lshift(mrb_state *mrb, mrb_value x, mrb_int width); -mrb_value mrb_bint_rshift(mrb_state *mrb, mrb_value x, mrb_int width); -mrb_value mrb_bint_to_s(mrb_state *mrb, mrb_value x, mrb_int base); -#ifndef MRB_NO_FLOAT -mrb_float mrb_bint_as_float(mrb_state *mrb, mrb_value x); -#endif -mrb_int mrb_bint_as_int(mrb_state *mrb, mrb_value x); -mrb_int mrb_bint_cmp(mrb_state *mrb, mrb_value x, mrb_value y); -void mrb_gc_free_bint(mrb_state *mrb, struct RBasic *x); #endif #endif /* MRB_USE_BIGINT */ From cc3a213fef2cac98149c736473007d189981e684 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 23 Apr 2022 21:19:12 +0900 Subject: [PATCH 250/292] Move bigint implementation files to `mruby-bigint` Users can now switch to their own implementation of GEM. However, we do not guarantee that this will not be a problem in the current situation. This may need to be improved in the future. --- mrbgems/mruby-bigint/README.md | 4 ---- {src => mrbgems/mruby-bigint/core}/bigint.c | 4 +--- {include/mruby => mrbgems/mruby-bigint/core}/bigint.h | 5 +---- mrbgems/mruby-bigint/mrbgem.rake | 4 ++++ mrbgems/mruby-numeric-ext/src/numeric_ext.c | 2 -- 5 files changed, 6 insertions(+), 13 deletions(-) rename {src => mrbgems/mruby-bigint/core}/bigint.c (99%) rename {include/mruby => mrbgems/mruby-bigint/core}/bigint.h (97%) diff --git a/mrbgems/mruby-bigint/README.md b/mrbgems/mruby-bigint/README.md index bf15b7f24..81b368601 100644 --- a/mrbgems/mruby-bigint/README.md +++ b/mrbgems/mruby-bigint/README.md @@ -3,7 +3,3 @@ This extension uses fgmp, which is a public domain implementation of a subset of the GNU gmp library by Mark Henderson But it's heavily modified to fit with mruby. You can get the original source code from You can read the original README for fgmp in - -## Implementation - -This mrbgem is only to turn on `MRB_USE_BIGINT` flag. The implementation resides in `include/mruby/bigint.h` and `src/bigint.c`. diff --git a/src/bigint.c b/mrbgems/mruby-bigint/core/bigint.c similarity index 99% rename from src/bigint.c rename to mrbgems/mruby-bigint/core/bigint.c index 66683f5e1..93ca97549 100644 --- a/src/bigint.c +++ b/mrbgems/mruby-bigint/core/bigint.c @@ -3,16 +3,15 @@ ** ** See Copyright Notice in mruby.h */ -#ifdef MRB_USE_BIGINT #include #include #include -#include #include #include #include #include +#include "bigint.h" static void mpz_init(mrb_state *mrb, mpz_t *s) @@ -1458,4 +1457,3 @@ mrb_bint_rshift(mrb_state *mrb, mrb_value x, mrb_int width) } return bint_norm(mrb, b2); } -#endif /* MRB_USE_BIGINT */ diff --git a/include/mruby/bigint.h b/mrbgems/mruby-bigint/core/bigint.h similarity index 97% rename from include/mruby/bigint.h rename to mrbgems/mruby-bigint/core/bigint.h index 925a5d27a..24ed6ee7c 100644 --- a/include/mruby/bigint.h +++ b/mrbgems/mruby-bigint/core/bigint.h @@ -3,7 +3,6 @@ ** ** See Copyright Notice in mruby.h */ -#ifdef MRB_USE_BIGINT #ifndef MRUBY_BIGINT_H #define MRUBY_BIGINT_H @@ -85,6 +84,4 @@ struct RBigint { #define RBIGINT(v) ((struct RBigint*)mrb_ptr(v)) -#endif - -#endif /* MRB_USE_BIGINT */ +#endif /* MRUBY_BIGINT_H */ diff --git a/mrbgems/mruby-bigint/mrbgem.rake b/mrbgems/mruby-bigint/mrbgem.rake index 528a7ee70..a1039bf57 100644 --- a/mrbgems/mruby-bigint/mrbgem.rake +++ b/mrbgems/mruby-bigint/mrbgem.rake @@ -3,4 +3,8 @@ MRuby::Gem::Specification.new('mruby-bigint') do |spec| spec.author = 'mruby developers' spec.summary = 'Integer class extension to multiple-precision' spec.build.defines << "MRB_USE_BIGINT" + + spec.build.libmruby_core_objs << Dir.glob(File.join(__dir__, "core/**/*.c")).map { |fn| + objfile(fn.relative_path_from(__dir__).pathmap("#{spec.build_dir}/%X")) + } end diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index 1010d8fa7..7ea0e9772 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -4,8 +4,6 @@ #include #ifdef MRB_USE_BIGINT -#include - static mrb_value bint_allbits(mrb_state *mrb, mrb_value x, mrb_value y) { From 889f1b898f513cd07e2da398b410a328c9e40c3e Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 23 Apr 2022 22:13:30 +0900 Subject: [PATCH 251/292] Hides the class of string objects allocated by `mrb_alloca()` Prevents retrieval with the `ObjectSpace.each_object` method. --- src/gc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gc.c b/src/gc.c index 886ccfdf9..914dbbf1d 100644 --- a/src/gc.c +++ b/src/gc.c @@ -293,7 +293,7 @@ MRB_API void* mrb_alloca(mrb_state *mrb, size_t size) { struct RString *s; - s = MRB_OBJ_ALLOC(mrb, MRB_TT_STRING, mrb->string_class); + s = MRB_OBJ_ALLOC(mrb, MRB_TT_STRING, NULL); return s->as.heap.ptr = (char*)mrb_malloc(mrb, size); } From 8bd77ca33279da7802e78794a6ba1d00e9ecd4d7 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 22 Apr 2022 08:57:19 +0900 Subject: [PATCH 252/292] vm.c: target_class should be retrieved from callinfo. --- src/vm.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/vm.c b/src/vm.c index aa043b06a..e5eaf5ed7 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1739,7 +1739,7 @@ RETRY_TRY_BLOCK: mrb_value recv, blk; const struct RProc *p = ci->proc; mrb_sym mid = ci->mid; - struct RClass* target_class = MRB_PROC_TARGET_CLASS(p); + struct RClass* target_class = mrb_vm_ci_target_class(ci); if (MRB_PROC_ENV_P(p) && p->e.env->mid && p->e.env->mid != mid) { /* alias support */ mid = p->e.env->mid; /* restore old mid */ @@ -1751,10 +1751,7 @@ RETRY_TRY_BLOCK: goto L_RAISE; } if ((target_class->flags & MRB_FL_CLASS_IS_PREPENDED) || target_class->tt == MRB_TT_MODULE) { - target_class = mrb_vm_ci_target_class(ci); - if (!target_class || target_class->tt != MRB_TT_ICLASS) { - goto super_typeerror; - } + goto super_typeerror; } recv = regs[0]; if (!mrb_obj_is_kind_of(mrb, recv, target_class)) { From 17b4d82f65b0d139e36c9064ce23844cc072464c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 22 Apr 2022 14:21:58 +0900 Subject: [PATCH 253/292] variable.c: remove `mrb_` prefix from a static function. --- src/variable.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/variable.c b/src/variable.c index 598850034..4f1c8bace 100644 --- a/src/variable.c +++ b/src/variable.c @@ -986,7 +986,7 @@ mrb_f_global_variables(mrb_state *mrb, mrb_value self) } static mrb_bool -mrb_const_defined_0(mrb_state *mrb, mrb_value mod, mrb_sym id, mrb_bool exclude, mrb_bool recurse) +const_defined_0(mrb_state *mrb, mrb_value mod, mrb_sym id, mrb_bool exclude, mrb_bool recurse) { struct RClass *klass = mrb_class_ptr(mod); struct RClass *tmp; @@ -1012,13 +1012,13 @@ retry: MRB_API mrb_bool mrb_const_defined(mrb_state *mrb, mrb_value mod, mrb_sym id) { - return mrb_const_defined_0(mrb, mod, id, TRUE, TRUE); + return const_defined_0(mrb, mod, id, TRUE, TRUE); } MRB_API mrb_bool mrb_const_defined_at(mrb_state *mrb, mrb_value mod, mrb_sym id) { - return mrb_const_defined_0(mrb, mod, id, TRUE, FALSE); + return const_defined_0(mrb, mod, id, TRUE, FALSE); } MRB_API mrb_value From 083691dbd19364aceba9cc03f9cbb4eec432422c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 22 Apr 2022 15:26:24 +0900 Subject: [PATCH 254/292] variable.c (const_get): stop searching constant before `Object`. `String::String` should raise `NameError` exception. --- src/variable.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/variable.c b/src/variable.c index 4f1c8bace..365d93034 100644 --- a/src/variable.c +++ b/src/variable.c @@ -774,6 +774,7 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym, mrb_bool skip) mrb_bool retry = FALSE; mrb_value name; + /* if skip then skip the current class (already searched) */ if (skip) c = c->super; L_RETRY: while (c) { @@ -782,6 +783,7 @@ L_RETRY: return v; } c = c->super; + if (!skip && c == mrb->object_class) break; } if (!retry && base->tt == MRB_TT_MODULE) { c = mrb->object_class; From 56a35131a455ea1d00711e8e3f4f06a51c32f967 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 22 Apr 2022 16:09:30 +0900 Subject: [PATCH 255/292] numeric.c (mrb_cmp): should not raise NoMethodError. Even when `obj1` does not have `<=>` method. --- src/numeric.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/numeric.c b/src/numeric.c index e55ee591b..be49c9e70 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1929,6 +1929,7 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2) return -2; return mrb_str_cmp(mrb, obj1, obj2); default: + if (!mrb_respond_to(mrb, obj1, MRB_OPSYM(cmp))) return -2; v = mrb_funcall_id(mrb, obj1, MRB_OPSYM(cmp), 1, obj2); if (mrb_nil_p(v) || !mrb_integer_p(v)) return -2; From 2bea39f339f62d472a18961c1cd863cc9ef2dcff Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 23 Apr 2022 13:35:27 +0900 Subject: [PATCH 256/292] mruby-range-ext/range.c: `Range#cover?()` takes a range too. --- mrbgems/mruby-range-ext/src/range.c | 83 +++++++++++++++++++-------- mrbgems/mruby-range-ext/test/range.rb | 16 +++++- 2 files changed, 75 insertions(+), 24 deletions(-) diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c index 9a88ef542..70bf0976e 100644 --- a/mrbgems/mruby-range-ext/src/range.c +++ b/mrbgems/mruby-range-ext/src/range.c @@ -2,29 +2,33 @@ #include static mrb_bool -r_le(mrb_state *mrb, mrb_value a, mrb_value b) +r_less(mrb_state *mrb, mrb_value a, mrb_value b, mrb_bool excl) { - mrb_int n = mrb_cmp(mrb, a, b); - - if (n == 0 || n == -1) return TRUE; - return FALSE; -} - -static mrb_bool -r_lt(mrb_state *mrb, mrb_value a, mrb_value b) -{ - return mrb_cmp(mrb, a, b) == -1; + switch (mrb_cmp(mrb, a, b)) { + case -2: /* failure */ + case 1: + return FALSE; + case 0: + return !excl; + case -1: + default: /* just in case */ + return TRUE; + } } /* * call-seq: * rng.cover?(obj) -> true or false + * rng.cover?(range) -> true or false * - * Returns true if +obj+ is between the begin and end of - * the range. + * Returns +true+ if the given argument is within +self+, +false+ otherwise. * - * This tests begin <= obj <= end when #exclude_end? is +false+ - * and begin <= obj < end when #exclude_end? is +true+. + * With non-range argument +object+, evaluates with <= and <. + * + * For range +self+ with included end value (#exclude_end? == false), + * evaluates thus: + * + * self.begin <= object <= self.end * * ("a".."z").cover?("c") #=> true * ("a".."z").cover?("5") #=> false @@ -40,20 +44,53 @@ range_cover(mrb_state *mrb, mrb_value range) beg = RANGE_BEG(r); end = RANGE_END(r); - if (mrb_nil_p(beg) || r_le(mrb, beg, val)) { - if (mrb_nil_p(end)) { + if (mrb_nil_p(beg) && mrb_nil_p(end)) return mrb_true_value(); + + if (mrb_range_p(val)) { + struct RRange *r2 = mrb_range_ptr(mrb, val); + mrb_value beg2 = RANGE_BEG(r2); + mrb_value end2 = RANGE_END(r2); + + /* range.cover?(nil..nil) => true */ + if (mrb_nil_p(beg2) && mrb_nil_p(end2)) return mrb_true_value(); + + /* (a..b).cover?(c..d) */ + if (mrb_nil_p(end)) { /* a.. */ + /* (a..).cover?(c..) => true */ + if (mrb_nil_p(end2)) return mrb_bool_value(mrb_cmp(mrb, beg, beg2) != -2); + /* (a..).cover?(c..d) where d false */ + if (r_less(mrb, end2, beg, RANGE_EXCL(r2))) return mrb_false_value(); return mrb_true_value(); } - if (RANGE_EXCL(r)) { - if (r_lt(mrb, val, end)) - return mrb_true_value(); + else if (mrb_nil_p(beg)) { /* ..b */ + /* (..b).cover?(..d) => true */ + if (mrb_nil_p(beg2)) return mrb_bool_value(mrb_cmp(mrb, end, end2) != -2); + /* (..b).cover?(c..d) where b false */ + if (r_less(mrb, end, beg2, RANGE_EXCL(r))) return mrb_false_value(); + return mrb_true_value(); } - else { - if (r_le(mrb, val, end)) - return mrb_true_value(); + else { /* a..b */ + /* (a..b).cover?(c..) => (c (a false */ + if (r_less(mrb, end, beg2, RANGE_EXCL(r))) return mrb_false_value(); + /* (a..b).cover?(c..d) where (d false */ + if (r_less(mrb, end2, beg, RANGE_EXCL(r2))) return mrb_false_value(); + return mrb_true_value(); } } + if (mrb_nil_p(beg) || r_less(mrb, beg, val, FALSE)) { + if (mrb_nil_p(end)) { + return mrb_true_value(); + } + if (r_less(mrb, val, end, RANGE_EXCL(r))) + return mrb_true_value(); + } return mrb_false_value(); } diff --git a/mrbgems/mruby-range-ext/test/range.rb b/mrbgems/mruby-range-ext/test/range.rb index 863c619c8..4ae575669 100644 --- a/mrbgems/mruby-range-ext/test/range.rb +++ b/mrbgems/mruby-range-ext/test/range.rb @@ -3,11 +3,25 @@ assert('Range#cover?') do assert_true ("a".."z").cover?("c") - assert_true !("a".."z").cover?("5") + assert_false ("a".."z").cover?("5") assert_true ("a".."z").cover?("cc") + assert_false ("a".."z").cover?(nil) assert_true ("a"..).cover?("c") assert_false ("a"..).cover?("5") assert_true ("a"..).cover?("cc") + assert_true (.."z").cover?("a") + assert_false (..."z").cover?("z") + assert_true (.."z").cover?("z") + assert_true (nil..nil).cover?(nil) + + assert_true ("a".."c").cover?("b".."d") + assert_true ("a"..).cover?("b"..) + assert_false ("a"..).cover?(1..) + assert_false ("d"..).cover?(.."b") + assert_true (.."c").cover?("b".."d") + assert_true (.."c").cover?(.."d") + assert_false (.."c").cover?(..2) + assert_false (.."c").cover?("d"..) end assert('Range#first') do From ede3bed9e6843727a83a3fef1af587a024cc8d2b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 07:21:40 +0900 Subject: [PATCH 257/292] object.c: add new function `mrb_ensure_integer_type()`. that checks if the value is an `Integer` which may be a big integer, where existing `mrb_ensure_int_type()` checks if the value is an Integer **and** fits in `mrb_int`. --- include/mruby.h | 3 +++ src/object.c | 18 +++++++++++++++++- 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/include/mruby.h b/include/mruby.h index 8a0396753..2eff81245 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1406,6 +1406,9 @@ MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str); #define mrb_to_str(mrb, str) mrb_ensure_string_type(mrb,str) /* obsolete: use mrb_obj_as_string() instead */ #define mrb_str_to_str(mrb, str) mrb_obj_as_string(mrb, str) +/* check if val is an integer (including Bigint) */ +MRB_API mrb_value mrb_ensure_integer_type(mrb_state *mrb, mrb_value val); +/* check if val fit in mrb_int */ MRB_API mrb_value mrb_ensure_int_type(mrb_state *mrb, mrb_value val); #define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val)) /* obsolete: use mrb_ensure_int_type() instead */ diff --git a/src/object.c b/src/object.c index d03bfcfea..530702173 100644 --- a/src/object.c +++ b/src/object.c @@ -497,7 +497,7 @@ mrb_value mrb_complex_to_i(mrb_state *mrb, mrb_value comp); #endif MRB_API mrb_value -mrb_ensure_int_type(mrb_state *mrb, mrb_value val) +mrb_ensure_integer_type(mrb_state *mrb, mrb_value val) { if (!mrb_integer_p(val)) { #ifndef MRB_NO_FLOAT @@ -506,6 +506,10 @@ mrb_ensure_int_type(mrb_state *mrb, mrb_value val) } else { switch (mrb_type(val)) { +#ifdef MRB_USE_BIGINT + case MRB_TT_BIGINT: + return val; +#endif #ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: return mrb_rational_to_i(mrb, val); @@ -524,6 +528,18 @@ mrb_ensure_int_type(mrb_state *mrb, mrb_value val) return val; } +MRB_API mrb_value +mrb_ensure_int_type(mrb_state *mrb, mrb_value val) +{ + val = mrb_ensure_integer_type(mrb, val); +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(val)) { + return mrb_int_value(mrb, mrb_bint_as_int(mrb, val)); + } +#endif + return val; +} + #ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_ensure_float_type(mrb_state *mrb, mrb_value val) From 425097c7be5b2371532edd5ae44b199522b6dbdf Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 07:26:42 +0900 Subject: [PATCH 258/292] mruby-kernel-ext/kernel.c: use `mrb_ensure_integer_type()`. Instead of obsolete `mrb_to_integer()`. --- mrbgems/mruby-kernel-ext/src/kernel.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index 94afb2a9c..b6c598d2f 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -167,7 +167,7 @@ arg_error: mrb_raise(mrb, E_ARGUMENT_ERROR, "base specified for non string value"); } /* to raise TypeError */ - return mrb_to_integer(mrb, val); + return mrb_ensure_integer_type(mrb, val); } #ifndef MRB_NO_FLOAT From f45ac65532d3c106e97860f82f02640b7aaedc6d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 07:29:21 +0900 Subject: [PATCH 259/292] fixup! mruby-kernel-ext/kernel.c: use `mrb_ensure_integer_type()`. --- mrbgems/mruby-pack/src/pack.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index fa2c227f5..47ad3d85a 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -1390,7 +1390,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) o = mrb_ary_ref(mrb, ary, aidx); if (type == PACK_TYPE_INTEGER) { - o = mrb_to_integer(mrb, o); + o = mrb_ensure_int_type(mrb, o); } #ifndef MRB_NO_FLOAT else if (type == PACK_TYPE_FLOAT) { From 0f4769536bc9ce528a6f40521b35398316780f48 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 07:29:55 +0900 Subject: [PATCH 260/292] src/numeric.c: use `mrb_ensure_float_type()`. Instead of obsolete `mrb_to_float()` or the combination of `mrb_float_value(mrb_as_float())`. --- mrbgems/mruby-kernel-ext/src/kernel.c | 2 +- mrbgems/mruby-pack/src/pack.c | 3 +-- src/numeric.c | 2 +- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index b6c598d2f..a0c274dcf 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -191,7 +191,7 @@ mrb_f_float(mrb_state *mrb, mrb_value self) if (mrb_string_p(arg)) { return mrb_float_value(mrb, mrb_str_to_dbl(mrb, arg, TRUE)); } - return mrb_to_float(mrb, arg); + return mrb_ensure_float_type(mrb, arg); } #endif diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index 47ad3d85a..cd9202404 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -1395,8 +1395,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) #ifndef MRB_NO_FLOAT else if (type == PACK_TYPE_FLOAT) { if (!mrb_float_p(o)) { - mrb_float f = mrb_as_float(mrb, o); - o = mrb_float_value(mrb, f); + o = mrb_ensure_float_type(mrb, o); } } #endif diff --git a/src/numeric.c b/src/numeric.c index be49c9e70..08599901b 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -259,7 +259,7 @@ coerce_step_counter(mrb_state *mrb, mrb_value self) #ifndef MRB_NO_FLOAT mrb->c->ci->mid = 0; if (mrb_float_p(num) || mrb_float_p(step)) { - return mrb_to_float(mrb, self); + return mrb_ensure_float_type(mrb, self); } #endif From b835979bf3fec722573dda31c0117740abe2f40a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 07:31:39 +0900 Subject: [PATCH 261/292] bigint.c: update the error message for too big integers. --- src/bigint.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bigint.c b/src/bigint.c index 66683f5e1..ef2cf84a1 100644 --- a/src/bigint.c +++ b/src/bigint.c @@ -1086,7 +1086,7 @@ mrb_bint_as_int(mrb_state *mrb, mrb_value x) mrb_int i; if (!mpz_get_int(&b->mp, &i)) { - mrb_raise(mrb, E_RANGE_ERROR, "integer overflow"); + mrb_raise(mrb, E_RANGE_ERROR, "integer too big"); } return i; } From 61700dbb0af84a2d8da47f0463b417111ab4d587 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 10:01:09 +0900 Subject: [PATCH 262/292] mruby-sprintf/sprintf.c: raise an error with MRB_NO_FLOAT. --- mrbgems/mruby-sprintf/src/sprintf.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 8de3a4541..a562bdac1 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -1002,12 +1002,14 @@ retry: } break; -#ifndef MRB_NO_FLOAT case 'f': case 'g': case 'G': case 'e': case 'E': { +#ifdef MRB_NO_FLOAT + mrb_raisef(mrb, E_ARGUMENT_ERROR, "%%%c not supported with MRB_NO_FLOAT defined", *p); +#else mrb_value val = GETARG(); double fval; mrb_int need = 6; @@ -1077,9 +1079,9 @@ retry: mrb_raise(mrb, E_RUNTIME_ERROR, "formatting error"); } blen += n; +#endif } break; -#endif } flags = FNONE; } From df098385033e1a97c388d055befee4652e4c1ff0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 10:02:54 +0900 Subject: [PATCH 263/292] numeric.c: mrb_float_to_integer can return a big integer. --- src/numeric.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/numeric.c b/src/numeric.c index 08599901b..c84ce47d7 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1571,7 +1571,11 @@ mrb_float_to_integer(mrb_state *mrb, mrb_value x) z = (mrb_int)d; } else { +#ifdef MRB_USE_BIGINT + return mrb_bint_new_float(mrb, d); +#else mrb_raisef(mrb, E_RANGE_ERROR, "number (%v) too big for integer", x); +#endif } } return mrb_int_value(mrb, z); From 39c8c051f8c435e3ddfc91d9440ba3418c195c3f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 10:03:47 +0900 Subject: [PATCH 264/292] numeric.c: mrb_integer_to_str now supports big integers. --- src/numeric.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/numeric.c b/src/numeric.c index c84ce47d7..27a7cb8c3 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1754,6 +1754,11 @@ mrb_integer_to_str(mrb_state *mrb, mrb_value x, mrb_int base) if (base < 2 || 36 < base) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %i", base); } +#ifdef MRB_USE_BIGINT + if (mrb_bigint_p(x)) { + return mrb_bint_to_s(mrb, x, base); + } +#endif const char *p = mrb_int_to_cstr(buf, sizeof(buf), val, base); mrb_assert(p != NULL); mrb_value str = mrb_str_new_cstr(mrb, p); From f225db4ed6095cc0f4f62cce9d0df3f2ff348a51 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 10:04:39 +0900 Subject: [PATCH 265/292] string.c: move compilation condition to remove unreachable code. --- src/string.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/string.c b/src/string.c index 754a3b5ca..f6f97c7df 100644 --- a/src/string.c +++ b/src/string.c @@ -2319,8 +2319,9 @@ mrb_str_len_to_integer(mrb_state *mrb, const char *str, size_t len, mrb_int base } if (badcheck && trailingbad(str, p, pend)) goto bad; return mrb_bint_new_str(mrb, p2, (mrb_int)(p3-p2), sign ? base : -base); -#endif +#else mrb_raisef(mrb, E_RANGE_ERROR, "string (%l) too big for integer", str, pend-str); +#endif } n += c; } From dd4da147729517274b92b0cc47c401f2f5363106 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 25 Apr 2022 19:14:16 +0900 Subject: [PATCH 266/292] symbol.c: remove type mismatch warnings. --- src/symbol.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/symbol.c b/src/symbol.c index db7047ac6..e42a6b0a1 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -217,7 +217,7 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit) size_t symcapa = mrb->symcapa; if (symcapa == 0) symcapa = 100; else symcapa = (size_t)(symcapa * 6 / 5); - mrb->symtbl = (const char**)mrb_realloc(mrb, mrb->symtbl, sizeof(char*)*symcapa); + mrb->symtbl = (const char**)mrb_realloc(mrb, (void*)mrb->symtbl, sizeof(char*)*symcapa); mrb->symflags = (uint8_t*)mrb_realloc(mrb, mrb->symflags, symcapa/8+1); memset(mrb->symflags+mrb->symcapa/8+1, 0, (symcapa-mrb->symcapa)/8); mrb->symlink = (uint8_t*)mrb_realloc(mrb, mrb->symlink, symcapa); @@ -229,7 +229,7 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit) mrb->symtbl[sym] = name; } else { - int ilen = mrb_packed_int_len(len); + size_t ilen = mrb_packed_int_len(len); char *p = (char *)mrb_malloc(mrb, len+ilen+1); mrb_packed_int_encode(len, (uint8_t*)p, (uint8_t*)p+ilen); memcpy(p+ilen, name, len); @@ -373,9 +373,9 @@ mrb_free_symtbl(mrb_state *mrb) mrb_free(mrb, (char*)mrb->symtbl[i]); } } - mrb_free(mrb, mrb->symtbl); - mrb_free(mrb, mrb->symlink); - mrb_free(mrb, mrb->symflags); + mrb_free(mrb, (void*)mrb->symtbl); + mrb_free(mrb, (void*)mrb->symlink); + mrb_free(mrb, (void*)mrb->symflags); } void From d20ee7298a8154f60b4278d1d480b36d66e03054 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 25 Apr 2022 14:08:22 +0000 Subject: [PATCH 267/292] build(deps): bump github/codeql-action from 1 to 2 Bumps [github/codeql-action](https://github.com/github/codeql-action) from 1 to 2. - [Release notes](https://github.com/github/codeql-action/releases) - [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/github/codeql-action/compare/v1...v2) --- updated-dependencies: - dependency-name: github/codeql-action dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/codeql-analysis.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index a6fb5d425..0f01e0c28 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -21,7 +21,7 @@ jobs: # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@v1 + uses: github/codeql-action/init@v2 # Override language selection by uncommenting this and choosing your languages # with: # languages: go, javascript, csharp, python, cpp, java @@ -29,7 +29,7 @@ jobs: # Autobuild attempts to build any compiled languages (C/C++, C#, or Java). # If this step fails, then you should remove it and run the build manually (see below) - name: Autobuild - uses: github/codeql-action/autobuild@v1 + uses: github/codeql-action/autobuild@v2 # ℹī¸ Command-line programs to run using the OS shell. # 📚 https://git.io/JvXDl @@ -43,4 +43,4 @@ jobs: # make release - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@v1 + uses: github/codeql-action/analyze@v2 From 68ce42488998c2863eb2bf89ae3cc5302b724dcb Mon Sep 17 00:00:00 2001 From: John Bampton Date: Tue, 26 Apr 2022 00:45:36 +1000 Subject: [PATCH 268/292] Avoid triggering CodeQL on the "push" event for Dependabot branches --- .github/workflows/codeql-analysis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index a6fb5d425..1269c4107 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -2,6 +2,7 @@ name: "Code scanning - action" on: push: + branches-ignore: "dependabot/**" pull_request: schedule: - cron: '0 19 * * 4' From c391d94da91b67b19b78caa045491cd0b511c7e3 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Tue, 26 Apr 2022 13:48:05 +1000 Subject: [PATCH 269/292] docs: fix grammar and spelling --- doc/guides/gc-arena-howto.md | 8 ++++---- doc/guides/mrbgems.md | 2 +- doc/mruby3.0.md | 4 ++-- doc/mruby3.1.md | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/guides/gc-arena-howto.md b/doc/guides/gc-arena-howto.md index 2c1cdc1fb..1fff624df 100644 --- a/doc/guides/gc-arena-howto.md +++ b/doc/guides/gc-arena-howto.md @@ -14,7 +14,7 @@ GC (garbage collector) must ensure that object is "alive", in other words, that it is referenced by somewhere from the program. This can be determined by checking if the object can be directly or indirectly referenced by root. The local variables, global variables and -constants etc are root. +constants etc. are root. If program execution is performed inside mruby VM, there is nothing to worry about because GC can access all roots owned by the VM. @@ -29,7 +29,7 @@ This can be a fatal bug if the GC tries to collect a live object. In CRuby, we scan C stack area, and use C variable as root to check whether object is alive or not. Of course, because we are accessing C stack just as memory region, we never know it is an integer or a -pointer. We workaround this by assuming that if it looks like a +pointer. We work around this by assuming that if it looks like a pointer, then assume it as a pointer. We call it "conservative". By the way, CRuby's "conservative GC" has some problems. @@ -65,14 +65,14 @@ objects (See `MRB_GC_FIXED_ARENA` and `MRB_GC_ARENA_SIZE` in doc/guides/mrbconf.md). If you create many objects in C functions, memory usage will increase, since -GC never kick in. This memory usage may look like memory leak, but will also +GC never kicks in. This memory usage may look like memory leaks, but will also make execution slower as more memory will need to be allocated. With the build time configuration, you can limit the maximum size of arena (e.g., 100). Then if you create many objects, arena overflows, thus you will get an "arena overflow error". -To workaround these problems, we have `mrb_gc_arena_save()` and +To work around these problems, we have `mrb_gc_arena_save()` and `mrb_gc_arena_restore()` functions. `int mrb_gc_arena_save(mrb)` returns the current position of the stack diff --git a/doc/guides/mrbgems.md b/doc/guides/mrbgems.md index 68d0560c2..9cd28c5fa 100644 --- a/doc/guides/mrbgems.md +++ b/doc/guides/mrbgems.md @@ -111,7 +111,7 @@ conf.gembox 'custom' This will cause the `custom` GemBox to be read in during the build process, adding `mruby-time` and `mrbgems-example` to the build. -If you want, you can put GemBox outside of mruby directory. In that case you must +If you want, you can put GemBox outside the mruby directory. In that case you must specify an absolute path like below. ```ruby diff --git a/doc/mruby3.0.md b/doc/mruby3.0.md index 09d2c4af9..359d82c7b 100644 --- a/doc/mruby3.0.md +++ b/doc/mruby3.0.md @@ -75,7 +75,7 @@ to be default `mrb_value` representation. Now the default is ## `MRB_WORD_BOXING` Pack `mrb_value` in an `intptr_t` integer. Consumes less -memory compared to `MRB_NO_BOXING` especially on 32 bit +memory compared to `MRB_NO_BOXING` especially on 32-bit platforms. `Fixnum` size is 31 bits so some integer values does not fit in `Fixnum` integers. @@ -116,7 +116,7 @@ Instructions that access pool[i]/syms[i] where i>255. * `OP_STRING16` * `OP_LOADSYM16` -Instructions that load a 32 bit integer. +Instructions that load a 32-bit integer. * `OP_LOADI32` diff --git a/doc/mruby3.1.md b/doc/mruby3.1.md index 5588ae24d..c99bdc542 100644 --- a/doc/mruby3.1.md +++ b/doc/mruby3.1.md @@ -119,7 +119,7 @@ If the size of `mrb_float` and `mrb_int` are same, the last 2 bits in the `mrb_f Previous NaN boxing packs values in NaN representation, but pointer retrievals are far more frequent than floating point number references. So we add constant offset to NaN representation to clear higher bits of pointer representation. This representation is called "Favor Pointer" NaN Boxing. -Also, previous NaN boxing limit the size of `mrb_int` to 4 bytes (32 bits) to fit in NaN values. Now we allocates integer values in the heap, if the value does not fit in the 32 bit range, just like we did in Word Boxing. +Also, previous NaN boxing limit the size of `mrb_int` to 4 bytes (32 bits) to fit in NaN values. Now we allocate integer values in the heap, if the value does not fit in the 32 bit range, just like we did in Word Boxing. ## Constant Folding From c4bfbb20791cda524db7bcb692d28cc8bbc93849 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Tue, 26 Apr 2022 15:46:20 +1000 Subject: [PATCH 270/292] Update minimum `pre-commit` version to latest `2.18.1` Conda, Homebrew and PyPI all have `2.18.1` https://github.com/pre-commit/pre-commit/releases https://pypi.org/project/pre-commit/#history https://formulae.brew.sh/formula/pre-commit https://anaconda.org/conda-forge/pre-commit Also run `pre-commit autoupdate` https://pre-commit.com/#pre-commit-autoupdate --- .pre-commit-config.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index f91ef3e90..d7c3cb36d 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,14 +3,14 @@ default_stages: [commit, push] default_language_version: # force all unspecified Python hooks to run python3 python: python3 -minimum_pre_commit_version: "1.20.0" +minimum_pre_commit_version: '2.18.1' repos: - repo: meta hooks: - id: identity - id: check-hooks-apply - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v4.1.0 + rev: v4.2.0 hooks: - id: check-added-large-files - id: check-case-conflict From 132d55c924fc9113186d746144f3c181bebda23f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 27 Apr 2022 12:52:51 +0900 Subject: [PATCH 271/292] symbol.c: fix `size_t` and `uint32_t` mixture. --- src/symbol.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/symbol.c b/src/symbol.c index e42a6b0a1..429074532 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -229,9 +229,10 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit) mrb->symtbl[sym] = name; } else { - size_t ilen = mrb_packed_int_len(len); + uint32_t ulen = (uint32_t)len; + size_t ilen = mrb_packed_int_len(ulen); char *p = (char *)mrb_malloc(mrb, len+ilen+1); - mrb_packed_int_encode(len, (uint8_t*)p, (uint8_t*)p+ilen); + mrb_packed_int_encode(ulen, (uint8_t*)p, (uint8_t*)p+ilen); memcpy(p+ilen, name, len); p[ilen+len] = 0; mrb->symtbl[sym] = p; From 6499efb8dd2ce10b92b51a8c90d7db12f9ba0eb9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 27 Apr 2022 13:01:30 +0900 Subject: [PATCH 272/292] fmt_fp.c: add type cast to remove a warning. --- src/fmt_fp.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/fmt_fp.c b/src/fmt_fp.c index 9249baa08..32b793674 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -103,7 +103,7 @@ mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, ch } else if (sign) { *s++ = sign; } - buf_remaining -= (s - buf); // Adjust for sign + buf_remaining -= (int)(s - buf); // Adjust for sign { char uc = fmt & 0x20; From 32fb8b19aa6ba81359d01a53cb889013953a5180 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 28 Apr 2022 14:22:11 +0900 Subject: [PATCH 273/292] class.c: fix integer size mixtures (int, mrb_ssize and mrb_int). --- src/class.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/class.c b/src/class.c index 2a3873eb1..2331b53f2 100644 --- a/src/class.c +++ b/src/class.c @@ -933,10 +933,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) { const char *fmt = format; char c; - int i = 0; + mrb_int i = 0; va_list ap; mrb_callinfo *ci = mrb->c->ci; - mrb_ssize argc = ci->n; + mrb_int argc = ci->n; const mrb_value *argv = ci->stack+1; mrb_bool argv_on_stack; mrb_bool opt = FALSE; @@ -944,7 +944,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) const mrb_value *pickarg = NULL; /* arguments currently being processed */ mrb_value kdict = mrb_nil_value(); mrb_bool reqkarg = FALSE; - mrb_ssize argc_min = 0, argc_max = 0; + int argc_min = 0, argc_max = 0; va_start(ap, format); From 49f3a028d12e18f2431248e3b27c5c3383a8475b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 29 Apr 2022 16:52:34 +0900 Subject: [PATCH 274/292] AUTHORS: update entries [ci skip] --- AUTHORS | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/AUTHORS b/AUTHORS index e6ed326d6..6ba888947 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,11 +1,11 @@ # Authors of mruby (mruby developers) -## The List of Contributors sorted by number of commits (as of 2022-03-27 bb5f6a8) +## The List of Contributors sorted by number of commits (as of 2022-04-28 32fb8b1) - 8121 Yukihiro "Matz" Matsumoto (@matz)* + 8214 Yukihiro "Matz" Matsumoto (@matz)* 586 KOBAYASHI Shuji (@shuujii) 376 Daniel Bovensiepen (@bovi) - 363 dearblue (@dearblue)* + 372 dearblue (@dearblue)* 346 Takeshi Watanabe (@take-cheeze)* 334 Masaki Muranaka (@monaka) 308 Tomoyuki Sahara (@tsahara)* @@ -22,10 +22,10 @@ 68 Hiroshi Mimaki (@mimaki)* 67 Akira Yumiyama (@akiray03)* 62 Paolo Bosetti (@pbosetti)* + 60 John Bampton (@jbampton) 59 Kurebayashi, Takahiro (@crimsonwoods)* 56 h2so5 (@h2so5) 52 Ralph Desir (@Mav7)* - 51 John Bampton (@jbampton) 45 Rory O'Connell (@RoryO)* 43 Yuichiro Kaneko (@yui-knk)+ 42 fleuria (@flaneur2020) From a243cf4d68fdd5de1e821c4ed844b8f38b4b0c69 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 30 Apr 2022 16:51:38 +0900 Subject: [PATCH 275/292] codedump.c: adjust integer size. * uint32_t and ptrdiff_t * uint16_t and uint8_t --- src/codedump.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/codedump.c b/src/codedump.c index 074eb0622..90ef6834f 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -43,11 +43,12 @@ print_lv_ab(mrb_state *mrb, const mrb_irep *irep, uint16_t a, uint16_t b) } static void -print_header(mrb_state *mrb, const mrb_irep *irep, uint32_t i) +print_header(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t i) { int32_t line; - line = mrb_debug_get_line(mrb, irep, i); + mrb_assert(i <= UINT32_MAX); + line = mrb_debug_get_line(mrb, irep, (uint32_t)i); if (line < 0) { printf(" "); } @@ -59,8 +60,9 @@ print_header(mrb_state *mrb, const mrb_irep *irep, uint32_t i) } static void -print_args(uint8_t i) +print_args(uint16_t i) { + mrb_assert(i <= 255); uint8_t n = i&0xf; uint8_t nk = (i>>4)&0xf; @@ -153,7 +155,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) printf("file: %s\n", next_file); file = next_file; } - print_header(mrb, irep, (uint32_t)i); + print_header(mrb, irep, i); ins = READ_B(); switch (ins) { CASE(OP_NOP, Z): From 23ce122fc2b1d29ee7241813bbab1c7e150e23ae Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 2 May 2022 18:59:38 +0900 Subject: [PATCH 276/292] vm.c (mrb_funcall_with_block): copy argv before prepare_missing(); fix #5704 Since prepare_missing() may call `missing` method internally. --- src/vm.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/vm.c b/src/vm.c index e5eaf5ed7..bff02877a 100644 --- a/src/vm.c +++ b/src/vm.c @@ -527,8 +527,14 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc mrb_stack_extend(mrb, n + argc + 3); if (argc >= 15) { ci->stack[n+1] = mrb_ary_new_from_values(mrb, argc, argv); + ci->stack[n+2] = blk; argc = 15; } + else { + if (argc > 0) + stack_copy(ci->stack+n+1, argv, argc); + ci->stack[n+argc+1] = blk; + } if (MRB_METHOD_UNDEF_P(m)) { uint16_t ac = (uint16_t)argc; m = prepare_missing(mrb, self, mid, &c, (uint32_t)n, &ac, mrb_nil_value(), 0); @@ -548,14 +554,6 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc argv = mrb->c->stbase + voff; } ci->stack[0] = self; - if (argc < 15) { - if (argc > 0) - stack_copy(ci->stack+1, argv, argc); - ci->stack[argc+1] = blk; - } - else { - ci->stack[2] = blk; - } if (MRB_METHOD_CFUNC_P(m)) { ci->cci = CINFO_DIRECT; From 9b9424fe3276811c805a09bc7948fd6958265563 Mon Sep 17 00:00:00 2001 From: dearblue Date: Mon, 2 May 2022 14:28:27 +0900 Subject: [PATCH 277/292] Strict acquisition of the `Random` class given by `mrb_get_args()` This is to prevent data corruption of the substituted `Random` instance. If the `Object::Random` constants are redefined to a different `MRB_TT_ISTRUCT` object class, they can pass `mrb_get_args()` validation. The following is an example of how the `Array#shuffle` method rewrites the data of a non `Random` instance. ```c // code.c #include #include #include #include #define EVAL_LIT(MRB, ...) mrb_load_string((MRB), #__VA_ARGS__) static mrb_value fake_initialize(mrb_state *mrb, mrb_value self) { char *p = ISTRUCT_PTR(self); for (int i = 0; i < ISTRUCT_DATA_SIZE; i++) { p[i] = 'A' + i; } return self; } static mrb_value fake_to_bytes(mrb_state *mrb, mrb_value self) { const char *p = ISTRUCT_PTR(self); return mrb_str_new(mrb, p, ISTRUCT_DATA_SIZE); } int main(int argc, char *argv[]) { mrb_state *mrb = mrb_open(); struct RClass *fake = mrb_define_class(mrb, "Fake", mrb->object_class); MRB_SET_INSTANCE_TT(fake, MRB_TT_ISTRUCT); mrb_define_method(mrb, fake, "initialize", fake_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, fake, "to_bytes", fake_to_bytes, MRB_ARGS_NONE()); EVAL_LIT(mrb, Random = Fake \n fake = Fake.new \n p [fake, fake.to_bytes] \n p a = (1..10).to_a \n p a.shuffle(fake) \n p [fake, fake.to_bytes] ); mrb_close(mrb); return 0; } ``` ```console % `bin/mruby-config --cc --cflags --ldflags` code.c `bin/mruby-config --libs` % ./a.out [#, "ABCDEFGHIJKLMNOPQRSTUVWX"] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [1, 7, 8, 10, 2, 6, 9, 3, 4, 5] [#, "\xe81{\v\fM\xb0D<\x99\xb1V+l\x84\x86QRSTUVWX"] ``` --- mrbgems/mruby-random/src/random.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index ae917d33e..fc99e334f 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -167,6 +167,7 @@ random_default(mrb_state *mrb) { #define random_ptr(v) (rand_state*)mrb_istruct_ptr(v) #define random_default_state(mrb) random_ptr(random_default(mrb)) +#define ID_RANDOM_STRICT MRB_SYM(mruby_Random) static mrb_value random_m_init(mrb_state *mrb, mrb_value self) @@ -245,7 +246,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary) rand_state *random; if (RARRAY_LEN(ary) > 1) { - struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random)); + struct RClass *c = mrb_class_get_id(mrb, ID_RANDOM_STRICT); if (mrb_get_args(mrb, "|I", &random, c) == 0) { random = random_default_state(mrb); } @@ -305,7 +306,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary) mrb_bool given; rand_state *random; mrb_int len; - struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random)); + struct RClass *c = mrb_class_get_id(mrb, ID_RANDOM_STRICT); if (mrb_get_args(mrb, "|i?I", &n, &given, &random, c) < 2) { random = random_default_state(mrb); @@ -386,6 +387,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb) mrb_define_method(mrb, mrb->kernel_module, "srand", random_f_srand, MRB_ARGS_OPT(1)); random = mrb_define_class(mrb, "Random", mrb->object_class); + mrb_const_set(mrb, mrb_obj_value(mrb->object_class), ID_RANDOM_STRICT, mrb_obj_value(random)); // for mrb_get_args() MRB_SET_INSTANCE_TT(random, MRB_TT_ISTRUCT); mrb_define_class_method(mrb, random, "rand", random_f_rand, MRB_ARGS_OPT(1)); mrb_define_class_method(mrb, random, "srand", random_f_srand, MRB_ARGS_OPT(1)); From 50b1ded35088ff836367a99063635774bf866822 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 4 May 2022 08:03:44 +0900 Subject: [PATCH 278/292] mruby-random/random.c: use rand_i() extensively. --- mrbgems/mruby-random/src/random.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index fc99e334f..f0e01c43c 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -137,7 +137,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_int max) } static mrb_int -random_rand_i(mrb_state *mrb, rand_state *t, mrb_int max) +rand_i(rand_state *t, mrb_int max) { return rand_uint32(t) % max; } @@ -257,7 +257,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary) mrb_value *ptr = RARRAY_PTR(ary); mrb_value tmp; - j = random_rand_i(mrb, random, max); + j = rand_i(random, max); tmp = ptr[i]; ptr[i] = ptr[j]; @@ -319,7 +319,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary) case 1: return RARRAY_PTR(ary)[0]; default: - return RARRAY_PTR(ary)[rand_uint32(random) % len]; + return RARRAY_PTR(ary)[rand_i(random, len)]; } } else { @@ -334,7 +334,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary) for (;;) { retry: - r = (mrb_int)(rand_uint32(random) % len); + r = rand_i(random, len); for (j=0; j Date: Wed, 4 May 2022 09:13:56 +0900 Subject: [PATCH 279/292] Introduce `mrb_stack_extend_adjust()` If necessary, adjust the pointer on the VM stack after `mrb_stack_extend()`. --- src/vm.c | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/src/vm.c b/src/vm.c index bff02877a..b04c9d7e5 100644 --- a/src/vm.c +++ b/src/vm.c @@ -202,6 +202,21 @@ mrb_stack_extend(mrb_state *mrb, mrb_int room) } } +static void +mrb_stack_extend_adjust(mrb_state *mrb, mrb_int room, const mrb_value **argp) +{ + const struct mrb_context *c = mrb->c; + ptrdiff_t voff = *argp - c->stbase; + + if (voff < 0 || voff >= c->stend - c->stbase) { + mrb_stack_extend(mrb, room); + } + else { + mrb_stack_extend(mrb, room); + *argp = c->stbase + voff; + } +} + static inline struct REnv* uvenv(mrb_state *mrb, mrb_int up) { @@ -508,7 +523,6 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc struct RClass *c; mrb_callinfo *ci = mrb->c->ci; mrb_int n = mrb_ci_nregs(ci); - ptrdiff_t voff = -1; if (!mrb->c->stbase) { stack_init(mrb); @@ -516,15 +530,12 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc if (ci - mrb->c->cibase > MRB_CALL_LEVEL_MAX) { mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err)); } - if (mrb->c->stbase <= argv && argv < mrb->c->stend) { - voff = argv - mrb->c->stbase; - } if (argc < 0) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%i)", argc); } c = mrb_class(mrb, self); m = mrb_method_search_vm(mrb, &c, mid); - mrb_stack_extend(mrb, n + argc + 3); + mrb_stack_extend_adjust(mrb, n + argc + 3, &argv); if (argc >= 15) { ci->stack[n+1] = mrb_ary_new_from_values(mrb, argc, argv); ci->stack[n+2] = blk; @@ -550,9 +561,6 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc mrb_stack_extend(mrb, p->body.irep->nregs + argc); } } - if (voff >= 0) { - argv = mrb->c->stbase + voff; - } ci->stack[0] = self; if (MRB_METHOD_CFUNC_P(m)) { @@ -858,7 +866,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value ci->n = (uint8_t)argc; n = argc + 2; } - mrb_stack_extend(mrb, n); + mrb_stack_extend_adjust(mrb, n, &argv); mrb->c->ci->stack[0] = self; if (ci->n == 15) { mrb->c->ci->stack[1] = mrb_ary_new_from_values(mrb, argc, argv); @@ -906,7 +914,7 @@ mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const p = mrb_proc_ptr(b); ci = mrb->c->ci; - mrb_stack_extend(mrb, 4); + mrb_stack_extend_adjust(mrb, 4, &argv); mrb->c->ci->stack[1] = mrb_ary_new_from_values(mrb, argc, argv); mrb->c->ci->stack[2] = mrb_nil_value(); mrb->c->ci->stack[3] = mrb_nil_value(); From c3e4ee0bf292d9e48eaa5646410b1d424efc557b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 6 May 2022 16:21:39 +0900 Subject: [PATCH 280/292] error.c: store error message converted as a string. This is controversial since this change alters the `raise` behavior. Previously, when an object that cannot be converted to a string, it just ignore message when it's printed (using `Exception#inspect`). But after this change, `raise` (more precisly `Exception.new`) raises TypeError exception. I think the new behavior is clearer, more intuitive. --- src/error.c | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/src/error.c b/src/error.c index 916109cb1..0fb951390 100644 --- a/src/error.c +++ b/src/error.c @@ -21,26 +21,18 @@ void mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg) { - if (!mrb_immediate_p(mesg)) { - exc->mesg = mrb_obj_ptr(mesg); - mrb_field_write_barrier_value(mrb, (struct RBasic*)exc, mesg); - mrb_iv_remove(mrb, mrb_obj_value(exc), MRB_SYM(mesg)); - } - else { - exc->mesg = NULL; - mrb_obj_iv_set(mrb, (struct RObject*)exc, MRB_SYM(mesg), mesg); + if (!mrb_string_p(mesg)) { + mesg = mrb_obj_as_string(mrb, mesg); } + exc->mesg = mrb_obj_ptr(mesg); + mrb_field_write_barrier_value(mrb, (struct RBasic*)exc, mesg); } mrb_value mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc) { - if (exc->mesg) { - return mrb_obj_value(exc->mesg); - } - else { - return mrb_obj_iv_get(mrb, (struct RObject*)exc, MRB_SYM(mesg)); - } + if (exc->mesg == NULL) return mrb_nil_value(); + return mrb_obj_value(exc->mesg); } MRB_API mrb_value From 38b69b6014779875bb69498ad5e1235507ec16c9 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 6 May 2022 16:26:31 +0900 Subject: [PATCH 281/292] error.c: protect `mrb_print_error()` from exceptions. Now the function can be called when `mrb->jmp` is not set. --- src/error.c | 20 ++++++++++++++++++++ src/print.c | 11 ----------- 2 files changed, 20 insertions(+), 11 deletions(-) diff --git a/src/error.c b/src/error.c index 0fb951390..40abc2a84 100644 --- a/src/error.c +++ b/src/error.c @@ -630,6 +630,26 @@ mrb_raise_nomemory(mrb_state *mrb) } } +MRB_API void +mrb_print_error(mrb_state *mrb) +{ +#ifndef MRB_NO_STDIO + if (mrb->jmp == NULL) { + struct mrb_jmpbuf c_jmp; + MRB_TRY(&c_jmp) { + mrb->jmp = &c_jmp; + mrb_print_backtrace(mrb); + } MRB_CATCH(&c_jmp) { + /* ignore exception during print_backtrace() */ + } MRB_END_EXC(&c_jmp); + mrb->jmp = NULL; + } + else { + mrb_print_backtrace(mrb); + } +#endif +} + void mrb_init_exception(mrb_state *mrb) { diff --git a/src/print.c b/src/print.c index 4af871b43..c6cb6464e 100644 --- a/src/print.c +++ b/src/print.c @@ -49,12 +49,6 @@ mrb_p(mrb_state *mrb, mrb_value obj) } -MRB_API void -mrb_print_error(mrb_state *mrb) -{ - mrb_print_backtrace(mrb); -} - MRB_API void mrb_show_version(mrb_state *mrb) { @@ -78,11 +72,6 @@ mrb_p(mrb_state *mrb, mrb_value obj) { } -MRB_API void -mrb_print_error(mrb_state *mrb) -{ -} - MRB_API void mrb_show_version(mrb_state *mrb) { From 457abf4c9ef91f0f888791c67598218091b55d8b Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 6 May 2022 16:45:17 +0900 Subject: [PATCH 282/292] error.c: now `mrb_exc_mesg_get()` returns a string or nil. --- src/error.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/error.c b/src/error.c index 40abc2a84..8773f1347 100644 --- a/src/error.c +++ b/src/error.c @@ -137,10 +137,9 @@ exc_to_s(mrb_state *mrb, mrb_value exc) mrb_value mrb_exc_inspect(mrb_state *mrb, mrb_value exc) { - mrb_value mesg = mrb_exc_mesg_get(mrb, mrb_exc_ptr(exc)); mrb_value cname = mrb_mod_to_s(mrb, mrb_obj_value(mrb_obj_class(mrb, exc))); - mesg = mrb_obj_as_string(mrb, mesg); - return RSTRING_LEN(mesg) == 0 ? cname : mrb_format(mrb, "%v (%v)", mesg, cname); + mrb_value mesg = mrb_exc_mesg_get(mrb, mrb_exc_ptr(exc)); /* string or nil */ + return (mrb_nil_p(mesg)||RSTRING_LEN(mesg)==0) ? cname : mrb_format(mrb, "%v (%v)", mesg, cname); } void mrb_keep_backtrace(mrb_state *mrb, mrb_value exc); From 45f61e38796c6097cd35db3410fcdc20379d167d Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sat, 7 May 2022 17:34:17 +0900 Subject: [PATCH 283/292] class.c (mrb_get_args): remove `I` specifier (istruct); close #5706 --- mrbgems/mruby-random/src/random.c | 25 +++++++++++++++---- .../mruby-test-inline-struct/test/inline.c | 11 +++++--- src/class.c | 24 ------------------ 3 files changed, 28 insertions(+), 32 deletions(-) diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index f0e01c43c..bd126a93d 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -242,14 +242,22 @@ random_m_bytes(mrb_state *mrb, mrb_value self) static mrb_value mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary) { - mrb_int i, max; - rand_state *random; if (RARRAY_LEN(ary) > 1) { + mrb_int i, max; + mrb_value r; + rand_state *random; + struct RClass *c = mrb_class_get_id(mrb, ID_RANDOM_STRICT); - if (mrb_get_args(mrb, "|I", &random, c) == 0) { + if (mrb_get_args(mrb, "|o", &r) == 0) { random = random_default_state(mrb); } + else if (mrb_obj_is_kind_of(mrb, r, c)){ + random = (rand_state*)mrb_istruct_ptr(r); + } + else { + mrb_raise(mrb, E_TYPE_ERROR, "Random object required"); + } mrb_ary_modify(mrb, mrb_ary_ptr(ary)); max = RARRAY_LEN(ary); for (i = RARRAY_LEN(ary) - 1; i > 0; i--) { @@ -304,13 +312,20 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary) { mrb_int n = 0; mrb_bool given; + mrb_value r; rand_state *random; mrb_int len; struct RClass *c = mrb_class_get_id(mrb, ID_RANDOM_STRICT); - if (mrb_get_args(mrb, "|i?I", &n, &given, &random, c) < 2) { + if (mrb_get_args(mrb, "|i?o", &n, &given, &r) < 2) { random = random_default_state(mrb); } + else if (mrb_obj_is_kind_of(mrb, r, c)){ + random = (rand_state*)mrb_istruct_ptr(r); + } + else { + mrb_raise(mrb, E_TYPE_ERROR, "Random object required"); + } len = RARRAY_LEN(ary); if (!given) { /* pick one element */ switch (len) { @@ -387,7 +402,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb) mrb_define_method(mrb, mrb->kernel_module, "srand", random_f_srand, MRB_ARGS_OPT(1)); random = mrb_define_class(mrb, "Random", mrb->object_class); - mrb_const_set(mrb, mrb_obj_value(mrb->object_class), ID_RANDOM_STRICT, mrb_obj_value(random)); // for mrb_get_args() + mrb_const_set(mrb, mrb_obj_value(mrb->object_class), ID_RANDOM_STRICT, mrb_obj_value(random)); // for class check MRB_SET_INSTANCE_TT(random, MRB_TT_ISTRUCT); mrb_define_class_method(mrb, random, "rand", random_f_rand, MRB_ARGS_OPT(1)); mrb_define_class_method(mrb, random, "srand", random_f_srand, MRB_ARGS_OPT(1)); diff --git a/mrbgems/mruby-test-inline-struct/test/inline.c b/mrbgems/mruby-test-inline-struct/test/inline.c index 7537bffc6..a0058554f 100644 --- a/mrbgems/mruby-test-inline-struct/test/inline.c +++ b/mrbgems/mruby-test-inline-struct/test/inline.c @@ -56,10 +56,15 @@ istruct_test_test_receive(mrb_state *mrb, mrb_value self) static mrb_value istruct_test_test_receive_direct(mrb_state *mrb, mrb_value self) { - char *ptr; + mrb_value is; struct RClass *klass = mrb_class_get(mrb, "InlineStructTest"); - mrb_get_args(mrb, "I", &ptr, klass); - return mrb_bool_value(ptr[0] == 's'); + mrb_get_args(mrb, "o", &is); + if (mrb_obj_is_kind_of(mrb, is, klass)) { + char *ptr = mrb_istruct_ptr(is);; + return mrb_bool_value(ptr[0] == 's'); + } + mrb_raise(mrb, E_TYPE_ERROR, "InlineStructTest"); + return mrb_false_value(); } static mrb_value diff --git a/src/class.c b/src/class.c index 2331b53f2..3c2033251 100644 --- a/src/class.c +++ b/src/class.c @@ -914,7 +914,6 @@ mrb_block_given_p(mrb_state *mrb) b: boolean [mrb_bool] n: String/Symbol [mrb_sym] d: data [void*,mrb_data_type const] 2nd argument will be used to check data type so it won't be modified; when ! follows, the value may be nil - I: inline struct [void*,struct RClass] I! gives NULL for nil &: block [mrb_value] &! raises exception if no block given *: rest argument [const mrb_value*,mrb_int] The rest of the arguments as an array; *! avoid copy of the stack |: optional Following arguments are optional @@ -1162,29 +1161,6 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } } break; - case 'I': - { - void* *p; - struct RClass *klass; - - p = va_arg(ap, void**); - klass = va_arg(ap, struct RClass*); - if (pickarg) { - if (altmode && mrb_nil_p(*pickarg)) { - *p = NULL; - } - else { - if (!mrb_obj_is_kind_of(mrb, *pickarg, klass)) { - mrb_raisef(mrb, E_TYPE_ERROR, "%v is not a %C", *pickarg, klass); - } - if (!mrb_istruct_p(*pickarg)) { - mrb_raisef(mrb, E_TYPE_ERROR, "%v is not inline struct", *pickarg); - } - *p = mrb_istruct_ptr(*pickarg); - } - } - } - break; #ifndef MRB_NO_FLOAT case 'f': { From 8c2dbb761f1cd450c62611aa845737a0dae95f41 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 8 May 2022 22:59:57 +0900 Subject: [PATCH 284/292] mruby-test-inline-struct/inline.c: add `mrb_istruct_p()` checks. --- mrbgems/mruby-test-inline-struct/test/inline.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-test-inline-struct/test/inline.c b/mrbgems/mruby-test-inline-struct/test/inline.c index a0058554f..2ceac3218 100644 --- a/mrbgems/mruby-test-inline-struct/test/inline.c +++ b/mrbgems/mruby-test-inline-struct/test/inline.c @@ -59,7 +59,7 @@ istruct_test_test_receive_direct(mrb_state *mrb, mrb_value self) mrb_value is; struct RClass *klass = mrb_class_get(mrb, "InlineStructTest"); mrb_get_args(mrb, "o", &is); - if (mrb_obj_is_kind_of(mrb, is, klass)) { + if (mrb_istruct_p(is) && mrb_obj_is_kind_of(mrb, is, klass)) { char *ptr = mrb_istruct_ptr(is);; return mrb_bool_value(ptr[0] == 's'); } From 04d160f90b81ab1ea2390b3fb692c7b3dd1c620f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 8 May 2022 23:12:49 +0900 Subject: [PATCH 285/292] mruby-test-inline-struct/inline.c: add a comment about istruct protection. --- mrbgems/mruby-test-inline-struct/test/inline.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/mrbgems/mruby-test-inline-struct/test/inline.c b/mrbgems/mruby-test-inline-struct/test/inline.c index 2ceac3218..59892327e 100644 --- a/mrbgems/mruby-test-inline-struct/test/inline.c +++ b/mrbgems/mruby-test-inline-struct/test/inline.c @@ -59,6 +59,9 @@ istruct_test_test_receive_direct(mrb_state *mrb, mrb_value self) mrb_value is; struct RClass *klass = mrb_class_get(mrb, "InlineStructTest"); mrb_get_args(mrb, "o", &is); + /* if you need to protect istruct retrieval from untrusted code, + you need to care about class replacing. + See mrbgem/mruby-random/src/random.c for detail */ if (mrb_istruct_p(is) && mrb_obj_is_kind_of(mrb, is, klass)) { char *ptr = mrb_istruct_ptr(is);; return mrb_bool_value(ptr[0] == 's'); From eafc4b3f96b2df56d000ecdb53177795d0d891fa Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 9 May 2022 17:46:26 +0900 Subject: [PATCH 286/292] doc/mruby3.1.md: update for the 3.1 release. --- doc/mruby3.1.md | 151 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 109 insertions(+), 42 deletions(-) diff --git a/doc/mruby3.1.md b/doc/mruby3.1.md index c99bdc542..61c11803c 100644 --- a/doc/mruby3.1.md +++ b/doc/mruby3.1.md @@ -1,48 +1,91 @@ # User visible changes in `mruby3.1` from `mruby3.0` -# Build System +# New Features -## `build_config` directory +## Core Language Features -Several configurations for new platforms are added: +### Keyword Arguments -* `cross-mingw-winetest.rb` -* `cross-mingw.rb` -* `nintendo_switch.rb` -* `serenity.rb` +CRuby3.0 compatible keyword arguments are introduced. +Keyword arguments are basically separated from ordinal arguments. -Some new configurations for added for convenience. +### Other Language Enhancement -* `minimal`: minimal configuration -* `host-f32`: compiles with `mrb_float` as 32 bit `float` -* `host-nofloat`: compiles with no float configuration +- Implement endless-def [Ruby:Feature#16746](https://bugs.ruby-lang.org/issues/16746) +- Replace `R-assignment` by `single-line pattern matching` [Ruby:Feature#15921](https://bugs.ruby-lang.org/issues/15921) +- Support squiggly heredocs. [#5246](https://github.com/mruby/mruby/pull/5246) +- Hash value omission [Ruby:Feature#14579](https://bugs.ruby-lang.org/issues/14579) -And `android_arm64-v8a.rb` was renamed to `android_arm64_v8a.rb` for consistency. - -# Configuration Options Changed +## Configuration Options Changed Some configuration macros are available: -* `MRB_WORDBOX_NO_FLOAT_TRUNCATE`: by default, float values are packed in the word if possible, but define this macro to allocate float values in the heap. -* `MRB_USE_RO_DATA_P_ETEXT`: define this macro if `_etext` is available on your platform. -* `MRB_NO_DEFAULT_RO_DATA_P`: define this macro to avoid using predefined `mrb_ro_data_p()` function +- `MRB_WORDBOX_NO_FLOAT_TRUNCATE`: by default, float values are packed in the word if possible, but define this macro to allocate float values in the heap. +- `MRB_USE_RO_DATA_P_ETEXT`: define this macro if `_etext` is available on your platform. +- `MRB_NO_DEFAULT_RO_DATA_P`: define this macro to avoid using predefined `mrb_ro_data_p()` function -# Language Changes +--- -## Keyword Arguments +# Updated Features -CRuby3.0 compatible keyword arguments are introduced. -Keyword arguments are basically separated from ordinal arguments +## New build configurations -## New Methods +We have added several new build configurations in the `build_config` directory. -* `Array#product` -* `Array#repeated_combination` -* `Array#repeated_permutation` -* `Random.bytes` -* `Random#bytes` +- `cross-mingw-winetest.rb` +- `cross-mingw.rb` +- `nintendo_switch.rb` +- `serenity.rb` +- `minimal`: minimal configuration +- `host-f32`: compiles with `mrb_float` as 32 bit `float` +- `host-nofloat`: compiles with no float configuration +- `android_arm64_v8a.rb`: renamed from `android_arm64-v8a.rb` -# Internal Changes +## Core Libraries + +### New Methods + +- `Array#product` +- `Array#repeated_combination` +- `Array#repeated_permutation` +- `Kernel#__ENCODING__` +- `Random.bytes` +- `Random#bytes` +- `String#center` + +### New Gem Enhancement + +- `mrbgems/mruby-pack` now supports `M` directive (Q encoding) +- `mrbgems/mruby-pack` now supports `X` directive (back-up by bytes) +- `mrbgems/mruby-pack` now supports `@` directive (absolute position) +- `mrbgems/mruby-pack` now supports `w` directive (BER compression) + +## Tools + +- `mruby-config` now supports `--cc` and `--ld` options. +- Remove `OP_` prefix from `mruby -v` code dump output. +- Prohibit use of `OP_EXT{1,2,3}` by `mrbc` with `--no-ext-ops` option. + +## Features for mruby Developer + +- Add new specifier `c` to `mrb_get_args()` for receive Class/Module. + +--- + +# Breaking Changes + +## Incompatibly Changed Methods + +- `Kernel#printf` (`mruby-sprintf`) Format specifiers `%a` and `%A` are removed. +- `Kernel#puts` (`mruby-print`) Now expand Array arguments. + +## mruby VM and bytecode + +Due to improvements in the binary format, mruby binaries are no longer backward compatible. +To run the mruby binaries on mruby 3.1, recompile with the mruby 3.1 `mrbc`. + +- Upgrade mruby VM version `RITE_VM_VER` to `0300` (means mruby 3.0 or after). +- Upgrade mruby binary version `RITE_BINARY_FORMAT_VER` to `0300`. ## Reintroduced Instructions @@ -53,18 +96,18 @@ Keyword arguments are basically separated from ordinal arguments `mruby3.1` removed following instructions. -* `OP_LOADL16` -* `OP_LOADSYM16` -* `OP_STRING16` -* `OP_LAMBDA16` -* `OP_BLOCK16` -* `OP_METHOD16` -* `OP_EXEC16` +- `OP_LOADL16` +- `OP_LOADSYM16` +- `OP_STRING16` +- `OP_LAMBDA16` +- `OP_BLOCK16` +- `OP_METHOD16` +- `OP_EXEC16` Those instructions are no longer needed by reintroduction of extension instructions. -* `OP_SENDV` -* `OP_SENDVB` +- `OP_SENDV` +- `OP_SENDVB` Those instructions for method calls with variable number of arguments are no longer needed. They are covered by `OP_SEND` instruction with `n=15`. @@ -72,11 +115,11 @@ Those instructions for method calls with variable number of arguments are no lon `mruby3.1` introduces following new instructions. -* `OP_GETIDX`: takes 1 operands `R[a][a+1]` -* `OP_SETIDX`: takes 1 operands `R[a][a+1]=R[a+2]` -* `OP_SSEND`: takes 3 operands `a=self.b(c...)`; see `OP_SEND` -* `OP_SSENDB`: takes 3 operands `a=self.b(c...){...}`; see `OP_SEND` -* `OP_SYMBOL`: takes 2 operands `R[a] = intern(Pool[b])` +- `OP_GETIDX`: takes 1 operands `R[a][a+1]` +- `OP_SETIDX`: takes 1 operands `R[a][a+1]=R[a+2]` +- `OP_SSEND`: takes 3 operands `a=self.b(c...)`; see `OP_SEND` +- `OP_SSENDB`: takes 3 operands `a=self.b(c...){...}`; see `OP_SEND` +- `OP_SYMBOL`: takes 2 operands `R[a] = intern(Pool[b])` ### `OP_GETIDX` and `OP_SETIDX` @@ -151,3 +194,27 @@ GETIV R1 :@foo ## `String#hash` now use `FNV1a` algorithm For better and faster hash values. + +--- + +# Major bug fixes + +- Fix infinite recursive call bugs in integer division [98799aa6](https://github.com/mruby/mruby/commit/98799aa6) +- Fix to raise TypeError with super inside instance_eval / class_eval [#5476](https://github.com/mruby/mruby/pull/5476) +- Fix to call `method_added` hooks on method definitions; [#2339](https://github.com/mruby/mruby/pull/2339) +- Fix a potential buffer overflow in `time_zonename` [26340a88](https://github.com/mruby/mruby/commit/26340a88) +- Fix `Module.instance_eval` bug [#5528](https://github.com/mruby/mruby/pull/5528) +- Fix fix `M` packing bug [bfe2bd49](https://github.com/mruby/mruby/commit/bfe2bd49) +- Fix a bug regarding attribute assignment with kargs [de2b4bd0](https://github.com/mruby/mruby/commit/de2b4bd0) +- Fix SIGSEGV with mrbgems/mruby-method [#5580](https://github.com/mruby/mruby/pull/5580) +- Fix print error before cleanup in `codegen_error()` [#5603](https://github.com/mruby/mruby/pull/5603) +- Fix a bug in unpacking BER [#5611](https://github.com/mruby/mruby/pull/5611) +- Fix a bug with numbered parameters as arguments [#5605](https://github.com/mruby/mruby/pull/5605) +- Fix `mrb_ary_shift_m` initialization bug [27d1e013](https://github.com/mruby/mruby/commit/27d1e013) +- Fix keyword argument with `super` [#5628](https://github.com/mruby/mruby/pull/5628) +- Fix a bug with numbered parameters on toplevel [7e7f1b2f](https://github.com/mruby/mruby/commit/7e7f1b2f) +- Fix keyword argument bug [#5632](https://github.com/mruby/mruby/issues/5632) +- Fix multiple assignments in parameters [#5647](https://github.com/mruby/mruby/issues/5647) +- Fix keyword parameters not passing through super [#5660](https://github.com/mruby/mruby/issues/5660) +- Fix infinite loop from unclosed here-doc [#5676](https://github.com/mruby/mruby/issues/5676) +- Fix negative integer division bug [#5678](https://github.com/mruby/mruby/issues/5678) From fc4e9cdf818c12e422d4a5319305bc05928080af Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 9 May 2022 18:57:26 +0900 Subject: [PATCH 287/292] mruby-test-inline-struct/inline.c: add type cast from `void*` to `char*`. --- mrbgems/mruby-test-inline-struct/test/inline.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrbgems/mruby-test-inline-struct/test/inline.c b/mrbgems/mruby-test-inline-struct/test/inline.c index 59892327e..f3940476b 100644 --- a/mrbgems/mruby-test-inline-struct/test/inline.c +++ b/mrbgems/mruby-test-inline-struct/test/inline.c @@ -63,7 +63,7 @@ istruct_test_test_receive_direct(mrb_state *mrb, mrb_value self) you need to care about class replacing. See mrbgem/mruby-random/src/random.c for detail */ if (mrb_istruct_p(is) && mrb_obj_is_kind_of(mrb, is, klass)) { - char *ptr = mrb_istruct_ptr(is);; + char *ptr = (char*)mrb_istruct_ptr(is);; return mrb_bool_value(ptr[0] == 's'); } mrb_raise(mrb, E_TYPE_ERROR, "InlineStructTest"); From 6189a90933f80c283a106bfcd2b06907e66a0f66 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 10 May 2022 14:02:16 +0900 Subject: [PATCH 288/292] github/workflow: remove Cygwin build from Github Actions. It often cross the 15 minutes timeout limit, so we just give up for now. --- .github/workflows/build.yml | 46 ------------------------------------- 1 file changed, 46 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 8a5f96b88..870efdd24 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -93,52 +93,6 @@ jobs: - name: Build and test run: rake -m test:build && rake test:run - Windows-Cygwin: - runs-on: windows-latest - timeout-minutes: 15 - env: - ACTIONS_ALLOW_UNSECURE_COMMANDS: true - MRUBY_CONFIG: ci/gcc-clang - CC: gcc - installer-path: '%TMP%\cygwin-setup.exe' - cygwin-root: C:\cygwin - package-dir: C:\cygwin-package - cache-version: v1 - steps: - - uses: actions/checkout@v3 - - uses: actions/cache@v3 - with: - path: ${{ env.package-dir }} - key: ${{ runner.os }}-cygwin-${{ env.cache-version }} - - name: Download Cygwin installer - shell: cmd - run: > - bitsadmin /transfer download /priority foreground - https://cygwin.com/setup-x86_64.exe ${{ env.installer-path }} - - name: Install Cygwin - shell: cmd - run: > - ${{ env.installer-path }} - --quiet-mode --no-shortcuts --no-startmenu --no-desktop --no-admin - --only-site --site http://mirrors.kernel.org/sourceware/cygwin/ - --root ${{ env.cygwin-root }} - --local-package-dir ${{ env.package-dir }} - --packages gcc-core,gcc-g++,ruby - - name: Set PATH for Cygwin - run: | - echo '::set-env name=PATH::${{ env.cygwin-root }}\bin;${{ env.cygwin-root }}\usr\bin' - - name: Ruby version - shell: cmd - run: ruby -v - - name: Compiler version - run: ${{ env.CC }} --version - - name: Build and test - shell: cmd - run: ruby /usr/bin/rake -m test:build && ruby /usr/bin/rake test:run - - name: Set PATH for cache archiving (tar) - # set Windows path so that Cygwin tar is not used for cache archiving - run: echo '::set-env name=PATH::C:\windows\System32' - Windows-VC: runs-on: windows-2022 timeout-minutes: 10 From 3ee10ccc63aea2bec8ac2b8c3e1f6b2acd58edad Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 10 May 2022 20:32:04 +0900 Subject: [PATCH 289/292] mruby3.1.md: update fixed CVE list. --- doc/mruby3.1.md | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/doc/mruby3.1.md b/doc/mruby3.1.md index 61c11803c..158b8ea7e 100644 --- a/doc/mruby3.1.md +++ b/doc/mruby3.1.md @@ -218,3 +218,38 @@ For better and faster hash values. - Fix keyword parameters not passing through super [#5660](https://github.com/mruby/mruby/issues/5660) - Fix infinite loop from unclosed here-doc [#5676](https://github.com/mruby/mruby/issues/5676) - Fix negative integer division bug [#5678](https://github.com/mruby/mruby/issues/5678) + +# CVEs + +## Fixed CVEs + +Following CVEs are fixed in this release. + +- [CVE-2021-4110](https://nvd.nist.gov/vuln/detail/CVE-2021-4110) +- [CVE-2021-4188](https://nvd.nist.gov/vuln/detail/CVE-2021-4188) +- [CVE-2022-0080](https://nvd.nist.gov/vuln/detail/CVE-2022-0080) +- [CVE-2022-0240](https://nvd.nist.gov/vuln/detail/CVE-2022-0240) +- [CVE-2022-0326](https://nvd.nist.gov/vuln/detail/CVE-2022-0326) +- [CVE-2022-0481](https://nvd.nist.gov/vuln/detail/CVE-2022-0481) +- [CVE-2022-0631](https://nvd.nist.gov/vuln/detail/CVE-2022-0631) +- [CVE-2022-0632](https://nvd.nist.gov/vuln/detail/CVE-2022-0632) +- [CVE-2022-0890](https://nvd.nist.gov/vuln/detail/CVE-2022-0890) +- [CVE-2022-1071](https://nvd.nist.gov/vuln/detail/CVE-2022-1071) +- [CVE-2022-1106](https://nvd.nist.gov/vuln/detail/CVE-2022-1106) +- [CVE-2022-1201](https://nvd.nist.gov/vuln/detail/CVE-2022-1201) +- [CVE-2022-1427](https://nvd.nist.gov/vuln/detail/CVE-2022-1427) + +## Unaffected CVEs + +Following CVEs do not cause problems in this release. They are fixed in the later release. + +- [CVE-2022-0481](https://nvd.nist.gov/vuln/detail/CVE-2022-0481) +- [CVE-2022-0525](https://nvd.nist.gov/vuln/detail/CVE-2022-0525) +- [CVE-2022-0570](https://nvd.nist.gov/vuln/detail/CVE-2022-0570) +- [CVE-2022-0614](https://nvd.nist.gov/vuln/detail/CVE-2022-0614) +- [CVE-2022-0623](https://nvd.nist.gov/vuln/detail/CVE-2022-0623) +- [CVE-2022-0630](https://nvd.nist.gov/vuln/detail/CVE-2022-0630) +- [CVE-2022-0717](https://nvd.nist.gov/vuln/detail/CVE-2022-0817) +- [CVE-2022-1212](https://nvd.nist.gov/vuln/detail/CVE-2022-1212) +- [CVE-2022-1276](https://nvd.nist.gov/vuln/detail/CVE-2022-1276) +- [CVE-2022-1286](https://nvd.nist.gov/vuln/detail/CVE-2022-1286) From 090303568c879bd81134e6e5436e9df79da5210f Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 11 May 2022 07:08:39 +0900 Subject: [PATCH 290/292] mruby3.2.md: use dash instead of asterisk for itemize. --- doc/mruby3.2.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/doc/mruby3.2.md b/doc/mruby3.2.md index 85c3dea30..9be40d089 100644 --- a/doc/mruby3.2.md +++ b/doc/mruby3.2.md @@ -2,28 +2,28 @@ # The language -* Now `a::B = c` should evaluate `a` then `c`. -* Anonymous arguments `*`, `**`, `&` can be passed for forwarding. -* Multi-precision integer is available now via `mruby-bigint` gem. +- Now `a::B = c` should evaluate `a` then `c`. +- Anonymous arguments `*`, `**`, `&` can be passed for forwarding. +- Multi-precision integer is available now via `mruby-bigint` gem. # Tools ## `mruby` -* `-b` only specifies the script is the binary. The files loaded by `-r` are not affected by the option. -* `mruby` now loads complied binary if the suffix is `.mrb`. +- `-b` only specifies the script is the binary. The files loaded by `-r` are not affected by the option. +- `mruby` now loads complied binary if the suffix is `.mrb`. ## `mrbc` -* Add `--no-optimize` option to disable optimization. +- Add `--no-optimize` option to disable optimization. # mrbgems ## mruby-errno -* `mruby-errno` gem is now bundled. +- `mruby-errno` gem is now bundled. ## mruby-class-ext -* Add `Class#subclasses` method. -* Add `Module#undefined_instance_methods` method. +- Add `Class#subclasses` method. +- Add `Module#undefined_instance_methods` method. From 257d16181d4819618c7cf7b495ff21d6b7533b93 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 11 May 2022 07:09:27 +0900 Subject: [PATCH 291/292] mruby3.2.md: add fixed CVE list. --- doc/mruby3.2.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/doc/mruby3.2.md b/doc/mruby3.2.md index 9be40d089..bbb274e76 100644 --- a/doc/mruby3.2.md +++ b/doc/mruby3.2.md @@ -27,3 +27,18 @@ - Add `Class#subclasses` method. - Add `Module#undefined_instance_methods` method. + +# CVEs + +Following CVEs are fixed. + +- [CVE-2022-0481](https://nvd.nist.gov/vuln/detail/CVE-2022-0481) +- [CVE-2022-0525](https://nvd.nist.gov/vuln/detail/CVE-2022-0525) +- [CVE-2022-0570](https://nvd.nist.gov/vuln/detail/CVE-2022-0570) +- [CVE-2022-0614](https://nvd.nist.gov/vuln/detail/CVE-2022-0614) +- [CVE-2022-0623](https://nvd.nist.gov/vuln/detail/CVE-2022-0623) +- [CVE-2022-0630](https://nvd.nist.gov/vuln/detail/CVE-2022-0630) +- [CVE-2022-0717](https://nvd.nist.gov/vuln/detail/CVE-2022-0817) +- [CVE-2022-1212](https://nvd.nist.gov/vuln/detail/CVE-2022-1212) +- [CVE-2022-1276](https://nvd.nist.gov/vuln/detail/CVE-2022-1276) +- [CVE-2022-1286](https://nvd.nist.gov/vuln/detail/CVE-2022-1286) From 6c6d8a98fa00a7b9e02418db5a64777da74a6032 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 12 May 2022 19:14:40 +0900 Subject: [PATCH 292/292] codedump.c: avoid printing 'local variable names:' header. If there is no local variable defined in `irep`. --- src/codedump.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/codedump.c b/src/codedump.c index 90ef6834f..6abb953fd 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -100,14 +100,17 @@ codedump(mrb_state *mrb, const mrb_irep *irep) if (irep->lv) { int i; + int head = FALSE; - printf("local variable names:\n"); for (i = 1; i < irep->nlocals; ++i) { char const *s = mrb_sym_dump(mrb, irep->lv[i - 1]); if (s) { - printf(" R%d:%s", i, s); + if (!head) { + head = TRUE; + printf("local variable names:\n"); + } + printf(" R%d:%s\n", i, s); } - putchar('\n'); } }